Attachment #288 for bug #463




extern Buffer input, output;
extern Buffer auth_debug;
extern int auth_debug_init;
extern Buffer loginmsg;

/* State exported from the child */


int mm_answer_pty(int, Buffer *);
int mm_answer_pty_cleanup(int, Buffer *);
int mm_answer_term(int, Buffer *);
int mm_answer_getloginmsg(int, Buffer *);
int mm_answer_rsa_keyallowed(int, Buffer *);
int mm_answer_rsa_challenge(int, Buffer *);
int mm_answer_rsa_response(int, Buffer *);

    {MONITOR_REQ_PTY, 0, mm_answer_pty},
    {MONITOR_REQ_PTYCLEANUP, 0, mm_answer_pty_cleanup},
    {MONITOR_REQ_TERM, 0, mm_answer_term},
    {MONITOR_REQ_LOGINMSG, 0, mm_answer_getloginmsg},
    {0, 0, NULL}
};


    {MONITOR_REQ_PTY, MON_ONCE, mm_answer_pty},
    {MONITOR_REQ_PTYCLEANUP, MON_ONCE, mm_answer_pty_cleanup},
    {MONITOR_REQ_TERM, 0, mm_answer_term},
    {MONITOR_REQ_LOGINMSG, 0, mm_answer_getloginmsg},
    {0, 0, NULL}
};


	if (!no_pty_flag) {
		monitor_permit(mon_dispatch, MONITOR_REQ_PTY, 1);
		monitor_permit(mon_dispatch, MONITOR_REQ_PTYCLEANUP, 1);
		monitor_permit(mon_dispatch, MONITOR_REQ_LOGINMSG, 1);
	}

	for (;;)

		mm_session_close(s);
	buffer_put_int(m, 0);
	mm_request_send(socket, MONITOR_ANS_PTY, m);
	return (0);
}

int
mm_answer_getloginmsg(int socket, Buffer *m)
{
	debug3("%s entering", __func__);

	buffer_clear(m);
	/* retrieve stored login message then clear buffer */
	buffer_append(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg));
	buffer_clear(&loginmsg);

	mm_request_send(socket, MONITOR_ANS_LOGINMSG, m);
	return (0);
}


Lines 44-49 Link Here

(-)monitor.h (+1 lines)
44	MONITOR_REQ_KEYEXPORT,	44	MONITOR_REQ_KEYEXPORT,
45	MONITOR_REQ_PTY, MONITOR_ANS_PTY,	45	MONITOR_REQ_PTY, MONITOR_ANS_PTY,
46	MONITOR_REQ_PTYCLEANUP,	46	MONITOR_REQ_PTYCLEANUP,
		47	MONITOR_REQ_LOGINMSG, MONITOR_ANS_LOGINMSG,
47	MONITOR_REQ_SESSKEY, MONITOR_ANS_SESSKEY,	48	MONITOR_REQ_SESSKEY, MONITOR_ANS_SESSKEY,
48	MONITOR_REQ_SESSID,	49	MONITOR_REQ_SESSID,
49	MONITOR_REQ_RSAKEYALLOWED, MONITOR_ANS_RSAKEYALLOWED,	50	MONITOR_REQ_RSAKEYALLOWED, MONITOR_ANS_RSAKEYALLOWED,




extern z_stream outgoing_stream;
extern struct monitor *pmonitor;
extern Buffer input, output;
extern Buffer loginmsg;

void
mm_request_send(int socket, enum monitor_reqtype type, Buffer *m)


	/* unlink pty from session */
	s->ttyfd = -1;
}

char *
mm_get_loginmsg(void)
{
	debug3("%s entering", __func__);

	buffer_init(&loginmsg);
	mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_LOGINMSG, &loginmsg);

	debug3("%s waiting for MONITOR_ANS_LOGINMSG", __func__);
	mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_LOGINMSG,
	    &loginmsg);
	return(buffer_ptr(&loginmsg));
}

/* Request process termination */

Lines 58-63 Link Here

(-)monitor_wrap.h (+1 lines)
58	void mm_terminate(void);	58	void mm_terminate(void);
59	int mm_pty_allocate(int , int , char *, int);	59	int mm_pty_allocate(int , int , char *, int);
60	void mm_session_pty_cleanup2(void *);	60	void mm_session_pty_cleanup2(void *);
		61	char *mm_get_loginmsg(void);
61		62
62	/* SSHv1 interfaces */	63	/* SSHv1 interfaces */
63	void mm_ssh1_session_id(u_char *);	64	void mm_ssh1_session_id(u_char *);




extern u_int utmp_len;
extern int startup_pipe;
extern void destroy_sensitive_data(void);
extern Buffer loginmsg;

/* original command from peer. */
const char *original_command = NULL;

void
do_login(Session *s, const char *command)
{
	char *time_string;
	socklen_t fromlen;
	struct sockaddr_storage from;
	struct passwd * pw = s->pw;

	if (check_quietlogin(s, command))
		return;

	/* print login messages */
	printf("%s", get_loginmsg());
		if (strchr(time_string, '\n'))
			*strchr(time_string, '\n') = 0;
		if (strcmp(s->hostname, "") == 0)
			printf("Last login: %s\r\n", time_string);
		else
			printf("Last login: %s from %s\r\n", time_string,
			    s->hostname);
	}

	do_motd();
}

		packet_disconnect("Protocol error: you already have a pty.");
		return 0;
	}
	/* Get the time and hostname when the user last logged in. */
	if (options.print_lastlog) {
		s->hostname[0] = '\0';
		s->last_login_time = get_last_login_time(s->pw->pw_uid,
		    s->pw->pw_name, s->hostname, sizeof(s->hostname));
	}

	s->term = packet_get_string(&len);


		return 0;
	}
	debug("session_pty_req: session %d alloc %s", s->self, s->tty);

	/* copy loginmsg from monitor to display after fork */
	if (use_privsep)
		PRIVSEP(get_loginmsg());

	/* for SSH1 the tty modes length is not given */
	if (!compat20)

Lines 39-47 Link Here

(-)session.h (-3 lines)
39	int ptyfd, ttyfd, ptymaster;	39	int ptyfd, ttyfd, ptymaster;
40	u_int row, col, xpixel, ypixel;	40	u_int row, col, xpixel, ypixel;
41	char tty[TTYSZ];	41	char tty[TTYSZ];
42	/* last login */
43	char hostname[MAXHOSTNAMELEN];
44	time_t last_login_time;
45	/* X11 */	42	/* X11 */
46	u_int display_number;	43	u_int display_number;
47	char *display;	44	char *display;

Lines 192-197 Link Here

(-)sshd.c (+6 lines)
192	int use_privsep;	192	int use_privsep;
193	struct monitor *pmonitor;	193	struct monitor *pmonitor;
194		194
		195	/* message to be displayed after login */
		196	Buffer loginmsg;
		197
195	/* Prototypes for various functions defined later in this file. */	198	/* Prototypes for various functions defined later in this file. */
196	void destroy_sensitive_data(void);	199	void destroy_sensitive_data(void);
197	void demote_sensitive_data(void);	200	void demote_sensitive_data(void);
Lines 1439-1444 Link Here
1439	if (use_privsep)	1442	if (use_privsep)
1440	if ((authctxt = privsep_preauth()) != NULL)	1443	if ((authctxt = privsep_preauth()) != NULL)
1441	goto authenticated;	1444	goto authenticated;
		1445
		1446	/* prepare buffer to collect authentication messages */
		1447	buffer_init(&loginmsg);
1442		1448
1443	/* perform the key exchange */	1449	/* perform the key exchange */
1444	/* authenticate user and start session */	1450	/* authenticate user and start session */

Lines 45-51 Link Here

(-)sshlogin.c (-2 / +48 lines)
45	#include <utmp.h>	45	#include <utmp.h>
46	#include "sshlogin.h"	46	#include "sshlogin.h"
47	#include "log.h"	47	#include "log.h"
		48	#include "buffer.h"
		49	#include "servconf.h"
48		50
		51	extern Buffer loginmsg;
		52	extern ServerOptions options;
		53
49	/*	54	/*
50	* Returns the time when the user last logged in. Returns 0 if the	55	* Returns the time when the user last logged in. Returns 0 if the
51	* information is not available. This must be called before record_login.	56	* information is not available. This must be called before record_login.
Lines 78-86 Link Here
78	return ll.ll_time;	83	return ll.ll_time;
79	}	84	}
80		85
		86	/*
		87	* Returns loginmsg as a printable string.
		88	*/
		89	char *
		90	get_loginmsg(void)
		91	{
		92	buffer_append(&loginmsg, "\0", 1);
		93	return(buffer_ptr(&loginmsg));
		94	}
		95
		96	/*
		97	* Generate and store last login message. This must be done before
		98	* login_login() is called and lastlog is updated.
		99	*/
		100	void
		101	store_lastlog_message(const char *user, uid_t uid)
		102	{
		103	char *time_string, hostname[MAXHOSTNAMELEN], buf[512];
		104	time_t last_login_time;
		105
		106	hostname[0] = '\0';
		107	last_login_time = get_last_login_time(uid, user, hostname,
		108	sizeof(hostname));
		109
		110	if (options.print_lastlog && last_login_time != 0) {
		111	time_string = ctime(&last_login_time);
		112	if (strchr(time_string, '\n'))
		113	*strchr(time_string, '\n') = 0;
		114	if (strcmp(hostname, "") == 0)
		115	snprintf(buf, sizeof(buf), "Last login: %s\r\n",
		116	time_string);
		117	else
		118	snprintf(buf, sizeof(buf), "Last login: %s from %s\r\n",
		119	time_string, hostname);
		120	buffer_append(&loginmsg, buf, strlen(buf));
		121	}
		122	}
		123
81	/*	124	/*
82	* Records that the user has logged in. I these parts of operating systems	125	* Records that the user has logged in. I wish these parts of operating
83	* were more standardized.	126	* systems were more standardized.
84	*/	127	*/
85	void	128	void
86	record_login(pid_t pid, const char ttyname, const char user, uid_t uid,	129	record_login(pid_t pid, const char ttyname, const char user, uid_t uid,
Lines 90-95 Link Here
90	struct lastlog ll;	133	struct lastlog ll;
91	char *lastlog;	134	char *lastlog;
92	struct utmp u;	135	struct utmp u;
		136
		137	/* save previous login details before writing new */
		138	store_lastlog_message(user, uid);
93		139
94	/* Construct an utmp/wtmp entry. */	140	/* Construct an utmp/wtmp entry. */
95	memset(&u, 0, sizeof(u));	141	memset(&u, 0, sizeof(u));

Lines 19-23 Link Here

(-)sshlogin.h (+1 lines)
19	const char , struct sockaddr , socklen_t);	19	const char , struct sockaddr , socklen_t);
20	void record_logout(pid_t, const char *);	20	void record_logout(pid_t, const char *);
21	u_long get_last_login_time(uid_t, const char , char , u_int);	21	u_long get_last_login_time(uid_t, const char , char , u_int);
		22	char *get_loginmsg(void);
22		23
23	#endif	24	#endif

Return to bug 463

Lines 69-74 Link Here

(-)monitor.c (+19 lines)
69	extern Buffer input, output;	69	extern Buffer input, output;
70	extern Buffer auth_debug;	70	extern Buffer auth_debug;
71	extern int auth_debug_init;	71	extern int auth_debug_init;
		72	extern Buffer loginmsg;
72		73
73	/* State exported from the child */	74	/* State exported from the child */
74		75
Lines 110-115 Link Here
110	int mm_answer_pty(int, Buffer *);	111	int mm_answer_pty(int, Buffer *);
111	int mm_answer_pty_cleanup(int, Buffer *);	112	int mm_answer_pty_cleanup(int, Buffer *);
112	int mm_answer_term(int, Buffer *);	113	int mm_answer_term(int, Buffer *);
		114	int mm_answer_getloginmsg(int, Buffer *);
113	int mm_answer_rsa_keyallowed(int, Buffer *);	115	int mm_answer_rsa_keyallowed(int, Buffer *);
114	int mm_answer_rsa_challenge(int, Buffer *);	116	int mm_answer_rsa_challenge(int, Buffer *);
115	int mm_answer_rsa_response(int, Buffer *);	117	int mm_answer_rsa_response(int, Buffer *);
Lines 176-181 Link Here
176	{MONITOR_REQ_PTY, 0, mm_answer_pty},	178	{MONITOR_REQ_PTY, 0, mm_answer_pty},
177	{MONITOR_REQ_PTYCLEANUP, 0, mm_answer_pty_cleanup},	179	{MONITOR_REQ_PTYCLEANUP, 0, mm_answer_pty_cleanup},
178	{MONITOR_REQ_TERM, 0, mm_answer_term},	180	{MONITOR_REQ_TERM, 0, mm_answer_term},
		181	{MONITOR_REQ_LOGINMSG, 0, mm_answer_getloginmsg},
179	{0, 0, NULL}	182	{0, 0, NULL}
180	};	183	};
181		184
Lines 209-214 Link Here
209	{MONITOR_REQ_PTY, MON_ONCE, mm_answer_pty},	212	{MONITOR_REQ_PTY, MON_ONCE, mm_answer_pty},
210	{MONITOR_REQ_PTYCLEANUP, MON_ONCE, mm_answer_pty_cleanup},	213	{MONITOR_REQ_PTYCLEANUP, MON_ONCE, mm_answer_pty_cleanup},
211	{MONITOR_REQ_TERM, 0, mm_answer_term},	214	{MONITOR_REQ_TERM, 0, mm_answer_term},
		215	{MONITOR_REQ_LOGINMSG, 0, mm_answer_getloginmsg},
212	{0, 0, NULL}	216	{0, 0, NULL}
213	};	217	};
214		218
Lines 314-319 Link Here
314	if (!no_pty_flag) {	318	if (!no_pty_flag) {
315	monitor_permit(mon_dispatch, MONITOR_REQ_PTY, 1);	319	monitor_permit(mon_dispatch, MONITOR_REQ_PTY, 1);
316	monitor_permit(mon_dispatch, MONITOR_REQ_PTYCLEANUP, 1);	320	monitor_permit(mon_dispatch, MONITOR_REQ_PTYCLEANUP, 1);
		321	monitor_permit(mon_dispatch, MONITOR_REQ_LOGINMSG, 1);
317	}	322	}
318		323
319	for (;;)	324	for (;;)
Lines 1068-1073 Link Here
1068	mm_session_close(s);	1073	mm_session_close(s);
1069	buffer_put_int(m, 0);	1074	buffer_put_int(m, 0);
1070	mm_request_send(socket, MONITOR_ANS_PTY, m);	1075	mm_request_send(socket, MONITOR_ANS_PTY, m);
		1076	return (0);
		1077	}
		1078
		1079	int
		1080	mm_answer_getloginmsg(int socket, Buffer *m)
		1081	{
		1082	debug3("%s entering", __func__);
		1083
		1084	buffer_clear(m);
		1085	/* retrieve stored login message then clear buffer */
		1086	buffer_append(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg));
		1087	buffer_clear(&loginmsg);
		1088
		1089	mm_request_send(socket, MONITOR_ANS_LOGINMSG, m);
1071	return (0);	1090	return (0);
1072	}	1091	}
1073		1092

Lines 86-91 Link Here

(-)session.c (-17 / +7 lines)
86	extern u_int utmp_len;	86	extern u_int utmp_len;
87	extern int startup_pipe;	87	extern int startup_pipe;
88	extern void destroy_sensitive_data(void);	88	extern void destroy_sensitive_data(void);
		89	extern Buffer loginmsg;
89		90
90	/* original command from peer. */	91	/* original command from peer. */
91	const char *original_command = NULL;	92	const char *original_command = NULL;
Lines 638-644 Link Here
638	void	639	void
639	do_login(Session s, const char command)	640	do_login(Session s, const char command)
640	{	641	{
641	char *time_string;
642	socklen_t fromlen;	642	socklen_t fromlen;
643	struct sockaddr_storage from;	643	struct sockaddr_storage from;
644	struct passwd * pw = s->pw;	644	struct passwd * pw = s->pw;
Lines 668-683 Link Here
668	if (check_quietlogin(s, command))	668	if (check_quietlogin(s, command))
669	return;	669	return;
670		670
671	if (options.print_lastlog && s->last_login_time != 0) {	671	/* print login messages */
672	time_string = ctime(&s->last_login_time);	672	printf("%s", get_loginmsg());
673	if (strchr(time_string, '\n'))
674	*strchr(time_string, '\n') = 0;
675	if (strcmp(s->hostname, "") == 0)
676	printf("Last login: %s\r\n", time_string);
677	else
678	printf("Last login: %s from %s\r\n", time_string,
679	s->hostname);
680	}
681		673
682	do_motd();	674	do_motd();
683	}	675	}
Lines 1370-1381 Link Here
1370	packet_disconnect("Protocol error: you already have a pty.");	1362	packet_disconnect("Protocol error: you already have a pty.");
1371	return 0;	1363	return 0;
1372	}	1364	}
1373	/* Get the time and hostname when the user last logged in. */
1374	if (options.print_lastlog) {
1375	s->hostname[0] = '\0';
1376	s->last_login_time = get_last_login_time(s->pw->pw_uid,
1377	s->pw->pw_name, s->hostname, sizeof(s->hostname));
1378	}
1379		1365
1380	s->term = packet_get_string(&len);	1366	s->term = packet_get_string(&len);
1381		1367
Lines 1406-1411 Link Here
1406	return 0;	1392	return 0;
1407	}	1393	}
1408	debug("session_pty_req: session %d alloc %s", s->self, s->tty);	1394	debug("session_pty_req: session %d alloc %s", s->self, s->tty);
		1395
		1396	/* copy loginmsg from monitor to display after fork */
		1397	if (use_privsep)
		1398	PRIVSEP(get_loginmsg());
1409		1399
1410	/* for SSH1 the tty modes length is not given */	1400	/* for SSH1 the tty modes length is not given */
1411	if (!compat20)	1401	if (!compat20)

Lines 59-64 Link Here

(-)monitor_wrap.c (+15 lines)
59	extern z_stream outgoing_stream;	59	extern z_stream outgoing_stream;
60	extern struct monitor *pmonitor;	60	extern struct monitor *pmonitor;
61	extern Buffer input, output;	61	extern Buffer input, output;
		62	extern Buffer loginmsg;
62		63
63	void	64	void
64	mm_request_send(int socket, enum monitor_reqtype type, Buffer *m)	65	mm_request_send(int socket, enum monitor_reqtype type, Buffer *m)
Lines 658-663 Link Here
658		659
659	/* unlink pty from session */	660	/* unlink pty from session */
660	s->ttyfd = -1;	661	s->ttyfd = -1;
		662	}
		663
		664	char *
		665	mm_get_loginmsg(void)
		666	{
		667	debug3("%s entering", __func__);
		668
		669	buffer_init(&loginmsg);
		670	mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_LOGINMSG, &loginmsg);
		671
		672	debug3("%s waiting for MONITOR_ANS_LOGINMSG", __func__);
		673	mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_LOGINMSG,
		674	&loginmsg);
		675	return(buffer_ptr(&loginmsg));
661	}	676	}
662		677
663	/* Request process termination */	678	/* Request process termination */