phunix/commands/httpd/config.c

/* config.c by Michael Temari 02/26/96
 *
 * This file is part of httpd.
 *
 * 02/26/1996 			Michael Temari <Michael@TemWare.Com>
 * 07/07/1996 Initial Release	Michael Temari <Michael@TemWare.Com>
 * 12/29/2002 			Michael Temari <Michael@TemWare.Com>
 *
 */
#include <sys/types.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <pwd.h>

#include "utility.h"
#include "config.h"

struct mtype *mtype = NULL;
struct msufx *msufx = NULL;
struct vhost *vhost = NULL;
struct vpath *vpath = NULL;
struct dirsend *dirsend = NULL;
struct auth *auth = NULL;
struct auth *proxyauth = NULL;
char *direxec = NULL;
char *srvrroot = "";
char *LogFile = NULL;
char *DbgFile = NULL;
char *User = NULL;
char *Chroot = NULL;

_PROTOTYPE(static int doconfig, (char *cfg_file));
_PROTOTYPE(static int doinclude, (char *parms[], int np));
_PROTOTYPE(static int domtype, (char *parms[], int np));
_PROTOTYPE(static struct auth *findauth, (char *name));
_PROTOTYPE(static int dovhost, (char *parms[], int np));
_PROTOTYPE(static int dovpath, (char *parms[], int np));
_PROTOTYPE(static int dosrvrroot, (char *parms[], int np));
_PROTOTYPE(static int dodirsend, (char *parms[], int np));
_PROTOTYPE(static int dodirexec, (char *parms[], int np));
_PROTOTYPE(static char *subvpath, (char *s));
_PROTOTYPE(static int dologfile, (char *parms[], int np));
_PROTOTYPE(static int dodbgfile, (char *parms[], int np));
_PROTOTYPE(static int douser, (char *parms[], int np));
_PROTOTYPE(static int dochroot, (char *parms[], int np));
_PROTOTYPE(static int adduser, (struct auth *pauth, char *user));
_PROTOTYPE(static int doauth, (char *parms[], int np));
_PROTOTYPE(static int doproxyauth, (char *parms[], int np));

int readconfig(cfg_file, testing)
char *cfg_file;
int testing;
{
int s;
char *cfg;
struct msufx *ps;
struct mtype *pt;
struct vhost *ph;
struct vpath *pv;
struct dirsend *pd;
struct auth *pa;

   cfg = HTTPD_CONFIG_FILE;
   if(cfg_file != (char *)NULL)
	if(*cfg_file)
		cfg = cfg_file;

   s = doconfig(cfg);

   if(testing) {
	printf("ServerRoot: %s\n", srvrroot);
	printf("UserName: %s\n", User == NULL ? "" : User);
	printf("Chroot: %s\n", Chroot == NULL ? "" : Chroot);
	printf("LogFile: %s\n", LogFile == NULL ? "" : LogFile);
	printf("DbgFile: %s\n", DbgFile == NULL ? "" : DbgFile);
	printf("DirSend:");
	for(pd = dirsend; pd != NULL; pd = pd->next)
   		printf(" %s", pd->file);
	printf("\n");
	printf("DirExec: %s\n", direxec == NULL ? "" : direxec);
	for(ph = vhost; ph != NULL; ph = ph->next)
		printf("VHost: %s %s\n", ph->hname, ph->root);
	for(pa = auth; pa != NULL; pa = pa->next)
   		printf("Auth: %s %s %d %s\n",
			pa->name, pa->desc, pa->urlaccess, pa->passwdfile);
	for(pa = proxyauth; pa != NULL; pa = pa->next)
   		printf("ProxyAuth: %s %s %d %s\n",
			pa->name, pa->desc, pa->urlaccess, pa->passwdfile);
	for(pv = vpath; pv != NULL; pv = pv->next)
   		printf("Vpath: %s %s %s %d\n",
			pv->from, pv->to, pv->auth->name, pv->urlaccess);
	for(pt = mtype; pt != NULL; pt = pt->next) {
   		printf("MType: %s :", pt->mimetype);
		for(ps = pt->msufx; ps != NULL; ps = ps->tnext)
		   	printf(" '%s'", ps->suffix);
		printf("\n");
	}
	for(ps = msufx; ps != NULL; ps = ps->snext)
   		printf("Suffix: %s\t%s\n", ps->suffix, ps->mtype->mimetype);
   }

   return(s);
}

static int doconfig(cfg_file)
char *cfg_file;
{
FILE *fp;
int np;
int s;
char *p;
char ltype[40];
char *parms[30];
static char buffer[2048];

   if((fp = fopen(cfg_file, "r")) == (FILE *)NULL) {
   	fprintf(stderr, "httpd: Could not read %s config file.\n", cfg_file);
	return(-1);
   }

   *ltype = '\0';

   while(fgets(buffer, sizeof(buffer), fp) != (char *)NULL) {
   	if(buffer[0] == '#') continue;	/* skip comments */
   	np = getparms(buffer, parms, sizeof(parms)/sizeof(parms[0]));
   	if(np == 0) continue;	/* blank line */
   	if(parms[0] == (char *)NULL)
   		parms[0] = ltype;
   	else {
   		p = parms[0];
   		while(*p) *p++ = tolower(*p);
   		strncpy(ltype, parms[0], sizeof(ltype));
   	}
   	s = 0;
   	if(!strcmp(parms[0], "mtype")) s = domtype(parms, np);
   	else
   	if(!strcmp(parms[0], "vhost")) s = dovhost(parms, np);
   	else
   	if(!strcmp(parms[0], "vpath")) s = dovpath(parms, np);
   	else
   	if(!strcmp(parms[0], "serverroot")) s = dosrvrroot(parms, np);
   	else
   	if(!strcmp(parms[0], "dirsend")) s = dodirsend(parms, np);
   	else
   	if(!strcmp(parms[0], "direxec")) s = dodirexec(parms, np);
   	else
   	if(!strcmp(parms[0], "logfile")) s = dologfile(parms, np);
   	else
   	if(!strcmp(parms[0], "dbgfile")) s = dodbgfile(parms, np);
   	else
   	if(!strcmp(parms[0], "user")) s = douser(parms, np);
   	else
   	if(!strcmp(parms[0], "chroot")) s = dochroot(parms, np);
   	else
   	if(!strcmp(parms[0], "auth")) s = doauth(parms, np);
   	else
   	if(!strcmp(parms[0], "proxyauth")) s = doproxyauth(parms, np);
   	else
	if(!strcmp(parms[0], "include")) s = doinclude(parms, np);
	else
   	fprintf(stderr, "httpd: Unknown directive: %s\n", parms[0]);
   	if(s) {
   		fprintf(stderr, "httpd: Error processing config file\n");
		fclose(fp);
   		return(-1);
   	}
   }

   fclose(fp);

   return(0);
}

static int doinclude(parms, np)
char *parms[];
int np;
{
char *p;

   if(np < 2) return(0);

   p = subvpath(parms[1]);

   return(doconfig(p));
}

static int domtype(parms, np)
char *parms[];
int np;
{
int i;
struct mtype *pt, *lpt, *newpt;
struct msufx *ps, *lps, *newps, *psend;

   if(np < 2) return(0);


   /* check if this mime type already exists in the list */
   for(pt = mtype, lpt = NULL; pt != NULL; lpt = pt, pt = pt->next)
   	if(!strcmp(parms[1], pt->mimetype))
   		break;

   if(pt == NULL) {		/* not there so add it */
   	newpt = malloc(sizeof(struct mtype));
   	if(newpt == NULL) {
   		fprintf(stderr, "httpd: malloc failed in domtype\n");
   		return(-1);
   	}
   	newpt->mimetype = malloc(strlen(parms[1])+1);
   	if(newpt->mimetype == NULL) {
   		fprintf(stderr, "httpd: malloc failed in domtype\n");
   		return(-1);
   	}
   	strcpy(newpt->mimetype, parms[1]);
   	newpt->msufx = NULL;
   	newpt->next = NULL;
   	if(lpt == NULL)
   		mtype = newpt;
   	else
   		lpt->next = newpt;
   } else
   	newpt = pt;

   /* find end of suffix list */
   for(ps = newpt->msufx, lps = NULL; ps != NULL; lps = ps, ps = ps->tnext) ;
   psend = lps;

   /* if no suffix given then add empty suffix for default */
   if(np == 2)
   	strcpy(parms[np++], "");

   /* add each suffix to the mime type */
   for(i = 2; i < np; i++) {
	/* a suffix can only be for a single mime type */
	for(ps = msufx, lps = NULL; ps != NULL; lps = ps, ps = ps->snext) {
		if(!strcmp(ps->suffix, parms[i])) {
			fprintf(stderr, "httpd: Suffix already found\n");
			return(-1);
		}
		if(strlen(parms[i]) > strlen(ps->suffix)) break;
	}
	newps = malloc(sizeof(struct msufx));
	if(newps == NULL) {
   		fprintf(stderr, "httpd: malloc failed in domtype\n");
   		return(-1);
   	}
	newps->suffix = malloc(strlen(parms[i])+1);
	if(newps->suffix == NULL) {
   		fprintf(stderr, "httpd: malloc failed in domtype\n");
   		return(-1);
   	}
	strcpy(newps->suffix, parms[i]);
	newps->mtype = newpt;
	newps->snext = NULL;
	newps->tnext = NULL;
	if(lps == NULL) {
		msufx = newps;
		newps->snext = ps;
	} else {
		lps->snext = newps;
		newps->snext = ps;
	}
	if(psend == NULL)
		newpt->msufx = newps;
	else
		psend->tnext = newps;
	psend = newps;
   }

   return(0);
}

static struct auth *findauth(name)
char *name;
{
char lname[80];
char *p, *p2;
struct auth *a = NULL;

   if(sizeof(lname) < (strlen(name)+1)) {
   	fprintf(stderr, "httpd: lname too small in findauth\n");
   	return(a);
   }
   p = name; p2 = lname;
   while(*p)
	*p2++ = tolower(*p++);
   *p2 = '\0';

   for(a = auth; a != NULL; a = a->next)
	if(!strcmp(a->name, lname)) break;

   return(a);
}

static int dovhost(parms, np)
char *parms[];
int np;
{
char *hname, *root;
struct vhost *ph, *lph, *newph;

   if(np < 2) return(0);

   hname = parms[1];

   if(np < 3)
   	root = "";
   else
	root = parms[2];

   for(ph = vhost, lph = NULL; ph != NULL; lph = ph, ph = ph->next)
	;

   newph = malloc(sizeof(struct vhost));
   if(newph == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dovhost\n");
   	return(-1);
   }
   newph->hname = malloc(strlen(hname)+1);
   if(newph->hname == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dovhost\n");
   	return(-1);
   }
   strcpy(newph->hname, hname);

   root = subvpath(root);

   newph->root = malloc(strlen(root)+1);
   if(newph->root == NULL) {
	fprintf(stderr, "httpd: malloc failed in dovhost\n");
   	return(-1);
   }
   strcpy(newph->root, root);

   if(np > 3)
   	if(parms[3][0] != '#') {
		fprintf(stderr, "httpd: junk at end of vhost line\n");
   		return(-1);
   	}

   newph->next = NULL;
   if(lph == NULL) {
	vhost = newph;
	newph->next = ph;
   } else {
	lph->next = newph;
	newph->next = ph;
   }

   return(0);
}

static int dovpath(parms, np)
char *parms[];
int np;
{
char *from, *to;
struct vpath *pv, *lpv, *newpv;

   if(np < 3) return(0);

   from = parms[1];
   to = parms[2];

   for(pv = vpath, lpv = NULL; pv != NULL; lpv = pv, pv = pv->next)
	;

   newpv = malloc(sizeof(struct vpath));
   if(newpv == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dovpath\n");
   	return(-1);
   }
   newpv->from = malloc(strlen(from)+1);
   if(newpv->from == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dovpath\n");
   	return(-1);
   }
   strcpy(newpv->from, from);

   to = subvpath(to);

   newpv->to = malloc(strlen(to)+1);
   if(newpv->to == NULL) {
	fprintf(stderr, "httpd: malloc failed in dovpath\n");
   	return(-1);
   }
   strcpy(newpv->to, to);

   newpv->auth = NULL;
   newpv->urlaccess = -1;

   if(np > 3)
   	if(parms[3][0] != '#') {
   		newpv->auth = findauth(parms[3]);
   		if(np > 4)
			if(parms[4][0] != '#') {
				newpv->urlaccess = mkurlaccess(parms[4]);
				if(np > 5)
   					if(parms[5][0] != '#') {
   						fprintf(stderr, "httpd: junk at end of vpath line\n");
   						return(-1);
   					}
			}
   	}

   newpv->next = NULL;
   if(lpv == NULL) {
	vpath = newpv;
	newpv->next = pv;
   } else {
	lpv->next = newpv;
	newpv->next = pv;
   }

   return(0);
}

static int dosrvrroot(parms, np)
char *parms[];
int np;
{
char *newroot;

   if(np < 2) return(0);

   newroot = subvpath(parms[1]);

   srvrroot = malloc(strlen(newroot)+1);
   if(srvrroot == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dosrvrroot\n");
   	return(-1);
   }
   strcpy(srvrroot, newroot);
   if(srvrroot[strlen(srvrroot)-1] == '/')
   	srvrroot[strlen(srvrroot)-1] = '\0';

   return(0);
}

static int dodirsend(parms, np)
char *parms[];
int np;
{
char *file;
int i;
struct dirsend *pd, *lpd, *npd;

   if(np < 2) return(0);

   /* find end of the list */
   for(pd = dirsend, lpd = NULL; pd != NULL; lpd = pd, pd = pd->next) ;

   for(i = 1; i < np; i++) {
   	file = parms[i];
   	if(file[0] == '#') break;
	npd = malloc(sizeof(struct dirsend));
	if(npd == NULL) {
   		fprintf(stderr, "httpd: malloc failed in dodirsend\n");
   		return(-1);
	}
	npd->file = malloc(strlen(file)+1);
	if(npd->file == NULL) {
		fprintf(stderr, "httpd: malloc failed in dodirsend\n");
		return(-1);
	}
	strcpy(npd->file, file);
	npd->next = NULL;
	if(lpd == NULL)
		dirsend = npd;
	else
		lpd->next = npd;
	lpd = npd;
   }

   return(0);
}

static int dodirexec(parms, np)
char *parms[];
int np;
{
char *file;

   if(np < 2) return(0);

   if(direxec != NULL) {
   	fprintf(stderr, "httpd: Error direxec line already present\n");
   	return(-1);
   }

   file = subvpath(parms[1]);

   direxec = malloc(strlen(file)+1);

   if(direxec == NULL) {
	fprintf(stderr, "httpd: malloc failed in dodirexec\n");
   	return(-1);
   }

   strcpy(direxec, file);

   if(np > 2)
   	if(parms[2][0] != '#') {
   		fprintf(stderr, "httpd: garbage on end of direxec line\n");
   		return(-1);
   	}

   return(0);
}

static char *subvpath(s)
char *s;
{
char *p, *p2;
int len;
static char buffer[1024];
char user[80];
struct passwd *pwd;

   /* replace beginning // with srvrroot */
   if(s[0] == '/' && s[1] == '/')
   	/* but not /// if we have VHOST's */
   	if(vhost == NULL || s[2] != '/') {
   		strcpy(buffer, srvrroot);
   		strncat(buffer, s+1, sizeof(buffer) - strlen(buffer));
   		buffer[sizeof(buffer)-1] = '\0';
   		return(buffer);
	}

   if(s[0] != '/' || s[1] != '~') return(s);

   /* replace beginning /~user with user home directory */
   p = s + 2;
   p2 = user;
   len = sizeof(user) - 1;
   while(*p && *p != '/' && len-- > 0) *p2++ = *p++;
   *p2 = '\0';
   if(*p != '\0' && *p != '/') return(s);
   if((pwd = getpwnam(user)) == (struct passwd *)NULL) return(s);
   strcpy(buffer, pwd->pw_dir);
   strncat(buffer, p, sizeof(buffer) - strlen(buffer));
   buffer[sizeof(buffer)-1] = '\0';

   return(buffer);
}

static int dologfile(parms, np)
char *parms[];
int np;
{
char *p;

   if(np < 2) return(0);

   p = subvpath(parms[1]);
   LogFile = malloc(strlen(p)+1);
   if(LogFile == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dologfile\n");
   	return(-1);
   }
   strcpy(LogFile, p);

   return(0);
}

static int dodbgfile(parms, np)
char *parms[];
int np;
{
char *p;

   if(np < 2) return(0);

   p = subvpath(parms[1]);
   DbgFile = malloc(strlen(p)+1);
   if(DbgFile == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dodbgfile\n");
   	return(-1);
   }
   strcpy(DbgFile, p);

   return(0);
}

static int douser(parms, np)
char *parms[];
int np;
{
   if(np < 2) return(0);

   User = malloc(strlen(parms[1])+1);
   if(User == NULL) {
   	fprintf(stderr, "httpd: malloc failed in douser\n");
   	return(-1);
   }
   strcpy(User, parms[1]);

   return(0);
}

static int dochroot(parms, np)
char *parms[];
int np;
{
char *newroot;

   if(np < 2) return(0);

   newroot = subvpath(parms[1]);

   Chroot = malloc(strlen(newroot)+1);
   if(Chroot == NULL) {
   	fprintf(stderr, "httpd: malloc failed in dochroot\n");
   	return(-1);
   }
   strcpy(Chroot, newroot);

   return(0);
}

static int adduser(pauth, user)
struct auth *pauth;
char *user;
{
struct authuser *pa, *lpa, *newpa;

   for(pa = pauth->users, lpa = NULL; pa != NULL; lpa = pa, pa = pa->next)
	;

   newpa = malloc(sizeof(struct authuser));
   if(newpa == NULL) {
   	fprintf(stderr, "httpd: malloc failed in adduser\n");
   	return(-1);
   }
   newpa->user = malloc(strlen(user)+1);
   if(newpa->user == NULL) {
   	fprintf(stderr, "httpd: malloc failed in adduser\n");
   	return(-1);
   }
   strcpy(newpa->user, user);

   newpa->next = NULL;
   if(lpa == NULL) {
	pauth->users = newpa;
	newpa->next = pa;
   } else {
	lpa->next = newpa;
	newpa->next = pa;
   }

   return(0);
}

static int doauth(parms, np)
char *parms[];
int np;
{
int i;
char *name, *desc, *pf;
char *p, *p2;
struct auth *pa, *lpa, *newpa;

   if(np < 3) return(0);

   name = parms[1];
   desc = parms[2];

   for(pa = auth, lpa = NULL; pa != NULL; lpa = pa, pa = pa->next)
	;

   newpa = malloc(sizeof(struct auth));
   if(newpa == NULL) {
   	fprintf(stderr, "httpd: malloc failed in doauth\n");
   	return(-1);
   }
   newpa->name = malloc(strlen(name)+1);
   if(newpa->name == NULL) {
   	fprintf(stderr, "httpd: malloc failed in doauth\n");
   	return(-1);
   }
   p = name; p2 = newpa->name;
   while(*p)
	*p2++ = tolower(*p++);
   *p2 = '\0';

   newpa->desc = malloc(strlen(desc)+1);
   if(newpa->desc == NULL) {
	fprintf(stderr, "httpd: malloc failed in doauth\n");
   	return(-1);
   }
   strcpy(newpa->desc, desc);

   newpa->urlaccess = mkurlaccess(parms[3]);
   newpa->passwdfile = NULL;
   newpa->users = NULL;

   if(np > 4)
   	if(parms[4][0] != '#') {
		if(!strcmp(parms[4], "."))
			pf = "/etc/passwd";
		else
			pf = subvpath(parms[4]);
   		newpa->passwdfile = malloc(strlen(pf)+1);
   		if(newpa->passwdfile == NULL) {
   			fprintf(stderr, "httpd: malloc failed in doauth\n");
   			return(-1);
   		}
   		strcpy(newpa->passwdfile, pf);
		i = 5;
		while(i < np) {
   			if(parms[i][0] == '#')
				break;
			if(adduser(newpa, parms[i]))
				return(-1);
			i++;
		}
   	}

   newpa->next = NULL;
   if(lpa == NULL) {
	auth = newpa;
	newpa->next = pa;
   } else {
	lpa->next = newpa;
	newpa->next = pa;
   }

   return(0);
}

static int doproxyauth(parms, np)
char *parms[];
int np;
{
int i;
char *name, *desc, *pf;
char *p, *p2;
struct auth *pa, *lpa, *newpa;

   if(np < 3) return(0);

   name = parms[1];
   desc = parms[2];

   if(proxyauth != (struct auth *)NULL) {
   	fprintf(stderr, "httpd: ProxyAuth defined multiple times using 1st only\n");
   	return(0);
   }

   for(pa = proxyauth, lpa = NULL; pa != NULL; lpa = pa, pa = pa->next)
	;

   newpa = malloc(sizeof(struct auth));
   if(newpa == NULL) {
   	fprintf(stderr, "httpd: malloc failed in doproxyauth\n");
   	return(-1);
   }
   newpa->name = malloc(strlen(name)+1);
   if(newpa->name == NULL) {
   	fprintf(stderr, "httpd: malloc failed in doproxyauth\n");
   	return(-1);
   }
   p = name; p2 = newpa->name;
   while(*p)
	*p2++ = tolower(*p++);
   *p2 = '\0';

   newpa->desc = malloc(strlen(desc)+1);
   if(newpa->desc == NULL) {
	fprintf(stderr, "httpd: malloc failed in doproxyauth\n");
   	return(-1);
   }
   strcpy(newpa->desc, desc);

   newpa->urlaccess = mkurlaccess(parms[3]);
   newpa->passwdfile = NULL;
   newpa->users = NULL;

   if(np > 4)
   	if(parms[4][0] != '#') {
		if(!strcmp(parms[4], "."))
			pf = "/etc/passwd";
		else
			pf = subvpath(parms[4]);
   		newpa->passwdfile = malloc(strlen(pf)+1);
   		if(newpa->passwdfile == NULL) {
   			fprintf(stderr, "httpd: malloc failed in doauth\n");
   			return(-1);
   		}
   		strcpy(newpa->passwdfile, pf);
		i = 5;
		while(i < np) {
   			if(parms[i][0] == '#')
				break;
			if(adduser(newpa, parms[i]))
				return(-1);
			i++;
		}
   	}

   newpa->next = NULL;
   if(lpa == NULL) {
	proxyauth = newpa;
	newpa->next = pa;
   } else {
	lpa->next = newpa;
	newpa->next = pa;
   }

   return(0);
}