Attachment #1331 for bug #1330




client_wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp,
    int *maxfdp, u_int *nallocp, int rekeying)
{
	struct timeval tv, *tvp;
	int ret;

	/* Add any selections by the channel mechanism. */

	 * event pending.
	 */

	ret = packet_select((*maxfdp)+1, *readsetp, *writesetp, NULL,
			compat20 ? options.server_alive_interval : 0);
	else {
		tv.tv_sec = options.server_alive_interval;
		tv.tv_usec = 0;
		tvp = &tv;
	}
	ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);
	if (ret < 0) {
		char buf[100];


		snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));
		buffer_append(&stderr_buffer, buf, strlen(buf));
		quit_pending = 1;
	} else if (ret == 0) {
		if (packet_idle_timedout()) {
			char buf[100];
			snprintf(buf, sizeof buf, "Idle timeout.\r\n");
			buffer_append(&stderr_buffer, buf, strlen(buf));
			quit_pending = 1;
		} else {
			server_alive_check();
		}
	}
}

static void

client_channel_closed(int id, void *arg)
{
	channel_cancel_cleanup(id);
	session_closed = 1;
	leave_raw_mode();
	if (options.control_persist && options.control_path != NULL && control_fd != -1) {
		packet_set_idle_timeout(options.control_timeout);
		daemon(0,0);
		return;
	}
	session_closed = 1;
}

/*




};
TAILQ_HEAD(, packet) outgoing;

/* Idle timeout variables */
static time_t idletime_last=0;
static int idle_timeout=0;


void
packet_set_idle_timeout(int max_idle_seconds) 
{
	debug("Setting idle timeout to %d", max_idle_seconds);
	idle_timeout=max_idle_seconds;
	if (max_idle_seconds>0) {
		/* Initialize */
		time(&idletime_last);
	}
}

/* Called whenever packets are sent or received.
 * This function decides which packets mean being idle */
void 
idle_timeout_check(int type) 
{
        /* No-op, if idle-timeouts are not configured */
        if (idle_timeout==0) return;

	/* The following packets reset the timeout on input or output.
	 * Note that only actual data resets timeout, control packets 
	 * do not. */
	if (compat20) {
	        switch(type) {
		case SSH2_MSG_CHANNEL_DATA:
		case SSH2_MSG_CHANNEL_EXTENDED_DATA:
		        time(&idletime_last);
		}
	} else {
		switch(type) {
		case SSH_MSG_CHANNEL_DATA:
		case SSH_CMSG_STDIN_DATA:
		case SSH_SMSG_STDOUT_DATA:
		case SSH_SMSG_STDERR_DATA:	
		        time(&idletime_last);
		} 
	}
}

/* Check if idle timeout occurred */
int
packet_idle_timedout()
{
	return (idle_timeout == -2);
}

/* This function combines the regular select() call with timeout
 * semantics */
int     
packet_select(int maxfds,
	      fd_set *readset, fd_set *writeset, fd_set *exceptset,
	      int max_time_milliseconds)
{
        struct timeval tv, *tvp=NULL;
	int milliseconds_to_idle=0;
	int ret;

	if (idle_timeout>0) {
	        /* Count the time to idle_timeout */
	        time_t diff=time(NULL)-idletime_last;
		if (diff>=idle_timeout)
		        milliseconds_to_idle=100;
		else
		        milliseconds_to_idle=(idle_timeout-diff)*1000;
	}
	/* If a timeout value was given and the timeout happens before
	 * idle_timeout, use it */
	if (max_time_milliseconds > 0 || milliseconds_to_idle > 0) {
		if (max_time_milliseconds > 0 &&
				max_time_milliseconds < milliseconds_to_idle) {
			milliseconds_to_idle = 0;
		} else {
			max_time_milliseconds = milliseconds_to_idle;
		}
	        tv.tv_sec = max_time_milliseconds / 1000;
		tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
		tvp = &tv;
	}

	ret = select( maxfds, readset, writeset, exceptset, tvp );

	/* Disconnect on idle_timeout */
	if (milliseconds_to_idle > 0 && ret == 0) {
		idle_timeout=-2;
	}
	return ret;
}
/*
 * Sets the descriptors used for communication.  Disables encryption until
 * packet_set_encryption_key is called.

	int len;

	DBG(debug("packet_start[%d]", type));

	idle_timeout_check(type);

	len = compat20 ? 6 : 9;
	memset(buf, 0, len - 1);
	buf[len - 1] = type;

		/* If we got a packet, return it. */
		if (type != SSH_MSG_NONE) {
			xfree(setp);
			idle_timeout_check(type);
			return type;
		}
		/*
		 * Otherwise, wait for some data to arrive, add it to the
		 * buffer, and try again.
		 */
		do {
   		        memset(setp, 0, howmany(connection_in + 1, NFDBITS) *
			       sizeof(fd_mask));
		        FD_SET(connection_in, setp);
			
			/* Wait for some data to arrive. */
		} while (packet_select(connection_in + 1,
				       setp, NULL, NULL, 0) == -1 &&
				(errno == EAGAIN || errno == EINTR))
			;
		if (packet_idle_timedout()) {
			logit("Idle timeout");
			cleanup_exit(255);
		}
		/* Read data from the socket. */
		len = read(connection_in, buf, sizeof(buf));
		if (len == 0) {

	    sizeof(fd_mask));
	packet_write_poll();
	while (packet_have_data_to_write()) {
	        do {
		        memset(setp, 0, howmany(connection_out + 1, NFDBITS) *
			       sizeof(fd_mask));
			FD_SET(connection_out, setp);
		} while (packet_select(connection_out + 1, 
				       NULL, setp, NULL, 0) == -1 &&
				(errno == EAGAIN || errno == EINTR))
			;
		if (packet_idle_timedout()) {
			logit("Idle timeout");
			cleanup_exit(255);
		}
		packet_write_poll();
	}
	xfree(setp);




int	 packet_need_rekeying(void);
void	 packet_set_rekey_limit(u_int32_t);

/* This sets the maximum idle time before packet_select() automatically
 * disconnects with packet_disconnect("Idletimeout"). 
 * Never autodisconnects if set to zero. zero is the default */
void    packet_set_idle_timeout(int max_idle_seconds);

/* This checks if an idle timeout occurred */
int	packet_idle_timedout(void);

/* This is an quite normal select, except that it implements idle_timeouts
 * set with packet_set_idle_timeout().
 * It also returns exits, if select() returns any other error than AGAIN
 * or EINTR. So if packet_select returns -1, you can safely reinit fd_sets
 * and call packet_select again, without checking errno.
 */
int     packet_select(int maxfds,
		      fd_set *readset, fd_set *writeset, fd_set *exceptset,
		      int max_time_milliseconds);


#endif				/* PACKET_H */

Lines 128-136 Link Here

(-)openssh-4.6p1-orig/readconf.c (-2 / +26 lines)
128	oEnableSSHKeysign, oRekeyLimit, oVerifyHostKeyDNS, oConnectTimeout,	128	oEnableSSHKeysign, oRekeyLimit, oVerifyHostKeyDNS, oConnectTimeout,
129	oAddressFamily, oGssAuthentication, oGssDelegateCreds,	129	oAddressFamily, oGssAuthentication, oGssDelegateCreds,
130	oServerAliveInterval, oServerAliveCountMax, oIdentitiesOnly,	130	oServerAliveInterval, oServerAliveCountMax, oIdentitiesOnly,
131	oSendEnv, oControlPath, oControlMaster, oHashKnownHosts,	131	oSendEnv, oControlPath, oControlMaster, oControlPersist, oHashKnownHosts,
132	oTunnel, oTunnelDevice, oLocalCommand, oPermitLocalCommand,	132	oTunnel, oTunnelDevice, oLocalCommand, oPermitLocalCommand,
133	oDeprecated, oUnsupported	133	oControlTimeout, oIdleTimeout, oDeprecated, oUnsupported
134	} OpCodes;	134	} OpCodes;
135		135
136	/* Textual representations of the tokens. */	136	/* Textual representations of the tokens. */
Lines 221-231 Link Here
221	{ "sendenv", oSendEnv },	221	{ "sendenv", oSendEnv },
222	{ "controlpath", oControlPath },	222	{ "controlpath", oControlPath },
223	{ "controlmaster", oControlMaster },	223	{ "controlmaster", oControlMaster },
		224	{ "controlpersist", oControlPersist },
		225	{ "controltimeout", oControlTimeout },
224	{ "hashknownhosts", oHashKnownHosts },	226	{ "hashknownhosts", oHashKnownHosts },
225	{ "tunnel", oTunnel },	227	{ "tunnel", oTunnel },
226	{ "tunneldevice", oTunnelDevice },	228	{ "tunneldevice", oTunnelDevice },
227	{ "localcommand", oLocalCommand },	229	{ "localcommand", oLocalCommand },
228	{ "permitlocalcommand", oPermitLocalCommand },	230	{ "permitlocalcommand", oPermitLocalCommand },
		231	{ "idletimeout", oIdleTimeout },
229	{ NULL, oBadOption }	232	{ NULL, oBadOption }
230	};	233	};
231		234
Lines 868-873 Link Here
868	*intptr = value;	871	*intptr = value;
869	break;	872	break;
870		873
		874	case oControlPersist:
		875	intptr = &options->control_persist;
		876	goto parse_flag;
		877
		878	case oControlTimeout:
		879	intptr = &options->control_timeout;
		880	goto parse_time;
		881
871	case oHashKnownHosts:	882	case oHashKnownHosts:
872	intptr = &options->hash_known_hosts;	883	intptr = &options->hash_known_hosts;
873	goto parse_flag;	884	goto parse_flag;
Lines 915-920 Link Here
915	intptr = &options->permit_local_command;	926	intptr = &options->permit_local_command;
916	goto parse_flag;	927	goto parse_flag;
917		928
		929	case oIdleTimeout:
		930	intptr = &options->idle_timeout;
		931	goto parse_time;
		932
918	case oDeprecated:	933	case oDeprecated:
919	debug("%s line %d: Deprecated option \"%s\"",	934	debug("%s line %d: Deprecated option \"%s\"",
920	filename, linenum, keyword);	935	filename, linenum, keyword);
Lines 1059-1070 Link Here
1059	options->num_send_env = 0;	1074	options->num_send_env = 0;
1060	options->control_path = NULL;	1075	options->control_path = NULL;
1061	options->control_master = -1;	1076	options->control_master = -1;
		1077	options->control_persist = -1;
		1078	options->control_timeout = -1;
1062	options->hash_known_hosts = -1;	1079	options->hash_known_hosts = -1;
1063	options->tun_open = -1;	1080	options->tun_open = -1;
1064	options->tun_local = -1;	1081	options->tun_local = -1;
1065	options->tun_remote = -1;	1082	options->tun_remote = -1;
1066	options->local_command = NULL;	1083	options->local_command = NULL;
1067	options->permit_local_command = -1;	1084	options->permit_local_command = -1;
		1085	options->idle_timeout = -1;
1068	}	1086	}
1069		1087
1070	/*	1088	/*
Lines 1189-1194 Link Here
1189	options->server_alive_count_max = 3;	1207	options->server_alive_count_max = 3;
1190	if (options->control_master == -1)	1208	if (options->control_master == -1)
1191	options->control_master = 0;	1209	options->control_master = 0;
		1210	if (options->control_persist == -1)
		1211	options->control_persist = 0;
		1212	if (options->control_timeout == -1)
		1213	options->control_timeout = 0;
1192	if (options->hash_known_hosts == -1)	1214	if (options->hash_known_hosts == -1)
1193	options->hash_known_hosts = 0;	1215	options->hash_known_hosts = 0;
1194	if (options->tun_open == -1)	1216	if (options->tun_open == -1)
Lines 1199-1204 Link Here
1199	options->tun_remote = SSH_TUNID_ANY;	1221	options->tun_remote = SSH_TUNID_ANY;
1200	if (options->permit_local_command == -1)	1222	if (options->permit_local_command == -1)
1201	options->permit_local_command = 0;	1223	options->permit_local_command = 0;
		1224	if (options->idle_timeout == -1)
		1225	options->idle_timeout = 0;
1202	/* options->local_command should not be set by default */	1226	/* options->local_command should not be set by default */
1203	/* options->proxy_command should not be set by default */	1227	/* options->proxy_command should not be set by default */
1204	/* options->user will be set in the main program if appropriate */	1228	/* options->user will be set in the main program if appropriate */

Lines 111-116 Link Here

(-)openssh-4.6p1-orig/readconf.h (+7 lines)
111		111
112	char *control_path;	112	char *control_path;
113	int control_master;	113	int control_master;
		114	int control_persist;
114		115
115	int hash_known_hosts;	116	int hash_known_hosts;
116		117
Lines 121-126 Link Here
121	char *local_command;	122	char *local_command;
122	int permit_local_command;	123	int permit_local_command;
123		124
		125	int idle_timeout; /*
		126	* If nonzero, the number of seconds
		127	* after which idle connections
		128	* will be terminated
		129	*/
		130	int control_timeout; /* Same, for master connections */
124	} Options;	131	} Options;
125		132
126	#define SSHCTL_MASTER_NO 0	133	#define SSHCTL_MASTER_NO 0

Lines 122-127 Link Here

(-)openssh-4.6p1-orig/servconf.c (-1 / +9 lines)
122	options->permit_tun = -1;	122	options->permit_tun = -1;
123	options->num_permitted_opens = -1;	123	options->num_permitted_opens = -1;
124	options->adm_forced_command = NULL;	124	options->adm_forced_command = NULL;
		125	options->idle_timeout = -1;
125	}	126	}
126		127
127	void	128	void
Lines 262-267 Link Here
262	options->compression = 0;	263	options->compression = 0;
263	}	264	}
264	#endif	265	#endif
		266	if (options->idle_timeout == -1)
		267	options->idle_timeout=0;
265		268
266	}	269	}
267		270
Lines 293-299 Link Here
293	sGssAuthentication, sGssCleanupCreds, sAcceptEnv, sPermitTunnel,	296	sGssAuthentication, sGssCleanupCreds, sAcceptEnv, sPermitTunnel,
294	sMatch, sPermitOpen, sForceCommand,	297	sMatch, sPermitOpen, sForceCommand,
295	sUsePrivilegeSeparation,	298	sUsePrivilegeSeparation,
296	sDeprecated, sUnsupported	299	sIdleTimeout, sDeprecated, sUnsupported
297	} ServerOpCodes;	300	} ServerOpCodes;
298		301
299	#define SSHCFG_GLOBAL 0x01 /* allowed in main section of sshd_config */	302	#define SSHCFG_GLOBAL 0x01 /* allowed in main section of sshd_config */
Lines 403-408 Link Here
403	{ "match", sMatch, SSHCFG_ALL },	406	{ "match", sMatch, SSHCFG_ALL },
404	{ "permitopen", sPermitOpen, SSHCFG_ALL },	407	{ "permitopen", sPermitOpen, SSHCFG_ALL },
405	{ "forcecommand", sForceCommand, SSHCFG_ALL },	408	{ "forcecommand", sForceCommand, SSHCFG_ALL },
		409	{ "idletimeout", sIdleTimeout, SSHCFG_ALL },
406	{ NULL, sBadOption, 0 }	410	{ NULL, sBadOption, 0 }
407	};	411	};
408		412
Lines 1254-1259 Link Here
1254	options->adm_forced_command = xstrdup(cp + len);	1258	options->adm_forced_command = xstrdup(cp + len);
1255	return 0;	1259	return 0;
1256		1260
		1261	case sIdleTimeout:
		1262	intptr = &options->idle_timeout;
		1263	goto parse_time;
		1264
1257	case sDeprecated:	1265	case sDeprecated:
1258	logit("%s line %d: Deprecated option %s",	1266	logit("%s line %d: Deprecated option %s",
1259	filename, linenum, arg);	1267	filename, linenum, arg);

Lines 141-146 Link Here

(-)openssh-4.6p1-orig/servconf.h (+5 lines)
141	int permit_tun;	141	int permit_tun;
142		142
143	int num_permitted_opens;	143	int num_permitted_opens;
		144	int idle_timeout; /*
		145	* If nonzero, the number of second
		146	* after which idle connections
		147	* will be terminated
		148	*/
144	} ServerOptions;	149	} ServerOptions;
145		150
146	void initialize_server_options(ServerOptions *);	151	void initialize_server_options(ServerOptions *);




wait_until_can_do_something(fd_set **readsetp, fd_set **writesetp, int *maxfdp,
    u_int *nallocp, u_int max_time_milliseconds)
{
	struct timeval tv, *tvp;
	int ret;
	int client_alive_scheduled = 0;
	int program_alive_scheduled = 0;

		if (max_time_milliseconds == 0 || client_alive_scheduled)
			max_time_milliseconds = 100;

	/* Wait for something to happen, or the timeout to expire. 
	 * packet select also implements server idle_timeouts for us. */
	ret = packet_select((*maxfdp)+1, *readsetp, *writesetp, NULL, 
			    max_time_milliseconds);
		tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
		tvp = &tv;
	}

	/* Wait for something to happen, or the timeout to expire. */
	ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);

	if (ret == -1) {
		memset(*readsetp, 0, *nallocp);
		memset(*writesetp, 0, *nallocp);
		if (errno != EINTR)
			error("select: %.100s", strerror(errno));
	} else {
		if (ret == 0) {
			if (client_alive_scheduled)
				client_alive_check();
			else if (packet_idle_timedout()) {
				logit("Idle timeout.");
				cleanup_exit(255);
			}
		}
		if (!compat20 && program_alive_scheduled && fdin_is_tty) {
			if (!fdout_eof)
				FD_SET(fdout, *readsetp);

Lines 238-243 Link Here

(-)openssh-4.6p1-orig/session.c (+2 lines)
238	if (!no_port_forwarding_flag && options.allow_tcp_forwarding)	238	if (!no_port_forwarding_flag && options.allow_tcp_forwarding)
239	channel_permit_all_opens();	239	channel_permit_all_opens();
240		240
		241	packet_set_idle_timeout(options.idle_timeout);
		242
241	if (compat20)	243	if (compat20)
242	do_authenticated2(authctxt);	244	do_authenticated2(authctxt);
243	else	245	else

Lines 973-978 Link Here

(-)openssh-4.6p1-orig/sshconnect.c (+1 lines)
973	ssh_userauth1(local_user, server_user, host, sensitive);	973	ssh_userauth1(local_user, server_user, host, sensitive);
974	}	974	}
975	xfree(local_user);	975	xfree(local_user);
		976	packet_set_idle_timeout(options.idle_timeout);
976	}	977	}
977		978
978	void	979	void

Return to bug 1330

Lines 482-488 Link Here

(-)openssh-4.6p1-orig/clientloop.c (-12 / +18 lines)
482	client_wait_until_can_do_something(fd_set readsetp, fd_set writesetp,	482	client_wait_until_can_do_something(fd_set readsetp, fd_set writesetp,
483	int maxfdp, u_int nallocp, int rekeying)	483	int maxfdp, u_int nallocp, int rekeying)
484	{	484	{
485	struct timeval tv, *tvp;
486	int ret;	485	int ret;
487		486
488	/* Add any selections by the channel mechanism. */	487	/* Add any selections by the channel mechanism. */
Lines 532-545 Link Here
532	* event pending.	531	* event pending.
533	*/	532	*/
534		533
535	if (options.server_alive_interval == 0 \|\| !compat20)	534	ret = packet_select((maxfdp)+1, readsetp, *writesetp, NULL,
536	tvp = NULL;	535	compat20 ? options.server_alive_interval : 0);
537	else {
538	tv.tv_sec = options.server_alive_interval;
539	tv.tv_usec = 0;
540	tvp = &tv;
541	}
542	ret = select((maxfdp)+1, readsetp, *writesetp, NULL, tvp);
543	if (ret < 0) {	536	if (ret < 0) {
544	char buf[100];	537	char buf[100];
545		538
Lines 557-564 Link Here
557	snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));	550	snprintf(buf, sizeof buf, "select: %s\r\n", strerror(errno));
558	buffer_append(&stderr_buffer, buf, strlen(buf));	551	buffer_append(&stderr_buffer, buf, strlen(buf));
559	quit_pending = 1;	552	quit_pending = 1;
560	} else if (ret == 0)	553	} else if (ret == 0) {
561	server_alive_check();	554	if (packet_idle_timedout()) {
		555	char buf[100];
		556	snprintf(buf, sizeof buf, "Idle timeout.\r\n");
		557	buffer_append(&stderr_buffer, buf, strlen(buf));
		558	quit_pending = 1;
		559	} else {
		560	server_alive_check();
		561	}
		562	}
562	}	563	}
563		564
564	static void	565	static void
Lines 1343-1350 Link Here
1343	client_channel_closed(int id, void *arg)	1344	client_channel_closed(int id, void *arg)
1344	{	1345	{
1345	channel_cancel_cleanup(id);	1346	channel_cancel_cleanup(id);
1346	session_closed = 1;
1347	leave_raw_mode();	1347	leave_raw_mode();
		1348	if (options.control_persist && options.control_path != NULL && control_fd != -1) {
		1349	packet_set_idle_timeout(options.control_timeout);
		1350	daemon(0,0);
		1351	return;
		1352	}
		1353	session_closed = 1;
1348	}	1354	}
1349		1355
1350	/*	1356	/*

Lines 277-283 Link Here

(-)openssh-4.6p1-orig/serverloop.c (-15 / +12 lines)
277	wait_until_can_do_something(fd_set readsetp, fd_set writesetp, int *maxfdp,	277	wait_until_can_do_something(fd_set readsetp, fd_set writesetp, int *maxfdp,
278	u_int *nallocp, u_int max_time_milliseconds)	278	u_int *nallocp, u_int max_time_milliseconds)
279	{	279	{
280	struct timeval tv, *tvp;
281	int ret;	280	int ret;
282	int client_alive_scheduled = 0;	281	int client_alive_scheduled = 0;
283	int program_alive_scheduled = 0;	282	int program_alive_scheduled = 0;
Lines 348-372 Link Here
348	if (max_time_milliseconds == 0 \|\| client_alive_scheduled)	347	if (max_time_milliseconds == 0 \|\| client_alive_scheduled)
349	max_time_milliseconds = 100;	348	max_time_milliseconds = 100;
350		349
351	if (max_time_milliseconds == 0)	350	/* Wait for something to happen, or the timeout to expire.
352	tvp = NULL;	351	* packet select also implements server idle_timeouts for us. */
353	else {	352	ret = packet_select((maxfdp)+1, readsetp, *writesetp, NULL,
354	tv.tv_sec = max_time_milliseconds / 1000;	353	max_time_milliseconds);
355	tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
356	tvp = &tv;
357	}
358
359	/* Wait for something to happen, or the timeout to expire. */
360	ret = select((maxfdp)+1, readsetp, *writesetp, NULL, tvp);
361		354
362	if (ret == -1) {	355	if (ret == -1) {
363	memset(readsetp, 0, nallocp);	356	memset(readsetp, 0, nallocp);
364	memset(writesetp, 0, nallocp);	357	memset(writesetp, 0, nallocp);
365	if (errno != EINTR)
366	error("select: %.100s", strerror(errno));
367	} else {	358	} else {
368	if (ret == 0 && client_alive_scheduled)	359	if (ret == 0) {
369	client_alive_check();	360	if (client_alive_scheduled)
		361	client_alive_check();
		362	else if (packet_idle_timedout()) {
		363	logit("Idle timeout.");
		364	cleanup_exit(255);
		365	}
		366	}
370	if (!compat20 && program_alive_scheduled && fdin_is_tty) {	367	if (!compat20 && program_alive_scheduled && fdin_is_tty) {
371	if (!fdout_eof)	368	if (!fdout_eof)
372	FD_SET(fdout, *readsetp);	369	FD_SET(fdout, *readsetp);

Lines 161-166 Link Here

(-)openssh-4.6p1-orig/packet.c (-13 / +120 lines)
161	};	161	};
162	TAILQ_HEAD(, packet) outgoing;	162	TAILQ_HEAD(, packet) outgoing;
163		163
		164	/* Idle timeout variables */
		165	static time_t idletime_last=0;
		166	static int idle_timeout=0;
		167
		168
		169	void
		170	packet_set_idle_timeout(int max_idle_seconds)
		171	{
		172	debug("Setting idle timeout to %d", max_idle_seconds);
		173	idle_timeout=max_idle_seconds;
		174	if (max_idle_seconds>0) {
		175	/* Initialize */
		176	time(&idletime_last);
		177	}
		178	}
		179
		180	/* Called whenever packets are sent or received.
		181	* This function decides which packets mean being idle */
		182	void
		183	idle_timeout_check(int type)
		184	{
		185	/* No-op, if idle-timeouts are not configured */
		186	if (idle_timeout==0) return;
		187
		188	/* The following packets reset the timeout on input or output.
		189	* Note that only actual data resets timeout, control packets
		190	* do not. */
		191	if (compat20) {
		192	switch(type) {
		193	case SSH2_MSG_CHANNEL_DATA:
		194	case SSH2_MSG_CHANNEL_EXTENDED_DATA:
		195	time(&idletime_last);
		196	}
		197	} else {
		198	switch(type) {
		199	case SSH_MSG_CHANNEL_DATA:
		200	case SSH_CMSG_STDIN_DATA:
		201	case SSH_SMSG_STDOUT_DATA:
		202	case SSH_SMSG_STDERR_DATA:
		203	time(&idletime_last);
		204	}
		205	}
		206	}
		207
		208	/* Check if idle timeout occurred */
		209	int
		210	packet_idle_timedout()
		211	{
		212	return (idle_timeout == -2);
		213	}
		214
		215	/* This function combines the regular select() call with timeout
		216	* semantics */
		217	int
		218	packet_select(int maxfds,
		219	fd_set readset, fd_set writeset, fd_set *exceptset,
		220	int max_time_milliseconds)
		221	{
		222	struct timeval tv, *tvp=NULL;
		223	int milliseconds_to_idle=0;
		224	int ret;
		225
		226	if (idle_timeout>0) {
		227	/* Count the time to idle_timeout */
228	time_t diff=time(NULL)-idletime_last;
229	if (diff>=idle_timeout)
230	milliseconds_to_idle=100;
231	else
232	milliseconds_to_idle=(idle_timeout-diff)*1000;
233	}
234	/* If a timeout value was given and the timeout happens before
235	* idle_timeout, use it */
236	if (max_time_milliseconds > 0 \|\| milliseconds_to_idle > 0) {
237	if (max_time_milliseconds > 0 &&
238	max_time_milliseconds < milliseconds_to_idle) {
239	milliseconds_to_idle = 0;
240	} else {
241	max_time_milliseconds = milliseconds_to_idle;
242	}
243	tv.tv_sec = max_time_milliseconds / 1000;
244	tv.tv_usec = 1000 * (max_time_milliseconds % 1000);
245	tvp = &tv;
246	}
247
248	ret = select( maxfds, readset, writeset, exceptset, tvp );
249
250	/* Disconnect on idle_timeout */
251	if (milliseconds_to_idle > 0 && ret == 0) {
252	idle_timeout=-2;
253	}
254	return ret;
255	}
164	/*	256	/*
165	* Sets the descriptors used for communication. Disables encryption until	257	* Sets the descriptors used for communication. Disables encryption until
166	* packet_set_encryption_key is called.	258	* packet_set_encryption_key is called.
Lines 472-477 Link Here
472	int len;	564	int len;
473		565
474	DBG(debug("packet_start[%d]", type));	566	DBG(debug("packet_start[%d]", type));
		567
		568	idle_timeout_check(type);
		569
475	len = compat20 ? 6 : 9;	570	len = compat20 ? 6 : 9;
476	memset(buf, 0, len - 1);	571	memset(buf, 0, len - 1);
477	buf[len - 1] = type;	572	buf[len - 1] = type;
Lines 912-932 Link Here
912	/* If we got a packet, return it. */	1007	/* If we got a packet, return it. */
913	if (type != SSH_MSG_NONE) {	1008	if (type != SSH_MSG_NONE) {
914	xfree(setp);	1009	xfree(setp);
		1010	idle_timeout_check(type);
915	return type;	1011	return type;
916	}	1012	}
917	/*	1013	/*
918	* Otherwise, wait for some data to arrive, add it to the	1014	* Otherwise, wait for some data to arrive, add it to the
919	* buffer, and try again.	1015	* buffer, and try again.
920	*/	1016	*/
921	memset(setp, 0, howmany(connection_in + 1, NFDBITS) *	1017	do {
922	sizeof(fd_mask));	1018	memset(setp, 0, howmany(connection_in + 1, NFDBITS) *
923	FD_SET(connection_in, setp);	1019	sizeof(fd_mask));
924		1020	FD_SET(connection_in, setp);
925	/* Wait for some data to arrive. */	1021
926	while (select(connection_in + 1, setp, NULL, NULL, NULL) == -1 &&	1022	/* Wait for some data to arrive. */
927	(errno == EAGAIN \|\| errno == EINTR))	1023	} while (packet_select(connection_in + 1,
		1024	setp, NULL, NULL, 0) == -1 &&
		1025	(errno == EAGAIN \|\| errno == EINTR))
928	;	1026	;
929		1027	if (packet_idle_timedout()) {
		1028	logit("Idle timeout");
		1029	cleanup_exit(255);
		1030	}
930	/* Read data from the socket. */	1031	/* Read data from the socket. */
931	len = read(connection_in, buf, sizeof(buf));	1032	len = read(connection_in, buf, sizeof(buf));
932	if (len == 0) {	1033	if (len == 0) {
Lines 1446-1457 Link Here
1446	sizeof(fd_mask));	1547	sizeof(fd_mask));
1447	packet_write_poll();	1548	packet_write_poll();
1448	while (packet_have_data_to_write()) {	1549	while (packet_have_data_to_write()) {
1449	memset(setp, 0, howmany(connection_out + 1, NFDBITS) *	1550	do {
1450	sizeof(fd_mask));	1551	memset(setp, 0, howmany(connection_out + 1, NFDBITS) *
1451	FD_SET(connection_out, setp);	1552	sizeof(fd_mask));
1452	while (select(connection_out + 1, NULL, setp, NULL, NULL) == -1 &&	1553	FD_SET(connection_out, setp);
1453	(errno == EAGAIN \|\| errno == EINTR))	1554	} while (packet_select(connection_out + 1,
		1555	NULL, setp, NULL, 0) == -1 &&
		1556	(errno == EAGAIN \|\| errno == EINTR))
1454	;	1557	;
		1558	if (packet_idle_timedout()) {
		1559	logit("Idle timeout");
		1560	cleanup_exit(255);
		1561	}
1455	packet_write_poll();	1562	packet_write_poll();
1456	}	1563	}
1457	xfree(setp);	1564	xfree(setp);

Lines 103-106 Link Here

(-)openssh-4.6p1-orig/packet.h (+19 lines)
103	int packet_need_rekeying(void);	103	int packet_need_rekeying(void);
104	void packet_set_rekey_limit(u_int32_t);	104	void packet_set_rekey_limit(u_int32_t);
105		105
		106	/* This sets the maximum idle time before packet_select() automatically
		107	* disconnects with packet_disconnect("Idletimeout").
		108	* Never autodisconnects if set to zero. zero is the default */
		109	void packet_set_idle_timeout(int max_idle_seconds);
		110
		111	/* This checks if an idle timeout occurred */
		112	int packet_idle_timedout(void);
		113
		114	/* This is an quite normal select, except that it implements idle_timeouts
		115	* set with packet_set_idle_timeout().
		116	* It also returns exits, if select() returns any other error than AGAIN
		117	* or EINTR. So if packet_select returns -1, you can safely reinit fd_sets
		118	* and call packet_select again, without checking errno.
		119	*/
		120	int packet_select(int maxfds,
		121	fd_set readset, fd_set writeset, fd_set *exceptset,
		122	int max_time_milliseconds);
		123
		124
106	#endif /* PACKET_H */	125	#endif /* PACKET_H */