This gets rid of everything related to hpn_buffer_size

Author: rapier1

channels.c

@@ -231,7 +231,6 @@ static void channel_handler_init(struct ssh_channels *sc);
 
 /* default values to enable hpn and the initial buffer size */
 static int hpn_disabled = 0;
-static int hpn_buffer_size = 2 * 1024 * 1024;
 
 /* -- channel core */
 
@@ -3779,11 +3778,10 @@ channel_fwd_bind_addr(struct ssh *ssh, const char *listen_addr, int *wildcardp,
 }
 
 void
-channel_set_hpn(int external_hpn_disabled, int external_hpn_buffer_size)
+channel_set_hpn_disabled(int external_hpn_disabled)
 {
 	hpn_disabled = external_hpn_disabled;
-	hpn_buffer_size = external_hpn_buffer_size;
-	debug("HPN Disabled: %d, HPN Buffer Size: %d", hpn_disabled, hpn_buffer_size);
+	debug("HPN Disabled: %d", hpn_disabled);
 }
 
 static int
@@ -3925,10 +3923,8 @@ channel_setup_fwd_listener_tcpip(struct ssh *ssh, int type,
 		}
 
 		/* Allocate a channel number for the socket. */
-		/* explicitly test for hpn disabled option. if true use smaller window size */
 		c = channel_new(ssh, "port-listener", type, sock, sock, -1,
-		    hpn_disabled ? CHAN_TCP_WINDOW_DEFAULT : hpn_buffer_size,
-		    CHAN_TCP_PACKET_DEFAULT, 0, "port listener", 1);
+		    CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT, 0, "port listener", 1);
 		c->path = xstrdup(host);
 		c->host_port = fwd->connect_port;
 		c->listening_addr = addr == NULL ? NULL : xstrdup(addr);
@@ -5096,8 +5092,7 @@ x11_create_display_inet(struct ssh *ssh, int x11_display_offset,
 		sock = socks[n];
 		nc = channel_new(ssh, "x11-listener",
 		    SSH_CHANNEL_X11_LISTENER, sock, sock, -1,
-				 hpn_disabled ? CHAN_X11_WINDOW_DEFAULT : hpn_buffer_size,
-				 CHAN_X11_PACKET_DEFAULT,
+				 CHAN_X11_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT,
 				 0, "X11 inet listener", 1);
 		nc->single_connection = single_connection;
 		(*chanids)[n] = nc->self;

channels.h

@@ -400,5 +400,5 @@ void	 chan_write_failed(struct ssh *, Channel *);
 void	 chan_obuf_empty(struct ssh *, Channel *);
 
 /* hpn handler */
-void     channel_set_hpn(int, int);
+void     channel_set_hpn_disabled(int);
 #endif

clientloop.c

@@ -1825,9 +1825,8 @@ client_request_x11(struct ssh *ssh, const char *request_type, int rchan)
 		return NULL;
         c = channel_new(ssh, "x11",
 			SSH_CHANNEL_X11_OPEN, sock, sock, -1,
-			/* again is this really necessary for X11? */
-			options.hpn_disabled ? CHAN_TCP_WINDOW_DEFAULT : options.hpn_buffer_size,
-			CHAN_X11_PACKET_DEFAULT, 0, "x11", 1);
+			CHAN_TCP_WINDOW_DEFAULT, CHAN_X11_PACKET_DEFAULT,
+			0, "x11", 1);
 	c->force_drain = 1;
 	return c;
 }
@@ -1862,8 +1861,7 @@ client_request_agent(struct ssh *ssh, const char *request_type, int rchan)
 
 	c = channel_new(ssh, "authentication agent connection",
 			SSH_CHANNEL_OPEN, sock, sock, -1,
-			options.hpn_disabled ? CHAN_X11_WINDOW_DEFAULT : options.hpn_buffer_size,
-			CHAN_TCP_PACKET_DEFAULT, 0,
+			CHAN_X11_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT, 0,
 			"authentication agent connection", 1);
 	c->force_drain = 1;
 	return c;
@@ -1890,8 +1888,7 @@ client_request_tun_fwd(struct ssh *ssh, int tun_mode,
 	debug_f("Tunnel forwarding using interface %s", ifname);
 
         c = channel_new(ssh, "tun", SSH_CHANNEL_OPENING, fd, fd, -1,
-	    options.hpn_disabled ? CHAN_TCP_WINDOW_DEFAULT : options.hpn_buffer_size,
-	    CHAN_TCP_PACKET_DEFAULT, 0, "tun", 1);
+	    CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT, 0, "tun", 1);
 	c->datagram = 1;
 
 

readconf.h

@@ -52,7 +52,6 @@ typedef struct {
 	int     tcp_keep_alive;	/* Set SO_KEEPALIVE. */
 	int     tcp_rcv_buf_poll; /* Option to poll recv buf every window transfer */
 	int     hpn_disabled;     /* Switch to disable HPN buffer management */
-	int     hpn_buffer_size;  /* Size of HPN buffer window */
 	int     hpn_buffer_limit; /* limit local_window_max to 1/2 receive buffer */
 	int	ip_qos_interactive;	/* IP ToS/DSCP/class for interactive */
 	int	ip_qos_bulk;		/* IP ToS/DSCP/class for bulk traffic */

servconf.c

@@ -282,10 +282,6 @@ void
 fill_default_server_options(ServerOptions *options)
 {
 	u_int i;
-	/* needed for hpn socket tests */
-	int sock;
-	int socksize;
-	int socksizelen = sizeof(int);
 
 	/* Portable-specific options */
 	if (options->use_pam == -1)

servconf.h

@@ -200,7 +200,6 @@ typedef struct {
 	int	use_pam;		/* Enable auth via PAM */
         int     tcp_rcv_buf_poll;       /* poll tcp rcv window in autotuning kernels*/
 	int	hpn_disabled;		/* disable hpn functionality. false by default */
-	int	hpn_buffer_size;	/* hpn buffer size - default 2MB */
 	int	none_enabled;		/* Enable NONE cipher switch */
 	int     nonemac_enabled;        /* Enable NONE MAC switch */
 	int     hpn_buffer_limit;       /* limit local_window_max to 1/2 receive buffer */

serverloop.c

@@ -566,8 +566,8 @@ server_request_tun(struct ssh *ssh)
 	debug("Tunnel forwarding using interface %s", ifname);
 
 	c = channel_new(ssh, "tun", SSH_CHANNEL_OPEN, sock, sock, -1,
-			options.hpn_disabled ? CHAN_TCP_WINDOW_DEFAULT : options.hpn_buffer_size,
-			CHAN_TCP_PACKET_DEFAULT, 0, "tun", 1);
+			CHAN_TCP_WINDOW_DEFAULT, CHAN_TCP_PACKET_DEFAULT,
+			0, "tun", 1);
 	c->datagram = 1;
 #if defined(SSH_TUN_FILTER)
 	if (mode == SSH_TUNMODE_POINTOPOINT)

session.c

@@ -2266,8 +2266,7 @@ session_set_fds(struct ssh *ssh, Session *s,
         channel_set_fds(ssh, s->chanid,
 			fdout, fdin, fderr,
 			ignore_fderr ? CHAN_EXTENDED_IGNORE : CHAN_EXTENDED_READ,
-			1, is_tty,
-			options.hpn_disabled ? CHAN_SES_WINDOW_DEFAULT : options.hpn_buffer_size);
+			1, is_tty, CHAN_SES_WINDOW_DEFAULT);
 }
 
 /*

ssh.c

@@ -2133,56 +2133,13 @@ ssh_session2_setup(struct ssh *ssh, int id, int success, void *arg)
 	    NULL, fileno(stdin), command, environ);
 }
 
+/* this used to do a lot more but now it just checks to see
+ * if we are disabling hpn */
 static void
 hpn_options_init(struct ssh *ssh)
 {
-	/*
-	 * We need to check to see if what they want to do about buffer
-	 * sizes here. In a hpn to nonhpn connection we want to limit
-	 * the window size to something reasonable in case the far side
-	 * has the large window bug. In hpn to hpn connection we want to
-	 * use the max window size but allow the user to override it
-	 * lastly if they disabled hpn then use the ssh std window size.
-	 *
-	 * So why don't we just do a getsockopt() here and set the
-	 * ssh window to that? In the case of a autotuning receive
-	 * window the window would get stuck at the initial buffer
-	 * size generally less than 96k. Therefore we need to set the
-	 * maximum ssh window size to the maximum hpn buffer size
-	 * unless the user has specifically set the tcprcvbufpoll
-	 * to no. In which case we *can* just set the window to the
-	 * minimum of the hpn buffer size and tcp receive buffer size.
-	 */
-
-	if (tty_flag)
-		options.hpn_buffer_size = CHAN_SES_WINDOW_DEFAULT;
-	else
-		options.hpn_buffer_size = (2 * 1024 * 1024);
-
-	if (ssh->compat & SSH_BUG_LARGEWINDOW) {
-		debug("HPN to Non-HPN connection");
-	} else {
-		debug("HPN to HPN connection");
-		if (ssh->compat & SSH_HPNSSH) {
-			debug("Using 'hpn' prefixed binaries");
-		}
-		int sock, socksize;
-		socklen_t socksizelen;
-		if (options.tcp_rcv_buf_poll <= 0) {
-			sock = socket(AF_INET, SOCK_STREAM, 0);
-			socksizelen = sizeof(socksize);
-			getsockopt(sock, SOL_SOCKET, SO_RCVBUF,
-				   &socksize, &socksizelen);
-			close(sock);
-			debug("socksize %d", socksize);
-			options.hpn_buffer_size = socksize;
-			debug("HPNBufferSize set to TCP RWIN: %d", options.hpn_buffer_size);
-		}
-	}
-
-	debug("Final hpn_buffer_size = %d", options.hpn_buffer_size);
-
-	channel_set_hpn(options.hpn_disabled, options.hpn_buffer_size);
+	channel_set_hpn_disabled(options.hpn_disabled);
+	debug_f("HPN disabled: %d", options.hpn_disabled);
 }
 
 /* open new channel for a session */
@@ -2203,7 +2160,7 @@ ssh_session2_open(struct ssh *ssh)
 	if (in == -1 || out == -1 || err == -1)
 		fatal("dup() in/out/err failed");
 
-	window = options.hpn_buffer_size;
+	window = CHAN_SES_WINDOW_DEFAULT;
 	packetmax = CHAN_SES_PACKET_DEFAULT;
 	if (tty_flag) {
 		window = CHAN_SES_WINDOW_DEFAULT;

sshd.c

@@ -1068,7 +1068,6 @@ listen_on_addrs(struct listenaddr *la)
 		getsockopt(listen_sock, SOL_SOCKET, SO_RCVBUF,
 				   &socksize, &socksizelen);
 		debug("Server TCP RWIN socket size: %d", socksize);
-		debug("HPN Buffer Size: %d", options.hpn_buffer_size);
 
 		/* Bind the socket to the desired port. */
 		if (bind(listen_sock, ai->ai_addr, ai->ai_addrlen) == -1) {
@@ -2232,7 +2231,7 @@ main(int ac, char **av)
 	free(laddr);
 
 	/* set the HPN options for the child */
-	channel_set_hpn(options.hpn_disabled, options.hpn_buffer_size);
+	channel_set_hpn_disabled(options.hpn_disabled);
 
 	/*
 	 * We don't want to listen forever unless the other side