util/http.c

   1 /* http.c  -  HTTP protocol handler
   2  * Copyright (C) 1999, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
   3  *
   4  * This file is part of GnuPG.
   5  *
   6  * GnuPG is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * GnuPG is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  19  */
  20
  21 #include <config.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <stdarg.h>
  25 #include <string.h>
  26 #include <ctype.h>
  27 #include <errno.h>
  28
  29 #ifdef _WIN32
  30 #include <windows.h>
  31 #else
  32 #include <unistd.h>
  33 #include <sys/types.h>
  34 #include <sys/socket.h>
  35 #include <sys/time.h>
  36 #include <time.h>
  37 #include <netinet/in.h>
  38 #include <arpa/inet.h>
  39 #include <netdb.h>
  40 #endif
  41
  42 #include "util.h"
  43 #include "iobuf.h"
  44 #include "i18n.h"
  45 #include "http.h"
  46 #include "srv.h"
  47
  48 #ifdef _WIN32
  49 #define sock_close(a)  closesocket(a)
  50 #else
  51 #define sock_close(a)  close(a)
  52 #endif
  53
  54 #define MAX_LINELEN 20000  /* max. length of a HTTP line */
  55 #define VALID_URI_CHARS "abcdefghijklmnopqrstuvwxyz"   \
  56                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"   \
  57                         "01234567890@"                 \
  58                         "!\"#$%&'()*+,-./:;<=>?[\\]^_{|}~"
  59
  60 #ifndef EAGAIN
  61 #define EAGAIN  EWOULDBLOCK
  62 #endif
  63
  64 static int parse_uri( PARSED_URI *ret_uri, const char *uri );
  65 static void release_parsed_uri( PARSED_URI uri );
  66 static int do_parse_uri( PARSED_URI uri, int only_local_part );
  67 static int remove_escapes( byte *string );
  68 static int insert_escapes( byte *buffer, const byte *string,
  69                                          const byte *special );
  70 static URI_TUPLE parse_tuple( byte *string );
  71 static int send_request( HTTP_HD hd, const char *proxy );
  72 static byte *build_rel_path( PARSED_URI uri );
  73 static int parse_response( HTTP_HD hd );
  74
  75 static int connect_server(const char *server, ushort port, unsigned int flags);
  76 static int write_server( int sock, const char *data, size_t length );
  77
  78 #ifdef _WIN32
  79 static void
  80 deinit_sockets (void)
  81 {
  82     WSACleanup();
  83 }
  84
  85 static void
  86 init_sockets (void)
  87 {
  88     static int initialized;
  89     static WSADATA wsdata;
  90
  91     if (initialized)
  92         return;
  93
  94     if( WSAStartup( 0x0101, &wsdata ) ) {
  95         log_error ("error initializing socket library: ec=%d\n",
  96                     (int)WSAGetLastError () );
  97         return;
  98     }
  99     if( wsdata.wVersion < 0x0001 ) {
 100         log_error ("socket library version is %x.%x - but 1.1 needed\n",
 101                    LOBYTE(wsdata.wVersion), HIBYTE(wsdata.wVersion));
 102         WSACleanup();
 103         return;
 104     }
 105     atexit ( deinit_sockets );
 106     initialized = 1;
 107 }
 108 #endif /*_WIN32*/
 109
 110 static byte bintoasc[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 111                          "abcdefghijklmnopqrstuvwxyz"
 112                          "0123456789+/";
 113
 114 /****************
 115  * create a radix64 encoded string.
 116  */
 117
 118 /* TODO: This is a duplicate of code in g10/armor.c.  Better to use a
 119    single copy in strgutil.c */
 120 static char *
 121 make_radix64_string( const byte *data, size_t len )
 122 {
 123     char *buffer, *p;
 124
 125     buffer = p = m_alloc( (len+2)/3*4 + 1 );
 126     for( ; len >= 3 ; len -= 3, data += 3 ) {
 127         *p++ = bintoasc[(data[0] >> 2) & 077];
 128         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
 129         *p++ = bintoasc[(((data[1]<<2)&074)|((data[2]>>6)&03))&077];
 130         *p++ = bintoasc[data[2]&077];
 131     }
 132     if( len == 2 ) {
 133         *p++ = bintoasc[(data[0] >> 2) & 077];
 134         *p++ = bintoasc[(((data[0] <<4)&060)|((data[1] >> 4)&017))&077];
 135         *p++ = bintoasc[((data[1]<<2)&074)];
 136     }
 137     else if( len == 1 ) {
 138         *p++ = bintoasc[(data[0] >> 2) & 077];
 139         *p++ = bintoasc[(data[0] <<4)&060];
 140     }
 141     *p = 0;
 142     return buffer;
 143 }
 144
 145 int
 146 http_open( HTTP_HD hd, HTTP_REQ_TYPE reqtype, const char *url,
 147            unsigned int flags, const char *proxy )
 148 {
 149     int rc;
 150
 151     if( !(reqtype == HTTP_REQ_GET || reqtype == HTTP_REQ_POST) )
 152         return G10ERR_INV_ARG;
 153
 154     /* initialize the handle */
 155     memset( hd, 0, sizeof *hd );
 156     hd->sock = -1;
 157     hd->initialized = 1;
 158     hd->req_type = reqtype;
 159     hd->flags = flags;
 160
 161     rc = parse_uri( &hd->uri, url );
 162     if( !rc ) {
 163         rc = send_request( hd, proxy );
 164         if( !rc ) {
 165             hd->fp_write = iobuf_sockopen( hd->sock , "w" );
 166             if( hd->fp_write )
 167                 return 0;
 168             rc = G10ERR_GENERAL;
 169         }
 170     }
 171
 172     if( !hd->fp_read && !hd->fp_write && hd->sock != -1 )
 173         sock_close( hd->sock );
 174     iobuf_close( hd->fp_read );
 175     iobuf_close( hd->fp_write);
 176     release_parsed_uri( hd->uri );
 177     hd->initialized = 0;
 178
 179     return rc;
 180 }
 181
 182
 183 void
 184 http_start_data( HTTP_HD hd )
 185 {
 186     iobuf_flush ( hd->fp_write );
 187     if( !hd->in_data ) {
 188         write_server (hd->sock, "\r\n", 2);
 189         hd->in_data = 1;
 190     }
 191 }
 192
 193
 194 int
 195 http_wait_response( HTTP_HD hd, unsigned int *ret_status )
 196 {
 197     int rc;
 198
 199     http_start_data( hd ); /* make sure that we are in the data */
 200
 201 #if 0
 202     hd->sock = dup( hd->sock );
 203     if( hd->sock == -1 )
 204         return G10ERR_GENERAL;
 205 #endif
 206     iobuf_ioctl (hd->fp_write, 1, 1, NULL); /* keep the socket open */
 207     iobuf_close (hd->fp_write);
 208     hd->fp_write = NULL;
 209     if ( !(hd->flags & HTTP_FLAG_NO_SHUTDOWN) )
 210         shutdown( hd->sock, 1 );
 211     hd->in_data = 0;
 212
 213     hd->fp_read = iobuf_sockopen( hd->sock , "r" );
 214     if( !hd->fp_read )
 215         return G10ERR_GENERAL;
 216
 217     rc = parse_response( hd );
 218     if( !rc && ret_status )
 219         *ret_status = hd->status_code;
 220
 221     return rc;
 222 }
 223
 224
 225 int
 226 http_open_document( HTTP_HD hd, const char *document,
 227                     unsigned int flags, const char *proxy )
 228 {
 229     int rc;
 230
 231     rc = http_open( hd, HTTP_REQ_GET, document, flags, proxy );
 232     if( rc )
 233         return rc;
 234
 235     rc = http_wait_response( hd, NULL );
 236     if( rc )
 237         http_close( hd );
 238
 239     return rc;
 240 }
 241
 242
 243 void
 244 http_close( HTTP_HD hd )
 245 {
 246     if( !hd || !hd->initialized )
 247         return;
 248     if( !hd->fp_read && !hd->fp_write && hd->sock != -1 )
 249         sock_close( hd->sock );
 250     iobuf_close( hd->fp_read );
 251     iobuf_close( hd->fp_write );
 252     release_parsed_uri( hd->uri );
 253     m_free( hd->buffer );
 254     hd->initialized = 0;
 255 }
 256
 257
 258
 259 /****************
 260  * Parse an URI and put the result into the newly allocated ret_uri.
 261  * The caller must always use release_parsed_uri to releases the
 262  * resources (even on an error).
 263  */
 264 static int
 265 parse_uri( PARSED_URI *ret_uri, const char *uri )
 266 {
 267    *ret_uri = m_alloc_clear( sizeof(**ret_uri) + strlen(uri) );
 268    strcpy( (*ret_uri)->buffer, uri );
 269    return do_parse_uri( *ret_uri, 0 );
 270 }
 271
 272 static void
 273 release_parsed_uri( PARSED_URI uri )
 274 {
 275     if( uri )
 276     {
 277         URI_TUPLE r, r2;
 278
 279         for( r = uri->query; r; r = r2 ) {
 280             r2 = r->next;
 281             m_free( r );
 282         }
 283         m_free( uri );
 284     }
 285 }
 286
 287 static int
 288 do_parse_uri( PARSED_URI uri, int only_local_part )
 289 {
 290     URI_TUPLE *tail;
 291     char *p, *p2, *p3;
 292     int n;
 293
 294     p = uri->buffer;
 295     n = strlen( uri->buffer );
 296     /* initialize all fields to an empty string or an empty list */
 297     uri->scheme = uri->host = uri->path = p + n;
 298     uri->port = 0;
 299     uri->params = uri->query = NULL;
 300
 301     /* a quick validity check */
 302     if( strspn( p, VALID_URI_CHARS) != n )
 303         return G10ERR_BAD_URI; /* invalid characters found */
 304
 305     if( !only_local_part ) {
 306         /* find the scheme */
 307         if( !(p2 = strchr( p, ':' ) ) || p2 == p )
 308            return G10ERR_BAD_URI; /* No scheme */
 309         *p2++ = 0;
 310         strlwr( p );
 311         uri->scheme = p;
 312         uri->port = 80;
 313         if( !strcmp( uri->scheme, "http" ) )
 314             ;
 315         else if( !strcmp( uri->scheme, "x-hkp" ) ) /* same as HTTP */
 316             uri->port = 11371;
 317         else
 318             return G10ERR_INVALID_URI; /* Unsupported scheme */
 319
 320         p = p2;
 321
 322         /* find the hostname */
 323         if( *p != '/' )
 324             return G10ERR_INVALID_URI; /* does not start with a slash */
 325
 326         p++;
 327         if( *p == '/' ) {  /* there seems to be a hostname */
 328             p++;
 329             if( (p2 = strchr(p, '/')) )
 330                 *p2++ = 0;
 331
 332             /* Check for username/password encoding */
 333             if((p3=strchr(p,'@')))
 334               {
 335                 uri->auth=p;
 336                 *p3++='\0';
 337                 p=p3;
 338               }
 339
 340             strlwr( p );
 341             uri->host = p;
 342             if( (p3=strchr( p, ':' )) ) {
 343                 *p3++ = 0;
 344                 uri->port = atoi( p3 );
 345             }
 346
 347             uri->host = p;
 348             if( (n = remove_escapes( uri->host )) < 0 )
 349                 return G10ERR_BAD_URI;
 350             if( n != strlen( p ) )
 351                 return G10ERR_BAD_URI; /* hostname with a Nul in it */
 352             p = p2 ? p2 : NULL;
 353         }
 354     } /* end global URI part */
 355
 356     /* parse the pathname part */
 357     if( !p || !*p ) /* we don't have a path */
 358         return 0; /* and this is okay */
 359
 360     /* todo: here we have to check params */
 361
 362     /* do we have a query part */
 363     if( (p2 = strchr( p, '?' )) )
 364         *p2++ = 0;
 365
 366     uri->path = p;
 367     if( (n = remove_escapes( p )) < 0 )
 368         return G10ERR_BAD_URI;
 369     if( n != strlen( p ) )
 370         return G10ERR_BAD_URI; /* path with a Nul in it */
 371     p = p2 ? p2 : NULL;
 372
 373     if( !p || !*p ) /* we don't have a query string */
 374         return 0;   /* okay */
 375
 376     /* now parse the query string */
 377     tail = &uri->query;
 378     for(;;) {
 379         URI_TUPLE elem;
 380
 381         if( (p2 = strchr( p, '&' )) )
 382             *p2++ = 0;
 383         if( !(elem = parse_tuple( p )) )
 384             return G10ERR_BAD_URI;
 385         *tail = elem;
 386         tail = &elem->next;
 387
 388         if( !p2 )
 389            break; /* ready */
 390         p = p2;
 391     }
 392
 393     return 0;
 394 }
 395
 396
 397
 398 /****************
 399  * Remove all %xx escapes; this is done inplace.
 400  * Returns: new length of the string.
 401  */
 402 static int
 403 remove_escapes( byte *string )
 404 {
 405     int n = 0;
 406     byte *p, *s;
 407
 408     for(p=s=string; *s ; s++ ) {
 409         if( *s == '%' ) {
 410             if( s[1] && s[2] && isxdigit(s[1]) && isxdigit(s[2]) ) {
 411                 s++;
 412                 *p  = *s >= '0' && *s <= '9' ? *s - '0' :
 413                       *s >= 'A' && *s <= 'F' ? *s - 'A' + 10 : *s - 'a' + 10 ;
 414                 *p <<= 4;
 415                 s++;
 416                 *p |= *s >= '0' && *s <= '9' ? *s - '0' :
 417                       *s >= 'A' && *s <= 'F' ? *s - 'A' + 10 : *s - 'a' + 10 ;
 418                 p++;
 419                 n++;
 420             }
 421             else {
 422                 *p++ = *s++;
 423                 if( *s )
 424                    *p++ = *s++;
 425                 if( *s )
 426                    *p++ = *s++;
 427                 if( *s )
 428                    *p = 0;
 429                 return -1; /* bad URI */
 430             }
 431         }
 432         else
 433         {
 434             *p++ = *s;
 435             n++;
 436         }
 437     }
 438     *p = 0; /* always keep a string terminator */
 439     return n;
 440 }
 441
 442
 443 static int
 444 insert_escapes( byte *buffer, const byte *string, const byte *special )
 445 {
 446     int n = 0;
 447
 448     for( ; *string; string++ ) {
 449         if( strchr( VALID_URI_CHARS, *string )
 450             && !strchr( special, *string ) )  {
 451             if( buffer )
 452                 *buffer++ = *string;
 453             n++;
 454         }
 455         else {
 456             if( buffer ) {
 457                 sprintf( buffer, "%%%02X", *string );
 458                 buffer += 3;
 459             }
 460             n += 3;
 461         }
 462     }
 463     return n;
 464 }
 465
 466
 467 static URI_TUPLE
 468 parse_tuple( byte *string )
 469 {
 470     byte *p = string;
 471     byte *p2;
 472     int n;
 473     URI_TUPLE tuple;
 474
 475     if( (p2 = strchr( p, '=' )) )
 476         *p2++ = 0;
 477     if( (n = remove_escapes( p )) < 0 )
 478         return NULL; /* bad URI */
 479     if( n != strlen( p ) )
 480        return NULL; /* name with a Nul in it */
 481     tuple = m_alloc_clear( sizeof *tuple );
 482     tuple->name = p;
 483     if( !p2 )  {
 484         /* we have only the name, so we assume an empty value string */
 485         tuple->value = p + strlen(p);
 486         tuple->valuelen = 0;
 487     }
 488     else { /* name and value */
 489         if( (n = remove_escapes( p2 )) < 0 ) {
 490             m_free( tuple );
 491             return NULL; /* bad URI */
 492         }
 493         tuple->value = p2;
 494         tuple->valuelen = n;
 495     }
 496     return tuple;
 497 }
 498
 499
 500 /****************
 501  * Send a HTTP request to the server
 502  * Returns 0 if the request was successful
 503  */
 504 static int
 505 send_request( HTTP_HD hd, const char *proxy )
 506 {
 507     const byte *server;
 508     byte *request, *p;
 509     ushort port;
 510     int rc;
 511     char *auth=NULL;
 512
 513     server = *hd->uri->host? hd->uri->host : "localhost";
 514     port   = hd->uri->port?  hd->uri->port : 80;
 515
 516     if(proxy)
 517       {
 518         PARSED_URI uri;
 519
 520         rc = parse_uri( &uri, proxy );
 521         if (rc)
 522           {
 523             log_error("invalid HTTP proxy (%s): %s\n",proxy,g10_errstr(rc));
 524             release_parsed_uri( uri );
 525             return G10ERR_NETWORK;
 526           }
 527         hd->sock = connect_server( *uri->host? uri->host : "localhost",
 528                                    uri->port? uri->port : 80, 0 );
 529         if(uri->auth)
 530           {
 531             char *x=make_radix64_string(uri->auth,strlen(uri->auth));
 532             auth=m_alloc(50+strlen(x));
 533             sprintf(auth,"Proxy-Authorization: Basic %s\r\n",x);
 534             m_free(x);
 535           }
 536
 537         release_parsed_uri( uri );
 538       }
 539     else
 540       {
 541         hd->sock = connect_server( server, port, hd->flags );
 542         if(hd->uri->auth)
 543           {
 544             char *x=make_radix64_string(hd->uri->auth,strlen(hd->uri->auth));
 545             auth=m_alloc(50+strlen(x));
 546             sprintf(auth,"Authorization: Basic %s\r\n",x);
 547             m_free(x);
 548           }
 549       }
 550
 551     if( hd->sock == -1 )
 552         return G10ERR_NETWORK;
 553
 554     p = build_rel_path( hd->uri );
 555
 556     request=m_alloc(strlen(server)*2 + strlen(p) + (auth?strlen(auth):0) + 50);
 557     if( proxy )
 558       sprintf( request, "%s http://%s:%hu%s%s HTTP/1.0\r\n%s",
 559                hd->req_type == HTTP_REQ_GET ? "GET" :
 560                hd->req_type == HTTP_REQ_HEAD? "HEAD":
 561                hd->req_type == HTTP_REQ_POST? "POST": "OOPS",
 562                server, port,  *p == '/'? "":"/", p, auth?auth:"" );
 563     else
 564       sprintf( request, "%s %s%s HTTP/1.0\r\nHost: %s\r\n%s",
 565                hd->req_type == HTTP_REQ_GET ? "GET" :
 566                hd->req_type == HTTP_REQ_HEAD? "HEAD":
 567                hd->req_type == HTTP_REQ_POST? "POST": "OOPS",
 568                *p == '/'? "":"/", p, server, auth?auth:"");
 569
 570     m_free(p);
 571
 572     rc = write_server( hd->sock, request, strlen(request) );
 573     m_free( request );
 574     m_free(auth);
 575
 576     return rc;
 577 }
 578
 579
 580 /****************
 581  * Build the relative path from the parsed URI.
 582  * Minimal implementation.
 583  */
 584 static byte*
 585 build_rel_path( PARSED_URI uri )
 586 {
 587     URI_TUPLE r;
 588     byte *rel_path, *p;
 589     int n;
 590
 591     /* count the needed space */
 592     n = insert_escapes( NULL, uri->path, "%;?&" );
 593     /* todo: build params */
 594     for( r=uri->query; r; r = r->next ) {
 595         n++; /* '?'/'&' */
 596         n += insert_escapes( NULL, r->name, "%;?&=" );
 597         n++; /* '='*/
 598         n += insert_escapes( NULL, r->value, "%;?&=" );
 599     }
 600     n++;
 601
 602     /* now  allocate and copy */
 603     p = rel_path = m_alloc( n );
 604     n = insert_escapes( p, uri->path, "%;?&" );
 605     p += n;
 606     /* todo: add params */
 607     for( r=uri->query; r; r = r->next ) {
 608         *p++ = r == uri->query? '?':'&';
 609         n = insert_escapes( p, r->name, "%;?&=" );
 610         p += n;
 611         *p++ = '=';
 612         /* todo: use valuelen */
 613         n = insert_escapes( p, r->value, "%;?&=" );
 614         p += n;
 615     }
 616     *p = 0;
 617     return rel_path;
 618 }
 619
 620
 621
 622 /***********************
 623  * Parse the response from a server.
 624  * Returns: errorcode and sets some fileds in the handle
 625  */
 626 static int
 627 parse_response( HTTP_HD hd )
 628 {
 629     byte *line, *p, *p2;
 630     unsigned maxlen, len;
 631
 632     /* Wait for the status line */
 633     do {
 634         maxlen = MAX_LINELEN;
 635         len = iobuf_read_line( hd->fp_read, &hd->buffer,
 636                                             &hd->buffer_size, &maxlen );
 637         line = hd->buffer;
 638         if( !maxlen )
 639             return -1; /* line has been truncated */
 640         if( !len )
 641             return -1; /* eof */
 642     } while( !*line  );
 643
 644     if( (p = strchr( line, '/')) )
 645         *p++ = 0;
 646     if( !p || strcmp( line, "HTTP" ) )
 647         return 0; /* assume http 0.9 */
 648
 649     if( (p2 = strpbrk( p, " \t" ) ) ) {
 650         *p2++ = 0;
 651         p2 += strspn( p2, " \t" );
 652     }
 653     if( !p2 )
 654         return 0; /* assume http 0.9 */
 655     p = p2;
 656     /* todo: add HTTP version number check here */
 657     if( (p2 = strpbrk( p, " \t" ) ) )
 658         *p2++ = 0;
 659     if( !isdigit(p[0]) || !isdigit(p[1]) || !isdigit(p[2]) || p[3] ) {
 660          /* malformed HTTP statuscode - assume HTTP 0.9 */
 661         hd->is_http_0_9 = 1;
 662         hd->status_code = 200;
 663         return 0;
 664     }
 665     hd->status_code = atoi( p );
 666
 667     /* skip all the header lines and wait for the empty line */
 668     do {
 669         maxlen = MAX_LINELEN;
 670         len = iobuf_read_line( hd->fp_read, &hd->buffer,
 671                                &hd->buffer_size, &maxlen );
 672         line = hd->buffer;
 673         /* we ignore truncated lines */
 674         if( !len )
 675             return -1; /* eof */
 676         /* time lineendings */
 677         if( (*line == '\r' && line[1] == '\n') || *line == '\n' )
 678             *line = 0;
 679     } while( len && *line  );
 680
 681     return 0;
 682 }
 683
 684 #ifdef TEST
 685 static int
 686 start_server()
 687 {
 688     struct sockaddr_in mya;
 689     struct sockaddr_in peer;
 690     int fd, client;
 691     fd_set rfds;
 692     int addrlen;
 693     int i;
 694
 695     if( (fd=socket(AF_INET,SOCK_STREAM, 0)) == -1 ) {
 696         log_error("socket() failed: %s\n", strerror(errno));
 697         return -1;
 698     }
 699     i = 1;
 700     if( setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, (byte*)&i, sizeof(i) ) )
 701         log_info("setsockopt(SO_REUSEADDR) failed: %s\n", strerror(errno) );
 702
 703     mya.sin_family=AF_INET;
 704     memset(&mya.sin_addr, 0, sizeof(mya.sin_addr));
 705     mya.sin_port=htons(11371);
 706
 707     if( bind( fd, (struct sockaddr *)&mya, sizeof(mya)) ) {
 708         log_error("bind to port 11371 failed: %s\n", strerror(errno) );
 709         sock_close( fd );
 710         return -1;
 711     }
 712
 713     if( listen( fd, 5 ) ) {
 714         log_error("listen failed: %s\n", strerror(errno) );
 715         sock_close( fd );
 716         return -1;
 717     }
 718
 719     for(;;) {
 720         FD_ZERO(&rfds);
 721         FD_SET( fd, &rfds );
 722
 723         if( select( fd+1, &rfds, NULL, NULL, NULL) <= 0 )
 724             continue; /* ignore any errors */
 725
 726         if( !FD_ISSET( fd, &rfds ) )
 727             continue;
 728
 729         addrlen = sizeof peer;
 730         client = accept( fd, (struct sockaddr *)&peer, &addrlen);
 731         if( client == -1 )
 732             continue; /* oops */
 733
 734         log_info("connect from %s\n", inet_ntoa( peer.sin_addr ) );
 735
 736         fflush(stdout);
 737         fflush(stderr);
 738         if( !fork() ) {
 739             int c;
 740             FILE *fp;
 741
 742             fp = fdopen( client , "r" );
 743             while( (c=getc(fp)) != EOF )
 744                 putchar(c);
 745             fclose(fp);
 746             exit(0);
 747         }
 748         sock_close( client );
 749     }
 750
 751
 752     return 0;
 753 }
 754 #endif
 755
 756
 757 static int
 758 connect_server( const char *server, ushort port, unsigned int flags )
 759 {
 760   int sock=-1,srv,srvcount=0,connected=0,hostfound=0;
 761   struct srventry *srvlist=NULL;
 762
 763 #ifdef _WIN32
 764   unsigned long inaddr;
 765
 766   init_sockets();
 767   /* Win32 gethostbyname doesn't handle IP addresses internally, so we
 768      try inet_addr first on that platform only. */
 769   if((inaddr=inet_addr(server))!=SOCKET_ERROR)
 770     {
 771       struct sockaddr_in addr;
 772
 773       memset(&addr,0,sizeof(addr));
 774
 775       if((sock=socket(AF_INET,SOCK_STREAM,0))==INVALID_SOCKET)
 776         {
 777           log_error("error creating socket: ec=%d\n",(int)WSAGetLastError());
 778           return -1;
 779         }
 780
 781       addr.sin_family=AF_INET;
 782       addr.sin_port=htons(port);
 783       memcpy(&addr.sin_addr,&inaddr,sizeof(inaddr));
 784
 785       if(connect(sock,(struct sockaddr *)&addr,sizeof(addr))==0)
 786         return sock;
 787       else
 788         {
 789           sock_close(sock);
 790           return -1;
 791         }
 792     }
 793 #endif
 794
 795 #ifdef USE_DNS_SRV
 796   /* Do the SRV thing */
 797   if(flags&HTTP_FLAG_TRY_SRV)
 798     {
 799       /* We're using SRV, so append the tags */
 800       char srvname[MAXDNAME];
 801       strcpy(srvname,"_hkp._tcp.");
 802       strncat(srvname,server,MAXDNAME-11);
 803       srvname[MAXDNAME-1]='\0';
 804       srvcount=getsrv(srvname,&srvlist);
 805     }
 806 #endif
 807
 808   if(srvlist==NULL)
 809     {
 810       /* Either we're not using SRV, or the SRV lookup failed.  Make
 811          up a fake SRV record. */
 812       srvlist=m_alloc_clear(sizeof(struct srventry));
 813       srvlist->port=port;
 814       strncpy(srvlist->target,server,MAXDNAME);
 815       srvcount=1;
 816     }
 817
 818 #ifdef HAVE_GETADDRINFO
 819
 820   for(srv=0;srv<srvcount;srv++)
 821     {
 822       struct addrinfo hints,*res,*ai;
 823       char portstr[6];
 824
 825       sprintf(portstr,"%u",srvlist[srv].port);
 826       memset(&hints,0,sizeof(hints));
 827       hints.ai_socktype=SOCK_STREAM;
 828       if(getaddrinfo(srvlist[srv].target,portstr,&hints,&res)==0)
 829         hostfound=1;
 830       else
 831         continue;
 832
 833       for(ai=res;ai;ai=ai->ai_next)
 834         {
 835           if((sock=socket(ai->ai_family,ai->ai_socktype,ai->ai_protocol))==-1)
 836             {
 837               log_error("error creating socket: %s\n",strerror(errno));
 838               freeaddrinfo(res);
 839               return -1;
 840             }
 841
 842           if(connect(sock,ai->ai_addr,ai->ai_addrlen)==0)
 843             {
 844               connected=1;
 845               break;
 846             }
 847         }
 848
 849       freeaddrinfo(res);
 850
 851       if(ai)
 852         break;
 853     }
 854
 855 #else /* !HAVE_GETADDRINFO */
 856
 857   for(srv=0;srv<srvcount;srv++)
 858     {
 859       int i=0;
 860       struct hostent *host=NULL;
 861       struct sockaddr_in addr;
 862
 863       memset(&addr,0,sizeof(addr));
 864
 865       if((host=gethostbyname(srvlist[srv].target))==NULL)
 866         continue;
 867
 868       if((sock=socket(host->h_addrtype,SOCK_STREAM,0))==-1)
 869         {
 870           log_error("error creating socket: %s\n",strerror(errno));
 871           return -1;
 872         }
 873
 874       addr.sin_family=host->h_addrtype;
 875       if(addr.sin_family!=AF_INET)
 876         {
 877           log_error("%s: unknown address family\n",srvlist[srv].target);
 878           return -1;
 879         }
 880
 881       addr.sin_port=htons(srvlist[srv].port);
 882
 883       /* Try all A records until one responds. */
 884       while(host->h_addr_list[i])
 885         {
 886           if(host->h_length!=4)
 887             {
 888               log_error("%s: illegal address length\n",srvlist[srv].target);
 889               return -1;
 890             }
 891
 892           memcpy(&addr.sin_addr,host->h_addr_list[i],host->h_length);
 893
 894           if(connect(sock,(struct sockaddr *)&addr,sizeof(addr))==0)
 895             {
 896               connected=1;
 897               break;
 898             }
 899
 900           i++;
 901         }
 902
 903       if(host->h_addr_list[i])
 904         break;
 905     }
 906 #endif /* !HAVE_GETADDRINFO */
 907
 908   m_free(srvlist);
 909
 910   if(!connected)
 911     {
 912 #ifdef _WIN32
 913       if(hostfound)
 914         log_error("%s: Unable to connect: ec=%d\n",server,(int)WSAGetLastError());
 915       else
 916         log_error("%s: Host not found: ec=%d\n",server,(int)WSAGetLastError());
 917 #else
 918       if(hostfound)
 919         log_error("%s: %s\n",server,strerror(errno));
 920       else
 921         log_error("%s: Host not found\n",server);
 922 #endif
 923       if(sock!=-1)
 924         sock_close(sock);
 925       return -1;
 926     }
 927
 928   return sock;
 929 }
 930
 931
 932 static int
 933 write_server( int sock, const char *data, size_t length )
 934 {
 935     int nleft;
 936
 937     nleft = length;
 938     while( nleft > 0 ) {
 939 #ifdef _WIN32
 940         int nwritten;
 941
 942         nwritten = send (sock, data, nleft, 0);
 943         if ( nwritten == SOCKET_ERROR ) {
 944             log_info ("write failed: ec=%d\n", (int)WSAGetLastError ());
 945             return G10ERR_NETWORK;
 946         }
 947 #else
 948         int nwritten = write( sock, data, nleft );
 949         if( nwritten == -1 ) {
 950             if( errno == EINTR )
 951                 continue;
 952             if( errno == EAGAIN ) {
 953                 struct timeval tv;
 954
 955                 tv.tv_sec =  0;
 956                 tv.tv_usec = 50000;
 957                 select(0, NULL, NULL, NULL, &tv);
 958                 continue;
 959             }
 960             log_info("write failed: %s\n", strerror(errno));
 961             return G10ERR_NETWORK;
 962         }
 963 #endif
 964         nleft -=nwritten;
 965         data += nwritten;
 966     }
 967
 968     return 0;
 969 }
 970
 971 /**** Test code ****/
 972 #ifdef TEST
 973
 974 int
 975 main(int argc, char **argv)
 976 {
 977     int rc;
 978     PARSED_URI uri;
 979     URI_TUPLE r;
 980     struct http_context hd;
 981     int c;
 982
 983     log_set_name("http-test");
 984     if( argc == 1 ) {
 985         start_server();
 986         return 0;
 987     }
 988
 989     if( argc != 2 ) {
 990         fprintf(stderr,"usage: http-test uri\n");
 991         return 1;
 992     }
 993     argc--; argv++;
 994
 995     rc = parse_uri( &uri, *argv );
 996     if( rc ) {
 997         log_error("`%s': %s\n", *argv, g10_errstr(rc));
 998         release_parsed_uri( uri );
 999         return 1;
1000     }
1001
1002     printf("Scheme: %s\n", uri->scheme );
1003     printf("Host  : %s\n", uri->host );
1004     printf("Port  : %u\n", uri->port );
1005     printf("Path  : %s\n", uri->path );
1006     for( r=uri->params; r; r = r->next ) {
1007         printf("Params: %s=%s", r->name, r->value );
1008         if( strlen( r->value ) != r->valuelen )
1009             printf(" [real length=%d]", (int)r->valuelen );
1010         putchar('\n');
1011     }
1012     for( r=uri->query; r; r = r->next ) {
1013         printf("Query : %s=%s", r->name, r->value );
1014         if( strlen( r->value ) != r->valuelen )
1015             printf(" [real length=%d]", (int)r->valuelen );
1016         putchar('\n');
1017     }
1018     release_parsed_uri( uri ); uri = NULL;
1019
1020     rc = http_open_document( &hd, *argv, 0, NULL );
1021     if( rc ) {
1022         log_error("can't get `%s': %s\n", *argv, g10_errstr(rc));
1023         return 1;
1024     }
1025     log_info("open_http_document succeeded; status=%u\n", hd.status_code );
1026     while( (c=iobuf_get( hd.fp_read)) != -1 )
1027         putchar(c);
1028     http_close( &hd );
1029     return 0;
1030 }
1031 #endif /*TEST*/