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

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

浏览器

开发平台：

Unix_Linux

misc.c：源码内容
  1. /***************************************
  2.   $Header: /home/amb/wwwoffle/RCS/misc.c 2.40 2000/02/20 09:44:01 amb Exp $
  4.   WWWOFFLE - World Wide Web Offline Explorer - Version 2.5d.
  5.   Miscellaneous HTTP / HTML functions.
  6.   ******************/ /******************
  7.   Written by Andrew M. Bishop
  9.   This file Copyright 1997,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.   ***************************************/
  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <string.h>
  18. #include <ctype.h>
  20. #include <time.h>
  21. #include <sys/time.h>
  22. #include <sys/types.h>
  23. #include <fcntl.h>
  24. #include <unistd.h>
  25. #include <errno.h>
  27. #include "misc.h"
  28. #include "errors.h"
  29. #include "proto.h"
  30. #include "config.h"
  31. #include "md5.h"
  34. /*++++++++++++++++++++++++++++++++++++++
  35.   Split a URL into a protocol, hostname, path name and an argument list.
  37.   URL *SplitURL Returns a URL structure containing the information.
  39.   char *url The name of the url to split.
  40.   ++++++++++++++++++++++++++++++++++++++*/
  42. URL *SplitURL(char *url)
  43. {
  44.  URL *Url=(URL*)malloc(sizeof(URL));
  45.  char *copyurl,*mallocurl=malloc(strlen(url)+2);
  46.  int i=0,n=0;
  47.  char *colon,*slash,*at,*ques,*temppath,root[2];
  49.  copyurl=mallocurl;
  50.  strcpy(copyurl,url);
  52.  /* Protocol */
  54.  colon=strchr(copyurl,':');
  55.  slash=strchr(copyurl,'/');
  56.  at   =strchr(copyurl,'@');
  58.  if(slash==copyurl)                     /* /dir/... (local) */
  59.    {
  60.     Url->proto=(char*)malloc(5);
  61.     strcpy(Url->proto,"http");
  62.    }
  63.  else if(colon && slash && (colon+1)==slash) /* http://... */
  64.    {
  65.     *colon=0;
  66.     Url->proto=(char*)malloc(colon-copyurl+1);
  67.     strcpy(Url->proto,copyurl);
  68.     copyurl=slash+1;
  69.     if(*copyurl=='/')
  70.        copyurl++;
  72.     colon=strchr(copyurl,':');
  73.     slash=strchr(copyurl,'/');
  74.    }
  75.  else if(colon && !isdigit(*(colon+1)) &&
  76.          (!slash || colon<slash) &&
  77.          (!at || (slash && at>slash)))  /* http:www.foo.com/...[:@]... */
  78.    {
  79.     *colon=0;
  80.     Url->proto=(char*)malloc(colon-copyurl+1);
  81.     strcpy(Url->proto,copyurl);
  82.     copyurl=colon+1;
  84.     colon=strchr(copyurl,':');
  85.    }
  86.  else                                   /* www.foo.com:80/... */
  87.    {
  88.     Url->proto=(char*)malloc(5);
  89.     strcpy(Url->proto,"http");
  90.    }
  92.  for(i=0;Url->proto[i];i++)
  93.     Url->proto[i]=tolower(Url->proto[i]);
  95.  Url->Protocol=NULL;
  97.  for(i=0;i<NProtocols;i++)
  98.     if(!strcmp(Protocols[i].name,Url->proto))
  99.        Url->Protocol=&Protocols[i];
  101.  /* Password */
  103.  if(at && at>copyurl && (!slash || slash>at))
  104.    {
  105.     if(colon && at>colon)               /* user:pass@www.foo.com...[/]... */
  106.       {
  107.        *colon=0;
  108.        Url->user=URLDecode(copyurl,0);
  109.        copyurl=colon+1;
  110.        *at=0;
  111.        Url->pass=URLDecode(copyurl,0);
  112.        copyurl=at+1;
  113.       }
  114.     else                               /* user@www.foo.com...[:/]... */
  115.       {
  116.        *at=0;
  117.        Url->user=URLDecode(copyurl,0);
  118.        copyurl=at+1;
  119.        Url->pass=NULL;
  120.       }
  121.    }
  122.  else
  123.    {
  124.     if(at==copyurl)             /* @www.foo.com... */
  125.        copyurl++;
  127.     Url->user=NULL;
  128.     Url->pass=NULL;
  129.    }
  131.  /* Arguments */
  133.  ques=strchr(copyurl,'?');
  135.  if(ques)                       /* ../path?... */
  136.    {
  137.     *ques++=0;
  138.     Url->args=(char*)malloc(strlen(ques)+1);
  139.     strcpy(Url->args,ques);
  140.    }
  141.  else
  142.     Url->args=NULL;
  144.  /* Hostname */
  146.  if(*copyurl=='/')              /* /path/... (local) */
  147.    {
  148.     Url->host=GetLocalHost(1);
  149.     Url->local=1;
  150.    }
  151.  else                           /* www.foo.com... */
  152.    {
  153.     Url->host=copyurl;
  154.     Url->local=0;
  156.     if(slash && (!ques || slash<ques)) /* www.foo.com/...[?]... */
  157.        copyurl=slash;
  158.     else                        /* www.foo.com[?]... */
  159.       {root[0]='/';root[1]=0;copyurl=root;}
  160.    }
  162.  /* Pathname */
  164.  temppath=URLDecode(copyurl,0);
  165.  Url->path=URLEncode(temppath);
  166.  free(temppath);
  168.  /* Hostname (cont) */
  170.  if(!Url->local)
  171.    {
  172.     *copyurl=0;
  173.     copyurl=Url->host;
  174.     Url->host=(char*)malloc(strlen(copyurl)+1);
  175.     strcpy(Url->host,copyurl);
  176.    }
  178.  for(i=0;Url->host[i] && Url->host[i]!=':';i++)
  179.     Url->host[i]=tolower(Url->host[i]);
  181.  if(Url->host[i]==':')
  182.     if(atoi(&Url->host[i+1])==(Url->Protocol?Url->Protocol->defport:80))
  183.        Url->host[i]=0;
  185.  if(!Url->local && IsLocalHost(Url->host,1) && Url->Protocol && Url->Protocol==&Protocols[0])
  186.    {
  187.     free(Url->host);
  188.     Url->host=GetLocalHost(1);
  189.     Url->local=1;
  190.    }
  192.  /* Canonicalise the URL. */
  194.  Url->name=(char*)malloc(strlen(Url->proto)+strlen(Url->host)+strlen(Url->path)+(Url->args?strlen(Url->args):1)+8);
  196.  strcpy(Url->name,Url->proto);
  197.  n=strlen(Url->proto);
  198.  strcpy(Url->name+n,"://");
  199.  n+=3;
  201.  Url->hostp=Url->name+n;
  203.  strcpy(Url->name+n,Url->host);
  204.  n+=strlen(Url->host);
  206.  Url->pathp=Url->name+n;
  208.  strcpy(Url->name+n,Url->path);
  209.  n+=strlen(Url->path);
  211.  if(Url->args && *Url->args)
  212.    {
  213.     strcpy(Url->name+n,"?");
  214.     strcpy(Url->name+n+1,Url->args);
  215.    }
  217.  if(Url->user)
  218.    {
  219.     Url->file=(char*)malloc(strlen(Url->proto)+strlen(Url->hostp)+strlen(Url->user)+(Url->pass?strlen(Url->pass):0)+8);
  221.     n=Url->hostp-Url->name;
  222.     strncpy(Url->file,Url->name,n);
  224.     strcpy(Url->file+n,Url->user);
  225.     n+=strlen(Url->user);
  227.     if(Url->pass)
  228.       {
  229.        strcpy(Url->file+n,":");
  230.        strcpy(Url->file+n+1,Url->pass);
  231.        n+=strlen(Url->pass)+1;
  232.       }
  234.     strcpy(Url->file+n,"@");
  235.     strcpy(Url->file+n+1,Url->hostp);
  236.    }
  237.  else
  238.     Url->file=Url->name;
  240.  if(Url->Protocol && !Url->Protocol->proxyable)
  241.    {
  242.     char *localhost=GetLocalHost(1);
  243.     Url->link=(char*)malloc(strlen(Url->name)+strlen(localhost)+8);
  244.     sprintf(Url->link,"http://%s/%s/%s",localhost,Url->proto,Url->hostp);
  245.    }
  246.  else
  247.     Url->link=Url->name;
  249.  Url->dir=Url->host;
  251. #if defined(__CYGWIN__)
  252.  if(strchr(Url->host,':'))
  253.    {
  254.     char *colon=strchr(Url->host,':');
  255.     Url->dir=(char*)malloc(strlen(Url->host));
  256.     strcpy(Url->dir,Url->host);
  258.     Url->dir[colon-Url->host]='!';
  259.    }
  260. #endif
  262.  /* end */
  264.  free(mallocurl);
  266.  return(Url);
  267. }
  270. /*++++++++++++++++++++++++++++++++++++++
  271.   Add a password to an existing URL.
  273.   URL *Url The URL to add the username and password to.
  275.   char *user The username.
  277.   char *pass The password.
  278.   ++++++++++++++++++++++++++++++++++++++*/
  280. void AddURLPassword(URL *Url,char *user,char *pass)
  281. {
  282.  int n;
  284.  Url->user=(char*)malloc(strlen(user)+1);
  285.  strcpy(Url->user,user);
  287.  if(pass)
  288.    {
  289.     Url->pass=(char*)malloc(strlen(pass)+1);
  290.     strcpy(Url->pass,pass);
  291.    }
  293.  Url->file=(char*)malloc(strlen(Url->name)+strlen(Url->user)+(Url->pass?strlen(Url->pass):0)+8);
  295.  n=Url->hostp-Url->name;
  296.  strncpy(Url->file,Url->name,n);
  298.  strcpy(Url->file+n,Url->user);
  299.  n+=strlen(Url->user);
  301.  if(Url->pass)
  302.    {
  303.     strcpy(Url->file+n,":");
  304.     strcpy(Url->file+n+1,Url->pass);
  305.     n+=strlen(Url->pass)+1;
  306.    }
  308.  strcpy(Url->file+n,"@");
  309.  strcpy(Url->file+n+1,Url->hostp);
  310. }
  313. /*++++++++++++++++++++++++++++++++++++++
  314.   Free the memory in a URL.
  316.   URL *Url The URL to free.
  317.   ++++++++++++++++++++++++++++++++++++++*/
  319. void FreeURL(URL *Url)
  320. {
  321.  if(Url->name!=Url->link)
  322.     free(Url->link);
  324.  if(Url->name!=Url->file)
  325.     free(Url->file);
  327.  if(Url->dir!=Url->host)
  328.     free(Url->dir);
  330.  free(Url->name);
  332.  if(Url->proto) free(Url->proto);
  333.  if(Url->host)  free(Url->host);
  334.  if(Url->path)  free(Url->path);
  335.  if(Url->args)  free(Url->args);
  337.  if(Url->user)  free(Url->user);
  338.  if(Url->pass)  free(Url->pass);
  340.  free(Url);
  341. }
  344. /*++++++++++++++++++++++++++++++++++++++
  345.   Convert a url reference from a page to an absolute one.
  347.   char *LinkURL Return the linked to URL or the original link if unchanged.
  349.   URL *Url The page that we are looking at.
  351.   char *link The link from the page.
  352.   ++++++++++++++++++++++++++++++++++++++*/
  354. char *LinkURL(URL *Url,char *link)
  355. {
  356.  char *new=link;
  357.  char *colon=strchr(link,':');
  358.  char *slash=strchr(link,'/');
  360.  if(colon && slash && colon<slash)
  361.     ;
  362.  else if(!*link)
  363.    {
  364.     new=(char*)malloc(strlen(Url->name));
  365.     strcpy(link,Url->name);
  366.    }
  367.  else
  368.    {
  369.     if(*link=='/')
  370.       {
  371.        new=(char*)malloc(strlen(Url->proto)+strlen(Url->host)+strlen(link)+8);
  372.        sprintf(new,"%s://%s%s",Url->proto,Url->host,link);
  373.       }
  374.     else
  375.       {
  376.        int j;
  377.        char *path=(char*)malloc(strlen(Url->path)+strlen(link)+2);
  379.        strcpy(path,Url->path);
  381.        for(j=strlen(path);j>0;j--)
  382.           if(path[j]=='/')
  383.              break;
  384.        path[j]=0;
  386.        strcat(path,"/");
  387.        strcat(path,link);
  389.        CanonicaliseName(path);
  391.        new=(char*)malloc(strlen(Url->proto)+strlen(Url->host)+strlen(path)+8);
  392.        sprintf(new,"%s://%s%s",Url->proto,Url->host,path);
  393.        free(path);
  394.       }
  395.    }
  397.  return(new);
  398. }
  401. /*++++++++++++++++++++++++++++++++++++++
  402.   Canonicalise a file name by removing '/../', '/./' and '//' references.
  404.   char *CanonicaliseName Returns the argument modified.
  406.   char *name The original name
  407.   ++++++++++++++++++++++++++++++++++++++*/
  409. char *CanonicaliseName(char *name)
  410. {
  411.  char *match,*name2;
  413.  match=name;
  414.  while((match=strstr(match,"/./")) || !strncmp(match=name,"./",2))
  415.    {
  416.     char *prev=match, *next=match+2;
  417.     while((*prev++=*next++));
  418.    }
  420.  match=name;
  421.  while((match=strstr(match,"//")))
  422.    {
  423.     char *prev=match, *next=match+1;
  424.     while((*prev++=*next++));
  425.    }
  427.  match=name2=name;
  428.  while((match=strstr(match,"/../")))
  429.    {
  430.     char *prev=match, *next=match+4;
  431.     if((prev-name2)==2 && !strncmp(name2,"../",3))
  432.       {name2+=3;match++;continue;}
  433.     while(prev>name2 && *--prev!='/');
  434.     match=prev;
  435.     if(*prev=='/')prev++;
  436.     while((*prev++=*next++));
  437.    }
  439.  match=&name[strlen(name)-2];
  440.  if(match>=name && !strcmp(match,"/."))
  441.     *match=0;
  443.  match=&name[strlen(name)-3];
  444.  if(match>=name && !strcmp(match,"/.."))
  445.     if(match==name)
  446.        *++match=0;
  447.     else
  448.        while(match>name && *--match!='/')
  449.           *match=0;
  451. #if 0 /* as used in cxref */
  453.  match=&name[strlen(name)-1];
  454.  if(match>name && !strcmp(match,"/"))
  455.     *match=0;
  457.  if(!*name)
  458.     *name='.',*(name+1)=0;
  460. #else /* as used in wwwoffle */
  462.  if(!*name || !strncmp(name,"../",3))
  463.     *name='/',*(name+1)=0;
  465. #endif
  467.  return(name);
  468. }
  471. /*++++++++++++++++++++++++++++++++++++++
  472.   Decode a string that has been UrlEncoded.
  474.   char *URLDecode Returns a malloced copy of the decoded string.
  476.   const char *str The string to be decoded.
  478.   int isform Set to true if the string being decoded is from a form.
  479.   ++++++++++++++++++++++++++++++++++++++*/
  481. char *URLDecode(const char *str, int isform)
  482. {
  483.  int i,j;
  484.  char *copy=(char*)malloc(strlen(str)+1);
  486.  for(i=0,j=0;str[i];i++)
  487.     if(str[i]=='+' && isform)
  488.        copy[j++]=' ';
  489.     else if(str[i]=='%')
  490.       {
  491.        unsigned int val=0;
  492.        i++;
  493.        if(str[i]>='a') val=str[i]-'a'+10;
  494.        else if(str[i]>='A') val=str[i]-'A'+10;
  495.        else val=str[i]-'0';
  496.        val*=16;
  497.        i++;
  498.        if(str[i]>='a') val+=str[i]-'a'+10;
  499.        else if(str[i]>='A') val+=str[i]-'A'+10;
  500.        else val+=str[i]-'0';
  501.        copy[j++]=val;
  502.       }
  503.     else
  504.        copy[j++]=str[i];
  506.  copy[j]=0;
  508.  return(copy);
  509. }
  512. /*++++++++++++++++++++++++++++++++++++++
  513.   Decode a URL argument string that has been UrlEncoded.
  515.   char *URLDecodeArgs Returns a malloced copy of the decoded string.
  517.   const char *str The string to be decoded.
  518.   ++++++++++++++++++++++++++++++++++++++*/
  520. char *URLDecodeArgs(const char *str)
  521. {
  522.  int i,j;
  523.  char *copy=(char*)malloc(strlen(str)+1);
  525.  for(i=0,j=0;str[i];i++)
  526.     if(str[i]=='%')
  527.       {
  528.        unsigned int val=0;
  529.        i++;
  530.        if(str[i]>='a') val=str[i]-'a'+10;
  531.        else if(str[i]>='A') val=str[i]-'A'+10;
  532.        else val=str[i]-'0';
  533.        val*=16;
  534.        i++;
  535.        if(str[i]>='a') val+=str[i]-'a'+10;
  536.        else if(str[i]>='A') val+=str[i]-'A'+10;
  537.        else val+=str[i]-'0';
  539.        if(val=='&' || val=='=')
  540.           copy[j++]=str[i];
  541.        else
  542.           copy[j++]=val;
  543.       }
  544.     else
  545.        copy[j++]=str[i];
  547.  copy[j]=0;
  549.  return(copy);
  550. }
  553. /*++++++++++++++++++++++++++++++++++++++
  554.   Encode a string using the UrlEncode method as used with the POST method.
  556.   char *URLEncode Returns a malloced copy of the encoded string.
  558.   const char *str The string to be encoded.
  559.   ++++++++++++++++++++++++++++++++++++++*/
  561. char *URLEncode(const char *str)
  562. {
  563.  int i,j;
  564.  char *copy=(char*)malloc(3*strlen(str)+1);
  566.  for(i=0,j=0;str[i];i++)
  567.     if(isalpha(str[i]) ||
  568.        isdigit(str[i]) ||
  569.        str[i]=='/' || str[i]=='?' || str[i]=='@' || str[i]=='=' ||
  570.        str[i]=='$' || str[i]=='-' || str[i]=='_' || str[i]=='.' || str[i]=='+' || str[i]=='!' ||
  571.        str[i]=='*' || str[i]=='(' || str[i]==')' || str[i]==',' || str[i]==''')
  572.        copy[j++]=str[i];
  573.     else
  574.       {
  575.        unsigned int val=str[i];
  576.        copy[j]='%';
  577.        if(val%16>9)
  578.           copy[j+2]=val%16+'A'-10;
  579.        else
  580.           copy[j+2]=val%16+'0';
  581.        val/=16;
  582.        if(val%16>9)
  583.           copy[j+1]=val%16+'A'-10;
  584.        else
  585.           copy[j+1]=val%16+'0';
  586.        j+=3;
  587.       }
  589.  copy[j]=0;
  591.  return(copy);
  592. }
  595. /*++++++++++++++++++++++++++++++++++++++
  596.   Encode a string using the UrlEncode method as used for passwords in URLs.
  598.   char *URLEncodePassword Returns a malloced copy of the encoded string.
  600.   const char *str The string to be encoded.
  601.   ++++++++++++++++++++++++++++++++++++++*/
  603. char *URLEncodePassword(const char *str)
  604. {
  605.  int i,j;
  606.  char *copy=(char*)malloc(3*strlen(str)+1);
  608.  for(i=0,j=0;str[i];i++)
  609.     if(isalpha(str[i]) ||
  610.        isdigit(str[i]) ||
  611.        str[i]=='?' || str[i]==':' || str[i]=='=' ||
  612.        str[i]=='$' || str[i]=='-' || str[i]=='_' || str[i]=='.' || str[i]=='+' || str[i]=='!' ||
  613.        str[i]=='*' || str[i]=='(' || str[i]==')' || str[i]==',' || str[i]==''')
  614.        copy[j++]=str[i];
  615.     else
  616.       {
  617.        unsigned int val=str[i];
  618.        copy[j]='%';
  619.        if(val%16>9)
  620.           copy[j+2]=val%16+'A'-10;
  621.        else
  622.           copy[j+2]=val%16+'0';
  623.        val/=16;
  624.        if(val%16>9)
  625.           copy[j+1]=val%16+'A'-10;
  626.        else
  627.           copy[j+1]=val%16+'0';
  628.        j+=3;
  629.       }
  631.  copy[j]=0;
  633.  return(copy);
  634. }
  637. /*++++++++++++++++++++++++++++++++++++++
  638.   Generate a hash value for a string.
  640.   char *MakeHash Returns a string that can be used as the hashed string.
  642.   const char *args The arguments.
  643.   ++++++++++++++++++++++++++++++++++++++*/
  645. char *MakeHash(const char *args)
  646. {
  647.  char md5[17];
  648.  char *hash,*p;
  649.  struct MD5Context ctx;
  651.  /* Initialize the computation context.  */
  652.  MD5Init (&ctx);
  654.  /* Process whole buffer but last len % 64 bytes.  */
  655.  MD5Update (&ctx, args, strlen(args));
  657.  /* Put result in desired memory area.  */
  658.  MD5Final (md5, &ctx);
  660.  md5[17]=0;
  662.  hash=Base64Encode(md5,16);
  664.  for(p=hash;*p;p++)
  665.     if(*p=='/')
  666.        *p='-';
  667.     else if(*p=='=')
  668.        *p=0;
  670.  return(hash);
  671. }
  674. /*++++++++++++++++++++++++++++++++++++++
  675.   Convert the time into an RFC 822 compliant date.
  677.   char *RFC822Date Returns a pointer to a fixed string containing the date.
  679.   long t The time.
  681.   int utc Set to true to get Universal Time, else localtime.
  682.   ++++++++++++++++++++++++++++++++++++++*/
  684. char *RFC822Date(long t,int utc)
  685. {
  686.  static char *week[7]={"Sun","Mon","Tue","Wed","Thu","Fri","Sat"};
  687.  static char *month[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
  688.  static char value[2][32];
  689.  static int which=0;
  690.  struct tm *tim;
  692.  if(utc)
  693.     tim=gmtime(&t);
  694.  else
  695.    {
  696.     tim=localtime(&t);
  697.     if(tim->tm_isdst<0)
  698.       {tim=gmtime(&t);utc=1;}
  699.    }
  701.  which^=1;
  703.  /* Sun, 06 Nov 1994 08:49:37 GMT    ; RFC 822, updated by RFC 1123 */
  704.  sprintf(value[which],"%3s, %02d %3s %4d %02d:%02d:%02d %s",
  705.          week[tim->tm_wday],
  706.          tim->tm_mday,
  707.          month[tim->tm_mon],
  708.          tim->tm_year+1900,
  709.          tim->tm_hour,
  710.          tim->tm_min,
  711.          tim->tm_sec,
  712. #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__)
  713.          utc?"GMT":tim->tm_zone
  714. #elif defined(__CYGWIN__)
  715.          utc?"GMT":_tzname[tim->tm_isdst>0]
  716. #else
  717.          utc?"GMT":tzname[tim->tm_isdst>0]
  718. #endif
  719.          );
  721.  return(value[which]);
  722. }
  725. /*++++++++++++++++++++++++++++++++++++++
  726.   Convert a string representing a date into a time.
  728.   long DateToTimeT Returns the time.
  730.   const char *date The date string.
  731.   ++++++++++++++++++++++++++++++++++++++*/
  733. long DateToTimeT(const char *date)
  734. {
  735.  static char *month[12]={"Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};
  736.  int  year,day,hour,min,sec;
  737.  char monthstr[16];
  738.  long retval=0;
  740.  if(sscanf(date,"%*s %d %s %d %d:%d:%d",&day,monthstr,&year,&hour,&min,&sec)==6 ||
  741.     sscanf(date,"%*s %d-%3s-%d %d:%d:%d",&day,monthstr,&year,&hour,&min,&sec)==6 ||
  742.     sscanf(date,"%*s %3s %d %d:%d:%d %d",monthstr,&day,&hour,&min,&sec,&year)==6)
  743.    {
  744.     struct tm tim;
  745.     int mon;
  747.     for(mon=0;mon<12;mon++)
  748.        if(!strcmp(monthstr,month[mon]))
  749.           break;
  751.     tim.tm_sec=sec;
  752.     tim.tm_min=min;
  753.     tim.tm_hour=hour;
  754.     tim.tm_mday=day;
  755.     tim.tm_mon=mon;
  756.     if(year<38)
  757.        tim.tm_year=year+100;
  758.     else if(year<100)
  759.        tim.tm_year=year;
  760.     else
  761.        tim.tm_year=year-1900;
  762.     tim.tm_isdst=0;
  764.     retval=mktime(&tim);
  766.     if(retval==-1)
  767.        retval=0;
  768.    }
  769.  else if(sscanf(date,"%ld %1s",&retval,monthstr)==1)
  770.     ;
  772.  return(retval);
  773. }
  776. /*+ The conversion from a 6 bit value to an ASCII character. +*/
  777. static char base64[64]={'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
  778.                         'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
  779.                         'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
  780.                         'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'};
  782. /*++++++++++++++++++++++++++++++++++++++
  783.   Decode a base 64 string.
  785.   char *Base64Decode Return a malloced string containing the decoded version.
  787.   const char *str The string to be decoded.
  789.   int *l Returns the length of the decoded string.
  790.   ++++++++++++++++++++++++++++++++++++++*/
  792. char *Base64Decode(const char *str,int *l)
  793. {
  794.  int le=strlen(str);
  795.  char *decoded=(char*)malloc(le+1);
  796.  int i,j,k;
  798.  while(str[le-1]=='=')
  799.     le--;
  801.  *l=3*(le/4)+(le%4)-1+!(le%4);
  803.  for(j=0;j<le;j++)
  804.     for(k=0;k<64;k++)
  805.        if(base64[k]==str[j])
  806.          {decoded[j]=k;break;}
  808.  for(i=j=0;j<(le+4);i+=3,j+=4)
  809.    {
  810.     unsigned long s=0;
  812.     for(k=0;k<4;k++)
  813.        if((j+k)<le)
  814.           s|=((unsigned long)decoded[j+k]&0xff)<<(18-6*k);
  816.     for(k=0;k<3;k++)
  817.        if((i+k)<*l)
  818.           decoded[i+k]=(char)((s>>(16-8*k))&0xff);
  819.    }
  820.  decoded[*l]=0;
  822.  return(decoded);
  823. }
  826. /*++++++++++++++++++++++++++++++++++++++
  827.   Encode a string into base 64.
  829.   char *Base64Encode Return a malloced string containing the encoded version.
  831.   const char *str The string to be encoded.
  833.   int l The length of the string to be encoded.
  834.   ++++++++++++++++++++++++++++++++++++++*/
  836. char *Base64Encode(const char *str,int l)
  837. {
  838.  int le=4*(l/3)+(l%3)+!!(l%3);
  839.  char *encoded=(char*)malloc(4*(le/4)+4*!!(le%4)+1);
  840.  int i,j,k;
  842.  for(i=j=0;i<(l+3);i+=3,j+=4)
  843.    {
  844.     unsigned long s=0;
  846.     for(k=0;k<3;k++)
  847.        if((i+k)<l)
  848.           s|=((unsigned long)str[i+k]&0xff)<<(16-8*k);
  850.     for(k=0;k<4;k++)
  851.        if((j+k)<le)
  852.           encoded[j+k]=(char)((s>>(18-6*k))&0x3f);
  853.    }
  855.  for(j=0;j<le;j++)
  856.     encoded[j]=base64[(int)encoded[j]];
  857.  for(;j%4;j++)
  858.     encoded[j]='=';
  859.  encoded[j]=0;
  861.  return(encoded);
  862. }
  865. /*++++++++++++++++++++++++++++++++++++++
  866.   Make the input string safe to output as HTML ( not < > & " ).
  868.   char* HTMLString Returns a safe HTML string.
  870.   const char* c A non-safe HTML string.
  871.   ++++++++++++++++++++++++++++++++++++++*/
  873. char* HTMLString(const char* c)
  874. {
  875.  int i=0,j=0,len=256-5;              /* 5 is the longest possible inserted amount */
  876.  char* ret=(char*)malloc(257);
  878.  do
  879.    {
  880.     for(;j<len && c[i];i++)
  881.        switch(c[i])
  882.          {
  883.          case '<':
  884.           ret[j++]='&';
  885.           ret[j++]='l';
  886.           ret[j++]='t';
  887.           ret[j++]=';';
  888.           break;
  889.          case '>':
  890.           ret[j++]='&';
  891.           ret[j++]='g';
  892.           ret[j++]='t';
  893.           ret[j++]=';';
  894.           break;
  895.          case '"':
  896.           ret[j++]='&';
  897.           ret[j++]='q';
  898.           ret[j++]='u';
  899.           ret[j++]='o';
  900.           ret[j++]='t';
  901.           ret[j++]=';';
  902.           break;
  903.          case '&':
  904.           ret[j++]='&';
  905.           ret[j++]='a';
  906.           ret[j++]='m';
  907.           ret[j++]='p';
  908.           ret[j++]=';';
  909.           break;
  910.          default:
  911.           ret[j++]=c[i];
  912.          }
  914.     if(c[i])                 /* Not finished */
  915.       {
  916.        ret=(char*)realloc((void*)ret,len+256+5);
  917.        len+=256;
  918.       }
  919.    }
  920.  while(c[i]);
  922.  ret[j]=0;
  924.  return(ret);
  925. }