[BACK]Return to monitor_wrap.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Diff for /src/usr.bin/ssh/monitor_wrap.c between version 1.5 and 1.5.2.1

version 1.5, 2002/03/25 20:12:10 version 1.5.2.1, 2002/05/18 04:12:11
Line 56 
Line 56 
 extern Newkeys *newkeys[];  extern Newkeys *newkeys[];
 extern z_stream incoming_stream;  extern z_stream incoming_stream;
 extern z_stream outgoing_stream;  extern z_stream outgoing_stream;
 extern struct monitor *monitor;  extern struct monitor *pmonitor;
 extern Buffer input, output;  extern Buffer input, output;
   
 void  void
Line 126 
Line 126 
         buffer_put_int(&m, nbits);          buffer_put_int(&m, nbits);
         buffer_put_int(&m, max);          buffer_put_int(&m, max);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_MODULI, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_MODULI, &m);
   
         debug3("%s: waiting for MONITOR_ANS_MODULI", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_MODULI", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_MODULI, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_MODULI, &m);
   
         success = buffer_get_char(&m);          success = buffer_get_char(&m);
         if (success == 0)          if (success == 0)
Line 151 
Line 151 
 int  int
 mm_key_sign(Key *key, u_char **sigp, u_int *lenp, u_char *data, u_int datalen)  mm_key_sign(Key *key, u_char **sigp, u_int *lenp, u_char *data, u_int datalen)
 {  {
         Kex *kex = *monitor->m_pkex;          Kex *kex = *pmonitor->m_pkex;
         Buffer m;          Buffer m;
   
         debug3("%s entering", __FUNCTION__);          debug3("%s entering", __FUNCTION__);
Line 160 
Line 160 
         buffer_put_int(&m, kex->host_key_index(key));          buffer_put_int(&m, kex->host_key_index(key));
         buffer_put_string(&m, data, datalen);          buffer_put_string(&m, data, datalen);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_SIGN, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_SIGN, &m);
   
         debug3("%s: waiting for MONITOR_ANS_SIGN", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_SIGN", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_SIGN, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_SIGN, &m);
         *sigp  = buffer_get_string(&m, lenp);          *sigp  = buffer_get_string(&m, lenp);
         buffer_free(&m);          buffer_free(&m);
   
Line 182 
Line 182 
         buffer_init(&m);          buffer_init(&m);
         buffer_put_cstring(&m, login);          buffer_put_cstring(&m, login);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_PWNAM, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_PWNAM, &m);
   
         debug3("%s: waiting for MONITOR_ANS_PWNAM", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_PWNAM", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_PWNAM, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_PWNAM, &m);
   
         if (buffer_get_char(&m) == 0) {          if (buffer_get_char(&m) == 0) {
                 buffer_free(&m);                  buffer_free(&m);
Line 205 
Line 205 
         return (pw);          return (pw);
 }  }
   
   char* mm_auth2_read_banner(void)
   {
           Buffer m;
           char *banner;
   
           debug3("%s entering", __FUNCTION__);
   
           buffer_init(&m);
           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);
           banner = buffer_get_string(&m, NULL);
           buffer_free(&m);
   
           return (banner);
   }
   
 /* Inform the privileged process about service and style */  /* Inform the privileged process about service and style */
   
 void  void
Line 218 
Line 236 
         buffer_put_cstring(&m, service);          buffer_put_cstring(&m, service);
         buffer_put_cstring(&m, style ? style : "");          buffer_put_cstring(&m, style ? style : "");
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_AUTHSERV, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_AUTHSERV, &m);
   
         buffer_free(&m);          buffer_free(&m);
 }  }
Line 234 
Line 252 
   
         buffer_init(&m);          buffer_init(&m);
         buffer_put_cstring(&m, password);          buffer_put_cstring(&m, password);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_AUTHPASSWORD, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_AUTHPASSWORD, &m);
   
         debug3("%s: waiting for MONITOR_ANS_AUTHPASSWORD", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_AUTHPASSWORD", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_AUTHPASSWORD, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_AUTHPASSWORD, &m);
   
         authenticated = buffer_get_int(&m);          authenticated = buffer_get_int(&m);
   
Line 307 
Line 325 
         buffer_put_string(&m, blob, len);          buffer_put_string(&m, blob, len);
         xfree(blob);          xfree(blob);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_KEYALLOWED, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_KEYALLOWED, &m);
   
         debug3("%s: waiting for MONITOR_ANS_KEYALLOWED", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_KEYALLOWED", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_KEYALLOWED, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_KEYALLOWED, &m);
   
         allowed = buffer_get_int(&m);          allowed = buffer_get_int(&m);
   
Line 348 
Line 366 
         buffer_put_string(&m, data, datalen);          buffer_put_string(&m, data, datalen);
         xfree(blob);          xfree(blob);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_KEYVERIFY, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_KEYVERIFY, &m);
   
         debug3("%s: waiting for MONITOR_ANS_KEYVERIFY", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_KEYVERIFY", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_KEYVERIFY, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_KEYVERIFY, &m);
   
         verified = buffer_get_int(&m);          verified = buffer_get_int(&m);
   
Line 490 
Line 508 
 }  }
   
 void  void
 mm_send_keystate(struct monitor *monitor)  mm_send_keystate(struct monitor *pmonitor)
 {  {
         Buffer m;          Buffer m;
         u_char *blob, *p;          u_char *blob, *p;
Line 516 
Line 534 
                 goto skip;                  goto skip;
         } else {          } else {
                 /* Kex for rekeying */                  /* Kex for rekeying */
                 mm_send_kex(&m, *monitor->m_pkex);                  mm_send_kex(&m, *pmonitor->m_pkex);
         }          }
   
         debug3("%s: Sending new keys: %p %p",          debug3("%s: Sending new keys: %p %p",
Line 562 
Line 580 
         buffer_put_string(&m, buffer_ptr(&input), buffer_len(&input));          buffer_put_string(&m, buffer_ptr(&input), buffer_len(&input));
         buffer_put_string(&m, buffer_ptr(&output), buffer_len(&output));          buffer_put_string(&m, buffer_ptr(&output), buffer_len(&output));
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_KEYEXPORT, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_KEYEXPORT, &m);
         debug3("%s: Finished sending state", __FUNCTION__);          debug3("%s: Finished sending state", __FUNCTION__);
   
         buffer_free(&m);          buffer_free(&m);
Line 576 
Line 594 
         int success = 0;          int success = 0;
   
         buffer_init(&m);          buffer_init(&m);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_PTY, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_PTY, &m);
   
         debug3("%s: waiting for MONITOR_ANS_PTY", __FUNCTION__);          debug3("%s: waiting for MONITOR_ANS_PTY", __FUNCTION__);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_PTY, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_PTY, &m);
   
         success = buffer_get_int(&m);          success = buffer_get_int(&m);
         if (success == 0) {          if (success == 0) {
Line 593 
Line 611 
         strlcpy(namebuf, p, namebuflen); /* Possible truncation */          strlcpy(namebuf, p, namebuflen); /* Possible truncation */
         xfree(p);          xfree(p);
   
         *ptyfd = mm_receive_fd(monitor->m_recvfd);          *ptyfd = mm_receive_fd(pmonitor->m_recvfd);
         *ttyfd = mm_receive_fd(monitor->m_recvfd);          *ttyfd = mm_receive_fd(pmonitor->m_recvfd);
   
         /* Success */          /* Success */
         return (1);          return (1);
Line 610 
Line 628 
                 return;                  return;
         buffer_init(&m);          buffer_init(&m);
         buffer_put_cstring(&m, s->tty);          buffer_put_cstring(&m, s->tty);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_PTYCLEANUP, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_PTYCLEANUP, &m);
         buffer_free(&m);          buffer_free(&m);
   
         /* closed dup'ed master */          /* closed dup'ed master */
Line 629 
Line 647 
         Buffer m;          Buffer m;
   
         buffer_init(&m);          buffer_init(&m);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_TERM, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_TERM, &m);
         buffer_free(&m);          buffer_free(&m);
 }  }
   
Line 641 
Line 659 
   
         buffer_init(&m);          buffer_init(&m);
         buffer_put_bignum2(&m, num);          buffer_put_bignum2(&m, num);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_SESSKEY, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_SESSKEY, &m);
   
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_SESSKEY, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_SESSKEY, &m);
   
         rsafail = buffer_get_int(&m);          rsafail = buffer_get_int(&m);
         buffer_get_bignum2(&m, num);          buffer_get_bignum2(&m, num);
Line 676 
Line 694 
         debug3("%s: entering", __FUNCTION__);          debug3("%s: entering", __FUNCTION__);
   
         buffer_init(&m);          buffer_init(&m);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_BSDAUTHQUERY, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_BSDAUTHQUERY, &m);
   
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_BSDAUTHQUERY,          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_BSDAUTHQUERY,
             &m);              &m);
         res = buffer_get_int(&m);          res = buffer_get_int(&m);
         if (res == -1) {          if (res == -1) {
Line 711 
Line 729 
   
         buffer_init(&m);          buffer_init(&m);
         buffer_put_cstring(&m, responses[0]);          buffer_put_cstring(&m, responses[0]);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_BSDAUTHRESPOND, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_BSDAUTHRESPOND, &m);
   
         mm_request_receive_expect(monitor->m_recvfd,          mm_request_receive_expect(pmonitor->m_recvfd,
             MONITOR_ANS_BSDAUTHRESPOND, &m);              MONITOR_ANS_BSDAUTHRESPOND, &m);
   
         authok = buffer_get_int(&m);          authok = buffer_get_int(&m);
Line 733 
Line 751 
         debug3("%s: entering", __FUNCTION__);          debug3("%s: entering", __FUNCTION__);
   
         buffer_init(&m);          buffer_init(&m);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_SKEYQUERY, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_SKEYQUERY, &m);
   
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_SKEYQUERY,          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_SKEYQUERY,
             &m);              &m);
         res = buffer_get_int(&m);          res = buffer_get_int(&m);
         if (res == -1) {          if (res == -1) {
Line 774 
Line 792 
   
         buffer_init(&m);          buffer_init(&m);
         buffer_put_cstring(&m, responses[0]);          buffer_put_cstring(&m, responses[0]);
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_SKEYRESPOND, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_SKEYRESPOND, &m);
   
         mm_request_receive_expect(monitor->m_recvfd,          mm_request_receive_expect(pmonitor->m_recvfd,
             MONITOR_ANS_SKEYRESPOND, &m);              MONITOR_ANS_SKEYRESPOND, &m);
   
         authok = buffer_get_int(&m);          authok = buffer_get_int(&m);
Line 797 
Line 815 
         for (i = 0; i < 16; i++)          for (i = 0; i < 16; i++)
                 buffer_put_char(&m, session_id[i]);                  buffer_put_char(&m, session_id[i]);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_SESSID, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_SESSID, &m);
         buffer_free(&m);          buffer_free(&m);
 }  }
   
Line 815 
Line 833 
         buffer_init(&m);          buffer_init(&m);
         buffer_put_bignum2(&m, client_n);          buffer_put_bignum2(&m, client_n);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_RSAKEYALLOWED, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_RSAKEYALLOWED, &m);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_RSAKEYALLOWED, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_RSAKEYALLOWED, &m);
   
         allowed = buffer_get_int(&m);          allowed = buffer_get_int(&m);
   
Line 855 
Line 873 
         buffer_put_string(&m, blob, blen);          buffer_put_string(&m, blob, blen);
         xfree(blob);          xfree(blob);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_RSACHALLENGE, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_RSACHALLENGE, &m);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_RSACHALLENGE, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_RSACHALLENGE, &m);
   
         buffer_get_bignum2(&m, challenge);          buffer_get_bignum2(&m, challenge);
         buffer_free(&m);          buffer_free(&m);
Line 884 
Line 902 
         buffer_put_string(&m, response, 16);          buffer_put_string(&m, response, 16);
         xfree(blob);          xfree(blob);
   
         mm_request_send(monitor->m_recvfd, MONITOR_REQ_RSARESPONSE, &m);          mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_RSARESPONSE, &m);
         mm_request_receive_expect(monitor->m_recvfd, MONITOR_ANS_RSARESPONSE, &m);          mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_RSARESPONSE, &m);
   
         success = buffer_get_int(&m);          success = buffer_get_int(&m);
         buffer_free(&m);          buffer_free(&m);
Legend:
Removed from v.1.5  
changed lines
  Added in v.1.5.2.1