/*
** File I/O module for fhttpd
** fhttpd-file.cc Copyright (C) 1995, 96, 97 Alex Belits
** This code is a part of fhttpd distribution
*/

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
#include <sys/param.h>
#include <dirent.h>
#include <signal.h>
#include <grp.h>
#include <time.h>

#ifndef NO_MMAP
#include <sys/mman.h>
#endif

#ifdef SOLARIS
extern "C"{
void bzero(void *s, size_t n);
int gethostname(char *name, int namelen);
}
#endif

#ifdef IRIX
#include "irix-fix.h"
#endif

#ifdef GETOPT_VARS_NOT_DEFINED
extern char *optarg;
extern int optind, opterr;
#endif

extern "C" {
#include "servproc.h"
void processimageform(struct request *req,struct httpresponse *response,
 const char *namevalue,double xvalue,double yvalue);
}

#include "fhttpd-decls.h"
#include "configargs.h"
#include "lists.h"
#include "wildmat.h"

#ifndef FILE_TRANSFER_BUFFER_SIZE
#define FILE_TRANSFER_BUFFER_SIZE 65536
#endif

#ifndef FHTTPD_CONFIG_FILE
#define FHTTPD_CONFIG_FILE "/etc/fhttpd.conf"
#endif

#ifndef MMAPPAGESIZE
#define MMAPPAGESIZE 4096
#endif

#ifndef IDLE_TIMEOUT
#define IDLE_TIMEOUT 120
#endif

#ifndef TRANSFER_TIMEOUT
#define TRANSFER_TIMEOUT 900
#endif

int global_resolve_hostnames=1;
char *default_header=NULL,*default_footer=NULL,*userhomedir=NULL;
List types,dirtypes,executables,specialexecutables,pipeoutexec;

char *configcommands[NCONFIGCOMMANDS]={
"NORESOLVE","HONORKEEPALIVE","HTTPPORT","FTPPORT","PROCESSPORT",
"STORMODE","ABSSTORMODE","MKDMODE","ABSMKDMODE",
"INBOUND","ABSINBOUND","PIPEINEXEC","ABSPIPEINEXEC",
"PIPEOUTEXEC","ABSPIPEOUTEXEC",
"DEFAULTHEADER","DEFAULTFOOTER","TYPE","ABSTYPE","DIRTYPE","ABSDIRTYPE",
"GETRULE","ABSGETRULE","EXECMASK","SPECIALEXECMASK",
"ACCESSREALM","ACCESSRIGHTS",
"PRELOAD","HTTPROOT","ADDRESSROOT","APPLICATION","AUTHAPPLICATION",
"LOGAPPLICATION",
"UMASK","MAXCONTENTLENGTH","MAXMESSAGESIZE",
"MAXDATAINQUEUE","MAXDATAINLOGQUEUE","USERDIR","MAPUSERDIR"};

char *strupr(char *s){
char *s1=s;
while(*s1){
 if(*s1>='a'&&*s1<='z') *s1&=0xdf;
 s1++;
 }
return s;
}

ConfigArgs *appfindwildargs(List *list,char *string,char *realstring){
ConfigArgs *currargs,*nextargs;
if(!string||!realstring) return NULL;
if(list){
 if(list->start){
  currargs=(ConfigArgs*)(list->start);
  while(currargs){
   nextargs=(ConfigArgs*)(currargs->next);
   if(currargs->params){
    if(currargs->params[0]){
     if(currargs->absolute){
      if(wildmat(realstring,currargs->params[0])){
       return currargs;
       }
      }else{
      if(wildmat(string,currargs->params[0])){ //FIXME!
       return currargs;
       }
      }
     }
    }
   currargs=nextargs;
   }
  }
 }
return NULL;
}

ConfigArgs *appfindwildargsreal(List *list,char *string){
if(!(*string)) return NULL;
if(list){
 return (ConfigArgs*)list->FindWildMatch(string);
 }
return NULL;
}

int filenamecmp(char *s1,char *s2,int *noslashflag){
int noslashvar,*noslash=&noslashvar;
char *s11=s1,*s22=s2;
int n;

if(noslashflag) noslash=noslashflag;

while(*s11==*s22&&*s11){
 s11++;
 s22++;
 }
if(!*s11&&!*s22) return 0;
if(*s11!='/'&&*s22!='/'){
 if(s11==s1)  return 1;
 s11--;
 s22--;
 }
n=((*s11=='/')<<1)|(*s22=='/');
switch(n){
 case 0: return 1;
 case 1:
  // *s22=='/' && *s11!='/'
  if(*s11) return 1;
  if(!s22[1]){
   *noslash=1;
   return 0;
   }
  if(!strcmp(s22,"/file_index.html")){
   *noslash=1;
   return 0;
   }
  if(!strcmp(s22,"/index.html")){
   *noslash=1;
   return 0;
   }
  return 1;
 case 2:
  // *s11=='/' && *s22!='/'
  if(*s22) return 1;
  if(!s11[1]){
   *noslash=1;
   return 0;
   }
  if(!strcmp(s11,"/file_index.html")){
   *noslash=1;
   return 0;
   }
  if(!strcmp(s11,"/index.html")){
   *noslash=1;
   return 0;
   }
  return 1;
 default:
  // *s11=='/' && *s22=='/'
  if(s22[1])
   if(strcmp(s22,"/file_index.html"))
    if(strcmp(s22,"/index.html")) return 1;
  if(!s11[1]) return 0;
  if(!strcmp(s11,"/file_index.html")) return 0;
  if(!strcmp(s11,"/index.html")) return 0;
  return 1;
 }
}

void unconfig(void){
ConfigArgs *currargs;
TypeArgs *currtypeargs;
global_resolve_hostnames=1;
if(default_header) free(default_header);
default_header=NULL;
if(default_footer) free(default_footer);
default_footer=NULL;
if(userhomedir) free(userhomedir);
userhomedir=NULL;
while((currtypeargs=(TypeArgs*)types.start)){
 delete currtypeargs;
 }
while((currtypeargs=(TypeArgs*)dirtypes.start)){
 delete currtypeargs;
 }
while((currargs=(ConfigArgs*)pipeoutexec.start)){
 delete currargs;
 }
while((currargs=(ConfigArgs*)executables.start)){
 delete currargs;
 }
while((currargs=(ConfigArgs*)specialexecutables.start)){
 delete currargs;
 }
}

int readconfig(char *name){
char buffer[MESSAGE_BUFFER_SIZE],*p,*p1,*param[20];
int i,ii,j,l,nparam,nline=0;
FILE *f;
ConfigArgs* args;
TypeArgs* currtype;
f=fopen(name,"rt");
if(f){
 while(fgets(buffer,MESSAGE_BUFFER_SIZE,f)){
  nline++;
  do{
   buffer[(MESSAGE_BUFFER_SIZE-1)]=0;
   p=strchr(buffer,'\n');
   if(p) *p=0;
   p=strchr(buffer,'\r');
   if(p) *p=0;
   p=strchr(buffer,'#');
   if(p) *p=0;
   p=strrchr(buffer,'\\');
   if(p){
    p1=p+1;
    while(p&&*p1){
     if(((unsigned char)*p1)>' '){
      p=NULL;
      }else p1++;
     }
    if(p){
     fgets(p,MESSAGE_BUFFER_SIZE-(p-buffer),f);
     nline++;
     }
    }
   }while(p&&p-buffer<(MESSAGE_BUFFER_SIZE-1));
  i=0;
  nparam=0;
  l=strlen(buffer);
  while(buffer[i]&&((unsigned char)buffer[i]<=' ')) i++;
  if(buffer[i]){
   do{
    while(buffer[i]&&(unsigned char)buffer[i]<=' ') i++;
    param[nparam]=buffer+i;
    for(;(unsigned char)buffer[i]>' ';i++);
    if(buffer[i]&&(unsigned char)buffer[i]<=' '){
     buffer[i]=0;
     i++;
     }
    if(!nparam){
     strupr(param[0]);
     }
    nparam++;
    }while(i<l&&nparam<20&&param[nparam-1][0]);
   if(nparam&&!param[nparam-1][0]) nparam--;
   for(i=0;i<NCONFIGCOMMANDS&&strcmp(param[0],configcommands[i]);i++);
   if(i==NCONFIGCOMMANDS) fprintf(stderr,"fhttpd: config line %d not understood.\n",nline); else{
    switch(i){
     case NORESOLVE:
      if(nparam==1){
       global_resolve_hostnames=0;
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"NoResolve\" has no parameters.\n",nline);
       }
      break;
     case PIPEOUTEXEC:
     case ABSPIPEOUTEXEC:
      if(nparam>=3){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       args=new ConfigArgs(nparam-1,param+1,i==ABSPIPEOUTEXEC);
       if(args){
        pipeoutexec.Add(args);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - Not enough parameters.\n",nline);
       }
     break;
     case DEFAULTHEADER:
      if(nparam==2){
       for(ii=0;param[1][ii];ii++){
        if(param[1][ii]=='_') param[1][ii]=' ';
        if(param[1][ii]=='\\') if(param[1][ii+1]) for(j=ii;param[1][j];j++) param[1][j]=param[1][j+1];
        }
       default_header=(char*)malloc(strlen(param[1])+1);
       if(default_header) strcpy(default_header,param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"DefaultHeader\" should have one parameter.\n",nline);
       }
      break;
     case DEFAULTFOOTER:
      if(nparam==2){
       for(ii=0;param[1][ii];ii++){
        if(param[1][ii]=='_') param[1][ii]=' ';
        if(param[1][ii]=='\\') if(param[1][ii+1]) for(j=ii;param[1][j];j++) param[1][j]=param[1][j+1];
        }
       default_footer=(char*)malloc(strlen(param[1])+1);
       if(default_footer) strcpy(default_footer,param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"DefaultFooter\" should have one parameter.\n",nline);
       }
     break;
     case C_TYPE:
     case C_ABSTYPE:
      if(nparam==5){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       if(strlen(param[3])>MAXPATHLEN) param[3][MAXPATHLEN+1]=0;
       if(strlen(param[4])>MAXPATHLEN) param[4][MAXPATHLEN+1]=0;
       for(ii=0;param[2][ii];ii++){
        if(param[2][ii]=='_') param[2][ii]=' ';
        if(param[2][ii]=='\\') if(param[2][ii+1]) for(j=ii;param[2][j];j++) param[2][j]=param[2][j+1];
        }
       for(ii=0;param[3][ii];ii++){
        if(param[3][ii]=='_') param[3][ii]=' ';
        if(param[3][ii]=='\\') if(param[3][ii+1]) for(j=ii;param[3][j];j++) param[3][j]=param[3][j+1];
        }
       for(ii=0;param[4][ii];ii++){
        if(param[4][ii]=='_') param[4][ii]=' ';
        if(param[4][ii]=='\\') if(param[4][ii+1]) for(j=ii;param[4][j];j++) param[4][j]=param[4][j+1];
        }
       currtype=new TypeArgs(param[1],param[2],param[3],param[4],i==C_ABSTYPE);
       if(currtype) types.Add(currtype);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"[Abs]Type\" should have 4 parameters.\n",nline);
       }
      break;
     case C_DIRTYPE:
     case C_ABSDIRTYPE:
      if(nparam==4){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       if(strlen(param[3])>MAXPATHLEN) param[3][MAXPATHLEN+1]=0;
       for(ii=0;param[2][ii];ii++){
        if(param[2][ii]=='_') param[2][ii]=' ';
        if(param[2][ii]=='\\') if(param[2][ii+1]) for(j=ii;param[2][j];j++) param[2][j]=param[2][j+1];
        }
       for(ii=0;param[3][ii];ii++){
        if(param[3][ii]=='_') param[3][ii]=' ';
        if(param[3][ii]=='\\') if(param[3][ii+1]) for(j=ii;param[3][j];j++) param[3][j]=param[3][j+1];
        }
       currtype=new TypeArgs(param[1],"",param[2],param[3],i==C_ABSDIRTYPE);
       if(currtype) dirtypes.Add(currtype);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"[Abs]DirType\" should have 3 parameters.\n",nline);
       }
      break;
     case EXECMASK:
      if(nparam>=2){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       args=new ConfigArgs(nparam,param);
       if(args){
	if(args->params[0]&&args->params[1]){
         free(args->params[0]);
         args->params[0]=(char*)malloc(strlen(args->params[1])+1);
         if(args->params[0]){
          strcpy(args->params[0],args->params[1]);
          args->charvalue=args->params[0];
          if(args->charvalue) args->charvaluelength=strlen(args->charvalue);
	  }
	 }
        executables.Add(args);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - Not enough parameters.\n",nline);
       }
      break;
     case SPECIALEXECMASK:
      if(nparam==2){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       args=new ConfigArgs(nparam-1,param+1);
       if(args){
        specialexecutables.Add(args);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"SpecialExecMask\" should have one parameter.\n",nline);
       }
      break;
     case USERDIR:
      if(nparam==2){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(userhomedir) free(userhomedir);
       userhomedir=(char*)malloc(strlen(param[1])+1);
       if(userhomedir) strcpy(userhomedir,param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"UserDir\" should have one parameter.\n",nline);
       }
     break;
     }
    }
   }
  }
 fclose(f);
 return 0;
 }
return -1;
}

int global_alarmflag=0;
int idle_timeout=IDLE_TIMEOUT;
int transfer_timeout=TRANSFER_TIMEOUT;

void alarmhandler(SIGACTARGS){
global_alarmflag=1;
}

void setalarm(int t){
global_alarmflag=0;
struct sigaction tmpsigaction;
bzero((char*)&tmpsigaction,sizeof(struct sigaction));
tmpsigaction.sa_handler=alarmhandler;
sigaddset(&tmpsigaction.sa_mask,SIGALRM);
tmpsigaction.sa_flags=0;
sigaction(SIGALRM,&tmpsigaction,NULL);
alarm(t);
}

int makefileresponse(struct httpresponse *response,
const char *contenttype,int keepalive){
char tmpline[128];
char tmpline1[128];
int i;
if(!response) return -1;
i=putlinetoresponse(response,"HTTP/1.0 200 OK\r\nContent-Type: ");
if(!contenttype){
 i|=putlinetoresponse(response,"text/html");
 }else{
 i|=putlinetoresponse(response,contenttype);
 }
i|=putlinetoresponse(response,"\r\nServer: " SERVERSOFTWARE);
if(keepalive){
 i|=putlinetoresponse(response,
 "\r\nConnection: Keep-Alive\r\nKeep-Alive: max=0, timeout=30");
 }
linefromtime(tmpline1,time(NULL));
sprintf(tmpline,"\r\nDate: %s\r\n",
       tmpline1);
i|=putlinetoresponse(response,tmpline);
if(i<0) i=-1;
return i;
}

int displayfileentry(struct httpresponse *response,char *s,
 char *absbase,char *relbase){
if(!s) return -1;
time_t tt,ft;
char filetime[80];
char absstring[MAXPATHLEN+1],relstring[MAXPATHLEN+1];
char *prefix=NULL,*postfix=NULL;
TypeArgs *currtype=NULL;

*filetime=0;
time(&tt);
ft=((__s32*)s)[2];
strcpy(filetime,ctime(&ft));
filetime[16]=0;
strncpy(absstring,absbase,MAXPATHLEN);
absstring[MAXPATHLEN]=0;
strncat(absstring,s+3*sizeof(__s32)+sizeof(char*),
 MAXPATHLEN-1-strlen(absstring));
absstring[MAXPATHLEN]=0;

strncpy(relstring,relbase,MAXPATHLEN);
relstring[MAXPATHLEN]=0;
strncat(relstring,s+3*sizeof(__s32)+sizeof(char*),
 MAXPATHLEN-1-strlen(relstring));
relstring[MAXPATHLEN]=0;

if((__s32)tt>((__s32*)s)[2]+15552000l){
 filetime[11]=' ';
 memcpy(filetime+12,filetime+20,4);
 }
if(S_ISDIR(((__s32*)s)[0])){
 currtype=(TypeArgs*)dirtypes.start;
 }else{
 currtype=(TypeArgs*)types.start;
 }
while(currtype){
 if(wildmat(currtype->absolute?absstring:relstring,
  (char*)(currtype->pattern))){
  prefix=currtype->dirprefix;
  postfix=currtype->dirpostfix;
  currtype=NULL;
  }
 if(currtype) currtype=(TypeArgs*)currtype->next;
 }
if(prefix) putlinetoresponse(response,prefix);
 else putlinetoresponse(response,"<DT>");
if(S_ISDIR(((__s32*)s)[0])){
 if(!prefix) putlinetoresponse(response,"<B>");
 putlinetoresponse(response,"<A HREF=\"");
 putulinetoresponse(response,/*s+3*sizeof(__s32)+sizeof(char*)*/relstring,'~');
 putlinetoresponse(response,"/\">");
 putmlinetoresponse(response,s+3*sizeof(__s32)+sizeof(char*));
 putlinetoresponse(response,"/</A> ");
 putlinetoresponse(response,filetime);
 if(postfix) putlinetoresponse(response,postfix);
  else putlinetoresponse(response,"</B>");
 if(*((char**)&(((__s32*)s)[3])))
  putlinetoresponse(response,*((char**)&(((__s32*)s)[3])));
 }else{
 putlinetoresponse(response,"<A HREF=\"");
 putulinetoresponse(response,/*s+3*sizeof(__s32)+sizeof(char*)*/relstring,'~');
 putlinetoresponse(response,"\">");
 putmlinetoresponse(response,s+3*sizeof(__s32)+sizeof(char*));
 putlinetoresponse(response,"</A> ");
 putlinetoresponse(response,filetime);
 sprintf(filetime," (%d bytes)",((__s32*)s)[1]);
 putlinetoresponse(response,filetime);
 if(postfix) putlinetoresponse(response,postfix);
 if(*((char**)&(((__s32*)s)[3])))
  putlinetoresponse(response,*((char**)&(((__s32*)s)[3])));
 }
putlinetoresponse(response,"\r\n");
return 0;
}

int makedirheader(struct httpresponse *response,const char *host,
 const char *dir,const char *headerfmt){
const char *hbpointer,*hpointer;
if(!host||!dir||!headerfmt) return -1;
hbpointer=headerfmt;
while(hbpointer){
 hpointer=strchr(hbpointer,'$');
 if(hpointer){
  writetoresponse(response,hbpointer,hpointer-hbpointer);
  hpointer++;
  switch(*hpointer){
   case 'D':
   case 'd':
    putmlinetoresponse(response,dir);
    hpointer++;
    break;
   case 'H':
   case 'h':
    putmlinetoresponse(response,host);
    hpointer++;
    break;
   case '$':
    writetoresponse(response,"$",1);
    hpointer++;
    break;
   }
  hbpointer=hpointer;
  }else{
  putlinetoresponse(response,hbpointer);
  hbpointer=NULL;
  }
 }
return 0;
}

int addfile(struct httpresponse *response,char *s){
#ifdef FCNTL_LOCK
struct flock rdlck={F_RDLCK,SEEK_SET,0,0,0},unlck={F_UNLCK,SEEK_SET,0,0,0};
#endif
struct stat statbuf;
int rvalue=0;
int tmph=open(s,O_RDONLY);
if(tmph>=0){
 if(!fstat(tmph,&statbuf)){
  if(S_ISREG(statbuf.st_mode)){
#ifdef FLOCK
   if(!flock(tmph,LOCK_SH))
#else
#ifdef FCNTL_LOCK
   if(!fcntl(tmph,F_SETLK,&rdlck))
#endif
#endif
    {
    char buffer[FILE_TRANSFER_BUFFER_SIZE];
    int l;
    while((l=read(tmph,buffer,FILE_TRANSFER_BUFFER_SIZE))>0){
     writetoresponse(response,buffer,l);
     }
#ifdef FLOCK
    flock(tmph,LOCK_UN);
#else
#ifdef FCNTL_LOCK
    fcntl(tmph,F_SETLK,&unlck);
#endif
#endif
    }
   }else rvalue=-1;
  }else rvalue=-1;
 close(tmph);
 }else rvalue=-1;
return rvalue;
}

int dircompare(const void *a,const void *b){
if(S_ISDIR(*(__s32*)*(char**)a)&&!S_ISDIR(*(__s32*)*(char**)b)) return -1;
if(S_ISDIR(*(__s32*)*(char**)b)&&!S_ISDIR(*(__s32*)*(char**)a)) return 1;
return strcmp(((char*)*(char**)a)+3*sizeof(__s32)+sizeof(char*),((char*)*(char**)b)+3*sizeof(__s32)+sizeof(char*));
}

int swrite(int h,char *s){
return write(h,s,strlen(s));
}

int checkinput(int h){
fd_set readfd;
FD_ZERO(&readfd);
FD_SET(h,&readfd);
return select(h+1,&readfd,NULL,NULL,NULL)>0;
}

int main(int argc,char **argv){
struct http_server *server;
struct request *req;
int argc1;
char **argv1;
int i,human=1,useuid=0,a=0,uid_error;
char *configfile=FHTTPD_CONFIG_FILE;
char tmpline[128];
int map_username=0; /* not global one in fhttpd itself */
char *startingslash;
#ifdef FCNTL_LOCK
struct flock rdlck={F_RDLCK,SEEK_SET,0,0,0},unlck={F_UNLCK,SEEK_SET,0,0,0};
#endif
signal(SIGPIPE,SIG_IGN);
signal(SIGCHLD,SIG_IGN);

int c,i0=0,i1=0;
while((c=getopt(argc,argv,"spdc:mu:it:T:"))!=-1){
 switch(c){
  case 'd': human=0; break;
  case 'c': configfile=optarg; break;
  case 's': i0=1; break;
  case 'p': i1=1; break;
  case 'm': map_username=1; break;
  case 'i': if(!getuid()) useuid=1; break;
  case 'u': 
   if(*optarg=='0')
    umask(strtoul(optarg,NULL,8));
    else umask(strtoul(optarg,NULL,10));
   break;
  case 't': idle_timeout=atoi(optarg); break;
  case 'T': transfer_timeout=atoi(optarg); break;
  case ':':
  case '?':
   return -1;
  }
 }

argc1=argc-optind;
argv1=(char**)malloc(sizeof(char*)*(argc1+2));
if(!argv1) return -1;
argv1+=2;
for(i=optind;i<argc;i++) argv1[i-optind]=argv[i];

if(i0){
 argv1--;
 *argv1="-s";
 argc1++;
 }else{
 if(i1){
  argv1--;
  *argv1="-p";
  argc1++;
  }
 }
argv1--;
argc1++;
*argv1=*argv;

server=createserver();
if(!server) return -1;

switch(servproc_init(server,human,argc1,argv1)){
 case 0: break;
 case APP_ERR_HUMAN:
  fprintf(stderr,
"Usage: %s [options] [appname] [username] [hostname] [portname]\n"
"Options:\n"
"  -d       Daemon mode -- never attempt terminal I/O\n"
"  -s       Socket mode, fhttpd internal use only\n"
"  -p       Pipe mode, fhttpd internal use only\n"
"  -u<mask> Set umask\n"
"  -t<time> Idle timeout in seconds, 0 - disable\n"
"  -T<time> Transfer timeout in seconds, 0 - disable\n"
"  -c<file> fhttpd config file\n"
"  -m       Map ~<username>\n"
"  -i       Use userid of mapped ~<username>\n",
                        server->app_progname);
  exit(1);
  break;
 case APP_ERR_CONFIG:
  fprintf(stderr,"%s: configuration error\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_READ:
  fprintf(stderr,"%s: read error\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_HOSTNAME:
  fprintf(stderr,"%s: can't resolve server hostname\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_SOCKET:
  fprintf(stderr,"%s: can't create socket\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_CONNECT:
  fprintf(stderr,"%s: can't connect\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_APPCONNECT:
  fprintf(stderr,"%s: connect error\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_USER:
  fprintf(stderr,"%s: login error\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_PASSWORD:
  fprintf(stderr,"%s: login error\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_APPLICATION:
  fprintf(stderr,"%s: application rejected by server\n",server->app_progname);
  exit(1);
  break;
 case APP_ERR_INSANE:
 case APP_ERR_DAEMON:
 case APP_ERR_AUTH:
 default:
  if(server->infd<0) exit(1);
 }

if(server->infd==0&&server->outfd==1){
 int fd2;
 close(2);
 fd2=open("/dev/null",O_WRONLY);
 if(fd2!=2){
  dup2(fd2,2);
  close(fd2);
  }
 }

setcapabilities(server,APP_CAP_KEEPALIVE);

readconfig(configfile);
setalarm(idle_timeout);
while(1){
req=NULL;
while(checkinput(server->infd)&&(req=readrequest(server))){
 setalarm(transfer_timeout);
 if(req->reqtype==FHTTPD_REQUEST){
  int headonly=(req->method==APP_METHOD_HEAD);
  struct httpresponse *response=createresponse(1024,req->id,req->fd,
   req->ver_major>0);
  if(response){
   if(req->script_name&&req->script_name_resolved){
    int trailingslash,h=-1,spexec=0;
    int len=strlen(req->script_name);
    if(len>0){
     trailingslash=(req->script_name[len-1]=='/');
     }else trailingslash=1;
    char script_name_resolved_buffer[2048];
    struct passwd *pw=NULL;
    uid_error=0;
    if(map_username&&req->script_name[0]=='/'&&req->script_name[1]=='~'){
     startingslash=strchr((char*)req->script_name+2,'/');
     if(startingslash){
      *startingslash=0;
      }
     pw=getpwnam(req->script_name+2);
     if(startingslash) *startingslash='/';
     if(pw&&pw->pw_uid>0){
      int len1;
      strncpy(script_name_resolved_buffer,pw->pw_dir,2046);
      script_name_resolved_buffer[2046]=0;
      len1=strlen(script_name_resolved_buffer);
      script_name_resolved_buffer[len1]='/';
      if(!userhomedir){
       strncpy(script_name_resolved_buffer+len1+1,"public_html",2047-len1-1);
       }else{
       strncpy(script_name_resolved_buffer+len1+1,userhomedir,2047-len1-1);
       }
      script_name_resolved_buffer[2047]=0;
      len1=strlen(script_name_resolved_buffer);
      if(startingslash){
       strncpy(script_name_resolved_buffer+len1,startingslash,2047-len1);
       }
      if(useuid){
       setgid(pw->pw_gid);
       initgroups(pw->pw_name,pw->pw_gid);
       seteuid(pw->pw_uid);
       }
      }else{
      uid_error=1;
      strncpy(script_name_resolved_buffer,req->script_name_resolved,2047);
      }
     }else{
     if(useuid) uid_error=1;
     strncpy(script_name_resolved_buffer,req->script_name_resolved,2047);
     }
    script_name_resolved_buffer[2047]=0;
    if(!uid_error){
    if(!pw&&!strcmp(req->script_name,"/imagemap")){
      /* imagemaps in form */
     char *namevalue=NULL;
     double xvalue=0,yvalue=0;
     int i,llen;
     parserequest(req);
     for(i=0;i<req->nform;i++){
      if(req->form[i].params&&req->form[i].paramc==2){
       llen=strlen(req->form[i].params[0]);
       if(llen>2){
	if(req->form[i].params[0][llen-2]=='.'){
         req->form[i].params[0][llen-2]=0;
         namevalue=req->form[i].params[0];
         if((req->form[i].params[0][llen-1]&0xdf)=='X'){
          xvalue=atol(req->form[i].params[1]);
	  }else{
          if((req->form[i].params[0][llen-1]&0xdf)=='Y'){
           yvalue=atol(req->form[i].params[1]);
	   }
	  }
	 }
        }
       }
      }
     processimageform(req,response,namevalue,xvalue,yvalue);
     }else{
     if(strlen(req->script_name)>=10&&!memcmp(req->script_name,"/imagemap/",10)){
      /* imagemaps */
      double xvalue=0,yvalue=0;
      char *p;
      parserequest(req);
      if(req->query_string){
       if((p=strchr(req->query_string,','))){
        *p=0;
        xvalue=atol(req->query_string);
        yvalue=atol(p+1);
	}
       }
      processimageform(req,response,req->script_name+9,xvalue,yvalue);
      }else{
      ConfigArgs *args=appfindwildargs(&pipeoutexec,(char*)req->script_name,
       script_name_resolved_buffer);
      int pipeexec=0;
      if(!args){
       args=appfindwildargsreal(&executables,script_name_resolved_buffer);
       }else{
       pipeexec=1;
       }

      if(args){
       /*cgi*/
       if(args->paramc>0){
        int indexnamechanged=0;
        char *mark=script_name_resolved_buffer;
        mark+=strlen(mark);
         
        if(!pipeexec){
        if(!trailingslash&&mark-script_name_resolved_buffer>=11){
         if(!strcmp(mark-11,"/index.html")){
          trailingslash=1;
          indexnamechanged=1;
          mark-=11;
          }else{
          if(mark-script_name_resolved_buffer>=16){
           if(!strcmp(mark-16,"/file_index.html")){
            trailingslash=1;
            indexnamechanged=2;
            mark-=16;
	    }
           }
          }
         }
        struct stat statbuf;
        if(trailingslash){
         if(mark+11<script_name_resolved_buffer+2047){
          strcpy(mark,"/exec_index");
          if(!stat(script_name_resolved_buffer,&statbuf)){
           if(!(statbuf.st_mode&(S_IXUSR|S_IXGRP|S_IXOTH))||!S_ISREG(statbuf.st_mode)){
            *mark=0;
            args=0;
            }
           }else{
           *mark=0;
           args=0;
           }
          if(!args){
           switch(indexnamechanged){
            case 1:
             strcpy(mark,"/index.html");
             indexnamechanged=0;
             trailingslash=0;
             break;
            case 2:
             strcpy(mark,"/file_index.html");
             indexnamechanged=0;
             trailingslash=0;
             break;
            }
           }
          }else{
          *mark=0;
          args=0;
          }
         }else{
         if(!stat(script_name_resolved_buffer,&statbuf)){
          if(!(statbuf.st_mode&(S_IXUSR|S_IXGRP|S_IXOTH))
           ||!S_ISREG(statbuf.st_mode)) args=0;
          }else{
          args=0;
          }
         }
	 }
        if(args){
         if(appfindwildargsreal(&specialexecutables,
          script_name_resolved_buffer)) spexec=1;
         int inpipe[2],outpipe[2],failure=0;
         if(!req->databuffsize||!pipe(inpipe)){
          if(req->fd<0){
           if(pipe(outpipe)){
            failure=1;
            if(req->databuffsize){
             close(inpipe[0]);
             close(inpipe[1]);
	     }
	    }
           }
          }else failure=1;
         if(!failure){
          pid_t r=fork();
          if(!r){ /* child process */
           ConfigArgs *args1=new ConfigArgs(args->paramc>100?args->paramc:100,args->params);
           args=args1;
           if(args){
            if(args->params){
             if(args->params[1]&&!pipeexec){
              free(args->params[1]);
              }
             if(req->query_string){
              char *tmpqs=(char*)malloc(strlen(req->query_string)+1);
              if(tmpqs){
               strcpy(tmpqs,req->query_string);
               mark=tmpqs;
               if(!strchr(mark,'=')){
                while(mark&&args->paramc<100){
                 args->params[args->paramc]=mark;
                 mark=strchr(mark,'+');
                 if(mark){
                  *mark=0;
                  mark++;
	          }
                 unescape(args->params[args->paramc]);
                 args->paramc++;
                 }
                }
	       }
              }
             args->params[args->paramc]=NULL;
             if(!pipeexec){
              args->params[1]=script_name_resolved_buffer;
              }else{
              for(i=1;args->params[i];i++){
               if(!strcmp(args->params[i],"%s"))
                args->params[i]=script_name_resolved_buffer;
               }
              }
             }
            }
           signal(SIGPIPE,SIG_DFL);
           signal(SIGCHLD,SIG_DFL);
           if(req->fd>=0){
            if(req->fd!=1){
             dup2(req->fd,1);
             close(req->fd);
             }
            }else{
            dup2(outpipe[1],1);
            close(outpipe[0]);
            close(outpipe[1]);
            }
           if(req->databuffsize){
            dup2(inpipe[0],0);
            close(inpipe[0]);
            close(inpipe[1]);
	    }else{
            int h=open("/dev/null",O_RDONLY);
            if(h>0){
             dup2(h,0);
             close(h);
             }
            }
           if(server->infd!=0&&server->infd!=1) close(server->infd);
           dup2(1,2);
           if(!spexec) swrite(1,"HTTP/1.0 200 OK\r\nServer: " SERVERSOFTWARE "\r\n");
           mark=strrchr(args->params[1],'/');
           if(mark){
            *mark=0;
            chdir(args->params[1]);
            *mark='/';
            }
           char **tmpenv=NULL;
           tmpenv=(char**)malloc(sizeof(char*)*req->nlines+2);
           if(tmpenv){
            int j=0;
            for(i=0;i<req->nlines;i++){
	     if(req->lines[i].paramc==2){
	      if(req->lines[i].params[0]&&req->lines[i].params[1]){
               int l0=strlen(req->lines[i].params[0]);
               int l1=strlen(req->lines[i].params[1]);
               tmpenv[j]=(char*)malloc(l0+l1+2);
               if(tmpenv[j]){
                memcpy(tmpenv[j],req->lines[i].params[0],l0);
                tmpenv[j][l0]='=';
                memcpy(tmpenv[i]+l0+1,req->lines[i].params[1],l1);
                tmpenv[j][l0+l1+1]=0;
                j++;
       	        }
	       }
	      }
	     }
            tmpenv[j]=(char*)malloc(strlen(args->params[1])+sizeof("PATH_TRANSLATED="));
	    if(tmpenv[j]){
             memcpy(tmpenv[j],"PATH_TRANSLATED=",
	            sizeof("PATH_TRANSLATED=")-1);
	     strcpy(tmpenv[j]+sizeof("PATH_TRANSLATED=")-1,args->params[1]);
	     j++;
	     }
            tmpenv[j]=NULL;
            }
           if(useuid){
            int tmpuid=geteuid();
            seteuid(0);
            setuid(tmpuid);
            }
           execve(args->params[1],args->params+1,tmpenv);
           if(spexec) swrite(1,"HTTP/1.0 200 OK\r\nServer: " SERVERSOFTWARE "\r\n");
           swrite(1,"Content-Type: text/html\r\n\r\n<H1>Server can't execute program</H1>");
           _exit(1);

	   }else{ /* parent */
           if(r!=-1){
            int errflag=0,bytescounter=0;
            if(req->fd<0) close(outpipe[1]);
            if(req->databuffsize){ /* anything in the request? */
             close(inpipe[0]); /* send request to the cgi script */
             if(write(inpipe[1],req->databuffer,req->databuffsize)
              !=req->databuffsize) errflag=1;
             close(inpipe[1]);
	     }
            if(req->fd<0){ /* if it doesn't do it by itself... */
             char buffer[FILE_TRANSFER_BUFFER_SIZE+3*sizeof(__s32)];
             int l=0; /* ...relay the response */
             while(!errflag&&((l=read(outpipe[0],buffer+3*sizeof(__s32),FILE_TRANSFER_BUFFER_SIZE))>0)){
	      bytescounter+=l;
              l+=+3*sizeof(__s32);
              ((__s32*)buffer)[0]=htonl(l);
              ((__s32*)buffer)[1]=htonl(FHTTPD_SEND);
              ((__s32*)buffer)[2]=htonl(response->id);
              if(global_alarmflag){
               kill(r,SIGTERM);
               errflag=1;
	       }else{
               if(write(server->outfd,buffer,l)!=l){
                kill(r,SIGTERM);
                errflag=1;
	        }
	       }
              }
             close(outpipe[0]);
	     }
            wait(&a);
	    if(errflag){
	     logmessage(server,response,"CGI_FAILURE",NULL);
	     }
	    if(req->fd<0){
             sprintf(tmpline,"%d",bytescounter);
	     logmessage(server,response,"CGI_RESPONSE_LENGTH",tmpline);
	     }else{
	     logmessage(server,response,"CGI_RESPONSE_LENGTH","Unknown");
	     }
            finishdropresponse(server,response); /* finish and drop */
            }else{ /* failure */
            if(req->databuffsize){
             close(inpipe[0]);
             close(inpipe[1]);
             }
            if(req->fd<0){
             close(outpipe[0]);
             close(outpipe[1]);
             }
            putlinetoresponse(response,"<H1>500 Internal Server Error</H1>");
	    logmessage(server,response,"RESPONSE","500");
            makestandardheader(response,500,NULL,NULL,req->keepalive);
            sendresponse(server,response);
            finishresponse(server,response);
	    }
	   }
	  }else{
          putlinetoresponse(response,"<H1>500 Internal Server Error</H1>");
	  logmessage(server,response,"RESPONSE","500");
          makestandardheader(response,500,NULL,NULL,req->keepalive);
          sendresponse(server,response);
          finishresponse(server,response);
	  }
	 }
        }else args=0;
       }
      if(!args){
       /* file/directory */
       char filemask[129];
       filemask[0]='*';
       filemask[1]=0;
       len=strlen(script_name_resolved_buffer);
       h=-1;
       if(trailingslash){
        if(len+16<2048){
         strcpy(script_name_resolved_buffer+len,"/file_index.html");
         h=open(script_name_resolved_buffer,O_RDONLY);
	 }
        if(h<0&&len+11<2048){
         strcpy(script_name_resolved_buffer+len,"/index.html");
         h=open(script_name_resolved_buffer,O_RDONLY);
	 }
        if(h<0){
         script_name_resolved_buffer[len]=0;
         h=open(script_name_resolved_buffer,O_RDONLY);
	 }else trailingslash=0;
        }
       if(h<0&&!trailingslash){
        h=open(script_name_resolved_buffer,O_RDONLY);
        int indexnamechanged=0;
        if(h<0){
         if(strlen(script_name_resolved_buffer)-10+15<2048){
          if(strlen(script_name_resolved_buffer)>=11){
           if(!strcmp(script_name_resolved_buffer
             +strlen(script_name_resolved_buffer)-11,"/index.html")){
            strcpy(script_name_resolved_buffer
             +strlen(script_name_resolved_buffer)-10,"file_index.html");
            indexnamechanged=1;
            h=open(script_name_resolved_buffer,O_RDONLY);
            if(h<0){
              *(script_name_resolved_buffer
             +strlen(script_name_resolved_buffer)-16)=0;
             trailingslash=1;
             h=open(script_name_resolved_buffer,O_RDONLY);
	     }
            }
           }else{
           if(!strcmp(script_name_resolved_buffer,"index.html")){
            strcpy(script_name_resolved_buffer,"file_index.html");
            indexnamechanged=1;
            if(h<0){
             strcpy(script_name_resolved_buffer,"/");
             trailingslash=1;
             h=open(script_name_resolved_buffer,O_RDONLY);
	     }
            }
           }
          }
         }
        if(h<0&&!indexnamechanged){
         if(strlen(script_name_resolved_buffer)>=16){
          if(!strcmp(script_name_resolved_buffer
            +strlen(script_name_resolved_buffer)-15,"file_index.html")){
	   if(script_name_resolved_buffer[strlen(script_name_resolved_buffer)
            -16]=='/'){

            strcpy(script_name_resolved_buffer
             +strlen(script_name_resolved_buffer)-15,"index.html");
            h=open(script_name_resolved_buffer,O_RDONLY);
            if(h<0){
             *(script_name_resolved_buffer
             +strlen(script_name_resolved_buffer)-11)=0;
             trailingslash=1;
             h=open(script_name_resolved_buffer,O_RDONLY);
	     }
	    }else{
            script_name_resolved_buffer[strlen(script_name_resolved_buffer)
            -15]=0;
            char *p=strrchr(script_name_resolved_buffer,'/');
            if(p){
             *p=0;
             strncpy(filemask,p+1,128);
             filemask[128]=0;
	     }
            trailingslash=1;
            h=open(script_name_resolved_buffer,O_RDONLY);
	    }
           }
          }else{
          if(!strcmp(script_name_resolved_buffer,"file_index.html")){
           strcpy(script_name_resolved_buffer,"index.html");
           h=open(script_name_resolved_buffer,O_RDONLY);
           if(h<0){
            strcpy(script_name_resolved_buffer,"/");
            trailingslash=1;
	    }
           }
          }
         }
        }
       if(h>=0){
        struct stat statbuf;
        if(!fstat(h,&statbuf)){
         if(statbuf.st_mtime>req->ifmodifiedsince){
         if(S_ISREG(statbuf.st_mode)){
	  if(!trailingslash){
           char *typeline=NULL;
           TypeArgs *currtype=(TypeArgs*)types.start;
           while(currtype){
            if(wildmat(currtype->absolute?(char*)script_name_resolved_buffer:
            (char*)req->script_name,
            (char*)(currtype->pattern))){
             typeline=currtype->typeline;
             currtype=NULL;
             }
            if(currtype) currtype=(TypeArgs*)currtype->next;
            }
           if(!typeline) typeline="text/plain";
           int errflag=0;
#ifdef FLOCK
           if(!flock(h,LOCK_SH))
#else
#ifdef FCNTL_LOCK
           if(!fcntl(h,F_SETLK,&rdlck))
#endif
#endif
            {
            __s32 filelength=statbuf.st_size;
            __s32 blocksize=filelength;
            if(blocksize<=0||blocksize>FILE_TRANSFER_BUFFER_SIZE) blocksize=FILE_TRANSFER_BUFFER_SIZE;
            blocksize=(FILE_TRANSFER_BUFFER_SIZE/blocksize)*blocksize;
            if(blocksize>filelength) blocksize=filelength;
	    logmessage(server,response,"RESPONSE","200");
            if(response->header){
             response->header->body=NULL;
             deleteresponse(response->header);
             response->header=NULL;
             makefileresponse(response,typeline,req->keepalive&&filelength);
	     //filelength=0 forces the connection to be dropped
             putlinetoresponse(response,"Last-Modified: ");
             linefromtime(tmpline,statbuf.st_mtime);
             putlinetoresponse(response,tmpline);
             sprintf(tmpline,"\r\nContent-Length: %d\r\n\r\n",filelength);
             putlinetoresponse(response,tmpline);
	     }
            sprintf(tmpline,"%d",filelength);
	    if(headonly){
	     logmessage(server,response,"HEADER_CONTENT_LENGTH",tmpline);
	     }else{
	     logmessage(server,response,"CONTENT_LENGTH",tmpline);
	     }

            if(req->fd>=0){
	   /* AF_UNIX socket */
             int l=0;
             int firstblock=1;
             struct iovec iov[2];
             if(filelength!=0&&!headonly){
#ifndef NO_MMAP
	      if(filelength>MMAPPAGESIZE){
#endif
               char buffer[FILE_TRANSFER_BUFFER_SIZE];
               while(!errflag&&((l=read(h,buffer,blocksize))>0)){
                setalarm(transfer_timeout);
		if(firstblock){
                 iov[0].iov_base=response->buffer;
                 iov[0].iov_len=response->datasize;
                 iov[1].iov_base=buffer;
                 iov[1].iov_len=l;
                 if(writev(req->fd,iov,2)!=response->datasize+l) errflag=1;
                 firstblock=0;
                 if(global_alarmflag) errflag=1;
		 }else{
                 if(write(req->fd,buffer,l)!=l) errflag=1;
                 if(global_alarmflag) errflag=1;
		 }
                }
#ifndef NO_MMAP
	       }else{
               char *mmbuf=(char*)mmap(NULL,filelength,PROT_READ,MAP_SHARED|MAP_FILE,h,0);
               if((long)mmbuf!=-1){
                iov[0].iov_base=response->buffer;
                iov[0].iov_len=response->datasize;
                iov[1].iov_base=mmbuf;
                iov[1].iov_len=filelength;
                if(writev(req->fd,iov,2)!=response->datasize+filelength) errflag=1;
                if(global_alarmflag) errflag=1;
                munmap(mmbuf,filelength);
	        }
	       }
#endif
	      }else{
              if(write(req->fd,response->buffer,response->datasize)
                !=response->datasize) errflag=1;
              if(global_alarmflag) errflag=1;
              }
             }else{
	     int l=0;
	   /* pipe or TCP */
             sendresponse(server,response);
             if(filelength!=0&&!headonly){
              char buffer[FILE_TRANSFER_BUFFER_SIZE+3*sizeof(__s32)];
              while(!errflag&&((l=read(h,buffer+3*sizeof(__s32),blocksize))>0)){
               l+=3*sizeof(__s32);
               ((__s32*)buffer)[0]=htonl(l);
               ((__s32*)buffer)[1]=htonl(FHTTPD_SEND);
               ((__s32*)buffer)[2]=htonl(response->id);

               if(write(server->outfd,buffer,l)!=l) errflag=1;
               }
	      }
      	     }
	    if(filelength) finishresponse(server,response);
	    else finishdropresponse(server,response);
            //filelength=0 forces the connection to be dropped
	    }
#ifdef FLOCK
           flock(h,LOCK_UN);
#else
#ifdef FCNTL_LOCK
          fcntl(h,F_SETLK,&unlck);
#endif
#endif
           }else{
           putlinetoresponse(response,"<H1>404 Not a directory</H1>");
	   logmessage(server,response,"RESPONSE","404");
           makestandardheader(response,404,NULL,NULL,req->keepalive);
           sendresponse(server,response);
           finishresponse(server,response);
	   }
          }else{
	  if(!trailingslash){
           if(S_ISDIR(statbuf.st_mode)){
            char tmpstr[2048];
            int l1=0;
            makemyurl(tmpstr,req,2047,NULL,NULL);
            l1=strlen(tmpstr);
            if(l1>=1){
	     if(tmpstr[l1-1]!='/'){
              tmpstr[l1]='/';
              tmpstr[l1+1]=0;
	      }
	     }
	    logmessage(server,response,"RESPONSE","302");
            redirect(req,tmpstr);
	    }else{
            putlinetoresponse(response,"<H1>404 Not a file or directory</H1>");
	    logmessage(server,response,"RESPONSE","404");
            makestandardheader(response,404,NULL,NULL,req->keepalive);
            sendresponse(server,response);
            finishresponse(server,response);
	    }
	   }else{
           if(S_ISDIR(statbuf.st_mode)){
	  /* directory */
            DIR *dirp=NULL;
            struct dirent *mydirent;
            int header_click_file=0,footer_click_file=0,index_file=0;
            char **filenames=NULL;
            int filenamescount=0,filenamessize=0;
	    if((dirp=opendir(script_name_resolved_buffer))){
             char tmpfullname[MAXPATHLEN+1];
             strncpy(tmpfullname,script_name_resolved_buffer,MAXPATHLEN);
             tmpfullname[MAXPATHLEN]=0;
             int tmpdirlen=strlen(tmpfullname);
             if(tmpdirlen<MAXPATHLEN){
              tmpfullname[tmpdirlen]='/';
              tmpdirlen++;
              tmpfullname[tmpdirlen]=0;

              char tmprelname[MAXPATHLEN+1];
              strncpy(tmprelname,req->script_name,MAXPATHLEN);
              tmprelname[MAXPATHLEN]=0;
              int tmpreldirlen=strlen(tmprelname);
              char *p=strrchr(tmprelname,'/');
              if(p) tmpreldirlen=p-tmprelname+1;
              tmprelname[tmpreldirlen]=0;
              while((mydirent=readdir(dirp))){
	       if(strcmp(mydirent->d_name,".")){
	        if(strcmp(mydirent->d_name,"..")){
                 if(!strcmp(mydirent->d_name,".header.html")){
                  header_click_file=1;
	 	  }else{
                  if(!strcmp(mydirent->d_name,".footer.html")){
                   footer_click_file=1;
		   }else{
                   if(!strcmp(mydirent->d_name,".index.html")){
                    index_file=1;
		    }else{
		    if(*mydirent->d_name!='.'
                     &&wildmat(mydirent->d_name,filemask)){
                     strncpy(tmpfullname+tmpdirlen,mydirent->d_name,MAXPATHLEN-1-tmpdirlen);
                     tmpfullname[MAXPATHLEN-1]=0;
                     int tmph=open(tmpfullname,O_RDONLY);
                     struct stat statbuf1;
                     if(!fstat(tmph,&statbuf1)){
		      if(!filenames){
                       filenames=(char**)malloc(64*sizeof(char*));
                       if(filenames) filenamessize=64;
		       }
                      if(filenames){
                       if(filenamessize<=filenamescount){
                        char **tmpfilenames=(char**)realloc(filenames,(filenamescount+64)*sizeof(char*));
                        if(tmpfilenames){
                         filenamessize=filenamescount+64;
                         filenames=tmpfilenames;
		         }
		        }
                       if(filenamessize>filenamescount){
                        filenames[filenamescount]=(char*)malloc(mydirent->d_reclen+3*sizeof(__s32)+sizeof(char*)+1);
		        if(filenames[filenamescount]){
                         strcpy(filenames[filenamescount]+3*sizeof(__s32)+sizeof(char*),mydirent->d_name);
                         ((__s32*)filenames[filenamescount])[0]=statbuf1.st_mode;
                         ((__s32*)filenames[filenamescount])[1]=statbuf1.st_size;
                         ((__s32*)filenames[filenamescount])[2]=statbuf1.st_mtime;
                         *((char**)&(((__s32*)filenames[filenamescount])[3]))=NULL;
                         filenamescount++;
		         }
		        }
		       }
		      }
                     close(tmph);
		     }
		    }
		   }
		  }
		 }
	        }
	       }
              if(filenames){
               if(filenamescount){
                qsort(filenames,filenamescount,sizeof(char*),dircompare);
                int i;
                if(header_click_file){
		 strncpy(tmpfullname+tmpdirlen,".header.html",MAXPATHLEN-1-tmpdirlen);
                 if(addfile(response,tmpfullname)) header_click_file=0;
		 }
                if(!header_click_file){
	         if(default_header){
                  makedirheader(response,req->server_name,tmprelname,
                  default_header);
	          }else{
                  makedirheader(response,req->server_name,tmprelname,
"<HTML>\r\n<HEAD>\r\n<TITLE>Directory $D at $H</TITLE>\r\n</HEAD>\r\n<BODY>\r\n<H1>Directory $D at $H</H1>\r\n<HR>\r\n<DL>\r\n");
	          }
		 }

		if(index_file){
		 strncpy(tmpfullname+tmpdirlen,".index.html",MAXPATHLEN-1-tmpdirlen);
                 FILE *f=fopen(tmpfullname,"rt");
                 if(f){
                  char buffer[MESSAGE_BUFFER_SIZE];
                  char *currline=NULL,*p;
                  int currlinelength=0,ll;
                  char *found=NULL;
                  while(fgets(buffer,MESSAGE_BUFFER_SIZE,f)){
                   buffer[(MESSAGE_BUFFER_SIZE-1)]=0;
                   if(isspace(buffer[0])){
		    if(currline){
                     ll=strlen(buffer);
                     p=(char*)realloc(currline,currlinelength+ll+1);
                     if(p){
                      currline=p;
                      strcpy(currline+currlinelength,buffer);
                      currlinelength+=ll;
                      *((char**)&(((__s32*)found)[3]))=currline;
		      }
		     }
                    }else{
                    currline=NULL;
                    currlinelength=0;
                    p=buffer;
                    while(*p&&!isspace(*p)) p++;
                    if(*p){
                     *p=0;
                     p++;
                     int n=filenamescount>>1;
                     int lower=0,upper=filenamescount;
                     int cmpresult;
                     found=NULL;
                     while(upper>lower&&!found){
                      cmpresult=strcmp(buffer,
                       filenames[n]+3*sizeof(__s32)+sizeof(char*));
                      if(!cmpresult){
                       found=filenames[n];
		       }else{
                       if(cmpresult<0){
                        upper=n;
			n=(n+lower)>>1;
		        }else{
                        lower=n+1;
			n=(n+upper)>>1;
		        }
		       }
                      }
                     if(found){
                      currlinelength=strlen(p);
                      currline=(char*)malloc(currlinelength+1);
                      if(currline){
                       strcpy(currline,p);
                       *((char**)&(((__s32*)found)[3]))=currline;
		       }else currlinelength=0;
		      }
		     }
                    }
		   }
                  fclose(f);
		  }
		 }
                for(i=0;i<filenamescount;i++){
                 tmpfullname[tmpdirlen]=0;
                 tmprelname[tmpreldirlen]=0;
                 displayfileentry(response,filenames[i],tmpfullname,tmprelname);
                 if(*((char**)&(((__s32*)filenames[i])[3]))){
                  free(*((char**)&(((__s32*)filenames[i])[3])));
		  }
                 free(filenames[i]);
		 }
                if(footer_click_file){
		 strncpy(tmpfullname+tmpdirlen,".footer.html",MAXPATHLEN-1-tmpdirlen);
                 if(addfile(response,tmpfullname)) footer_click_file=0;
                 }
                if(!footer_click_file){
	         if(default_footer){
                  makedirheader(response,req->server_name,tmprelname,
                  default_footer);
	          }else{
                  makedirheader(response,req->server_name,tmprelname,
"</DL>\r\n<HR>\r\n<I>FTP/HTTP server at $H</I>\r\n</BODY>\r\n</HTML>");
	          }
		 }
                }else{
	        if(!strcmp(filemask,"*")){
                 makedirheader(response,req->server_name,tmprelname,
"<HTML>\r\n<HEAD>\r\n<TITLE>Directory $D at $H</TITLE>\r\n</HEAD>\r\n<BODY>\r\n<H1>Directory $D at $H is empty</H1>\r\n</BODY>\r\n</HTML>");
		 }else{
                 makedirheader(response,req->server_name,tmprelname,
"<HTML>\r\n<HEAD>\r\n<TITLE>Directory $D at $H</TITLE>\r\n</HEAD>\r\n<BODY>\r\n<H1>Directory $D at $H has no matching files</H1>\r\n</BODY>\r\n</HTML>");
		 }
	        }
               free(filenames);
	       }else{
	       if(!strcmp(filemask,"*")){
                makedirheader(response,req->server_name,tmprelname,
"<HTML>\r\n<HEAD>\r\n<TITLE>Directory $D at $H</TITLE>\r\n</HEAD>\r\n<BODY>\r\n<H1>Directory $D at $H is empty</H1>\r\n</BODY>\r\n</HTML>");
		}else{
                makedirheader(response,req->server_name,tmprelname,
"<HTML>\r\n<HEAD>\r\n<TITLE>Directory $D at $H</TITLE>\r\n</HEAD>\r\n<BODY>\r\n<H1>Directory $D at $H has no matching files</H1>\r\n</BODY>\r\n</HTML>");
	        }
	       }
	      }
             closedir(dirp);
	     logmessage(server,response,"RESPONSE","200");
             sprintf(tmpline,"%ld",response->datasize);
	     if(headonly){
	      logmessage(server,response,"HEADER_CONTENT_LENGTH",tmpline);
	      }else{
	      logmessage(server,response,"CONTENT_LENGTH",tmpline);
	      }
             makestandardheader(response,200,"text/html",NULL,req->keepalive);
             putlinetoheader(response,"Last-Modified: ");
             linefromtime(tmpline,statbuf.st_mtime);
             putlinetoheader(response,tmpline);
             putlinetoheader(response,"\r\n");
             if(headonly&&response->header){
              struct httpresponse *t=response->header;
              response->header->body=NULL;
              response->header=NULL;
              deleteresponse(response);
              response=t;
              putlinetoresponse(response,"\r\n");
	      }
             sendresponse(server,response);
             finishresponse(server,response);
	     }else{
             putlinetoresponse(response,"<H1>403 Forbidden</H1>");
	     logmessage(server,response,"RESPONSE","403");
             makestandardheader(response,403,NULL,NULL,req->keepalive);
             sendresponse(server,response);
             finishresponse(server,response);
	     }
	    }else{
	    if(errno==EPERM||errno==EACCES){
             putlinetoresponse(response,"<H1>403 Forbidden</H1>");
	     logmessage(server,response,"RESPONSE","403");
             makestandardheader(response,403,NULL,NULL,req->keepalive);
	     }else{
             putlinetoresponse(response,"<H1>404 Not found</H1>");
	     logmessage(server,response,"RESPONSE","404");
             makestandardheader(response,404,NULL,NULL,req->keepalive);
	     }
            sendresponse(server,response);
            finishresponse(server,response);
	    }
	   }
	  }
	  }else{
          logmessage(server,response,"RESPONSE","304");
          makestandardheader(response,304,NULL,NULL,req->keepalive);
          sendresponse(server,response);
          finishresponse(server,response);
	  }
	 }else{
         putlinetoresponse(response,"<H1>403 Forbidden</H1>");
         logmessage(server,response,"RESPONSE","403");
         makestandardheader(response,403,NULL,NULL,req->keepalive);
         sendresponse(server,response);
         finishresponse(server,response);
	 }
        close(h);
        }else{
        if(errno==EPERM||errno==EACCES){
         putlinetoresponse(response,"<H1>403 Forbidden</H1>");
         logmessage(server,response,"RESPONSE","403");
         makestandardheader(response,403,NULL,NULL,req->keepalive);
	 }else{
         putlinetoresponse(response,"<H1>404 Not found</H1>");
	 logmessage(server,response,"RESPONSE","404");
         makestandardheader(response,404,NULL,NULL,req->keepalive);
	 }
        sendresponse(server,response);
        finishresponse(server,response);
        }
       }
      }
     }
     if(useuid){
      seteuid(0);
      setuid(0);
      pw=getpwuid(0);
      if(pw){
       setgid(pw->pw_gid);
       initgroups(pw->pw_name,pw->pw_gid);
       }
      }
     }else{
     putlinetoresponse(response,"<H1>404 Not found</H1>");
     logmessage(server,response,"RESPONSE","404");
     makestandardheader(response,404,NULL,NULL,req->keepalive);
     sendresponse(server,response);
     finishresponse(server,response);
     }
    }else{
    putlinetoresponse(response,"<H1>500 Internal Server Error</H1>");
    logmessage(server,response,"RESPONSE","500");
    makestandardheader(response,500,NULL,NULL,req->keepalive);
    sendresponse(server,response);
    finishresponse(server,response);
    }
   deleteresponse(response);
   }
  }else{
  if(req->reqtype==FHTTPD_EXITOK){
   exit(0);
   }
  }
 deleterequest(req);
 req=NULL;
 setalarm(idle_timeout);
 }
if(global_alarmflag){
 setalarm(idle_timeout);
 if(server->infd==0&&server->outfd==1) requestexit(server,1); 
  //auto-exit only if started from server
 }else return 1;
}
}