src/usr.bin/ssh/monitor_wrap.c - diff

Return to monitor_wrap.c CVS log

Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/monitor_wrap.c between version 1.31 and 1.31.2.2

version 1.31, 2003/08/28 12:54:34

version 1.31.2.2, 2004/08/19 22:37:31

Line 63

extern z_stream outgoing_stream;

extern struct monitor *pmonitor;

extern Buffer input, output;

extern Buffer loginmsg;

int

mm_is_monitor(void)

{

* m_pid is only set in the privileged part, and

* points to the unprivileged child.

return (pmonitor && pmonitor->m_pid > 0);

}

void

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

mm_request_send(int sock, enum monitor_reqtype type, Buffer *m)

{

u_int mlen = buffer_len(m);

u_char buf[5];

Line 74

Line 85

PUT_32BIT(buf, mlen + 1);

buf[4] = (u_char) type; /* 1st byte of payload is mesg-type */

if (atomicio(vwrite, socket, buf, sizeof(buf)) != sizeof(buf))

if (atomicio(vwrite, sock, buf, sizeof(buf)) != sizeof(buf))

fatal("%s: write", __func__);

if (atomicio(vwrite, socket, buffer_ptr(m), mlen) != mlen)

if (atomicio(vwrite, sock, buffer_ptr(m), mlen) != mlen)

fatal("%s: write", __func__);

}

void

mm_request_receive(int socket, Buffer *m)

mm_request_receive(int sock, Buffer *m)

{

u_char buf[4];

u_int msg_len;

Line 89

Line 100

debug3("%s entering", __func__);

res = atomicio(read, socket, buf, sizeof(buf));

res = atomicio(read, sock, buf, sizeof(buf));

if (res != sizeof(buf)) {

if (res == 0)

fatal_cleanup();

cleanup_exit(255);

fatal("%s: read: %ld", __func__, (long)res);

}

msg_len = GET_32BIT(buf);

Line 100

Line 111

fatal("%s: read: bad msg_len %d", __func__, msg_len);

buffer_clear(m);

buffer_append_space(m, msg_len);

res = atomicio(read, socket, buffer_ptr(m), msg_len);

res = atomicio(read, sock, buffer_ptr(m), msg_len);

if (res != msg_len)

fatal("%s: read: %ld != msg_len", __func__, (long)res);

}

void

mm_request_receive_expect(int socket, enum monitor_reqtype type, Buffer *m)

mm_request_receive_expect(int sock, enum monitor_reqtype type, Buffer *m)

{

u_char rtype;

debug3("%s entering: type %d", __func__, type);

mm_request_receive(socket, m);

mm_request_receive(sock, m);

rtype = buffer_get_char(m);

if (rtype != type)

fatal("%s: read: rtype %d != type %d", __func__,

Line 176

Line 187

}

struct passwd *

mm_getpwnamallow(const char *login)

mm_getpwnamallow(const char *username)

{

Buffer m;

struct passwd *pw;

Line 185

Line 196

debug3("%s entering", __func__);

buffer_init(&m);

buffer_put_cstring(&m, login);

buffer_put_cstring(&m, username);

mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_PWNAM, &m);

Line 210

Line 221

return (pw);

}

char *mm_auth2_read_banner(void)

char *

mm_auth2_read_banner(void)

{

Buffer m;

char *banner;

Line 221

Line 233

mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_AUTH2_READ_BANNER, &m);

buffer_clear(&m);

mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_AUTH2_READ_BANNER, &m);

mm_request_receive_expect(pmonitor->m_recvfd,

MONITOR_ANS_AUTH2_READ_BANNER, &m);

banner = buffer_get_string(&m, NULL);

buffer_free(&m);

/* treat empty banner as missing banner */

if (strlen(banner) == 0) {

xfree(banner);

banner = NULL;

}

return (banner);

}

Line 517

Line 535

}

void

mm_send_keystate(struct monitor *pmonitor)

mm_send_keystate(struct monitor *monitor)

{

Buffer m;

u_char *blob, *p;

Line 553

Line 571

goto skip;

} else {

/* Kex for rekeying */

mm_send_kex(&m, *pmonitor->m_pkex);

mm_send_kex(&m, *monitor->m_pkex);

}

debug3("%s: Sending new keys: %p %p",

Line 605

Line 623

buffer_put_string(&m, buffer_ptr(&input), buffer_len(&input));

buffer_put_string(&m, buffer_ptr(&output), buffer_len(&output));

mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_KEYEXPORT, &m);

mm_request_send(monitor->m_recvfd, MONITOR_REQ_KEYEXPORT, &m);

debug3("%s: Finished sending state", __func__);

buffer_free(&m);

Line 615

Line 633

mm_pty_allocate(int *ptyfd, int *ttyfd, char *namebuf, int namebuflen)

{

Buffer m;

char *p;

char *p, *msg;

int success = 0;

buffer_init(&m);

Line 631

Line 649

return (0);

}

p = buffer_get_string(&m, NULL);

msg = buffer_get_string(&m, NULL);

buffer_free(&m);

strlcpy(namebuf, p, namebuflen); /* Possible truncation */

xfree(p);

buffer_append(&loginmsg, msg, strlen(msg));

xfree(msg);

*ptyfd = mm_receive_fd(pmonitor->m_recvfd);

*ttyfd = mm_receive_fd(pmonitor->m_recvfd);

Line 644

Line 666

}

void

mm_session_pty_cleanup2(void *session)

mm_session_pty_cleanup2(Session *s)

{

Session *s = session;

Buffer m;

if (s->ttyfd == -1)

Line 765

Line 786

return ((authok == 0) ? -1 : 0);

}

#ifdef SKEY

int

mm_skey_query(void *ctx, char **name, char **infotxt,

u_int *numprompts, char ***prompts, u_int **echo_on)

Line 828

Line 850

return ((authok == 0) ? -1 : 0);

}

#endif /* SKEY */

void

mm_ssh1_session_id(u_char session_id[16])

Line 944

Line 967

#ifdef GSSAPI

OM_uint32

mm_ssh_gssapi_server_ctx(Gssctxt **ctx, gss_OID oid)

mm_ssh_gssapi_server_ctx(Gssctxt **ctx, gss_OID goid)

{

Buffer m;

OM_uint32 major;

Line 953

Line 976

*ctx = NULL;

buffer_init(&m);

buffer_put_string(&m, oid->elements, oid->length);

buffer_put_string(&m, goid->elements, goid->length);

mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_GSSSETUP, &m);

mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_GSSSETUP, &m);

Line 987

Line 1010

buffer_free(&m);

return (major);

}

OM_uint32

mm_ssh_gssapi_checkmic(Gssctxt *ctx, gss_buffer_t gssbuf, gss_buffer_t gssmic)

{

Buffer m;

OM_uint32 major;

buffer_init(&m);

buffer_put_string(&m, gssbuf->value, gssbuf->length);

buffer_put_string(&m, gssmic->value, gssmic->length);

mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_GSSCHECKMIC, &m);

mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_GSSCHECKMIC,

&m);

major = buffer_get_int(&m);

buffer_free(&m);

return(major);

}

int