/[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 118 by twoaday, Mon Nov 14 15:01:01 2005 UTC revision 119 by twoaday, Fri Dec 9 08:04:51 2005 UTC
# Line 37  Line 37 
37  #include "wptGPG.h"  #include "wptGPG.h"
38  #include "wptRegistry.h"  #include "wptRegistry.h"
39    
40    #define net_errno ((int)WSAGetLastError ())
41    
42  static char base64code[] =  static char base64code[] =
43    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
44    
45  keyserver server[MAX_KEYSERVERS] = {0};  keyserver server[MAX_KEYSERVERS] = {0};
46  static keyserver_proxy_ctx proxy = {0};  static keyserver_proxy_ctx proxy = {0};
47  static const char * server_list[] = {  static const char *server_list[] = {
48      "hkp://wwwkeys.nl.pgp.net",      "hkp://wwwkeys.nl.pgp.net",
49      "hkp://wwwkeys.pl.pgp.net",      "hkp://wwwkeys.pl.pgp.net",
50      "hkp://wwwkeys.at.pgp.net",      "hkp://wwwkeys.at.pgp.net",
# Line 59  static const char * server_list[] = { Line 61  static const char * server_list[] = {
61      "ldap://keyserver.pgp.com",      "ldap://keyserver.pgp.com",
62      NULL      NULL
63  };  };
 static char hkp_errmsg[1024];  
 static int hkp_err = 0;  
 static u32 conf_timestamp = 0;  
 char * default_keyserver = NULL;  
 unsigned short default_keyserver_port = 0;  
64    
65    
66    static char  hkp_errmsg[1024];  /* Holds the error message from the server */
67    static int   hkp_err = 0;       /* != 0 indicates an error occurred. */
68    static DWORD conf_timestamp = 0;/* timestamp of the configuration fiele. */
69    
70    char    *default_keyserver = NULL;
71    WORD    default_keyserver_port = 0;
72    
73    
74    /* Basic64 encode the input @inputstr to @outputstr. */
75  static void  static void
76  base64_encode( const char *inputstr, char *outputstr, int maxlen )  base64_encode (const char *inputstr, char *outputstr, int maxlen)
77  {        {      
78      int index = 0, temp = 0, res = 0, i = 0, inputlen = 0, len = 0;      int index = 0, temp = 0, res = 0, i = 0, inputlen = 0, len = 0;
79            
80      inputlen = strlen (inputstr); /* fixme: check if len > maxlen */      /* XXX: check len < maxlen. */
81        inputlen = strlen (inputstr);
82      for (i = 0; i <inputlen; i++) {      for (i = 0; i <inputlen; i++) {
83          res = temp;          res = temp;
84          res = (res << 8) | (inputstr[i] & 0xFF);          res = (res << 8) | (inputstr[i] & 0xFF);
# Line 84  base64_encode( const char *inputstr, cha Line 91  base64_encode( const char *inputstr, cha
91          temp = res;          temp = res;
92      }      }
93            
94      switch( index ) {      switch (index) {
95      case 0: break;              case 0: break;        
96      case 2: outputstr[len++] = base64code[temp << 2 & 0x3F];          case 2: outputstr[len++] = base64code[temp << 2 & 0x3F];    
97              outputstr[len++] = '='; break;                      outputstr[len++] = '='; break;        
# Line 94  base64_encode( const char *inputstr, cha Line 101  base64_encode( const char *inputstr, cha
101      }      }
102            
103      outputstr[len] = '\0';      outputstr[len] = '\0';
104  } /* base64_encode */  }
105    
106    
107  /* Skip the URL schema and return only the host part of it. */  /* Skip the URL schema and return only the host part of it. */
108  static const char *  static const char*
109  skip_type_prefix (const char * hostname)  skip_type_prefix (const char *hostname)
110  {  {
111      if (hostname && !strncmp (hostname, "http://", 7))      if (hostname && !strncmp (hostname, "http://", 7))
112          hostname += 7;          hostname += 7;
# Line 117  skip_type_prefix (const char * hostname) Line 124  skip_type_prefix (const char * hostname)
124     Return 0 on success. */     Return 0 on success. */
125  static int  static int
126  check_hkp_response (const char *resp, int recv)  check_hkp_response (const char *resp, int recv)
127  {  {    
128        char *p, *end;
129      int ec, len;      int ec, len;
     char *p, * end;  
130    
131      ec = recv ? WPTERR_WINSOCK_RECVKEY : WPTERR_WINSOCK_SENDKEY;      ec = recv ? WPTERR_WINSOCK_RECVKEY : WPTERR_WINSOCK_SENDKEY;
132      if (!strstr (resp, "HTTP/1.0 200 OK") &&      if (!strstr (resp, "HTTP/1.0 200 OK") &&
# Line 132  check_hkp_response (const char *resp, in Line 139  check_hkp_response (const char *resp, in
139          if (p && strlen (p) < sizeof (hkp_errmsg)) {          if (p && strlen (p) < sizeof (hkp_errmsg)) {
140              end = strstr (p, "</p>");              end = strstr (p, "</p>");
141              len = end? (end - p + 1) : strlen (p);              len = end? (end - p + 1) : strlen (p);
142                memset (hkp_errmsg, 0, sizeof (hkp_errmsg));
143              strncpy (hkp_errmsg, p, len);              strncpy (hkp_errmsg, p, len);
144              hkp_err = 1;              hkp_err = 1;
145          }          }
# Line 155  sock_getline (int fd, char *buf, int buf Line 163  sock_getline (int fd, char *buf, int buf
163      while (recv (fd, &ch, 1, 0) > 0) {      while (recv (fd, &ch, 1, 0) > 0) {
164          *buf++ = ch;          *buf++ = ch;
165          count++;          count++;
166            /* XXX: remove the '\r' */
167          if (ch == '\n' || count == (buflen - 1)) {          if (ch == '\n' || count == (buflen - 1)) {
168              *buf = 0;              *buf = 0;
169              if (nbytes)              if (nbytes)
# Line 177  sock_select (int fd, int nsecs) Line 186  sock_select (int fd, int nsecs)
186    
187      FD_ZERO (&rfd);      FD_ZERO (&rfd);
188      FD_SET (fd, &rfd);      FD_SET (fd, &rfd);
189      if (select (fd + 1, &rfd, NULL, NULL, &tv) == SOCKET_ERROR)      if (select (fd + 1, &rfd, NULL, NULL, &tv) == SOCKET_ERROR) {
190            log_debug ("sock_select: select() failed ec=%d.\r\n", net_errno);
191          return SOCKET_ERROR;          return SOCKET_ERROR;
192        }
193      if (FD_ISSET (fd, &rfd))      if (FD_ISSET (fd, &rfd))
194          return 1;          return 1;
195      return 0;      return 0;
196  }  }
197    
198    
199  /* Read from a socket with a fixed timeout of 10 seconds.  /* Read from a socket @fd to buffer @buf with a fixed timeout
200       of 10 seconds. The amount of bytes which were read are
201       returned in @nbytes.
202     Return value: 0 on success. */     Return value: 0 on success. */
203  static int  static int
204  sock_read (int fd, char *buf, int buflen, int *nbytes)  sock_read (int fd, char *buf, int buflen, int *nbytes)
205  {        {      
206      int nread;      DWORD nread;
207      int nleft = buflen;      int nleft = buflen;
208      int rc, n = 0;      int rc, n = 0;
209    
# Line 199  sock_read (int fd, char *buf, int buflen Line 212  sock_read (int fd, char *buf, int buflen
212              return WPTERR_WINSOCK_TIMEOUT;              return WPTERR_WINSOCK_TIMEOUT;
213          rc = sock_select (fd, 1);          rc = sock_select (fd, 1);
214          if (rc == SOCKET_ERROR)          if (rc == SOCKET_ERROR)
215              return SOCKET_ERROR;              return rc;
216          else if( !rc )          else if (!rc)
217              n++;              n++;
218          else {          else {
219              nread = recv (fd, buf, nleft, 0);              nread = recv (fd, buf, nleft, 0);
220              if (nread == SOCKET_ERROR)              if (nread == SOCKET_ERROR) {
221                    log_debug ("sock_read: recv() failed ec=%d.\r\n", net_errno);
222                  return SOCKET_ERROR;                  return SOCKET_ERROR;
223                }
224              else if (!nread)              else if (!nread)
225                  break;                  break;
226              nleft -= nread;              nleft -= nread;
# Line 219  sock_read (int fd, char *buf, int buflen Line 234  sock_read (int fd, char *buf, int buflen
234  }  }
235    
236    
237  /* Write @buf to a socket @fd. */  /* Write the buffer @buf with the length @buflen to a socket @fd. */
238  static int  static int
239  sock_write (int fd, const char *buf, int buflen)  sock_write (int fd, const char *buf, int buflen)
240  {  {
241      int nwritten;      DWORD nwritten;
242      int nleft = buflen;      int nleft = buflen;
243    
244      while (nleft > 0) {      while (nleft > 0) {
245          nwritten = send (fd, buf, nleft, 0);          nwritten = send (fd, buf, nleft, 0);
246          if (nwritten == SOCKET_ERROR)          if (nwritten == SOCKET_ERROR) {
247                log_debug ("sock_write: send() failed ec=%d\r\n", net_errno);
248              return SOCKET_ERROR;              return SOCKET_ERROR;
249            }
250          nleft -= nwritten;          nleft -= nwritten;
251          buf += nwritten;                  buf += nwritten;        
252      }      }
# Line 238  sock_write (int fd, const char *buf, int Line 255  sock_write (int fd, const char *buf, int
255  }  }
256    
257    
258    /* Set the default keyserver. */
259  void  void
260  set_default_kserver (void)  set_default_kserver (void)
261  {  {
262      char * p = get_reg_entry_keyserver ("Default");      char *p = get_reg_entry_keyserver ("Default");
263      free_if_alloc (default_keyserver);      free_if_alloc (default_keyserver);
264      default_keyserver = p && *p != ' ' ? p : m_strdup (DEF_HKP_KEYSERVER);      default_keyserver = p && *p != ' ' ? p : m_strdup (DEF_HKP_KEYSERVER);
265      p = get_reg_entry_keyserver ("Default_Port");      p = get_reg_entry_keyserver ("Default_Port");
266      if (p && *p) {      if (p && *p) {
267          default_keyserver_port = (u16)strtoul (p, NULL, 10);          default_keyserver_port = (WORD)strtoul (p, NULL, 10);
268          free_if_alloc (p);          free_if_alloc (p);
269      }      }
270      else      else
# Line 260  wsock_init (void) Line 278  wsock_init (void)
278  {  {
279      WSADATA wsa;      WSADATA wsa;
280    
281      if (WSAStartup (0x202, &wsa))      if (WSAStartup (0x202, &wsa)) {
282            log_debug ("wsock_init: WSAStartup failed ec=%d\r\n", net_errno);
283          return WPTERR_WINSOCK_INIT;          return WPTERR_WINSOCK_INIT;
284        }
285      set_default_kserver ();      set_default_kserver ();
286      return 0;      return 0;
287  }  }
# Line 291  wsock_strerror (void) Line 311  wsock_strerror (void)
311      int ec = WSAGetLastError ();      int ec = WSAGetLastError ();
312            
313      switch (ec) {      switch (ec) {
314      case WSAENETDOWN:      case WSAENETDOWN:
315          return _("The network subsystem has failed");              return _("The network subsystem has failed");
316      case WSAHOST_NOT_FOUND:      case WSAHOST_NOT_FOUND:
317          return _("Authoritative Answer Host not found");          return _("Authoritative Answer Host not found");
318      case WSAETIMEDOUT:      case WSAETIMEDOUT:
319          return _("The connection has been dropped because of a network failure");          return _("The connection has been dropped because of a network failure");
320      default:      default:
321          _snprintf (buf, sizeof (buf) -1, _("Unknown Winsock error ec=%d"),ec);          _snprintf (buf, sizeof (buf) -1, _("Unknown Winsock error ec=%d"),ec);
322          return buf;          return buf;
323      }      }
# Line 318  kserver_strerror (void) Line 338  kserver_strerror (void)
338  /* Read a keyserver from the list at index @idx.  /* Read a keyserver from the list at index @idx.
339     Return value: keyserver name at the given position. */     Return value: keyserver name at the given position. */
340  const char*  const char*
341  kserver_get_hostname (int idx, int type, u16 *port)  kserver_get_hostname (int idx, int type, WORD *port)
342  {  {
343      if (type == -1) {      if (type == -1) {
344          *port = default_keyserver_port;          *port = default_keyserver_port;
# Line 347  kserver_check_inet_connection (void) Line 367  kserver_check_inet_connection (void)
367  }  }
368    
369    
370  /*  /* If the request contains the keyid, it have to be
371   * If the request contains the keyid, it have to be     always postfix with '0x'+keyid. This code checks
372   * always postfix with '0x'+keyid. This code checks     if the keyid is a decimal value and if so if it contains
373   * if the keyid is a decimal value and if so if it contains    the '0x'. If not it is inserted. */
  * the '0x'. If not it is inserted.  
  */  
374  const char*  const char*
375  kserver_check_keyid (const char *keyid)  kserver_check_keyid (const char *keyid)
376  {        {      
377      static char id[20];      static char id[21];
378    
379      if (strstr (keyid, "@"))      if (strstr (keyid, "@"))
380          return keyid; /* email address */          return keyid; /* email address */
# Line 366  kserver_check_keyid (const char *keyid) Line 384  kserver_check_keyid (const char *keyid)
384          return id;          return id;
385      }      }
386      return keyid;      return keyid;
387  } /* kserver_check_keyid */  }
388    
389    
390    /* Update the keyserver proxy user. */
391  static void  static void
392  kserver_update_proxyuser (const char *proxy_user, const char *proxy_pass)  kserver_update_proxyuser (const char *proxy_user, const char *proxy_pass)
393  {  {
# Line 386  kserver_update_proxyuser (const char *pr Line 405  kserver_update_proxyuser (const char *pr
405      free_if_alloc (proxy.pass);      free_if_alloc (proxy.pass);
406      proxy.user = m_strdup (proxy_user);      proxy.user = m_strdup (proxy_user);
407      proxy.pass = m_strdup (proxy_pass);      proxy.pass = m_strdup (proxy_pass);
408  } /* kserver_update_proxyuser */  }
409    
410    
411  /* Check that the given buffer contains a valid keyserver URL. */  /* Check that the given buffer contains a valid keyserver URL. */
# Line 430  proto_from_URL (const char * buf) Line 449  proto_from_URL (const char * buf)
449    
450    
451  void  void
452  keyserver_set_default (const char * hostname, u16 port)  keyserver_set_default (const char *hostname, WORD port)
453  {  {
454      if (hostname) {      if (hostname) {
455          free_if_alloc (default_keyserver);          free_if_alloc (default_keyserver);
# Line 443  keyserver_set_default (const char * host Line 462  keyserver_set_default (const char * host
462      server[0].used = 1;      server[0].used = 1;
463      server[0].port = port;      server[0].port = port;
464      server[0].proto = proto_from_URL (default_keyserver);      server[0].proto = proto_from_URL (default_keyserver);
465  } /* keyserver_set_default */  }
466    
467    
468  static const char *  /* Skip all kind of whitespace chars in @str. */
469  skip_whitespace (const char * str)  static const char*
470    skip_whitespace (const char *str)
471  {  {
472      while (str && *str)      while (str && *str) {
     {  
473          if (*str == ' ' ||          if (*str == ' ' ||
474              *str == '\t' ||              *str == '\t' ||
475              *str == '\n' ||              *str == '\n' ||
476              *str == '\r')              *str == '\r') {
         {  
477              str++;              str++;
478              continue;              continue;
479          }          }
# Line 470  kserver_load_conf (const char * conf) Line 488  kserver_load_conf (const char * conf)
488  {  {
489      struct stat statbuf;      struct stat statbuf;
490      FILE *fp;      FILE *fp;
491      char buf[1024], * s, *p;      char buf[1024], * s, * p;
492      char *user = NULL, *pass = NULL;          char *user = NULL, *pass = NULL;    
     int pos;  
493      int no_config=0, chk_pos=0;      int no_config=0, chk_pos=0;
494        int pos;
495            
496      for (pos = 0; pos < MAX_KEYSERVERS; pos++) {      for (pos = 0; pos < MAX_KEYSERVERS; pos++) {
497          server[pos].used = 0;          server[pos].used = 0;
# Line 499  kserver_load_conf (const char * conf) Line 517  kserver_load_conf (const char * conf)
517      }      }
518      /* check if the host has a http:// prefix and skip it */      /* check if the host has a http:// prefix and skip it */
519      if( proxy.host && !strncmp( proxy.host, "http://", 7 ) ) {      if( proxy.host && !strncmp( proxy.host, "http://", 7 ) ) {
520          char *pr = m_strdup (proxy.host+7);          char *host = m_strdup (proxy.host+7);
521          if (!pr)          if (!host)
522              BUG (NULL);              BUG (0);
523          free_if_alloc (proxy.host);          free_if_alloc (proxy.host);
524          proxy.host = pr;          proxy.host = host;
525      }      }
526      free_if_alloc (user);      free_if_alloc (user);
527      free_if_alloc (pass);      free_if_alloc (pass);
# Line 546  kserver_load_conf (const char * conf) Line 564  kserver_load_conf (const char * conf)
564              memcpy (server[pos].name, s, (p-s));              memcpy (server[pos].name, s, (p-s));
565          }          }
566          pos++;          pos++;
567          if (pos > MAX_KEYSERVERS) {          if (pos > MAX_KEYSERVERS)
568            {
569              msg_box (NULL, _("The keyserver limit is exceeded"), _("Keyserver Warning"), MB_INFO);              msg_box (NULL, _("The keyserver limit is exceeded"), _("Keyserver Warning"), MB_INFO);
570              break;              break;
571          }          }
# Line 566  kserver_load_conf (const char * conf) Line 585  kserver_load_conf (const char * conf)
585  } /* kserver_load_conf */  } /* kserver_load_conf */
586    
587    
588  const char *  /* Return the proxy host and port if available. Null otherwise. */
589  kserver_get_proxy (int * r_port)  const char*
590    kserver_get_proxy (int *r_port)
591  {  {
592      if (proxy.host) {      if (proxy.host) {
593          if (r_port)          if (r_port)
# Line 575  kserver_get_proxy (int * r_port) Line 595  kserver_get_proxy (int * r_port)
595          return proxy.host;          return proxy.host;
596      }      }
597      return NULL;      return NULL;
598  } /* kserver_get_proxy */  }
599    
600    
601  const char *  /* Return a requested item from the proxy environment. */
602    const char*
603  kserver_get_proxy_info (int id)  kserver_get_proxy_info (int id)
604  {  {
605      switch (id) {        switch (id) {  
# Line 586  kserver_get_proxy_info (int id) Line 607  kserver_get_proxy_info (int id)
607      case PROXY_PASS: return proxy.pass;      case PROXY_PASS: return proxy.pass;
608      }      }
609      return NULL;      return NULL;
610  } /* kserver_get_proxy_info */  }
611    
612    
613  /* Connect to the keyserver @hostname. */  /* Connect to the keyserver @hostname (port @port).
614       Return value: 0 on success */
615  int  int
616  kserver_connect (const char *hostname, u16 port, int *conn_fd)  kserver_connect (const char *hostname, WORD port, int *conn_fd)
617  {  {
618      int rc, fd;      int rc, fd;
619      u32 iaddr;      DWORD iaddr;
620      char host[128] = {0};      char host[128] = {0};
621      struct hostent *hp;      struct hostent *hp;
622      struct sockaddr_in sock;      struct sockaddr_in sock;
# Line 625  kserver_connect (const char *hostname, u Line 647  kserver_connect (const char *hostname, u
647          memcpy (&sock.sin_addr, hp->h_addr, hp->h_length);          memcpy (&sock.sin_addr, hp->h_addr, hp->h_length);
648      }      }
649      else {      else {
650          log_debug ("gethostbyname: failed.\r\n");          log_debug ("gethostbyname: failed ec=%d.\r\n", net_errno);
651          return WPTERR_WINSOCK_RESOLVE;          return WPTERR_WINSOCK_RESOLVE;
652      }      }
653      fd = socket (AF_INET, SOCK_STREAM, 0);      fd = socket (AF_INET, SOCK_STREAM, 0);
# Line 633  kserver_connect (const char *hostname, u Line 655  kserver_connect (const char *hostname, u
655          return WPTERR_WINSOCK_SOCKET;          return WPTERR_WINSOCK_SOCKET;
656      rc = connect (fd, (struct sockaddr *) &sock, sizeof (sock));      rc = connect (fd, (struct sockaddr *) &sock, sizeof (sock));
657      if (rc == SOCKET_ERROR) {      if (rc == SOCKET_ERROR) {
658          log_debug ("connect: failed.\r\n");          log_debug ("connect: failed ec=%d.\r\n", net_errno);
659          closesocket (fd);          closesocket (fd);
660          return WPTERR_WINSOCK_CONNECT;          return WPTERR_WINSOCK_CONNECT;
661      }      }
# Line 642  kserver_connect (const char *hostname, u Line 664  kserver_connect (const char *hostname, u
664          *conn_fd = fd;          *conn_fd = fd;
665      WSASetLastError (0);      WSASetLastError (0);
666      return 0;      return 0;
667  } /* kserver_connect */  }
668    
669    
670  /* Perform URL-encoding on the given pubkey blob. */  /* Perform URL-encoding on the given pubkey blob. */
# Line 650  static char* Line 672  static char*
672  kserver_urlencode (const char *pubkey, size_t octets, size_t *newlen)  kserver_urlencode (const char *pubkey, size_t octets, size_t *newlen)
673  {  {
674      char *p, numbuf[5];      char *p, numbuf[5];
675      size_t j = 0;      size_t j;
676      size_t i, size;      size_t i, size;
677            
678      p = new char [2*octets];      p = new char [2*octets+1];
679      if (!p)      if (!p)
680          BUG (0);          BUG (0);
681    
682      for (size=0, i=0; i < octets; i++) {      for (size = 0, i = 0; i < octets; i++) {
683          if (isalnum (pubkey[i]) || pubkey[i] == '-') {          if (isalnum (pubkey[i]) || pubkey[i] == '-') {
684              p[size] = pubkey[i];              p[size] = pubkey[i];
685              size++;              size++;
# Line 667  kserver_urlencode (const char *pubkey, s Line 689  kserver_urlencode (const char *pubkey, s
689              size++;              size++;
690          }          }
691          else {          else {
692              sprintf(numbuf, "%%%02X", pubkey[i]);              sprintf (numbuf, "%%%02X", pubkey[i]);
693              for (j = 0; j<strlen(numbuf); j++) {              for (j = 0; j < strlen (numbuf); j++) {
694                  p[size] = numbuf[j];                  p[size] = numbuf[j];
695                  size++;                  size++;
696              }              }
697          }          }
698      }      }
# Line 682  kserver_urlencode (const char *pubkey, s Line 704  kserver_urlencode (const char *pubkey, s
704    
705  /* Format a request for the given keyid (send). */  /* Format a request for the given keyid (send). */
706  static char*  static char*
707  kserver_send_request (const char *hostname, u16 port, const char *pubkey, int octets)  kserver_send_request (const char *hostname, WORD port,
708                          const char *pubkey, int octets)
709  {  {
710      char *request = NULL, *enc_pubkey = NULL;      char *request = NULL;
711      int reqlen;      char *enc_pubkey = NULL;
712      size_t enc_octets;      size_t enc_octets;
713        int reqlen;
714    
715      log_debug ("kserver_send_request: %s:%d\n", hostname, port);      log_debug ("kserver_send_request: %s:%d\r\n", hostname, port);
716    
717      if (!port)      if (!port)
718          port = HKP_PORT;          port = HKP_PORT;
# Line 728  kserver_send_request (const char *hostna Line 752  kserver_send_request (const char *hostna
752                     "\r\n"                     "\r\n"
753                     "keytext=%s"                     "keytext=%s"
754                     "\n",                     "\n",
755                     skip_type_prefix (hostname), port, enc_octets+9, enc_pubkey);                     skip_type_prefix (hostname), port,
756                       enc_octets+9, enc_pubkey);
757      }      }
758      free_if_alloc (enc_pubkey);      free_if_alloc (enc_pubkey);
759    
760      log_debug ("%s\n", request);      log_debug ("%s\r\n", request);
761      return request;      return request;
762  } /* kserver_send_request */  }
763    
764    
765  /* Interface receiving a public key. */  /* Interface for receiving a public key. */
766  int  int
767  kserver_recvkey (const char *hostname, u16 port, const char *keyid, char *key, int maxkeylen)  kserver_recvkey (const char *hostname, WORD port, const char *keyid,
768  {                         char *key, int maxkeylen)
769      int rc, n;  {
     int conn_fd;  
770      char *request = NULL;      char *request = NULL;
771            int conn_fd;
772        int rc, n;
773    
774      if (!port)      if (!port)
775          port = HKP_PORT;          port = HKP_PORT;
776      hkp_err = 0; /* reset */          hkp_err = 0; /* reset */    
# Line 797  leave: Line 823  leave:
823      closesocket (conn_fd);      closesocket (conn_fd);
824      free_if_alloc (request);      free_if_alloc (request);
825      return rc;      return rc;
826  } /* kserver_recvkey */  }
827    
828    
829  /* Interface to send a public key. */  /* Interface to send a public key. */
830  int  int
831  kserver_sendkey (const char *hostname, u16 port, const char *pubkey, int len )  kserver_sendkey (const char *hostname, WORD port, const char *pubkey, int len )
832  {  {
     int n, rc;  
     int conn_fd;  
833      char *request = NULL;      char *request = NULL;
834      char log[2048];      char log[2048];
835        int conn_fd, n;
836        int rc;
837            
838      hkp_err = 0; /* reset */      hkp_err = 0; /* reset */
839      rc = kserver_connect (hostname, port, &conn_fd);      rc = kserver_connect (hostname, port, &conn_fd);
# Line 820  kserver_sendkey (const char *hostname, u Line 846  kserver_sendkey (const char *hostname, u
846          goto leave;              goto leave;    
847      }      }
848            
849      rc = sock_write( conn_fd, request, lstrlen(request) );      rc = sock_write (conn_fd, request, strlen (request));
850      if( rc == SOCKET_ERROR ) {      if (rc == SOCKET_ERROR) {
851          rc = WPTERR_WINSOCK_SENDKEY;          rc = WPTERR_WINSOCK_SENDKEY;
852          goto leave;              goto leave;    
853      }      }
854            
855      rc = sock_read( conn_fd, log, sizeof (log)-1, &n );      rc = sock_read (conn_fd, log, sizeof (log)-1, &n);
856      if( rc == SOCKET_ERROR ) {      if (rc == SOCKET_ERROR) {
857          rc = WPTERR_WINSOCK_SENDKEY;          rc = WPTERR_WINSOCK_SENDKEY;
858          goto leave;          goto leave;
859      }      }
860    
861      log_debug ("kserver_sendkey:\r\n%s\r\n", log);      log_debug ("kserver_sendkey:\r\n%s\r\n", log);
       
862      rc = check_hkp_response (log, 0);      rc = check_hkp_response (log, 0);
863      if( rc )      if (rc)
864          goto leave;          goto leave;
865            
866      WSASetLastError (0);      WSASetLastError (0);
# Line 844  leave: Line 869  leave:
869      closesocket (conn_fd);      closesocket (conn_fd);
870      free_if_alloc (request);      free_if_alloc (request);
871      return rc;      return rc;
872  } /* kserver_sendkey */  }
873    
874    
875  int  int
876  kserver_search_init (const char * hostname, u16 port, const char * keyid, int * conn_fd)  kserver_search_init (const char *hostname, WORD port,
877                         const char *keyid, int *conn_fd)
878  {  {
879      int rc, sock_fd;      char *request = NULL;
880      int n=0;      int n=0;
881      char * request = NULL;      int rc, sock_fd;
882        
883      rc = kserver_connect (hostname, port, &sock_fd);      rc = kserver_connect (hostname, port, &sock_fd);
884      if (rc) {      if (rc) {
885          *conn_fd = 0;          *conn_fd = 0;
# Line 893  kserver_search_init (const char * hostna Line 919  kserver_search_init (const char * hostna
919  leave:  leave:
920      free_if_alloc (request);      free_if_alloc (request);
921      return rc;      return rc;
922  } /* kserver_search_init */  }
923    
924    
925    /* Check keyserver response. */
926  int  int
927  kserver_search_chkresp (int fd)  kserver_search_chkresp (int fd)
928  {  {
# Line 912  kserver_search_chkresp (int fd) Line 939  kserver_search_chkresp (int fd)
939      if (strncmp (buf+(8+1), "200", 3))      if (strncmp (buf+(8+1), "200", 3))
940          return WPTERR_KEYSERVER_NOTFOUND;          return WPTERR_KEYSERVER_NOTFOUND;
941      return 0;      return 0;
942  } /* kserver_search_chkresp */  }
943    
944    
945  int  int
# Line 921  kserver_search (int fd, keyserver_key * Line 948  kserver_search (int fd, keyserver_key *
948      char buf[1024], *p;      char buf[1024], *p;
949      int uidlen, nbytes, pos = 0;      int uidlen, nbytes, pos = 0;
950    
951      log_debug ("keyserver_search:\n");      log_debug ("keyserver_search:\r\n");
952            
953      if (sock_getline (fd, buf, sizeof (buf) - 1, &nbytes))      if (sock_getline (fd, buf, sizeof (buf) - 1, &nbytes))
954          return WPTERR_GENERAL;          return WPTERR_GENERAL;
955    
956      log_debug ("%s\n", buf);      log_debug ("%s\r\n", buf);
957            
958      if (!strncmp (buf, "pub", 3)) {      if (!strncmp (buf, "pub", 3)) {
959          int revoked = strstr (buf, "KEY REVOKED") != NULL? 1 : 0;          int revoked = strstr (buf, "KEY REVOKED") != NULL? 1 : 0;
# Line 959  kserver_search (int fd, keyserver_key * Line 986  kserver_search (int fd, keyserver_key *
986          p = strchr (key->uid, '&');          p = strchr (key->uid, '&');
987          if (p) {          if (p) {
988              key->uid[(p-key->uid)] = '<';              key->uid[(p-key->uid)] = '<';
989              memmove (key->uid+(p-key->uid)+1, key->uid+(p-key->uid)+4, strlen (key->uid)-3);              memmove (key->uid+(p-key->uid)+1, key->uid+(p-key->uid)+4,
990                         strlen (key->uid)-3);
991          }          }
992          return 0;          return 0;
993      }      }
# Line 982  add_node( keyserver_cfgfile *cfg, const Line 1010  add_node( keyserver_cfgfile *cfg, const
1010          return WPTERR_GENERAL;            return WPTERR_GENERAL;  
1011      node = new keyserver_node;      node = new keyserver_node;
1012      if( !node )      if( !node )
1013          BUG( NULL );          BUG (NULL);
1014            
1015      memset( node, 0, sizeof *node );      memset( node, 0, sizeof *node );
1016      node->used = 1;      node->used = 1;
# Line 1084  kserver_cfgfile_release( keyserver_cfgfi Line 1112  kserver_cfgfile_release( keyserver_cfgfi
1112  } /* kserver_cfgfile_release */  } /* kserver_cfgfile_release */
1113    
1114    
1115    /* Release mbmers in the proxy context @ctx. */
1116  void  void
1117  proxy_release( keyserver_proxy_ctx *ctx )  proxy_release( keyserver_proxy_ctx *ctx )
1118  {  {
1119      free_if_alloc( ctx->host );      free_if_alloc (ctx->host);
1120      free_if_alloc( ctx->pass );      free_if_alloc (ctx->pass);
1121      free_if_alloc( ctx->user );      free_if_alloc (ctx->user);
1122  } /* proxy_release */  }
1123    
1124    
1125    /* Receive an key via LDAP from host @host with the keyid @keyid.
1126       @key contains the key on success. */
1127  int  int
1128  ldap_recvkey (const char * host, const char * keyid, char * key, int maxkeylen)  ldap_recvkey (const char *host, const char *keyid, char *key, int maxkeylen)
1129  {  {
1130      const char *s;      const char *s;
1131      char *ksprg = NULL, *p = NULL;      char *ksprg = NULL, *p = NULL;
# Line 1186  leave: Line 1217  leave:
1217      free_if_alloc( p );      free_if_alloc( p );
1218      free_if_alloc( ksprg );      free_if_alloc( ksprg );
1219      return rc;      return rc;
1220  } /* ldap_recvkey */  }
1221    
1222    
1223  static int  static int
1224  finger_readline (int fd, char * buf, int nbytes)  finger_readline (int fd, char *buf, int nbytes)
1225  {  {
1226      char c = 0;      char c = 0;
1227      int n, pos = 0;      int n, pos = 0;
# Line 1212  finger_readline (int fd, char * buf, int Line 1243  finger_readline (int fd, char * buf, int
1243  }  }
1244    
1245    
1246    /* Receive an key via FINGER from host @host with the user @user.
1247       On success @key contains the key. */
1248  int  int
1249  finger_recvkey (const char * host, const char * user, char * key, int maxkeylen)  finger_recvkey (const char *host, const char *user, char *key, int maxkeylen)
1250  {  {
1251      struct hostent * hp;      struct hostent * hp;
1252      struct sockaddr_in saddr;      struct sockaddr_in saddr;
# Line 1271  finger_recvkey (const char * host, const Line 1304  finger_recvkey (const char * host, const
1304  }  }
1305    
1306    
1307    /* Check if the given name @name is a valid hostname. */
1308  int  int
1309  check_IP_or_hostname (const char *name)  check_IP_or_hostname (const char *name)
1310  {  {
Legend:
Removed from v.118  
changed lines
  Added in v.119
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26