/*
 * FTP/HTTP daemon
 * configfile.cc Copyright (C) 1995, 96 Alex Belits
 *
 * This source/code is public free; you can distribute it and/or modify
 * it under terms of the GNU General Public License (published by the
 * Free Software Foundation) either version two of this License, or any
 * later version.
 *
 */

#include "fhttpd.h"
#include "configargs.h"
#include "process.h"

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"};

int map_username=0;
char *default_header=NULL,*default_footer=NULL,*userhomedir=NULL;
int honorkeepalive=0;
int global_resolve_hostnames=1;
int global_umask=0;
int http_server_port=WEBSERVER,ftp_server_port=FTPSERVER,process_server_port=PROCESSSERVER;
__s32 http_server_addr=0,ftp_server_addr=0,process_server_addr=0;

List inbounds,pipeinexec,pipeoutexec,pipeinpermanent,pipeoutpermanent,getrules,
     types,dirtypes,executables,specialexecutables,accessrealms,accessrights,loadedfiles,addressroots,
     stor_modelist,mkd_modelist,applist,logapplications;


void unconfig(void){
ConfigArgs *currargs;
Application *currapp;
ModeArgs *currmodeargs;
TypeArgs *currtypeargs;
AddressRoot *curraddressroot;
AccessRights *currrights;
AccessRealm *currrealm;
LoadedFile *currloadedfile;
honorkeepalive=0;
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;
map_username=0;
global_umask=0;
if(globalhttppw){
 if(globalhttppw->pw_dir) free(globalhttppw->pw_dir);
 globalhttppw->pw_dir=NULL;
 }
max_content_length=MAX_CONTENT_LENGTH;
max_message_size=MAX_MESSAGE_SIZE;
max_totalsize=MAX_TOTALSIZE;
max_totallogmessagessize=MAX_TOTALMESSAGESIZE;
while((currapp=(Application*)applist.start)){
 delete currapp;
 }
while((currapp=(Application*)logapplications.start)){
 delete currapp;
 }
while((currmodeargs=(ModeArgs*)stor_modelist.start)){
 delete currmodeargs;
 }
while((currmodeargs=(ModeArgs*)mkd_modelist.start)){
 delete currmodeargs;
 }
while((currargs=(ConfigArgs*)inbounds.start)){
 delete currargs;
 }
while((currargs=(ConfigArgs*)pipeinexec.start)){
 delete currargs;
 }
while((currargs=(ConfigArgs*)pipeoutexec.start)){
 delete currargs;
 }
while((currtypeargs=(TypeArgs*)types.start)){
 delete currtypeargs;
 }
while((currtypeargs=(TypeArgs*)dirtypes.start)){
 delete currtypeargs;
 }
while((currargs=(ConfigArgs*)getrules.start)){
 delete currargs;
 }
while((currargs=(ConfigArgs*)executables.start)){
 delete currargs;
 }
while((currargs=(ConfigArgs*)specialexecutables.start)){
 delete currargs;
 }
while((curraddressroot=(AddressRoot*)addressroots.start)){
 delete curraddressroot;
 }
while((currrights=(AccessRights*)accessrights.start)){
 delete currrights;
 }
while((currrealm=(AccessRealm*)accessrealms.start)){
 delete currrealm;
 }
while((currloadedfile=(LoadedFile*)loadedfiles.start)){
 delete currloadedfile;
 }
}

static int first_time_config=1;

int readconfig(char *name){
char buffer[MESSAGE_BUFFER_SIZE],*p,*p1,*param[20],*tmpparam[20],*pcolon;
int i,ii,j,l,nparam,nline=0,octvalue;
FILE *f;
ConfigArgs* args;
AccessRights* rightsargs;
AccessRealm* realmargs;
TypeArgs* currtype;
LoadedFile* currloadedfile;
struct hostent *currhostent;
int currip;
AddressRoot *curraddressroot;
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.\r\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.\r\n",nline);
       }
      break;
     case HONORKEEPALIVE:
      if(nparam==1){
       honorkeepalive=1;
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"HonorKeepAlive\" has no parameters.\r\n",nline);
       }
      break;
     case HTTPPORT:
      if(nparam==2){
       if(first_time_config){
        pcolon=strchr(param[1],':');
        if(pcolon){
         *pcolon=0;
         if(param[1][0]>='0'&&param[1][0]<='9'){
          currip=inet_addr(param[1]);
          }else{
          currhostent=gethostbyname(param[1]);
          if(currhostent){
           currip=((struct in_addr*)(currhostent->h_addr))->s_addr;
           }else{
           currip=-1;
           }
	  }
         if(currip==-1){
          fprintf(stderr,"fhttpd: config line %d - Wrong hostname.\r\n",nline);
          }else{
          http_server_addr=htonl(currip);
          }
         pcolon++;
	 }else pcolon=param[1];
        http_server_port=atoi(pcolon);
        }else{
        fprintf(stderr,"fhttpd: config line %d - \"HTTPPort\" can't be reassigned.\r\n",nline);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"HTTPPort\" should have one parameter.\r\n",nline);
       }
      break;
     case FTPPORT:
      if(nparam==2){
       if(first_time_config){
        pcolon=strchr(param[1],':');
        if(pcolon){
         *pcolon=0;
         if(param[1][0]>='0'&&param[1][0]<='9'){
          currip=inet_addr(param[1]);
          }else{
          currhostent=gethostbyname(param[1]);
          if(currhostent){
           currip=((struct in_addr*)(currhostent->h_addr))->s_addr;
           }else{
           currip=-1;
           }
	  }
         if(currip==-1){
          fprintf(stderr,"fhttpd: config line %d - Wrong hostname.\r\n",nline);
          }else{
          ftp_server_addr=htonl(currip);
          }
         pcolon++;
	 }else pcolon=param[1];
        ftp_server_port=atoi(pcolon);
        }else{
        fprintf(stderr,"fhttpd: config line %d - \"FTPPort\" can't be reassigned.\r\n",nline);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"FTPPort\" should have one parameter.\r\n",nline);
       }
      break;
     case PROCESSPORT:
      if(nparam==2){
       if(first_time_config){
        pcolon=strchr(param[1],':');
        if(pcolon){
         *pcolon=0;
         if(param[1][0]>='0'&&param[1][0]<='9'){
          currip=inet_addr(param[1]);
          }else{
          currhostent=gethostbyname(param[1]);
          if(currhostent){
           currip=((struct in_addr*)(currhostent->h_addr))->s_addr;
           }else{
           currip=-1;
           }
	  }
         if(currip==-1){
          fprintf(stderr,"fhttpd: config line %d - Wrong hostname.\r\n",nline);
          }else{
          process_server_addr=htonl(currip);
          }
         pcolon++;
	 }else pcolon=param[1];
        process_server_port=atoi(pcolon);
        }else{
        fprintf(stderr,"fhttpd: config line %d - \"ProcessPort\" can't be reassigned.\r\n",nline);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"ProcessPort\" should have one parameter.\r\n",nline);
       }
      break;
     case INBOUND:
     case ABSINBOUND:
      if(nparam==2){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       args=new ConfigArgs(1,param+1,i==ABSINBOUND);
       if(args){
        inbounds.Add(args);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"[Abs]Inbound\" should have one parameter.\r\n",nline);
       }
      break;
     case UMASK:
      if(nparam==2){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[1])==4){
        if(param[1][0]=='0'
         &&param[1][1]>='0'&&param[1][1]<='7'
         &&param[1][2]>='0'&&param[1][2]<='7'
	 &&param[1][3]>='0'&&param[1][3]<='7'){
         global_umask=0;
         global_umask=(int)strtol(param[1],(char**)NULL,8);
	 }else{
         fprintf(stderr,"fhttpd: config line %d - Not an octal number.\r\n",nline);
         }
        }else{
        fprintf(stderr,"fhttpd: config line %d - Mode must be a 4-digit octal number.\r\n",nline);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"umask\" should have one parameter.\r\n",nline);
       }
      break;
     case STORMODE:
     case ABSSTORMODE:
     case MKDMODE:
     case ABSMKDMODE:
      if(nparam==3){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])==4){
        if(param[2][0]=='0'
         &&param[2][1]>='0'&&param[2][1]<='7'
         &&param[2][2]>='0'&&param[2][2]<='7'
	 &&param[2][3]>='0'&&param[2][3]<='7'){
         octvalue=0;
         octvalue=(int)strtol(param[2],(char**)NULL,8);
         args=new ModeArgs(1,param+1,octvalue,i==ABSSTORMODE||i==ABSMKDMODE);
         if(args){
          if(i==STORMODE||i==ABSSTORMODE){
           stor_modelist.Add(args);
	   }else{
           mkd_modelist.Add(args);
	   }
          }
	 }else{
         fprintf(stderr,"fhttpd: config line %d - Not an octal number.\r\n",nline);
         }
        }else{
        fprintf(stderr,"fhttpd: config line %d - Mode must be a 4-digit octal number.\r\n",nline);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"[Abs]StorMode\" should have 2 parameters.\r\n",nline);
       }
      break;
     case PIPEINEXEC:
     case ABSPIPEINEXEC:
      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==ABSPIPEINEXEC);
       if(args){
        pipeinexec.Add(args);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - Not enough parameters.\r\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.\r\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];
        }
       if(default_header) free(default_header);
       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.\r\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];
        }
       if(default_footer) free(default_footer);
       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.\r\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.\r\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.\r\n",nline);
       }
      break;
     case GETRULE:
     case ABSGETRULE:
      if(nparam>=7){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[3])>MAXPATHLEN) param[3][MAXPATHLEN+1]=0;
       if(strlen(param[5])>MAXPATHLEN) param[5][MAXPATHLEN+1]=0;
       if(nparam>7)
        if(strlen(param[7])>MAXPATHLEN) param[7][MAXPATHLEN+1]=0;
       strupr(param[2]);
       strupr(param[4]);
       strupr(param[6]);
       if(!strcmp(param[2],"EQ")||!strcmp(param[2],"NE")
         ||!strcmp(param[2],"EQCI")||!strcmp(param[2],"NECI")){
        if(!strcmp(param[4],"NAMEEQ")||!strcmp(param[4],"NAMENE")
          ||!strcmp(param[4],"NAMEEQCI")||!strcmp(param[4],"NAMENECI")){
         if(!strcmp(param[6],"BASEDIR")||!strcmp(param[6],"CWD")||!strcmp(param[6],"NAME")){
          args=new ConfigArgs(nparam-1,param+1,i==ABSGETRULE);
          if(args){
           getrules.Add(args);
           }         
	  }else{
          fprintf(stderr,"fhttpd: config line %d - syntax error.\r\n",nline);
          }
	 }else{
         fprintf(stderr,"fhttpd: config line %d - syntax error.\r\n",nline);
         }
	}else{
        fprintf(stderr,"fhttpd: config line %d - syntax error.\r\n",nline);
        }
       }else{

       if(nparam>=5){
        if(strlen(param[3])>MAXPATHLEN) param[3][MAXPATHLEN+1]=0;
        if(nparam>5)
         if(strlen(param[5])>MAXPATHLEN) param[5][MAXPATHLEN+1]=0;
        strupr(param[1]);
        strupr(param[2]);
        strupr(param[4]);
        if(!strcmp(param[1],"UNCONDITIONAL")){
         if(!strcmp(param[2],"NAMEEQ")||!strcmp(param[2],"NAMENE")){
          if(!strcmp(param[4],"BASEDIR")||!strcmp(param[4],"CWD")||!strcmp(param[4],"NAME")){
           tmpparam[0]="";
           tmpparam[1]=param[1];
           tmpparam[2]="";
       
           for(ii=2;ii<nparam;ii++) tmpparam[ii+1]=param[ii];           
           
           args=new ConfigArgs(nparam+1,tmpparam,i==ABSGETRULE);
           if(args){
            getrules.Add(args);
            }         
	   }else{
           fprintf(stderr,"fhttpd: config line %d - syntax error.\r\n",nline);
           }
	  }else{
          fprintf(stderr,"fhttpd: config line %d - syntax error.\r\n",nline);
          }
	 }else{
         fprintf(stderr,"fhttpd: config line %d - syntax error.\r\n",nline);
         }
        }else{
        fprintf(stderr,"fhttpd: config line %d - syntax error.\r\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.\r\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.\r\n",nline);
       }
      break;
     case ACCESSREALM:
      if(nparam==3){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       realmargs=new AccessRealm(param[1],param[2]);
       if(realmargs){
        realmargs->readfile();
        accessrealms.Add(realmargs);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"AccessRealm\" should have 2 parameters.\r\n",nline);
       }
      break;
     case ACCESSRIGHTS:
      if(nparam>=3){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       rightsargs=NULL;
       if(!strcasecmp(param[2],"restrict")||!strcasecmp(param[2],"allow")){
        if(nparam==3){
         rightsargs=new AccessRights(param[1],NULL,param[2]);
	 }else{
         fprintf(stderr,"fhttpd: config line %d - Too many parameters.\r\n",nline);
	 }
        }else{
        realmargs=(AccessRealm*)accessrealms.Find(param[2]);
        if(realmargs){
	 if(nparam>3){
          if(strlen(param[3])>MAXPATHLEN) param[3][MAXPATHLEN+1]=0;
          rightsargs=new AccessRights(param[1],realmargs,param[3]);
	  }else{
          fprintf(stderr,"fhttpd: config line %d - No username.\r\n",nline);
	  }
	 }else{
         fprintf(stderr,"fhttpd: config line %d - No such realm.\r\n",nline);
	 }
        }
       if(rightsargs){
        accessrights.Add(rightsargs);
        }else{
        fprintf(stderr,"fhttpd: config line %d - Rights record not added.\r\n",nline);
        }
       }else{
       fprintf(stderr,"fhttpd: config line %d - Not enough parameters.\r\n",nline);
       }
      break;
     case PRELOAD:
      if(nparam>=3){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       currloadedfile=NULL;
       if(nparam==4){
        if(param[3][0]>='0'&&param[3][0]<='9'){
         currip=inet_addr(param[3]);
         }else{
         currhostent=gethostbyname(param[3]);
         if(currhostent){
          currip=((struct in_addr*)(currhostent->h_addr))->s_addr;
          }else{
          currip=-1;
          }
         }
        if(currip==-1){
         fprintf(stderr,"fhttpd: config line %d - Wrong hostname.\r\n",nline);
         }else{
         currloadedfile=new LoadedFile(param[1],param[2],currip);
         }
        }else{
        currloadedfile=new LoadedFile(param[1],param[2],-1);
        }
       if(currloadedfile){
	if(currloadedfile->size){
         loadedfiles.Add(currloadedfile);
	 }else{
         fprintf(stderr,"fhttpd: config line %d - Can't load file.\r\n",nline);
         delete currloadedfile;
         }
        }
       }else{ 
       fprintf(stderr,"fhttpd: config line %d - Wrong number of parameters.\r\n",nline);
       }
      break;
     case HTTPROOT:
      if(nparam==2){
       if(strlen(param[1])>MAXPATHLEN) param[1][MAXPATHLEN+1]=0;
       if(!diroverride){
	if(globalhttppw){
         if(globalhttppw->pw_dir) free(globalhttppw->pw_dir);
         globalhttppw->pw_dir=(char*)malloc(strlen(param[1])+1);
         if(globalhttppw->pw_dir){
          strcpy(globalhttppw->pw_dir,param[1]);
	  }else{
          fprintf(stderr,"fhttpd: config line %d - Insufficient memory.\r\n",nline);
	  }
	 }
	}else{
        fprintf(stderr,"fhttpd: config line %d - Directory already configured.\r\n",nline);
	}
       }else{ 
       fprintf(stderr,"fhttpd: config line %d - \"HTTPRoot\" should have one parameter.\r\n",nline);
       }
      break;
     case ADDRESSROOT:
      if(nparam==3){
       if(strlen(param[2])>MAXPATHLEN) param[2][MAXPATHLEN+1]=0;
       if(param[1][0]>='0'&&param[1][0]<='9'){
        currip=inet_addr(param[1]);
        }else{
        currhostent=gethostbyname(param[1]);
        if(currhostent){
         currip=((struct in_addr*)(currhostent->h_addr))->s_addr;
         }else{
         currip=-1;
         }
        }
       if(currip==-1){
        fprintf(stderr,"fhttpd: config line %d - Wrong hostname.\r\n",nline);
        }else{
        curraddressroot=new AddressRoot(currip,param[1],param[2]);
        if(curraddressroot) addressroots.Add(curraddressroot);
        }
       }else{ 
       fprintf(stderr,"fhttpd: config line %d - \"AddressRoot\" should have 2 parameters.\r\n",nline);
       }
      break;
     case LOGAPPLICATION:
     case AUTHAPPLICATION:
     case APPLICATION:
      {
      class Application *currapp;
      int requests=0,instances=0,usesocket=0,cmdcount=0,instancesforuid=0,
      authentication=0;
      char *mappedname=NULL;
      char *pathname=NULL;
      char *cmdline[20];
      char *ptmp;
      if(i==AUTHAPPLICATION) authentication=1;
      if(nparam>=9){
       cmdcount=nparam-7;
       for(ii=8;ii<nparam;ii++){
        cmdline[ii-7]=param[ii];
        }
       cmdline[nparam-7]=NULL;
       cmdcount=nparam-7;
       if(i!=LOGAPPLICATION){
        if(!strcmp("-s",param[8])) usesocket=1;
         else
         if(!strcmp("-p",param[8])) usesocket=0;
          else
fprintf(stderr,"fhttpd: config line %d - Wrong parameter 9, should be \"-p\" or \"-s\" -- ignored.\r\n",nline);
        }
       }
      if(nparam>=8){
       if(strlen(param[7])>MAXPATHLEN) param[7][MAXPATHLEN+1]=0;
       pathname=param[7];
       }
      if(nparam>=7){
       if(strlen(param[6])>MAXPATHLEN) param[6][MAXPATHLEN+1]=0;
       mappedname=param[6];
       }
      if(nparam>=6){
       if(param[5][0]<'0'||param[5][0]>'9') requests=-1; 
        else requests=atoi(param[5]);
       }
      if(nparam>=5){
       if(param[4][0]<'0'||param[4][0]>'9') instances=-1;
        else{
        ptmp=strchr(param[4],',');
        if(ptmp){
         *ptmp=0;
         instancesforuid=atoi(ptmp+1);
	 }
        instances=atoi(param[4]);
        if(ptmp){
         *ptmp=',';
	 }
	}
       }
      if(nparam>=4){
       if(requests==-1)
        fprintf(stderr,"fhttpd: config line %d - Wrong requests limit.\r\n",
         nline);
        else 
        if(instances==-1)
         fprintf(stderr,"fhttpd: config line %d - Wrong instances limit.\r\n",
          nline);
         else{
         cmdline[0]=pathname;
         if(!cmdcount){
          cmdcount=1;
          cmdline[1]=NULL;
	  }
         currapp=new Application(processserver,param[1],param[2],param[3],
          requests,instances,mappedname,pathname,cmdcount,cmdline,
          -1,usesocket,instancesforuid,authentication);
         if(currapp){
	  if(i==LOGAPPLICATION){
           logapplications.Add(currapp);
	   }else{
           applist.Add(currapp);
	   }
          }
         }
        }else{
        fprintf(stderr,"fhttpd: config line %d - Wrong number of parameters.\r\n",nline);
        }
       }
      break;
     case MAXCONTENTLENGTH:
      if(nparam==2){
       max_content_length=atoi(param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"MaxContentLength\" should have one parameter.\r\n",nline);
       }
      break;
     case MAXMESSAGESIZE:
      if(nparam==2){
       max_message_size=atoi(param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"MaxMessageSize\" should have one parameter.\r\n",nline);
       }
      break;
     case MAXDATAINQUEUE:
      if(nparam==2){
       max_totalsize=atoi(param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"MaxDataInQueue\" should have one parameter.\r\n",nline);
       }
      break;
     case MAXDATAINLOGQUEUE:
      if(nparam==2){
       max_totallogmessagessize=atoi(param[1]);
       }else{
       fprintf(stderr,"fhttpd: config line %d - \"MaxDataInLogQueue\" should have one parameter.\r\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.\r\n",nline);
       }
      break;
     case MAPUSERDIR: 
      if(nparam==1) map_username=1;
       else fprintf(stderr,"fhttpd: config line %d - \"MapUserDir\" has no parameters.\r\n",nline);
     }
    }
   }
  }
 fclose(f);
 first_time_config=0;
 if(!diroverride){
  if(globalhttppw&&original_rootdir){
   if(!globalhttppw->pw_dir){
    globalhttppw->pw_dir=(char*)malloc(strlen(original_rootdir)+1);
    if(globalhttppw->pw_dir){
     strcpy(globalhttppw->pw_dir,original_rootdir);
     }else globalhttppw=NULL;
    }
   }
  }else{
  if(globalhttppw){
   globalhttppw->pw_dir=(char*)malloc(strlen(diroverride)+1);
   if(globalhttppw->pw_dir){
    strcpy(globalhttppw->pw_dir,diroverride);
    }else globalhttppw=NULL;
   }
  }
 return 0;
 }
return -1;
}

int reloadpasswdflag=0;