Attachment #3518 for bug #3304

View | Details | Raw Unified | Return to bug 3304
Collapse All | Expand All




{
	u_int n, sz, nfdset;

	debug_f("entering, maxfd = %d", *maxfdp);
	channel_before_prepare_select(ssh); /* might update channel_max_fd */

	n = MAXIMUM(*maxfdp, ssh->chanctxt->channel_max_fd);

	memset(*readsetp, 0, sz);
	memset(*writesetp, 0, sz);

	debug_f("before handler, maxfd = %d", *maxfdp);
	if (!ssh_packet_is_rekeying(ssh))
		channel_handler(ssh, CHAN_PRE, *readsetp, *writesetp,
		    minwait_secs);
	debug_f("done, maxfd = %d", *maxfdp);
}

/*




#include <pwd.h>
#include <unistd.h>
#include <limits.h>
#include <fcntl.h>

#include "openbsd-compat/sys-queue.h"
#include "xmalloc.h"

	schedule_server_alive_check();
}

static void
debug_bad_fdset(const char *what, fd_set *set, int maxfd)
{
	int i;

	for (i = 0; i < maxfd; i++) {
		if (!FD_ISSET(i, set) || fcntl(i, F_GETFL) != -1)
			continue;
		debug_f("select: %s bad fd %i", what, i);
	}
}

static void
debug_bad_select(fd_set *readset, fd_set *writeset, int maxfd)
{
	debug_bad_fdset("readset", readset, maxfd);
	debug_bad_fdset("writeset", writeset, maxfd);
}

/*
 * Waits until the client can do something (some data becomes available on
 * one of the file descriptors).

	struct timeval tv, *tvp;
	int timeout_secs;
	time_t minwait_secs = 0, now = monotime();
	int oerrno, r, ret;

	/* Add any selections by the channel mechanism. */
	channel_prepare_select(ssh, readsetp, writesetp, maxfdp,

		tv.tv_usec = 0;
		tvp = &tv;
	}

	ret = select((*maxfdp)+1, *readsetp, *writesetp, NULL, tvp);
	if (ret == -1) {
		if (errno != EINTR) {
			oerrno = errno;
			debug_f("select: %s", strerror(errno));
			debug_bad_select(*readsetp, *writesetp, *maxfdp);
			errno = oerrno;
		}
		/*
		 * We have to clear the select masks, because we return.
		 * We have to return, because the mainloop checks for the flags

			fatal_fr(r, "sshbuf_putf");
		quit_pending = 1;
	} else if (options.server_alive_interval > 0 && !FD_ISSET(connection_in,
	    *readsetp) && monotime() >= server_alive_time) {
		/*
		 * ServerAlive check is needed. We can't rely on the select
		 * timing out since traffic on the client side such as port
		 * forwards can keep waking it up.
		 */
		server_alive_check(ssh);
	}
}

static void

Return to bug 3304

Lines 2438-2443 channel_prepare_select(struct ssh ssh, fd_set readsetp, fd_set *writesetp, Link Here

(-)a/channels.c (+3 lines)
2438	{	2438	{
2439	u_int n, sz, nfdset;	2439	u_int n, sz, nfdset;
2440		2440
		2441	debug_f("entering, maxfd = %d", *maxfdp);
2441	channel_before_prepare_select(ssh); /* might update channel_max_fd */	2442	channel_before_prepare_select(ssh); /* might update channel_max_fd */
2442		2443
2443	n = MAXIMUM(*maxfdp, ssh->chanctxt->channel_max_fd);	2444	n = MAXIMUM(*maxfdp, ssh->chanctxt->channel_max_fd);
Lines 2458-2466 channel_prepare_select(struct ssh ssh, fd_set readsetp, fd_set *writesetp, Link Here
2458	memset(*readsetp, 0, sz);	2459	memset(*readsetp, 0, sz);
2459	memset(*writesetp, 0, sz);	2460	memset(*writesetp, 0, sz);
2460		2461
		2462	debug_f("before handler, maxfd = %d", *maxfdp);
2461	if (!ssh_packet_is_rekeying(ssh))	2463	if (!ssh_packet_is_rekeying(ssh))
2462	channel_handler(ssh, CHAN_PRE, readsetp, writesetp,	2464	channel_handler(ssh, CHAN_PRE, readsetp, writesetp,
2463	minwait_secs);	2465	minwait_secs);
		2466	debug_f("done, maxfd = %d", *maxfdp);
2464	}	2467	}
2465		2468
2466	/*	2469	/*

Lines 85-90 Link Here

(-)a/clientloop.c (-3 / +29 lines)
85	#include <pwd.h>	85	#include <pwd.h>
86	#include <unistd.h>	86	#include <unistd.h>
87	#include <limits.h>	87	#include <limits.h>
		88	#include <fcntl.h>
88		89
89	#include "openbsd-compat/sys-queue.h"	90	#include "openbsd-compat/sys-queue.h"
90	#include "xmalloc.h"	91	#include "xmalloc.h"
Lines 492-497 server_alive_check(struct ssh *ssh) Link Here
492	schedule_server_alive_check();	493	schedule_server_alive_check();
493	}	494	}
494		495
		496	static void
		497	debug_bad_fdset(const char what, fd_set set, int maxfd)
		498	{
		499	int i;
		500
		501	for (i = 0; i < maxfd; i++) {
		502	if (!FD_ISSET(i, set) \|\| fcntl(i, F_GETFL) != -1)
		503	continue;
		504	debug_f("select: %s bad fd %i", what, i);
		505	}
		506	}
		507
		508	static void
		509	debug_bad_select(fd_set readset, fd_set writeset, int maxfd)
		510	{
		511	debug_bad_fdset("readset", readset, maxfd);
		512	debug_bad_fdset("writeset", writeset, maxfd);
		513	}
		514
495	/*	515	/*
496	* Waits until the client can do something (some data becomes available on	516	* Waits until the client can do something (some data becomes available on
497	* one of the file descriptors).	517	* one of the file descriptors).
Lines 504-510 client_wait_until_can_do_something(struct ssh *ssh, Link Here
504	struct timeval tv, *tvp;	524	struct timeval tv, *tvp;
505	int timeout_secs;	525	int timeout_secs;
506	time_t minwait_secs = 0, now = monotime();	526	time_t minwait_secs = 0, now = monotime();
507	int r, ret;	527	int oerrno, r, ret;
508		528
509	/* Add any selections by the channel mechanism. */	529	/* Add any selections by the channel mechanism. */
510	channel_prepare_select(ssh, readsetp, writesetp, maxfdp,	530	channel_prepare_select(ssh, readsetp, writesetp, maxfdp,
Lines 553-561 client_wait_until_can_do_something(struct ssh *ssh, Link Here
553	tv.tv_usec = 0;	573	tv.tv_usec = 0;
554	tvp = &tv;	574	tvp = &tv;
555	}	575	}
556
557	ret = select((maxfdp)+1, readsetp, *writesetp, NULL, tvp);	576	ret = select((maxfdp)+1, readsetp, *writesetp, NULL, tvp);
558	if (ret == -1) {	577	if (ret == -1) {
		578	if (errno != EINTR) {
		579	oerrno = errno;
		580	debug_f("select: %s", strerror(errno));
		581	debug_bad_select(readsetp, writesetp, *maxfdp);
		582	errno = oerrno;
		583	}
559	/*	584	/*
560	* We have to clear the select masks, because we return.	585	* We have to clear the select masks, because we return.
561	* We have to return, because the mainloop checks for the flags	586	* We have to return, because the mainloop checks for the flags
Lines 571-583 client_wait_until_can_do_something(struct ssh *ssh, Link Here
571	fatal_fr(r, "sshbuf_putf");	596	fatal_fr(r, "sshbuf_putf");
572	quit_pending = 1;	597	quit_pending = 1;
573	} else if (options.server_alive_interval > 0 && !FD_ISSET(connection_in,	598	} else if (options.server_alive_interval > 0 && !FD_ISSET(connection_in,
574	*readsetp) && monotime() >= server_alive_time)	599	*readsetp) && monotime() >= server_alive_time) {
575	/*	600	/*
576	* ServerAlive check is needed. We can't rely on the select	601	* ServerAlive check is needed. We can't rely on the select
577	* timing out since traffic on the client side such as port	602	* timing out since traffic on the client side such as port
578	* forwards can keep waking it up.	603	* forwards can keep waking it up.
579	*/	604	*/
580	server_alive_check(ssh);	605	server_alive_check(ssh);
		606	}
581	}	607	}
582		608
583	static void	609	static void