Attachment #1263 for bug #1307

Lines 455-460 client_check_window_change(void) Link Here

(-)clientloop.c (+15 lines)
455	}	455	}
456		456
457	static void	457	static void
		458	client_global_ignore(int type, u_int32_t seq, void *ctxt)
		459	{
		460	server_alive_timeouts = 0;
		461	}
		462
		463	static void
		464	client_global_unimplemented(int type, u_int32_t seq, void *ctxt)
		465	{
		466	server_alive_timeouts = 0;
		467	debug("Received SSH2_MSG_UNIMPLEMENTED for %u", seq);
		468	}
		469
		470	static void
458	client_global_request_reply(int type, u_int32_t seq, void *ctxt)	471	client_global_request_reply(int type, u_int32_t seq, void *ctxt)
459	{	472	{
460	server_alive_timeouts = 0;	473	server_alive_timeouts = 0;
Lines 2002-2007 client_init_dispatch_20(void) Link Here
2002	/* global request reply messages */	2015	/* global request reply messages */
2003	dispatch_set(SSH2_MSG_REQUEST_FAILURE, &client_global_request_reply);	2016	dispatch_set(SSH2_MSG_REQUEST_FAILURE, &client_global_request_reply);
2004	dispatch_set(SSH2_MSG_REQUEST_SUCCESS, &client_global_request_reply);	2017	dispatch_set(SSH2_MSG_REQUEST_SUCCESS, &client_global_request_reply);
		2018	dispatch_set(SSH2_MSG_IGNORE, &client_global_ignore);
		2019	dispatch_set(SSH2_MSG_UNIMPLEMENTED, &client_global_unimplemented);
2005	}	2020	}
2006	static void	2021	static void
2007	client_init_dispatch_13(void)	2022	client_init_dispatch_13(void)




 * 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, although SSH2_MSG_IGNORE are since they are needed
 * for keepalives.
 */

static int

int
packet_read_poll_seqnr(u_int32_t *seqnr_p)
{
	u_int reason;
	u_char type;
	char *msg;


			if (type)
				DBG(debug("received packet type %d", type));
			switch (type) {
			case SSH2_MSG_IGNORE:
				break;
			case SSH2_MSG_DEBUG:
				packet_get_char();
				msg = packet_get_string(NULL);

				xfree(msg);
				cleanup_exit(255);
				break;
			case SSH2_MSG_UNIMPLEMENTED:
				seqnr = packet_get_int();
				debug("Received SSH2_MSG_UNIMPLEMENTED for %u",
				    seqnr);
				break;
			default:
				return type;
			}

Lines 891-896 server_input_keep_alive(int type, u_int3 Link Here

(-)serverloop.c (+9 lines)
891	}	891	}
892		892
893	static void	893	static void
		894	server_global_unimplemented(int type, u_int32_t seq, void *ctxt)
		895	{
		896	debug("Received SSH2_MSG_UNIMPLEMENTED for %u", seq);
		897	server_input_keep_alive(type, seq, ctxt);
		898	}
		899
		900	static void
894	server_input_stdin_data(int type, u_int32_t seq, void *ctxt)	901	server_input_stdin_data(int type, u_int32_t seq, void *ctxt)
895	{	902	{
896	char *data;	903	char *data;
Lines 1193-1198 server_init_dispatch_20(void) Link Here
1193	dispatch_set(SSH2_MSG_CHANNEL_FAILURE, &server_input_keep_alive);	1200	dispatch_set(SSH2_MSG_CHANNEL_FAILURE, &server_input_keep_alive);
1194	dispatch_set(SSH2_MSG_REQUEST_SUCCESS, &server_input_keep_alive);	1201	dispatch_set(SSH2_MSG_REQUEST_SUCCESS, &server_input_keep_alive);
1195	dispatch_set(SSH2_MSG_REQUEST_FAILURE, &server_input_keep_alive);	1202	dispatch_set(SSH2_MSG_REQUEST_FAILURE, &server_input_keep_alive);
		1203	dispatch_set(SSH2_MSG_IGNORE, &server_input_keep_alive);
		1204	dispatch_set(SSH2_MSG_UNIMPLEMENTED, &server_global_unimplemented);
1196	/* rekeying */	1205	/* rekeying */
1197	dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);	1206	dispatch_set(SSH2_MSG_KEXINIT, &kex_input_kexinit);
1198	}	1207	}

Return to bug 1307

Lines 967-975 packet_read_expect(int expected_type) Link Here

(-)packet.c (-11 / +5 lines)
967	* packet_process_incoming. If so, reads the packet; otherwise returns	967	* packet_process_incoming. If so, reads the packet; otherwise returns
968	* SSH_MSG_NONE. This does not wait for data from the connection.	968	* SSH_MSG_NONE. This does not wait for data from the connection.
969	*	969	*
970	* SSH_MSG_DISCONNECT is handled specially here. Also,	970	* SSH_MSG_DISCONNECT is handled specially here. Also, SSH_MSG_IGNORE
971	* SSH_MSG_IGNORE messages are skipped by this function and are never returned	971	* messages are skipped by this function and are never returned
972	* to higher levels.	972	* to higher levels, although SSH2_MSG_IGNORE are since they are needed
		973	* for keepalives.
973	*/	974	*/
974		975
975	static int	976	static int
Lines 1184-1190 packet_read_poll2(u_int32_t *seqnr_p) Link Here
1184	int	1185	int
1185	packet_read_poll_seqnr(u_int32_t *seqnr_p)	1186	packet_read_poll_seqnr(u_int32_t *seqnr_p)
1186	{	1187	{
1187	u_int reason, seqnr;	1188	u_int reason;
1188	u_char type;	1189	u_char type;
1189	char *msg;	1190	char *msg;
1190		1191
Lines 1194-1201 packet_read_poll_seqnr(u_int32_t *seqnr_ Link Here
1194	if (type)	1195	if (type)
1195	DBG(debug("received packet type %d", type));	1196	DBG(debug("received packet type %d", type));
1196	switch (type) {	1197	switch (type) {
1197	case SSH2_MSG_IGNORE:
1198	break;
1199	case SSH2_MSG_DEBUG:	1198	case SSH2_MSG_DEBUG:
1200	packet_get_char();	1199	packet_get_char();
1201	msg = packet_get_string(NULL);	1200	msg = packet_get_string(NULL);
Lines 1212-1222 packet_read_poll_seqnr(u_int32_t *seqnr_ Link Here
1212	xfree(msg);	1211	xfree(msg);
1213	cleanup_exit(255);	1212	cleanup_exit(255);
1214	break;	1213	break;
1215	case SSH2_MSG_UNIMPLEMENTED:
1216	seqnr = packet_get_int();
1217	debug("Received SSH2_MSG_UNIMPLEMENTED for %u",
1218	seqnr);
1219	break;
1220	default:	1214	default:
1221	return type;	1215	return type;
1222	}	1216	}