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

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

浏览器

开发平台：

Unix_Linux

index.c：源码内容
  1. /***************************************
  2.   $Header: /home/amb/wwwoffle/RCS/index.c 2.63 1999/09/06 18:54:11 amb Exp $
  4.   WWWOFFLE - World Wide Web Offline Explorer - Version 2.5.
  5.   Generate an index of the web pages that are cached in the system.
  6.   ******************/ /******************
  7.   Written by Andrew M. Bishop
  9.   This file Copyright 1997,98,99 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>
  20. #include <time.h>
  21. #include <utime.h>
  22. #include <sys/types.h>
  23. #include <sys/stat.h>
  24. #include <dirent.h>
  25. #include <fcntl.h>
  26. #include <unistd.h>
  28. #include "wwwoffle.h"
  29. #include "misc.h"
  30. #include "proto.h"
  31. #include "config.h"
  32. #include "errors.h"
  35. /*+ A type to contain the information required to sort the files. +*/
  36. typedef struct _FileIndex
  37. {
  38.  URL *url;                      /*+ The URL of the file. +*/
  39.  char *name;                    /*+ The name of the URL. +*/
  40.  char *host;                    /*+ The host of the URL. +*/
  41.  char *type;                    /*+ The type (file extension) of the URL. +*/
  42.  long time;                     /*+ The time of the file (access or modification as appropriate). +*/
  43. }
  44. FileIndex;
  46. /*+ The method of sorting used. +*/
  47. static char *sorttype[]={"none"  ,
  48.                          "mtime" ,
  49.                          "atime" ,
  50.                          "dated" ,
  51.                          "alpha" ,
  52.                          "domain",
  53.                          "type"  ,
  54.                          "none"  };
  56. /*+ An enumerated type for the sort modes. +*/
  57. typedef enum _SortMode
  58. {
  59.  None,                          /*+ No sorting, natural order. +*/
  60.  MTime,                         /*+ Sort by modification time +*/
  61.  ATime,                         /*+ Sort by access time. +*/
  62.  Dated,                         /*+ Sort by modification time with separators. +*/
  63.  Alpha,                         /*+ Sort Alphabetically. +*/
  64.  Domain,                        /*+ Sort by domain name. +*/
  65.  Type,                          /*+ Sort by type (file extension). +*/
  66.  NSortModes                     /*+ The number of sort modes. +*/
  67. }
  68. SortMode;
  71. /*+ The list of files. +*/
  72. static FileIndex **files=NULL;
  73. static int nfiles=0;
  75. /*+ The earliest time that files can appear in the dated list. +*/
  76. static time_t earliest=0;
  78. /*+ The current time. +*/
  79. static time_t now;
  81. static void IndexRoot(int fd);
  82. static void IndexProtocol(int fd,char *proto,SortMode mode,int delopt,int refopt, int monopt,int allopt);
  83. static void IndexHost(int fd,char *proto,char *host,SortMode mode,int delopt,int refopt, int monopt,int allopt);
  84. static void IndexOutgoing(int fd,SortMode mode,int delopt,int refopt, int monopt,int allopt);
  85. static void IndexMonitor(int fd,SortMode mode,int delopt,int refopt, int monopt,int allopt);
  86. static void IndexLastTime(int fd,char *name,SortMode mode,int delopt,int refopt, int monopt,int allopt);
  87. static void IndexLatest(int fd,SortMode mode,int delopt,int refopt, int monopt,int allopt);
  89. static void add_dir(char *name,SortMode mode);
  90. static void add_file(char *name,SortMode mode);
  92. static void dated_separator(int fd,int file,int *lastdays,int *lasthours);
  94. static int sort_alpha(FileIndex **a,FileIndex **b);
  95. static int sort_type(FileIndex **a,FileIndex **b);
  96. static int sort_domain(FileIndex **a,FileIndex **b);
  97. static int sort_time(FileIndex **a,FileIndex **b);
  100. /*++++++++++++++++++++++++++++++++++++++
  101.   Generate an index of the pages that are in the cache.
  103.   int fd The file descriptor to write the output to.
  105.   URL *Url The URL that specifies the path to generate the index for.
  106.   ++++++++++++++++++++++++++++++++++++++*/
  108. void IndexPage(int fd,URL *Url)
  109. {
  110.  char *newpath;
  111.  char *proto=NULL,*host="";
  112.  SortMode sort=NSortModes,s;
  113.  Protocol *protocol=NULL;
  114.  int outgoing=0,monitor=0,lasttime=0,prevtime=0,latest=0,main=0;
  115.  int delopt=0,refopt=0,monopt=0,allopt=0;
  116.  int i;
  118.  if(!strcmp(Url->path,"/index/url/"))
  119.    {
  120.     URL *indexUrl;
  122.     if(Url->args && (indexUrl=SplitURL(Url->args)))
  123.       {
  124.        char *localhost=GetLocalHost(1);
  125.        char *relocate=(char*)malloc(strlen(localhost)+strlen(indexUrl->proto)+strlen(indexUrl->host)+32);
  126.        sprintf(relocate,"http://%s/index/%s/%s?sort=%srn",localhost,indexUrl->proto,indexUrl->host,sorttype[Alpha]);
  127.        HTMLMessage(fd,301,"WWWOFFLE Index URL Redirect",relocate,"IndexURLRedirect",
  128.                    "url",Url->args,
  129.                    "link",relocate+7+strlen(localhost),
  130.                    NULL);
  131.        FreeURL(indexUrl);
  132.        free(localhost);
  133.        free(relocate);
  134.       }
  135.     else
  136.        HTMLMessage(fd,404,"WWWOFFLE Illegal Index Page",NULL,"IndexIllegal",
  137.                    "url",Url->pathp,
  138.                    NULL);
  140.     return;
  141.    }
  143.  newpath=(char*)malloc(strlen(Url->path)-6);
  144.  strcpy(newpath,Url->path+7);
  146.  if(*newpath && newpath[strlen(newpath)-1]=='/')
  147.     newpath[strlen(newpath)-1]=0;
  149.  for(i=0;newpath[i];i++)
  150.     if(newpath[i]=='/')
  151.       {
  152.        newpath[i]=0;
  153.        host=newpath+i+1;
  154.        break;
  155.       }
  157.  proto=newpath;
  159.  for(i=0;i<NProtocols;i++)
  160.     if(!strcmp(proto,Protocols[i].name))
  161.        protocol=&Protocols[i];
  163.  outgoing=!strcmp(proto,"outgoing");
  164.  monitor =!strcmp(proto,"monitor");
  165.  lasttime=!strcmp(proto,"lasttime");
  166.  prevtime=!strncmp(proto,"prevtime",8) && atoi(proto+8)>=0 && atoi(proto+8)<=NUM_PREVTIME_DIR;
  167.  latest  =!strcmp(proto,"latest");
  168.  main=(!protocol && !outgoing && !monitor && !lasttime && !prevtime && !latest);
  170.  if(Url->args)
  171.    {
  172.     char *p=Url->args,*amp;
  174.     do
  175.       {
  176.        amp=strchr(p,'&');
  178.        if(amp)
  179.           *amp=0;
  181.        if(!strncmp(p,"sort=",5))
  182.           for(s=0;s<NSortModes;s++)
  183.              if(!strcmp(p+5,sorttype[s]))
  184.                {sort=s;break;}
  186.        if(!strcmp(p,"delete"))
  187.           delopt=1;
  189.        if(!strcmp(p,"refresh"))
  190.           refopt=1;
  192.        if(!strcmp(p,"monitor"))
  193.           monopt=1;
  195.        if(!strcmp(p,"all"))
  196.           allopt=1;
  198.        if(amp)
  199.          {p=amp+1;*amp='&';}
  200.       }
  201.     while(amp);
  202.    }
  204.  files=NULL;
  205.  nfiles=0;
  207.  now=time(NULL);
  208.  earliest=0;
  210.  if((*host && (strchr(host,'/') || !strcmp(host,"..") || !strcmp(host,"."))) ||
  211.     (main && Url->path[7]) ||
  212.     ((outgoing || monitor || lasttime || prevtime || latest) && *host))
  213.     HTMLMessage(fd,404,"WWWOFFLE Illegal Index Page",NULL,"IndexIllegal",
  214.                 "url",Url->pathp,
  215.                 NULL);
  216.  else if(sort==NSortModes && (outgoing || monitor || lasttime || prevtime || protocol))
  217.    {
  218.     char *localhost=GetLocalHost(1);
  219.     char *relocate=(char*)malloc(strlen(localhost)+strlen(Url->path)+strlen(sorttype[0])+16);
  220.     sprintf(relocate,"http://%s%s?sort=%s",localhost,Url->path,sorttype[0]);
  221.     HTMLMessage(fd,301,"WWWOFFLE Index Redirect",relocate,"IndexRedirect",
  222.                 "url",Url->pathp,
  223.                 "link",relocate+7+strlen(localhost),
  224.                 NULL);
  225.     free(relocate);
  226.     free(localhost);
  227.    }
  228.  else
  229.    {
  230.     HTMLMessageHead(fd,200,"WWWOFFLE Index",
  231.                     NULL);
  232.     HTMLMessageBody(fd,"Index-Head",
  233.                     "type",prevtime?"prevtime":proto,
  234.                     "subtype",prevtime?proto+8:host,
  235.                     "sort",sorttype[sort],
  236.                     "delete" ,delopt?"&delete":"",
  237.                     "refresh",refopt?"&refresh":"",
  238.                     "monitor",monopt?"&monitor":"",
  239.                     "all"    ,allopt?"&all":"",
  240.                     NULL);
  242.     if(outgoing)
  243.        IndexOutgoing(fd,sort,delopt,refopt,monopt,allopt);
  244.     else if(monitor)
  245.        IndexMonitor(fd,sort,delopt,refopt,monopt,allopt);
  246.     else if(lasttime || prevtime)
  247.        IndexLastTime(fd,proto,sort,delopt,refopt,monopt,allopt);
  248.     else if(latest)
  249.        IndexLatest(fd,sort,delopt,refopt,monopt,allopt);
  250.     else if(protocol && !*host)
  251.        IndexProtocol(fd,proto,sort,delopt,refopt,monopt,allopt);
  252.     else if(protocol && *host)
  253.        IndexHost(fd,proto,host,sort,delopt,refopt,monopt,allopt);
  254.     else
  255.        IndexRoot(fd);
  257.     HTMLMessageBody(fd,"Index-Tail",
  258.                     "type",prevtime?"prevtime":proto,
  259.                     "subtype",prevtime?proto+8:host,
  260.                     "sort",sorttype[sort],
  261.                     "delete" ,delopt?"&delete":"",
  262.                     "refresh",refopt?"&refresh":"",
  263.                     "monitor",monopt?"&monitor":"",
  264.                     "all"    ,allopt?"&all":"",
  265.                     NULL);
  266.    }
  268.  free(newpath);
  269. }
  272. /*++++++++++++++++++++++++++++++++++++++
  273.   Index the root of the cache.
  275.   int fd The file descriptor to write to.
  276.   ++++++++++++++++++++++++++++++++++++++*/
  278. static void IndexRoot(int fd)
  279. {
  280.  HTMLMessageBody(fd,"IndexRoot-Body",NULL);
  281. }
  284. /*++++++++++++++++++++++++++++++++++++++
  285.   Index the hosts for one protocol in the cache.
  287.   int fd The file descriptor to write to.
  289.   char *proto The protocol to index.
  291.   SortMode mode The sort mode to use.
  293.   int delopt The option to display the delete button in the index.
  295.   int refopt The option to display the refresh buttons in the index.
  297.   int monopt The option to display the monitor button in the index.
  299.   int allopt The option to show all pages including DontIndex ones.
  300.   ++++++++++++++++++++++++++++++++++++++*/
  302. static void IndexProtocol(int fd,char *proto,SortMode mode,int delopt,int refopt, int monopt,int allopt)
  303. {
  304.  DIR *dir;
  305.  struct dirent* ent;
  306.  int i;
  307.  char total[8],indexed[8],notindexed[8];
  308.  int lastdays=0,lasthours=0;
  310.  /* Open the spool directory. */
  312.  if(chdir(proto))
  313.    {PrintMessage(Warning,"Cannot change to directory '%s' [%!s]; not indexed.",proto);
  314.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  316.  dir=opendir(".");
  317.  if(!dir)
  318.    {PrintMessage(Warning,"Cannot open spool directory '%s' [%!s]; index failed.",proto);chdir("..");
  319.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  321.  ent=readdir(dir);  /* skip .  */
  322.  if(!ent)
  323.    {PrintMessage(Warning,"Cannot read spool directory '%s' [%!s]; index failed.",proto);closedir(dir);chdir("..");
  324.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  325.  ent=readdir(dir);  /* skip .. */
  327.  /* Get all of the host sub-directories. */
  329.  while((ent=readdir(dir)))
  330.     add_dir(ent->d_name,mode);
  332.  closedir(dir);
  334.  chdir("..");
  336.  /* Sort the files. */
  338.  if(mode==MTime || mode==ATime || mode==Dated)
  339.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_time);
  340.  else if(mode==Alpha || mode==Type)
  341.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_alpha);
  342.  else if(mode==Domain)
  343.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_domain);
  345.  /* Output the page. */
  347.  sprintf(total,"%d",nfiles);
  349.  HTMLMessageBody(fd,"IndexProtocol-Head",
  350.                  "proto",proto,
  351.                  "total",total,
  352.                  "sort",sorttype[mode],
  353.                  "delete" ,delopt?"&delete":"",
  354.                  "refresh",refopt?"&refresh":"",
  355.                  "monitor",monopt?"&monitor":"",
  356.                  "all"    ,allopt?"&all":"",
  357.                  NULL);
  359.  for(i=0;i<nfiles;i++)
  360.    {
  361.     if(mode==Dated)
  362.        dated_separator(fd,i,&lastdays,&lasthours);
  364.     HTMLMessageBody(fd,"IndexProtocol-Body",
  365.                     "proto",proto,
  366.                     "host",files[i]->name,
  367.                     "sort",sorttype[mode],
  368.                     "delete" ,delopt?"&delete":"",
  369.                     "refresh",refopt?"&refresh":"",
  370.                     "monitor",monopt?"&monitor":"",
  371.                     "all"    ,allopt?"&all":"",
  372.                     NULL);
  374.     free(files[i]->name);
  375.     free(files[i]);
  376.    }
  378.  sprintf(indexed   ,"%d",nfiles);
  379.  sprintf(notindexed,"%d",0);
  381.  HTMLMessageBody(fd,"IndexProtocol-Tail",
  382.                  "proto",proto,
  383.                  "total",total,
  384.                  "indexed",indexed,
  385.                  "notindexed",notindexed,
  386.                  "sort",sorttype[mode],
  387.                  "delete" ,delopt?"&delete":"",
  388.                  "refresh",refopt?"&refresh":"",
  389.                  "monitor",monopt?"&monitor":"",
  390.                  "all"    ,allopt?"&all":"",
  391.                  NULL);
  393.  /* Tidy up and exit */
  395.  if(files)
  396.     free(files);
  397.  files=NULL;
  398.  nfiles=0;
  399. }
  402. /*++++++++++++++++++++++++++++++++++++++
  403.   Create an index of the pages on a host.
  405.   int fd The file descriptor to write to.
  407.   char *proto The protocol to index.
  409.   char *host The name of the subdirectory.
  411.   SortMode mode The sort mode to use.
  413.   int delopt The option to display the delete button in the index.
  415.   int refopt The option to display the refresh buttons in the index.
  417.   int monopt The option to display the monitor button in the index.
  419.   int allopt The option to show all pages including DontIndex ones.
  420.   ++++++++++++++++++++++++++++++++++++++*/
  422. static void IndexHost(int fd,char *proto,char *host,SortMode mode,int delopt,int refopt, int monopt,int allopt)
  423. {
  424.  DIR *dir;
  425.  struct dirent* ent;
  426.  int i,nindexed=0;
  427.  char total[8],indexed[8],notindexed[8];
  428.  int lastdays=0,lasthours=0;
  430.  /* Open the spool subdirectory. */
  432.  if(chdir(proto))
  433.    {PrintMessage(Warning,"Cannot change to directory '%s' [%!s]; not indexed.",proto);
  434.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  436.  /* Open the spool subdirectory. */
  438. #if defined(__CYGWIN__)
  439.  if(strchr(host,':'))
  440.    {
  441.     char *colon=strchr(host,':');
  442.     *colon='!';
  443.    }
  444. #endif
  446.  if(chdir(host))
  447.    {PrintMessage(Warning,"Cannot change to directory '%s/%s' [%!s]; not indexed.",proto,host);chdir("..");
  448.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  450.  dir=opendir(".");
  451.  if(!dir)
  452.    {PrintMessage(Warning,"Cannot open directory '%s/%s' [%!s]; not indexed.",proto,host);chdir("../..");
  453.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  455.  ent=readdir(dir);  /* skip .  */
  456.  if(!ent)
  457.    {PrintMessage(Warning,"Cannot read directory '%s/%s' [%!s]; not indexed.",proto,host);closedir(dir);chdir("../..");
  458.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  459.  ent=readdir(dir);  /* skip .. */
  461. #if defined(__CYGWIN__)
  462.  if(strchr(host,'!'))
  463.    {
  464.     char *bang=strchr(host,'!');
  465.     *bang=':';
  466.    }
  467. #endif
  469.  /* Add all of the file names. */
  471.  while((ent=readdir(dir)))
  472.     add_file(ent->d_name,mode);
  474.  closedir(dir);
  476.  chdir("../..");
  478.  /* Sort the files. */
  480.  if(mode==MTime || mode==ATime || mode==Dated)
  481.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_time);
  482.  else if(mode==Alpha || mode==Domain)
  483.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_alpha);
  484.  else if(mode==Type)
  485.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_type);
  487.  /* Output the page. */
  489.  sprintf(total,"%d",nfiles);
  491.  HTMLMessageBody(fd,"IndexHost-Head",
  492.                  "proto",proto,
  493.                  "host",host,
  494.                  "total",total,
  495.                  "sort",sorttype[mode],
  496.                  "delete" ,delopt?"&delete":"",
  497.                  "refresh",refopt?"&refresh":"",
  498.                  "monitor",monopt?"&monitor":"",
  499.                  "all"    ,allopt?"&all":"",
  500.                  NULL);
  502.  for(i=0;i<nfiles;i++)
  503.    {
  504.     if(allopt || !IsNotIndexed(files[i]->url,"host"))
  505.       {
  506.        char *decurl=URLDecode(files[i]->url->pathp,0);
  508.        if(mode==Dated)
  509.           dated_separator(fd,i,&lastdays,&lasthours);
  511.        HTMLMessageBody(fd,"IndexHost-Body",
  512.                        "url",files[i]->url->name,
  513.                        "link",files[i]->url->link,
  514.                        "item",decurl,
  515.                        "delete" ,delopt?"&delete":"",
  516.                        "refresh",refopt?"&refresh":"",
  517.                        "monitor",monopt?"&monitor":"",
  518.                        NULL);
  520.        free(decurl);
  522.        nindexed++;
  523.       }
  525.     FreeURL(files[i]->url);
  526.     free(files[i]);
  527.    }
  529.  sprintf(indexed   ,"%d",nindexed);
  530.  sprintf(notindexed,"%d",nfiles-nindexed);
  532.  HTMLMessageBody(fd,"IndexHost-Tail",
  533.                  "proto",proto,
  534.                  "host",host,
  535.                  "total",total,
  536.                  "indexed",indexed,
  537.                  "notindexed",notindexed,
  538.                  "sort",sorttype[mode],
  539.                  "delete" ,delopt?"&delete":"",
  540.                  "refresh",refopt?"&refresh":"",
  541.                  "monitor",monopt?"&monitor":"",
  542.                  "all"    ,allopt?"&all":"",
  543.                  NULL);
  545.  /* Tidy up and exit */
  547.  if(files)
  548.     free(files);
  549.  files=NULL;
  550.  nfiles=0;
  551. }
  554. /*++++++++++++++++++++++++++++++++++++++
  555.   Create an index of the requests that are waiting in the outgoing directory.
  557.   int fd The file descriptor to write to.
  559.   SortMode mode The method to use to sort the names.
  561.   int delopt The option to display the delete button in the index.
  563.   int refopt The option to display the refresh buttons in the index.
  565.   int monopt The option to display the monitor button in the index.
  567.   int allopt The option to show all pages including DontIndex ones.
  568.   ++++++++++++++++++++++++++++++++++++++*/
  570. static void IndexOutgoing(int fd,SortMode mode,int delopt,int refopt, int monopt,int allopt)
  571. {
  572.  DIR *dir;
  573.  struct dirent* ent;
  574.  int i,nindexed=0;
  575.  char total[8],indexed[8],notindexed[8];
  576.  int lastdays=0,lasthours=0;
  578.  /* Open the outgoing subdirectory. */
  580.  if(chdir("outgoing"))
  581.    {PrintMessage(Warning,"Cannot change to directory 'outgoing' [%!s]; not indexed.");
  582.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  584.  dir=opendir(".");
  585.  if(!dir)
  586.    {PrintMessage(Warning,"Cannot open directory 'outgoing' [%!s]; not indexed.");chdir("..");
  587.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  589.  ent=readdir(dir);  /* skip .  */
  590.  if(!ent)
  591.    {PrintMessage(Warning,"Cannot read directory 'outgoing' [%!s]; not indexed.");closedir(dir);chdir("..");
  592.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  593.  ent=readdir(dir);  /* skip .. */
  595.  /* Add all of the file names. */
  597.  while((ent=readdir(dir)))
  598.     add_file(ent->d_name,mode);
  600.  closedir(dir);
  602.  chdir("..");
  604.  /* Sort the files. */
  606.  if(mode==MTime || mode==ATime || mode==Dated)
  607.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_time);
  608.  else if(mode==Alpha)
  609.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_alpha);
  610.  else if(mode==Type)
  611.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_type);
  612.  else if(mode==Domain)
  613.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_domain);
  615.  /* Output the page. */
  617.  sprintf(total,"%d",nfiles);
  619.  HTMLMessageBody(fd,"IndexOutgoing-Head",
  620.                  "total",total,
  621.                  "sort",sorttype[mode],
  622.                  "delete" ,delopt?"&delete":"",
  623.                  "refresh",refopt?"&refresh":"",
  624.                  "monitor",monopt?"&monitor":"",
  625.                  "all"    ,allopt?"&all":"",
  626.                  NULL);
  628.  for(i=0;i<nfiles;i++)
  629.    {
  630.     if(allopt || !IsNotIndexed(files[i]->url,"outgoing"))
  631.       {
  632.        char *decurl=URLDecode(files[i]->url->name,0);
  634.        if(mode==Dated)
  635.           dated_separator(fd,i,&lastdays,&lasthours);
  637.        HTMLMessageBody(fd,"IndexOutgoing-Body",
  638.                        "url",files[i]->url->name,
  639.                        "link",files[i]->url->link,
  640.                        "item",decurl,
  641.                        "delete" ,delopt?"&delete":"",
  642.                        "refresh",refopt?"&refresh":"",
  643.                        "monitor",monopt?"&monitor":"",
  644.                        NULL);
  646.        free(decurl);
  648.        nindexed++;
  649.       }
  651.     FreeURL(files[i]->url);
  652.     free(files[i]);
  653.    }
  655.  sprintf(indexed   ,"%d",nindexed);
  656.  sprintf(notindexed,"%d",nfiles-nindexed);
  658.  HTMLMessageBody(fd,"IndexOutgoing-Tail",
  659.                  "total",total,
  660.                  "indexed",indexed,
  661.                  "notindexed",notindexed,
  662.                  "sort",sorttype[mode],
  663.                  "delete" ,delopt?"&delete":"",
  664.                  "refresh",refopt?"&refresh":"",
  665.                  "monitor",monopt?"&monitor":"",
  666.                  "all"    ,allopt?"&all":"",
  667.                  NULL);
  669.  /* Tidy up and exit */
  671.  if(files)
  672.     free(files);
  673.  files=NULL;
  674.  nfiles=0;
  675. }
  678. /*++++++++++++++++++++++++++++++++++++++
  679.   Create an index of the requests that are in the monitor directory.
  681.   int fd The file descriptor to write to.
  683.   SortMode mode The method to use to sort the names.
  685.   int delopt The option to display the delete button in the index.
  687.   int refopt The option to display the refresh buttons in the index.
  689.   int monopt The option to display the monitor button in the index.
  691.   int allopt The option to show all pages including DontIndex ones.
  692.   ++++++++++++++++++++++++++++++++++++++*/
  694. static void IndexMonitor(int fd,SortMode mode,int delopt,int refopt, int monopt,int allopt)
  695. {
  696.  DIR *dir;
  697.  struct dirent* ent;
  698.  int i,nindexed=0;
  699.  char total[8],indexed[8],notindexed[8];
  700.  int lastdays=0,lasthours=0;
  702.  /* Open the monitor subdirectory. */
  704.  if(chdir("monitor"))
  705.    {PrintMessage(Warning,"Cannot change to directory 'monitor' [%!s]; not indexed.");
  706.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  708.  dir=opendir(".");
  709.  if(!dir)
  710.    {PrintMessage(Warning,"Cannot open directory 'monitor' [%!s]; not indexed.");chdir("..");
  711.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  713.  ent=readdir(dir);  /* skip .  */
  714.  if(!ent)
  715.    {PrintMessage(Warning,"Cannot read directory 'monitor' [%!s]; not indexed.");closedir(dir);chdir("..");
  716.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  717.  ent=readdir(dir);  /* skip .. */
  719.  /* Add all of the file names. */
  721.  while((ent=readdir(dir)))
  722.     add_file(ent->d_name,mode);
  724.  closedir(dir);
  726.  chdir("..");
  728.  /* Sort the files. */
  730.  if(mode==MTime || mode==ATime || mode==Dated)
  731.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_time);
  732.  else if(mode==Alpha)
  733.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_alpha);
  734.  else if(mode==Type)
  735.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_type);
  736.  else if(mode==Domain)
  737.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_domain);
  739.  /* Output the page. */
  741.  sprintf(total,"%d",nfiles);
  743.  HTMLMessageBody(fd,"IndexMonitor-Head",
  744.                  "total",total,
  745.                  "sort",sorttype[mode],
  746.                  "delete" ,delopt?"&delete":"",
  747.                  "refresh",refopt?"&refresh":"",
  748.                  "monitor",monopt?"&monitor":"",
  749.                  "all"    ,allopt?"&all":"",
  750.                  NULL);
  752.  for(i=0;i<nfiles;i++)
  753.    {
  754.     if(allopt || !IsNotIndexed(files[i]->url,"monitor"))
  755.       {
  756.        char *decurl=URLDecode(files[i]->url->name,0);
  757.        int last,next;
  758.        char laststr[8],nextstr[8];
  760.        MonitorTimes(files[i]->url,&last,&next);
  762.        if(last>=(31*24))
  763.           sprintf(laststr,"31+");
  764.        else
  765.           sprintf(laststr,"%d:%d",last/24,last%24);
  766.        if(next>=(31*24))
  767.           sprintf(nextstr,"31+");
  768.        else
  769.           sprintf(nextstr,"%d:%d",next/24,next%24);
  771.        if(mode==Dated)
  772.           dated_separator(fd,i,&lastdays,&lasthours);
  774.        HTMLMessageBody(fd,"IndexMonitor-Body",
  775.                        "url",files[i]->url->name,
  776.                        "link",files[i]->url->link,
  777.                        "item",decurl,
  778.                        "last",laststr,
  779.                        "next",nextstr,
  780.                        "delete" ,delopt?"&delete":"",
  781.                        "refresh",refopt?"&refresh":"",
  782.                        "monitor",monopt?"&monitor":"",
  783.                        NULL);
  785.        free(decurl);
  787.        nindexed++;
  788.       }
  790.     FreeURL(files[i]->url);
  791.     free(files[i]);
  792.    }
  794.  sprintf(indexed   ,"%d",nindexed);
  795.  sprintf(notindexed,"%d",nfiles-nindexed);
  797.  HTMLMessageBody(fd,"IndexMonitor-Tail",
  798.                  "total",total,
  799.                  "indexed",indexed,
  800.                  "notindexed",notindexed,
  801.                  "sort",sorttype[mode],
  802.                  "delete" ,delopt?"&delete":"",
  803.                  "refresh",refopt?"&refresh":"",
  804.                  "monitor",monopt?"&monitor":"",
  805.                  "all"    ,allopt?"&all":"",
  806.                  NULL);
  808.  /* Tidy up and exit */
  810.  if(files)
  811.     free(files);
  812.  files=NULL;
  813.  nfiles=0;
  814. }
  817. /*++++++++++++++++++++++++++++++++++++++
  818.   Create an index of the pages that were got last time online.
  820.   int fd The file descriptor to write to.
  822.   char *name The name of the directory.
  824.   SortMode mode The method to use to sort the names.
  826.   int delopt The option to display the delete button in the index.
  828.   int refopt The option to display the refresh buttons in the index.
  830.   int monopt The option to display the monitor button in the index.
  832.   int allopt The option to show all pages including DontIndex ones.
  833.   ++++++++++++++++++++++++++++++++++++++*/
  835. static void IndexLastTime(int fd,char *name,SortMode mode,int delopt,int refopt, int monopt,int allopt)
  836. {
  837.  DIR *dir;
  838.  struct dirent* ent;
  839.  int i,nindexed=0;
  840.  char total[8],indexed[8],notindexed[8];
  841.  int lastdays=0,lasthours=0;
  843.  /* Open the lasttime subdirectory. */
  845.  if(chdir(name))
  846.    {PrintMessage(Warning,"Cannot change to directory '%s' [%!s]; not indexed.",name);
  847.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  849.  dir=opendir(".");
  850.  if(!dir)
  851.    {PrintMessage(Warning,"Cannot open directory '%s' [%!s]; not indexed.",name);chdir("..");
  852.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  854.  ent=readdir(dir);  /* skip .  */
  855.  if(!ent)
  856.    {PrintMessage(Warning,"Cannot read directory '%s' [%!s]; not indexed.",name);closedir(dir);chdir("..");
  857.    HTMLMessageBody(fd,"IndexError-Body",NULL);return;}
  858.  ent=readdir(dir);  /* skip .. */
  860.  /* Add all of the file names. */
  862.  while((ent=readdir(dir)))
  863.     add_file(ent->d_name,mode);
  865.  closedir(dir);
  867.  chdir("..");
  869.  /* Sort the files. */
  871.  if(mode==MTime || mode==ATime || mode==Dated)
  872.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_time);
  873.  else if(mode==Alpha)
  874.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_alpha);
  875.  else if(mode==Type)
  876.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_type);
  877.  else if(mode==Domain)
  878.     qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_domain);
  880.  /* Output the page. */
  882.  sprintf(total,"%d",nfiles);
  884.  HTMLMessageBody(fd,"IndexLastTime-Head",
  885.                  "number",name+8,
  886.                  "total",total,
  887.                  "sort",sorttype[mode],
  888.                  "delete" ,delopt?"&delete":"",
  889.                  "refresh",refopt?"&refresh":"",
  890.                  "monitor",monopt?"&monitor":"",
  891.                  "all"    ,allopt?"&all":"",
  892.                  NULL);
  894.  for(i=0;i<nfiles;i++)
  895.    {
  896.     if(allopt || !IsNotIndexed(files[i]->url,"latest"))
  897.       {
  898.        char *decurl=URLDecode(files[i]->url->name,0);
  900.        if(mode==Dated)
  901.           dated_separator(fd,i,&lastdays,&lasthours);
  903.        HTMLMessageBody(fd,"IndexLastTime-Body",
  904.                        "url",files[i]->url->name,
  905.                        "link",files[i]->url->link,
  906.                        "item",decurl,
  907.                        "delete" ,delopt?"&delete":"",
  908.                        "refresh",refopt?"&refresh":"",
  909.                        "monitor",monopt?"&monitor":"",
  910.                        NULL);
  912.        free(decurl);
  914.        nindexed++;
  915.       }
  917.     FreeURL(files[i]->url);
  918.     free(files[i]);
  919.    }
  921.  sprintf(indexed   ,"%d",nindexed);
  922.  sprintf(notindexed,"%d",nfiles-nindexed);
  924.  HTMLMessageBody(fd,"IndexLastTime-Tail",
  925.                  "number",name+8,
  926.                  "total",total,
  927.                  "indexed",indexed,
  928.                  "notindexed",notindexed,
  929.                  "sort",sorttype[mode],
  930.                  "delete" ,delopt?"&delete":"",
  931.                  "refresh",refopt?"&refresh":"",
  932.                  "monitor",monopt?"&monitor":"",
  933.                  "all"    ,allopt?"&all":"",
  934.                  NULL);
  936.  /* Tidy up and exit */
  938.  if(files)
  939.     free(files);
  940.  files=NULL;
  941.  nfiles=0;
  942. }
  945. /*++++++++++++++++++++++++++++++++++++++
  946.   Create an index of the latest pages.
  948.   int fd The file descriptor to write to.
  950.   SortMode mode The method to use to sort the names.
  952.   int delopt The option to display the delete button in the index.
  954.   int refopt The option to display the refresh buttons in the index.
  956.   int monopt The option to display the monitor button in the index.
  958.   int allopt The option to show all pages including DontIndex ones.
  959.   ++++++++++++++++++++++++++++++++++++++*/
  961. static void IndexLatest(int fd,SortMode mode,int delopt,int refopt, int monopt,int allopt)
  962. {
  963.  int i,p,nindexed=0;
  964.  char total[8],indexed[8],notindexed[8];
  965.  int lastdays=0,lasthours=0;
  967.  earliest=now-IndexLatestDays*24*3600;
  969.  if(IndexLatestDays>0)
  970.    {
  971.     /* Add all of the files in the sub directories. */
  973.     for(p=0;p<NProtocols;p++)
  974.       {
  975.        struct stat buf;
  977.        if(!lstat(Protocols[p].name,&buf) && S_ISDIR(buf.st_mode))
  978.          {
  979.           DIR *dir2;
  980.           struct dirent* ent2;
  982.           if(chdir(Protocols[p].name))
  983.             {PrintMessage(Warning,"Cannot change to directory '%s' [%!s]; not indexed.",Protocols[p].name);continue;}
  985.           /* Open the spool directory. */
  987.           dir2=opendir(".");
  988.           if(!dir2)
  989.             {PrintMessage(Warning,"Cannot open directory '%s' [%!s]; not indexed.",Protocols[p].name);chdir("..");continue;}
  991.           ent2=readdir(dir2);  /* skip .  */
  992.           if(!ent2)
  993.             {PrintMessage(Warning,"Cannot read directory '%s' [%!s]; index failed.",Protocols[p].name);closedir(dir2);chdir("..");continue;}
  994.           ent2=readdir(dir2);  /* skip .. */
  996.           /* Print all of the sub directories. */
  998.           while((ent2=readdir(dir2)))
  999.             {
  1000.              struct stat buf2;
  1002.              if(lstat(ent2->d_name,&buf2))
  1003.                 PrintMessage(Inform,"Cannot stat file '%s' [%!s]; race condition?",ent2->d_name);
  1004.              else
  1005.                 if(S_ISDIR(buf2.st_mode) && buf2.st_mtime>earliest)
  1006.                   {
  1007.                    DIR *dir3;
  1008.                    struct dirent* ent3;
  1009.                    struct utimbuf utbuf;
  1011.                    if(chdir(ent2->d_name))
  1012.                      {PrintMessage(Warning,"Cannot change to directory '%s/%s' [%!s]; not indexed.",Protocols[p].name,ent2->d_name);continue;}
  1014.                    dir3=opendir(".");
  1015.                    if(!dir3)
  1016.                      {PrintMessage(Warning,"Cannot open directory '%s/%s' [%!s]; not indexed.",Protocols[p].name,ent2->d_name);chdir("..");continue;}
  1018.                    ent3=readdir(dir3);  /* skip .  */
  1019.                    if(!ent3)
  1020.                      {PrintMessage(Warning,"Cannot read directory '%s/%s' [%!s]; not indexed.",Protocols[p].name,ent2->d_name);closedir(dir3);chdir("..");continue;}
  1021.                    ent3=readdir(dir3);  /* skip .. */
  1023.                    while((ent3=readdir(dir3)))
  1024.                       add_file(ent3->d_name,mode);
  1026.                    closedir(dir3);
  1027.                    chdir("..");
  1029.                    utbuf.actime=buf2.st_atime;
  1030.                    utbuf.modtime=buf2.st_mtime;
  1031.                    utime(ent2->d_name,&utbuf);
  1032.                   }
  1033.             }
  1035.           closedir(dir2);
  1036.           chdir("..");
  1037.          }
  1038.       }
  1040.     /* Sort the files. */
  1042.     if(mode==MTime || mode==ATime || mode==Dated)
  1043.        qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_time);
  1044.     else if(mode==Alpha)
  1045.        qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_alpha);
  1046.     else if(mode==Type)
  1047.        qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_type);
  1048.     else if(mode==Domain)
  1049.        qsort(files,nfiles,sizeof(FileIndex*),(int (*)(const void*,const void*))sort_domain);
  1050.    }
  1052.  /* Output the page. */
  1054.  sprintf(total,"%d",nfiles);
  1056.  HTMLMessageBody(fd,"IndexLatest-Head",
  1057.                  "total",total,
  1058.                  "sort",sorttype[mode],
  1059.                  "delete" ,delopt?"&delete":"",
  1060.                  "refresh",refopt?"&refresh":"",
  1061.                  "monitor",monopt?"&monitor":"",
  1062.                  "all"    ,allopt?"&all":"",
  1063.                  NULL);
  1065.  for(i=0;i<nfiles;i++)
  1066.    {
  1067.     if(allopt || !IsNotIndexed(files[i]->url,"latest"))
  1068.       {
  1069.        char *decurl=URLDecode(files[i]->url->name,0);
  1071.        if(mode==Dated)
  1072.           dated_separator(fd,i,&lastdays,&lasthours);
  1074.        HTMLMessageBody(fd,"IndexLatest-Body",
  1075.                        "url",files[i]->url->name,
  1076.                        "link",files[i]->url->link,
  1077.                        "item",decurl,
  1078.                        "delete" ,delopt?"&delete":"",
  1079.                        "refresh",refopt?"&refresh":"",
  1080.                        "monitor",monopt?"&monitor":"",
  1081.                        NULL);
  1083.        free(decurl);
  1085.        nindexed++;
  1086.       }
  1088.     FreeURL(files[i]->url);
  1089.     free(files[i]);
  1090.    }
  1092.  sprintf(indexed   ,"%d",nindexed);
  1093.  sprintf(notindexed,"%d",nfiles-nindexed);
  1095.  HTMLMessageBody(fd,"IndexLatest-Tail",
  1096.                  "total",total,
  1097.                  "indexed",indexed,
  1098.                  "notindexed",notindexed,
  1099.                  "sort",sorttype[mode],
  1100.                  "delete" ,delopt?"&delete":"",
  1101.                  "refresh",refopt?"&refresh":"",
  1102.                  "monitor",monopt?"&monitor":"",
  1103.                  "all"    ,allopt?"&all":"",
  1104.                  NULL);
  1106.  /* Tidy up and exit */
  1108.  if(files)
  1109.     free(files);
  1110.  files=NULL;
  1111.  nfiles=0;
  1112. }
  1115. /*++++++++++++++++++++++++++++++++++++++
  1116.   Add a directory to the list.
  1118.   char *name The name of the directory.
  1120.   SortMode mode The sort mode.
  1121.   ++++++++++++++++++++++++++++++++++++++*/
  1123. static void add_dir(char *name,SortMode mode)
  1124. {
  1125.  struct stat buf;
  1127.  if(stat(name,&buf))
  1128.    {PrintMessage(Inform,"Cannot stat directory '%s' [%!s]; race condition?",name);return;}
  1129.  else if(S_ISDIR(buf.st_mode))
  1130.    {
  1131.     if(!(nfiles%16))
  1132.       {
  1133.        if(!files)
  1134.           files=(FileIndex**)malloc(16*sizeof(FileIndex*));
  1135.        else
  1136.           files=(FileIndex**)realloc(files,(nfiles+16)*sizeof(FileIndex*));
  1137.       }
  1138.     files[nfiles]=(FileIndex*)malloc(sizeof(FileIndex));
  1140. #if defined(__CYGWIN__)
  1141.     if(strchr(name,'!'))
  1142.       {
  1143.        char *bang=strchr(name,'!');
  1144.        *bang=':';
  1145.       }
  1146. #endif
  1148.     files[nfiles]->name=(char*)malloc(strlen(name)+1);
  1149.     strcpy(files[nfiles]->name,name);
  1151.     if(mode==Domain)
  1152.        files[nfiles]->host=files[nfiles]->name;
  1153.     else if(mode==Type)
  1154.        files[nfiles]->type="";
  1155.     else if(mode==MTime || mode==Dated)
  1156.        files[nfiles]->time=buf.st_mtime;
  1157.     else if(mode==ATime)
  1158.        files[nfiles]->time=buf.st_atime;
  1160.     nfiles++;
  1161.    }
  1162. }
  1165. /*++++++++++++++++++++++++++++++++++++++
  1166.   Add a file to the list.
  1168.   char *name The name of the file.
  1170.   SortMode mode The sort mode.
  1171.   ++++++++++++++++++++++++++++++++++++++*/
  1173. static void add_file(char *name,SortMode mode)
  1174. {
  1175.  char *url=NULL;
  1176.  struct stat buf;
  1178.  if((*name!='D' && *name!='O') || name[strlen(name)-1]=='~')
  1179.     return;
  1181.  url=FileNameToURL(name);
  1183.  if(!url)
  1184.     return;
  1186.  if(stat(name,&buf))
  1187.    {PrintMessage(Inform,"Cannot stat file '%s' [%!s]; race condition?",name);return;}
  1188.  else if(S_ISREG(buf.st_mode) && (mode!=Dated || buf.st_mtime>earliest))
  1189.    {
  1190.     if(!(nfiles%16))
  1191.       {
  1192.        if(!files)
  1193.           files=(FileIndex**)malloc(16*sizeof(FileIndex*));
  1194.        else
  1195.           files=(FileIndex**)realloc(files,(nfiles+16)*sizeof(FileIndex*));
  1196.       }
  1197.     files[nfiles]=(FileIndex*)malloc(sizeof(FileIndex));
  1199.     files[nfiles]->url=SplitURL(url);
  1200.     files[nfiles]->name=files[nfiles]->url->name;
  1202.     if(mode==Domain)
  1203.        files[nfiles]->host=files[nfiles]->url->host;
  1204.     else if(mode==Type)
  1205.       {
  1206.        char *p=files[nfiles]->url->path+strlen(files[nfiles]->url->path);
  1208.        for(;p>=files[nfiles]->url->path;p--)
  1209.           if(*p=='.')
  1210.             {files[nfiles]->type=p;break;}
  1211.           else if(*p=='/')
  1212.             {files[nfiles]->type="";break;}
  1213.       }
  1214.     else if(mode==MTime || mode==Dated)
  1215.        files[nfiles]->time=buf.st_mtime;
  1216.     else if(mode==ATime)
  1217.        files[nfiles]->time=buf.st_atime;
  1219.     nfiles++;
  1220.    }
  1221. }
  1224. /*++++++++++++++++++++++++++++++++++++++
  1225.   Write out a date separator for the dated format if needed.
  1227.   int fd The file to write to.
  1229.   int file The number of the file in the list.
  1231.   int *lastdays The age of the previous file in days.
  1233.   int *lasthours The age of the previous file in hours.
  1234.   ++++++++++++++++++++++++++++++++++++++*/
  1236. static void dated_separator(int fd,int file,int *lastdays,int *lasthours)
  1237. {
  1238.  int days=(now-files[file]->time)/(24*3600),hours=(now-files[file]->time)/3600;
  1240.  if(*lastdays<days)
  1241.    {
  1242.     char daystr[8];
  1243.     sprintf(daystr,"%d",days-*lastdays);
  1245.     HTMLMessageBody(fd,"IndexSeparator-Body",
  1246.                     "days",daystr,
  1247.                     NULL);
  1249.    }
  1250.  else if(file && *lasthours<(hours-1))
  1251.    {
  1252.     HTMLMessageBody(fd,"IndexSeparator-Body",
  1253.                     "days","",
  1254.                     NULL);
  1255.    }
  1257.  *lastdays=days;
  1258.  *lasthours=hours;
  1259. }
  1262. /*++++++++++++++++++++++++++++++++++++++
  1263.   Used to sort the files into alphabetical order.
  1265.   int sort_alpha Returns the comparison of the pointers to strings.
  1267.   FileIndex **a The first FileIndex.
  1269.   FileIndex **b The second FileIndex.
  1270.   ++++++++++++++++++++++++++++++++++++++*/
  1272. static int sort_alpha(FileIndex **a,FileIndex **b)
  1273. {
  1274.  char *an=(*a)->name;
  1275.  char *bn=(*b)->name;
  1277.  return(strcmp(an,bn));
  1278. }
  1281. /*++++++++++++++++++++++++++++++++++++++
  1282.   Used to sort the files into type (file extension) order.
  1284.   int sort_type Returns the comparison of the pointers to strings.
  1286.   FileIndex **a The first FileIndex.
  1288.   FileIndex **b The second FileIndex.
  1289.   ++++++++++++++++++++++++++++++++++++++*/
  1291. static int sort_type(FileIndex **a,FileIndex **b)
  1292. {
  1293.  char *an=(*a)->name,*at=(*a)->type;
  1294.  char *bn=(*b)->name,*bt=(*b)->type;
  1295.  int sort1=strcmp(at,bt);
  1297.  if(sort1==0)
  1298.     return(strcmp(an,bn));
  1299.  else
  1300.     return(sort1);
  1301. }
  1304. /*++++++++++++++++++++++++++++++++++++++
  1305.   Used to sort the files into domain order.
  1307.   int sort_domain Returns the comparison of the pointers to strings.
  1309.   FileIndex **a The first FileIndex.
  1311.   FileIndex **b The second FileIndex.
  1312.   ++++++++++++++++++++++++++++++++++++++*/
  1314. static int sort_domain(FileIndex **a,FileIndex **b)
  1315. {
  1316.  char *ap=(*a)->host+strlen((*a)->host);
  1317.  char *bp=(*b)->host+strlen((*b)->host);
  1318.  int chosen=0;
  1320.  do
  1321.    {
  1322.     ap--;
  1323.     bp--;
  1325.     while(ap>(*a)->host && *ap!='.' && *ap!='/')
  1326.        ap--;
  1327.     while(bp>(*b)->host && *bp!='.' && *bp!='/')
  1328.        bp--;
  1330.     chosen=strcmp(ap,bp);
  1331.    }
  1332.  while(!chosen);
  1334.  return(chosen);
  1335. }
  1338. /*++++++++++++++++++++++++++++++++++++++
  1339.   Used to sort the files into time order.
  1341.   int sort_time Returns the comparison of the times.
  1343.   FileIndex **a The first FileIndex.
  1345.   FileIndex **b The second FileIndex.
  1346.   ++++++++++++++++++++++++++++++++++++++*/
  1348. static int sort_time(FileIndex **a,FileIndex **b)
  1349. {
  1350.  long at=(*a)->time;
  1351.  long bt=(*b)->time;
  1353.  return(bt-at);
  1354. }