/[winpt]/trunk/Src/wptKeyserver.cpp
ViewVC logotype

Diff of /trunk/Src/wptKeyserver.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 5 by twoaday, Mon Mar 7 13:21:36 2005 UTC revision 32 by twoaday, Mon Oct 24 08:03:48 2005 UTC
# Line 93  base64_encode( const char *inputstr, cha Line 93  base64_encode( const char *inputstr, cha
93  } /* base64_encode */  } /* base64_encode */
94    
95    
96    /* Skip the URL schema and return only the host part of it. */
97  static const char *  static const char *
98  skip_type_prefix (const char * hostname)  skip_type_prefix (const char * hostname)
99  {  {
# Line 108  skip_type_prefix (const char * hostname) Line 109  skip_type_prefix (const char * hostname)
109  }  }
110    
111    
112    /* Check that the keyserver response indicates an OK.
113       Return 0 on success. */
114  static int  static int
115  check_hkp_response (const char *resp, int recv)  check_hkp_response (const char *resp, int recv)
116  {  {
# Line 131  check_hkp_response (const char *resp, in Line 134  check_hkp_response (const char *resp, in
134          return ec;          return ec;
135      }      }
136      return 0;      return 0;
137  } /* check_hkp_response */  }
138    
139    
140    /* Read a single line (\r\n) from a socket.
141       Return 0 on success. */
142  static int  static int
143  sock_getline (int fd, char *buf, int buflen, int *nbytes)  sock_getline (int fd, char *buf, int buflen, int *nbytes)
144  {  {
# Line 155  sock_getline (int fd, char *buf, int buf Line 160  sock_getline (int fd, char *buf, int buf
160      }      }
161    
162      return -1;      return -1;
163  } /* sock_getline */  }
164    
165    
166    /* Perform a select() on the given fd to find out
167       is there is data for reading. Wait at least @nsecs seconds. */
168  static int  static int
169  sock_select (int fd)  sock_select (int fd, int nsecs)
170  {  {
171      FD_SET rfd;      FD_SET rfd;
172      timeval tv = {1, 0};      timeval tv = {nsecs, 0};
173    
174      FD_ZERO (&rfd);      FD_ZERO (&rfd);
175      FD_SET (fd, &rfd);      FD_SET (fd, &rfd);
# Line 171  sock_select (int fd) Line 178  sock_select (int fd)
178      if (FD_ISSET (fd, &rfd))      if (FD_ISSET (fd, &rfd))
179          return 1;          return 1;
180      return 0;      return 0;
181  } /* sock_select */  }
182    
183    
184    /* Read from a socket with a fixed timeout of 10 seconds.
185       Return value: 0 on success. */
186  static int  static int
187  sock_read( int fd, char *buf, int buflen, int *nbytes )  sock_read (int fd, char *buf, int buflen, int *nbytes)
188  {        {      
189      DWORD nread;      DWORD nread;
190      int nleft = buflen;      int nleft = buflen;
# Line 184  sock_read( int fd, char *buf, int buflen Line 193  sock_read( int fd, char *buf, int buflen
193      while (nleft > 0) {      while (nleft > 0) {
194          if (n >= 10)          if (n >= 10)
195              return WPTERR_WINSOCK_TIMEOUT;              return WPTERR_WINSOCK_TIMEOUT;
196          if ( (rc = sock_select( fd )) == SOCKET_ERROR )          rc = sock_select (fd, 1);
197            if (rc == SOCKET_ERROR)
198              return SOCKET_ERROR;              return SOCKET_ERROR;
199          else if( !rc )          else if( !rc )
200              n++;              n++;
201          else {          else {
202              nread = recv(fd, buf, nleft, 0);              nread = recv (fd, buf, nleft, 0);
203              if (nread == SOCKET_ERROR)              if (nread == SOCKET_ERROR)
204                  return SOCKET_ERROR;                  return SOCKET_ERROR;
205              else if (!nread)              else if (!nread)
# Line 202  sock_read( int fd, char *buf, int buflen Line 212  sock_read( int fd, char *buf, int buflen
212          *nbytes = buflen - nleft;          *nbytes = buflen - nleft;
213                    
214      return 0;      return 0;
215  } /* sock_read */  }
216    
217    
218    /* Write @buf to a socket @fd. */
219  static int  static int
220  sock_write( int fd, const char *buf, int buflen )  sock_write (int fd, const char *buf, int buflen)
221  {  {
222      DWORD nwritten;      DWORD nwritten;
223      int nleft = buflen;      int nleft = buflen;
# Line 220  sock_write( int fd, const char *buf, int Line 231  sock_write( int fd, const char *buf, int
231      }      }
232    
233      return 0;      return 0;
234  } /* sock_write */  }
235    
236    
237  void  void
# Line 236  set_default_kserver (void) Line 247  set_default_kserver (void)
247      }      }
248      else      else
249          default_keyserver_port = HKP_PORT;          default_keyserver_port = HKP_PORT;
250  } /* set_default_kserver */  }
251    
252    
253  /*  /* Initialize the Winsock2 interface.*/
  * Initialize the Winsock2 interface.  
  */  
254  int  int
255  wsock_init (void)  wsock_init (void)
256  {  {
# Line 251  wsock_init (void) Line 260  wsock_init (void)
260          return WPTERR_WINSOCK_INIT;          return WPTERR_WINSOCK_INIT;
261      set_default_kserver ();      set_default_kserver ();
262      return 0;      return 0;
263  } /* wsock_init */  }
264    
265    
266  /*  /* Cleanup the Winsock2 interface. */
  * Should be called after the keyserver access.  
  */  
267  void  void
268  wsock_end (void)  wsock_end (void)
269  {  {
# Line 269  wsock_end (void) Line 276  wsock_end (void)
276              free_if_alloc (server[i].name);              free_if_alloc (server[i].name);
277      }      }
278      WSACleanup ();      WSACleanup ();
279  } /* wsock_end */  }
280    
281    
282    /* Return a string representation of a winsock error. */
283  const char*  const char*
284  wsock_strerror( void )  wsock_strerror (void)
285  {      {    
286      static char buf[384];      static char buf[384];
287      int ec = WSAGetLastError( );      int ec = WSAGetLastError ();
288            
289      switch ( ec ) {      switch (ec) {
290      case WSAENETDOWN: return _("The network subsystem has failed");          case WSAENETDOWN:
291      case WSAHOST_NOT_FOUND: return _("Authoritative Answer Host not found");                      return _("The network subsystem has failed");    
292      case WSAETIMEDOUT: return _("The connection has been dropped because of a network failure");      case WSAHOST_NOT_FOUND:
293      default: _snprintf( buf, sizeof (buf) -1, _("Unknown Winsock error ec=%d"),ec); return buf;          return _("Authoritative Answer Host not found");
294        case WSAETIMEDOUT:
295            return _("The connection has been dropped because of a network failure");
296        default:
297            _snprintf (buf, sizeof (buf) -1, _("Unknown Winsock error ec=%d"),ec);
298            return buf;
299      }      }
300      return NULL;      return NULL;
301  } /* wsock_strerror */  }
302    
303    
304    /* Return the last keyserver error as a string. */
305  const char*  const char*
306  kserver_strerror( void )  kserver_strerror (void)
307  {        {      
308      if( hkp_err )      if (hkp_err)
309          return hkp_errmsg;          return hkp_errmsg;
310      return NULL;      return NULL;
311  } /* kserver_strerror */  }
312    
313    
314  const char *  /* Read a keyserver from the list at index @idx.
315       Return value: keyserver name at the given position. */
316    const char*
317  kserver_get_hostname (int idx, int type, u16 *port)  kserver_get_hostname (int idx, int type, u16 *port)
318  {  {
319      if (type == -1) {      if (type == -1) {
# Line 312  kserver_get_hostname (int idx, int type, Line 328  kserver_get_hostname (int idx, int type,
328  }  }
329    
330    
331    /* Check if the computer is connected to the internet.
332       Return 0 on success -1 otherwise. */
333  int  int
334  kserver_check_inet_connection (void)  kserver_check_inet_connection (void)
335  {  {
# Line 351  static void Line 369  static void
369  kserver_update_proxyuser (const char *proxy_user, const char *proxy_pass)  kserver_update_proxyuser (const char *proxy_user, const char *proxy_pass)
370  {  {
371      char t[257]; /* user:pass = 127+1+127+1 = 257 */      char t[257]; /* user:pass = 127+1+127+1 = 257 */
372        int n = 0;
373    
374        n = 4*strlen (proxy_user) / 3 + 32 + strlen (proxy_pass) + 2;
375      free_if_alloc (proxy.base64_user);      free_if_alloc (proxy.base64_user);
376      proxy.base64_user = new char[4*strlen( proxy_user ) / 3 + 32];      proxy.base64_user = new char[n];
377      if( !proxy.base64_user )      if (!proxy.base64_user)
378          BUG (0);          BUG (0);
379      _snprintf (t, sizeof (t)-1, "%s:%s", proxy_user, proxy_pass);      _snprintf (t, sizeof (t)-1, "%s:%s", proxy_user, proxy_pass);
380      base64_encode (t, proxy.base64_user, 257);      base64_encode (t, proxy.base64_user, 257);
# Line 365  kserver_update_proxyuser (const char *pr Line 385  kserver_update_proxyuser (const char *pr
385  } /* kserver_update_proxyuser */  } /* kserver_update_proxyuser */
386    
387    
388    /* Check that the given buffer contains a valid keyserver URL. */
389  static int  static int
390  check_URL (const char * buf)  check_URL (const char * buf)
391  {  {
392      if (strlen (buf) < 7)      if (strlen (buf) < 7)
393          return -1;          return -1;
394      if( !strstr (buf, "ldap://")      if (!strstr (buf, "ldap://")
395          && !strstr (buf, "http://")          && !strstr (buf, "http://")
396          && !strstr (buf, "finger://")          && !strstr (buf, "finger://")
397          && !strstr (buf, "hkp://"))          && !strstr (buf, "hkp://"))
398          return -1;          return -1;
399      return 0;      return 0;
400  } /* check_URL */  }
401            
402    
403    /* Get the port number from the given protocol. */
404    static int
405    port_from_proto (int proto)
406    {
407        switch (proto) {
408        case KSPROTO_LDAP: return 0;
409        case KSPROTO_FINGER: return FINGER_PORT;
410        case KSPROTO_HTTP: return HKP_PORT;
411        }
412        return 0;
413    }
414    
415    
416    /* Get the port number from the given URL. */
417  static int  static int
418  proto_from_URL (const char * buf)  proto_from_URL (const char * buf)
419  {  {
# Line 386  proto_from_URL (const char * buf) Line 421  proto_from_URL (const char * buf)
421          return KSPROTO_LDAP;          return KSPROTO_LDAP;
422      else if (strstr( buf, "finger"))      else if (strstr( buf, "finger"))
423          return KSPROTO_FINGER;          return KSPROTO_FINGER;
424      return KSPROTO_HTTP;      return KSPROTO_HKP;
425  } /* proto_from_URL */  }
426    
427    
428  void  void
# Line 400  keyserver_set_default (const char * host Line 435  keyserver_set_default (const char * host
435              BUG (0);              BUG (0);
436          default_keyserver_port = port;          default_keyserver_port = port;
437      }      }
438      server[0].name =  default_keyserver;      server[0].name =  m_strdup (default_keyserver);
439      server[0].used = 1;      server[0].used = 1;
440      server[0].port = port;      server[0].port = port;
441      server[0].proto = proto_from_URL (default_keyserver);      server[0].proto = proto_from_URL (default_keyserver);
# Line 434  kserver_load_conf (const char * conf) Line 469  kserver_load_conf (const char * conf)
469      char buf[1024], * s, * p;      char buf[1024], * s, * p;
470      char *user = NULL, *pass = NULL;          char *user = NULL, *pass = NULL;    
471      int pos, proxy_auth = 0;      int pos, proxy_auth = 0;
472      int no_config=0;      int no_config=0, chk_pos=0;
473            
474      for (pos = 0; pos < MAX_KEYSERVERS; pos++) {      for (pos = 0; pos < MAX_KEYSERVERS; pos++) {
475          server[pos].used = 0;          server[pos].used = 0;
# Line 443  kserver_load_conf (const char * conf) Line 478  kserver_load_conf (const char * conf)
478            
479      fp = fopen (conf, "rb");      fp = fopen (conf, "rb");
480      if (!fp) {      if (!fp) {
481          for( pos = 0; server_list[pos]; pos++ ) {          for (pos = 0; server_list[pos]; pos++) {
482              server[pos].used = 1;              server[pos].used = 1;
483              server[pos].name = (char *)server_list[pos];              server[pos].name = m_strdup (server_list[pos]);
484              server[pos].proto = proto_from_URL( server_list[pos] );              server[pos].proto = proto_from_URL (server_list[pos]);
485          }          }
486          no_config=1;          no_config=1;
487      }      }
488      get_reg_proxy_prefs( &proxy.host, &proxy.port, &user, &pass );      get_reg_proxy_prefs (&proxy.host, &proxy.port, &user, &pass);
489      if( user && pass )      if (user && pass)
490          kserver_update_proxyuser( user, pass );          kserver_update_proxyuser (user, pass);  
491      else if( user && !pass || !user && pass ) {      else if (user && !pass || !user && pass) {
492          msg_box( NULL, _("Invalid proxy configuration."          msg_box( NULL, _("Invalid proxy configuration."
493                           "You need to set a user and a password"                           "You need to set a user and a password"
494                           "to use proxy authentication!"), _("Proxy Error"), MB_ERR );                           "to use proxy authentication!"), _("Proxy Error"), MB_ERR );
# Line 488  kserver_load_conf (const char * conf) Line 523  kserver_load_conf (const char * conf)
523                               _("Keyserver Error"), MB_ERR);                               _("Keyserver Error"), MB_ERR);
524              continue;              continue;
525          }          }
526          p = strchr (s+6, ':');          chk_pos=6;
527            if (strstr (s, "finger"))
528                chk_pos = 10;
529            p = strchr (s+chk_pos, ':');
530          server[pos].used = 1;          server[pos].used = 1;
531          server[pos].proto = proto_from_URL (s);          server[pos].proto = proto_from_URL (s);
532            server[pos].port = port_from_proto (server[pos].proto);
533          if (!p)          if (!p)
534              server[pos].name = m_strdup (s);              server[pos].name = m_strdup (s);
535          else {                else {      
# Line 529  kserver_load_conf (const char * conf) Line 568  kserver_load_conf (const char * conf)
568  const char *  const char *
569  kserver_get_proxy (int * r_port)  kserver_get_proxy (int * r_port)
570  {  {
571      if (proxy.host)      if (proxy.host) {
     {  
572          if (r_port)          if (r_port)
573              *r_port = proxy.port;              *r_port = proxy.port;
574          return proxy.host;          return proxy.host;
# Line 540  kserver_get_proxy (int * r_port) Line 578  kserver_get_proxy (int * r_port)
578    
579    
580  const char *  const char *
581  kserver_get_proxy_info( int id )  kserver_get_proxy_info (int id)
582  {  {
583      switch( id ) {        switch (id) {  
584      case PROXY_USER: return proxy.user;      case PROXY_USER: return proxy.user;
585      case PROXY_PASS: return proxy.pass;      case PROXY_PASS: return proxy.pass;
586      }      }
# Line 550  kserver_get_proxy_info( int id ) Line 588  kserver_get_proxy_info( int id )
588  } /* kserver_get_proxy_info */  } /* kserver_get_proxy_info */
589    
590    
591  /*  /* Connect to the keyserver @hostname. */
  * Connect to the keyserver 'hostname'.  
  * We always use the HKP port.  
  */  
592  int  int
593  kserver_connect (const char *hostname, u16 port, int *conn_fd)  kserver_connect (const char *hostname, u16 port, int *conn_fd)
594  {  {
# Line 563  kserver_connect (const char *hostname, u Line 598  kserver_connect (const char *hostname, u
598      struct hostent *hp;      struct hostent *hp;
599      struct sockaddr_in sock;      struct sockaddr_in sock;
600    
601      if (debug)      log_debug ("kserver_connect: %s:%d\r\n", hostname, port);
602          log_f ("kserver_connect: %s:%d\r\n", hostname, port);  
603      if (!port)      if (!port)
604          port = HKP_PORT;          port = HKP_PORT;
605      if (conn_fd)      if (conn_fd)
# Line 582  kserver_connect (const char *hostname, u Line 617  kserver_connect (const char *hostname, u
617      if ((iaddr = inet_addr (host)) != INADDR_NONE)      if ((iaddr = inet_addr (host)) != INADDR_NONE)
618          memcpy (&sock.sin_addr, &iaddr, sizeof (iaddr));          memcpy (&sock.sin_addr, &iaddr, sizeof (iaddr));
619      else if ((hp = gethostbyname (host))) {      else if ((hp = gethostbyname (host))) {
620          if (hp->h_addrtype != AF_INET)          if (hp->h_addrtype != AF_INET || hp->h_length != 4) {
621              return WPTERR_WINSOCK_RESOLVE;              log_debug ("gethostbyname: unknown address type.\r\n");
         else if (hp->h_length != 4)  
622              return WPTERR_WINSOCK_RESOLVE;              return WPTERR_WINSOCK_RESOLVE;
623            }
624          memcpy (&sock.sin_addr, hp->h_addr, hp->h_length);          memcpy (&sock.sin_addr, hp->h_addr, hp->h_length);
625      }      }
626      else {      else {
627          if (debug)          log_debug ("gethostbyname: failed.\r\n");
             log_f ("gethostbyname: failed.\r\n");  
628          return WPTERR_WINSOCK_RESOLVE;          return WPTERR_WINSOCK_RESOLVE;
629      }      }
630      fd = socket (AF_INET, SOCK_STREAM, 0);      fd = socket (AF_INET, SOCK_STREAM, 0);
# Line 598  kserver_connect (const char *hostname, u Line 632  kserver_connect (const char *hostname, u
632          return WPTERR_WINSOCK_SOCKET;          return WPTERR_WINSOCK_SOCKET;
633      rc = connect (fd, (struct sockaddr *) &sock, sizeof (sock));      rc = connect (fd, (struct sockaddr *) &sock, sizeof (sock));
634      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
635          if (debug)          log_debug ("connect: failed.\r\n");
636              log_f ("connect: failed.\r\n");          closesocket (fd);
         closesocket(fd);  
637          return WPTERR_WINSOCK_CONNECT;          return WPTERR_WINSOCK_CONNECT;
638      }      }
639    
640      if (conn_fd)      if (conn_fd)
641          *conn_fd = fd;          *conn_fd = fd;
642      WSASetLastError(0);      WSASetLastError (0);
643      return 0;      return 0;
644  } /* kserver_connect */  } /* kserver_connect */
645    
646    
647    /* Perform URL-encoding on the given pubkey blob. */
648  static char*  static char*
649  kserver_urlencode (const char *pubkey, int octets, int *newlen)  kserver_urlencode (const char *pubkey, size_t octets, size_t *newlen)
650  {  {
651      char *p, numbuf[5];      char *p, numbuf[5];
652      size_t j = 0;      size_t j = 0;
653      int i, size;      size_t i, size;
654            
655      p = new char [2*octets];      p = new char [2*octets];
656      if (!p)      if (!p)
657          BUG (0);          BUG (0);
658    
659      for (size=0, i=0; i<octets; i++) {      for (size=0, i=0; i < octets; i++) {
660          if (isalnum (pubkey[i]) || pubkey[i] == '-') {          if (isalnum (pubkey[i]) || pubkey[i] == '-') {
661              p[size] = pubkey[i];              p[size] = pubkey[i];
662              size++;              size++;
# Line 642  kserver_urlencode (const char *pubkey, i Line 676  kserver_urlencode (const char *pubkey, i
676      p[size] = '\0';      p[size] = '\0';
677      *newlen = size;      *newlen = size;
678      return p;      return p;
679  } /* kserver_urlencode */  }
680    
681    
682  /*  /* Format a request for the given keyid (send). */
  * Format a request for the given keyid (send).  
  */  
683  static char*  static char*
684  kserver_send_request (const char *hostname, u16 port, const char *pubkey, int octets)  kserver_send_request (const char *hostname, u16 port, const char *pubkey, int octets)
685  {  {
686      char *request = NULL, *enc_pubkey = NULL;      char *request = NULL, *enc_pubkey = NULL;
687      int reqlen, enc_octets;      int reqlen;
688            size_t enc_octets;
689      if (debug)  
690          log_f ("kserver_send_request: %s:%d\n", hostname, port);      log_debug ("kserver_send_request: %s:%d\n", hostname, port);
691    
692      if (!port)      if (!port)
693          port = HKP_PORT;          port = HKP_PORT;
694      reqlen = 512 + strlen (hostname) + 2*strlen (pubkey);      reqlen = 512 + strlen (hostname) + 2*strlen (pubkey);
# Line 697  kserver_send_request (const char *hostna Line 730  kserver_send_request (const char *hostna
730                     skip_type_prefix (hostname), port, enc_octets+9, enc_pubkey);                     skip_type_prefix (hostname), port, enc_octets+9, enc_pubkey);
731      }      }
732      free_if_alloc (enc_pubkey);      free_if_alloc (enc_pubkey);
733      if (debug)  
734          log_f("%s\n", request);      log_debug ("%s\n", request);
735      return request;      return request;
736  } /* kserver_send_request */  } /* kserver_send_request */
737    
738    
739  /*  /* Interface receiving a public key. */
  * Interface receiving a public key.  
  */  
740  int  int
741  kserver_recvkey (const char *hostname, u16 port, const char *keyid, char *key, int maxkeylen)  kserver_recvkey (const char *hostname, u16 port, const char *keyid, char *key, int maxkeylen)
742  {        {      
# Line 738  kserver_recvkey (const char *hostname, u Line 769  kserver_recvkey (const char *hostname, u
769      else {      else {
770          _snprintf (request, 300,          _snprintf (request, 300,
771              "GET /pks/lookup?op=get&search=%s HTTP/1.0\r\n\r\n", keyid);              "GET /pks/lookup?op=get&search=%s HTTP/1.0\r\n\r\n", keyid);
772      }        }
773      if (debug)  
774          log_f ("%s\n", request);      log_debug ("%s\r\n", request);
775            
776      rc = sock_write (conn_fd, request, strlen (request));      rc = sock_write (conn_fd, request, strlen (request));
777      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
# Line 753  kserver_recvkey (const char *hostname, u Line 784  kserver_recvkey (const char *hostname, u
784          rc = WPTERR_WINSOCK_RECVKEY;          rc = WPTERR_WINSOCK_RECVKEY;
785          goto leave;          goto leave;
786      }      }
787        
788      if( debug )      log_debug("%s\r\n", key);
789          log_f("%s\n", key);      rc = check_hkp_response (key, 1);
790            if (rc)
     rc = check_hkp_response( key, 1 );  
     if( rc )  
791          goto leave;          goto leave;
792            
793      WSASetLastError( 0 );      WSASetLastError (0);
794            
795  leave:  leave:
796      closesocket( conn_fd );      closesocket (conn_fd);
797      free_if_alloc( request );      free_if_alloc (request);
798      return rc;      return rc;
799  } /* kserver_recvkey */  } /* kserver_recvkey */
800    
801    
802  /*  /* Interface to send a public key. */
  * Interface to send a public key.  
  */  
803  int  int
804  kserver_sendkey (const char *hostname, u16 port, const char *pubkey, int len )  kserver_sendkey (const char *hostname, u16 port, const char *pubkey, int len )
805  {  {
# Line 787  kserver_sendkey (const char *hostname, u Line 814  kserver_sendkey (const char *hostname, u
814          goto leave;          goto leave;
815            
816      request = kserver_send_request (hostname, port, pubkey, len);      request = kserver_send_request (hostname, port, pubkey, len);
817      if( request == NULL ) {      if (request == NULL) {
818          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
819          goto leave;              goto leave;    
820      }      }
# Line 803  kserver_sendkey (const char *hostname, u Line 830  kserver_sendkey (const char *hostname, u
830          rc = WPTERR_WINSOCK_SENDKEY;          rc = WPTERR_WINSOCK_SENDKEY;
831          goto leave;          goto leave;
832      }      }
833      if (debug)  
834          log_f("%s\n", log);      log_debug ("kserver_sendkey:\r\n%s\r\n", log);
835            
836      rc = check_hkp_response( log, 0 );      rc = check_hkp_response (log, 0);
837      if( rc )      if( rc )
838          goto leave;          goto leave;
839            
840      WSASetLastError( 0 );      WSASetLastError (0);
841            
842  leave:  leave:
843      closesocket( conn_fd );      closesocket (conn_fd);
844      free_if_alloc( request );      free_if_alloc (request);
845      return rc;      return rc;
846  } /* kserver_sendkey */  } /* kserver_sendkey */
847    
# Line 823  int Line 850  int
850  kserver_search_init (const char * hostname, u16 port, const char * keyid, int * conn_fd)  kserver_search_init (const char * hostname, u16 port, const char * keyid, int * conn_fd)
851  {  {
852      int rc, sock_fd;      int rc, sock_fd;
853        int n=0;
854      char * request = NULL;      char * request = NULL;
855            
856      rc = kserver_connect (hostname, port, &sock_fd);      rc = kserver_connect (hostname, port, &sock_fd);
# Line 831  kserver_search_init (const char * hostna Line 859  kserver_search_init (const char * hostna
859          goto leave;          goto leave;
860      }      }
861            
862      request = new char[300+1];      n=300;
863        request = new char[n+1];
864      if (!request)      if (!request)
865          BUG (0);          BUG (0);
866            
867      if (proxy.host && proxy.user) {      if (proxy.host && proxy.user) {
868          _snprintf (request, 300,          _snprintf (request, n,
869              "GET http://%s:%d/pks/lookup?op=index&search=%s HTTP/1.0\r\n"              "GET http://%s:%d/pks/lookup?op=index&search=%s HTTP/1.0\r\n"
870              "Proxy-Authorization: Basic %s\r\n\r\n",              "Proxy-Authorization: Basic %s\r\n\r\n",
871              skip_type_prefix (hostname), port, keyid, proxy.base64_user);              skip_type_prefix (hostname), port, keyid, proxy.base64_user);
872      }          }    
873      else if (proxy.host) {      else if (proxy.host) {
874          _snprintf (request, 300,          _snprintf (request, n,
875              "GET http://%s:%d/pks/lookup?op=index&search=%s HTTP/1.0\r\n\r\n",              "GET http://%s:%d/pks/lookup?op=index&search=%s HTTP/1.0\r\n\r\n",
876              skip_type_prefix (hostname), port, keyid);              skip_type_prefix (hostname), port, keyid);
877      }      }
878      else {      else {
879          _snprintf (request, 300,          _snprintf (request, n,
880                     "GET /pks/lookup?op=index&search=%s HTTP/1.0\r\n\r\n", keyid);                     "GET /pks/lookup?op=index&search=%s HTTP/1.0\r\n\r\n", keyid);
881      }      }
882            
883      if (debug)      log_debug ("kserver_search_init:\r\n%s\r\n", request);
         log_f("%s\n", request);  
884            
885      if (sock_write (sock_fd, request, strlen (request)) == SOCKET_ERROR) {      if (sock_write (sock_fd, request, strlen (request)) == SOCKET_ERROR) {
886          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
# Line 872  kserver_search_chkresp (int fd) Line 900  kserver_search_chkresp (int fd)
900  {  {
901      char buf[128];      char buf[128];
902      int n=0;      int n=0;
903        
904      /* parse response 'HTTP/1.0 500 OK' */      /* parse response 'HTTP/1.0 500 OK' */
905      if (sock_getline (fd, buf, 127, &n))      if (sock_getline (fd, buf, 127, &n))
906          return WPTERR_KEYSERVER_NOTFOUND;          return WPTERR_KEYSERVER_NOTFOUND;
907    
908        log_debug ("kserver_search_chkpresp: %s\r\n", buf);
909      if (strncmp (buf, "HTTP/1.", 7))      if (strncmp (buf, "HTTP/1.", 7))
910          return WPTERR_KEYSERVER_NOTFOUND;          return WPTERR_KEYSERVER_NOTFOUND;
911      if (strncmp (buf+(8+1), "200", 3))      if (strncmp (buf+(8+1), "200", 3))
# Line 889  kserver_search (int fd, keyserver_key * Line 919  kserver_search (int fd, keyserver_key *
919  {  {
920      char buf[1024], *p;      char buf[1024], *p;
921      int uidlen, nbytes, pos = 0;      int uidlen, nbytes, pos = 0;
922        
923      if (debug)      log_debug ("keyserver_search:\n");
         log_f ("keyserver_search:\n");  
924            
925      if (sock_getline (fd, buf, sizeof (buf) - 1, &nbytes))      if (sock_getline (fd, buf, sizeof (buf) - 1, &nbytes))
926          return WPTERR_GENERAL;          return WPTERR_GENERAL;
927        
928      if (debug)      log_debug ("%s\n", buf);
         log_f ("%s\n", buf);  
929            
930      if (!strncmp (buf, "pub", 3)) {      if (!strncmp (buf, "pub", 3)) {
931            int revoked = strstr (buf, "KEY REVOKED") != NULL? 1 : 0;
932          key->bits = atol (buf+3);          key->bits = atol (buf+3);
933          p = strchr (buf, '>');          p = strchr (buf, '>');
934          if (!p)          if (!p)
# Line 913  kserver_search (int fd, keyserver_key * Line 942  kserver_search (int fd, keyserver_key *
942          pos = p - buf + 5;          pos = p - buf + 5;
943          memcpy (key->date, buf + pos, 10);          memcpy (key->date, buf + pos, 10);
944          key->date[10] = '\0';          key->date[10] = '\0';
945            if (revoked) {
946                strcpy (key->uid, "KEY REVOKED: not checked");
947                return 0;
948            }
949          pos += 10;          pos += 10;
950          p = buf + pos + 1;          p = buf + pos + 1;
951          while (p && *p != '>')          while (p && *p != '>')
# Line 1235  finger_recvkey (const char * host, const Line 1268  finger_recvkey (const char * host, const
1268          rc = WPTERR_WINSOCK_RECVKEY;          rc = WPTERR_WINSOCK_RECVKEY;
1269      return rc;      return rc;
1270  }  }
1271    
1272    
1273    int
1274    check_IP_or_hostname (const char *name)
1275    {
1276        const char *not_allowed = "=!�$%&@#*~\\/}][{<>|,;:'";
1277        size_t i, j;
1278    
1279        for (i=0; i < strlen (name); i++) {
1280            for (j =0; j < strlen (not_allowed); j++) {
1281                if (name[i] == not_allowed[j])
1282                    return -1;
1283            }
1284        }
1285        return 0;
1286    }
Legend:
Removed from v.5  
changed lines
  Added in v.32
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26