util/http.c

   1 /* http.c  -  HTTP protocol handler
   2  *      Copyright (C) 1999 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 #include <unistd.h>
  29 #include <sys/types.h>
  30 #include <sys/socket.h>
  31 #include <sys/time.h>
  32 #include <arpa/inet.h>
  33 #include <netinet/in.h>
  34 #include <netdb.h>
  35
  36 #include "util.h"
  37 #include "iobuf.h"
  38 #include "i18n.h"
  39
  40 #include "http.h"
  41
  42 #define MAX_LINELEN 20000  /* max. length of a HTTP line */
  43 #define VALID_URI_CHARS "abcdefghijklmnopqrstuvwxyz"   \
  44                         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"   \
  45                         "01234567890@"                 \
  46                         "!\"#$%&'()*+,-./:;<=>?[\\]^_{|}~"
  47
  48 #ifndef EAGAIN
  49   #define EAGAIN  EWOULDBLOCK
  50 #endif
  51
  52 static int parse_uri( PARSED_URI *ret_uri, const char *uri );
  53 static void release_parsed_uri( PARSED_URI uri );
  54 static int do_parse_uri( PARSED_URI uri, int only_local_part );
  55 static int remove_escapes( byte *string );
  56 static int insert_escapes( byte *buffer, const byte *string,
  57                                          const byte *special );
  58 static URI_TUPLE parse_tuple( byte *string );
  59 static int send_request( HTTP_HD hd );
  60 static byte *build_rel_path( PARSED_URI uri );
  61 static int parse_response( HTTP_HD hd );
  62
  63 static int connect_server( const char *server, ushort port );
  64 static int write_server( int sock, const char *data, size_t length );
  65
  66
  67 int
  68 http_open( HTTP_HD hd, HTTP_REQ_TYPE reqtype, const char *url,
  69                                               unsigned int flags )
  70 {
  71     int rc;
  72
  73     if( flags || !(reqtype == HTTP_REQ_GET || reqtype == HTTP_REQ_POST) )
  74         return G10ERR_INV_ARG;
  75
  76     /* initialize the handle */
  77     memset( hd, 0, sizeof *hd );
  78     hd->sock = -1;
  79     hd->initialized = 1;
  80     hd->req_type = reqtype;
  81
  82     rc = parse_uri( &hd->uri, url );
  83     if( !rc ) {
  84         rc = send_request( hd );
  85         if( !rc ) {
  86             hd->fp_write = iobuf_fdopen( hd->sock , "w" );
  87             if( hd->fp_write )
  88                 return 0;
  89             rc = G10ERR_GENERAL;
  90         }
  91     }
  92
  93     if( !hd->fp_read && !hd->fp_write && hd->sock != -1 )
  94         close( hd->sock );
  95     iobuf_close( hd->fp_read );
  96     iobuf_close( hd->fp_write);
  97     release_parsed_uri( hd->uri );
  98     hd->initialized = 0;
  99
 100     return rc;
 101 }
 102
 103
 104 void
 105 http_start_data( HTTP_HD hd )
 106 {
 107     if( !hd->in_data ) {
 108         iobuf_put( hd->fp_write, '\n' );
 109         hd->in_data = 1;
 110     }
 111 }
 112
 113
 114 int
 115 http_wait_response( HTTP_HD hd, unsigned int *ret_status )
 116 {
 117     int rc;
 118
 119     http_start_data( hd ); /* make sure that we are in the data */
 120     iobuf_flush( hd->fp_write );
 121
 122     hd->sock = dup( hd->sock );
 123     if( hd->sock == -1 )
 124         return G10ERR_GENERAL;
 125     iobuf_close( hd->fp_write );
 126     hd->fp_write = NULL;
 127     shutdown( hd->sock, 1 );
 128     hd->in_data = 0;
 129
 130     hd->fp_read = iobuf_fdopen( hd->sock , "r" );
 131     if( !hd->fp_read )
 132         return G10ERR_GENERAL;
 133
 134     rc = parse_response( hd );
 135     if( !rc && ret_status )
 136         *ret_status = hd->status_code;
 137
 138     return rc;
 139 }
 140
 141
 142 int
 143 http_open_document( HTTP_HD hd, const char *document, unsigned int flags )
 144 {
 145     int rc;
 146
 147     if( flags )
 148         return G10ERR_INV_ARG;
 149
 150     rc = http_open( hd, HTTP_REQ_GET, document, 0 );
 151     if( rc )
 152         return rc;
 153
 154     rc = http_wait_response( hd, NULL );
 155     if( rc )
 156         http_close( hd );
 157
 158     return rc;
 159 }
 160
 161
 162
 163
 164 void
 165 http_close( HTTP_HD hd )
 166 {
 167     if( !hd || !hd->initialized )
 168         return;
 169     if( !hd->fp_read && !hd->fp_write && hd->sock != -1 )
 170         close( hd->sock );
 171     iobuf_close( hd->fp_read );
 172     iobuf_close( hd->fp_write );
 173     release_parsed_uri( hd->uri );
 174     m_free( hd->buffer );
 175     hd->initialized = 0;
 176 }
 177
 178
 179
 180 /****************
 181  * Parse an URI and put the result into the newly allocated ret_uri.
 182  * The caller must always use release_parsed_uri to releases the
 183  * resources (even on an error).
 184  */
 185 static int
 186 parse_uri( PARSED_URI *ret_uri, const char *uri )
 187 {
 188    *ret_uri = m_alloc_clear( sizeof(**ret_uri) + strlen(uri) );
 189    strcpy( (*ret_uri)->buffer, uri );
 190    return do_parse_uri( *ret_uri, 0 );
 191 }
 192
 193 static void
 194 release_parsed_uri( PARSED_URI uri )
 195 {
 196     if( uri )
 197     {
 198         URI_TUPLE r, r2;
 199
 200         for( r = uri->query; r; r = r2 ) {
 201             r2 = r->next;
 202             m_free( r );
 203         }
 204         m_free( uri );
 205     }
 206 }
 207
 208 static int
 209 do_parse_uri( PARSED_URI uri, int only_local_part )
 210 {
 211     URI_TUPLE *tail;
 212     char *p, *p2, *p3;
 213     int n;
 214
 215     p = uri->buffer;
 216     n = strlen( uri->buffer );
 217     /* initialize all fields to an empty string or an empty list */
 218     uri->scheme = uri->host = uri->path = p + n;
 219     uri->port = 0;
 220     uri->params = uri->query = NULL;
 221
 222     /* a quick validity check */
 223     if( strspn( p, VALID_URI_CHARS) != n )
 224         return G10ERR_BAD_URI; /* invalid characters found */
 225
 226     if( !only_local_part ) {
 227         /* find the scheme */
 228         if( !(p2 = strchr( p, ':' ) ) || p2 == p )
 229            return G10ERR_BAD_URI; /* No scheme */
 230         *p2++ = 0;
 231         strlwr( p );
 232         uri->scheme = p;
 233         if( !strcmp( uri->scheme, "http" ) )
 234             ;
 235         else if( !strcmp( uri->scheme, "x-hkp" ) ) /* same as HTTP */
 236             ;
 237         else
 238             return G10ERR_INVALID_URI; /* Unsupported scheme */
 239
 240         p = p2;
 241
 242         /* find the hostname */
 243         if( *p != '/' )
 244             return G10ERR_INVALID_URI; /* does not start with a slash */
 245
 246         p++;
 247         if( *p == '/' ) {  /* there seems to be a hostname */
 248             p++;
 249             if( (p2 = strchr(p, '/')) )
 250                 *p2++ = 0;
 251             strlwr( p );
 252             uri->host = p;
 253             if( (p3=strchr( p, ':' )) ) {
 254                 *p3++ = 0;
 255                 uri->port = atoi( p3 );
 256             }
 257             else
 258                uri->port = 80;
 259             uri->host = p;
 260             if( (n = remove_escapes( uri->host )) < 0 )
 261                 return G10ERR_BAD_URI;
 262             if( n != strlen( p ) )
 263                 return G10ERR_BAD_URI; /* hostname with a Nul in it */
 264             p = p2 ? p2 : NULL;
 265         }
 266     } /* end global URI part */
 267
 268     /* parse the pathname part */
 269     if( !p || !*p ) /* we don't have a path */
 270         return 0; /* and this is okay */
 271
 272     /* fixme: here we have to check params */
 273
 274     /* do we have a query part */
 275     if( (p2 = strchr( p, '?' )) )
 276         *p2++ = 0;
 277
 278     uri->path = p;
 279     if( (n = remove_escapes( p )) < 0 )
 280         return G10ERR_BAD_URI;
 281     if( n != strlen( p ) )
 282         return G10ERR_BAD_URI; /* path with a Nul in it */
 283     p = p2 ? p2 : NULL;
 284
 285     if( !p || !*p ) /* we don't have a query string */
 286         return 0;   /* okay */
 287
 288     /* now parse the query string */
 289     tail = &uri->query;
 290     for(;;) {
 291         URI_TUPLE elem;
 292
 293         if( (p2 = strchr( p, '&' )) )
 294             *p2++ = 0;
 295         if( !(elem = parse_tuple( p )) )
 296             return G10ERR_BAD_URI;
 297         *tail = elem;
 298         tail = &elem->next;
 299
 300         if( !p2 )
 301            break; /* ready */
 302         p = p2;
 303     }
 304
 305     return 0;
 306 }
 307
 308
 309
 310 /****************
 311  * Remove all %xx escapes; this is done inplace.
 312  * Returns: new length of the string.
 313  */
 314 static int
 315 remove_escapes( byte *string )
 316 {
 317     int n = 0;
 318     byte *p, *s;
 319
 320     for(p=s=string; *s ; s++ ) {
 321         if( *s == '%' ) {
 322             if( s[1] && s[2] && isxdigit(s[1]) && isxdigit(s[2]) ) {
 323                 s++;
 324                 *p  = *s >= '0' && *s <= '9' ? *s - '0' :
 325                       *s >= 'A' && *s <= 'F' ? *s - 'A' + 10 : *s - 'a' + 10 ;
 326                 *p <<= 4;
 327                 s++;
 328                 *p |= *s >= '0' && *s <= '9' ? *s - '0' :
 329                       *s >= 'A' && *s <= 'F' ? *s - 'A' + 10 : *s - 'a' + 10 ;
 330                 p++;
 331                 n++;
 332             }
 333             else {
 334                 *p++ = *s++;
 335                 if( *s )
 336                    *p++ = *s++;
 337                 if( *s )
 338                    *p++ = *s++;
 339                 if( *s )
 340                    *p = 0;
 341                 return -1; /* bad URI */
 342             }
 343         }
 344         else
 345         {
 346             *p++ = *s;
 347             n++;
 348         }
 349     }
 350     *p = 0; /* always keep a string terminator */
 351     return n;
 352 }
 353
 354
 355 static int
 356 insert_escapes( byte *buffer, const byte *string, const byte *special )
 357 {
 358     int n = 0;
 359
 360     for( ; *string; string++ ) {
 361         if( strchr( VALID_URI_CHARS, *string )
 362             && !strchr( special, *string ) )  {
 363             if( buffer )
 364                 *buffer++ = *string;
 365             n++;
 366         }
 367         else {
 368             if( buffer ) {
 369                 sprintf( buffer, "%02X", *string );
 370                 buffer += 3;
 371             }
 372             n += 3;
 373         }
 374     }
 375     return n;
 376 }
 377
 378
 379
 380
 381
 382 static URI_TUPLE
 383 parse_tuple( byte *string )
 384 {
 385     byte *p = string;
 386     byte *p2;
 387     int n;
 388     URI_TUPLE tuple;
 389
 390     if( (p2 = strchr( p, '=' )) )
 391         *p2++ = 0;
 392     if( (n = remove_escapes( p )) < 0 )
 393         return NULL; /* bad URI */
 394     if( n != strlen( p ) )
 395        return NULL; /* name with a Nul in it */
 396     tuple = m_alloc_clear( sizeof *tuple );
 397     tuple->name = p;
 398     if( !p2 )  {
 399         /* we have only the name, so we assume an empty value string */
 400         tuple->value = p + strlen(p);
 401         tuple->valuelen = 0;
 402     }
 403     else { /* name and value */
 404         if( (n = remove_escapes( p2 )) < 0 ) {
 405             m_free( tuple );
 406             return NULL; /* bad URI */
 407         }
 408         tuple->value = p2;
 409         tuple->valuelen = n;
 410     }
 411     return tuple;
 412 }
 413
 414
 415 /****************
 416  * Send a HTTP request to the server
 417  * Returns 0 if the request was successful
 418  */
 419 static int
 420 send_request( HTTP_HD hd )
 421 {
 422     const byte *server;
 423     byte *request, *p;
 424     ushort port;
 425     int rc;
 426
 427     server = *hd->uri->host? hd->uri->host : "localhost";
 428     port   = hd->uri->port?  hd->uri->port : 80;
 429
 430     hd->sock = connect_server( server, port );
 431     if( hd->sock == -1 )
 432         return G10ERR_NETWORK;
 433
 434     p = build_rel_path( hd->uri );
 435     request = m_alloc( strlen(p) + 20 );
 436     sprintf( request, "%s %s%s HTTP/1.0\r\n",
 437                           hd->req_type == HTTP_REQ_GET ? "GET" :
 438                           hd->req_type == HTTP_REQ_HEAD? "HEAD":
 439                           hd->req_type == HTTP_REQ_POST? "POST": "OOPS",
 440                                                   *p == '/'? "":"/", p );
 441     m_free(p);
 442
 443     rc = write_server( hd->sock, request, strlen(request) );
 444     m_free( request );
 445
 446     return rc;
 447 }
 448
 449
 450
 451
 452 /****************
 453  * Build the relative path from the parsed URI.
 454  * Minimal implementation.
 455  */
 456 static byte*
 457 build_rel_path( PARSED_URI uri )
 458 {
 459     URI_TUPLE r;
 460     byte *rel_path, *p;
 461     int n;
 462
 463     /* count the needed space */
 464     n = insert_escapes( NULL, uri->path, "%;?&" );
 465     /* fixme: add params */
 466     for( r=uri->query; r; r = r->next ) {
 467         n++; /* '?'/'&' */
 468         n += insert_escapes( NULL, r->name, "%;?&=" );
 469         n++; /* '='*/
 470         n += insert_escapes( NULL, r->value, "%;?&=" );
 471     }
 472     n++;
 473
 474     /* now  allocate and copy */
 475     p = rel_path = m_alloc( n );
 476     n = insert_escapes( p, uri->path, "%;?&" );
 477     p += n;
 478     /* fixme: add params */
 479     for( r=uri->query; r; r = r->next ) {
 480         *p++ = r == uri->query? '?':'&';
 481         n = insert_escapes( p, r->name, "%;?&=" );
 482         p += n;
 483         *p++ = '=';
 484         /* fixme: use valuelen */
 485         n = insert_escapes( p, r->value, "%;?&=" );
 486         p += n;
 487     }
 488     *p = 0;
 489     return rel_path;
 490 }
 491
 492
 493
 494 /***********************
 495  * Parse the response from a server.
 496  * Returns: errorcode and sets some fileds in the handle
 497  */
 498 static int
 499 parse_response( HTTP_HD hd )
 500 {
 501     byte *line, *p, *p2;
 502     unsigned maxlen, len;
 503
 504     /* Wait for the status line */
 505     do {
 506         maxlen = MAX_LINELEN;
 507         len = iobuf_read_line( hd->fp_read, &hd->buffer,
 508                                             &hd->buffer_size, &maxlen );
 509         line = hd->buffer;
 510         if( !maxlen )
 511             return -1; /* line has been truncated */
 512         if( !len )
 513             return -1; /* eof */
 514     } while( !*line  );
 515
 516     if( (p = strchr( line, '/')) )
 517         *p++ = 0;
 518     if( !p || strcmp( line, "HTTP" ) )
 519         return 0; /* assume http 0.9 */
 520
 521     if( (p2 = strpbrk( p, " \t" ) ) ) {
 522         *p2++ = 0;
 523         p2 += strspn( p2, " \t" );
 524     }
 525     if( !p2 )
 526         return 0; /* assume http 0.9 */
 527     p = p2;
 528     /* fixme: add HTTP version number check here */
 529     if( (p2 = strpbrk( p, " \t" ) ) )
 530         *p2++ = 0;
 531     if( !isdigit(p[0]) || !isdigit(p[1]) || !isdigit(p[2]) || p[3] ) {
 532          /* malformed HTTP statuscode - assume HTTP 0.9 */
 533         hd->is_http_0_9 = 1;
 534         hd->status_code = 200;
 535         return 0;
 536     }
 537     hd->status_code = atoi( p );
 538
 539     /* skip all the header lines and wait for the empty line */
 540     do {
 541         maxlen = MAX_LINELEN;
 542         len = iobuf_read_line( hd->fp_read, &hd->buffer,
 543                                &hd->buffer_size, &maxlen );
 544         line = hd->buffer;
 545         /* we ignore truncated lines */
 546         if( !len )
 547             return -1; /* eof */
 548         /* time lineendings */
 549         if( (*line == '\r' && line[1] == '\n') || *line == '\n' )
 550             *line = 0;
 551     } while( len && *line  );
 552
 553     return 0;
 554 }
 555
 556 #if 0
 557 static int
 558 start_server()
 559 {
 560     struct sockaddr_in mya;
 561     struct sockaddr_in peer;
 562     int fd, client;
 563     fd_set rfds;
 564     int addrlen;
 565     int i;
 566
 567     if( (fd=socket(AF_INET,SOCK_STREAM, 0)) == -1 ) {
 568         log_error("socket() failed: %s\n", strerror(errno));
 569         return -1;
 570     }
 571     i = 1;
 572     if( setsockopt( fd, SOL_SOCKET, SO_REUSEADDR, (byte*)&i, sizeof(i) ) )
 573         log_info("setsockopt(SO_REUSEADDR) failed: %s\n", strerror(errno) );
 574
 575     mya.sin_family=AF_INET;
 576     memset(&mya.sin_addr, 0, sizeof(mya.sin_addr));
 577     mya.sin_port=htons(11371);
 578
 579     if( bind( fd, (struct sockaddr *)&mya, sizeof(mya)) ) {
 580         log_error("bind to port 11371 failed: %s\n", strerror(errno) );
 581         close( fd );
 582         return -1;
 583     }
 584
 585     if( listen( fd, 5 ) ) {
 586         log_error("listen failed: %s\n", strerror(errno) );
 587         close( fd );
 588         return -1;
 589     }
 590
 591     for(;;) {
 592         FD_ZERO(&rfds);
 593         FD_SET( fd, &rfds );
 594
 595         if( select( fd+1, &rfds, NULL, NULL, NULL) <= 0 )
 596             continue; /* ignore any errors */
 597
 598         if( !FD_ISSET( fd, &rfds ) )
 599             continue;
 600
 601         addrlen = sizeof peer;
 602         client = accept( fd, (struct sockaddr *)&peer, &addrlen);
 603         if( client == -1 )
 604             continue; /* oops */
 605
 606         log_info("connect from %s\n", inet_ntoa( peer.sin_addr ) );
 607
 608         fflush(stdout);
 609         fflush(stderr);
 610         if( !fork() ) {
 611             int c;
 612             FILE *fp;
 613
 614             fp = fdopen( client , "r" );
 615             while( (c=getc(fp)) != EOF )
 616                 putchar(c);
 617             fclose(fp);
 618             exit(0);
 619         }
 620         close( client );
 621     }
 622
 623
 624     return 0;
 625 }
 626 #endif
 627
 628
 629
 630 static int
 631 connect_server( const char *server, ushort port )
 632 {
 633     struct sockaddr_in addr;
 634     struct hostent *host;
 635     int sd;
 636
 637     addr.sin_family = AF_INET;
 638     addr.sin_port = htons(port);
 639     host = gethostbyname((char*)server);
 640     if( !host )
 641          return -1;
 642
 643     addr.sin_addr = *(struct in_addr*)host->h_addr;
 644
 645     sd = socket(AF_INET, SOCK_STREAM, 0);
 646     if( sd == -1 )
 647         return -1;
 648
 649     if( connect( sd, (struct sockaddr *)&addr, sizeof addr) == -1 ) {
 650         close(sd);
 651         return -1;
 652     }
 653
 654     return sd;
 655 }
 656
 657
 658 static int
 659 write_server( int sock, const char *data, size_t length )
 660 {
 661     int nleft, nwritten;
 662
 663     nleft = length;
 664     while( nleft > 0 ) {
 665         nwritten = write( sock, data, nleft );
 666         if( nwritten == -1 ) {
 667             if( errno == EINTR )
 668                 continue;
 669             if( errno == EAGAIN ) {
 670                 struct timeval tv;
 671
 672                 tv.tv_sec =  0;
 673                 tv.tv_usec = 50000;
 674                 select(0, NULL, NULL, NULL, &tv);
 675                 continue;
 676             }
 677             log_info("write failed: %s\n", strerror(errno));
 678             return G10ERR_NETWORK;
 679         }
 680         nleft -=nwritten;
 681         data += nwritten;
 682     }
 683
 684     return 0;
 685 }
 686
 687
 688 /**** Test code ****/
 689 #ifdef TEST
 690
 691 int
 692 main(int argc, char **argv)
 693 {
 694     int rc;
 695     PARSED_URI uri;
 696     URI_TUPLE r;
 697     struct http_context hd;
 698     int c;
 699
 700     log_set_name("http-test");
 701     if( argc == 1 ) {
 702         start_server();
 703         return 0;
 704     }
 705
 706     if( argc != 2 ) {
 707         fprintf(stderr,"usage: http-test uri\n");
 708         return 1;
 709     }
 710     argc--; argv++;
 711
 712     rc = parse_uri( &uri, *argv );
 713     if( rc ) {
 714         log_error("`%s': %s\n", *argv, g10_errstr(rc));
 715         release_parsed_uri( uri );
 716         return 1;
 717     }
 718
 719     printf("Scheme: %s\n", uri->scheme );
 720     printf("Host  : %s\n", uri->host );
 721     printf("Port  : %u\n", uri->port );
 722     printf("Path  : %s\n", uri->path );
 723     for( r=uri->params; r; r = r->next ) {
 724         printf("Params: %s=%s", r->name, r->value );
 725         if( strlen( r->value ) != r->valuelen )
 726             printf(" [real length=%d]", (int)r->valuelen );
 727         putchar('\n');
 728     }
 729     for( r=uri->query; r; r = r->next ) {
 730         printf("Query : %s=%s", r->name, r->value );
 731         if( strlen( r->value ) != r->valuelen )
 732             printf(" [real length=%d]", (int)r->valuelen );
 733         putchar('\n');
 734     }
 735     release_parsed_uri( uri ); uri = NULL;
 736
 737     rc = http_open_document( &hd, *argv, 0 );
 738     if( rc ) {
 739         log_error("can't get `%s': %s\n", *argv, g10_errstr(rc));
 740         return 1;
 741     }
 742     log_info("open_http_document succeeded; status=%u\n", hd.status_code );
 743     while( (c=iobuf_get( hd.fp_read)) != -1 )
 744         putchar(c);
 745     http_close( &hd );
 746     return 0;
 747 }
 748 #endif /*TEST*/