[openssh.git] / packet.h

/*

packet.h

Author: Tatu Ylonen <ylo@cs.hut.fi>

Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
                   All rights reserved

Created: Sat Mar 18 02:02:14 1995 ylo

Interface for the packet protocol functions.

*/

/* RCSID("$Id$"); */

#include "config.h"
#ifndef PACKET_H
#define PACKET_H

#ifdef HAVE_OPENSSL
#include <openssl/bn.h>
#endif
#ifdef HAVE_SSL
#include <ssl/bn.h>
#endif

/* Sets the socket used for communication.  Disables encryption until
   packet_set_encryption_key is called.  It is permissible that fd_in
   and fd_out are the same descriptor; in that case it is assumed to
   be a socket. */
void packet_set_connection(int fd_in, int fd_out);

/* Puts the connection file descriptors into non-blocking mode. */
void packet_set_nonblocking(void);

/* Returns the file descriptor used for input. */
int packet_get_connection_in(void);

/* Returns the file descriptor used for output. */
int packet_get_connection_out(void);

/* Closes the connection (both descriptors) and clears and frees
   internal data structures. */ 
void packet_close(void);

/* Causes any further packets to be encrypted using the given key.  The same
   key is used for both sending and reception.  However, both directions
   are encrypted independently of each other.  Cipher types are
   defined in ssh.h. */
void packet_set_encryption_key(const unsigned char *key, unsigned int keylen,
			       int cipher_type, int is_client);

/* Sets remote side protocol flags for the current connection.  This can
   be called at any time. */
void packet_set_protocol_flags(unsigned int flags);

/* Returns the remote protocol flags set earlier by the above function. */
unsigned int packet_get_protocol_flags(void);

/* Enables compression in both directions starting from the next packet. */
void packet_start_compression(int level);

/* Informs that the current session is interactive.  Sets IP flags for optimal
   performance in interactive use. */
void packet_set_interactive(int interactive, int keepalives);

/* Returns true if the current connection is interactive. */
int packet_is_interactive(void);

/* Starts constructing a packet to send. */
void packet_start(int type);

/* Appends a character to the packet data. */
void packet_put_char(int ch);

/* Appends an integer to the packet data. */
void packet_put_int(unsigned int value);

/* Appends an arbitrary precision integer to packet data. */
void packet_put_bignum(BIGNUM *value);

/* Appends a string to packet data. */
void packet_put_string(const char *buf, unsigned int len);

/* Finalizes and sends the packet.  If the encryption key has been set,
   encrypts the packet before sending. */
void packet_send(void);

/* Waits until a packet has been received, and returns its type. */
int packet_read(int *payload_len_ptr);

/* Waits until a packet has been received, verifies that its type matches
   that given, and gives a fatal error and exits if there is a mismatch. */
void packet_read_expect(int *payload_len_ptr, int type);

/* Checks if a full packet is available in the data received so far via
   packet_process_incoming.  If so, reads the packet; otherwise returns
   SSH_MSG_NONE.  This does not wait for data from the connection. 
   
   SSH_MSG_DISCONNECT is handled specially here.  Also,
   SSH_MSG_IGNORE messages are skipped by this function and are never returned
   to higher levels. */
int packet_read_poll(int *packet_len_ptr);

/* Buffers the given amount of input characters.  This is intended to be
   used together with packet_read_poll. */
void packet_process_incoming(const char *buf, unsigned int len);

/* Returns a character (0-255) from the packet data. */
unsigned int packet_get_char(void);

/* Returns an integer from the packet data. */
unsigned int packet_get_int(void);

/* Returns an arbitrary precision integer from the packet data.  The integer
   must have been initialized before this call. */
void packet_get_bignum(BIGNUM *value, int *length_ptr);

/* Returns a string from the packet data.  The string is allocated using
   xmalloc; it is the responsibility of the calling program to free it when
   no longer needed.  The length_ptr argument may be NULL, or point to an
   integer into which the length of the string is stored. */
char *packet_get_string(unsigned int *length_ptr);

/* Logs the error in syslog using LOG_INFO, constructs and sends a disconnect
   packet, closes the connection, and exits.  This function never returns.
   The error message should not contain a newline.  The total length of the
   message must not exceed 1024 bytes. */
void packet_disconnect(const char *fmt, ...);

/* Sends a diagnostic message to the other side.  This message
   can be sent at any time (but not while constructing another message).
   The message is printed immediately, but only if the client is being
   executed in verbose mode.  These messages are primarily intended to
   ease debugging authentication problems.  The total length of the message
   must not exceed 1024 bytes.  This will automatically call
   packet_write_wait.  If the remote side protocol flags do not indicate
   that it supports SSH_MSG_DEBUG, this will do nothing. */
void packet_send_debug(const char *fmt, ...);

/* Checks if there is any buffered output, and tries to write some of the
   output. */
void packet_write_poll(void);

/* Waits until all pending output data has been written. */
void packet_write_wait(void);

/* Returns true if there is buffered data to write to the connection. */
int packet_have_data_to_write(void);

/* Returns true if there is not too much data to write to the connection. */
int packet_not_very_much_data_to_write(void);

/* Stores tty modes from the fd into current packet. */
void tty_make_modes(int fd);

/* Parses tty modes for the fd from the current packet. */
void tty_parse_modes(int fd, int *n_bytes_ptr);

#define packet_integrity_check(payload_len, expected_len, type) \
do { \
  int _p = (payload_len), _e = (expected_len); \
  if (_p != _e) { \
    log("Packet integrity error (%d != %d) at %s:%d", \
	_p, _e, __FILE__, __LINE__); \
    packet_disconnect("Packet integrity error. (%d)", (type)); \
  } \
} while (0)

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