/* Copyright (c) 2004-2008, 2010, Sara Golemon <sarag@libssh2.org> * Copyright (c) 2009-2011 by Daniel Stenberg * Copyright (c) 2010 Simon Josefsson * All rights reserved. * * Redistribution and use in source and binary forms, * with or without modification, are permitted provided * that the following conditions are met: * *   Redistributions of source code must retain the above *   copyright notice, this list of conditions and the *   following disclaimer. * *   Redistributions in binary form must reproduce the above *   copyright notice, this list of conditions and the following *   disclaimer in the documentation and/or other materials *   provided with the distribution. * *   Neither the name of the copyright holder nor the names *   of any other contributors may be used to endorse or *   promote products derived from this software without *   specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY * OF SUCH DAMAGE. */ #ifndef LIBSSH2_PRIV_H#define LIBSSH2_PRIV_H 1 #define LIBSSH2_LIBRARY#include "libssh2_config.h" #ifdef HAVE_WINDOWS_H#ifndef WIN32_LEAN_AND_MEAN#define WIN32_LEAN_AND_MEAN#endif#include <windows.h>#undef WIN32_LEAN_AND_MEAN#endif #ifdef HAVE_WS2TCPIP_H#include <ws2tcpip.h>#endif #include <stdio.h>#include <time.h> /* The following CPP block should really only be in session.c and   packet.c.  However, AIX have #define's for 'events' and 'revents'   and we are using those names in libssh2.h, so we need to include   the AIX headers first, to make sure all code is compiled with   consistent names of these fields.  While arguable the best would to   change libssh2.h to use other names, that would break backwards   compatibility.  For more information, see:   http://www.mail-archive.com/libssh2-devel%40lists.sourceforge.net/msg00003.html   http://www.mail-archive.com/libssh2-devel%40lists.sourceforge.net/msg00224.html*/#ifdef HAVE_POLL# include <sys/poll.h>#else# if defined(HAVE_SELECT) && !defined(WIN32)# ifdef HAVE_SYS_SELECT_H# include <sys/select.h># else# include <sys/time.h># include <sys/types.h># endif# endif#endif /* Needed for struct iovec on some platforms */#ifdef HAVE_SYS_UIO_H#include <sys/uio.h>#endif #ifdef HAVE_SYS_SOCKET_H# include <sys/socket.h>#endif#ifdef HAVE_SYS_IOCTL_H# include <sys/ioctl.h>#endif#ifdef HAVE_INTTYPES_H#include <inttypes.h>#endif #include "libssh2.h"#include "libssh2_publickey.h"#include "libssh2_sftp.h"#include "misc.h" /* for the linked list stuff */ #ifndef FALSE#define FALSE 0#endif#ifndef TRUE#define TRUE 1#endif /* Provide iovec / writev on WIN32 platform. */#ifdef WIN32 struct iovec {    size_t iov_len;    void * iov_base;}; #define inline __inline static inline int writev(int sock, struct iovec *iov, int nvecs){    DWORD ret;    if (WSASend(sock, (LPWSABUF)iov, nvecs, &ret, 0, NULL, NULL) == 0) {        return ret;    }    return -1;} #endif /* WIN32 */ #include "crypto.h" #ifdef HAVE_WINSOCK2_H #include <winsock2.h>#include <mswsock.h>#include <ws2tcpip.h> #ifdef _MSC_VER/* "inline" keyword is valid only with C++ engine! */#define inline __inline#endif #endif /* RFC4253 section 6.1 Maximum Packet Length says: * * "All implementations MUST be able to process packets with * uncompressed payload length of 32768 bytes or less and * total packet size of 35000 bytes or less (including length, * padding length, payload, padding, and MAC.)." */#define MAX_SSH_PACKET_LEN 35000 #define LIBSSH2_ALLOC(session, count) \  session->alloc((count), &(session)->abstract)#define LIBSSH2_REALLOC(session, ptr, count) \ ((ptr) ? session->realloc((ptr), (count), &(session)->abstract) : \ session->alloc((count), &(session)->abstract))#define LIBSSH2_FREE(session, ptr) \ session->free((ptr), &(session)->abstract)#define LIBSSH2_IGNORE(session, data, datalen) \ session->ssh_msg_ignore((session), (data), (datalen), &(session)->abstract)#define LIBSSH2_DEBUG(session, always_display, message, message_len, \                      language, language_len)    \    session->ssh_msg_debug((session), (always_display), (message), \                           (message_len), (language), (language_len), \                           &(session)->abstract)#define LIBSSH2_DISCONNECT(session, reason, message, message_len, \                           language, language_len)                \    session->ssh_msg_disconnect((session), (reason), (message),   \                                (message_len), (language), (language_len), \                                &(session)->abstract) #define LIBSSH2_MACERROR(session, data, datalen)         \    session->macerror((session), (data), (datalen), &(session)->abstract)#define LIBSSH2_X11_OPEN(channel, shost, sport)          \    channel->session->x11(((channel)->session), (channel), \                          (shost), (sport), (&(channel)->session->abstract)) #define LIBSSH2_CHANNEL_CLOSE(session, channel)          \    channel->close_cb((session), &(session)->abstract, \                      (channel), &(channel)->abstract) #define LIBSSH2_SEND_FD(session, fd, buffer, length, flags) \    session->send(fd, buffer, length, flags, &session->abstract)#define LIBSSH2_RECV_FD(session, fd, buffer, length, flags) \    session->recv(fd, buffer, length, flags, &session->abstract) #define LIBSSH2_SEND(session, buffer, length, flags)  \    LIBSSH2_SEND_FD(session, session->socket_fd, buffer, length, flags)#define LIBSSH2_RECV(session, buffer, length, flags)                    \    LIBSSH2_RECV_FD(session, session->socket_fd, buffer, length, flags) typedef struct _LIBSSH2_KEX_METHOD LIBSSH2_KEX_METHOD;typedef struct _LIBSSH2_HOSTKEY_METHOD LIBSSH2_HOSTKEY_METHOD;typedef struct _LIBSSH2_CRYPT_METHOD LIBSSH2_CRYPT_METHOD;typedef struct _LIBSSH2_COMP_METHOD LIBSSH2_COMP_METHOD; typedef struct _LIBSSH2_PACKET LIBSSH2_PACKET; typedef enum{    libssh2_NB_state_idle = 0,    libssh2_NB_state_allocated,    libssh2_NB_state_created,    libssh2_NB_state_sent,    libssh2_NB_state_sent1,    libssh2_NB_state_sent2,    libssh2_NB_state_sent3,    libssh2_NB_state_sent4,    libssh2_NB_state_sent5,    libssh2_NB_state_sent6,    libssh2_NB_state_sent7,    libssh2_NB_state_jump1,    libssh2_NB_state_jump2,    libssh2_NB_state_jump3,    libssh2_NB_state_jump4,    libssh2_NB_state_jump5} libssh2_nonblocking_states; typedef struct packet_require_state_t{    libssh2_nonblocking_states state;    time_t start;} packet_require_state_t; typedef struct packet_requirev_state_t{    time_t start;} packet_requirev_state_t; typedef struct kmdhgGPsha1kex_state_t{    libssh2_nonblocking_states state;    unsigned char *e_packet;    unsigned char *s_packet;    unsigned char *tmp;    unsigned char h_sig_comp[SHA_DIGEST_LENGTH];    unsigned char c;    size_t e_packet_len;    size_t s_packet_len;    size_t tmp_len;    _libssh2_bn_ctx *ctx;    _libssh2_bn *x;    _libssh2_bn *e;    _libssh2_bn *f;    _libssh2_bn *k;    unsigned char *s;    unsigned char *f_value;    unsigned char *k_value;    unsigned char *h_sig;    size_t f_value_len;    size_t k_value_len;    size_t h_sig_len;    libssh2_sha1_ctx exchange_hash;    packet_require_state_t req_state;    libssh2_nonblocking_states burn_state;} kmdhgGPsha1kex_state_t; typedef struct key_exchange_state_low_t{    libssh2_nonblocking_states state;    packet_require_state_t req_state;    kmdhgGPsha1kex_state_t exchange_state;    _libssh2_bn *p;             /* SSH2 defined value (p_value) */    _libssh2_bn *g;             /* SSH2 defined value (2) */    unsigned char request[13];    unsigned char *data;    size_t request_len;    size_t data_len;} key_exchange_state_low_t; typedef struct key_exchange_state_t{    libssh2_nonblocking_states state;    packet_require_state_t req_state;    key_exchange_state_low_t key_state_low;    unsigned char *data;    size_t data_len;    unsigned char *oldlocal;    size_t oldlocal_len;} key_exchange_state_t; #define FwdNotReq "Forward not requested" typedef struct packet_queue_listener_state_t{    libssh2_nonblocking_states state;    unsigned char packet[17 + (sizeof(FwdNotReq) - 1)];    unsigned char *host;    unsigned char *shost;    uint32_t sender_channel;    uint32_t initial_window_size;    uint32_t packet_size;    uint32_t port;    uint32_t sport;    uint32_t host_len;    uint32_t shost_len;    LIBSSH2_CHANNEL *channel;} packet_queue_listener_state_t; #define X11FwdUnAvil "X11 Forward Unavailable" typedef struct packet_x11_open_state_t{    libssh2_nonblocking_states state;    unsigned char packet[17 + (sizeof(X11FwdUnAvil) - 1)];    unsigned char *shost;    uint32_t sender_channel;    uint32_t initial_window_size;    uint32_t packet_size;    uint32_t sport;    uint32_t shost_len;    LIBSSH2_CHANNEL *channel;} packet_x11_open_state_t; struct _LIBSSH2_PACKET{    struct list_node node; /* linked list header */     /* the raw unencrypted payload */    unsigned char *data;    size_t data_len;     /* Where to start reading data from,     * used for channel data that's been partially consumed */    size_t data_head;}; typedef struct _libssh2_channel_data{    /* Identifier */    uint32_t id;     /* Limits and restrictions */    uint32_t window_size_initial, window_size, packet_size;     /* Set to 1 when CHANNEL_CLOSE / CHANNEL_EOF sent/received */    char close, eof, extended_data_ignore_mode;} libssh2_channel_data; struct _LIBSSH2_CHANNEL{    struct list_node node;     unsigned char *channel_type;    unsigned channel_type_len;     /* channel's program exit status */    int exit_status;     /* channel's program exit signal (without the SIG prefix) */    char *exit_signal;     libssh2_channel_data local, remote;    /* Amount of bytes to be refunded to receive window (but not yet sent) */    uint32_t adjust_queue;     LIBSSH2_SESSION *session;     void *abstract;      LIBSSH2_CHANNEL_CLOSE_FUNC((*close_cb));     /* State variables used in libssh2_channel_setenv_ex() */    libssh2_nonblocking_states setenv_state;    unsigned char *setenv_packet;    size_t setenv_packet_len;    unsigned char setenv_local_channel[4];    packet_requirev_state_t setenv_packet_requirev_state;     /* State variables used in libssh2_channel_request_pty_ex()       libssh2_channel_request_pty_size_ex() */    libssh2_nonblocking_states reqPTY_state;    unsigned char reqPTY_packet[41 + 256];    size_t reqPTY_packet_len;    unsigned char reqPTY_local_channel[4];    packet_requirev_state_t reqPTY_packet_requirev_state;     /* State variables used in libssh2_channel_x11_req_ex() */    libssh2_nonblocking_states reqX11_state;    unsigned char *reqX11_packet;    size_t reqX11_packet_len;    unsigned char reqX11_local_channel[4];    packet_requirev_state_t reqX11_packet_requirev_state;     /* State variables used in libssh2_channel_process_startup() */    libssh2_nonblocking_states process_state;    unsigned char *process_packet;    size_t process_packet_len;    unsigned char process_local_channel[4];    packet_requirev_state_t process_packet_requirev_state;     /* State variables used in libssh2_channel_flush_ex() */    libssh2_nonblocking_states flush_state;    size_t flush_refund_bytes;    size_t flush_flush_bytes;     /* State variables used in libssh2_channel_receive_window_adjust() */    libssh2_nonblocking_states adjust_state;    unsigned char adjust_adjust[9];     /* packet_type(1) + channel(4) + adjustment(4) */     /* State variables used in libssh2_channel_read_ex() */    libssh2_nonblocking_states read_state;     uint32_t read_local_id;     /* State variables used in libssh2_channel_write_ex() */    libssh2_nonblocking_states write_state;    unsigned char write_packet[13];    size_t write_packet_len;    size_t write_bufwrite;     /* State variables used in libssh2_channel_close() */    libssh2_nonblocking_states close_state;    unsigned char close_packet[5];     /* State variables used in libssh2_channel_wait_closedeof() */    libssh2_nonblocking_states wait_eof_state;     /* State variables used in libssh2_channel_wait_closed() */    libssh2_nonblocking_states wait_closed_state;     /* State variables used in libssh2_channel_free() */    libssh2_nonblocking_states free_state;     /* State variables used in libssh2_channel_handle_extended_data2() */    libssh2_nonblocking_states extData2_state; }; struct _LIBSSH2_LISTENER{    struct list_node node; /* linked list header */     LIBSSH2_SESSION *session;     char *host;    int port;     /* a list of CHANNELs for this listener */    struct list_head queue;     int queue_size;    int queue_maxsize;     /* State variables used in libssh2_channel_forward_cancel() */    libssh2_nonblocking_states chanFwdCncl_state;    unsigned char *chanFwdCncl_data;    size_t chanFwdCncl_data_len;}; typedef struct _libssh2_endpoint_data{    unsigned char *banner;     unsigned char *kexinit;    size_t kexinit_len;     const LIBSSH2_CRYPT_METHOD *crypt;    void *crypt_abstract;     const struct _LIBSSH2_MAC_METHOD *mac;    uint32_t seqno;    void *mac_abstract;     const LIBSSH2_COMP_METHOD *comp;    void *comp_abstract;     /* Method Preferences -- NULL yields "load order" */    char *crypt_prefs;    char *mac_prefs;    char *comp_prefs;    char *lang_prefs;} libssh2_endpoint_data; #define PACKETBUFSIZE (1024*16) struct transportpacket{    /* ------------- for incoming data --------------- */    unsigned char buf[PACKETBUFSIZE];    unsigned char init[5];  /* first 5 bytes of the incoming data stream,                               still encrypted */    size_t writeidx;        /* at what array index we do the next write into                               the buffer */    size_t readidx;         /* at what array index we do the next read from                               the buffer */    uint32_t packet_length; /* the most recent packet_length as read from the                               network data */    uint8_t padding_length; /* the most recent padding_length as read from the                               network data */    size_t data_num;        /* How much of the total package that has been read                               so far. */    size_t total_num;       /* How much a total package is supposed to be, in                               number of bytes. A full package is                               packet_length + padding_length + 4 +                               mac_length. */    unsigned char *payload; /* this is a pointer to a LIBSSH2_ALLOC()

Lines 1–500 of 1040. Load more