开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
parse.c
资源名称：wwwoffle-2.5e.tgz　[点击查看]
上传用户：seven77cht
上传日期：2007-01-04
资源大小：486k
文件大小：25k
源码类别：

浏览器

开发平台：

Unix_Linux

parse.c：源码内容
  1. /***************************************
  2.   $Header: /home/amb/wwwoffle/RCS/parse.c 2.65 2000/01/19 18:58:08 amb Exp $
  4.   WWWOFFLE - World Wide Web Offline Explorer - Version 2.5d.
  5.   Functions to parse the HTTP requests.
  6.   ******************/ /******************
  7.   Written by Andrew M. Bishop
  9.   This file Copyright 1996,97,98,99,2000 Andrew M. Bishop
  10.   It may be distributed under the GNU Public License, version 2, or
  11.   any higher version.  See section COPYING of the GNU Public license
  12.   for conditions under which this file may be redistributed.
  13.   ***************************************/
  16. #include <stdio.h>
  17. #include <stdlib.h>
  18. #include <string.h>
  19. #include <ctype.h>
  21. #include <sys/types.h>
  22. #include <sys/stat.h>
  23. #include <time.h>
  24. #include <unistd.h>
  26. #include "wwwoffle.h"
  27. #include "misc.h"
  28. #include "proto.h"
  29. #include "errors.h"
  30. #include "config.h"
  32. /*+ The time that the program went online. +*/
  33. time_t OnlineTime=0;
  35. /*+ Headers from a request that can be re-used in automatically generated requests. +*/
  36. static char *reusable_headers[]={"User-Agent",
  37.                                  "Accept",
  38.                                  "Accept-Charset",
  39.                                  "Accept-Language",
  40.                                  "From",
  41.                                  "Proxy-Authorization"};
  43. /*+ Headers that we do not allow the users to censor. +*/
  44. static char *non_censored_headers[]={"Host",
  45.                                      "Connection",
  46.                                      "Proxy-Connection",
  47.                                      "Authorization"};
  49. /*+ Headers that are difficult with HTTP/1.1. +*/
  50. static char *deleted_http11_headers[]={"If-Match",
  51.                                        "If-None-Match",
  52.                                        "If-Range",
  53.                                        "Range",
  54.                                        "Upgrade",
  55.                                        "Accept-Encoding"};
  57. /*+ The headers from the request that are re-usable. +*/
  58. static Header *reusable_header;
  61. static int AddToHeaderRaw(Header *head,char *line);
  64. /*++++++++++++++++++++++++++++++++++++++
  65.   Parse the request to the server.
  67.   char *ParseRequest Returns the URL or NULL if it failed.
  69.   int fd The file descriptor to read the request from.
  71.   Header **request_head Return the header of the request.
  73.   Body **request_body Return the body of the request.
  74.   ++++++++++++++++++++++++++++++++++++++*/
  76. char *ParseRequest(int fd,Header **request_head,Body **request_body)
  77. {
  78.  char *url=NULL,*line=NULL;
  79.  int i,length=-1;
  81.  *request_head=NULL;
  82.  *request_body=NULL;
  84.  reusable_header=CreateHeader("GET reusable HTTP/1.0rn",1);
  86.  while((line=read_line_or_timeout(fd,line,SocketTimeout)))
  87.    {
  88.     char *key,*val;
  90.     if(!*request_head) /* first line */
  91.       {
  92.        *request_head=CreateHeader(line,1);
  94.        if(!*(*request_head)->url)
  95.           return(NULL);
  97.        url=(char*)malloc(strlen((*request_head)->url)+1);
  98.        strcpy(url,(*request_head)->url);
  100.        continue;
  101.       }
  103.     if(!AddToHeaderRaw(*request_head,line))
  104.        break;
  106.     key=(*request_head)->key[(*request_head)->n-1];
  107.     val=(*request_head)->val[(*request_head)->n-1];
  109.     /* Find the content length */
  111.     if(!strcasecmp("Content-Length",key))
  112.        length=atoi(val);
  114.     /* Find re-usable headers (for recursive requests) */
  116.     for(i=0;i<sizeof(reusable_headers)/sizeof(char*);i++)
  117.        if(!strcmp(reusable_headers[i],key))
  118.           AddToHeader(reusable_header,key,val);
  120.     /* Check for firewall operation. */
  122.     if(!strcasecmp("Host",key) && url && *url=='/')
  123.       {
  124.        char *oldurl=url;
  125.        url=(char*)malloc(strlen(url)+strlen(val)+8);
  126.        strcpy(url,"http://");
  127.        strcat(url,val);
  128.        strcat(url,oldurl);
  129.        free(oldurl);
  130.       }
  132.     /* Check for passwords */
  134.     if(!strcasecmp("Authorization",key))
  135.       {
  136.        char *p=val,*copy,*userpass;
  137.        int l;
  139.        while(*p!=' ') p++;
  140.        while(*p==' ') p++;
  142.        userpass=URLEncodePassword(Base64Decode(p,&l));
  143.        p=url;
  145.        if(*url=='/')
  146.          {
  147.           char *localhost=GetLocalHost(1);
  149.           copy=(char*)malloc(strlen(url)+strlen(userpass)+strlen(localhost)+10);
  151.           strcpy(copy,"http://");
  152.           strcat(copy,userpass);
  153.           strcat(copy,"@");
  154.           strcat(copy,localhost);
  155.          }
  156.        else
  157.          {
  158.           copy=(char*)malloc(strlen(url)+strlen(userpass)+2);
  160.           while(*p!=':') p++; p++;
  161.           while(*p=='/') p++;
  163.           strncpy(copy,url,p-url);
  164.           copy[p-url]=0;
  165.           strcat(copy,userpass);
  166.           strcat(copy,"@");
  167.          }
  169.        strcat(copy,p);
  171.        free(url);
  172.        url=copy;
  173.       }
  174.    }
  176.  if(line)
  177.     free(line);
  179.  if(!*request_head)
  180.     return(NULL);
  182.  if(!strcmp("POST",(*request_head)->method) ||
  183.     !strcmp("PUT",(*request_head)->method))
  184.    {
  185.     if(length==-1)
  186.       {free(url);return(NULL);}
  188.     *request_body=CreateBody(length);
  190.     if(length)
  191.       {
  192.        int m,l=length;
  194.        do
  195.          {
  196.           m=read_data_or_timeout(fd,&(*request_body)->content[length-l],l,SocketTimeout);
  197.          }
  198.        while(m>0 && (l-=m));
  200.        if(l)
  201.          {free(url);return(NULL);}
  203.        empty_buffer(fd);
  204.       }
  206.     (*request_body)->content[length]=0;
  208.     url=(char*)realloc((void*)url,strlen(url)+40);
  210.     if(strchr(url,'?'))
  211.       {
  212.        char *from=url+strlen(url),*to=from+1;
  213.        while(*from!='?')
  214.           *to--=*from--;
  215.        *to='!';
  216.       }
  217.     else
  218.        strcat(url,"?");
  220.     sprintf(url+strlen(url),"!%s:%s.%08lx",(*request_head)->method,MakeHash((*request_body)->content),time(NULL));
  221.    }
  223.  return(url);
  224. }
  227. /*++++++++++++++++++++++++++++++++++++++
  228.   Modify the request to ask for changes since the spooled file.
  230.   int RequestChanges Returns 1 if the file needs changes made, 0 if not, or -1 in case of an error.
  232.   int fd The file descriptor of the spooled file.
  234.   Header *request_head The head of the HTTP request to modify.
  235.   ++++++++++++++++++++++++++++++++++++++*/
  237. int RequestChanges(int fd,Header *request_head)
  238. {
  239.  struct stat buf;
  240.  int status,retval=0;
  241.  Header *spooled_head=NULL;
  243.  status=ParseReply(fd,NULL,&spooled_head);
  245.  if(status==0 || fstat(fd,&buf))
  246.    {
  247.     PrintMessage(Debug,"Requesting URL (Empty or no status).");
  248.     retval=1;
  249.    }
  250.  else if(status<200 || status>=400)
  251.    {
  252.     PrintMessage(Debug,"Requesting URL (Error status).");
  253.     retval=1;
  254.    }
  255.  else
  256.    {
  257.     char *expires,*head,*val;
  259.     if(RequestExpired && (expires=GetHeader(spooled_head,"Expires",NULL)))
  260.       {
  261.        time_t since=DateToTimeT(expires);
  263.        if(since<=time(NULL))
  264.          {
  265.           PrintMessage(Debug,"Requesting URL (Expiry date of '%s').",expires);
  266.           retval=1;
  267.          }
  268.       }
  270.     if(retval==0)
  271.        if(RequestNoCache && (GetHeader(spooled_head,head="Pragma"       ,val="no-cache") ||
  272.                              GetHeader(spooled_head,head="Cache-Control",val="no-cache")))
  273.          {
  274.           PrintMessage(Debug,"Requesting URL (No cache header '%s: %s').",head,val);
  275.           retval=1;
  276.          }
  278.     if(retval==0)
  279.        if(RequestChangedOnce && buf.st_mtime>OnlineTime)
  280.          {
  281.           PrintMessage(Debug,"Not requesting URL (Only once per online session).");
  282.           retval=0;
  283.          }
  284.        else if((time(NULL)-buf.st_mtime)<RequestChanged)
  285.          {
  286.           PrintMessage(Debug,"Not requesting URL (Last changed %d seconds ago).",time(NULL)-buf.st_mtime);
  287.           retval=0;
  288.          }
  289.        else
  290.          {
  291.           AddToHeader(request_head,"If-Modified-Since",RFC822Date(buf.st_mtime,1));
  293.           PrintMessage(Debug,"Requesting URL (Making a conditional request).");
  294.           retval=1;
  295.          }
  296.    }
  298.  if(spooled_head)
  299.     FreeHeader(spooled_head);
  301.  return(retval);
  302. }
  305. /*++++++++++++++++++++++++++++++++++++++
  306.   Return the location that the URL has been moved to.
  308.   char *MovedLocation Returns the new URL.
  310.   URL *Url The original URL.
  312.   Header *reply_head The head of the original HTTP reply.
  313.   ++++++++++++++++++++++++++++++++++++++*/
  315. char *MovedLocation(URL *Url,Header *reply_head)
  316. {
  317.  char *location;
  318.  char *new;
  320.  location=GetHeader(reply_head,"Location",NULL);
  322.  if(!location)
  323.     return(NULL);
  325.  new=LinkURL(Url,location);
  326.  if(new==location)
  327.    {
  328.     new=(char*)malloc(strlen(location)+1);
  329.     strcpy(new,location);
  330.    }
  332.  return(new);
  333. }
  336. /*++++++++++++++++++++++++++++++++++++++
  337.   Create a new request for a page.
  339.   Header *RequestURL Ask for a page.
  341.   URL *Url The URL to get.
  343.   char *referer The Refering URL or NULL if none.
  344.   ++++++++++++++++++++++++++++++++++++++*/
  346. Header *RequestURL(URL *Url,char *referer)
  347. {
  348.  char *top=(char*)malloc(strlen(Url->name)+32);
  349.  Header *new;
  350.  int i;
  352.  sprintf(top,"GET %s HTTP/1.0rn",Url->name);
  353.  new=CreateHeader(top,1);
  354.  free(top);
  356.  if(Url->user)
  357.    {
  358.     char *userpass=(char*)malloc(strlen(Url->user)+(Url->pass?strlen(Url->pass):0)+2);
  359.     char *auth=(char*)malloc((strlen(Url->user)+(Url->pass?strlen(Url->pass):0))*2+16);
  361.     strcpy(userpass,Url->user);
  362.     strcat(userpass,":");
  363.     if(Url->pass)
  364.        strcat(userpass,Url->pass);
  366.     sprintf(auth,"Basic %s",Base64Encode(userpass,strlen(userpass)));
  367.     AddToHeader(new,"Authorization",auth);
  369.     free(userpass);
  370.     free(auth);
  371.    }
  373.  if(referer)
  374.     AddToHeader(new,"Referer",referer);
  376.  if(reusable_header->n)
  377.     for(i=0;i<reusable_header->n;i++)
  378.        AddToHeader(new,reusable_header->key[i],reusable_header->val[i]);
  380.  return(new);
  381. }
  384. /*++++++++++++++++++++++++++++++++++++++
  385.   Modify the request taking into account censoring of header and modified URL.
  387.   URL *Url The actual URL.
  389.   Header *request_head The head of the HTTP request possibly with a different URL.
  390.   ++++++++++++++++++++++++++++++++++++++*/
  392. void ModifyRequest(URL *Url,Header *request_head)
  393. {
  394.  int i,j;
  396.  /* Modify the top line of the header. */
  398.  free(request_head->url);
  399.  request_head->url=(char*)malloc(strlen(Url->name)+1);
  400.  strcpy(request_head->url,Url->name);
  402.  /* Remove the false arguments from POST/PUT URLs. */
  404.  if(!strcmp(request_head->method,"POST") ||
  405.     !strcmp(request_head->method,"PUT"))
  406.    {
  407.     char *pling=strstr(request_head->url,"?!");
  408.     char *pling2=strchr(++pling+1,'!');
  410.     if(pling2)
  411.        for(;pling<pling2;pling++)
  412.           *pling=*(pling+1);
  414.     *(pling-1)=0;
  415.    }
  417.  /* Add a host header */
  419.  RemoveFromHeader(request_head,"Host",NULL);
  421.  AddToHeader(request_head,"Host",Url->host);
  423.  /* Add a Connection / Proxy-Connection header */
  425.  RemoveFromHeader(request_head,"Connection",NULL);
  426.  RemoveFromHeader(request_head,"Proxy-Connection",NULL);
  428.  if(!strcmp(request_head->version,"HTTP/1.1"))
  429.     strcpy(request_head->version,"HTTP/1.0");
  431.  AddToHeader(request_head,"Connection","close");
  432.  AddToHeader(request_head,"Proxy-Connection","close");
  434.  /* Check the authorisation header. */
  436.  RemoveFromHeader(request_head,"Authorization",NULL);
  438.  if(Url->user)
  439.    {
  440.     char *userpass=(char*)malloc(strlen(Url->user)+(Url->pass?strlen(Url->pass):0)+2);
  441.     char *auth=(char*)malloc((strlen(Url->user)+(Url->pass?strlen(Url->pass):0))*2+16);
  443.     strcpy(userpass,Url->user);
  444.     strcat(userpass,":");
  445.     if(Url->pass)
  446.        strcat(userpass,Url->pass);
  448.     sprintf(auth,"Basic %s",Base64Encode(userpass,strlen(userpass)));
  449.     AddToHeader(request_head,"Authorization",auth);
  451.     free(userpass);
  452.     free(auth);
  453.    }
  455.  /* Remove some headers */
  457.  for(j=0;j<sizeof(deleted_http11_headers)/sizeof(char*);j++)
  458.     RemoveFromHeader(request_head,deleted_http11_headers[j],NULL);
  460.  RemoveFromHeader(request_head,"Pragma","wwwoffle");
  462.  /* Censor the header */
  464.  for(i=0;i<request_head->n;i++)
  465.    {
  466.     char *censor;
  468.     if(!request_head->key[i])
  469.        continue;
  471.     for(j=0;j<sizeof(non_censored_headers)/sizeof(char*);j++)
  472.        if(!strcasecmp(non_censored_headers[j],request_head->key[i]))
  473.           continue;
  475.     if((censor=CensoredHeader(Url->name,request_head->key[i],request_head->val[i])))
  476.       {
  477.        if(censor!=request_head->val[i])
  478.          {
  479.           PrintMessage(Debug,"CensorRequestHeader replaced '%s: %s' by '%s: %s'.",request_head->key[i],request_head->val[i],request_head->key[i],censor);
  480.           request_head->size+=strlen(censor)-strlen(request_head->val[i]);
  481.           free(request_head->val[i]);
  482.           request_head->val[i]=censor;
  483.          }
  484.       }
  485.     else
  486.       {
  487.        PrintMessage(Debug,"CensorRequestHeader removed '%s: %s'.",request_head->key[i],request_head->val[i]);
  488.        RemoveFromHeader(request_head,request_head->key[i],request_head->val[i]);
  489.        continue;
  490.       }
  492.     if(!strcasecmp("Referer",request_head->key[i]))
  493.       {
  494.        char *pling=strstr(request_head->val[i],"?!");
  496.        if(pling)
  497.          {
  498.           char *pling2=strchr(++pling+1,'!');
  500.           if(pling2)
  501.              for(;pling<pling2;pling++)
  502.                 *pling=*(pling+1);
  504.           *(pling-1)=0;
  505.          }
  506.       }
  507.    }
  508. }
  511. /*++++++++++++++++++++++++++++++++++++++
  512.   Change the request to one that contains an authorisation string if required.
  514.   char *proxy The name of the proxy.
  516.   Header *request_head The HTTP request head.
  517.   ++++++++++++++++++++++++++++++++++++++*/
  519. void MakeRequestAuthorised(char *proxy,Header *request_head)
  520. {
  521.  char *userpass=WhatProxyAuth(proxy);
  523.  RemoveFromHeader(request_head,"Proxy-Authorization",NULL);
  525.  if(userpass)
  526.    {
  527.     char *auth=(char*)malloc(strlen(userpass)*2+8);
  529.     sprintf(auth,"Basic %s",Base64Encode(userpass,strlen(userpass)));
  530.     AddToHeader(request_head,"Proxy-Authorization",auth);
  532.     free(userpass);
  533.     free(auth);
  534.    }
  535. }
  538. /*++++++++++++++++++++++++++++++++++++++
  539.   Change the request from one to a proxy to a normal one.
  541.   Header *request_head The head of the HTTP request.
  542.   ++++++++++++++++++++++++++++++++++++++*/
  544. void MakeRequestNonProxy(Header *request_head)
  545. {
  546.  char *p=request_head->url,*q=request_head->url;
  548.  /* The URL is already in canonical form because of the ModifyRequest() function. */
  550.  while(*p!=':')                 /* 'http://' */
  551.     p++;
  552.  p+=3;
  554.  while(*p!='/')                 /* 'www.host.domain/' */
  555.     p++;
  557.  while(*p)
  558.     *q++=*p++;
  559.  *q=0;
  561.  /* Remove the proxy connection & authorization headers. */
  563.  RemoveFromHeader(request_head,"Proxy-Connection","close");
  564.  RemoveFromHeader(request_head,"Proxy-Authorization",NULL);
  565. }
  568. /*++++++++++++++++++++++++++++++++++++++
  569.   Parse the reply from the server.
  571.   int ParseReply Return the numeric status of the reply.
  573.   int fd The file descriptor to read from (or -1 to use the Protocol's method).
  575.   URL *Url The URL that we are reading.
  577.   Header **reply_head Return the head of the HTTP reply.
  578.   ++++++++++++++++++++++++++++++++++++++*/
  580. int ParseReply(int fd,URL *Url,Header **reply_head)
  581. {
  582.  char *line=NULL;
  584.  *reply_head=NULL;
  586.  while((fd==-1 && (line=(Url->Protocol->readhead)(line))) ||
  587.        (fd!=-1 && (line=read_line(fd,line))))
  588.    {
  589.     if(!*reply_head)   /* first line */
  590.       {
  591.        *reply_head=CreateHeader(line,0);
  593.        if(!*(*reply_head)->version)
  594.           break;
  595.        continue;
  596.       }
  598.     if(!AddToHeaderRaw(*reply_head,line))
  599.        break;
  600.    }
  602.  if(!line)
  603.    return(0);
  605.  free(line);
  607.  if(*reply_head)
  608.     return((*reply_head)->status);
  609.  else
  610.     return(0);
  611. }
  614. /*++++++++++++++++++++++++++++++++++++++
  615.   Find the status of a spooled page.
  617.   int SpooledPageStatus Returns the status number.
  619.   URL *Url The URL to check.
  620.   ++++++++++++++++++++++++++++++++++++++*/
  622. int SpooledPageStatus(URL *Url)
  623. {
  624.  int spool=OpenWebpageSpoolFile(1,Url);
  625.  int status=0;
  627.  if(spool!=-1)
  628.    {
  629.     char *reply;
  631.     init_buffer(spool);
  633.     reply=read_line(spool,NULL);
  635.     if(reply)
  636.       {
  637.        sscanf(reply,"%*s %d",&status);
  638.        free(reply);
  639.       }
  641.     close(spool);
  642.    }
  644.  return(status);
  645. }
  648. /*++++++++++++++++++++++++++++++++++++++
  649.   Modify the reply taking into account censoring of the header.
  651.   Header *reply_head The head of the HTTP reply.
  652.   ++++++++++++++++++++++++++++++++++++++*/
  654. void ModifyReply(Header *reply_head)
  655. {
  656.  int i;
  658.  /* Add a Connection / Proxy-Connection header */
  660.  RemoveFromHeader(reply_head,"Connection",NULL);
  661.  RemoveFromHeader(reply_head,"Proxy-Connection",NULL);
  663.  if(!strcmp(reply_head->version,"HTTP/1.1"))
  664.     strcpy(reply_head->version,"HTTP/1.0");
  666.  AddToHeader(reply_head,"Connection","close");
  667.  AddToHeader(reply_head,"Proxy-Connection","close");
  669.  /* Censor the header */
  671.  for(i=0;i<reply_head->n;i++)
  672.    {
  673.     int j;
  674.     char *censor;
  676.     if(!reply_head->key[i])
  677.        continue;
  679.     for(j=0;j<sizeof(non_censored_headers)/sizeof(char*);j++)
  680.        if(!strcasecmp(non_censored_headers[j],reply_head->key[i]))
  681.           continue;
  683.     if((censor=CensoredHeader(NULL,reply_head->key[i],reply_head->val[i])))
  684.       {
  685.        if(censor!=reply_head->val[i])
  686.          {
  687.           PrintMessage(Debug,"CensorReplyHeader replaced '%s: %s' by '%s: %s'.",reply_head->key[i],reply_head->val[i],reply_head->key[i],censor);
  688.           reply_head->size+=strlen(censor)-strlen(reply_head->val[i]);
  689.           free(reply_head->val[i]);
  690.           reply_head->val[i]=censor;
  691.          }
  692.       }
  693.     else
  694.       {
  695.        PrintMessage(Debug,"CensorReplyHeader removed '%s: %s'.",reply_head->key[i],reply_head->val[i]);
  696.        RemoveFromHeader(reply_head,reply_head->key[i],reply_head->val[i]);
  697.       }
  698.    }
  699. }
  702. /*++++++++++++++++++++++++++++++++++++++
  703.   Create a new Header structure.
  705.   Header *CreateHeader Returns the new header structure.
  707.   char *line The top line in the original header.
  709.   int type The type of header, request=1, reply=0;
  710.   ++++++++++++++++++++++++++++++++++++++*/
  712. Header *CreateHeader(char *line,int type)
  713. {
  714.  Header *new=(Header*)malloc(sizeof(*new));
  715.  char *p=(char*)malloc(strlen(line)+1),*oldp=p;
  716.  char *method="",*url="",*note="",*version="";
  717.  int status=0;
  719.  /* Parse the original header. */
  721.  strcpy(p,line);
  723.  new->type=type;
  725.  if(type==1)
  726.    {
  727.                                 /* GET http://www/xxx HTTP/1.0rn */
  728.     method=p;
  729.     while(*p && !isspace(*p))   /*    ^                            */
  730.        p++;
  731.     if(!*p) goto eol_req;
  732.     *p++=0;
  733.     while(*p && isspace(*p))    /*     ^                           */
  734.        p++;
  735.     if(!*p) goto eol_req;
  736.     url=p;
  737.     while(*p && !isspace(*p))   /*                   ^             */
  738.        p++;
  739.     if(!*p) goto eol_req;
  740.     *p++=0;
  741.     while(*p && isspace(*p))    /*                    ^            */
  742.        p++;
  743.     if(!*p) goto eol_req;
  744.     version=p;
  745.     while(*p && !isspace(*p))   /*                            ^    */
  746.        p++;
  747.     *p=0;
  749.    eol_req:
  751.     if(!*version)
  752.        version="HTTP/1.0";
  754.     new->method=(char*)malloc(strlen(method)+1);
  755.     strcpy(new->method,method);
  757.     new->url=(char*)malloc(strlen(url)+1);
  758.     strcpy(new->url,url);
  760.     for(p=new->method;*p;p++)
  761.        *p=toupper(*p);
  763.     new->status=0;
  764.     new->note=NULL;
  766.     new->size=strlen(new->method)+strlen(new->url);
  767.    }
  768.  else
  769.    {
  770.                                 /* HTTP/1.1 200 OK or somethingrn */
  771.     version=p;
  772.     while(*p && !isspace(*p))   /*         ^                        */
  773.        p++;
  774.     if(!*p) goto eol_rep;
  775.     *p++=0;
  776.     while(*p && isspace(*p))    /*          ^                       */
  777.        p++;
  778.     if(!*p) goto eol_rep;
  779.     status=atoi(p);
  780.     while(*p && !isspace(*p))   /*             ^                    */
  781.        p++;
  782.     if(!*p) goto eol_rep;
  783.     *p++=0;
  784.     while(*p && isspace(*p))    /*              ^                   */
  785.        p++;
  786.     if(!*p) goto eol_rep;
  787.     note=p;
  788.     while(*p && !iscntrl(*p))   /*                             ^    */
  789.        p++;
  790.     *p=0;
  792.    eol_rep:
  794.     new->method=NULL;
  795.     new->url=NULL;
  797.     new->status=status%1000;
  799.     new->note=(char*)malloc(strlen(note)+1);
  800.     strcpy(new->note,note);
  802.     new->size=strlen(new->note)+3; /* 3 = strlen(status) */
  803.    }
  805.  new->version=(char*)malloc(strlen(version)+1);
  806.  strcpy(new->version,version);
  808.  for(p=new->version;*p;p++)
  809.     *p=toupper(*p);
  811.  new->size+=strlen(new->version)+4; /* 4 = 2*' ' + 'rn' */
  813.  new->size+=2; /* 2 = 'rn' */
  815.  new->n=0;
  816.  new->key=NULL;
  817.  new->val=NULL;
  819.  free(oldp);
  821.  return(new);
  822. }
  825. /*++++++++++++++++++++++++++++++++++++++
  826.   Add a specified key and value to the header structure.
  828.   Header *head The header structure to add to.
  830.   char *key The key to add.
  832.   char *val The value to add.
  833.   ++++++++++++++++++++++++++++++++++++++*/
  835. void AddToHeader(Header *head,char *key,char *val)
  836. {
  837.  int i;
  839.  head->size+=strlen(key)+strlen(val)+4;
  841.  if(head->key)
  842.     for(i=0;i<head->n;i++)
  843.        if(!head->key[i])
  844.          {
  845.           head->key[i]=(char*)malloc(strlen(key)+1);
  846.           strcpy(head->key[i],key);
  847.           head->val[i]=(char*)malloc(strlen(val)+1);
  848.           strcpy(head->val[i],val);
  849.           return;
  850.          }
  852.  if(head->key)
  853.    {
  854.     head->key=(char**)realloc((void*)head->key,sizeof(char*)*(head->n+1));
  855.     head->val=(char**)realloc((void*)head->val,sizeof(char*)*(head->n+1));
  856.    }
  857.  else
  858.    {
  859.     head->key=(char**)malloc(sizeof(char*)*8);
  860.     head->val=(char**)malloc(sizeof(char*)*8);
  861.    }
  863.  head->key[head->n]=(char*)malloc(strlen(key)+1);
  864.  strcpy(head->key[head->n],key);
  865.  head->val[head->n]=(char*)malloc(strlen(val)+1);
  866.  strcpy(head->val[head->n],val);
  868.  head->n++;
  869. }
  872. /*++++++++++++++++++++++++++++++++++++++
  873.   Add a raw line to a header.
  875.   int AddToHeaderRaw Returns 1 if OK, else 0.
  877.   Header *head The header to add the line to.
  879.   char *line The raw line of data.
  880.   ++++++++++++++++++++++++++++++++++++++*/
  882. static int AddToHeaderRaw(Header *head,char *line)
  883. {
  884.  char *key,*val,*r=line+strlen(line)-1;
  886.  /* trim line */
  888.  while(r>line && isspace(*r))
  889.     r--;
  891.  /* last line */
  893.  if(r==line)
  894.     return(0);
  896.  /* split line */
  898.  key=line;
  899.  val=line;
  901.  while(*val && *val!=':')
  902.     val++;
  904.  if(!*val)
  905.     return(0);
  907.  *++r=0;
  908.  *val++=0;
  909.  while(*val && isspace(*val))
  910.     val++;
  912.  /* Add to the header */
  914.  AddToHeader(head,key,val);
  916.  return(1);
  917. }
  919. /*++++++++++++++++++++++++++++++++++++++
  920.   Remove the specified key and value pair from a header structure.
  922.   Header *head The header to remove from.
  924.   char* key The key to look for and remove.
  926.   char *val The value to look for and remove.
  927.   ++++++++++++++++++++++++++++++++++++++*/
  929. void RemoveFromHeader(Header *head,char* key,char *val)
  930. {
  931.  int i;
  933.  for(i=0;i<head->n;i++)
  934.    {
  935.     if(!head->key[i])
  936.        continue;
  938.     if(!strcasecmp(head->key[i],key) &&
  939.        (!val || !strncasecmp(head->val[i],val,strlen(val))))
  940.       {
  941.        head->size-=strlen(head->key[i])+strlen(head->val[i])+4;
  943.        free(head->key[i]);
  944.        head->key[i]=NULL;
  945.        free(head->val[i]);
  946.        head->val[i]=NULL;
  947.       }
  948.    }
  949. }
  952. /*++++++++++++++++++++++++++++++++++++++
  953.   Search through a HTTP header for a specified key and value pair.
  955.   char *GetHeader Returns the value for the header key or NULL if none.
  957.   Header *head The header to search through.
  959.   char* key The key to look for.
  961.   char *val The value to look for.
  962.   ++++++++++++++++++++++++++++++++++++++*/
  964. char *GetHeader(Header *head,char* key,char *val)
  965. {
  966.  int i;
  968.  for(i=0;i<head->n;i++)
  969.    {
  970.     if(!head->key[i])
  971.        continue;
  973.     if(!strcasecmp(head->key[i],key) &&
  974.        (!val || !strncasecmp(head->val[i],val,strlen(val))))
  975.        return(head->val[i]);
  976.    }
  978.  return(NULL);
  979. }
  982. /*++++++++++++++++++++++++++++++++++++++
  983.   Return a string that contains the whole of the header.
  985.   char *HeaderString Returns the header as a string.
  987.   Header *head The header structure to convert.
  988.   ++++++++++++++++++++++++++++++++++++++*/
  990. char *HeaderString(Header *head)
  991. {
  992.  char *str;
  993.  int i;
  995.  str=(char*)malloc(head->size+16);
  997.  if(head->type==1)
  998.    {
  999.     strcpy(str,head->method);
  1000.     strcat(str," ");
  1001.     strcat(str,head->url);
  1002.     strcat(str," ");
  1003.     strcat(str,head->version);
  1004.    }
  1005.  else
  1006.    {
  1007.     if(*head->version)
  1008.       {
  1009.        strcpy(str,head->version);
  1010.        strcat(str," ");
  1011.        sprintf(str+strlen(head->version)+1,"%3d",head->status);
  1012.        strcat(str," ");
  1013.        strcat(str,head->note);
  1014.       }
  1015.     else
  1016.        strcpy(str,"HTTP/1.0 200 OK");
  1017.    }
  1018.  strcat(str,"rn");
  1020.  for(i=0;i<head->n;i++)
  1021.    {
  1022.     if(!head->key[i])
  1023.        continue;
  1025.     strcat(str,head->key[i]);
  1026.     strcat(str,": ");
  1027.     strcat(str,head->val[i]);
  1028.     strcat(str,"rn");
  1029.    }
  1031.  strcat(str,"rn");
  1033.  return(str);
  1034. }
  1037. /*++++++++++++++++++++++++++++++++++++++
  1038.   Free a header structure.
  1040.   Header *head The header structure to free.
  1041.   ++++++++++++++++++++++++++++++++++++++*/
  1043. void FreeHeader(Header *head)
  1044. {
  1045.  int i;
  1047.  if(head->type)
  1048.    {
  1049.     free(head->method);
  1050.     free(head->url);
  1051.    }
  1052.  else
  1053.     free(head->note);
  1055.  free(head->version);
  1057.  for(i=0;i<head->n;i++)
  1058.    {
  1059.     if(!head->key[i])
  1060.        continue;
  1062.     free(head->key[i]);
  1063.     free(head->val[i]);
  1064.    }
  1066.  if(head->n)
  1067.    {
  1068.     free(head->key);
  1069.     free(head->val);
  1070.    }
  1072.  free(head);
  1073. }
  1076. /*++++++++++++++++++++++++++++++++++++++
  1077.   Create a new Body structure.
  1079.   Header *CreateBody Returns the new body structure.
  1081.   int length The length of the body;
  1082.   ++++++++++++++++++++++++++++++++++++++*/
  1084. Body *CreateBody(int length)
  1085. {
  1086.  Body *new=(Body*)malloc(sizeof(*new));
  1088.  new->length=length;
  1090.  new->content=malloc(length+3);
  1092.  return(new);
  1093. }
  1096. /*++++++++++++++++++++++++++++++++++++++
  1097.   Free a body structure.
  1099.   Body *body The body structure to free.
  1100.   ++++++++++++++++++++++++++++++++++++++*/
  1102. void FreeBody(Body *body)
  1103. {
  1104.  if(body->content)
  1105.     free(body->content);
  1107.  free(body);
  1108. }