ref/srv.html

<html dir="ltr">
<head>
<meta content="text/html; charset=UTF-8" http-equiv="Content-Type"/>
<title>Arc: Web server</title>
<link rel="shortcut icon" href="/assets/favicon.png">
<link rel="stylesheet" type="text/css" href="code.css">
<link href="/assets/bootstrap.css" rel="stylesheet">
</head>
<body style='margin:12px 50px 0'>
  <div class="navbar navbar-inverse">
    <div class="navbar-inner">
      <ul class="nav navbar-nav">
        <li><a href="/ref/">Arc 3.1</a>
        <li><a href="http://tryarc.org">Try it</a></li>
        <li><a href="http://github.com/arclanguage/anarki">Get it</a></li>
        <li><a href="http://ycombinator.com/arc/tut.txt">Tutorial</a></li>
        <li><a href="http://arclanguage.org/forum">Forum</a></li>
      </ul>
    </div>
  </div> <!-- end of navbar -->
<div class="links">Previous: <a href="html.html">HTML generation</a>
Up: <a href="index.html">Contents</a>
Next: <a href="app.html">The Arc application server</a>
</div>
<h1 class="links">Web server</h1>
Arc includes a web server with several interesting features, including a continuation-based design.  The web server includes many different operations to create forms and links with associated continuations.
<p>
The Arc distribution comes with sample web applications including a new site (<code>news.arc</code>) and a blog (<code>blog.arc</code>).
<h2>Running the server</h2>
The server can be started simply with
<pre class="repl">
arc>(serve 8080)
</pre>
<p>
However, it is generally better to start the server in a separate thread, so the Arc REPL can be used.  This allows the web server to be modified while it is running.
<pre class="repl">
arc> (thread (serve 8080))
</pre>
A handler can be associated with a URL using the <code>defop</code> macro; this defines a handler function, taking the <code>req</code> parameter:
<pre class="code">
(defop hello req (prn "Hello world!"))
</pre>
The resulting page can be accessed at <a href="http://localhost:8080/hello">http://localhost:8080/hello</a>.
<p>
The Arc web server is rather fragile and platform-dependent.  If you encounter problems, the easiest solution is to use the unofficial <a href="http://arcfn.com/2008/02/git-and-anarki-arc-repository-brief.html">Anarki version</a>, which has multiple patches.
<p>
To define a top-level page (<a href="http://localhost:8080">http://localhost:8080</a>), use the page name <code>||</code> (the MzScheme representation of the empty symbol, between <a href="http://download.plt-scheme.org/doc/372/html/mzscheme/mzscheme-Z-H-11.html#node_sec_11.2.4">quoting vertical bars</a>).
<pre class="code">
(defop || req (pr "This is the home page."))
</pre>
<p>
To redirect a page to a different page, the <code>defopr</code> macro is used, with a function that outputs the name of the target page.  For example, to redirect <a href="http://localhost:8080/index.html">http://localhost:8080/index.html</a> to the earlier "hello" page:
<pre class="code">
(defopr index.html req (prn "hello"))
</pre>
<p>
The <code>req</code> parameter receives a table that has the field <code>ip</code> holding the IP address of the client, and potentially <code>cooks</code> holding the cookies, and <code>args</code> holding a list of key value pairs from the URL's query string.
<p>
The <code>defop-raw</code> and <code>defopr-raw</code> macros let the handler function add HTTP headers.  The handler must then output a blank line followed by the HTML content or redirect path.  One use of this is to add cookies to the headers.
<pre class="code">
 (defop-raw bar (str req) (w/stdout str
   (prn "Set-Cookie: mycookie=42")
   (prn)
   (prn (req 'ip)) (br) (prn (req 'cooks)) (br) (prn (req 'args))))
</pre>
On the second reload (after the cookie gets assigned), <a href="http://localhost:8080/bar?x=1&y=2&z">http://localhost:8080/bar?x=1&y=2&z</a> will display:
<pre class="code">
127.0.0.1
((mycookie 42))
((x 1) (y 2) (z ))
</pre>
This illustrates how the handler can access the client's IP address, the cookies, and the URL query parameters.  The handle does not have access to other HTTP headers.
<p>
This functionality can be used to implement a simple form and form handler; the form is at <a href="http://localhost:8080/myform">http://localhost:8080/myform</a>.  This example uses some of the <a href="html.html">HTML functions</a>.
<pre class="code">
(defop myform req (form "myhandler" (single-input "Enter:" 'foo 10 "Submit")))
(defop myhandler req  (prn "You entered") (prbold (alref (req 'args) "foo")))
</pre>

<p>
Several types of output functions are supported by Arc.  The simplest is a function that outputs HTML.  A function can also optionally output additional HTTP headers.  Arc also supports redirect functions that can perform server-side operations and then redirect the browser to a new page; these functions can optionally output additional headers.  Finally, Arc has partial support for asynchronous functions, which don't return any response to the request.
<p>
The following table shows the macros for generating arbitrary server-side handlers of the given types.
<table width=100% class="info">
<tr><th width=16%>&nbsp;</th><th width=16%>HTML</th><th width=16%>Headers + HTML</th><th width=16%>Redirect</th><th width=16%>Headers + Redirect</th></tr>
<tr>
<th>Macro</th>
<td><code>defop</code></td>
<td><code>defop-raw</code></td>
<td><code>defopr</code></td>
<td><code>defopr-raw</code></td>
</tr></table>
<h2>Continuations</h2>
The previous section showed how to implement basic HTML and redirect handlers in Arc.
Arc's web server also provides continuation support, which is typically used for handlers.  That is, links and forms can be assigned a function that will be executed on the server if the link or form is clicked.
(The continuation would be called a callback in some languages.)
<p>
The continuations used by the web server are explicit function.  (The web server does not use <code>ccc</code> first-class continuations.)  The functions take a request object as argument and print the appropriate response.  By using closures, the functions can maintain state across requests; the state will be included in the closure when the function is defined, and the function can access the state when it is later invoked.
<p>
The web server includes many operations to associate continuation functions and fnids with links and forms.
The web server contains operations to generate links and forms of the various types, as shown in the following table.
<p>
The previous example can be implemented with continuations as follows:
<pre class="code">
(defop myform2 req (aform myfunc (single-input "Enter:" 'foo 10 "Submit")))
(def myfunc (req) (prn "You entered") (prbold (alref (req 'args) "foo")))
</pre>
Generally, the continuation function is defined within the original form definition, so a closure can be created.  (In this case, the closure is unnecessary, as no state from the first operation is preserved.)
<pre class="code">
(defop myform2 req (aform
  [do (prn "You entered") (prbold (alref (_ 'args) "foo"))]
  (single-input "Enter:" 'foo 10 "Submit")))
</pre>
<p>
Internally, the web server associates a token called the <code>fnid</code> with each instance of a link or form, and records the continuation function for each token.  Periodically, old fnids are deleted.
<p>
The following table illustrates the operations to generate links, URLs, or forms, for the four different types of output functions.  (In practice, both <code>arform</code> and <code>arformh</code> give access to the headers.)
<table width=100% class="info">
<tr><th width=16%>&nbsp;</th><th width=16%>HTML</th><th width=16%>Headers + HTML</th><th width=16%>Redirect</th><th width=16%>Headers + Redirect</th></tr>
<tr>
<th>Link generation</th>
<td><code>w/link, w/link-if, onlink, linkf</code></td>
<td><code></code></td>
<td><code>w/rlink, rlinkf</code></td>
<td><code></code></td>
</tr>
<tr>
<th>URL generation</th>
<td><code>flink, url-for</code></td>
<td><code></code></td>
<td><code>rflink</code></td>
<td><code></code></td>
</tr>
<tr>
<th>Form generation</th>
<td><code>aform, timed-aform</code></td>
<td><code>aformh</code></td>
<td><code>arform</code></td>
<td><code>arformh</code></td>
</tr>
</table>
<p>
Different operations use one of five different mechanisms to specify the continuation function.  The function may be specified as an expression, a function of one variable (the request object), a request parameter and body, output stream and request parameters and a body, or a body alone.  The documentation should be consulted to see which mechanism goes with which function.
<h2>Explanation of the "Arc Challenge" solution</h2>
The <a href="http://www.paulgraham.com/arcchallenge.html">Arc Challenge</a> posed the problem of implementing a simple web function.  Under the URL "/said", it provides a form with input field.  When submitted, the form goes to a page with a link "click here".  The link leads to a page with the text "You said: " followed by the original input.
<p>
The solution in Arc is as follows:
<pre class="code">
(defop said req
  (aform [w/link (pr "you said: " (arg _ "foo"))
           (pr "click here")]
    (input "foo") 
    (submit)))
</pre>
The solution may be easier to understand if the continuation functions are made explicit:
<pre class="code">
(defop said req
  (aform form-continuation
    (input "foo") 
    (submit)))

(def form-continuation (req) 
  (w/link 
      (pr "you said: " (arg req "foo")) ;link continuation expression
    (pr "click here")))
</pre>
The <code>said</code> operation creates a form that when submitted
executes the <code>form-continuation</code> function.  The continuation function
creates a link that will execute the link continuation expression.
The important thing to notice is the link continuation expression is defined
inside <code>form-continuation</code>, which results in a closure with the
<code>req</code> object from <code>form-continuation</code>.  That is,
when the link continuation executes, potentially a long time after
<code>form-continuation</code> completes, it will still have the state.
This illustrates how closures can be used to carry state from one request
to another.
The form can be executed multiple times, and each execution will have a unique state in the link continuation closure.
<h2>Web server</h2>
<p><table class='arc'>
  <tr>
    <td class='arc'><a name='defop'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>defop</span> <span class='args'>name req-param [body ...]</span>
    <div class='desc'>Defines a HTML response handler for the URL path <code>name</code>.  The handler body takes one parameter, the <code>req</code> object and should output to <code>stdout</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop foo req (prn "Hello"))
<span class="return">#&lt;procedure: gs2265&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='defop-raw'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>defop-raw</span> <span class='args'>name (outstream-param req-param) [body ...]</span>
    <div class='desc'>Defines a HTML response handler for the URL path <code>name</code>.  The handler body takes two parameters: the output stream and the <code>req</code> object.  The handler can output additional HTTP headers.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop-raw fooraw (str req)
  (w/stdout str (prn "X-Arc: foo") (prn) (prn "Hello")))
<span class="return">#&lt;procedure: gs2271&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='defopr'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>defopr</span> <span class='args'>name req-param [body ...]</span>
    <div class='desc'>Defines a redirect response handler for the URL path <code>name</code>.  The handler body takes one parameter, the <code>req</code> object and should output to <code>stdout</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defopr bar req (prn "foo"))
<span class="return">#&lt;procedure: gs2282&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='defopr-raw'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>defopr-raw</span> <span class='args'>name (outstream-param req-param) [body ...]</span>
    <div class='desc'>Defines a redirect response handler for the URL path <code>name</code>.  The handler body takes two parameters: the output stream and the <code>req</code> object.  The handler can output additional HTTP headers.</div>
    </td>
    <td class='arc'><pre>
&gt;(defopr-raw baz (str req)
  (disp "Set-Cookie: this=that\n" str) "foo")
<span class="return">#&lt;procedure: gs2291&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='aform'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>aform</span> <span class='args'>f [body ...]</span>
    <div class='desc'>Generates a form from <code>body</code>.  <code>f</code> is a continuation function to execute when the form is submitted.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop af rq (aform (fn (req) (prn req)) (submit)))
<span class="return">#&lt;procedure: gs2301&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='fnform'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>fnform</span> <span class='args'>f bodyfn [redir]</span>
    <div class='desc'>Generates a form from a body function. <code>f</code> is a continuation function to execute when the form is submitted.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop af rq (fnform (fn (req) (fn (_) (prn req))) (submit)))
<span class="return">#&lt;procedure: gs2313&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='timed-aform'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>timed-aform</span> <span class='args'>lasts f [body ...]</span>
    <div class='desc'>Generates a form.  The <code>fnid</code> has a lifetime of <code>lasts</code> seconds.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop taf rq (timed-aform 10 (fn (req) (prn req)) (submit)))
<span class="return">#&lt;procedure: gs2324&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='timed-arform'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>timed-arform</span> <span class='args'>lasts f [body ...]</span>
    <div class='desc'>Generates a form.  Like timed-aform except with a redirect.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop taf rq (timed-arform 10 (fn (req) (prn req)) (submit)))
<span class="return">#&lt;procedure: gs2335&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='arform'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>arform</span> <span class='args'>f [body ...]</span>
    <div class='desc'>Generates a form that goes to a redirect.  The callback function <code>f</code> must return the redirect target.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop arf rq (arform (fn (req) "foo") (prn "Click:") (submit)))
<span class="return">#&lt;procedure: gs2346&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='aformh'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>aformh</span> <span class='args'>f [body ...]</span>
    <div class='desc'>Generates a form with additional headers.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop afh rq (aformh
  (fn (req) (prn "Set-Cookie: a=b\n") (prn req))
  (prn "Click:") (submit)))
<span class="return">#&lt;procedure: gs2357&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='arformh'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>arformh</span> <span class='args'>f [body ...]</span>
    <div class='desc'>Generates a form that goes to a redirect with additional headers.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop arfh rq (arform (fn (req) (prn "Set-Cookie: a=b") "foo")
  (prn "Click:") (submit)))
<span class="return">#&lt;procedure: gs2368&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='url-for'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>url-for</span> <span class='args'>fnid</span>
    <div class='desc'>Generates a URL linking to the given <code>fnid</code>, using <code>fnurl*</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(url-for '1234)
<span class="return">"/x?fnid=1234"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='afnid'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>afnid</span> <span class='args'>f</span>
    <div class='desc'>Generate anaphoric <code>fnid</code>. The continuation function <code>f</code> can access the <code>fnid</code> as the variable <code>it</code>. <code>f</code> must print a blank line before the HTML content.</div>
    </td>
    <td class='arc'><pre>
&gt;(afnid (fn (req) (prn "\nFnid is " it)))
<span class="return">ApzY33zZEd
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='flink'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>flink</span> <span class='args'>f</span>
    <div class='desc'>Generates a URL that will run the continuation function <code>f</code>.  It creates a <code>fnid</code> to do this.</div>
    </td>
    <td class='arc'><pre>
&gt;(flink (fn (req) (prn "hi")))
<span class="return">"/x?fnid=DltGUEIJsK"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='rflink'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>rflink</span> <span class='args'>f</span>
    <div class='desc'>Generates a URL that will run the redirect continuation function <code>f</code>.  It creates a <code>fnid</code> to do this.</div>
    </td>
    <td class='arc'><pre>
&gt;(rflink (fn (req) (prn "Header: x") "foo"))
<span class="return">"/r?fnid=wzWRwQ3LcI"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='w/link'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>w/link</span> <span class='args'>expr [body ...]</span>
    <div class='desc'>Wraps <code>body</code> in a link to continuation expression <code>expr</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop wl req (w/link (prn "You clicked.") (prn "Click here")))
<span class="return">#&lt;procedure: gs2386&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='w/link-if'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>w/link-if</span> <span class='args'>test expr [body ...]</span>
    <div class='desc'>If <code>test</code> is true, wraps <code>body</code> in a link to continuation expression <code>expr</code>.  Otherwise, just displays <code>body</code> without the link.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop wli req (w/link-if t (prn "You clicked.")
  (prn "Click here")))
<span class="return">#&lt;procedure: gs2398&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='w/rlink'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>w/rlink</span> <span class='args'>expr [body ...]</span>
    <div class='desc'>Wraps <code>body</code> in a link to redirect continuation expression <code>expr</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop wrl req (w/rlink "foo" (prn "Click here")))
<span class="return">#&lt;procedure: gs2410&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='onlink'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>onlink</span> <span class='args'>text [body ...]</span>
    <div class='desc'>Creates a link with contents <code>text</code> that will execute continuation expression <code>body</code>.  Note that <code>onlink</code> reverses the roles of the arguments compared to <code>w/link</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop ol req (onlink "Click here" (prn "You clicked.")))
<span class="return">#&lt;procedure: gs2422&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='onrlink'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>onrlink</span> <span class='args'>text [body ...]</span>
    <div class='desc'>Creates a rlink with contents <code>text</code> that will execute continuation expression <code>body</code>.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop ol req (onrlink "Click here" (prn "You clicked.")))
<span class="return">#&lt;procedure: gs2434&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='linkf'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>linkf</span> <span class='args'>text parms [body ...]</span>
    <div class='desc'>Creates a link with contents <code>text</code> to run the continuation function specified by <code>params</code> and <code>body</code>.  Params should be a single argument such as <code>(req)</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop lf rq (linkf "Click here" (req) (prn "Your request: " req)))
<span class="return">#&lt;procedure: gs2446&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='rlinkf'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>rlinkf</span> <span class='args'>text parms [body ...]</span>
    <div class='desc'>Creates a link with contents <code>text</code> to run the redirection continuation function specified by <code>params</code> and <code>body</code>.  Params should be a single argument such as <code>(req)</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(defop rlf rq (rlinkf "Click here" (req) "foo"))
<span class="return">#&lt;procedure: gs2457&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='arg'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>arg</span> <span class='args'>req key</span>
    <div class='desc'>Looks up the URL query value for <code>key</code> in <code>req</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(let req (obj args '((foo 1)))
  (arg req 'foo))
<span class="return">1
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='serve'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>serve</span> <span class='args'>[port]</span>
    <div class='desc'>Start server, by default on port 8080.</div>
    </td>
    <td class='arc'><pre>
&gt;(serve 8080)

</pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='srvlog'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>srvlog</span> <span class='args'>type [args ...]</span>
    <div class='desc'>Records timestamp and <code>args</code> in the server log <code>type</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(srvlog 'blog "Stuff to log")
<span class="stdout">Error: open-output-file: cannot open output file
  path: /pa
th/to/doc/arc/logs/blog-2018-08-26
  system error: No such f
ile or directory; errno=2

</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='defbg'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>defbg</span> <span class='args'>id sec [body ...]</span>
    <div class='desc'>Creates a background thread with the given id tha will run the body every sec seconds.  Any existing thread with the same id is terminated.  New in arc3.</div>
    </td>
    <td class='arc'>  </td></tr>
</table>
<h2>Web server configuration variables</h2>
<p><table class='arc'>
  <tr>
    <td class='arc'><a name='arcdir*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>arcdir*</span> <span class='args'></span>
    <div class='desc'>Parent directory for server data.</div>
    </td>
    <td class='arc'><pre>
&gt;arcdir*
<span class="return">"arc/"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='logdir*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>logdir*</span> <span class='args'></span>
    <div class='desc'>Directory to hold server logs.</div>
    </td>
    <td class='arc'><pre>
&gt;logdir*
<span class="return">"arc/logs/"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='staticdir*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>staticdir*</span> <span class='args'></span>
    <div class='desc'>Directory to hold static files.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;staticdir*
<span class="return">"static/"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='static-max-age*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>static-max-age*</span> <span class='args'></span>
    <div class='desc'>Maximum age for static files; used in Cache-Control header.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;static-max-age*
<span class="return">nil
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='max-age*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>max-age*</span> <span class='args'></span>
    <div class='desc'>Table of maximum age by operation; used in Cache-Control header.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;max-age*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='quitsrv*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>quitsrv*</span> <span class='args'></span>
    <div class='desc'>Flag to shut down server if set to true.</div>
    </td>
    <td class='arc'><pre>
&gt;quitsrv*
<span class="return">nil
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='breaksrv*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>breaksrv*</span> <span class='args'></span>
    <div class='desc'>Flag to enable stopping server with control-C.</div>
    </td>
    <td class='arc'><pre>
&gt;breaksrv*
<span class="return">nil
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='srv-noisy*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>srv-noisy*</span> <span class='args'></span>
    <div class='desc'>Flag to enable debug logging in the server.</div>
    </td>
    <td class='arc'><pre>
&gt;srv-noisy*
<span class="return">nil
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='threadlife*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>threadlife*</span> <span class='args'></span>
    <div class='desc'>Maximum time (in seconds) for a thread to handle a request before being killed.</div>
    </td>
    <td class='arc'><pre>
&gt;threadlife*
<span class="return">30
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='throttle-ips*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>throttle-ips*</span> <span class='args'></span>
    <div class='desc'>Table of IP addresses that should be throttled; they will be delayed by up to <code>throttle-time*</code> seconds.</div>
    </td>
    <td class='arc'><pre>
&gt;throttle-ips*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='throttle-time*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>throttle-time*</span> <span class='args'></span>
    <div class='desc'>Maximum number of seconds to delay requests from IP addresses in <code>throttle-ips*</code></div>
    </td>
    <td class='arc'><pre>
&gt;throttle-time*
<span class="stdout">Error: _throttle-time*: undefined;
 cannot reference an iden
tifier before its definition
  in module: top-level
  intern
al name: _throttle-time*

</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='ignore-ips*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>ignore-ips*</span> <span class='args'></span>
    <div class='desc'>IP addresses to ignore.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;ignore-ips*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='spurned*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>spurned*</span> <span class='args'></span>
    <div class='desc'>Count of ignored IP addresses by address.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;spurned*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='req-limit*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>req-limit*</span> <span class='args'></span>
    <div class='desc'>Maximum number of requests in req-window* seconds before triggering DoS attack detection.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;req-limit*
<span class="return">30
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='req-window*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>req-window*</span> <span class='args'></span>
    <div class='desc'>Time window in seconds for triggering throttling.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;req-window*
<span class="return">10
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='dos-window*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>dos-window*</span> <span class='args'></span>
    <div class='desc'>Time window in seconds for triggering DoS attack detection.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;dos-window*
<span class="return">2
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='opcounts*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>opcounts*</span> <span class='args'></span>
    <div class='desc'>Table counting number of times each operation executed. New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;opcounts*
<span class="return">#hash()
</span></pre>
  </td></tr>
</table>
<h2>Web server internals</h2>
The key stages in the life cycle of a request are:
<ul>
<li> <code>handle-request</code> handles one request.  It accepts a connection on socket <code>s</code>, starts a thread running <code>handle-request-thread</code>, and lets the thread run for <code>life</code> seconds.
</li> handle-request-thread is the thread to handle a request.  It reads the header, calls <code>parseheader</code>, <code>srvlog</code>, <code>respond</code> (get) or <code>handle-post</code> (post) or <code>respond-err</code>.  Finally, it executes <code>harvest-fnids</code> when done.

<li>
One key component of the web server is <code>(respond str op args cooks ip)</code>, which generates the response to a GET or POST request.
 <code>str</code> is the output stream, rest from <code>parseheader</code>
It performs the following actions:
<ul>
<li>
 If <code>op</code> is in <code>redirector*</code>, it does a redirect.
<li> Otherwise, if <code>op</code> is in <code>srvops*</code>, it prints <code>header*</code> and executes the associated function.
<li> Otherwise, a <code>static-filetype</code> is copied with <code>srv-header*</code>.
<li> Otherwise, it returns <code>respond-err</code>.
</ul>
<li>A fnid-based request will go to a handler such as <code>x</code>, which executes the continuation associated with the fnid, which it gets from <code>fns*</code>.  Earlier, the continuation function was registered by <code>fnid</code>.
</ul>
<p>
The URL "/deadlink" displays a "dead link" message.  The URL "/" displays a welcome message.  The URL "/topips" displays the user IP addresses with the heaviest server use.
<p>
The table below provides some internal implementation details.  The table shows which URL is assigned to each request type, and which macro is used to implement it.  Somewhat surprisingly, that the HTML functions with and without headers both use the same underlying URL and implementation; the higher-level macros simply don't provide headers if no headers are desired.
<table width=100% class="info">
<tr><th width=16%>&nbsp;</th><th width=16%>HTML</th><th width=16%>Headers + HTML</th><th width=16%>Redirect</th><th width=16%>Headers + Redirect</th><th width=16%>Asynchronous</th></tr>
<tr>
<th>Path variable</th>
<td><code>fnurl*</code></td>
<td><code>fnurl*</code></td>
<td><code>rfnurl*</code></td>
<td><code>rfnurl2*</code></td>
<td><code>jfnurl*</code></td>
</tr>
<th>URL Path</th>
<td><code>/x</code></td>
<td><code>/x</code></td>
<td><code>/r</code></td>
<td><code>/y</code></td>
<td><code>/a</code></td>
</tr>
<th>Implementation macro</th>
<td><code>defop-raw x</code></td>
<td><code>defop-raw x</code></td>
<td><code>defopr r</code></td>
<td><code>defopr-raw y</code></td>
<td><code>defop-raw a</code></td>
</tr>
</table>
The following table lists the operations and variables in <code>srv.arc</code> that are generally for internal use.
<p><table class='arc'>
  <tr>
    <td class='arc'><a name='serve1'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>serve1</span> <span class='args'>[port]</span>
    <div class='desc'>Start server to handle a single request.</div>
    </td>
    <td class='arc'><pre>
&gt;(serve1 8080)
 
</pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='ensure-srvdirs'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>ensure-srvdirs</span> <span class='args'></span>
    <div class='desc'>Create directories for <code>arcdir*</code> and <code>logdir*</code> if necessary.</div>
    </td>
    <td class='arc'><pre>
&gt;(ensure-srvdirs)
 
</pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='handle-request'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>handle-request</span> <span class='args'>s [breaksrv]</span>
    <div class='desc'>Handles a request.  It accepts a connection on socket <code>s</code> and starts a thread running <code>handle-request-thread</code>.  If breaksrv is true, ^C will break out of the server.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='handle-request-thread'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>handle-request-thread</span> <span class='args'>i o ip</span>
    <div class='desc'>The core code to handle a request.  The arguments are the input port, the output port, and the user's IP address.  It reads the header, calls <code>parseheader</code>, <code>srvlog</code>, <code>respond</code> (get) or <code>handle-post</code> (post) or <code>respond-err</code>.  Then executes <code>harvest-fnids</code> when done.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='handle-post'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>handle-post</span> <span class='args'>i o op args n cookies ip</span>
    <div class='desc'>Handles a POST action.  The arguments are the input port, the output port, the path, the arguments, the content-length, the cookies, and the user's IP address.  Collects POST data and calls <code>respond</code>.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='respond'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>respond</span> <span class='args'>str op args cooks ip</span>
    <div class='desc'>Responds to a GET or POST request.  <code>str</code> is the output stream, rest from <code>parseheader</code>. If <code>op</code> is in <code>redirector*</code>, it does a redirect.  If <code>op</code> is in <code>srvops*</code> otherwise, it prints <code>header*</code> and executes the associated function.  Otherwise, a <code>static-filetype</code> is copied with <code>type-header*</code>.  Otherwise, <code>respond-err</code>.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='save-optime'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>save-optime</span> <span class='args'>name elapsed</span>
    <div class='desc'>Updates <code>optimes*</code> with the time taken to run <code>name</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(save-optime "foo" 10)
<span class="return">(10)
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='static-filetype'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>static-filetype</span> <span class='args'>sym</span>
    <div class='desc'>Returns a filetype symbol for a static file.</div>
    </td>
    <td class='arc'><pre>
&gt;(static-filetype "foo.gif")
<span class="return">gif
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='respond-err'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>respond-err</span> <span class='args'>str msg [args ...]</span>
    <div class='desc'>Generates an error response page containing <code>msg</code> and <code>args</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(respond-err (stdout) "Bad news")

</pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='parseurl'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>parseurl</span> <span class='args'>s</span>
    <div class='desc'>Parses an action and URL. Returns a list of <code>type</code> (<code>get</code> or <code>post</code>), <code>op</code> (the path), and an association list of <code>args</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(parseurl "GET /x?foo=1&amp;bar")
<span class="return">(get x (("foo" "1") ("bar" "")))
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='parseheader'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>parseheader</span> <span class='args'>lines</span>
    <div class='desc'>Parses a request header.  Returns a list of <code>type</code>, <code>op</code>, <code>args</code>, <code>content-length</code> (for <code>post</code>), and <code>cookies</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(parseheader '("POST /foo?a=b" "Cookie: bar=baz"
     "Content-Length: 42"))
<span class="return">(post foo (("a" "b")) 42 (("bar" "baz")))
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='parsecookies'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>parsecookies</span> <span class='args'>s</span>
    <div class='desc'>Parse a HTTP cookies header.  Returns an association list of name/value pairs.</div>
    </td>
    <td class='arc'><pre>
&gt;(parsecookies "Cookie: name1=val1;name2=val2")
<span class="return">(("name1" "val1") ("name2" "val2"))
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='parseargs'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>parseargs</span> <span class='args'>s</span>
    <div class='desc'>Parses args part of URL. Returns an association list of key/value pairs.</div>
    </td>
    <td class='arc'><pre>
&gt;(parseargs "x=a+b&amp;y=%c3%e9&amp;z")
<span class="return">(("x" "a b") ("y" "��") ("z" ""))
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='reassemble-args'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>reassemble-args</span> <span class='args'>req</span>
    <div class='desc'>Creates the URL query string from the <code>args</code> in <code>req</code>.  The arguments are not URL-encoded, so they must not contain any special characters.</div>
    </td>
    <td class='arc'><pre>
&gt;(let req (obj args '(("x" "foo") ("y" "bar")))
  (reassemble-args req))
<span class="return">"?x=foo&amp;y=bar"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='new-fnid'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>new-fnid</span> <span class='args'></span>
    <div class='desc'>Generates a random unused fnid symbol.</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(new-fnid)
<span class="return">OZ3W6XFovO
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='fnid'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>fnid</span> <span class='args'>f</span>
    <div class='desc'>Generates a <code>fnid</code> with continuation function <code>f</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(fnid (fn (req) (prn "hi")))
<span class="return">h74MwrIYrF
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='timed-fnid'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>timed-fnid</span> <span class='args'>lasts f</span>
    <div class='desc'>Generates a <code>fnid</code> that will expire after <code>lasts</code> seconds.</div>
    </td>
    <td class='arc'><pre>
&gt;(timed-fnid 100 (fn (req) (prn "hi")))
<span class="return">R6cceNyVpi
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='harvest-fnids'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>harvest-fnids</span> <span class='args'>[max]</span>
    <div class='desc'>If <code>fns*</code> has more than <code>max</code> fnids, purges any expired <code>timed-fnids*</code> and purges the oldest <code>fnids*</code> (10% of <code>max</code> are purged).</div>
    </td>
    <td class='arc'><pre>
&gt;(harvest-fnids 1000)
<span class="return">nil
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='fnid-field'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>fnid-field</span> <span class='args'>id</span>
    <div class='desc'>Generates a hidden field assigning <code>id</code> to <code>fnid</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;(fnid-field 'abc123)
<span class="stdout">&lt;input type=hidden name="fnid" value="abc123"&gt;
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='unique-id'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>unique-id</span> <span class='args'>[length]</span>
    <div class='desc'>Generates a unique random alphanumeric id.  The minimum length is 5, and the default length is 8.  The table <code>unique-ids*</code> holds all generated ids to ensure uniqueness.</div>
    </td>
    <td class='arc'><pre>
&gt;(unique-id)
<span class="return">32o5uGIQ
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='memodate'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>memodate</span> <span class='args'></span>
    <div class='desc'>Returns current date.  Uses memoization for efficiency; dates are cached for 60 seconds.  Only works on some platforms.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='fns*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>fns*</span> <span class='args'></span>
    <div class='desc'>Table mapping from <code>fnid</code> to continuation function.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='fnids*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>fnids*</span> <span class='args'></span>
    <div class='desc'>List of fnids without an explicit lifetime.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='timed-fnids*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>timed-fnids*</span> <span class='args'></span>
    <div class='desc'>List of entries for fnids with an explicit lifetime.  Each entry is a list  of <code>fnid, time, lasts</code> for <code>fnids</code> with an expiration time.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='fnurl*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>fnurl*</span> <span class='args'></span>
    <div class='desc'>URL path for a fnid continuation.</div>
    </td>
    <td class='arc'><pre>
&gt;fnurl*
<span class="return">"/x"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='rfnurl*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>rfnurl*</span> <span class='args'></span>
    <div class='desc'>URL path for a fnid continuation redirect.</div>
    </td>
    <td class='arc'><pre>
&gt;rfnurl*
<span class="return">"/r"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='rfnurl2*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>rfnurl2*</span> <span class='args'></span>
    <div class='desc'>URL path for a fnid continuation raw redirect.</div>
    </td>
    <td class='arc'><pre>
&gt;rfnurl2*
<span class="return">"/y"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='jfnurl*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>jfnurl*</span> <span class='args'></span>
    <div class='desc'>URL path for an asynchronous fnid continuation.</div>
    </td>
    <td class='arc'><pre>
&gt;jfnurl*
<span class="return">"/a"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='unique-ids*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>unique-ids*</span> <span class='args'></span>
    <div class='desc'>Table of ids generated by <code>unique-id</code>.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='unknown-msg*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>unknown-msg*</span> <span class='args'></span>
    <div class='desc'>Message for an unknown operator.</div>
    </td>
    <td class='arc'><pre>
&gt;unknown-msg*
<span class="return">"Unknown."
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='rdheader*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>rdheader*</span> <span class='args'></span>
    <div class='desc'>Redirect header</div>
    </td>
    <td class='arc'><pre>
&gt;rdheader*
<span class="return">"HTTP/1.0 302 Moved"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='srvops*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>srvops*</span> <span class='args'></span>
    <div class='desc'>Holds operations defined by the <code>defop</code> macros. Used by <code>respond</code> to map the URL path to the handler.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='redirector*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>redirector*</span> <span class='args'></span>
    <div class='desc'>Table with entries for names that are 'redirectors'.  These will return <code>rdheader*</code> and the new location.</div>
    </td>
    <td class='arc'><pre>
&gt;(keys redirector*)
<span class="return">(bar r baz y)
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='optimes*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>optimes*</span> <span class='args'></span>
    <div class='desc'>Table of the last 1000 elapsed times (in ms) for operations.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='header*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>header*</span> <span class='args'></span>
    <div class='desc'>HTTP header</div>
    </td>
    <td class='arc'><pre>
&gt;header*
<span class="return">"HTTP/1.1 200 OK\nContent-Type: text/html; charset=utf-8\nConnection: close"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='type-header*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>type-header*</span> <span class='args'></span>
    <div class='desc'>Table of return HTML headers for static files.  Renamed from srv-header* in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;(keys type-header*)
<span class="return">(jpg png gif text/html)
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='requests*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>requests*</span> <span class='args'></span>
    <div class='desc'>Counter of the total number of requests handled.</div>
    </td>
    <td class='arc'><pre>
&gt;requests*
<span class="return">0
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='requests/ip*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>requests/ip*</span> <span class='args'></span>
    <div class='desc'>Table mapping from IP address to the total number of requests associated with that IP address.</div>
    </td>
    <td class='arc'><pre>
&gt;requests/ip*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='dead-msg*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>dead-msg*</span> <span class='args'></span>
    <div class='desc'>Message when a link has an expired <code>fnid</code>.</div>
    </td>
    <td class='arc'><pre>
&gt;dead-msg*
<span class="return">"\nUnknown or expired link."
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='bgthreads*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>bgthreads*</span> <span class='args'></span>
    <div class='desc'>Table of background threads.</div>
    </td>
    <td class='arc'><pre>
&gt;bgthreads*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='pending-threads*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>pending-threads*</span> <span class='args'></span>
    <div class='desc'>List of pending background threads.</div>
    </td>
    <td class='arc'><pre>
&gt;pending-threads*
<span class="stdout">Error: _pending-threads*: undefined;
 cannot reference an id
entifier before its definition
  in module: top-level
  inte
rnal name: _pending-threads*

</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='req-times*'></a>
<img src='var.gif' title='Variable'/>
<span class='op'>req-times*</span> <span class='args'></span>
    <div class='desc'>Table of requests by IP addresses for DoS attack detection.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;req-times*
<span class="return">#hash()
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='handle-request'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>handle-request</span> <span class='args'>s [life]</span>
    <div class='desc'>Implements handle-request without breaksrv.  New in arc3.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='log-request'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>log-request</span> <span class='args'>type op args cooks ip t0 t1</span>
    <div class='desc'>Logs a request.  New in arc3.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='gen-type-header'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>gen-type-header</span> <span class='args'>ctype</span>
    <div class='desc'>Generates response header for the type. New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;(gen-type-header "gif")
<span class="return">"HTTP/1.0 200 OK\nContent-Type: gif\nConnection: close"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='timed-aform2'></a>
<img src='macro.gif' title='Macro'/>
<span class='op'>timed-aform2</span> <span class='args'>genurl lasts f [body ...]</span>
    <div class='desc'>timed-aform with ignored genurl argument.</div>
    </td>
    <td class='arc'>  </td></tr>
  <tr>
    <td class='arc'><a name='logfile-name'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>logfile-name</span> <span class='args'>type</span>
    <div class='desc'>Creates logfile name for the given type. New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;(logfile-name "gif")
<span class="return">"arc/logs/gif-2018-08-26"
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='sortable'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>sortable</span> <span class='args'>table comparison-fn</span>
    <div class='desc'>Sorts a table.  Default comparison is >.  New in arc3.</div>
    </td>
    <td class='arc'><pre>
&gt;(sortable (obj 'a 5 'b 2 'c 4))
<span class="return">(((quote a) 5) ((quote c) 4) ((quote b) 2))
</span></pre>
  </td></tr>
  <tr>
    <td class='arc'><a name='new-bgthread'></a>
<img src='proc.gif' title='Procedure'/>
<span class='op'>new-bgthread</span> <span class='args'>id f sec</span>
    <div class='desc'>Creates a background thread with the given id tha will run f every sec seconds.  Any existing thread with the same id is terminated.  New in arc3.</div>
    </td>
    <td class='arc'>  </td></tr>
</table>
<p>
Copyright 2008 Ken Shirriff.
</body>
</html>