/[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 231 by twoaday, Tue Jun 20 09:18:44 2006 UTC revision 290 by twoaday, Sat Mar 10 11:18:34 2007 UTC
# Line 1  Line 1 
1  /* wptKeyserver.cpp - W32 Keyserver Access  /* wptKeyserver.cpp - W32 Keyserver Access
2   *      Copyright (C) 2000-2006 Timo Schulz   *      Copyright (C) 2000-2007 Timo Schulz
3   *      Copyright (C) 2001 Marco Cunha   *      Copyright (C) 2001 Marco Cunha
4   *   *
5   * This file is part of WinPT.   * This file is part of WinPT.
# Line 13  Line 13 
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15   * General Public License for more details.   * General Public License for more details.
  *  
  * You should have received a copy of the GNU General Public License  
  * along with WinPT; if not, write to the Free Software Foundation,  
  * Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA  
16   */   */
   
17  #ifdef HAVE_CONFIG_H  #ifdef HAVE_CONFIG_H
18  #include <config.h>  #include <config.h>
19  #endif  #endif
# Line 29  Line 24 
24  #include <sys/stat.h>  #include <sys/stat.h>
25  #include <ctype.h>  #include <ctype.h>
26    
27    #include "wptGPG.h"
28  #include "wptKeyserver.h"  #include "wptKeyserver.h"
29  #include "wptErrors.h"  #include "wptErrors.h"
30  #include "wptTypes.h"  #include "wptTypes.h"
31  #include "wptNLS.h"  #include "wptNLS.h"
32  #include "wptW32API.h"  #include "wptW32API.h"
 #include "wptGPG.h"  
33  #include "wptRegistry.h"  #include "wptRegistry.h"
34  #include "wptUTF8.h"  #include "wptUTF8.h"
35    #include "wptVersion.h"
36    #include "StringBuffer.h"
37    
38    
39  /* Map net_errno to a winsock error. */  /* Map net_errno to a winsock error. */
40  #define net_errno ((int)WSAGetLastError ())  #define net_errno ((int)WSAGetLastError ())
# Line 59  static int   hkp_err = 0;      /* != 0 indica Line 57  static int   hkp_err = 0;      /* != 0 indica
57  char *default_keyserver = NULL;  char *default_keyserver = NULL;
58  WORD default_keyserver_port = 0;  WORD default_keyserver_port = 0;
59    
60  /* Default socket timeout. */  /* Default socket timeout (secs). */
61  static int default_socket_timeout = 6;  static size_t default_socket_timeout = 6;
62    
63    
64  /* Wrapper for safe memory allocation. */  /* Wrapper for safe memory allocation. */
# Line 83  base64_encode (const char *inbuf, char * Line 81  base64_encode (const char *inbuf, char *
81      char base64code[] =      char base64code[] =
82          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";          "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
83      int index = 0, temp = 0, res = 0;      int index = 0, temp = 0, res = 0;
84      int i = 0, inputlen = 0, len = 0;      int i, inputlen, len = 0;
85            
86      inputlen = strlen (inbuf);      inputlen = strlen (inbuf);
87      for (i = 0; i < inputlen; i++) {      for (i = 0; i < inputlen; i++) {
# Line 213  check_hkp_response (const char *resp, in Line 211  check_hkp_response (const char *resp, in
211          !strstr (resp, "HTTP/1.1 500 OK"))          !strstr (resp, "HTTP/1.1 500 OK"))
212          return ec; /* http error */          return ec; /* http error */
213    
214      if (!parse_keyserver_error (resp, hkp_errmsg, sizeof (hkp_errmsg)-2)) {      if (!parse_keyserver_error (resp, hkp_errmsg, DIM (hkp_errmsg)-2)) {
215          if (!strlen (hkp_errmsg))          if (!strlen (hkp_errmsg))
216              _snprintf (hkp_errmsg, sizeof (hkp_errmsg)-1,              _snprintf (hkp_errmsg, DIM (hkp_errmsg)-1,
217                          "Unknown keyserver error");                          "Unknown keyserver error");
218          hkp_err = 1;          hkp_err = 1;
219          return ec;          return ec;
# Line 277  sock_select (int fd, int nsecs) Line 275  sock_select (int fd, int nsecs)
275     returned in @nbytes.     returned in @nbytes.
276     Return value: 0 on success. */     Return value: 0 on success. */
277  static int  static int
278  sock_read (int fd, char *buf, int buflen, int *nbytes)  sock_read (int fd, char *buf, size_t buflen, int *nbytes)
279  {  {
280      DWORD nread;      int nread;
281      int nleft = buflen;      size_t nleft = buflen;
282      int rc, n = 0;      size_t n = 0;
283        int rc;
284            
285      if (nbytes)      if (nbytes)
286          *nbytes = 0;          *nbytes = 0;
# Line 315  sock_read (int fd, char *buf, int buflen Line 314  sock_read (int fd, char *buf, int buflen
314  /* Helper to create a string from the gpgme data and  /* Helper to create a string from the gpgme data and
315     then release the gpgme data object. */     then release the gpgme data object. */
316  char*  char*
317  data_release_and_get_mem (gpgme_data_t in, int *r_bufferlen)  data_release_and_get_mem (gpgme_data_t in, size_t *r_bufferlen)
318  {  {
319      size_t n;      size_t n;
320      char *buffer, *p;      char *buffer, *p;
# Line 324  data_release_and_get_mem (gpgme_data_t i Line 323  data_release_and_get_mem (gpgme_data_t i
323      p = gpgme_data_release_and_get_mem (in, &n);      p = gpgme_data_release_and_get_mem (in, &n);
324      buffer = m_strdup (p);      buffer = m_strdup (p);
325      if (r_bufferlen)      if (r_bufferlen)
326          *r_bufferlen = (int)n;          *r_bufferlen = n;
327      gpgme_free (p);      gpgme_free (p);
328      return buffer;      return buffer;
329  }  }
# Line 334  data_release_and_get_mem (gpgme_data_t i Line 333  data_release_and_get_mem (gpgme_data_t i
333     return the data in @buffer. Caller must free data.     return the data in @buffer. Caller must free data.
334     Return value: 0 on success. */     Return value: 0 on success. */
335  int  int
336  sock_read_ext (int fd, char **buffer, int *r_bufferlen)  sock_read_ext (int fd, char **buffer, size_t *r_bufferlen)
337  {  {
338      gpgme_data_t dh;      gpgme_data_t dh;
339      char buf[1024];      char buf[1024];
340      size_t n=0;      size_t timeout=0;
341      int nread, rc;      int nread, rc;
342    
343      if (gpgme_data_new (&dh))      if (gpgme_data_new (&dh))
344          BUG (0);          return SOCKET_ERROR;
345      while (n < 10) {      while (timeout < default_socket_timeout) {
346          rc = sock_select (fd, 1);          rc = sock_select (fd, 1);
347          if (rc == SOCKET_ERROR) {          if (rc == SOCKET_ERROR) {
348              gpgme_data_release (dh);              gpgme_data_release (dh);
349              return rc;              return rc;
350          }          }
351          else if (!rc)          else if (!rc)
352              n++;              timeout++; /* socket not ready yet. */
353          else {          else {
354              nread = recv (fd, buf, sizeof (buf), 0);              nread = recv (fd, buf, DIM (buf), 0);
355              if (nread == SOCKET_ERROR)              if (nread == SOCKET_ERROR)
356                  return SOCKET_ERROR;                  return SOCKET_ERROR;
357              else if (!nread)              else if (!nread)
# Line 360  sock_read_ext (int fd, char **buffer, in Line 359  sock_read_ext (int fd, char **buffer, in
359              gpgme_data_write (dh, buf, nread);              gpgme_data_write (dh, buf, nread);
360          }          }
361      }      }
362        if (timeout >= default_socket_timeout)
363            return WPTERR_WINSOCK_TIMEOUT;
364      *buffer = data_release_and_get_mem (dh, r_bufferlen);      *buffer = data_release_and_get_mem (dh, r_bufferlen);
365      return 0;      return 0;
366  }  }
# Line 368  sock_read_ext (int fd, char **buffer, in Line 368  sock_read_ext (int fd, char **buffer, in
368    
369  /* Write the buffer @buf with the length @buflen to a socket @fd. */  /* Write the buffer @buf with the length @buflen to a socket @fd. */
370  static int  static int
371  sock_write (int fd, const char *buf, int buflen)  sock_write (int fd, const char *buf, size_t buflen)
372  {  {
373      DWORD nwritten;      int nwritten;
374      int nleft = buflen;      int nleft = buflen;
375    
376      while (nleft > 0) {      while (nleft > 0) {
# Line 408  wsock_end (void) Line 408  wsock_end (void)
408      char *p;      char *p;
409      int i;      int i;
410    
411    #ifdef WINPT_MOBILE
412        p = m_strdup ("keyserver.conf");
413    #else
414      p = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);      p = make_special_filename (CSIDL_APPDATA, "winpt\\keyserver.conf", NULL);
415    #endif
416      kserver_save_conf (p);      kserver_save_conf (p);
417      free_if_alloc (p);      free_if_alloc (p);
418      free_if_alloc (default_keyserver);      free_if_alloc (default_keyserver);
419      for (i=0; i < MAX_KEYSERVERS; i++) {      for (i=0; i < MAX_KEYSERVERS; i++) {
420          if (server[i].used && server[i].name != NULL)          if (server[i].name != NULL)
421              free_if_alloc (server[i].name);              free_if_alloc (server[i].name);
422      }      }
423      kserver_proxy_release (&proxy);      kserver_proxy_release (&proxy);
# Line 464  wsock_strerror (void) Line 468  wsock_strerror (void)
468    
469  /* Set default socket timeout for all reading operations. */  /* Set default socket timeout for all reading operations. */
470  void  void
471  kserver_set_socket_timeout (int nsec)  kserver_set_socket_timeout (size_t nsec)
472  {  {
473      if (nsec < 0 || nsec > 3600)      if (nsec < 0 || nsec > 3600)
474          nsec = 0;          nsec = 0;
# Line 491  kserver_get_hostname (int idx, int type, Line 495  kserver_get_hostname (int idx, int type,
495          *port = default_keyserver_port;          *port = default_keyserver_port;
496          return default_keyserver;          return default_keyserver;
497      }      }
498      else if (!type && idx < DIM (server_list)) {      else if (!type && (size_t)idx < DIM (server_list)) {
499          /* XXX: handle non HKP servers. */          /* XXX: handle non HKP servers. */
500          *port = HKP_PORT;          *port = HKP_PORT;
501          return server_list[idx];          return server_list[idx];
# Line 529  kserver_check_keyid (const char *keyid) Line 533  kserver_check_keyid (const char *keyid)
533          return keyid; /* email address */          return keyid; /* email address */
534      if (strncmp (keyid, "0x", 2)) {      if (strncmp (keyid, "0x", 2)) {
535          memset (&id, 0, sizeof (id));          memset (&id, 0, sizeof (id));
536          _snprintf (id, sizeof (id)-1, "0x%s", keyid);          _snprintf (id, DIM (id)-1, "0x%s", keyid);
537          return id;          return id;
538      }      }
539      return keyid;      return keyid;
# Line 546  update_proxy_user (const char *proxy_use Line 550  update_proxy_user (const char *proxy_use
550      n = 4*strlen (proxy_user) / 3 + 32 + strlen (proxy_pass) + 2;      n = 4*strlen (proxy_user) / 3 + 32 + strlen (proxy_pass) + 2;
551      free_if_alloc (proxy.base64_user);      free_if_alloc (proxy.base64_user);
552      proxy.base64_user = safe_alloc (n+1);      proxy.base64_user = safe_alloc (n+1);
553      _snprintf (t, sizeof (t)-1, "%s:%s", proxy_user, proxy_pass);      _snprintf (t, DIM (t)-1, "%s:%s", proxy_user, proxy_pass);
554      base64_encode (t, proxy.base64_user);      base64_encode (t, proxy.base64_user);
555      free_if_alloc (proxy.user);      free_if_alloc (proxy.user);
556      free_if_alloc (proxy.pass);      free_if_alloc (proxy.pass);
# Line 647  kserver_save_conf (const char *conf) Line 651  kserver_save_conf (const char *conf)
651  }  }
652    
653    
654    /* Return the specified keyserver config setting @key as an integer. */
655    static int
656    get_conf_kserver_int (const char *key)
657    {
658        char *p;
659        int val = 0;
660    
661        p = get_reg_entry_keyserver (key);
662        if (p && *p)
663            val = atoi (p);
664        free_if_alloc (p);
665        return val;
666    }
667    
668    
669    /* Read the proxy configuration and store it into @prox. */
670    static void
671    read_proxy_config (keyserver_proxy_t prox)
672    {
673        char *proto;
674    
675        if (!prox)
676            return;
677        
678        proto = get_reg_entry_keyserver("Proto");
679        if (proto != NULL && strlen (proto) > 0)
680            prox->proto = atoi (proto);
681        else
682            prox->proto = PROXY_PROTO_NONE;
683        free_if_alloc (proto);
684        free_if_alloc (prox->host);
685        prox->host = get_reg_entry_keyserver ("Host");
686        free_if_alloc (prox->user);
687        prox->user = get_reg_entry_keyserver ("User");
688        free_if_alloc (prox->pass);
689        prox->pass = get_reg_entry_keyserver ("Pass");
690        prox->port = get_conf_kserver_int ("Port");
691    }
692    
693    
694  /* Load the keyserver config file @conf. */  /* Load the keyserver config file @conf. */
695  int  int
696  kserver_load_conf (const char *conf)  kserver_load_conf (const char *conf)
# Line 654  kserver_load_conf (const char *conf) Line 698  kserver_load_conf (const char *conf)
698      FILE *fp;      FILE *fp;
699      char buf[1024], *s, *p;      char buf[1024], *s, *p;
700      char *user = NULL, *pass = NULL;          char *user = NULL, *pass = NULL;    
701      int no_config=0, chk_pos=0;      int no_config=0, chk_pos;
702      int pos;      int pos;
703            
704      for (pos = 0; pos < MAX_KEYSERVERS; pos++) {      for (pos = 0; pos < MAX_KEYSERVERS; pos++) {
705          server[pos].used = 0;          server[pos].used = 0;
706          server[pos].port = HKP_PORT;          server[pos].port = HKP_PORT;
707            server[pos].name = NULL;
708      }      }
709            
710      fp = fopen (conf, "rb");      fp = fopen (conf, "rb");
# Line 669  kserver_load_conf (const char *conf) Line 714  kserver_load_conf (const char *conf)
714              server[pos].name = m_strdup (server_list[pos]);              server[pos].name = m_strdup (server_list[pos]);
715              server[pos].proto = proto_from_URL (server_list[pos]);              server[pos].proto = proto_from_URL (server_list[pos]);
716          }          }
717          no_config=1;          no_config = 1;
718      }      }
719      get_reg_proxy_prefs (&proxy);      read_proxy_config (&proxy);
720      if (user && pass)      if (user && pass)
721          update_proxy_user (user, pass);          update_proxy_user (user, pass);
722      else if (user && !pass || !user && pass) {      else if (user && !pass || !user && pass) {
723          msg_box (NULL, _("Invalid proxy configuration."          msg_box (NULL, _("Invalid proxy configuration. "
724                           "You need to set a user and a password "                           "You need to set a user and a password "
725                           "to use proxy authentication!"),                           "to use proxy authentication!"),
726                           _("Proxy Error"), MB_ERR);                           _("Proxy Error"), MB_ERR);
# Line 691  kserver_load_conf (const char *conf) Line 736  kserver_load_conf (const char *conf)
736            
737      pos = 0;      pos = 0;
738      while (fp && !feof (fp)) {      while (fp && !feof (fp)) {
739          s = fgets (buf, sizeof (buf)-1, fp);          s = fgets (buf, DIM (buf)-1, fp);
740          if (!s)          if (!s)
741              break;              break;
742          if (strstr (buf, "\r\n"))          if (strstr (buf, "\r\n"))
# Line 732  kserver_load_conf (const char *conf) Line 777  kserver_load_conf (const char *conf)
777      if (fp)      if (fp)
778          fclose (fp);          fclose (fp);
779      if (!pos) {      if (!pos) {
780          /* only issue an error if the config file exist but          /* Only issue an error if the config file exist but
781             it has no valid entries. */             it has no valid entries. */
782          keyserver_set_default (NULL, HKP_PORT);          keyserver_set_default (NULL, HKP_PORT);
783          if (!no_config)          if (!no_config)
# Line 752  kserver_connect (const char *hostname, W Line 797  kserver_connect (const char *hostname, W
797      struct sockaddr_in sock;      struct sockaddr_in sock;
798      char host[128] = {0};      char host[128] = {0};
799      DWORD iaddr;      DWORD iaddr;
800        bool use_proxy = proxy.host != NULL;
801      int rc, fd;      int rc, fd;
802    
     log_debug ("kserver_connect: %s:%d\r\n", hostname, port);  
   
803      if (!port)      if (!port)
804          port = HKP_PORT;          port = HKP_PORT;
805      if (conn_fd)      if (conn_fd)
806          *conn_fd = 0;          *conn_fd = 0;
807      hostname = skip_type_prefix (hostname);      hostname = skip_type_prefix (hostname);
808        log_debug ("kserver_connect: %s:%d\r\n", hostname, port);
809            
810      if (proxy.host && proxy.proto == PROXY_PROTO_HTTP)      if (use_proxy && proxy.proto == PROXY_PROTO_HTTP)
811          port = proxy.port;          port = proxy.port;
812      memset (&sock, 0, sizeof (sock));      memset (&sock, 0, sizeof (sock));
813      sock.sin_family = AF_INET;      sock.sin_family = AF_INET;
814      sock.sin_port = htons (port);      sock.sin_port = htons (port);
815      if (proxy.host)      strncpy (host, use_proxy? proxy.host : hostname, DIM (host)-1);
         strncpy (host, proxy.host, 127);  
     else  
         strncpy (host, hostname, 127);  
816    
817      if ((iaddr = inet_addr (host)) != INADDR_NONE)      if ((iaddr = inet_addr (host)) != INADDR_NONE)
818          memcpy (&sock.sin_addr, &iaddr, sizeof (iaddr));          memcpy (&sock.sin_addr, &iaddr, sizeof (iaddr));
# Line 783  kserver_connect (const char *hostname, W Line 825  kserver_connect (const char *hostname, W
825      }      }
826      else {      else {
827          log_debug ("gethostbyname: failed ec=%d.\r\n", net_errno);          log_debug ("gethostbyname: failed ec=%d.\r\n", net_errno);
828          return WPTERR_WINSOCK_RESOLVE;          return use_proxy? WPTERR_WINSOCK_PROXY : WPTERR_WINSOCK_RESOLVE;
829      }      }
830      fd = socket (AF_INET, SOCK_STREAM, 0);      fd = socket (AF_INET, SOCK_STREAM, 0);
831      if (fd == INVALID_SOCKET)        if (fd == INVALID_SOCKET)  
# Line 792  kserver_connect (const char *hostname, W Line 834  kserver_connect (const char *hostname, W
834      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
835          log_debug ("connect: failed ec=%d.\r\n", net_errno);          log_debug ("connect: failed ec=%d.\r\n", net_errno);
836          closesocket (fd);          closesocket (fd);
837          return WPTERR_WINSOCK_CONNECT;          return use_proxy? WPTERR_WINSOCK_PROXY : WPTERR_WINSOCK_CONNECT;
838      }      }
839    
840      if (proxy.proto == PROXY_PROTO_SOCKS5) {      if (proxy.proto == PROXY_PROTO_SOCKS5) {
841            /* XXX: finish code and provide errors constants. */
842          rc = socks_handshake (&proxy, fd, hostname, port);          rc = socks_handshake (&proxy, fd, hostname, port);
843          if (rc) {          if (rc) {
844              closesocket (fd);              closesocket (fd);
845              return WPTERR_GENERAL; /* XXX: use better code. */              return WPTERR_GENERAL;
846          }          }
847      }      }
848    
# Line 826  URL_encode (const char *url, DWORD ulen, Line 869  URL_encode (const char *url, DWORD ulen,
869  {  {
870      gpgme_data_t hd;      gpgme_data_t hd;
871      char numbuf[5], *p;      char numbuf[5], *p;
872      size_t i;      size_t i, nlen;
     int nlen;  
873    
874      if (gpgme_data_new (&hd))      if (gpgme_data_new (&hd))
875          BUG (0);          BUG (0);
# Line 910  kserver_send_request (const char *hostna Line 952  kserver_send_request (const char *hostna
952  /* Interface for receiving a public key. */  /* Interface for receiving a public key. */
953  int  int
954  kserver_recvkey (const char *hostname, WORD port, const char *keyid,  kserver_recvkey (const char *hostname, WORD port, const char *keyid,
955                   char **r_key, int *r_keylen)                   char **r_key, size_t *r_keylen)
956  {  {
957      const char *fmt;      StringBuffer req;
958      char *request = NULL;      const char *reqbuf;
959      int conn_fd;      int conn_fd;
960      int rc, reqlen;      int rc;
961    
962      if (!port)      if (!port)
963          port = HKP_PORT;          port = HKP_PORT;
# Line 924  kserver_recvkey (const char *hostname, W Line 966  kserver_recvkey (const char *hostname, W
966      if (rc)      if (rc)
967          goto leave;          goto leave;
968    
     reqlen = strlen (hostname)+32+strlen (keyid)+1;  
969      if (proxy.host && proxy.user && proxy.proto == PROXY_PROTO_HTTP) {      if (proxy.host && proxy.user && proxy.proto == PROXY_PROTO_HTTP) {
970          fmt = "GET http://%s:%d/pks/lookup?op=get&search=%s HTTP/1.0\r\n"          req = req + "GET http://" + skip_type_prefix (hostname) +
971                "Proxy-Authorization: Basic %s\r\n\r\n";              ":" + port +
972          reqlen =+ strlen (fmt) + strlen (proxy.base64_user)+1;              "/pks/lookup?op=get&search=" + keyid + " HTTP/1.0\r\n" +
973          request = safe_alloc (reqlen+1);              "Proxy-Authorization: Basic " + proxy.base64_user + "\r\n\r\n";
         _snprintf (request, reqlen, fmt, skip_type_prefix (hostname), port,  
                    keyid, proxy.base64_user);  
974      }      }
975      else if (proxy.host && proxy.proto == PROXY_PROTO_HTTP) {      else if (proxy.host && proxy.proto == PROXY_PROTO_HTTP) {
976          fmt = "GET http://%s:%d/pks/lookup?op=get&search=%s HTTP/1.0\r\n\r\n";          req = req + "GET http://" + skip_type_prefix (hostname) +
977          reqlen += strlen (fmt)+1;              ":" + port + "/pks/lookup?op=get&search=" + keyid +
978          request = safe_alloc (reqlen+1);              " HTTP/1.0\r\n\r\n";
         _snprintf (request, reqlen, fmt, skip_type_prefix (hostname),  
                                          port, keyid);  
     }  
     else {  
         fmt = "GET /pks/lookup?op=get&search=%s HTTP/1.0\r\n\r\n";  
         reqlen += strlen (fmt)+1;  
         request = safe_alloc (reqlen+1);  
         _snprintf (request, reqlen, fmt, keyid);  
979      }      }
980        else
981      log_debug ("request:\r\n%s\r\n", request);          req = req + "GET /pks/lookup?op=get&search=" + keyid +
982                " HTTP/1.0\r\n\r\n";
983            
984      rc = sock_write (conn_fd, request, strlen (request));      log_debug ("req:\r\n%s\r\n", req.getBuffer ());
985    
986        reqbuf = req.getBuffer ();
987        rc = sock_write (conn_fd, reqbuf, strlen (reqbuf));
988      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
989          rc = WPTERR_WINSOCK_RECVKEY;          rc = WPTERR_WINSOCK_RECVKEY;
990          goto leave;          goto leave;
# Line 970  kserver_recvkey (const char *hostname, W Line 1005  kserver_recvkey (const char *hostname, W
1005            
1006  leave:  leave:
1007      closesocket (conn_fd);      closesocket (conn_fd);
     free_if_alloc (request);  
1008      return rc;      return rc;
1009  }  }
1010    
1011    
1012  /* Interface to send a public key. */  /* Interface to send a public key. */
1013  int  int
1014  kserver_sendkey (const char *hostname, WORD port, const char *pubkey, int len )  kserver_sendkey (const char *hostname, WORD port,
1015                     const char *pubkey, size_t len)
1016  {  {
1017      char *request = NULL;      char *request = NULL;
1018      char log[2048] = {0};      char log[2048] = {0};
# Line 990  kserver_sendkey (const char *hostname, W Line 1025  kserver_sendkey (const char *hostname, W
1025          goto leave;          goto leave;
1026            
1027      request = kserver_send_request (hostname, port, pubkey, len);      request = kserver_send_request (hostname, port, pubkey, len);
     if (request == NULL) {  
         rc = WPTERR_GENERAL;  
         goto leave;      
     }  
       
1028      rc = sock_write (conn_fd, request, strlen (request));      rc = sock_write (conn_fd, request, strlen (request));
1029      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
1030          rc = WPTERR_WINSOCK_SENDKEY;          rc = WPTERR_WINSOCK_SENDKEY;
1031          goto leave;              goto leave;    
1032      }      }
1033            
1034      rc = sock_read (conn_fd, log, sizeof (log)-1, &n);      rc = sock_read (conn_fd, log, DIM (log)-1, &n);
1035      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
1036          rc = WPTERR_WINSOCK_SENDKEY;          rc = WPTERR_WINSOCK_SENDKEY;
1037          goto leave;          goto leave;
# Line 1013  kserver_sendkey (const char *hostname, W Line 1043  kserver_sendkey (const char *hostname, W
1043          goto leave;          goto leave;
1044            
1045      WSASetLastError (0);      WSASetLastError (0);
1046        
1047  leave:  leave:
1048      closesocket (conn_fd);      closesocket (conn_fd);
1049      free_if_alloc (request);      free_if_alloc (request);
# Line 1029  kserver_search_chkresp (int fd) Line 1059  kserver_search_chkresp (int fd)
1059      int n=0;      int n=0;
1060            
1061      /* parse response 'HTTP/1.0 500 OK' */      /* parse response 'HTTP/1.0 500 OK' */
1062      if (sock_getline (fd, buf, sizeof (buf)-1, &n))      if (sock_getline (fd, buf, DIM (buf)-1, &n))
1063          return WPTERR_KEYSERVER_NOTFOUND;          return WPTERR_KEYSERVER_NOTFOUND;
1064    
1065      log_debug ("kserver_search_chkpresp: %s\r\n", buf);      log_debug ("kserver_search_chkpresp: %s\r\n", buf);
# Line 1051  kserver_search_end (int conn_fd) Line 1081  kserver_search_end (int conn_fd)
1081    
1082    
1083  /* Extract the amount of keys from the info record. */  /* Extract the amount of keys from the info record. */
1084  static int  static size_t
1085  count_keys_in_response (char *buf)  count_keys_in_response (char *buf)
1086  {  {
1087      char *p;      char *p;
1088      int recno = 0;      int recno = 0;
1089      int n = 0;      size_t n = 0;
1090    
1091      /* info:1:4 */      /* info:1:4 */
1092      if (strncmp (buf, "info", 4))      if (strncmp (buf, "info", 4))
# Line 1079  count_keys_in_response (char *buf) Line 1109  count_keys_in_response (char *buf)
1109     the amount of keys which were found. */     the amount of keys which were found. */
1110  int  int
1111  kserver_search_begin (const char *hostname, WORD port,  kserver_search_begin (const char *hostname, WORD port,
1112                        const char *pattern, int *conn_fd, int *nkeys)                        const char *pattern, int *conn_fd, size_t *nkeys)
1113  {  {
1114      const char *fmt;  
1115      char *request = NULL;      StringBuffer req;
1116        const char *reqbuf;
1117      char *enc_patt = NULL;      char *enc_patt = NULL;
1118      char status[128];      char status[128];
1119      int rc, sock_fd;      int rc, sock_fd;
1120      int reqlen;      int nread;
1121            
1122      *conn_fd = 0;      *conn_fd = 0;
1123    
# Line 1095  kserver_search_begin (const char *hostna Line 1126  kserver_search_begin (const char *hostna
1126          goto leave;          goto leave;
1127    
1128      enc_patt = URL_encode (pattern, strlen (pattern), NULL);      enc_patt = URL_encode (pattern, strlen (pattern), NULL);
     reqlen = strlen (enc_patt) + strlen (hostname) + 32 + 1;  
   
1129      if (proxy.host && proxy.user && proxy.proto == PROXY_PROTO_HTTP) {      if (proxy.host && proxy.user && proxy.proto == PROXY_PROTO_HTTP) {
1130          fmt = "GET http://%s:%d/pks/lookup?options=mr&op=index&search=%s HTTP/1.0\r\n"          req = req + "GET http://" + skip_type_prefix (hostname) + ":" + port +
1131                "Proxy-Authorization: Basic %s\r\n\r\n";              "/pks/lookup?options=mr&op=index&search=" + enc_patt +
1132          reqlen += strlen (proxy.base64_user) + strlen (fmt) + 1;              " HTTP/1.0\r\n"
1133          request = safe_alloc (reqlen+1);              "Proxy-Authorization: Basic " + proxy.base64_user + "\r\n\r\n";
         _snprintf (request, reqlen, fmt, skip_type_prefix (hostname), port,  
                    enc_patt, proxy.base64_user);  
1134      }          }    
1135      else if (proxy.host && proxy.proto == PROXY_PROTO_HTTP) {      else if (proxy.host && proxy.proto == PROXY_PROTO_HTTP) {
1136          fmt = "GET http://%s:%d/pks/lookup?options=mr&op=index&search=%s HTTP/1.0\r\n\r\n";          req = req + "GET http://" + skip_type_prefix (hostname) + ":" + port +
1137          reqlen += strlen (fmt)+1;              "/pks/lookup?options=mr&op=index&search=" + enc_patt +
1138          request = safe_alloc (reqlen+1);              " HTTP/1.0\r\n\r\n";
         _snprintf (request, reqlen, skip_type_prefix (hostname), port,  
                             enc_patt);  
1139      }      }
1140      else {      else {
1141          fmt = "GET /pks/lookup?options=mr&op=index&search=%s HTTP/1.0\r\n\r\n";          req = req + "GET /pks/lookup?options=mr&op=index&search=" +
1142          reqlen += strlen (fmt)+1;              enc_patt + " HTTP/1.0\r\n\r\n";
         request = safe_alloc (reqlen+1);  
         _snprintf (request, reqlen, fmt, enc_patt);  
1143      }      }
1144        
1145      log_debug ("kserver_search_begin:\r\n%s\r\n", request);      log_debug ("kserver_search_begin:\r\n%s\r\n", req.getBuffer ());
1146      if (sock_write (sock_fd, request, strlen (request)) == SOCKET_ERROR) {      reqbuf = req.getBuffer ();
1147        if (sock_write (sock_fd, reqbuf, strlen (reqbuf)) == SOCKET_ERROR) {
1148          rc = WPTERR_GENERAL;          rc = WPTERR_GENERAL;
1149          goto leave;          goto leave;
1150      }      }
# Line 1134  kserver_search_begin (const char *hostna Line 1158  kserver_search_begin (const char *hostna
1158    
1159      /* Skip all lines until we reach the "info:" record. */      /* Skip all lines until we reach the "info:" record. */
1160      for (;;) {      for (;;) {
1161          if (sock_getline (sock_fd, status, sizeof (status)-1, &reqlen)) {                if (sock_getline (sock_fd, status, DIM (status)-1, &nread)) {  
1162              log_debug ("kserver_search_begin: retrieving status line failed.\r\n");              log_debug ("kserver_search_begin: retrieving status line failed.\r\n");
1163              closesocket (sock_fd);              closesocket (sock_fd);
1164              sock_fd = 0;              sock_fd = 0;
# Line 1150  kserver_search_begin (const char *hostna Line 1174  kserver_search_begin (const char *hostna
1174      *conn_fd = sock_fd;      *conn_fd = sock_fd;
1175            
1176  leave:  leave:
     free_if_alloc (request);  
1177      free_if_alloc (enc_patt);      free_if_alloc (enc_patt);
1178      return rc;      return rc;
1179  }  }
# Line 1163  parse_pub_record (keyserver_key_s *key, Line 1186  parse_pub_record (keyserver_key_s *key,
1186      enum pub_rec_t {ID=1, KEYID, ALGO, SIZE, CREATE, EXPIRE};      enum pub_rec_t {ID=1, KEYID, ALGO, SIZE, CREATE, EXPIRE};
1187      char *p;      char *p;
1188      int recno = 0;      int recno = 0;
1189        int off = 0;
1190    
1191      /* pub:BF3DF9B4:17:1024:925411133:: */      /* pub:{BF3DF9B4, ED4681C9BF3DF9B4, FPR}:17:1024:925411133:: */
1192      p = strtok (buf, ":");      p = strtok (buf, ":");
1193      while (p != NULL) {      while (p != NULL) {
1194          recno++;          recno++;
# Line 1172  parse_pub_record (keyserver_key_s *key, Line 1196  parse_pub_record (keyserver_key_s *key,
1196          case ID:          case ID:
1197              break;              break;
1198    
1199          case KEYID:          case KEYID:
1200                /* If for any reason the returned record actually contains
1201                   a fingerprint instead of a key ID, we truncate the fpr. */
1202                off = strlen (p) == 40? 32 : 0;
1203              free_if_alloc (key->keyid);              free_if_alloc (key->keyid);
1204              key->keyid = m_strdup (p);              key->keyid = m_strdup (p+off);
1205              break;              break;
1206    
1207          case ALGO:          case ALGO:
# Line 1195  parse_pub_record (keyserver_key_s *key, Line 1222  parse_pub_record (keyserver_key_s *key,
1222          }          }
1223          p = strtok (NULL, ":");          p = strtok (NULL, ":");
1224      }      }
       
1225  }  }
1226    
1227    
# Line 1279  kserver_search_next (int fd, keyserver_k Line 1305  kserver_search_next (int fd, keyserver_k
1305      key = new keyserver_key_s;      key = new keyserver_key_s;
1306      memset (key, 0, sizeof *key);      memset (key, 0, sizeof *key);
1307      for (;;) {      for (;;) {
1308          if (sock_getline (fd, buf, sizeof (buf)-1, &n))          if (sock_getline (fd, buf, DIM (buf)-1, &n))
1309              break;              break;
1310          /*log_debug ("record: '%s'\r\n", buf); */          /*log_debug ("record: '%s'\r\n", buf); */
1311          if (!strncmp (buf, "pub", 3))          if (!strncmp (buf, "pub", 3))
# Line 1364  static FILE* Line 1390  static FILE*
1390  do_spawn_ldap_helper (const char *host, const char *keyid)  do_spawn_ldap_helper (const char *host, const char *keyid)
1391  {  {
1392      FILE *fp = NULL;      FILE *fp = NULL;
1393      char *p, *sep;      StringBuffer cmd;
1394      char *ksprg;      char *sep, *p, *ksprg;
1395      char outf[256], inf[256];      char outf[256], inf[256];
1396      size_t n;      size_t n;
1397    
# Line 1386  do_spawn_ldap_helper (const char *host, Line 1412  do_spawn_ldap_helper (const char *host,
1412          fp = NULL;          fp = NULL;
1413          goto leave;          goto leave;
1414      }      }
1415      get_temp_name (outf, sizeof (outf)-1, keyid);      get_temp_name (outf, DIM (outf)-1, keyid);
1416      get_temp_name (inf, sizeof (inf)-1, NULL);      get_temp_name (inf, DIM (inf)-1, NULL);
1417      fp = fopen (inf, "w+b");      fp = fopen (inf, "w+b");
1418      if (!fp) {      if (!fp) {
1419          log_box ("LDAP Keyserver Plugin", MB_ERR, "%s: %s", inf,          log_box ("LDAP Keyserver Plugin", MB_ERR, "%s: %s", inf,
# Line 1396  do_spawn_ldap_helper (const char *host, Line 1422  do_spawn_ldap_helper (const char *host,
1422      }      }
1423      fprintf (fp,      fprintf (fp,
1424          "VERSION 1\n"          "VERSION 1\n"
1425          "PROGRAM 1.4.3-cvs\n"          "PROGRAM %d.%d.%d\n"
1426          "SCHEME ldap\n"          "SCHEME ldap\n"
1427          "HOST %s\n"          "HOST %s\n"
1428          "COMMAND GET\n"          "COMMAND GET\n"
1429          "\n"          "\n"
1430          "%s\n",          "%s\n",
1431            gpgver[0], gpgver[1], gpgver[2],
1432          host? skip_type_prefix (host): "64.94.85.200", keyid);          host? skip_type_prefix (host): "64.94.85.200", keyid);
1433      fclose (fp);      fclose (fp);
1434    
1435      p = safe_alloc (strlen (ksprg) + strlen (inf) + strlen (outf) + 32);      cmd = ksprg;
1436      sprintf (p, "%s -o %s %s", ksprg, outf, inf);      cmd = cmd + " -o " + outf + " " + inf;
1437      if (spawn_application (p)) {      if (spawn_application ((char*)cmd.getBuffer ())) {
1438          fp = NULL;          fp = NULL;
1439          goto leave;          goto leave;
1440      }      }
# Line 1419  do_spawn_ldap_helper (const char *host, Line 1446  do_spawn_ldap_helper (const char *host,
1446  leave:  leave:
1447      DeleteFile (inf);      DeleteFile (inf);
1448      DeleteFile (outf);      DeleteFile (outf);
     free_if_alloc (p);  
1449      free_if_alloc (ksprg);      free_if_alloc (ksprg);
1450      return fp;      return fp;
1451  }  }
# Line 1428  leave: Line 1454  leave:
1454     @key contains the key on success. */     @key contains the key on success. */
1455  int  int
1456  ldap_recvkey (const char *host, const char *keyid,  ldap_recvkey (const char *host, const char *keyid,
1457                char **r_key, int *r_keylen)                char **r_key, size_t *r_keylen)
1458  {    {  
1459      gpgme_data_t raw;      gpgme_data_t raw;
1460      FILE *fp;      FILE *fp;
# Line 1444  ldap_recvkey (const char *host, const ch Line 1470  ldap_recvkey (const char *host, const ch
1470      if (gpgme_data_new (&raw))      if (gpgme_data_new (&raw))
1471          BUG (0);          BUG (0);
1472      while (!feof (fp)) {      while (!feof (fp)) {
1473          s = fgets (buf, sizeof (buf)-1, fp);          s = fgets (buf, DIM (buf)-1, fp);
1474          if (!s)          if (!s)
1475              break;              break;
1476          if (strstr (s, "KEY") && strstr (s, "FAILED")) {          if (strstr (s, "KEY") && strstr (s, "FAILED")) {
# Line 1474  ldap_recvkey (const char *host, const ch Line 1500  ldap_recvkey (const char *host, const ch
1500     On success @key contains the key. */     On success @key contains the key. */
1501  int  int
1502  finger_recvkey (const char *host, const char *user,  finger_recvkey (const char *host, const char *user,
1503                  char **r_key, int *r_keylen)                  char **r_key, size_t *r_keylen)
1504  {  {
1505      gpgme_data_t raw;      gpgme_data_t raw;
1506      char buf[256];      char buf[256+1];
1507      int fd, nread;      int fd, nread;
1508      int start_key = 0;      int start_key = 0;
1509      int rc=0;      int rc=0;
# Line 1490  finger_recvkey (const char *host, const Line 1516  finger_recvkey (const char *host, const
1516      sock_write (fd, "\r\n", 2);      sock_write (fd, "\r\n", 2);
1517    
1518      if (gpgme_data_new (&raw))      if (gpgme_data_new (&raw))
1519          BUG (0);          return WPTERR_WINSOCK_RECVKEY;
1520    
1521      for (;;) {      for (;;) {
1522          if (sock_getline (fd, buf, sizeof (buf), &nread))          if (sock_getline (fd, buf, DIM (buf)-1, &nread))
1523              break;              break;
1524          strcat (buf, "\n");          strcat (buf, "\n");
1525          if (strstr (buf, "BEGIN PGP PUBLIC KEY BLOCK")) {          if (strstr (buf, "BEGIN PGP PUBLIC KEY BLOCK")) {
# Line 1517  finger_recvkey (const char *host, const Line 1543  finger_recvkey (const char *host, const
1543  }  }
1544    
1545    
1546  /* Check if the given name @name is a valid hostname. */  /* Check if the given name @name is a valid inernet address
1547       which means an dotted IP or a valid DNS name.
1548       Return value: 0 on success. */
1549  int  int
1550  check_IP_or_hostname (const char *name)  check_inet_address (const char *addr)
1551  {  {
1552      const char *not_allowed = "=!�$%&@#*~\\/}][{<>|,;:'";      const char *not_allowed = "=!�$%&@#*~\\/}][{<>|,;:'";
1553      size_t i, j;      size_t i;
1554    
1555      for (i=0; i < strlen (name); i++) {      for (i=0; i < strlen (addr); i++) {
1556          for (j =0; j < strlen (not_allowed); j++) {          if (strchr (not_allowed, addr[i]))
1557              if (name[i] == not_allowed[j])              return -1;
                 return -1;  
         }  
1558      }      }
1559      return 0;      return 0;
1560  }  }
Legend:
Removed from v.231  
changed lines
  Added in v.290
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26