packet.h

   1 /*
   2
   3 packet.h
   4
   5 Author: Tatu Ylonen <ylo@cs.hut.fi>
   6
   7 Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
   8                    All rights reserved
   9
  10 Created: Sat Mar 18 02:02:14 1995 ylo
  11
  12 Interface for the packet protocol functions.
  13
  14 */
  15
  16 /* RCSID("$Id$"); */
  17
  18 #ifndef PACKET_H
  19 #define PACKET_H
  20
  21 #include "config.h"
  22
  23 #ifdef HAVE_OPENSSL
  24 #include <openssl/bn.h>
  25 #endif
  26 #ifdef HAVE_SSL
  27 #include <ssl/bn.h>
  28 #endif
  29
  30 /* Sets the socket used for communication.  Disables encryption until
  31    packet_set_encryption_key is called.  It is permissible that fd_in
  32    and fd_out are the same descriptor; in that case it is assumed to
  33    be a socket. */
  34 void packet_set_connection(int fd_in, int fd_out);
  35
  36 /* Puts the connection file descriptors into non-blocking mode. */
  37 void packet_set_nonblocking(void);
  38
  39 /* Returns the file descriptor used for input. */
  40 int packet_get_connection_in(void);
  41
  42 /* Returns the file descriptor used for output. */
  43 int packet_get_connection_out(void);
  44
  45 /* Closes the connection (both descriptors) and clears and frees
  46    internal data structures. */
  47 void packet_close(void);
  48
  49 /* Causes any further packets to be encrypted using the given key.  The same
  50    key is used for both sending and reception.  However, both directions
  51    are encrypted independently of each other.  Cipher types are
  52    defined in ssh.h. */
  53 void packet_set_encryption_key(const unsigned char *key, unsigned int keylen,
  54                                int cipher_type, int is_client);
  55
  56 /* Sets remote side protocol flags for the current connection.  This can
  57    be called at any time. */
  58 void packet_set_protocol_flags(unsigned int flags);
  59
  60 /* Returns the remote protocol flags set earlier by the above function. */
  61 unsigned int packet_get_protocol_flags(void);
  62
  63 /* Enables compression in both directions starting from the next packet. */
  64 void packet_start_compression(int level);
  65
  66 /* Informs that the current session is interactive.  Sets IP flags for optimal
  67    performance in interactive use. */
  68 void packet_set_interactive(int interactive, int keepalives);
  69
  70 /* Returns true if the current connection is interactive. */
  71 int packet_is_interactive(void);
  72
  73 /* Starts constructing a packet to send. */
  74 void packet_start(int type);
  75
  76 /* Appends a character to the packet data. */
  77 void packet_put_char(int ch);
  78
  79 /* Appends an integer to the packet data. */
  80 void packet_put_int(unsigned int value);
  81
  82 /* Appends an arbitrary precision integer to packet data. */
  83 void packet_put_bignum(BIGNUM *value);
  84
  85 /* Appends a string to packet data. */
  86 void packet_put_string(const char *buf, unsigned int len);
  87
  88 /* Finalizes and sends the packet.  If the encryption key has been set,
  89    encrypts the packet before sending. */
  90 void packet_send(void);
  91
  92 /* Waits until a packet has been received, and returns its type. */
  93 int packet_read(int *payload_len_ptr);
  94
  95 /* Waits until a packet has been received, verifies that its type matches
  96    that given, and gives a fatal error and exits if there is a mismatch. */
  97 void packet_read_expect(int *payload_len_ptr, int type);
  98
  99 /* Checks if a full packet is available in the data received so far via
 100    packet_process_incoming.  If so, reads the packet; otherwise returns
 101    SSH_MSG_NONE.  This does not wait for data from the connection.
 102
 103    SSH_MSG_DISCONNECT is handled specially here.  Also,
 104    SSH_MSG_IGNORE messages are skipped by this function and are never returned
 105    to higher levels. */
 106 int packet_read_poll(int *packet_len_ptr);
 107
 108 /* Buffers the given amount of input characters.  This is intended to be
 109    used together with packet_read_poll. */
 110 void packet_process_incoming(const char *buf, unsigned int len);
 111
 112 /* Returns a character (0-255) from the packet data. */
 113 unsigned int packet_get_char(void);
 114
 115 /* Returns an integer from the packet data. */
 116 unsigned int packet_get_int(void);
 117
 118 /* Returns an arbitrary precision integer from the packet data.  The integer
 119    must have been initialized before this call. */
 120 void packet_get_bignum(BIGNUM *value, int *length_ptr);
 121
 122 /* Returns a string from the packet data.  The string is allocated using
 123    xmalloc; it is the responsibility of the calling program to free it when
 124    no longer needed.  The length_ptr argument may be NULL, or point to an
 125    integer into which the length of the string is stored. */
 126 char *packet_get_string(unsigned int *length_ptr);
 127
 128 /* Logs the error in syslog using LOG_INFO, constructs and sends a disconnect
 129    packet, closes the connection, and exits.  This function never returns.
 130    The error message should not contain a newline.  The total length of the
 131    message must not exceed 1024 bytes. */
 132 void packet_disconnect(const char *fmt, ...);
 133
 134 /* Sends a diagnostic message to the other side.  This message
 135    can be sent at any time (but not while constructing another message).
 136    The message is printed immediately, but only if the client is being
 137    executed in verbose mode.  These messages are primarily intended to
 138    ease debugging authentication problems.  The total length of the message
 139    must not exceed 1024 bytes.  This will automatically call
 140    packet_write_wait.  If the remote side protocol flags do not indicate
 141    that it supports SSH_MSG_DEBUG, this will do nothing. */
 142 void packet_send_debug(const char *fmt, ...);
 143
 144 /* Checks if there is any buffered output, and tries to write some of the
 145    output. */
 146 void packet_write_poll(void);
 147
 148 /* Waits until all pending output data has been written. */
 149 void packet_write_wait(void);
 150
 151 /* Returns true if there is buffered data to write to the connection. */
 152 int packet_have_data_to_write(void);
 153
 154 /* Returns true if there is not too much data to write to the connection. */
 155 int packet_not_very_much_data_to_write(void);
 156
 157 /* Stores tty modes from the fd into current packet. */
 158 void tty_make_modes(int fd);
 159
 160 /* Parses tty modes for the fd from the current packet. */
 161 void tty_parse_modes(int fd, int *n_bytes_ptr);
 162
 163 #define packet_integrity_check(payload_len, expected_len, type) \
 164 do { \
 165   int _p = (payload_len), _e = (expected_len); \
 166   if (_p != _e) { \
 167     log("Packet integrity error (%d != %d) at %s:%d", \
 168         _p, _e, __FILE__, __LINE__); \
 169     packet_disconnect("Packet integrity error. (%d)", (type)); \
 170   } \
 171 } while (0)
 172
 173 #endif /* PACKET_H */