qse/cmd/http/httpd.c

2923 lines
87 KiB
C

#include <qse/http/stdhttpd.h>
#include <qse/xli/stdxli.h>
#include <qse/cmn/main.h>
#include <qse/cmn/str.h>
#include <qse/cmn/mem.h>
#include <qse/cmn/mbwc.h>
#include <qse/cmn/time.h>
#include <qse/cmn/path.h>
#include <qse/cmn/opt.h>
#include <qse/cmn/htb.h>
#include <qse/cmn/fmt.h>
#include <qse/cmn/hton.h>
#include <signal.h>
#include <locale.h>
#include <stdio.h> /* TODO: remove this header file */
#include <stdlib.h>
#if defined(_WIN32)
# include <winsock2.h>
# include <windows.h>
# include <tchar.h>
# include <process.h>
#elif defined(__OS2__)
# define INCL_DOSPROCESS
# define INCL_DOSEXCEPTIONS
# define INCL_ERRORS
# include <os2.h>
#elif defined(__DOS__)
# include <dos.h>
# include <tcp.h> /* watt-32 */
#else
# include <unistd.h>
# include <errno.h>
# include <fcntl.h>
#endif
#if defined(HAVE_OPENSSL_SSL_H) && defined(HAVE_SSL)
# include <openssl/ssl.h>
# if defined(HAVE_OPENSSL_ERR_H)
# include <openssl/err.h>
# endif
# if defined(HAVE_OPENSSL_ENGINE_H)
# include <openssl/engine.h>
# endif
# define USE_SSL
#endif
#if defined(HAVE_SYS_PRCTL_H)
# include <sys/prctl.h>
#endif
#if defined(HAVE_SYS_TIME_H)
# include <sys/time.h>
#endif
#if defined(HAVE_SYS_RESOURCE_H)
# include <sys/resource.h>
#endif
/* --------------------------------------------------------------------- */
static qse_httpd_t* g_httpd = QSE_NULL;
static const qse_char_t* g_cfgfile = QSE_NULL;
static int g_daemon = 0;
static int g_debug = 0;
/* --------------------------------------------------------------------- */
enum
{
SCFG_SSLCERTFILE,
SCFG_SSLKEYFILE,
SCFG_MAX
};
enum
{
XCFG_ROOT,
XCFG_REALM,
XCFG_AUTH,
XCFG_DIRHEAD,
XCFG_DIRFOOT,
XCFG_ERRHEAD,
XCFG_ERRFOOT,
XCFG_MAX
};
struct cgi_t
{
enum
{
CGI_PREFIX,
CGI_SUFFIX,
CGI_NAME,
CGI_MAX
} type;
qse_mchar_t* spec;
int nph;
qse_mchar_t* shebang;
struct cgi_t* next;
};
struct auth_rule_t
{
enum {
AUTH_RULE_PREFIX,
AUTH_RULE_SUFFIX,
AUTH_RULE_NAME,
AUTH_RULE_OTHER,
AUTH_RULE_MAX
} type;
qse_mchar_t* spec;
/* TODO: add individual realm and auth string */
int noauth;
struct auth_rule_t* next;
};
struct mime_t
{
enum {
MIME_PREFIX,
MIME_SUFFIX,
MIME_NAME,
MIME_OTHER,
MIME_MAX
} type;
qse_mchar_t* spec;
qse_mchar_t* value;
struct mime_t* next;
};
struct access_t
{
/* TODO: support more types like ACCESS_GLOB
not-only the base name, find a way to use query path or xpath */
enum
{
ACCESS_PREFIX,
ACCESS_SUFFIX,
ACCESS_NAME,
ACCESS_OTHER,
ACCESS_MAX
} type;
qse_mchar_t* spec;
int value;
struct access_t* next;
};
typedef struct loccfg_t loccfg_t;
struct loccfg_t
{
qse_mcstr_t locname;
qse_mchar_t* xcfg[XCFG_MAX];
enum
{
ROOT_TYPE_PATH = 0,
ROOT_TYPE_NWAD,
ROOT_TYPE_NWAD_SECURE,
ROOT_TYPE_HOST,
ROOT_TYPE_HOST_SECURE,
ROOT_TYPE_RELOC,
ROOT_TYPE_ERROR
} root_type;
union
{
qse_nwad_t nwad;
const qse_mchar_t* host;
int error_code;
qse_httpd_rsrc_reloc_t reloc;
} root;
struct
{
qse_size_t count;
qse_mchar_t* files;
} index;
struct
{
struct cgi_t* head;
struct cgi_t* tail;
} cgi[CGI_MAX];
struct
{
struct auth_rule_t* head;
struct auth_rule_t* tail;
} auth_rule[AUTH_RULE_MAX];
struct
{
struct mime_t* head;
struct mime_t* tail;
} mime[MIME_MAX];
struct
{
struct access_t* head;
struct access_t* tail;
} access[2][ACCESS_MAX];
struct
{
unsigned int allow_http: 1;
unsigned int allow_https: 1;
unsigned int allow_connect: 1;
unsigned int allow_intercept: 2; /* 0: no, 1: proxy, 2: local */
unsigned int allow_upgrade: 1;
unsigned int dns_enabled: 1;
unsigned int urs_enabled: 1;
unsigned int x_forwarded: 1;
qse_nwad_t dns_nwad; /* TODO: multiple dns */
qse_nwad_t urs_nwad; /* TODO: multiple urs */
int dns_timeout;
int dns_retries;
int dns_queries;
int urs_timeout;
int urs_retries;
qse_httpd_mod_t* dns_preresolve_mod;
qse_httpd_mod_t* urs_prerewrite_mod;
qse_mchar_t pseudonym[128]; /* TODO: good size? */
} proxy;
loccfg_t* next;
};
typedef struct server_hostcfg_t server_hostcfg_t;
struct server_hostcfg_t
{
qse_mchar_t* hostname;
loccfg_t* loccfg;
server_hostcfg_t* next;
};
typedef struct server_xtn_t server_xtn_t;
struct server_xtn_t
{
int backlog_size;
int nodir; /* no directory listing */
int num; /* the server number in the xli configuration */
qse_nwad_t bind; /* binding address */
int secure; /* ssl */
qse_mchar_t* scfg[SCFG_MAX];
qse_httpd_serverstd_makersrc_t orgmakersrc;
qse_httpd_serverstd_freersrc_t orgfreersrc;
qse_httpd_serverstd_query_t orgquery;
qse_htb_t* cfgtab; /* key: host name, value: server_hostcfg_t */
};
/* --------------------------------------------------------------------- */
typedef struct httpd_xtn_t httpd_xtn_t;
struct httpd_xtn_t
{
const qse_char_t* cfgfile;
qse_xli_t* xli;
qse_httpd_impede_t org_impede;
int impede_code;
qse_httpd_urs_prerewrite_t org_urs_prerewrite;
loccfg_t dflcfg;
};
/* --------------------------------------------------------------------- */
static void sig_stop (int sig)
{
if (g_httpd) qse_httpd_stop (g_httpd);
}
static void sig_reconf (int sig)
{
if (g_httpd)
{
httpd_xtn_t* httpd_xtn;
httpd_xtn = qse_httpd_getxtn(g_httpd);
httpd_xtn->impede_code = sig;
qse_httpd_impede (g_httpd);
}
}
static void setup_signal_handler (int signum, void(*handler)(int))
{
#if defined(HAVE_SIGACTION)
struct sigaction act;
qse_memset (&act, 0, QSE_SIZEOF(act));
act.sa_handler = handler;
sigaction (signum, &act, QSE_NULL);
#else
signal (signum, handler);
#endif
}
static void setup_signal_handlers ()
{
#if defined(SIGINT)
setup_signal_handler (SIGINT, sig_stop);
#endif
#if defined(SIGTERM)
setup_signal_handler (SIGTERM, sig_stop);
#endif
#if defined(SIGHUP)
setup_signal_handler (SIGHUP, sig_reconf);
#endif
#if defined(SIGUSR1)
setup_signal_handler (SIGUSR1, sig_reconf);
#endif
#if defined(SIGPIPE)
setup_signal_handler (SIGPIPE, SIG_IGN);
#endif
}
static void restore_signal_handlers ()
{
#if defined(SIGINT)
setup_signal_handler (SIGINT, SIG_DFL);
#endif
#if defined(SIGTERM)
setup_signal_handler (SIGTERM, SIG_DFL);
#endif
#if defined(SIGHUP)
setup_signal_handler (SIGHUP, SIG_DFL);
#endif
#if defined(SIGUSR1)
setup_signal_handler (SIGUSR1, SIG_DFL);
#endif
#if defined(SIGPIPE)
setup_signal_handler (SIGPIPE, SIG_DFL);
#endif
}
static int daemonize (int devnull)
{
#if defined(HAVE_FORK)
switch (fork())
{
case -1: return -1;
case 0: break; /* child */
default: _exit (0); /* parent */
}
if (setsid () <= -1) return -1;
/*umask (0);*/
chdir ("/");
if (devnull)
{
/* redirect stdin/out/err to /dev/null */
int fd = open ("/dev/null", O_RDWR);
if (fd >= 0)
{
dup2 (fd, 0);
dup2 (fd, 1);
dup2 (fd, 2);
close (fd);
}
}
return 0;
#else
return -1;
#endif
}
/* --------------------------------------------------------------------- */
int xxxx (void* ctx, qse_env_char_t** envir)
{
/* NOTE: this is for experiment only */
#if 0
extern char** environ;
char buf[1000];
char* cl;
int cl_i = 0;
environ = envir;
printf ("Content-Type: text/html\n\n");
printf ("<html><body><pre>\n");
system ("ls -laF /tmp");
printf ("--------------------\n");
system ("printenv");
cl = getenv("CONTENT_LENGTH");
if (cl) cl_i = atoi(cl);
/*if (cl_i)
{ */
while (fgets (buf, sizeof(buf), stdin) != NULL)
{
printf ("%s", buf);
}
/*}
system ("while read xxx; do echo $xxx; done; echo 123 456 789");*/
printf ("</pre></body></html>\n");
#endif
printf ("Content-Type: text/html\n\n");
printf ("<html><body><pre>\n");
system ("ls -laF /tmp");
printf ("</pre></body></html>\n");
return 0;
}
static int make_resource (
qse_httpd_t* httpd, qse_httpd_client_t* client,
qse_htre_t* req, qse_httpd_rsrc_t* rsrc)
{
server_xtn_t* server_xtn;
server_xtn = qse_httpd_getserverxtn(httpd, client->server);
if (server_xtn->orgmakersrc (httpd, client, req, rsrc) <= -1) return -1;
if (server_xtn->nodir && rsrc->type == QSE_HTTPD_RSRC_DIR)
{
/* prohibit no directory listing */
server_xtn->orgfreersrc (httpd, client, req, rsrc);
rsrc->type = QSE_HTTPD_RSRC_ERROR;
rsrc->u.error.code = 403;
}
return 0;
}
static void free_resource (
qse_httpd_t* httpd, qse_httpd_client_t* client,
qse_htre_t* req, qse_httpd_rsrc_t* rsrc)
{
server_xtn_t* server_xtn;
server_xtn = qse_httpd_getserverxtn(httpd, client->server);
server_xtn->orgfreersrc (httpd, client, req, rsrc);
}
/* --------------------------------------------------------------------- */
static loccfg_t* find_loccfg (
qse_httpd_t* httpd, qse_htb_t* cfgtab,
const qse_mchar_t* host, qse_size_t hostlen, const qse_mchar_t* qpath)
{
qse_htb_pair_t* pair;
server_hostcfg_t* hostcfg;
loccfg_t* loccfg;
pair = qse_htb_search (cfgtab, host, hostlen);
if (pair)
{
hostcfg = (server_hostcfg_t*)QSE_HTB_VPTR(pair);
/* the location names are inspected in the order as shown
* in the configuration. */
for (loccfg = hostcfg->loccfg; loccfg; loccfg = loccfg->next)
{
QSE_ASSERT (loccfg->locname.len > 0);
if (qse_mbsbeg (qpath, loccfg->locname.ptr) &&
(loccfg->locname.ptr[loccfg->locname.len - 1] == QSE_MT('/') ||
qpath[loccfg->locname.len] == QSE_MT('/') ||
qpath[loccfg->locname.len] == QSE_MT('\0')))
{
return loccfg;
}
}
}
return QSE_NULL;
}
static int get_server_root (
qse_httpd_t* httpd,
qse_httpd_server_t* server,
loccfg_t* loccfg,
const qse_httpd_serverstd_query_info_t* qinfo,
qse_httpd_serverstd_root_t* root)
{
qse_http_method_t mth;
qse_mchar_t* qpath;
int proto_len;
qse_memset (root, 0, QSE_SIZEOF(*root));
mth = qse_htre_getqmethodtype (qinfo->req);
qpath = qse_htre_getqpath(qinfo->req);
qse_memset (root, 0, QSE_SIZEOF(*root));
if (qinfo->client->status & QSE_HTTPD_CLIENT_INTERCEPTED)
{
/* transparent proxying */
if (loccfg->proxy.allow_intercept <= 0)
{
root->type = QSE_HTTPD_SERVERSTD_ROOT_ERROR;
root->u.error.code = 403; /* forbidden */
return 0;
}
else if (loccfg->proxy.allow_intercept <= 1)
{
root->type = QSE_HTTPD_SERVERSTD_ROOT_PROXY;
root->u.proxy.dst.nwad = qinfo->client->orgdst_addr;
if (qse_nwadequal(&qinfo->client->orgdst_addr, &qinfo->client->local_addr))
{
/* if the local address is the same as the original
* destination and INTERCEPTED is set, it's probably
* TPROXYed. if TPROXY is used, set the source to the
* original source. */
root->u.proxy.src.nwad = qinfo->client->remote_addr;
/* well, i don't keep the port number, though */
qse_setnwadport (&root->u.proxy.src.nwad, 0);
}
if (mth == QSE_HTTP_CONNECT)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_RAW;
}
else
{
if (loccfg->proxy.pseudonym[0])
root->u.proxy.pseudonym = loccfg->proxy.pseudonym;
if (server->dope.flags & QSE_HTTPD_SERVER_SECURE)
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_SECURE;
}
goto proxy_ok;
}
}
if (mth == QSE_HTTP_CONNECT)
{
if (loccfg->proxy.allow_connect)
{
/* TODO: disallow connecting back to self */
/* TODO: Proxy-Authorization???? */
root->type = QSE_HTTPD_SERVERSTD_ROOT_PROXY;
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_RAW;
/* no pseudonym for RAW proxying */
if (qse_mbstonwad(qpath, &root->u.proxy.dst.nwad) <= -1)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_STR;
root->u.proxy.dst.str = qpath;
}
else
{
/* make the source binding type the same as destination */
/* no default port for raw proxying */
root->u.proxy.src.nwad.type = root->u.proxy.dst.nwad.type;
}
goto proxy_ok;
}
else
{
root->type = QSE_HTTPD_SERVERSTD_ROOT_ERROR;
root->u.error.code = 403; /* forbidden */
return 0;
}
}
if ((loccfg->proxy.allow_http && qse_mbszcasecmp (qpath, QSE_MT("http://"), (proto_len = 7)) == 0) ||
(loccfg->proxy.allow_https && qse_mbszcasecmp (qpath, QSE_MT("https://"), (proto_len = 8)) == 0))
{
qse_mchar_t* host, * slash;
host = qpath + proto_len;
slash = qse_mbschr (host, QSE_MT('/'));
if (slash && slash - host > 0)
{
qse_size_t len_before_slash;
qse_mchar_t* org_qpath = QSE_NULL;
len_before_slash = slash - qpath;
if (!(qinfo->req->flags & QSE_HTRE_QPATH_PERDEC) ||
qse_mbszcmp (qpath, (org_qpath = qse_htre_getorgqpath(qinfo->req)), len_before_slash) == 0)
{
/* this block ensures to proxy a request whose protocol and
* host name part were not percent-encoded in the original
* request */
/* e.g. proto://hostname/XXXX
* slash should point to the slash before XXXX.
* if hostname is empty, this 'if' block is skipped. */
root->type = QSE_HTTPD_SERVERSTD_ROOT_PROXY;
if (loccfg->proxy.pseudonym[0])
root->u.proxy.pseudonym = loccfg->proxy.pseudonym;
/* TODO: refrain from manipulating the request like this */
/* move the host name part backward by 1 byte to make a room for
* terminating null. An orginal input of http://www.yahoo.com/ab/cd
* becomes http:/www.yahoo.com\0ab/cd. host gets to point to
* www.yahoo.com. qpath(qinfo->req.u.q.path) is updated to ab/cd. */
qse_memmove (host - 1, host, slash - host);
slash[-1] = QSE_MT('\0');
host = host - 1;
root->u.proxy.host = host;
if (proto_len == 8) root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_SECURE;
if (qse_mbstonwad (host, &root->u.proxy.dst.nwad) <= -1)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_STR;
root->u.proxy.dst.str = host;
}
else
{
/* make the source binding type the same as destination */
if (qse_getnwadport(&root->u.proxy.dst.nwad) == 0)
qse_setnwadport (&root->u.proxy.dst.nwad, qse_hton16(80));
root->u.proxy.src.nwad.type = root->u.proxy.dst.nwad.type;
}
/* TODO: refrain from manipulating the request like this */
qinfo->req->u.q.path.len -= len_before_slash;
qinfo->req->u.q.path.ptr = slash; /* TODO: use setqpath or something... */
if (org_qpath)
{
qinfo->req->orgqpath.len -= len_before_slash;
qinfo->req->orgqpath.ptr += len_before_slash;
}
goto proxy_ok;
}
}
else
{
root->type = QSE_HTTPD_SERVERSTD_ROOT_ERROR;
root->u.error.code = 403; /* forbidden */
return 0;
}
}
switch (loccfg->root_type)
{
case ROOT_TYPE_NWAD_SECURE:
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_SECURE;
/* fall thru */
case ROOT_TYPE_NWAD:
/* simple forwarding. it's not controlled by proxy.http, proxy.https or proxy.connect */
root->type = QSE_HTTPD_SERVERSTD_ROOT_PROXY;
root->u.proxy.dst.nwad = loccfg->root.nwad;
root->u.proxy.src.nwad.type = root->u.proxy.dst.nwad.type;
if (loccfg->proxy.pseudonym[0])
root->u.proxy.pseudonym = loccfg->proxy.pseudonym;
goto proxy_ok;
case ROOT_TYPE_HOST_SECURE:
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_SECURE;
case ROOT_TYPE_HOST:
root->type = QSE_HTTPD_SERVERSTD_ROOT_PROXY;
root->u.proxy.dst.str = loccfg->root.host;
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_DST_STR;
if (loccfg->proxy.pseudonym[0])
root->u.proxy.pseudonym = loccfg->proxy.pseudonym;
goto proxy_ok;
case ROOT_TYPE_RELOC:
root->type = QSE_HTTPD_SERVERSTD_ROOT_RELOC;
root->u.reloc.flags = loccfg->root.reloc.flags;
root->u.reloc.target = qse_mbsdup (loccfg->root.reloc.target, qse_httpd_getmmgr(httpd));
if (root->u.reloc.target == QSE_NULL)
{
root->type = QSE_HTTPD_SERVERSTD_ROOT_ERROR;
root->u.error.code = 500; /* internal server error */
}
break;
case ROOT_TYPE_ERROR:
root->type = QSE_HTTPD_SERVERSTD_ROOT_ERROR;
root->u.error.code = loccfg->root.error_code;
break;
default:
/* local file system */
root->type = QSE_HTTPD_SERVERSTD_ROOT_PATH;
root->u.path.val = loccfg->xcfg[XCFG_ROOT];
root->u.path.rpl = loccfg->locname.len;
break;
}
return 0;
proxy_ok:
if (loccfg->proxy.dns_enabled)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_ENABLE_DNS | QSE_HTTPD_RSRC_PROXY_DNS_SERVER;
root->u.proxy.dns_server.nwad = loccfg->proxy.dns_nwad;
root->u.proxy.dns_server.tmout.sec = loccfg->proxy.dns_timeout;
root->u.proxy.dns_server.retries = loccfg->proxy.dns_retries;
root->u.proxy.dns_server.flags = loccfg->proxy.dns_queries;
root->u.proxy.dns_preresolve_mod = loccfg->proxy.dns_preresolve_mod;
}
if (loccfg->proxy.urs_enabled)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_ENABLE_URS | QSE_HTTPD_RSRC_PROXY_URS_SERVER;
root->u.proxy.urs_server.nwad = loccfg->proxy.urs_nwad;
root->u.proxy.urs_server.tmout.sec = loccfg->proxy.urs_timeout;
root->u.proxy.urs_server.retries = loccfg->proxy.urs_retries;
root->u.proxy.urs_prerewrite_mod = loccfg->proxy.urs_prerewrite_mod;
}
if (loccfg->proxy.x_forwarded)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_X_FORWARDED;
}
if (loccfg->proxy.allow_upgrade)
{
root->u.proxy.flags |= QSE_HTTPD_RSRC_PROXY_ALLOW_UPGRADE;
}
return 0;
}
static int query_server (
qse_httpd_t* httpd, qse_httpd_server_t* server,
qse_httpd_serverstd_query_code_t code,
qse_httpd_serverstd_query_info_t* qinfo, void* result)
{
httpd_xtn_t* httpd_xtn;
server_xtn_t* server_xtn;
loccfg_t* loccfg = QSE_NULL;
httpd_xtn = qse_httpd_getxtn(httpd);
server_xtn = qse_httpd_getserverxtn(httpd, server);
if (code == QSE_HTTPD_SERVERSTD_SSL)
{
/* SSL is a server-wide configuration item.
* handle this without inspecting the host and the query path. */
qse_httpd_serverstd_ssl_t* ssl;
ssl = (qse_httpd_serverstd_ssl_t*)result;
ssl->certfile = server_xtn->scfg[SCFG_SSLCERTFILE];
ssl->keyfile = server_xtn->scfg[SCFG_SSLKEYFILE];
return 0;
}
if (server_xtn->cfgtab)
{
if (qinfo && qinfo->req && server_xtn->cfgtab)
{
const qse_mchar_t* host = QSE_NULL;
const qse_mchar_t* qpath;
qse_http_method_t mth;
const qse_htre_hdrval_t* hosthdr;
mth = qse_htre_getqmethodtype (qinfo->req);
qpath = qse_htre_getqpath (qinfo->req);
if (mth == QSE_HTTP_CONNECT)
{
qse_nwad_t nwad;
/* the query path for CONNECT is not a path name, but
* a host name. the path is adjusted to the root directory. */
host = qpath;
qpath = QSE_MT("/");
if (qse_mbstonwad (host, &nwad) >= 0)
{
/* the host is a numeric. try he Host: header.
* i expect the values of the host and qpath variables
* are maintained if Host: is not found after goto. */
goto try_host;
}
}
else
{
try_host:
hosthdr = qse_htre_getheaderval (qinfo->req, QSE_MT("Host"));
if (hosthdr)
{
/*while (hosthdr->next) hosthdr = hosthdr->next; */
host = hosthdr->ptr;
}
}
if (host)
{
const qse_mchar_t* colon;
qse_size_t hostlen;
/* remove :port-number if the host name contains it */
colon = qse_mbsrchr(host, QSE_MT(':'));
if (colon) hostlen = colon - host;
else hostlen = qse_mbslen(host);
/* Wild card search
*
* www.tango.com =>
* www.tango.com
* tango.com
* com <-- up to here
* *
*
* tango.com =>
* tango.com
* com <-- up to here
* *
*/
while (hostlen > 0)
{
qse_mchar_t c;
loccfg = find_loccfg (httpd, server_xtn->cfgtab, host, hostlen, qpath);
if (loccfg) goto found;
/* skip the current segment */
do
{
c = *host++;
hostlen--;
}
while (c != QSE_MT('.') && hostlen > 0);
}
}
if (loccfg == QSE_NULL) loccfg = find_loccfg (httpd, server_xtn->cfgtab, QSE_MT("*"), 1, qpath);
}
if (loccfg == QSE_NULL) loccfg = find_loccfg (httpd, server_xtn->cfgtab, QSE_MT("*"), 1, QSE_MT("/"));
}
if (loccfg == QSE_NULL) loccfg = &httpd_xtn->dflcfg;
found:
switch (code)
{
case QSE_HTTPD_SERVERSTD_ROOT:
#if 0
if (qse_mbscmp (qse_htre_getqpath(qinfo->req), QSE_MT("/version")) == 0)
{
/* return static text without inspecting further */
/*((qse_httpd_serverstd_root_t*)result)->type = QSE_HTTPD_SERVERSTD_ROOT_TEXT;
((qse_httpd_serverstd_root_t*)result)->u.text.ptr = QSE_MT(QSE_PACKAGE_NAME " " QSE_PACKAGE_VERSION);
((qse_httpd_serverstd_root_t*)result)->u.text.mime = QSE_MT("text/plain");*/
else
#endif
return get_server_root (httpd, server, loccfg, qinfo, result);
case QSE_HTTPD_SERVERSTD_REALM:
{
const qse_mchar_t* apath;
qse_size_t i;
((qse_httpd_serverstd_realm_t*)result)->name = loccfg->xcfg[XCFG_REALM];
/* qinfo->xpath is not available for the REALM query in the std implementation.
* let me check if it's available in case the implementation changes */
apath = qinfo->xpath? qinfo->xpath: qse_htre_getqpath (qinfo->req);
if (apath)
{
const qse_mchar_t* base;
base = qse_mbsbasename (apath);
for (i = 0; i < QSE_COUNTOF(loccfg->auth_rule); i++)
{
struct auth_rule_t* auth_rule;
for (auth_rule = loccfg->auth_rule[i].head; auth_rule; auth_rule = auth_rule->next)
{
if ((auth_rule->type == AUTH_RULE_PREFIX && qse_mbsbeg (base, auth_rule->spec)) ||
(auth_rule->type == AUTH_RULE_SUFFIX && qse_mbsend (base, auth_rule->spec)) ||
(auth_rule->type == AUTH_RULE_NAME && qse_mbscmp (base, auth_rule->spec) == 0) ||
auth_rule->type == AUTH_RULE_OTHER)
{
if (auth_rule->noauth)
{
/* if noauth is set, authorization is not required */
((qse_httpd_serverstd_realm_t*)result)->authreq = 0;
return 0;
}
else
{
/* proceed to perform authorization */
break;
}
}
}
}
}
((qse_httpd_serverstd_realm_t*)result)->authreq = (loccfg->xcfg[XCFG_REALM] != QSE_NULL);
return 0;
}
case QSE_HTTPD_SERVERSTD_AUTH:
{
qse_httpd_serverstd_auth_t* auth;
auth = (qse_httpd_serverstd_auth_t*)result;
auth->authok = 0;
if (loccfg->xcfg[XCFG_AUTH])
{
if (qse_mbsxcmp (auth->key.ptr, auth->key.len, loccfg->xcfg[XCFG_AUTH]) == 0)
{
auth->authok = 1;
}
}
return 0;
}
case QSE_HTTPD_SERVERSTD_DIRHEAD:
*(const qse_mchar_t**)result = loccfg->xcfg[XCFG_DIRHEAD];
return 0;
case QSE_HTTPD_SERVERSTD_DIRFOOT:
*(const qse_mchar_t**)result = loccfg->xcfg[XCFG_DIRFOOT];
return 0;
case QSE_HTTPD_SERVERSTD_ERRHEAD:
*(const qse_mchar_t**)result = loccfg->xcfg[XCFG_ERRHEAD];
return 0;
case QSE_HTTPD_SERVERSTD_ERRFOOT:
*(const qse_mchar_t**)result = loccfg->xcfg[XCFG_ERRFOOT];
return 0;
case QSE_HTTPD_SERVERSTD_INDEX:
((qse_httpd_serverstd_index_t*)result)->count = loccfg->index.count;
((qse_httpd_serverstd_index_t*)result)->files = loccfg->index.files;
return 0;
case QSE_HTTPD_SERVERSTD_CGI:
{
qse_size_t i;
qse_httpd_serverstd_cgi_t* scgi;
const qse_mchar_t* xpath_base;
#if 0
qse_mchar_t* qpath;
qpath = qse_htre_getqpath(qinfo->req);
#endif
scgi = (qse_httpd_serverstd_cgi_t*)result;
qse_memset (scgi, 0, QSE_SIZEOF(*scgi));
#if 0
printf ("qinfo->xpath [%s] %d [%s]\n", qinfo->xpath, qinfo->xpath_nx, qpath);
/*if (qse_mbscmp (qinfo->xpath, QSE_MT("/tmp/version.cgi")) == 0)*/
if (qse_mbscmp (qpath, QSE_MT("/local/version.cgi")) == 0)
{
scgi->cgi = 1;
scgi->nph = 0;
scgi->fncptr = xxxx;
scgi->shebang = QSE_NULL;
return 0;
}
#endif
if (!qinfo->xpath_nx)
{
xpath_base = qse_mbsbasename (qinfo->xpath);
for (i = 0; i < QSE_COUNTOF(loccfg->cgi); i++)
{
struct cgi_t* cgi;
for (cgi = loccfg->cgi[i].head; cgi; cgi = cgi->next)
{
if ((cgi->type == CGI_PREFIX && qse_mbsbeg (xpath_base, cgi->spec)) ||
(cgi->type == CGI_SUFFIX && qse_mbsend (xpath_base, cgi->spec)) ||
(cgi->type == CGI_NAME && qse_mbscmp (xpath_base, cgi->spec) == 0))
{
scgi->cgi = 1;
scgi->nph = cgi->nph;
scgi->shebang = cgi->shebang;
return 0;
}
}
}
}
return 0;
}
case QSE_HTTPD_SERVERSTD_MIME:
{
qse_size_t i;
const qse_mchar_t* xpath_base;
xpath_base = qse_mbsbasename (qinfo->xpath);
*(const qse_mchar_t**)result = QSE_NULL;
for (i = 0; i < QSE_COUNTOF(loccfg->mime); i++)
{
struct mime_t* mime;
for (mime = loccfg->mime[i].head; mime; mime = mime->next)
{
if ((mime->type == MIME_PREFIX && qse_mbsbeg (xpath_base, mime->spec)) ||
(mime->type == MIME_SUFFIX && qse_mbsend (xpath_base, mime->spec)) ||
(mime->type == MIME_NAME && qse_mbscmp (xpath_base, mime->spec) == 0) ||
mime->type == MIME_OTHER)
{
*(const qse_mchar_t**)result = mime->value;
return 0;
}
}
}
return 0;
}
case QSE_HTTPD_SERVERSTD_DIRACC:
case QSE_HTTPD_SERVERSTD_FILEACC:
{
switch (qse_htre_getqmethodtype(qinfo->req))
{
case QSE_HTTP_OPTIONS:
case QSE_HTTP_HEAD:
case QSE_HTTP_GET:
case QSE_HTTP_POST:
case QSE_HTTP_PUT:
case QSE_HTTP_DELETE:
{
qse_size_t i;
const qse_mchar_t* xpath_base;
int id;
id = (code == QSE_HTTPD_SERVERSTD_DIRACC)? 0: 1;
xpath_base = qse_mbsbasename (qinfo->xpath);
*(int*)result = 200;
for (i = 0; i < QSE_COUNTOF(loccfg->access[id]); i++)
{
struct access_t* access;
for (access = loccfg->access[id][i].head; access; access = access->next)
{
if ((access->type == ACCESS_PREFIX && qse_mbsbeg (xpath_base, access->spec)) ||
(access->type == ACCESS_SUFFIX && qse_mbsend (xpath_base, access->spec)) ||
(access->type == ACCESS_NAME && qse_mbscmp (xpath_base, access->spec) == 0) ||
access->type == ACCESS_OTHER)
{
*(int*)result = access->value;
return 0;
}
}
}
break;
}
default:
*(int*)result = 405; /* method not allowed */
break;
}
return 0;
}
}
return server_xtn->orgquery (httpd, server, code, qinfo, result);
}
/* --------------------------------------------------------------------- */
static void free_loccfg_contents (qse_httpd_t* httpd, loccfg_t* loccfg)
{
qse_size_t i, j;
for (i = 0; i < QSE_COUNTOF(loccfg->xcfg); i++)
{
if (loccfg->xcfg[i])
{
qse_httpd_freemem (httpd, loccfg->xcfg[i]);
loccfg->xcfg[i] = QSE_NULL;
}
}
if (loccfg->index.files)
{
qse_httpd_freemem (httpd, loccfg->index.files);
loccfg->index.files = QSE_NULL;
loccfg->index.count = 0;
}
for (i = 0; i < QSE_COUNTOF(loccfg->cgi); i++)
{
struct cgi_t* cgi = loccfg->cgi[i].head;
while (cgi)
{
struct cgi_t* x = cgi;
cgi = x->next;
if (x->shebang) qse_httpd_freemem (httpd, x->shebang);
if (x->spec) qse_httpd_freemem (httpd, x->spec);
if (x) qse_httpd_freemem (httpd, x);
}
loccfg->cgi[i].head = QSE_NULL;
loccfg->cgi[i].tail = QSE_NULL;
}
for (i = 0; i < QSE_COUNTOF(loccfg->auth_rule); i++)
{
struct auth_rule_t* auth_rule = loccfg->auth_rule[i].head;
while (auth_rule)
{
struct auth_rule_t* x = auth_rule;
auth_rule = x->next;
if (x->spec) qse_httpd_freemem (httpd, x->spec);
if (x) qse_httpd_freemem (httpd, x);
}
loccfg->auth_rule[i].head = QSE_NULL;
loccfg->auth_rule[i].tail = QSE_NULL;
}
for (i = 0; i < QSE_COUNTOF(loccfg->mime); i++)
{
struct mime_t* mime = loccfg->mime[i].head;
while (mime)
{
struct mime_t* x = mime;
mime = x->next;
if (x->spec) qse_httpd_freemem (httpd, x->spec);
if (x->value) qse_httpd_freemem (httpd, x->value);
if (x) qse_httpd_freemem (httpd, x);
}
loccfg->mime[i].head = QSE_NULL;
loccfg->mime[i].tail = QSE_NULL;
}
for (j = 0; j < QSE_COUNTOF(loccfg->access); j++)
{
for (i = 0; i < QSE_COUNTOF(loccfg->access[j]); i++)
{
struct access_t* access = loccfg->access[j][i].head;
while (access)
{
struct access_t* x = access;
access = x->next;
if (x->spec) qse_httpd_freemem (httpd, x->spec);
if (x) qse_httpd_freemem (httpd, x);
}
loccfg->access[j][i].head = QSE_NULL;
loccfg->access[j][i].tail = QSE_NULL;
}
}
if (loccfg->locname.ptr) qse_httpd_freemem (httpd, loccfg->locname.ptr);
}
static int get_boolean (const qse_xli_str_t* v)
{
return (qse_strxcasecmp (v->ptr, v->len, QSE_T("yes")) == 0 ||
qse_strxcasecmp (v->ptr, v->len, QSE_T("on")) == 0);
}
static int get_intercept (const qse_xli_str_t* v)
{
if (qse_strxcasecmp (v->ptr, v->len, QSE_T("local")) == 0) return 2;
if (qse_strxcasecmp (v->ptr, v->len, QSE_T("proxy")) == 0 ||
qse_strxcasecmp (v->ptr, v->len, QSE_T("yes")) == 0 ||
qse_strxcasecmp (v->ptr, v->len, QSE_T("on")) == 0) return 1;
return 0;
}
static int get_integer (const qse_xli_str_t* v)
{
/* TODO: be more strict */
return qse_strxtoi (v->ptr, v->len, 10, QSE_NULL);
}
static int parse_dns_query_types (qse_httpd_t* httpd, const qse_xli_str_t* str)
{
int flags = 0;
while (str)
{
if (qse_strxcasecmp (str->ptr, str->len, QSE_T("a")) == 0) flags |= QSE_HTTPD_DNS_SERVER_A;
else if (qse_strxcasecmp (str->ptr, str->len, QSE_T("aaaa")) == 0) flags |= QSE_HTTPD_DNS_SERVER_AAAA;
else
{
qse_printf (QSE_T("ERROR: invalid dns query type for proxy dns - %s\n"), str->ptr);
return -1;
}
str = str->next;
}
return flags;
}
static int load_loccfg_basic (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
static struct
{
const qse_char_t* x;
const qse_char_t* y;
} loc_xcfg_items[] =
{
{ QSE_T("root"), QSE_T("server-default.root") },
{ QSE_T("realm"), QSE_T("server-default.realm") },
{ QSE_T("auth"), QSE_T("server-default.auth") },
{ QSE_T("dir-head"), QSE_T("server-default.dir-head") },
{ QSE_T("dir-foot"), QSE_T("server-default.dir-foot") },
{ QSE_T("error-head"), QSE_T("server-default.error-head") },
{ QSE_T("error-foot"), QSE_T("server-default.error-foot") }
};
int i;
qse_xli_pair_t* pair;
for (i = 0; i < QSE_COUNTOF(loc_xcfg_items); i++)
{
pair = qse_xli_findpair (xli, list, loc_xcfg_items[i].x);
if (!pair) pair = qse_xli_findpair (xli, QSE_NULL, loc_xcfg_items[i].y);
if (pair && pair->val->type == QSE_XLI_STR)
{
cfg->xcfg[i] = qse_httpd_strntombsdup (httpd, ((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len);
if (cfg->xcfg[i] == QSE_NULL)
{
/*qse_printf (QSE_T("ERROR in copying - %s\n"), qse_httpd_geterrmsg (httpd));*/
qse_printf (QSE_T("ERROR in copying\n"));
return -1;
}
}
}
return 0;
}
static int load_loccfg_index (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
qse_xli_pair_t* pair;
pair = qse_xli_findpair (xli, list, QSE_T("index"));
if (!pair) pair = qse_xli_findpair (xli, QSE_NULL, QSE_T("server-default.index"));
if (pair && pair->val->type == QSE_XLI_STR)
{
qse_char_t* duptmp;
qse_size_t count, duplen;
duptmp = qse_xli_dupflatstr (xli, (qse_xli_str_t*)pair->val, &duplen, &count);
if (duptmp == QSE_NULL)
{
qse_printf (QSE_T("ERROR: memory failure in copying index\n"));
return -1;
}
cfg->index.files = qse_httpd_strntombsdup (httpd, duptmp, duplen);
qse_xli_freemem (xli, duptmp);
if (cfg->index.files == QSE_NULL)
{
qse_printf (QSE_T("ERROR: memory failure in copying index\n"));
return -1;
}
cfg->index.count = count;
}
return 0;
}
static int load_loccfg_cgi (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
qse_xli_pair_t* pair;
qse_xli_atom_t* atom;
pair = qse_xli_findpair (xli, list, QSE_T("cgi"));
if (!pair) pair = qse_xli_findpair (xli, QSE_NULL, QSE_T("server-default.cgi"));
if (pair && pair->val->type == QSE_XLI_LIST)
{
qse_xli_list_t* cgilist = (qse_xli_list_t*)pair->val;
for (atom = cgilist->head; atom; atom = atom->next)
{
struct cgi_t* cgi;
int type;
if (atom->type != QSE_XLI_PAIR) continue;
pair = (qse_xli_pair_t*)atom;
if (qse_strcmp (pair->key, QSE_T("prefix")) == 0) type = CGI_PREFIX;
else if (qse_strcmp (pair->key, QSE_T("suffix")) == 0) type = CGI_SUFFIX;
else if (qse_strcmp (pair->key, QSE_T("name")) == 0) type = CGI_NAME;
else continue;
cgi = qse_httpd_callocmem (httpd, QSE_SIZEOF(*cgi));
if (cgi == QSE_NULL)
{
qse_printf (QSE_T("ERROR: memory failure in copying cgi\n"));
return -1;
}
cgi->type = type;
cgi->spec = qse_httpd_strtombsdup (httpd, pair->alias);
if (!cgi->spec)
{
qse_httpd_freemem (httpd, cgi);
qse_printf (QSE_T("ERROR: memory failure in copying cgi name\n"));
return -1;
}
if (pair->val->type == QSE_XLI_STR)
{
qse_xli_str_t* str;
qse_size_t count = 0;
for (str = (qse_xli_str_t*)pair->val; str; str = str->next)
{
if (count == 0)
{
/* the first segment */
if (qse_strxcmp (str->ptr, str->len, QSE_T("nph")) == 0) cgi->nph = 1;
}
else if (count == 1)
{
/* second segment */
cgi->shebang = qse_httpd_strntombsdup (httpd, str->ptr, str->len);
if (!cgi->shebang)
{
qse_httpd_freemem (httpd, cgi->spec);
qse_httpd_freemem (httpd, cgi);
qse_printf (QSE_T("ERROR: memory failure in copying cgi shebang\n"));
return -1;
}
}
count++;
/* TODO: more sanity check like the number of maximum segments or the value of the first segment...*/
}
}
if (cfg->cgi[type].tail)
cfg->cgi[type].tail->next = cgi;
else
cfg->cgi[type].head = cgi;
cfg->cgi[type].tail = cgi;
}
}
return 0;
}
static int load_loccfg_authrule (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
qse_xli_pair_t* pair;
qse_xli_atom_t* atom;
pair = qse_xli_findpair (xli, list, QSE_T("auth-rule"));
if (!pair) pair = qse_xli_findpair (xli, QSE_NULL, QSE_T("server-default.auth-rule"));
if (pair && pair->val->type == QSE_XLI_LIST)
{
qse_xli_list_t* auth_rule_list = (qse_xli_list_t*)pair->val;
for (atom = auth_rule_list->head; atom; atom = atom->next)
{
struct auth_rule_t* auth_rule;
int type;
if (atom->type != QSE_XLI_PAIR) continue;
pair = (qse_xli_pair_t*)atom;
if (qse_strcmp (pair->key, QSE_T("prefix")) == 0) type = AUTH_RULE_PREFIX;
else if (qse_strcmp (pair->key, QSE_T("suffix")) == 0) type = AUTH_RULE_SUFFIX;
else if (qse_strcmp (pair->key, QSE_T("name")) == 0) type = AUTH_RULE_NAME;
else if (qse_strcmp (pair->key, QSE_T("other")) == 0) type = AUTH_RULE_OTHER;
else continue;
auth_rule = qse_httpd_callocmem (httpd, QSE_SIZEOF(*auth_rule));
if (auth_rule == QSE_NULL)
{
qse_printf (QSE_T("ERROR: memory failure in copying auth-rule\n"));
return -1;
}
auth_rule->type = type;
if (pair->alias)
{
auth_rule->spec = qse_httpd_strtombsdup (httpd, pair->alias);
if (!auth_rule->spec)
{
qse_httpd_freemem (httpd, auth_rule);
qse_printf (QSE_T("ERROR: memory failure in copying auth-rule\n"));
return -1;
}
}
auth_rule->noauth = 0;
if (qse_strxcmp (((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len, QSE_T("noauth")) == 0) auth_rule->noauth = 1;
if (cfg->auth_rule[type].tail)
cfg->auth_rule[type].tail->next = auth_rule;
else
cfg->auth_rule[type].head = auth_rule;
cfg->auth_rule[type].tail = auth_rule;
}
}
/* TODO: support multiple auth entries */
return 0;
}
static int load_loccfg_mime (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
qse_xli_pair_t* pair;
qse_xli_atom_t* atom;
pair = qse_xli_findpair (xli, list, QSE_T("mime"));
if (!pair) pair = qse_xli_findpair (xli, QSE_NULL, QSE_T("server-default.mime"));
if (pair && pair->val->type == QSE_XLI_LIST)
{
qse_xli_list_t* mimelist = (qse_xli_list_t*)pair->val;
for (atom = mimelist->head; atom; atom = atom->next)
{
struct mime_t* mime;
int type;
if (atom->type != QSE_XLI_PAIR) continue;
pair = (qse_xli_pair_t*)atom;
if (qse_strcmp (pair->key, QSE_T("prefix")) == 0) type = MIME_PREFIX;
else if (qse_strcmp (pair->key, QSE_T("suffix")) == 0) type = MIME_SUFFIX;
else if (qse_strcmp (pair->key, QSE_T("name")) == 0) type = MIME_NAME;
else if (qse_strcmp (pair->key, QSE_T("other")) == 0) type = MIME_OTHER;
else continue;
mime = qse_httpd_callocmem (httpd, QSE_SIZEOF(*mime));
if (mime == QSE_NULL)
{
qse_printf (QSE_T("ERROR: memory failure in copying mime\n"));
return -1;
}
mime->type = type;
mime->spec = qse_httpd_strtombsdup (httpd, pair->alias);
if (!mime->spec)
{
qse_httpd_freemem (httpd, mime);
qse_printf (QSE_T("ERROR: memory failure in copying mime\n"));
return -1;
}
mime->value = qse_httpd_strntombsdup (httpd, ((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len);
if (!mime->value)
{
qse_httpd_freemem (httpd, mime->spec);
qse_httpd_freemem (httpd, mime);
qse_printf (QSE_T("ERROR: memory failure in copying mime\n"));
return -1;
}
if (cfg->mime[type].tail)
cfg->mime[type].tail->next = mime;
else
cfg->mime[type].head = mime;
cfg->mime[type].tail = mime;
}
}
return 0;
}
static int load_loccfg_access (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
/* local access items */
static struct
{
const qse_char_t* x;
const qse_char_t* y;
} loc_acc_items[] =
{
{ QSE_T("dir-access"), QSE_T("server-default.dir-access") },
{ QSE_T("file-access"), QSE_T("server-default.file-access") }
};
int i;
qse_xli_pair_t* pair;
qse_xli_atom_t* atom;
for (i = 0; i < 2; i++)
{
pair = qse_xli_findpair (xli, list, loc_acc_items[i].x);
if (!pair) pair = qse_xli_findpair (xli, QSE_NULL, loc_acc_items[i].y);
if (pair && pair->val->type == QSE_XLI_LIST)
{
qse_xli_list_t* acclist = (qse_xli_list_t*)pair->val;
for (atom = acclist->head; atom; atom = atom->next)
{
struct access_t* acc;
const qse_char_t* tmp;
qse_size_t len;
int type, value;
if (atom->type != QSE_XLI_PAIR) continue;
pair = (qse_xli_pair_t*)atom;
if (qse_strcmp (pair->key, QSE_T("prefix")) == 0) type = ACCESS_PREFIX;
else if (qse_strcmp (pair->key, QSE_T("suffix")) == 0) type = ACCESS_SUFFIX;
else if (qse_strcmp (pair->key, QSE_T("name")) == 0) type = ACCESS_NAME;
else if (qse_strcmp (pair->key, QSE_T("other")) == 0) type = ACCESS_OTHER;
else continue;
tmp = ((qse_xli_str_t*)pair->val)->ptr;
len = ((qse_xli_str_t*)pair->val)->len;
if (qse_strxcmp (tmp, len, QSE_T("noent")) == 0) value = 404;
else if (qse_strxcmp (tmp, len, QSE_T("forbid")) == 0) value = 403;
else if (qse_strxcmp (tmp, len, QSE_T("ok")) == 0) value = 200;
else continue;
/* TODO: more sanity check */
acc = qse_httpd_callocmem (httpd, QSE_SIZEOF(*acc));
if (acc == QSE_NULL)
{
qse_printf (QSE_T("ERROR: memory failure in copying acc\n"));
return -1;
}
acc->type = type;
if (pair->alias)
{
acc->spec = qse_httpd_strtombsdup (httpd, pair->alias);
if (!acc->spec)
{
qse_httpd_freemem (httpd, acc);
qse_printf (QSE_T("ERROR: memory failure in copying access\n"));
return -1;
}
}
acc->value = value;
if (cfg->access[i][type].tail)
cfg->access[i][type].tail->next = acc;
else
cfg->access[i][type].head = acc;
cfg->access[i][type].tail = acc;
}
}
}
return 0;
}
static int load_loccfg_proxy (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
qse_xli_pair_t* pair;
qse_xli_list_t* proxy = QSE_NULL;
qse_xli_list_t* default_proxy = QSE_NULL;
pair = qse_xli_findpair (xli, list, QSE_T("proxy"));
if (pair)
{
QSE_ASSERT (pair->val->type == QSE_XLI_LIST);
proxy = (qse_xli_list_t*)pair->val;
}
pair = qse_xli_findpair (xli, QSE_NULL, QSE_T("server-default.proxy"));
if (pair)
{
QSE_ASSERT (pair->val->type == QSE_XLI_LIST);
default_proxy = (qse_xli_list_t*)pair->val;
}
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("http")); /* server.host[].location[].proxy.http */
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("http")); /* server-default.proxy.http */
if (pair) cfg->proxy.allow_http = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("https")); /* server.host[].location[].proxy.https */
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("https")); /* server-default.proxy.https */
if (pair) cfg->proxy.allow_https = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("connect"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("connect"));
if (pair) cfg->proxy.allow_connect = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("intercept"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("intercept"));
if (pair) cfg->proxy.allow_intercept = get_intercept ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("upgrade"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("upgrade"));
if (pair) cfg->proxy.allow_upgrade = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("x-forwarded"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("x-forwarded"));
if (pair) cfg->proxy.x_forwarded = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("pseudonym"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("pseudonym"));
if (pair)
{
qse_xli_str_t* str = (qse_xli_str_t*)pair->val;
#if defined(QSE_CHAR_IS_MCHAR)
qse_mbsxcpy (cfg->proxy.pseudonym, QSE_COUNTOF(cfg->proxy.pseudonym), str->ptr);
#else
qse_size_t wcslen, mbslen = QSE_COUNTOF(cfg->proxy.pseudonym);
if (qse_wcstombs (str->ptr, &wcslen, cfg->proxy.pseudonym, &mbslen) <= -1)
{
qse_printf (QSE_T("ERROR: invalid pseudonym for proxy - %s"), str->ptr);
return -1;
}
#endif
}
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("dns-enabled"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("dns-enabled"));
if (pair) cfg->proxy.dns_enabled = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("dns-server"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("dns-server"));
if (pair)
{
qse_xli_str_t* str = (qse_xli_str_t*)pair->val;
if (qse_strtonwad (str->ptr, &cfg->proxy.dns_nwad) <= -1)
{
qse_printf (QSE_T("ERROR: invalid address for proxy dns - %s"), str->ptr);
return -1;
}
}
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("dns-timeout"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("dns-timeout"));
if (pair) cfg->proxy.dns_timeout = get_integer ((qse_xli_str_t*)pair->val);
else cfg->proxy.dns_timeout = -1;
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("dns-retries"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("dns-retries"));
if (pair) cfg->proxy.dns_retries = get_integer ((qse_xli_str_t*)pair->val);
else cfg->proxy.dns_retries = -1;
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("dns-queries"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("dns-queries"));
if (pair)
{
cfg->proxy.dns_queries = parse_dns_query_types (httpd, (qse_xli_str_t*)pair->val);
if (cfg->proxy.dns_queries <= -1) return -1;
}
else cfg->proxy.dns_queries = QSE_HTTPD_DNS_SERVER_A | QSE_HTTPD_DNS_SERVER_AAAA;
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("dns-preresolve-hook"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("dns-preresolve-hook"));
if (pair)
{
cfg->proxy.dns_preresolve_mod = qse_httpd_findmod (httpd, ((qse_xli_str_t*)pair->val)->ptr);
if (!cfg->proxy.dns_preresolve_mod)
qse_printf (QSE_T("WARNING: dns-preresolve-hook not found - %s\n"), ((qse_xli_str_t*)pair->val)->ptr);
}
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("urs-enabled"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("urs-enabled"));
if (pair) cfg->proxy.urs_enabled = get_boolean ((qse_xli_str_t*)pair->val);
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("urs-server"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("urs-server"));
if (pair)
{
qse_xli_str_t* str = (qse_xli_str_t*)pair->val;
if (qse_strtonwad (str->ptr, &cfg->proxy.urs_nwad) <= -1)
{
qse_printf (QSE_T("ERROR: invalid address for proxy urs - %s"), str->ptr);
return -1;
}
}
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("urs-timeout"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("urs-timeout"));
if (pair) cfg->proxy.urs_timeout = get_integer ((qse_xli_str_t*)pair->val);
else cfg->proxy.urs_timeout = -1;
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("urs-retries"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("urs-retries"));
if (pair) cfg->proxy.urs_retries = get_integer ((qse_xli_str_t*)pair->val);
else cfg->proxy.urs_retries = -1;
pair = QSE_NULL;
if (proxy) pair = qse_xli_findpair (xli, proxy, QSE_T("urs-prerewrite-hook"));
if (!pair && default_proxy) pair = qse_xli_findpair (xli, default_proxy, QSE_T("urs-prerewrite-hook"));
if (pair)
{
cfg->proxy.urs_prerewrite_mod = qse_httpd_findmod (httpd, ((qse_xli_str_t*)pair->val)->ptr);
if (!cfg->proxy.urs_prerewrite_mod)
qse_printf (QSE_T("WARNING: urs-prerewrite-hook not found - %s\n"), ((qse_xli_str_t*)pair->val)->ptr);
}
return 0;
}
static int load_loccfg (qse_httpd_t* httpd, qse_xli_t* xli, qse_xli_list_t* list, loccfg_t* cfg)
{
/*httpd_xtn_t* httpd_xtn;
httpd_xtn = qse_httpd_getxtn(httpd);*/
if (load_loccfg_basic (httpd, xli, list, cfg) <= -1 ||
load_loccfg_index (httpd, xli, list, cfg) <= -1 ||
load_loccfg_cgi (httpd, xli, list, cfg) <= -1 ||
load_loccfg_authrule (httpd, xli, list, cfg) <= -1 ||
load_loccfg_mime (httpd, xli, list, cfg) <= -1 ||
load_loccfg_access (httpd, xli, list, cfg) <= -1 ||
load_loccfg_proxy (httpd, xli, list, cfg) <= -1) return -1;
#if 0
/* TODO: perform more sanity check */
if (qse_mbschr (cfg->xcfg[XCFG_AUTH], QSE_MT(':')) == QSE_NULL)
{
qse_printf (QSE_T("WARNING: no colon in the auth string - [%hs]\n"), cfg->xcfg[XCFG_AUTH]);
}
#endif
cfg->root_type = ROOT_TYPE_PATH; /* default type */
if (cfg->xcfg[XCFG_ROOT])
{
/* check if the root value is special */
const qse_mchar_t* root = cfg->xcfg[XCFG_ROOT];
int proto_len = 0;
if (root[0] == QSE_MT('<') && QSE_ISMDIGIT(root[1]))
{
int code = 0;
root++;
while (QSE_ISMDIGIT(*root))
{
code = code * 10 + (*root - QSE_MT('0'));
root++;
}
if (code >= 400 && code <= 599 && root[0] == QSE_MT('>') && root[1] == QSE_MT('\0'))
{
cfg->root_type = ROOT_TYPE_ERROR;
cfg->root.error_code = code;
goto done;
}
if ((code == 301 || code == 302 || code == 303 || code == 307 || code == 308) && *root == QSE_MT('>'))
{
root++;
if (QSE_ISMPRINT(*root))
{
cfg->root_type = ROOT_TYPE_RELOC;
cfg->root.reloc.flags = 0;
switch (code)
{
case 308:
cfg->root.reloc.flags |= QSE_HTTPD_RSRC_RELOC_PERMANENT;
/* fall thru */
case 307:
cfg->root.reloc.flags |= QSE_HTTPD_RSRC_RELOC_KEEPMETHOD;
break;
case 301:
cfg->root.reloc.flags |= QSE_HTTPD_RSRC_RELOC_PERMANENT;
break;
}
cfg->root.reloc.target = root;
goto done;
}
}
root = cfg->xcfg[XCFG_ROOT];
}
else
{
if (qse_mbszcasecmp (root, QSE_MT("http://"), (proto_len = 7)) == 0 ||
qse_mbszcasecmp (root, QSE_MT("https://"), (proto_len = 8)) == 0)
{
root += proto_len;
}
else
{
proto_len = 0;
}
}
if (qse_mbstonwad (root, &cfg->root.nwad) >= 0)
{
if (cfg->root.nwad.type != QSE_NWAD_IN4 && cfg->root.nwad.type != QSE_NWAD_IN6)
{
qse_printf (QSE_T("ERROR: invalid address for root - [%hs]\n"), cfg->xcfg[XCFG_ROOT]);
return -1;
}
cfg->root_type = (proto_len == 8)? ROOT_TYPE_NWAD_SECURE: ROOT_TYPE_NWAD;
goto done;
}
else if (proto_len > 0 && *root != QSE_MT('\0'))
{
/* it begins with http:// or https:// */
cfg->root_type = (proto_len == 8)? ROOT_TYPE_HOST_SECURE: ROOT_TYPE_HOST;
cfg->root.host = root;
goto done;
}
}
done:
return 0;
}
static void free_server_hostcfg (qse_httpd_t* httpd, server_hostcfg_t* hostcfg)
{
loccfg_t* lc, * cur;
lc = hostcfg->loccfg;
while (lc)
{
cur = lc;
lc = lc->next;
free_loccfg_contents (httpd, cur);
qse_httpd_freemem (httpd, cur);
}
if (hostcfg->hostname) qse_httpd_freemem (httpd, hostcfg->hostname);
qse_httpd_freemem (httpd, hostcfg);
}
static void free_cfgtab_value (qse_htb_t* htb, void* vptr, qse_size_t vlen)
{
qse_httpd_t* httpd;
httpd = *(qse_httpd_t**) qse_htb_getxtn(htb);
free_server_hostcfg (httpd, (server_hostcfg_t*)vptr);
}
static int load_server_config (qse_httpd_t* httpd, qse_httpd_server_t* server, qse_xli_list_t* list)
{
qse_size_t i, j, host_count, loc_count;
httpd_xtn_t* httpd_xtn;
server_xtn_t* server_xtn;
server_hostcfg_t* hostcfg;
loccfg_t* loccfg;
static struct
{
const qse_char_t* x;
const qse_char_t* y;
} scfg_items[] =
{
{ QSE_T("ssl-cert-file"), QSE_T("server-default.ssl-cert-file") },
{ QSE_T("ssl-key-file"), QSE_T("server-default.ssl-key-file") }
};
static qse_htb_style_t cfgtab_style =
{
{
QSE_HTB_COPIER_DEFAULT,
QSE_HTB_COPIER_DEFAULT
},
{
QSE_HTB_FREEER_DEFAULT,
free_cfgtab_value
},
QSE_HTB_COMPER_DEFAULT,
QSE_HTB_KEEPER_DEFAULT,
QSE_HTB_SIZER_DEFAULT,
QSE_HTB_HASHER_DEFAULT
};
httpd_xtn = qse_httpd_getxtn(httpd);
server_xtn = qse_httpd_getserverxtn(httpd, server);
/* load the server-wide configuration not specific to host/location */
for (i = 0; i < SCFG_MAX; i++)
{
qse_xli_pair_t* pair;
pair = qse_xli_findpair (httpd_xtn->xli, list, scfg_items[i].x);
if (!pair) pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, scfg_items[i].y);
if (pair && pair->val->type == QSE_XLI_STR)
{
server_xtn->scfg[i] = qse_httpd_strntombsdup (httpd, ((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len);
if (server_xtn->scfg[i] == QSE_NULL)
{
/*qse_printf (QSE_T("ERROR in copying - %s\n"), qse_httpd_geterrmsg (httpd));*/
qse_printf (QSE_T("ERROR in copying\n"));
return -1;
}
}
}
/* load host/location specific configuration */
host_count = qse_xli_countpairs (httpd_xtn->xli, list, QSE_T("host"));
if (host_count <= 0) return 0; /* nothing to load */
QSE_ASSERT (server_xtn->cfgtab == QSE_NULL);
server_xtn->cfgtab = qse_htb_open (
qse_httpd_getmmgr (httpd), QSE_SIZEOF(httpd),
host_count + (host_count / 3) + 1, 70, QSE_SIZEOF(qse_mchar_t), 0);
if (server_xtn->cfgtab == QSE_NULL)
{
/* TOOD: print error */
return -1;
}
/* store the back reference into the configuration table */
*(qse_httpd_t**)qse_htb_getxtn (server_xtn->cfgtab) = httpd;
qse_htb_setstyle (server_xtn->cfgtab, &cfgtab_style);
for (i = 0; i < host_count; i++)
{
qse_xli_pair_t* host;
qse_char_t buf[32];
qse_strxfmt (buf, QSE_COUNTOF(buf), QSE_T("host[%d]"), i);
host = qse_xli_findpair (httpd_xtn->xli, list, buf);
if (!host) break;
if (host->val->type == QSE_XLI_LIST && host->alias)
{
loc_count = qse_xli_countpairs (httpd_xtn->xli, (qse_xli_list_t*)host->val, QSE_T("location"));
if (((hostcfg = qse_httpd_callocmem (httpd, QSE_SIZEOF(*hostcfg))) == QSE_NULL) ||
((hostcfg->hostname = qse_httpd_strtombsdup (httpd, (host->alias[0] == QSE_T('\0')? QSE_T("*"):host->alias))) == QSE_NULL)) goto oops;
for (j = loc_count; j > 0; )
{
qse_xli_pair_t* loc;
j--;
qse_strxfmt (buf, QSE_COUNTOF(buf), QSE_T("location[%d]"), j);
loc = qse_xli_findpair (httpd_xtn->xli, (qse_xli_list_t*)host->val, buf);
if (!loc) break;
if (loc->val->type == QSE_XLI_LIST && loc->alias)
{
loccfg = qse_httpd_callocmem (httpd, QSE_SIZEOF(*loccfg));
if (loccfg == QSE_NULL) goto oops;
/* just chain it before loading the actual data */
loccfg->next = hostcfg->loccfg;
hostcfg->loccfg = loccfg;
/* load the data now */
if (load_loccfg (httpd, httpd_xtn->xli, (qse_xli_list_t*)loc->val, loccfg) <= -1) goto oops;
/* clone the location name */
loccfg->locname.ptr = qse_httpd_strtombsdup (httpd,
(loc->alias[0] == QSE_T('\0')? QSE_T("/"): loc->alias));
if (loccfg->locname.ptr == QSE_NULL) goto oops;
loccfg->locname.len = qse_mbslen (loccfg->locname.ptr);
}
}
if (qse_htb_upsert (server_xtn->cfgtab, hostcfg->hostname, qse_mbslen(hostcfg->hostname), hostcfg, 0) == QSE_NULL)
{
/* TODO: print error */
goto oops;
}
}
}
return 0;
oops:
if (hostcfg) free_server_hostcfg (httpd, hostcfg);
return -1;
}
static void free_server_config (qse_httpd_t* httpd, qse_httpd_server_t* server)
{
server_xtn_t* server_xtn;
qse_size_t i;
server_xtn = qse_httpd_getserverxtn(httpd, server);
for (i = 0; i < SCFG_MAX; i++)
{
if (server_xtn->scfg[i])
{
qse_httpd_freemem (httpd, server_xtn->scfg[i]);
server_xtn->scfg[i] = QSE_NULL;
}
}
if (server_xtn->cfgtab)
{
qse_htb_close (server_xtn->cfgtab);
server_xtn->cfgtab = QSE_NULL;
}
}
static qse_httpd_server_t* attach_server (qse_httpd_t* httpd, int num, qse_xli_list_t* list)
{
qse_httpd_server_dope_t dope;
qse_httpd_server_t* xserver;
httpd_xtn_t* httpd_xtn;
server_xtn_t* server_xtn;
qse_xli_pair_t* pair;
httpd_xtn = qse_httpd_getxtn(httpd);
qse_memset (&dope, 0, QSE_SIZEOF(dope));
pair = qse_xli_findpair (httpd_xtn->xli, list, QSE_T("backlog-size"));
if (!pair) pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, QSE_T("server-default.backlog-size"));
if (pair == QSE_NULL || pair->val->type != QSE_XLI_STR)
{
dope.backlog_size = 256;
}
else
{
unsigned int v;
v = qse_strtoui (((qse_xli_str_t*)pair->val)->ptr, 10, QSE_NULL);
if (v <= 0) v = 256;
dope.backlog_size = v;
}
pair = qse_xli_findpair (httpd_xtn->xli, list, QSE_T("bind"));
if (pair == QSE_NULL || pair->val->type != QSE_XLI_STR)
{
/* TOOD: logging */
qse_printf (QSE_T("WARNING: no value or invalid value specified for bind\n"));
return QSE_NULL;
}
if (qse_strntonwad (((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len, &dope.nwad) <= -1)
{
/* TOOD: logging */
qse_printf (QSE_T("WARNING: invalid value for bind - %s\n"), ((qse_xli_str_t*)pair->val)->ptr);
return QSE_NULL;
}
pair = qse_xli_findpair (httpd_xtn->xli, list, QSE_T("ssl"));
if (!pair) pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, QSE_T("server-default.ssl"));
if (pair && pair->val->type == QSE_XLI_STR &&
qse_strxcmp (((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len, QSE_T("yes")) == 0) dope.flags |= QSE_HTTPD_SERVER_SECURE;
dope.flags |= QSE_HTTPD_SERVER_TRANSPARENT; /* need this to support TPROXY when proxy.allow_intercept is enabled */
dope.detach = free_server_config;
xserver = qse_httpd_attachserverstd (httpd, &dope, QSE_SIZEOF(server_xtn_t));
if (xserver == QSE_NULL)
{
/* TODO: logging */
qse_printf (QSE_T("WARNING: failed to attach server\n"));
return QSE_NULL;
}
server_xtn = qse_httpd_getserverxtn(httpd, xserver);
/* remember original callbacks */
qse_httpd_getserverstdopt (httpd, xserver, QSE_HTTPD_SERVERSTD_QUERY, &server_xtn->orgquery);
qse_httpd_getserverstdopt (httpd, xserver, QSE_HTTPD_SERVERSTD_MAKERSRC, &server_xtn->orgmakersrc);
qse_httpd_getserverstdopt (httpd, xserver, QSE_HTTPD_SERVERSTD_FREERSRC, &server_xtn->orgfreersrc);
/* set changeable callbacks */
qse_httpd_setserverstdopt (httpd, xserver, QSE_HTTPD_SERVERSTD_QUERY, query_server);
qse_httpd_setserverstdopt (httpd, xserver, QSE_HTTPD_SERVERSTD_MAKERSRC, make_resource);
qse_httpd_setserverstdopt (httpd, xserver, QSE_HTTPD_SERVERSTD_FREERSRC, free_resource);
/* remember the binding address used */
server_xtn->num = num;
server_xtn->bind = dope.nwad;
server_xtn->secure = (dope.flags & QSE_HTTPD_SERVER_SECURE);
return xserver;
}
static int load_hook_modules (qse_httpd_t* httpd, qse_xli_list_t* hook_list)
{
qse_char_t buf[32];
qse_xli_pair_t* file, * cfg, * mod;
qse_httpd_mod_t* module;
httpd_xtn_t* httpd_xtn;
int i;
httpd_xtn = qse_httpd_getxtn(httpd);
for (i = 0; ; i++)
{
qse_strxfmt (buf, QSE_COUNTOF(buf), QSE_T("module[%d]"), i);
mod = qse_xli_findpair (httpd_xtn->xli, hook_list, buf);
if (mod == QSE_NULL) break;
file = qse_xli_findpair (httpd_xtn->xli, (qse_xli_list_t*)mod->val, QSE_T("file"));
if (file == QSE_NULL)
{
/* TODO: log warning when file is not found in module */
}
else
{
module = qse_httpd_loadmod (httpd, ((qse_xli_str_t*)file->val)->ptr);
if (!module)
{
/* TODO: better error handling and logging */
qse_printf (QSE_T("WARNING: failed to load module [%s]\n"), ((qse_xli_str_t*)file->val)->ptr);
}
else
{
cfg = qse_xli_findpair (httpd_xtn->xli, (qse_xli_list_t*)mod->val, QSE_T("config"));
if (cfg)
{
if (!module->config)
{
qse_printf (QSE_T("WARNING: unneeded configuration for [%s]. no configuration handler\n"),
((qse_xli_str_t*)file->val)->ptr);
}
else
{
const qse_xli_atom_t* atom;
const qse_xli_pair_t* pair;
int x;
for (atom = ((qse_xli_list_t*)(cfg->val))->head; atom; atom = atom->next)
{
if (atom->type != QSE_XLI_PAIR) continue;
pair = (qse_xli_pair_t*)atom;
if (pair->val->type != QSE_XLI_STR) continue;
x = qse_httpd_configmod (httpd, module, pair->key, ((qse_xli_str_t*)pair->val)->ptr);
if (x <= -1)
{
qse_printf (QSE_T("WARNING: failed to set module configuration [%s] to [%s] for [%s]\n"),
pair->key, ((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)file->val)->ptr);
}
else if (x == 0)
{
qse_printf (QSE_T("WARNING: invalid module configuration item [%s] for [%s]\n"),
pair->key, ((qse_xli_str_t*)file->val)->ptr);
}
}
}
}
}
}
}
return i;
}
static int open_config_file (qse_httpd_t* httpd)
{
httpd_xtn_t* httpd_xtn;
qse_xli_iostd_t xli_in;
int trait, i;
static struct
{
const qse_char_t* name;
qse_xli_scm_t scm;
} defs[] =
{
{ QSE_T("name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("max-nofile"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("max-nproc"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("hooks"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("hooks.module"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYALIAS, 0, 0 } },
{ QSE_T("hooks.module.file"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("hooks.module.config"), { QSE_XLI_SCM_VALLIST |
QSE_XLI_SCM_KEYNODUP | QSE_XLI_SCM_VALIFFY, 0, 0 } },
{ QSE_T("server-default"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.backlog-size"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.ssl-cert-file"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.ssl-key-file"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.root"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.realm"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 0, 1 } },
{ QSE_T("server-default.auth"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 0, 1 } },
{ QSE_T("server-default.index"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 0xFFFF } },
{ QSE_T("server-default.auth-rule"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.auth-rule.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.auth-rule.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.auth-rule.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.auth-rule.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.cgi"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.cgi.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 0, 2 } },
{ QSE_T("server-default.cgi.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 0, 2 } },
{ QSE_T("server-default.cgi.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 0, 2 } },
{ QSE_T("server-default.mime"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.mime.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.mime.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.mime.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.mime.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.dir-access"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.dir-access.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.dir-access.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.dir-access.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.dir-access.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.file-access"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.file-access.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.file-access.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.file-access.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server-default.file-access.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.dir-head"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.dir-foot"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.error-head"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.error-foot"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server-default.proxy.http"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.https"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.connect"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.intercept"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.upgrade"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.x-forwarded"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.pseudonym"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.dns-enabled"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.dns-server"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.dns-timeout"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.dns-retries"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.dns-queries"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 0, 0xFFFF } },
{ QSE_T("server-default.proxy.dns-preresolve-hook"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.urs-enabled"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.urs-server"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.urs-timeout"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.urs-retries"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server-default.proxy.urs-prerewrite-hook"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server"), { QSE_XLI_SCM_VALLIST, 0, 0 } },
{ QSE_T("server.backlog-size"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.bind"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.ssl"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.ssl-cert-file"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.ssl-key-file"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYALIAS, 0, 0 } },
{ QSE_T("server.host.location"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYALIAS, 0, 0 } },
{ QSE_T("server.host.location.root"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 0, 1 } },
{ QSE_T("server.host.location.realm"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 0, 1 } },
{ QSE_T("server.host.location.auth"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.index"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 0xFFFF } },
{ QSE_T("server.host.location.auth-rule"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server.host.location.auth-rule.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.auth-rule.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.auth-rule.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.auth-rule.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.cgi"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server.host.location.cgi.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 0, 2 } },
{ QSE_T("server.host.location.cgi.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 0, 2 } },
{ QSE_T("server.host.location.cgi.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 0, 2 } },
{ QSE_T("server.host.location.mime"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server.host.location.mime.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.mime.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.mime.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.mime.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.dir-access"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server.host.location.dir-access.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.dir-access.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.dir-access.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.dir-access.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.file-access"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server.host.location.file-access.prefix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.file-access.suffix"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.file-access.name"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYALIAS, 1, 1 } },
{ QSE_T("server.host.location.file-access.other"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.dir-head"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.dir-foot"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.error-head"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.error-foot"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy"), { QSE_XLI_SCM_VALLIST | QSE_XLI_SCM_KEYNODUP, 0, 0 } },
{ QSE_T("server.host.location.proxy.http"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.https"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.connect"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.intercept"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.upgrade"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.x-forwarded"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.pseudonym"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.dns-enabled"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.dns-server"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.dns-timeout"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.dns-retries"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.dns-queries"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 0, 0xFFFF } },
{ QSE_T("server.host.location.proxy.dns-preresolve-hook"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.urs-enabled"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.urs-server"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.urs-timeout"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.urs-retries"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } },
{ QSE_T("server.host.location.proxy.urs-prerewrite-hook"), { QSE_XLI_SCM_VALSTR | QSE_XLI_SCM_KEYNODUP, 1, 1 } }
};
httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
QSE_ASSERT (httpd_xtn->xli == QSE_NULL);
httpd_xtn->xli = qse_xli_openstd (0, 0, QSE_NULL);
if (httpd_xtn->xli == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("Cannot open xli\n"));
return -1;
}
qse_xli_getopt (httpd_xtn->xli, QSE_XLI_TRAIT, &trait);
trait |= QSE_XLI_MULSEGSTR | QSE_XLI_VALIDATE;
qse_xli_setopt (httpd_xtn->xli, QSE_XLI_TRAIT, &trait);
for (i = 0; i < QSE_COUNTOF(defs); i++)
{
if (qse_xli_definepair (httpd_xtn->xli, defs[i].name, &defs[i].scm) <= -1)
{
qse_fprintf (QSE_STDERR, QSE_T("Cannot define %s - %s\n"), defs[i].name, qse_xli_geterrmsg(httpd_xtn->xli));
qse_xli_close (httpd_xtn->xli);
httpd_xtn->xli = QSE_NULL;
return -1;
}
}
xli_in.type = QSE_XLI_IOSTD_FILE;
xli_in.u.file.path = httpd_xtn->cfgfile;
xli_in.u.file.cmgr = QSE_NULL;
if (qse_xli_readstd (httpd_xtn->xli, &xli_in) <= -1)
{
const qse_xli_loc_t* errloc;
errloc = qse_xli_geterrloc (httpd_xtn->xli);
if (errloc->line > 0 || errloc->colm > 0)
{
qse_fprintf (QSE_STDERR, QSE_T("Cannot load %s at line %lu column %lu - %s\n"),
xli_in.u.file.path, (unsigned long int)errloc->line, (unsigned long int)errloc->colm, qse_xli_geterrmsg(httpd_xtn->xli));
}
else
{
qse_fprintf (QSE_STDERR, QSE_T("Cannot load %s - %s\n"), xli_in.u.file.path, qse_xli_geterrmsg(httpd_xtn->xli));
}
qse_xli_close (httpd_xtn->xli);
httpd_xtn->xli = QSE_NULL;
return -1;
}
return 0;
}
static int close_config_file (qse_httpd_t* httpd)
{
httpd_xtn_t* httpd_xtn;
httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
if (httpd_xtn->xli)
{
qse_xli_close (httpd_xtn->xli);
httpd_xtn->xli = QSE_NULL;
}
return 0;
}
static void set_limit (qse_httpd_t* httpd, const qse_char_t* name, int what)
{
qse_xli_pair_t* pair;
httpd_xtn_t* httpd_xtn;
httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, name);
if (pair)
{
#if defined(HAVE_GETRLIMIT) && defined(HAVE_SETRLIMIT)
struct rlimit lim;
QSE_ASSERT (pair->val->type == QSE_XLI_STR);
if (getrlimit (what, &lim) == 0)
{
const qse_char_t* str;
qse_size_t len;
str = ((qse_xli_str_t*)pair->val)->ptr;
len = ((qse_xli_str_t*)pair->val)->len;
if (qse_strxcmp (str, len, QSE_T("none")) != 0)
{
if (qse_strxcmp (str, len, QSE_T("unlimited")) == 0)
lim.rlim_cur = RLIM_INFINITY;
else
lim.rlim_cur = qse_strtoui (((qse_xli_str_t*)pair->val)->ptr, 10, QSE_NULL);
if (setrlimit (what, &lim) <= -1)
{
/* TODO: warning */
}
}
}
#endif
}
}
static int load_config (qse_httpd_t* httpd)
{
qse_xli_pair_t* pair;
httpd_xtn_t* httpd_xtn;
int i;
httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
if (open_config_file (httpd) <= -1) goto oops;
pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, QSE_T("name"));
if (pair)
{
qse_mchar_t* tmp;
QSE_ASSERT (pair->val->type == QSE_XLI_STR);
tmp = qse_httpd_strntombsdup (httpd, ((qse_xli_str_t*)pair->val)->ptr, ((qse_xli_str_t*)pair->val)->len);
if (tmp) qse_httpd_setname (httpd, tmp);
qse_httpd_freemem (httpd, tmp);
}
#if defined(RLIMIT_NOFILE)
set_limit (httpd, QSE_T("max-nofile"), RLIMIT_NOFILE);
#endif
#if defined(RLIMIT_NPROC)
set_limit (httpd, QSE_T("max-nproc"), RLIMIT_NPROC);
#endif
pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, QSE_T("hooks"));
if (pair) load_hook_modules (httpd, (qse_xli_list_t*)pair->val);
for (i = 0; ; i++)
{
qse_char_t buf[32];
qse_strxfmt (buf, QSE_COUNTOF(buf), QSE_T("server[%d]"), i);
pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, buf);
if (pair == QSE_NULL) break;
if (pair->val->type != QSE_XLI_LIST)
{
qse_fprintf (QSE_STDERR, QSE_T("WARNING: non-list value for server\n"));
}
else
{
qse_httpd_server_t* server;
server = attach_server (httpd, i, (qse_xli_list_t*)pair->val);
if (server)
{
if (load_server_config (httpd, server, (qse_xli_list_t*)pair->val) <= -1)
{
qse_fprintf (QSE_STDERR, QSE_T("failed to load configuration from %s\n"), httpd_xtn->cfgfile);
goto oops;
}
}
}
}
if (i == 0)
{
qse_fprintf (QSE_STDERR, QSE_T("No valid server specified in %s\n"), httpd_xtn->cfgfile);
goto oops;
}
/* load the global default */
pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, QSE_T("server-default"));
if (pair && pair->val->type == QSE_XLI_LIST)
{
if (load_loccfg (httpd, httpd_xtn->xli, (qse_xli_list_t*)pair->val, &httpd_xtn->dflcfg) <= -1)
{
qse_fprintf (QSE_STDERR, QSE_T("failed to load configuration from %s\n"), httpd_xtn->cfgfile);
goto oops;
}
}
close_config_file (httpd);
return 0;
oops:
close_config_file (httpd);
return -1;
}
static void reconf_server (qse_httpd_t* httpd, qse_httpd_server_t* server)
{
httpd_xtn_t* httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
server_xtn_t* server_xtn;
qse_xli_pair_t* pair;
/* reconfigure the server when the server is impeded in sig_reconf(). */
server_xtn = qse_httpd_getserverxtn(httpd, server);
if (httpd_xtn->xli)
{
qse_char_t buf[32];
qse_strxfmt (buf, QSE_COUNTOF(buf), QSE_T("server[%d]"), server_xtn->num);
pair = qse_xli_findpair (httpd_xtn->xli, QSE_NULL, buf);
if (pair && pair->val->type == QSE_XLI_LIST)
{
free_server_config (httpd, server);
load_server_config (httpd, server, (qse_xli_list_t*)pair->val);
}
}
}
static void impede_httpd (qse_httpd_t* httpd)
{
httpd_xtn_t* httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
/* reconfigure the server when the server is impeded in sig_reconf(). */
if (httpd_xtn->impede_code == 9999)
{
qse_httpd_stop (httpd);
}
else
{
if (open_config_file (httpd) >= 0)
{
qse_httpd_server_t* server;
server = qse_httpd_getfirstserver (httpd);
while (server)
{
if (server->dope.flags & QSE_HTTPD_SERVER_ACTIVE)
reconf_server (httpd, server);
server = qse_httpd_getnextserver (httpd, server);
}
close_config_file (httpd);
}
}
/* chain-call the orignal impedence function */
if (httpd_xtn->org_impede) httpd_xtn->org_impede (httpd);
}
static int prerewrite_url (qse_httpd_t* httpd, qse_httpd_client_t* client, qse_htre_t* req, const qse_mchar_t* host, qse_mchar_t** url)
{
httpd_xtn_t* httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
printf ("PREREWRITING.....................\n");
/*
if (qse_htre_getqmethodtype(req) == QSE_HTTP_CONNECT)
{
*url = QSE_NULL;
return 0;
}
*/
/* TODO: override prerewrite url */
return httpd_xtn->org_urs_prerewrite (httpd, client, req, host, url);
}
static void logact_httpd (qse_httpd_t* httpd, const qse_httpd_act_t* act)
{
/*httpd_xtn_t* httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);*/
qse_char_t tmp[128], tmp2[128], tmp3[128];
switch (act->code)
{
case QSE_HTTPD_CATCH_MERRMSG:
qse_printf (QSE_T("ERROR: %hs\n"), act->u.merrmsg);
break;
case QSE_HTTPD_CATCH_MWARNMSG:
qse_printf (QSE_T("WARNING: %hs\n"), act->u.mwarnmsg);
break;
case QSE_HTTPD_READERR_CLIENT:
qse_nwadtostr (&act->u.client->remote_addr, tmp, QSE_COUNTOF(tmp), QSE_NWADTOSTR_ALL);
qse_printf (QSE_T("failed to read client - %s\n"), tmp);
break;
}
}
/* --------------------------------------------------------------------- */
static void print_version (void)
{
qse_fprintf (QSE_STDOUT, QSE_T("QSEHTTPD %hs\n"), QSE_PACKAGE_VERSION);
qse_fprintf (QSE_STDOUT, QSE_T("Copyright 2006-2014 Chung, Hyung-Hwan\n"));
}
static void print_usage (qse_sio_t* out, int argc, qse_char_t* argv[])
{
const qse_char_t* b = qse_basename (argv[0]);
qse_fprintf (out, QSE_T("USAGE: %s [options] -c file\n"), b);
qse_fprintf (out, QSE_T(" %s [options] --config-file file\n"), b);
qse_fprintf (out, QSE_T("options as follows:\n"));
qse_fprintf (out, QSE_T(" -h/--help show this message\n"));
qse_fprintf (out, QSE_T(" --version show version\n"));
qse_fprintf (out, QSE_T(" -c/--config-file file specify a configuration file\n"));
qse_fprintf (out, QSE_T(" -d/--daemon run in the background\n"));
qse_fprintf (out, QSE_T(" -n string specify a process name if supported\n"));
qse_fprintf (out, QSE_T(" -x output debugging messages\n"));
}
static int handle_args (int argc, qse_char_t* argv[])
{
static qse_opt_lng_t lng[] =
{
{ QSE_T(":config-file"), QSE_T('c') },
{ QSE_T("daemon"), QSE_T('d') },
{ QSE_T("help"), QSE_T('h') },
{ QSE_T("version"), QSE_T('\0') },
{ QSE_NULL, QSE_T('\0') }
};
static qse_opt_t opt =
{
QSE_T("c:dhn:x"),
lng
};
qse_cint_t c;
while ((c = qse_getopt (argc, argv, &opt)) != QSE_CHAR_EOF)
{
switch (c)
{
default:
goto wrongusage;
case QSE_T('?'):
qse_fprintf (QSE_STDERR,
QSE_T("ERROR: bad option - %c\n"),
opt.opt
);
goto wrongusage;
case QSE_T(':'):
qse_fprintf (QSE_STDERR,
QSE_T("ERROR: bad parameter for %c\n"),
opt.opt
);
goto wrongusage;
case QSE_T('c'):
g_cfgfile = opt.arg;
break;
case QSE_T('d'):
g_daemon = 1;
break;
case QSE_T('h'):
print_usage (QSE_STDOUT, argc, argv);
return 0;
case QSE_T('n'):
{
/* i don't care about failure to set the name */
#if defined(HAVE_PRCTL)
#if !defined(PR_SET_NAME)
# define PR_SET_NAME 15
#endif
#if defined(QSE_CHAR_IS_MCHAR)
prctl (PR_SET_NAME, (unsigned long)opt.arg, 0, 0, 0);
#else
qse_mchar_t* mopt = qse_wcstombsdup (opt.arg, QSE_NULL, QSE_MMGR_GETDFL());
if (mopt)
{
prctl (PR_SET_NAME, (unsigned long)mopt, 0, 0, 0);
QSE_MMGR_FREE (QSE_MMGR_GETDFL(), mopt);
}
#endif
#endif
break;
}
case QSE_T('x'):
g_debug = 1;
break;
case QSE_T('\0'):
{
if (qse_strcmp(opt.lngopt, QSE_T("version")) == 0)
{
print_version ();
return 0;
}
break;
}
}
}
if (opt.ind < argc || g_cfgfile == QSE_NULL) goto wrongusage;
return 1;
wrongusage:
print_usage (QSE_STDERR, argc, argv);
return -1;
}
static void free_httpd_xtn (qse_httpd_t* httpd)
{
httpd_xtn_t* httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
free_loccfg_contents (httpd, &httpd_xtn->dflcfg);
}
static int httpd_main (int argc, qse_char_t* argv[])
{
qse_httpd_t* httpd = QSE_NULL;
httpd_xtn_t* httpd_xtn;
qse_ntime_t tmout;
int trait, ret;
qse_httpd_rcb_t rcb;
qse_httpd_ecb_t ecb;
qse_httpd_scb_t scb;
ret = handle_args (argc, argv);
if (ret <= -1) return -1;
if (ret == 0) return 0;
httpd = qse_httpd_openstd(QSE_SIZEOF(httpd_xtn_t), QSE_NULL);
if (httpd == QSE_NULL)
{
qse_fprintf (QSE_STDERR, QSE_T("ERROR: Cannot open httpd\n"));
goto oops;
}
qse_memset (&ecb, 0, QSE_SIZEOF(ecb));
ecb.close = free_httpd_xtn;
qse_httpd_pushecb (httpd, &ecb);
httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(httpd);
httpd_xtn->cfgfile = g_cfgfile;
if (load_config (httpd) <= -1) goto oops;
if (g_daemon)
{
if (daemonize (1) <= -1)
{
qse_fprintf (QSE_STDERR, QSE_T("ERROR: Cannot daemonize\n"));
goto oops;
}
}
g_httpd = httpd;
setup_signal_handlers ();
qse_httpd_getopt (httpd, QSE_HTTPD_TRAIT, &trait);
trait |= QSE_HTTPD_CGIERRTONUL | QSE_HTTPD_LOGACT /*| QSE_HTTPD_PROXYNOVIA*/;
qse_httpd_setopt (httpd, QSE_HTTPD_TRAIT, &trait);
tmout.sec = 10;
tmout.nsec = 0;
qse_httpd_setopt (httpd, QSE_HTTPD_TMOUT, &tmout);
tmout.sec = 30;
tmout.nsec = 0;
qse_httpd_setopt (httpd, QSE_HTTPD_IDLELIMIT, &tmout);
qse_httpd_getopt (httpd, QSE_HTTPD_SCB, &scb);
httpd_xtn->org_urs_prerewrite = scb.urs.prerewrite;
scb.urs.prerewrite = prerewrite_url;
qse_httpd_setopt (httpd, QSE_HTTPD_SCB, &scb);
qse_httpd_getopt (httpd, QSE_HTTPD_RCB, &rcb);
httpd_xtn->org_impede = rcb.impede;
rcb.impede = impede_httpd; /* executed when qse_httpd_impede() is called */
if (g_debug) rcb.logact = logact_httpd; /* i don't remember old logging handler */
qse_httpd_setopt (httpd, QSE_HTTPD_RCB, &rcb);
ret = qse_httpd_loopstd (httpd, QSE_NULL, QSE_NULL);
restore_signal_handlers ();
g_httpd = QSE_NULL;
if (ret <= -1) qse_fprintf (QSE_STDERR, QSE_T("Httpd error - %d\n"), qse_httpd_geterrnum (httpd));
oops:
if (httpd) qse_httpd_close (httpd);
return -1;
}
#if defined(__DOS__)
static void interrupt (*old_keyboard_handler)() = QSE_NULL;
static int impeded_for_keyboard = 0;
static void interrupt new_keyboard_handler (void)
{
if (!impeded_for_keyboard && g_httpd)
{
httpd_xtn_t* httpd_xtn = (httpd_xtn_t*)qse_httpd_getxtn(g_httpd);
int c;
/* TODO: read a keystroke... etc */
httpd_xtn->impede_code = 9999;
qse_httpd_impede (g_httpd);
impeded_for_keyboard = 1;
}
if (old_keyboard_handler) old_keyboard_handler ();
}
#endif
int qse_main (int argc, qse_achar_t* argv[])
{
int ret;
#if defined(_WIN32)
char locale[100];
UINT codepage;
WSADATA wsadata;
#elif defined(__DOS__)
extern BOOL _watt_do_exit;
#else
/* nothing */
#endif
#if defined(_WIN32)
codepage = GetConsoleOutputCP();
if (codepage == CP_UTF8)
{
/*SetConsoleOUtputCP (CP_UTF8);*/
qse_setdflcmgrbyid (QSE_CMGR_UTF8);
}
else
{
/* .codepage */
qse_fmtuintmaxtombs (locale, QSE_COUNTOF(locale),
codepage, 10, -1, QSE_MT('\0'), QSE_MT("."));
setlocale (LC_ALL, locale);
/*qse_setdflcmgrbyid (QSE_CMGR_SLMB);*/
}
#else
setlocale (LC_ALL, "");
/*qse_setdflcmgrbyid (QSE_CMGR_SLMB);*/
#endif
qse_open_stdsios ();
#if defined(__DOS__)
old_keyboard_handler = _dos_getvect (0x09);
_dos_setvect (0x09, new_keyboard_handler);
#endif
#if defined(_WIN32)
if (WSAStartup (MAKEWORD(2,0), &wsadata) != 0)
{
qse_fprintf (QSE_STDERR, QSE_T("Failed to start up winsock\n"));
ret = -1;
goto oops;
}
#elif defined(__DOS__)
_watt_do_exit = 0; /* prevent sock_init from exiting upon failure */
if (sock_init () != 0)
{
qse_fprintf (QSE_STDERR, QSE_T("Failed to initialize watt-32\n"));
ret = -1;
goto oops;
}
/*trace2com_init (1, 38400);*/
#endif
#if defined(USE_SSL)
SSL_load_error_strings ();
SSL_library_init ();
#endif
ret = qse_run_main (argc, argv, httpd_main);
#if defined(USE_SSL)
/* ERR_remove_state() should be called for each thread if the application is thread */
ERR_remove_state (0);
#if defined(HAVE_ENGINE_CLEANUP)
ENGINE_cleanup ();
#endif
ERR_free_strings ();
EVP_cleanup ();
#if defined(HAVE_CRYPTO_CLEANUP_ALL_EX_DATA)
CRYPTO_cleanup_all_ex_data ();
#endif
#endif
#if defined(_WIN32)
WSACleanup ();
#elif defined(__DOS__)
sock_exit ();
#endif
oops:
#if defined(__DOS__)
if (old_keyboard_handler)
_dos_setvect (0x09, old_keyboard_handler);
#endif
qse_close_stdsios ();
return ret;
}