dropbear: common-channel.c comparison

comparison common-channel.c @ 362:1c7bf9cec6c8 channel-fix

Rearranged some more bits, marked some areas that need work. * send_msg_channel_data() no longer allocates a separate buffer * getchannel() handles unknown channels so callers don't have to

author	Matt Johnston <matt@ucc.asn.au>
date	Mon, 02 Oct 2006 16:34:06 +0000
parents	78518751cb82
children	6ba2894ec8d5

comparison

equal deleted inserted replaced

-:78518751cb82
+:1c7bf9cec6c8
 	return newchan;
 }
 /* Returns the channel structure corresponding to the channel in the current
-* data packet (ses.payload must be positioned appropriately) */
+* data packet (ses.payload must be positioned appropriately).
-struct Channel* getchannel() {
+* A valid channel is always returns, it will fail fatally with an unknown
+* channel */
+static struct Channel* getchannel_msg(const char* kind) {
 	unsigned int chan;
 	chan = buf_getint(ses.payload);
 	if (chan >= ses.chansize || ses.channels[chan] == NULL) {
-		return NULL;
+		if (kind) {
+			dropbear_exit("%s for unknown channel %d", kind, chan);
+		} else {
+			dropbear_exit("Unknown channel %d", chan);
+		}
 	}
 	return ses.channels[chan];
+}
+struct Channel* getchannel() {
+	return getchannel_msg(NULL);
 }
 /* Iterate through the channels, performing IO if available */
 void channelio(fd_set *readfds, fd_set *writefds) {
 	struct Channel *channel;
 	unsigned int i;
-	int ret;
 	/* iterate through all the possible channels */
 	for (i = 0; i < ses.chansize; i++) {
 		channel = ses.channels[i];
 #endif
 		/* write to program/pipe stdin */
 		if (channel->writefd >= 0 && FD_ISSET(channel->writefd, writefds)) {
 			if (channel->initconn) {
+				/* XXX could this go somewhere cleaner? */
 				check_in_progress(channel);
 				continue; /* Important not to use the channel after
 							 check_in_progress(), as it may be NULL */
 			}
 			writechannel(channel, channel->writefd, channel->writebuf);
 	TRACE(("writebuf size %d extrabuf ptr 0x%x extrabuf size %d",
 				cbuf_getused(channel->writebuf),
 				channel->writebuf,
 				channel->writebuf ? 0 : cbuf_getused(channel->extrabuf)))
+	/* XXX not good, doesn't flush out */
+	if (channel->recv_close) {
+		if (! channel->sent_close) {
+			TRACE(("Sending MSG_CHANNEL_CLOSE in response to same."))
+			send_msg_channel_close(channel);
+		}
+		remove_channel(channel);
+		return;
+	}
 	/* server chansession channels are special, since readfd mightn't
 	 * close in the case of "sleep 4 & echo blah" until the sleep is up */
 	if (channel->type->check_close) {
 		if (channel->type->check_close(channel)) {
 			close_write_fd(channel);
 	if (!channel->sent_close
 		&& channel->writefd == FD_CLOSED
 		&& channel->readfd == FD_CLOSED
 		&& (channel->extrabuf != NULL || channel->errfd == FD_CLOSED)) {
 		send_msg_channel_close(channel);
+	}
+	/* XXX blah */
+	if (channel->recv_eof &&
+		(cbuf_getused(channel->writebuf) == 0
+			&& (channel->extrabuf == NULL
+					|| cbuf_getused(channel->extrabuf) == 0))) {
+		close_write_fd(channel);
 	}
 	/* When either party wishes to terminate the channel, it sends
 	 * SSH_MSG_CHANNEL_CLOSE.  Upon receiving this message, a party MUST
 	 * send back a SSH_MSG_CHANNEL_CLOSE unless it has already sent this
 	 * the party may then reuse the channel number.  A party MAY send
 	 * SSH_MSG_CHANNEL_CLOSE without having sent or received
 	 * SSH_MSG_CHANNEL_EOF.
 	 * (from draft-ietf-secsh-connect)
 	 */
-	if (channel->recv_close) {
-		if (! channel->sent_close) {
-			TRACE(("Sending MSG_CHANNEL_CLOSE in response to same."))
-			send_msg_channel_close(channel);
-		}
-		remove_channel(channel);
-	}
 }
 /* Check whether a deferred (EINPROGRESS) connect() was successful, and
 * if so, set up the channel properly. Otherwise, the channel is cleaned up, so
 		TRACE(("leave check_in_progress: success"))
 	}
 }
 /* Send the close message and set the channel as closed */
 static void send_msg_channel_close(struct Channel *channel) {
 	TRACE(("enter send_msg_channel_close"))
 	if (channel->type->closehandler) {
 	buf_putbyte(ses.writepayload, SSH_MSG_CHANNEL_CLOSE);
 	buf_putint(ses.writepayload, channel->remotechan);
 	encrypt_packet();
+	/* XXX is setting sent_eof required? */
 	channel->sent_eof = 1;
 	channel->sent_close = 1;
 	TRACE(("leave send_msg_channel_close"))
 }
 	}
 	cbuf_incrread(cbuf, len);
 	channel->recvdonelen += len;
-	if (fd == channel->writefd && cbuf_getused(cbuf) == 0 && channel->recv_eof) {
-		/* Check if we're closing up */
-		close_write_fd(channel);
-		TRACE(("leave writechannel: recv_eof set"))
-		return;
-	}
 	/* Window adjust handling */
 	if (channel->recvdonelen >= RECV_WINDOWEXTEND) {
 		/* Set it back to max window */
 		send_msg_channel_window_adjust(channel, channel->recvdonelen);
 		channel->recvwindow += channel->recvdonelen;
 	dropbear_assert(channel->recvwindow <= RECV_MAXWINDOW);
 	dropbear_assert(channel->recvwindow <= cbuf_getavail(channel->writebuf));
 	dropbear_assert(channel->extrabuf == NULL ||
 			channel->recvwindow <= cbuf_getavail(channel->extrabuf));
 	TRACE(("leave writechannel"))
 }
 /* Set the file descriptors for the main select in session.c
 	struct Channel * channel;
 	TRACE(("enter recv_msg_channel_eof"))
-	channel = getchannel();
+	channel = getchannel_msg("EOF");
-	if (channel == NULL) {
-		dropbear_exit("EOF for unknown channel");
-	}
 	channel->recv_eof = 1;
-	if (cbuf_getused(channel->writebuf) == 0
-			&& (channel->extrabuf == NULL
+	check_close(channel);
-					|| cbuf_getused(channel->extrabuf) == 0)) {
-		close_write_fd(channel);
-	}
 	TRACE(("leave recv_msg_channel_eof"))
 }
 /* Handle channel closure(), respond in kind and close the channels */
 	struct Channel * channel;
 	TRACE(("enter recv_msg_channel_close"))
-	channel = getchannel();
+	channel = getchannel_msg("Close");
-	if (channel == NULL) {
-		/* disconnect ? */
+	/* XXX eof required? */
-		dropbear_exit("Close for unknown channel");
-	}
 	channel->recv_eof = 1;
 	channel->recv_close = 1;
-	if (channel->sent_close) {
+	check_close(channel);
-		remove_channel(channel);
-	}
 	TRACE(("leave recv_msg_channel_close"))
 }
 /* Remove a channel entry, this is only executed after both sides have sent
 * channel close */
 static void remove_channel(struct Channel * channel) {
 	TRACE(("enter remove_channel"))
 	TRACE(("channel index is %d", channel->index))
+	/* XXX shuold we assert for sent_closed and recv_closed?
+	 * but we also cleanup manually, maybe we need a flag. */
 	cbuf_free(channel->writebuf);
 	channel->writebuf = NULL;
 	if (channel->extrabuf) {
 		cbuf_free(channel->extrabuf);
 		channel->extrabuf = NULL;
 	}
 	/* close the FDs in case they haven't been done
-	 * yet (ie they were shutdown etc */
+	 * yet (they might have been shutdown etc) */
 	close(channel->writefd);
 	close(channel->readfd);
 	close(channel->errfd);
 	channel->typedata = NULL;
 	struct Channel *channel;
 	TRACE(("enter recv_msg_channel_request"))
 	channel = getchannel();
-	if (channel == NULL) {
-		/* disconnect ? */
-		dropbear_exit("Unknown channel");
-	}
 	if (channel->type->reqhandler) {
 		channel->type->reqhandler(channel);
 	} else {
 		send_msg_channel_failure(channel);
 * if it is extended data. if it is extended, then the type is in
 * exttype */
 static void send_msg_channel_data(struct Channel *channel, int isextended,
 		unsigned int exttype) {
-	buffer *buf;
 	int len;
-	unsigned int maxlen;
+	size_t maxlen, size_pos;
 	int fd;
 /*	TRACE(("enter send_msg_channel_data"))
 	TRACE(("extended = %d type = %d", isextended, exttype))*/
 	maxlen = MIN(channel->transwindow, channel->transmaxpacket);
 	/* -(1+4+4) is SSH_MSG_CHANNEL_DATA, channel number, string length, and
 	 * exttype if is extended */
 	maxlen = MIN(maxlen,
 			ses.writepayload->size - 1 - 4 - 4 - (isextended ? 4 : 0));
+	TRACE(("maxlen %d", maxlen))
 	if (maxlen == 0) {
 		TRACE(("leave send_msg_channel_data: no window"))
-		return; /* the data will get written later */
+		return;
 	}
+	buf_putbyte(ses.writepayload,
+			isextended ? SSH_MSG_CHANNEL_EXTENDED_DATA : SSH_MSG_CHANNEL_DATA);
+	buf_putint(ses.writepayload, channel->remotechan);
+	if (isextended) {
+		buf_putint(ses.writepayload, exttype);
+	}
+	/* a dummy size first ...*/
+	size_pos = ses.writepayload->pos;
+	buf_putint(ses.writepayload, 0);
 	/* read the data */
-	TRACE(("maxlen %d", maxlen))
+	len = read(fd, buf_getwriteptr(ses.writepayload, maxlen), maxlen);
-	buf = buf_new(maxlen);
-	TRACE(("buf pos %d data %x", buf->pos, buf->data))
-	len = read(fd, buf_getwriteptr(buf, maxlen), maxlen);
 	if (len <= 0) {
-		/* on error/eof, send eof */
 		if (len == 0 || errno != EINTR) {
 			close_read_fd(channel, fd);
 		}
-		buf_free(buf);
+		ses.writepayload->len = ses.writepayload->pos = 0;
-		buf = NULL;
 		TRACE(("leave send_msg_channel_data: read err or EOF for fd %d",
 					channel->index));
 		return;
 	}
-	buf_incrlen(buf, len);
+	buf_incrwritepos(ses.writepayload, len);
+	/* ... real size here */
-	buf_putbyte(ses.writepayload,
+	buf_setpos(ses.writepayload, size_pos);
-			isextended ? SSH_MSG_CHANNEL_EXTENDED_DATA : SSH_MSG_CHANNEL_DATA);
+	buf_putint(ses.writepayload, len);
-	buf_putint(ses.writepayload, channel->remotechan);
-	if (isextended) {
-		buf_putint(ses.writepayload, exttype);
-	}
-	buf_putstring(ses.writepayload, buf_getptr(buf, len), len);
-	buf_free(buf);
-	buf = NULL;
 	channel->transwindow -= len;
 	encrypt_packet();
 	TRACE(("leave send_msg_channel_data"))
 void recv_msg_channel_data() {
 	struct Channel *channel;
 	channel = getchannel();
-	if (channel == NULL) {
-		dropbear_exit("Unknown channel");
-	}
 	common_recv_msg_channel_data(channel, channel->writefd, channel->writebuf);
 }
 /* Shared for data and stderr data - when we receive data, put it in a buffer
 	struct Channel * channel;
 	unsigned int incr;
 	channel = getchannel();
-	if (channel == NULL) {
-		dropbear_exit("Unknown channel");
-	}
 	incr = buf_getint(ses.payload);
 	TRACE(("received window increment %d", incr))
 	incr = MIN(incr, MAX_TRANS_WIN_INCR);
 	}
 	/* Get the channel type. Client and server style invokation will set up a
 	 * different list for ses.chantypes at startup. We just iterate through
 	 * this list and find the matching name */
+	/* XXX fugly */
 	for (cp = &ses.chantypes[0], chantype = (*cp);
 			chantype != NULL;
 			cp++, chantype = (*cp)) {
 		if (strcmp(type, chantype->name) == 0) {
 			break;
 		goto failure;
 	}
 	if (channel->type->inithandler) {
 		ret = channel->type->inithandler(channel);
+		if (ret == SSH_OPEN_IN_PROGRESS) {
+			/* We'll send the confirmation later */
+			goto cleanup;
+		}
 		if (ret > 0) {
-			if (ret == SSH_OPEN_IN_PROGRESS) {
-				/* We'll send the confirmation later */
-				goto cleanup;
-			}
 			errtype = ret;
 			delete_channel(channel);
 			TRACE(("inithandler returned failure %d", ret))
 			goto failure;
 		}
 	int ret;
 	TRACE(("enter recv_msg_channel_open_confirmation"))
 	channel = getchannel();
-	if (channel == NULL) {
-		dropbear_exit("Unknown channel");
-	}
 	if (!channel->await_open) {
 		dropbear_exit("unexpected channel reply");
 	}
 	channel->await_open = 0;
 void recv_msg_channel_open_failure() {
 	struct Channel * channel;
 	channel = getchannel();
-	if (channel == NULL) {
-		dropbear_exit("Unknown channel");
-	}
 	if (!channel->await_open) {
 		dropbear_exit("unexpected channel reply");
 	}
 	channel->await_open = 0;

Mercurial > dropbear

comparison common-channel.c @ 362:1c7bf9cec6c8 channel-fix