Initial import of htcd system 1.0

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>

10 files changed, 1112 insertions, 0 deletions

diff --git a/src/serv/auth.cc b/src/serv/auth.cc
new file mode 100644
index 0000000..abf16b3
--- /dev/null
+++ b/src/serv/auth.cc
@@ -0,0 +1,162 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+
+const mstring default_tag=".default";
+
+/////////////////////////////////////////////////////////////////
+
+TOK_IMPL(remote_name) { out<<Reqd(env)->tcp->node.name; }
+TOK_IMPL(remote_address) { out<<Reqd(env)->tcp->node.ip; }
+TOK_IMPL(remote_port) { out<<Reqd(env)->tcp->port; }
+
+/////////////////////////////////////////////////////////////////
+
+inline int match(const sref& rem,const sref& longrem,const sref& dom)
+{
+  if(rem==dom) return 1;
+  if(*dom!='.') return 0;
+  if(longrem.right_last(dom)==dom) return 1;
+  return 0;
+}
+
+inline int allow(const sref& uname,const sref& list)
+{
+  mstring remote=First(uname);
+  mstring longrem=remote; if(longrem.find('.')<0) longrem+=default_tag;
+  if(remote.empty()) return 0;
+  if(First(list).empty()) return 1;
+  sref first,rest=list;
+  while(Split(first,rest)) if(match(remote,longrem,first)) return 1;
+  return 0;
+}
+
+TOK_IMPL(remote_allow) { out<<allow(Reqd(env)->tcp->node.name,env[0]); }
+TOK_IMPL(bindroot) { Reqd(env)->htcd()->bindroot=env[0]; }
+
+/////////////////////////////////////////////////////////////////
+
+TOK_IMPL(user_allow) {
+  htcd_req* htcd=Reqd(env);
+  mstring opt=env.parg(-1);
+  int now=opt.empty()?time(0):atoi(opt);
+  out<<htcd->user.allow_list(env[0],now,htcd->RootAllowed());
+}
+
+TOK_IMPL(on_clear) {
+  htcd_req* htcd=Reqd(env);
+  if(htcd->user.allow_list(env[0],time(0),htcd->RootAllowed())) env.parg(out,1);
+  else env.parg(out,2);
+}
+
+/////////////////////////////////////////////////////////////////
+
+TOK_IMPL(allowed) {
+  int ok=0;
+  if(!env.db) THROW("htc: no open database");
+  if(env.dbat>=0&&env.dbat<env.db->size()) {
+    user_t user;
+    env.db->Get(env.dbat,user.list);
+    if(user.list.size()!=user_tabs)
+      THROW("htc: cannot test - probably not a users database");
+    mstring opt=env.parg(-1);
+    int now=opt.empty()?time(0):atoi(opt);
+    ok=user.allow_list(env[0],now,Reqd(env)->RootAllowed());
+  }
+  out<<ok;
+}
+
+TOK_IMPL(ingroups) {
+  int ok=0;
+  if(!env.db) THROW("htc: no open database");
+  if(env.dbat>=0&&env.dbat<env.db->size()) {
+    user_t user;
+    env.db->Get(env.dbat,user.list);
+    if(user.list.size()!=user_tabs)
+      THROW("htc: cannot test - probably not a users database");
+    mstring opt=env.parg(-1);
+    int now=opt.empty()?time(0):atoi(opt);
+    ok=user.allow_list(env[0],now,-1);
+  }
+  out<<ok;
+}
+
+/////////////////////////////////////////////////////////////////
+
+void envAddAuth(tokmap& T)
+{
+  TOK_ADD(remote_name,"",tok_t::PUBLIC,
+          "%Remote hostname\n"
+          "%Syntax: \\remote.name\n"
+          );
+  TOK_ADD(remote_address,"",tok_t::PUBLIC,
+          "%Remote address\n"
+          "%Syntax: \\remote.address\n"
+          );
+  TOK_ADD(remote_port,"",tok_t::PUBLIC,
+          "%Remote port\n"
+          "%Syntax: \\remote.port\n"
+          );
+  
+  /////////////////////////////////////////////////////////////
+  
+  TOK_ADD(remote_allow,"x",tok_t::PUBLIC,
+          "%True if remote hostname allowed by domain\n"
+          "%Syntax: \\remote.allow{domain list}\n"
+          "%\n"
+          "%May be used to restrict access without any group\n"
+          );
+  TOK_ADD(bindroot,"x",tok_t::SYSONLY,
+          "%Bind root access to explicit addresses\n"
+          "%Syntax: \\bindroot{address list}\n"
+          "%\n"
+          "%Note that domain syntax does not work here; you\n"
+          "%want to have total control over all root access.\n"
+          );
+
+  /////////////////////////////////////////////////////////////
+
+  TOK_ADD(user_allow,"x?",tok_t::SYSONLY,
+          "%Core test on user clearance\n"
+          "%Syntax: \\user.allow{groups}<time>\n"
+          "%\n"
+          "%In case of several groups, all must be allowed.\n"
+          );
+  TOK_ADD(on_clear,"xr?",tok_t::SYSONLY,
+          "%Do if user is allowed in all groups now\n"
+          "%Syntax: \\on.clear{groups}{body}<else>\n"
+          );
+  
+  /////////////////////////////////////////////////////////////
+  
+  TOK_ADD(allowed,"x?",tok_t::SYSONLY,
+          "%True if the current record is allowed in all groups now\n"
+          "%Syntax: \\allowed{groups}<time>\n"
+          "%\n"
+          "%Only used as a query function\n"
+          );
+
+  TOK_ADD(ingroups,"x?",tok_t::SYSONLY,
+          "%True if the current record is part of all groups now\n"
+          "%Syntax: \\ingroups{groups}<time>\n"
+          "%\n"
+          "%Only used as a query function\n"
+          );
+}
diff --git a/src/serv/const.cc b/src/serv/const.cc
new file mode 100644
index 0000000..f252a17
--- /dev/null
+++ b/src/serv/const.cc
@@ -0,0 +1,69 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+
+inline tok_t* Const(tokmap& map,const char* s,const sref& b) throw(merror_t) {
+  return Const(map,sref(s),b,tok_t::PUBLIC);
+}
+
+void envAddConst(tokmap& T)
+{
+  Const(T,"HTTP.100",HTTP_100);
+  Const(T,"HTTP.101",HTTP_101);
+  Const(T,"HTTP.200",HTTP_200);
+  Const(T,"HTTP.201",HTTP_201);
+  Const(T,"HTTP.202",HTTP_202);
+  Const(T,"HTTP.203",HTTP_203);
+  Const(T,"HTTP.204",HTTP_204);
+  Const(T,"HTTP.205",HTTP_205);
+  Const(T,"HTTP.206",HTTP_206);
+  Const(T,"HTTP.300",HTTP_300);
+  Const(T,"HTTP.301",HTTP_301);
+  Const(T,"HTTP.302",HTTP_302);
+  Const(T,"HTTP.303",HTTP_303);
+  Const(T,"HTTP.304",HTTP_304);
+  Const(T,"HTTP.305",HTTP_305);
+  Const(T,"HTTP.306",HTTP_306);
+  Const(T,"HTTP.307",HTTP_307);
+  Const(T,"HTTP.400",HTTP_400);
+  Const(T,"HTTP.401",HTTP_401);
+  Const(T,"HTTP.402",HTTP_402);
+  Const(T,"HTTP.403",HTTP_403);
+  Const(T,"HTTP.404",HTTP_404);
+  Const(T,"HTTP.405",HTTP_405);
+  Const(T,"HTTP.406",HTTP_406);
+  Const(T,"HTTP.407",HTTP_407);
+  Const(T,"HTTP.408",HTTP_408);
+  Const(T,"HTTP.409",HTTP_409);
+  Const(T,"HTTP.410",HTTP_410);
+  Const(T,"HTTP.411",HTTP_411);
+  Const(T,"HTTP.412",HTTP_412);
+  Const(T,"HTTP.413",HTTP_413);
+  Const(T,"HTTP.414",HTTP_414);
+  Const(T,"HTTP.415",HTTP_415);
+  Const(T,"HTTP.416",HTTP_416);
+  Const(T,"HTTP.417",HTTP_417);
+  Const(T,"HTTP.500",HTTP_500);
+  Const(T,"HTTP.501",HTTP_501);
+  Const(T,"HTTP.502",HTTP_502);
+  Const(T,"HTTP.503",HTTP_503);
+  Const(T,"HTTP.504",HTTP_504);
+  Const(T,"HTTP.505",HTTP_505);
+}
diff --git a/src/serv/direct.cc b/src/serv/direct.cc
new file mode 100644
index 0000000..1e7c2d6
--- /dev/null
+++ b/src/serv/direct.cc
@@ -0,0 +1,73 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+#include <mt/dates.h>
+
+const mstring log_cmd="\\group:\\user.id";
+
+TOK_IMPL(error) {
+  throw("htc: 'error' no longer supported");
+}
+
+TOK_IMPL(log) {
+  htcd_req* htc=Reqd(env);
+  MLOCK(htc->htcd()->mutex);
+  fp_stream& tlog=htc->htcd()->errlog;
+  tlog<<"["<<time(0)<<"]["<<htc->tcp->node.ip<<"]["
+      <<htc->tcp->node.name<<":"<<htc->tcp->port<<"]["
+      <<htc->group<<":"<<htc->user.uid()<<"] ";
+  env.parg(tlog,0);
+  tlog<<"\n";
+  tlog.flush();
+}
+
+TOK_IMPL(output) {
+  env.parg(*Reqd(env)->output,0);
+}
+
+void envAddDirect(tokmap& T)
+{
+  TOK_ADD(output,"r",tok_t::PUBLIC,
+          "%Redirect to output stream\n"
+          "%Syntax: \\output{body}\n"
+          "%\n"
+          "%Normally used on server-level, when output refers\n"
+          "%to a socket.\n"
+          );
+
+  TOK_ADD(error,"r",tok_t::SYSONLY,
+          "%Redirect to error stream\n"
+          "%Syntax: \\error{body}\n"
+          "%\n"
+          "%Normally used for debugging and loggin of errors.\n"
+          );
+
+  TOK_ADD(log,"r",tok_t::SYSONLY,
+          "%Message log\n"
+          "%Syntax: \\log{msg}\n"
+          "%\n"
+          "%Outputs to log stream a single line with pre-set information:\n"
+          "%\n"
+          "%IP address\n"
+          "%Time\n"
+          "%Request\n"          
+          "%Response\n"          
+          );
+}
diff --git a/src/serv/form.cc b/src/serv/form.cc
new file mode 100644
index 0000000..815f9c4
--- /dev/null
+++ b/src/serv/form.cc
@@ -0,0 +1,102 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+
+const mstring tag="T.";
+const mstring ncookie_tag="ncookie";
+const mstring multipart_tag="multipart";
+const mstring body_tag="T.body";
+
+static mstring Tag(const sref& in)
+{
+  mstring name=in;
+  for(int i=0;i<name.size();i++) if(name[i]=='_') name[i]='.';
+  if(tag.empty()||tag==name.left(tag.size())) return name;
+  name.insert(0,tag);
+  return name;
+}
+
+static void AddConst(tokmap& map,const sref& s,const sref& b) throw(merror_t)
+{
+  tok_t* p=map.get_this(s);
+  if(p) {
+    mstring nb=p->body; nb.append(1,' '); nb+=b;
+    Const(map,s,nb,tok_t::PUBLIC,1);
+  }
+  else Const(map,s,b,tok_t::PUBLIC);
+}
+
+static void PushMultipart(tokmap& map,const Mime& root) throw(merror_t)
+{
+  rpile part;
+  if(root.Multipart(part)) {
+    for(int i=0;i<part.size();i++) {
+      Mime msg(part[i]);
+      if(msg.cont_disp_name.nempty()) {
+        mstring name=Tag(msg.cont_disp_name);
+        if(msg.cont_disp_file.nempty()) {
+          reference_t* tok=Reference(map,name,msg.cont_disp_file,tok_t::PUBLIC);
+          swrite via;
+          if(eqn(msg.cont_trans_enc,trans_base64))
+            decode64(via(tok->data),msg.body);
+          else if(eqn(msg.cont_trans_enc,trans_quote))
+            decodeQP(via(tok->data),msg.body);
+          else
+            via(tok->data)<<msg.body;
+        }
+        else AddConst(map,name,msg.body);
+      }
+    }
+  }
+}
+
+static void PushWWWForm(tokmap& map,const sref& in) throw(merror_t)
+{
+  sspile tmp;
+  Unpack(tmp,in);
+  for(int i=0;i<tmp.size();i++)
+    AddConst(map,Tag(tmp[i].first),tmp[i].second);
+}
+
+void SetCookies(tokmap& map,const httpReq& req)
+{
+  Const(map,ncookie_tag,itoa(req.cookies.size()),tok_t::PUBLIC);
+  int n=0;
+  for(sspile::const_iterator p=req.cookies.begin();p!=req.cookies.end();p++) {
+    mstring name,val;
+    name.convert("cookie%d.name",n);
+    val.convert("cookie%d.val",n);
+    Const(map,name,p->first,tok_t::PUBLIC);
+    Const(map,val,p->second,tok_t::PUBLIC);
+    n++;
+  }
+  if(req.arg.nempty()) PushWWWForm(map,req.arg);
+}
+
+void envAddForm(tokmap& map,const httpReq& req)
+{
+  if(req.method==HTTP_POST) {
+    if(req.cont_type.find(multipart_tag,cset_lcase)>=0) PushMultipart(map,req);
+    else PushWWWForm(map,req.body);
+  }
+  else if(req.method==HTTP_PUT) {
+    Const(map,body_tag,req.body,tok_t::PUBLIC);
+  }
+}
diff --git a/src/serv/htcd.h b/src/serv/htcd.h
new file mode 100644
index 0000000..7eaa8dc
--- /dev/null
+++ b/src/serv/htcd.h
@@ -0,0 +1,74 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef HTCdH
+#define HTCdH
+
+#include <serv/tempmap.h>
+#include <sh/htc.h>
+#include <http/http.h>
+
+///////////////////////////////////////////////////
+
+struct HTCd : public HTC {
+  fp_stream logger,errlog;
+  mstring bindroot;
+  mutex_t mutex;
+  
+  HTCd(const mstring& path);
+  ~HTCd();
+};
+
+///////////////////////////////////////////////////
+
+struct htcd_user : public htc_user {
+  htcd_user(tokmap& p,const mstring& path);
+};
+
+///////////////////////////////////////////////////
+
+struct tcpReq {
+  IPnode node;
+  int port;
+};
+
+///////////////////////////////////////////////////
+
+struct htcd_req : public htc_req {
+  mstream* output;
+  tcpReq* tcp;
+  httpReq* req;
+  httpResp resp;
+
+  HTCd* htcd() { return (HTCd*)glob; }
+  
+  void AddBody(const sref& body);
+  int RootAllowed();
+  
+  htcd_req(HTCd& g,tokmap& p,mstream& out,tcpReq& trec,httpReq& hrec);
+};
+
+inline htcd_req* Reqd(Env& env) throw(merror_t) { return (htcd_req*)env.req; }
+
+///////////////////////////////////////////////////
+
+void Setup(tokmap& user,HTCd& htcd);
+
+#endif
+
diff --git a/src/serv/htcs.cc b/src/serv/htcs.cc
new file mode 100644
index 0000000..42ac8e3
--- /dev/null
+++ b/src/serv/htcs.cc
@@ -0,0 +1,92 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+#include <hdb/buffer.h>
+#include <mt/lock.h>
+
+static fp_stream mout(stdout),merr(stderr);
+const mstring left="{",right="}";
+
+static int unbalanced(const sref& in)
+{
+  static const charset tag("{[(");
+  if(in.empty()) return 1;
+  sref s=in.right_first_of(tag);
+  while(s.nempty()) {
+    int p=-1;
+    switch(*s) {
+    case '{': p=s.skip(cset_braces); break;
+    case '[': p=s.skip(cset_indices); break;
+    case '(': p=s.skip(cset_para); break;
+    }
+    if(p<0) return 1;
+    s=s.adv(p).right_first_of(tag);
+  }
+  return 0;
+}
+
+main(int argc,char* argv[]) try
+{
+  NODELOCK(USERMAP);
+  if(argc<2) THROW("Usage: "<<argv[0]<<" <docroot>");
+  mstring path=argv[1];
+  if(path.back()=='/') path=path.popb();
+  HTCd htcd(path);
+  tokmap user(htcd.toks);
+  Setup(user,htcd);
+  htcd_user thr(user,path);
+  tcpReq tcp; tcp.port=0;
+  httpReq hreq; hreq.method="GET";
+  htcd_req req(htcd,thr.toks,mout,tcp,hreq);
+  Env env(htcd.ops,req,XSYSTEM);
+  if(argc>2) {
+    for(int i=3;i<argc;i++) env.xpush(left+sref(argv[i])+right);
+    mstring buffer; LoadBuffer(buffer,argv[2]);
+    if(*buffer=='#') buffer.erase(0,buffer.find('\n')+1);
+    mstream m;
+    env.eval(m,buffer,1);
+  }
+  else {
+    mstring buffer,line;
+    while(!feof(stdin)) {
+      merr<<"htcd>";
+      buffer.clear();
+      while(!feof(stdin)&&unbalanced(buffer)) {
+        getline(line,stdin);
+        buffer.append(sref(line));
+        buffer+='\n';
+      }
+      try {
+        env.parse(mout,buffer);
+        mout<<"\n";
+      }
+      catch(const merror_t& e) {
+        merr<<e.desc<<"\n";
+      }
+    }
+  }
+  return 0;
+}
+catch(const merror_t& e) {
+  merr<<"ERROR: ["<<e.desc<<"]\n";
+  return -1;
+}
+
+
diff --git a/src/serv/main.cc b/src/serv/main.cc
new file mode 100644
index 0000000..f02f10c
--- /dev/null
+++ b/src/serv/main.cc
@@ -0,0 +1,122 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+#include <hdb/buffer.h>
+
+const mstring RCURI="/sys/htcd.rc";
+const mstring TREEURI="/sys/sitemap.hdb";
+const mstring TEMPURI="/sys/temp.hdb";
+
+const mstring LOGURI="/sys/htcd.log";
+const mstring ERRURI="/sys/htcd.err";
+
+///////////////////////////////////////////////////
+
+static void OpenTREE(dbmap& db,const sref& path)
+{
+  mstring TREEMAP=path+TREEURI;
+  db.Open(TREEMAP,1);
+  if(db.Tables()==0) for(int i=0;i<tree_tabs;i++) db.InsertTable(i,tree_tab[i]);
+}
+
+static void OpenTEMP(dbmap& db,const sref& path)
+{
+  mstring TEMPMAP=path+TEMPURI;
+  db.Open(TEMPMAP,1);
+  if(db.Tables()==0) for(int i=0;i<temp_tabs;i++) db.InsertTable(i,temp_tab[i]);
+}
+
+htcd_user::htcd_user(tokmap& p,const mstring& path) : htc_user(p)
+{
+  OpenTREE(DBRef(toks,TREE_tag,ms_empty,tok_t::SYSONLY)->db,path);
+  OpenTEMP(DBRef(toks,TEMP_tag,ms_empty,tok_t::SYSONLY)->db,path);
+}
+
+///////////////////////////////////////////////////
+
+void SetCookies(tokmap& map,const httpReq& req);
+void envAddForm(tokmap& map,const httpReq& req);
+
+int htcd_req::RootAllowed()
+{
+  if(htcd()->bindroot.empty()) return 1;
+  sref first,rest=htcd()->bindroot;
+  while(Split(first,rest)) if(first==tcp->node.name) return 1;
+  return 0;
+}
+
+htcd_req::htcd_req(HTCd& g,tokmap& p,mstream& out,
+                   tcpReq& trec,httpReq& hrec) : htc_req(g,p)
+{
+  output=&out;
+  tcp=&trec;
+  req=&hrec;
+  SetCookies(toks,hrec);
+}
+
+void htcd_req::AddBody(const sref& body)
+{
+  req->body=body;
+  envAddForm(toks,*req);
+}
+
+///////////////////////////////////////////////////
+
+void envAddDirect(tokmap& map);
+void envAddReq(tokmap& map);
+void envAddConst(tokmap& map);
+void envAddAuth(tokmap& map);
+void envAddTemp(tokmap& map);
+
+HTCd::HTCd(const mstring& path):
+  logger(fopen((path+LOGURI).c_str(),"a+")),
+  errlog(fopen((path+ERRURI).c_str(),"a+")),
+  HTC(path)
+{
+  envAddDirect(toks);
+  envAddReq(toks);
+  envAddConst(toks);
+  envAddAuth(toks);
+  envAddTemp(toks);
+  
+  memset(&mutex,0,sizeof(mutex));
+  errlog<<"["<<time(0)<<"][MAIN][HTCd started]\n";
+  errlog.flush();
+}
+
+HTCd::~HTCd()
+{
+  fclose(errlog.fp);
+  fclose(logger.fp);
+}
+
+void Setup(tokmap& user,HTCd& htcd)
+{
+  tcpReq tcp; tcp.port=0;
+  httpReq hreq; hreq.method="GET";
+  mstream m1;
+  htcd_req req(htcd,htcd.toks,m1,tcp,hreq);
+  Env env(htcd.ops,req,XSYSTEM);
+  mstring buffer;
+  LoadBuffer(buffer,htcd.docroot+RCURI);
+  Env e(env,user,htcd.docroot+RCURI);
+  mstream m2;
+  e.parse(m2,buffer);
+}
diff --git a/src/serv/request.cc b/src/serv/request.cc
new file mode 100644
index 0000000..163797f
--- /dev/null
+++ b/src/serv/request.cc
@@ -0,0 +1,279 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+
+TOK_IMPL(req_mime_version) { out<<Reqd(env)->req->mime_version; }
+TOK_IMPL(req_cont_type) { out<<Reqd(env)->req->cont_type; }
+TOK_IMPL(req_cont_type_charset) { out<<Reqd(env)->req->cont_type_charset; }
+TOK_IMPL(req_cont_type_name) { out<<Reqd(env)->req->cont_type_name; }
+TOK_IMPL(req_cont_type_boundary) { out<<Reqd(env)->req->cont_type_boundary; }
+TOK_IMPL(req_cont_id) { out<<Reqd(env)->req->cont_id; }
+TOK_IMPL(req_cont_desc) { out<<Reqd(env)->req->cont_desc; }
+TOK_IMPL(req_cont_disp) { out<<Reqd(env)->req->cont_disp; }
+TOK_IMPL(req_cont_disp_name) { out<<Reqd(env)->req->cont_disp_name; }
+TOK_IMPL(req_cont_disp_file) { out<<Reqd(env)->req->cont_disp_file; }
+TOK_IMPL(req_cont_trans_enc) { out<<Reqd(env)->req->cont_trans_enc; }
+TOK_IMPL(req_cont_length) { out<<Reqd(env)->req->cont_length; }
+
+TOK_IMPL(req_cache) { out<<Reqd(env)->req->cache; }
+TOK_IMPL(req_connect) { out<<Reqd(env)->req->connect; }
+TOK_IMPL(req_date) { out<<Reqd(env)->req->date; }
+TOK_IMPL(req_pragma) { out<<Reqd(env)->req->pragma; }
+TOK_IMPL(req_trailer) { out<<Reqd(env)->req->trailer; }
+TOK_IMPL(req_trans_enc) { out<<Reqd(env)->req->trans_enc; }
+TOK_IMPL(req_upgrade) { out<<Reqd(env)->req->upgrade; }
+TOK_IMPL(req_via) { out<<Reqd(env)->req->via; }
+TOK_IMPL(req_warning) { out<<Reqd(env)->req->warning; }
+TOK_IMPL(req_allow) { out<<Reqd(env)->req->allow; }
+TOK_IMPL(req_cont_enc) { out<<Reqd(env)->req->cont_enc; }
+TOK_IMPL(req_cont_lang) { out<<Reqd(env)->req->cont_lang; }
+TOK_IMPL(req_cont_location) { out<<Reqd(env)->req->cont_location; }
+TOK_IMPL(req_cont_md5) { out<<Reqd(env)->req->cont_md5; }
+TOK_IMPL(req_cont_range) { out<<Reqd(env)->req->cont_range; }
+TOK_IMPL(req_expires) { out<<Reqd(env)->req->expires; }
+TOK_IMPL(req_lastmod) { out<<Reqd(env)->req->lastmod; }
+
+TOK_IMPL(req_method) { out<<Reqd(env)->req->method; }
+TOK_IMPL(req_uri) { out<<Reqd(env)->req->uri; }
+TOK_IMPL(req_arg) { out<<Reqd(env)->req->arg; }
+TOK_IMPL(req_version) { out<<Reqd(env)->req->version; }
+TOK_IMPL(req_accept) { out<<Reqd(env)->req->accept; }
+TOK_IMPL(req_accept_charset) { out<<Reqd(env)->req->accept_charset; }
+TOK_IMPL(req_accept_enc) { out<<Reqd(env)->req->accept_enc; }
+TOK_IMPL(req_accept_lang) { out<<Reqd(env)->req->accept_lang; }
+TOK_IMPL(req_accept_range) { out<<Reqd(env)->req->accept_range; }
+TOK_IMPL(req_auth) { out<<Reqd(env)->req->auth; }
+TOK_IMPL(req_expect) { out<<Reqd(env)->req->expect; }
+TOK_IMPL(req_from) { out<<Reqd(env)->req->from; }
+TOK_IMPL(req_host) { out<<Reqd(env)->req->host; }
+TOK_IMPL(req_if_match) { out<<Reqd(env)->req->if_match; }
+TOK_IMPL(req_if_mod) { out<<Reqd(env)->req->if_mod; }
+TOK_IMPL(req_if_none) { out<<Reqd(env)->req->if_none; }
+TOK_IMPL(req_if_range) { out<<Reqd(env)->req->if_range; }
+TOK_IMPL(req_if_unmod) { out<<Reqd(env)->req->if_unmod; }
+TOK_IMPL(req_max_forwards) { out<<Reqd(env)->req->max_forwards; }
+TOK_IMPL(req_proxy) { out<<Reqd(env)->req->proxy; }
+TOK_IMPL(req_range) { out<<Reqd(env)->req->range; }
+TOK_IMPL(req_referer) { out<<Reqd(env)->req->referer; }
+TOK_IMPL(req_te) { out<<Reqd(env)->req->te; }
+TOK_IMPL(req_useragent) { out<<Reqd(env)->req->user_agent; }
+
+///////////////////////////////////////////////////////////////////
+
+TOK_IMPL(resp_cookie) {
+  Reqd(env)->resp.set_cookies.push_back(cookie_t(env[0],env[1],env.parg(2)));
+}
+TOK_IMPL(resp_mime_version) { Reqd(env)->resp.mime_version=env[0]; }
+TOK_IMPL(resp_cont_type) { Reqd(env)->resp.cont_type=env[0]; }
+TOK_IMPL(resp_cont_type_charset) { Reqd(env)->resp.cont_type_charset=env[0]; }
+TOK_IMPL(resp_cont_type_name) { Reqd(env)->resp.cont_type_name=env[0]; }
+TOK_IMPL(resp_cont_type_boundary) { Reqd(env)->resp.cont_type_boundary=env[0]; }
+TOK_IMPL(resp_cont_id) { Reqd(env)->resp.cont_id=env[0]; }
+TOK_IMPL(resp_cont_desc) { Reqd(env)->resp.cont_desc=env[0]; }
+TOK_IMPL(resp_cont_disp) { Reqd(env)->resp.cont_disp=env[0]; }
+TOK_IMPL(resp_cont_disp_name) { Reqd(env)->resp.cont_disp_name=env[0]; }
+TOK_IMPL(resp_cont_disp_file) { Reqd(env)->resp.cont_disp_file=env[0]; }
+TOK_IMPL(resp_cont_trans_enc) { Reqd(env)->resp.cont_trans_enc=env[0]; }
+TOK_IMPL(resp_cont_length) { Reqd(env)->resp.cont_length=env[0]; }
+
+TOK_IMPL(resp_cache) { Reqd(env)->resp.cache=env[0]; }
+TOK_IMPL(resp_connect) { Reqd(env)->resp.connect=env[0]; }
+TOK_IMPL(resp_date) { Reqd(env)->resp.date=env[0]; }
+TOK_IMPL(resp_pragma) { Reqd(env)->resp.pragma=env[0]; }
+TOK_IMPL(resp_trailer) { Reqd(env)->resp.trailer=env[0]; }
+TOK_IMPL(resp_trans_enc) { Reqd(env)->resp.trans_enc=env[0]; }
+TOK_IMPL(resp_upgrade) { Reqd(env)->resp.upgrade=env[0]; }
+TOK_IMPL(resp_via) { Reqd(env)->resp.via=env[0]; }
+TOK_IMPL(resp_warning) { Reqd(env)->resp.warning=env[0]; }
+TOK_IMPL(resp_allow) { Reqd(env)->resp.allow=env[0]; }
+TOK_IMPL(resp_cont_enc) { Reqd(env)->resp.cont_enc=env[0]; }
+TOK_IMPL(resp_cont_lang) { Reqd(env)->resp.cont_lang=env[0]; }
+TOK_IMPL(resp_cont_location) { Reqd(env)->resp.cont_location=env[0]; }
+TOK_IMPL(resp_cont_md5) { Reqd(env)->resp.cont_md5=env[0]; }
+TOK_IMPL(resp_cont_range) { Reqd(env)->resp.cont_range=env[0]; }
+TOK_IMPL(resp_expires) { Reqd(env)->resp.expires=env[0]; }
+TOK_IMPL(resp_lastmod) { Reqd(env)->resp.lastmod=env[0]; }
+
+TOK_IMPL(resp_version) { Reqd(env)->resp.version=env[0]; }
+TOK_IMPL(resp_status) { Reqd(env)->resp.status=env[0]; }
+TOK_IMPL(resp_age) { Reqd(env)->resp.age=env[0]; }
+TOK_IMPL(resp_etag) { Reqd(env)->resp.etag=env[0]; }
+TOK_IMPL(resp_location) { Reqd(env)->resp.location=env[0]; }
+TOK_IMPL(resp_proxy_auth) { Reqd(env)->resp.proxy_authent=env[0]; }
+TOK_IMPL(resp_retry) { Reqd(env)->resp.retry=env[0]; }
+TOK_IMPL(resp_server) { Reqd(env)->resp.server=env[0]; }
+TOK_IMPL(resp_vary) { Reqd(env)->resp.vary=env[0]; }
+TOK_IMPL(resp_auth) { Reqd(env)->resp.authent=env[0]; }
+
+TOK_IMPL(resp_accept) { Reqd(env)->resp.accept=env[0]; }
+TOK_IMPL(resp_accept_charset) { Reqd(env)->resp.accept_charset=env[0]; }
+TOK_IMPL(resp_accept_enc) { Reqd(env)->resp.accept_enc=env[0]; }
+TOK_IMPL(resp_accept_lang) { Reqd(env)->resp.accept_lang=env[0]; }
+TOK_IMPL(resp_accept_range) { Reqd(env)->resp.accept_range=env[0]; }
+
+///////////////////////////////////////////////////////////////////
+
+TOK_IMPL(resp_getstatus) { out<<Reqd(env)->resp.status; }
+
+///////////////////////////////////////////////////////////////////
+
+TOK_IMPL(andarg) { sref s=Reqd(env)->req->arg; if(s.nempty()) out.put('?')<<s; }
+
+///////////////////////////////////////////////////////////////////
+
+const mstring reqhelp="%Request header entry\n";
+const mstring resphelp="%Response header entry; takes one argument\n";
+const mstring respgethelp="%Get response header entry\n";
+const mstring x_tag="x";
+
+void envAddReq(tokmap& T)
+{
+  TOK_ADD(req_mime_version,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_type,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_type_charset,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_type_name,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_type_boundary,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_id,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_desc,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_disp,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_disp_name,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_disp_file,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_trans_enc,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_length,ms_empty,tok_t::PUBLIC,reqhelp);
+  
+  TOK_ADD(req_cache,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_connect,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_date,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_pragma,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_trailer,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_trans_enc,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_upgrade,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_via,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_warning,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_allow,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_enc,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_lang,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_location,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_md5,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_cont_range,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_expires,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_lastmod,ms_empty,tok_t::PUBLIC,reqhelp);
+  
+  TOK_ADD(req_method,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_uri,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_arg,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_version,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_accept,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_accept_charset,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_accept_enc,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_accept_lang,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_accept_range,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_auth,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_expect,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_from,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_host,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_if_match,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_if_mod,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_if_none,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_if_range,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_if_unmod,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_max_forwards,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_proxy,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_range,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_referer,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_te,ms_empty,tok_t::PUBLIC,reqhelp);
+  TOK_ADD(req_useragent,ms_empty,tok_t::PUBLIC,reqhelp);
+
+  ///////////////////////////////////////////////////////////////
+
+  TOK_ADD(andarg,ms_empty,tok_t::PUBLIC,
+          "%Conditional output of argument string\n"
+          "%Syntax: \\andarg\n"
+          "%\n"
+          "%Outputs ?\\req.arg if \\req.arg is non-empty.\n"
+          );
+
+  TOK_ADD(resp_cookie,"xx?",tok_t::SYSONLY,
+          "%Set cookie\n"
+          "%Syntax: \\resp.cookie{name}{val}<options>\n"
+          "%\n"
+          "%Sets the cookie name to value val\n"
+          "%The options field should be on the form expected\n"
+          "%in the HTTP header, for instance\n"
+          "%domain=something; path=/; expires=http-data\n"
+          "%\n"
+          "%No newlines should be added, and remember that ; needs\n"
+          "%to be escaped.\n"
+          );
+
+  ///////////////////////////////////////////////////////////////
+
+  TOK_ADD(resp_mime_version,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_type,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_type_charset,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_type_name,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_type_boundary,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_id,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_desc,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_disp,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_disp_name,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_disp_file,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_trans_enc,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_length,x_tag,tok_t::SYSONLY,resphelp);
+
+  TOK_ADD(resp_cache,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_connect,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_date,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_pragma,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_trailer,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_trans_enc,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_upgrade,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_via,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_warning,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_allow,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_enc,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_lang,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_location,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_md5,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_cont_range,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_expires,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_lastmod,x_tag,tok_t::SYSONLY,resphelp);
+
+  TOK_ADD(resp_version,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_status,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_age,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_etag,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_location,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_proxy_auth,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_retry,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_server,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_vary,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_auth,x_tag,tok_t::SYSONLY,resphelp);
+
+  TOK_ADD(resp_accept,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_accept_charset,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_accept_enc,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_accept_lang,x_tag,tok_t::SYSONLY,resphelp);
+  TOK_ADD(resp_accept_range,x_tag,tok_t::SYSONLY,resphelp);
+
+  ///////////////////////////////////////////////////////////////
+
+  TOK_ADD(resp_getstatus,ms_empty,tok_t::PUBLIC,respgethelp);
+}
diff --git a/src/serv/tempmap.cc b/src/serv/tempmap.cc
new file mode 100644
index 0000000..43b8732
--- /dev/null
+++ b/src/serv/tempmap.cc
@@ -0,0 +1,82 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <serv/htcd.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+const mstring TEMPDIR="/tmp/";
+
+inline dbmap* GetDB(Env& env)
+{
+  dbref_t* p=(dbref_t*)env.toks->get(TEMP_tag);
+  if(!env.is_clear(p)||!p->is_dbref()) THROW("htc: could not find tempfile db");
+  p->db.remap();
+  return &p->db;
+}
+
+TOK_IMPL(tempfile)
+{
+  mstring path=Reqd(env)->htcd()->docroot+TEMPDIR;
+  mstring file=Random(8),ext=env[1];
+  int fd;
+  while((fd=open((path+file+ext).c_str(),O_CREAT|O_EXCL|O_WRONLY|O_TRUNC,0600))==-1)
+    file=Random(8);
+  close(fd);
+  tempmap_t temp;
+  temp.name()=file+ext;
+  temp.start()=itoa(time(0));
+  temp.stop()=itoa(time(0)+atoi(env[0]));
+  temp.refer()=Reqd(env)->user.uid();
+  dbmap* db=GetDB(env);
+  if(db->empty()) temp.id()=itoa(1);
+  else temp.id()=itoa(atoi(db->at(db->size()-1,temp_id))+1);
+  int row=db->Insert(temp.list,1);
+  if(row<0) THROW("htc: could not add tempfile - record not unique");
+  out<<temp.name();
+}
+
+TOK_IMPL(tempfile_update)
+{
+  mstring path=Reqd(env)->htcd()->docroot+TEMPDIR;
+  time_t now=time(0);
+  dbmap* db=GetDB(env);
+  int n=0;
+  while(n<db->size()) {
+    if(now>atoi(db->at(n,temp_stop))) {
+      remove((path+db->at(n,temp_name)).c_str());
+      db->Rem(n);
+    }
+    else n++;
+  }
+}
+
+void envAddTemp(tokmap& T)
+{
+  TOK_ADD(tempfile,"xx",tok_t::SYSONLY,
+          "%Create a temporary file"
+          "%Syntax: \\tempfile{duration}{.ext}\n"
+          );
+  TOK_ADD(tempfile_update,"",tok_t::SYSONLY,
+          "%Update tempfile database\n"
+          "%Syntax: \\tempfile_update\n"
+          );
+}
+
diff --git a/src/serv/tempmap.h b/src/serv/tempmap.h
new file mode 100644
index 0000000..0b9cf5a
--- /dev/null
+++ b/src/serv/tempmap.h
@@ -0,0 +1,57 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#ifndef TEMPMAPH
+#define TEMPMAPH
+
+#include <sh/htc.h>
+
+const mstring TEMP_tag="TEMP";
+
+const int temp_tabs=5,temp_id=0,temp_name=1,temp_start=2,temp_stop=3;
+const mstring temp_tab[temp_tabs]={
+  "ID","NAME","START","STOP","REFER"
+};
+
+struct tempmap_t {
+  spile list;
+  
+  tempmap_t() : list(temp_tabs) { reset(); }
+  
+  mstring& id() { return list[0]; }
+  mstring& name() { return list[1]; }
+  mstring& start() { return list[2]; }
+  mstring& stop() { return list[3]; }
+  mstring& refer() { return list[4]; }
+
+  void reset() {
+    list.resize(temp_tabs);
+    id()=itoa(0);
+    name().clear();
+    start()=itoa(0);
+    stop()=itoa(0);
+    refer()=itoa(0);
+  }
+};
+
+/////////////////////////////////////////////////////////
+
+void envAddTemp(tokmap& T);
+
+#endif