Attachment #1707 for bug #1664

Lines 70-73 void client_register_global_confirm(global_confirm_cb , void ); Link Here

(-)a/clientloop.h (-1 / +1 lines)
70		70
71	void muxserver_listen(void);	71	void muxserver_listen(void);
72	int muxserver_accept_control(void);	72	int muxserver_accept_control(void);
73	void muxclient(const char *);	73	void muxclient(const char , int, char *);




{
	Buffer m;
	Channel *c;
	int client_fd, new_fd[3], ver, allowed, window, packetmax, ask;
	socklen_t addrlen;
	struct sockaddr_storage addr;
	struct mux_session_confirm_ctx *cctx;

		return 0;
	}

	allowed = 1;
	mux_command = buffer_get_int(&m);
	flags = buffer_get_int(&m);

	/* Process extra arguments and ask user for permission */
	allowed = 1;
	ask = (options.control_master == SSHCTL_MASTER_ASK ||
	       options.control_master == SSHCTL_MASTER_AUTO_ASK);

	switch (mux_command) {
	case SSHMUX_COMMAND_OPEN:
		if (ask)
		    options.control_master == SSHCTL_MASTER_AUTO_ASK)
			allowed = ask_permission("Allow shared connection "
						 "to %s? ", host);
		/* continue below */
		break;
	case SSHMUX_COMMAND_TERMINATE:
		if (ask)
		    options.control_master == SSHCTL_MASTER_AUTO_ASK)
			allowed = ask_permission("Terminate shared connection "
						 "to %s? ", host);
		break;
			start_close = 1;
		/* FALLTHROUGH */
	case SSHMUX_COMMAND_ALIVE_CHECK:
		/* Reply for SSHMUX_COMMAND_TERMINATE and ALIVE_CHECK */
		buffer_clear(&m);
		buffer_put_int(&m, allowed);
		buffer_put_int(&m, getpid());
		if (ssh_msg_send(client_fd, SSHMUX_VER, &m) == -1) {
			error("%s: client msg_send failed", __func__);
			close(client_fd);
			buffer_free(&m);
			return start_close;
		}
		buffer_free(&m);
		close(client_fd);
		return start_close;
	default:
		error("Unsupported command %d", mux_command);
		buffer_free(&m);
		close(client_fd);
		return 0;
	}

	/* Build response */
	buffer_clear(&m);
	buffer_put_int(&m, allowed);
	buffer_put_int(&m, getpid());

	switch (mux_command) {
	case SSHMUX_COMMAND_OPEN:
	case SSHMUX_COMMAND_ALIVE_CHECK:
		break;
	case SSHMUX_COMMAND_TERMINATE:
		if (allowed)
 			start_close = 1;
		break;
	default:
		error("Unsupported command %d", mux_command);
		goto cleanup;
 	}
	if (!allowed)
		error("Refused control connection");

	/* Send response */
	if (ssh_msg_send(client_fd, SSHMUX_VER, &m) == -1) {
		error("%s: client msg_send failed", __func__);
		goto cleanup;
		buffer_free(&m);
		return 0;
	}

	if ((mux_command != SSHMUX_COMMAND_OPEN) || !allowed) {
	cleanup:
 		buffer_free(&m);
		close(client_fd);
		return start_close;
 	}
 
	/* Continue SSHMUX_COMMAND_OPEN processing */
	buffer_clear(&m);
	if (ssh_msg_recv(client_fd, &m) == -1) {
		error("%s: client msg_recv failed", __func__);


/* Multiplex client main loop. */
void
muxclient(const char *path, int ac, char **av)
{
	struct sockaddr_un addr;
	int i, r, fd, sock, exitval[2], num_env;

	extern char **environ;
	u_int allowed, flags;

	/* check arguments */
	switch (muxclient_command) {
	case 0:
		muxclient_command = SSHMUX_COMMAND_OPEN;
	case SSHMUX_COMMAND_OPEN:
		break;
	default:
		if (ac != 0)
			fatal("Bad number of arguments for control command");
	}

	switch (options.control_master) {
	case SSHCTL_MASTER_AUTO:


	buffer_init(&m);

	/* Build command header */
	buffer_put_int(&m, muxclient_command);
	buffer_put_int(&m, flags);

	/* Add command specific data */
	switch (muxclient_command) {
	default:
		break;
	}
	
	/* Send our command to server */
	if (ssh_msg_send(sock, SSHMUX_VER, &m) == -1) {
		error("%s: msg_send", __func__);
 muxerr:

	}
	muxserver_pid = buffer_get_int(&m);

	buffer_clear(&m);

	switch (muxclient_command) {
	case SSHMUX_COMMAND_ALIVE_CHECK:
		fprintf(stderr, "Master running (pid=%d)\r\n",

		fprintf(stderr, "Exit request sent.\r\n");
		exit(0);
	case SSHMUX_COMMAND_OPEN:
		buffer_clear(&m);
		buffer_put_cstring(&m, term ? term : "");
		if (options.escape_char == SSH_ESCAPECHAR_NONE)
			buffer_put_int(&m, 0xffffffff);

Lines 188-194 static int ssh_session2(void); Link Here

(-)a/ssh.c (-2 / +2 lines)
188	static void load_public_identity_files(void);	188	static void load_public_identity_files(void);
189		189
190	/* from muxclient.c */	190	/* from muxclient.c */
191	void muxclient(const char *);	191	void muxclient(const char , int ac, char *av);
192	void muxserver_listen(void);	192	void muxserver_listen(void);
193		193
194	/*	194	/*
Lines 683-689 main(int ac, char **av) Link Here
683	if (muxclient_command != 0 && options.control_path == NULL)	683	if (muxclient_command != 0 && options.control_path == NULL)
684	fatal("No ControlPath specified for \"-O\" command");	684	fatal("No ControlPath specified for \"-O\" command");
685	if (options.control_path != NULL)	685	if (options.control_path != NULL)
686	muxclient(options.control_path);	686	muxclient(options.control_path, ac, av);
687		687
688	timeout_ms = options.connection_timeout * 1000;	688	timeout_ms = options.connection_timeout * 1000;
689		689

Return to bug 1664

Lines 208-214 muxserver_accept_control(void) Link Here

(-)a/mux.c (-47 / +56 lines)
208	{	208	{
209	Buffer m;	209	Buffer m;
210	Channel *c;	210	Channel *c;
211	int client_fd, new_fd[3], ver, allowed, window, packetmax;	211	int client_fd, new_fd[3], ver, allowed, window, packetmax, ask;
212	socklen_t addrlen;	212	socklen_t addrlen;
213	struct sockaddr_storage addr;	213	struct sockaddr_storage addr;
214	struct mux_session_confirm_ctx *cctx;	214	struct mux_session_confirm_ctx *cctx;
Lines 259-325 muxserver_accept_control(void) Link Here
259	return 0;	259	return 0;
260	}	260	}
261		261
262	allowed = 1;
263	mux_command = buffer_get_int(&m);	262	mux_command = buffer_get_int(&m);
264	flags = buffer_get_int(&m);	263	flags = buffer_get_int(&m);
265		264
266	buffer_clear(&m);	265	/* Process extra arguments and ask user for permission */
		266	allowed = 1;
		267	ask = (options.control_master == SSHCTL_MASTER_ASK \|\|
		268	options.control_master == SSHCTL_MASTER_AUTO_ASK);
267		269
268	switch (mux_command) {	270	switch (mux_command) {
269	case SSHMUX_COMMAND_OPEN:	271	case SSHMUX_COMMAND_OPEN:
270	if (options.control_master == SSHCTL_MASTER_ASK \|\|	272	if (ask)
271	options.control_master == SSHCTL_MASTER_AUTO_ASK)
272	allowed = ask_permission("Allow shared connection "	273	allowed = ask_permission("Allow shared connection "
273	"to %s? ", host);	274	"to %s? ", host);
274	/* continue below */
275	break;	275	break;
276	case SSHMUX_COMMAND_TERMINATE:	276	case SSHMUX_COMMAND_TERMINATE:
277	if (options.control_master == SSHCTL_MASTER_ASK \|\|	277	if (ask)
278	options.control_master == SSHCTL_MASTER_AUTO_ASK)
279	allowed = ask_permission("Terminate shared connection "	278	allowed = ask_permission("Terminate shared connection "
280	"to %s? ", host);	279	"to %s? ", host);
281	if (allowed)	280	break;
282	start_close = 1;
283	/* FALLTHROUGH */
284	case SSHMUX_COMMAND_ALIVE_CHECK:
285	/* Reply for SSHMUX_COMMAND_TERMINATE and ALIVE_CHECK */
286	buffer_clear(&m);
287	buffer_put_int(&m, allowed);
288	buffer_put_int(&m, getpid());
289	if (ssh_msg_send(client_fd, SSHMUX_VER, &m) == -1) {
290	error("%s: client msg_send failed", __func__);
291	close(client_fd);
292	buffer_free(&m);
293	return start_close;
294	}
295	buffer_free(&m);
296	close(client_fd);
297	return start_close;
298	default:
299	error("Unsupported command %d", mux_command);
300	buffer_free(&m);
301	close(client_fd);
302	return 0;
303	}	281	}
304		282
305	/* Reply for SSHMUX_COMMAND_OPEN */	283	/* Build response */
306	buffer_clear(&m);	284	buffer_clear(&m);
307	buffer_put_int(&m, allowed);	285	buffer_put_int(&m, allowed);
308	buffer_put_int(&m, getpid());	286	buffer_put_int(&m, getpid());
		287
		288	switch (mux_command) {
		289	case SSHMUX_COMMAND_OPEN:
		290	case SSHMUX_COMMAND_ALIVE_CHECK:
		291	break;
		292	case SSHMUX_COMMAND_TERMINATE:
		293	if (allowed)
		294	start_close = 1;
		295	break;
		296	default:
		297	error("Unsupported command %d", mux_command);
		298	goto cleanup;
		299	}
		300	if (!allowed)
		301	error("Refused control connection");
		302
		303	/* Send response */
309	if (ssh_msg_send(client_fd, SSHMUX_VER, &m) == -1) {	304	if (ssh_msg_send(client_fd, SSHMUX_VER, &m) == -1) {
310	error("%s: client msg_send failed", __func__);	305	error("%s: client msg_send failed", __func__);
311	close(client_fd);	306	goto cleanup;
312	buffer_free(&m);
313	return 0;
314	}	307	}
315		308
316	if (!allowed) {	309	if ((mux_command != SSHMUX_COMMAND_OPEN) \|\| !allowed) {
317	error("Refused control connection");	310	cleanup:
		311	buffer_free(&m);
318	close(client_fd);	312	close(client_fd);
319	buffer_free(&m);	313	return start_close;
320	return 0;	314	}
321	}	315
322		316	/* Continue SSHMUX_COMMAND_OPEN processing */
323	buffer_clear(&m);	317	buffer_clear(&m);
324	if (ssh_msg_recv(client_fd, &m) == -1) {	318	if (ssh_msg_recv(client_fd, &m) == -1) {
325	error("%s: client msg_recv failed", __func__);	319	error("%s: client msg_recv failed", __func__);
Lines 487-493 env_permitted(char *env) Link Here
487		481
488	/* Multiplex client main loop. */	482	/* Multiplex client main loop. */
489	void	483	void
490	muxclient(const char *path)	484	muxclient(const char path, int ac, char *av)
491	{	485	{
492	struct sockaddr_un addr;	486	struct sockaddr_un addr;
493	int i, r, fd, sock, exitval[2], num_env;	487	int i, r, fd, sock, exitval[2], num_env;
Lines 496-503 muxclient(const char *path) Link Here
496	extern char **environ;	490	extern char **environ;
497	u_int allowed, flags;	491	u_int allowed, flags;
498		492
499	if (muxclient_command == 0)	493	/* check arguments */
		494	switch (muxclient_command) {
		495	case 0:
500	muxclient_command = SSHMUX_COMMAND_OPEN;	496	muxclient_command = SSHMUX_COMMAND_OPEN;
		497	case SSHMUX_COMMAND_OPEN:
		498	break;
		499	default:
		500	if (ac != 0)
		501	fatal("Bad number of arguments for control command");
		502	}
501		503
502	switch (options.control_master) {	504	switch (options.control_master) {
503	case SSHCTL_MASTER_AUTO:	505	case SSHCTL_MASTER_AUTO:
Lines 562-570 muxclient(const char *path) Link Here
562		564
563	buffer_init(&m);	565	buffer_init(&m);
564		566
565	/* Send our command to server */	567	/* Build command header */
566	buffer_put_int(&m, muxclient_command);	568	buffer_put_int(&m, muxclient_command);
567	buffer_put_int(&m, flags);	569	buffer_put_int(&m, flags);
		570
		571	/* Add command specific data */
		572	switch (muxclient_command) {
		573	default:
		574	break;
		575	}
		576
		577	/* Send our command to server */
568	if (ssh_msg_send(sock, SSHMUX_VER, &m) == -1) {	578	if (ssh_msg_send(sock, SSHMUX_VER, &m) == -1) {
569	error("%s: msg_send", __func__);	579	error("%s: msg_send", __func__);
570	muxerr:	580	muxerr:
Lines 599-606 muxclient(const char *path) Link Here
599	}	609	}
600	muxserver_pid = buffer_get_int(&m);	610	muxserver_pid = buffer_get_int(&m);
601		611
602	buffer_clear(&m);
603
604	switch (muxclient_command) {	612	switch (muxclient_command) {
605	case SSHMUX_COMMAND_ALIVE_CHECK:	613	case SSHMUX_COMMAND_ALIVE_CHECK:
606	fprintf(stderr, "Master running (pid=%d)\r\n",	614	fprintf(stderr, "Master running (pid=%d)\r\n",
Lines 610-615 muxclient(const char *path) Link Here
610	fprintf(stderr, "Exit request sent.\r\n");	618	fprintf(stderr, "Exit request sent.\r\n");
611	exit(0);	619	exit(0);
612	case SSHMUX_COMMAND_OPEN:	620	case SSHMUX_COMMAND_OPEN:
		621	buffer_clear(&m);
613	buffer_put_cstring(&m, term ? term : "");	622	buffer_put_cstring(&m, term ? term : "");
614	if (options.escape_char == SSH_ESCAPECHAR_NONE)	623	if (options.escape_char == SSH_ESCAPECHAR_NONE)
615	buffer_put_int(&m, 0xffffffff);	624	buffer_put_int(&m, 0xffffffff);