dropbear: common-session.c comparison

comparison common-session.c @ 1069:2fa71c3b2827 pam

merge pam branch up to date

author	Matt Johnston <matt@ucc.asn.au>
date	Mon, 16 Mar 2015 21:34:05 +0800
parents	9a6395ddb1b6 4c733310c21d
children	16379795f80b

comparison

equal deleted inserted replaced

-:9a6395ddb1b6
+:2fa71c3b2827
 #include "ssh.h"
 #include "dbrandom.h"
 #include "kex.h"
 #include "channel.h"
 #include "runopts.h"
+#include "netio.h"
 static void checktimeouts();
 static long select_timeout();
 static int ident_readln(int fd, char* buf, int count);
 static void read_session_identification();
 int exitflag = 0; /* GLOBAL */
 /* called only at the start of a session, set up initial state */
 void common_session_init(int sock_in, int sock_out) {
 	time_t now;
+#ifdef DEBUG_TRACE
+	debug_start_net();
+#endif
 	TRACE(("enter session_init"))
 	ses.sock_in = sock_in;
 	ses.sock_out = sock_out;
 		timeout.tv_usec = 0;
 		FD_ZERO(&writefd);
 		FD_ZERO(&readfd);
 		dropbear_assert(ses.payload == NULL);
-		/* during initial setup we flush out the KEXINIT packet before
+		/* We delay reading from the input socket during initial setup until
-		 * attempting to read the remote version string, which might block */
+		after we have written out our initial KEXINIT packet (empty writequeue).
+		This means our initial packet can be in-flight while we're doing a blocking
+		read for the remote ident */
 		if (ses.sock_in != -1 && (ses.remoteident || isempty(&ses.writequeue))) {
 			FD_SET(ses.sock_in, &readfd);
 		}
 		if (ses.sock_out != -1 && !isempty(&ses.writequeue)) {
 			FD_SET(ses.sock_out, &writefd);
 		   SIGCHLD in svr-chansession is the only one currently. */
 		FD_SET(ses.signal_pipe[0], &readfd);
 		/* set up for channels which can be read/written */
 		setchannelfds(&readfd, &writefd);
+		/* Pending connections to test */
+		set_connect_fds(&writefd);
 		val = select(ses.maxfd+1, &readfd, &writefd, NULL, &timeout);
 		if (exitflag) {
 			dropbear_exit("Terminated by signal");
 			 * will be ready for a new packet */
 			if (ses.payload != NULL) {
 				process_packet();
 			}
 		}
 		/* if required, flush out any queued reply packets that
 		were being held up during a KEX */
 		maybe_flush_reply_queue();
+		handle_connect_fds(&writefd);
 		/* process pipes etc for the channels, ses.dataallowed == 0
 		 * during rekeying ) */
 		channelio(&readfd, &writefd);
 	} /* for(;;) */
 	ses.recursion_count--;
 	ses.exit_recursion = 0;
 }
+static void cleanup_buf(buffer **buf) {
+	if (!*buf) {
+		return;
+	}
+	buf_burn(*buf);
+	buf_free(*buf);
+	*buf = NULL;
+}
 /* clean up a session on exit */
 void session_cleanup() {
 	TRACE(("enter session_cleanup"))
 	if (!sessinitdone) {
 		TRACE(("leave session_cleanup: !sessinitdone"))
 		return;
 	}
+	/* Beware of changing order of functions here. */
+	/* Must be before extra_session_cleanup() */
+	chancleanup();
 	if (ses.extra_session_cleanup) {
 		ses.extra_session_cleanup();
 	}
-	chancleanup();
+	/* After these are freed most functions will exit */
+#ifdef DROPBEAR_CLEANUP
-	/* Cleaning up keys must happen after other cleanup
+	/* listeners call cleanup functions, this should occur before
-	functions which might queue packets */
+	other session state is freed. */
-	if (ses.session_id) {
+	remove_all_listeners();
-		buf_burn(ses.session_id);
-		buf_free(ses.session_id);
+	remove_connect_pending();
-		ses.session_id = NULL;
-	}
+	while (!isempty(&ses.writequeue)) {
-	if (ses.hash) {
+		buf_free(dequeue(&ses.writequeue));
-		buf_burn(ses.hash);
+	}
-		buf_free(ses.hash);
-		ses.hash = NULL;
+	m_free(ses.remoteident);
-	}
+	m_free(ses.authstate.pw_dir);
+	m_free(ses.authstate.pw_name);
+	m_free(ses.authstate.pw_shell);
+	m_free(ses.authstate.pw_passwd);
+	m_free(ses.authstate.username);
+#endif
+	cleanup_buf(&ses.session_id);
+	cleanup_buf(&ses.hash);
+	cleanup_buf(&ses.payload);
+	cleanup_buf(&ses.readbuf);
+	cleanup_buf(&ses.writepayload);
+	cleanup_buf(&ses.kexhashbuf);
+	cleanup_buf(&ses.transkexinit);
+	if (ses.dh_K) {
+		mp_clear(ses.dh_K);
+	}
+	m_free(ses.dh_K);
 	m_burn(ses.keys, sizeof(struct key_context));
 	m_free(ses.keys);
 	TRACE(("leave session_cleanup"))
 }
 	TRACE(("leave ident_readln: return %d", pos+1))
 	return pos+1;
 }
 void ignore_recv_response() {
-	// Do nothing
+	/* Do nothing */
 	TRACE(("Ignored msg_request_response"))
 }
 static void send_msg_keepalive() {
+	time_t old_time_idle = ses.last_packet_time_idle;
+	struct Channel *chan = get_any_ready_channel();
 	CHECKCLEARTOWRITE();
-	time_t old_time_idle = ses.last_packet_time_idle;
-	struct Channel *chan = get_any_ready_channel();
 	if (chan) {
 		/* Channel requests are preferable, more implementations
 		handle them than SSH_MSG_GLOBAL_REQUEST */
 		TRACE(("keepalive channel request %d", chan->index))
 	int any = 0;
 	unsigned int i;
 	TRACE(("update_channel_prio"))
+	if (ses.sock_out < 0) {
+		TRACE(("leave update_channel_prio: no socket"))
+		return;
+	}
 	new_prio = DROPBEAR_PRIO_BULK;
 	for (i = 0; i < ses.chansize; i++) {
 		struct Channel *channel = ses.channels[i];
 		if (!channel || channel->prio == DROPBEAR_CHANNEL_PRIO_EARLY) {
 			if (channel && channel->prio == DROPBEAR_CHANNEL_PRIO_EARLY) {
 		TRACE(("update_channel_prio: not any"))
 		new_prio = DROPBEAR_PRIO_LOWDELAY;
 	}
 	if (new_prio != ses.socket_prio) {
-		TRACE(("Dropbear priority transitioning %4.4s -> %4.4s", (char*)&ses.socket_prio, (char*)&new_prio))
+		TRACE(("Dropbear priority transitioning %d -> %d", ses.socket_prio, new_prio))
 		set_sock_priority(ses.sock_out, new_prio);
 		ses.socket_prio = new_prio;
 	}
 }

Mercurial > dropbear

comparison common-session.c @ 1069:2fa71c3b2827 pam