coronita-1.0.4/bin/cn-logdlf0100755000076600001440000000153610275113046014531 0ustar gabiusers#!/usr/bin/perl # # $Id: cn-logdlf,v 1.2 2005/08/01 11:56:34 krip Exp $ # convert coronita log to dlf %meth = ('B'=>'GET', 'G'=>'GET', 'H'=>'HEAD', 'P'=>'POST'); @mon=('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'); while (<>) { chomp; ($gtf,$ra,$peer,$msec,$code,$size,$meth,$uri,$qry,$proto,$ref,$ua, $cookie,$user) = split(/\t/); next unless $gtf =~ /^\d{17}$/; next unless $code =~ /^\d{3}$/; ($ye,$mo,$da,$ho,$mi,$se) = $gtf =~ /(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})/; $date = "$da/$mon[$mo-1]/$ye:$ho:$mi:$se +0000"; if (($m) = $meth =~ /^([BGHP])\d*$/) {$meth = $meth{$m};} $uri .= '?'.$qry if $qry; $proto = 'HTTP/1.'.$proto if $proto =~ /^\d*$/; $proto = " $proto" if $proto; $user ||= '-'; $ref ||= '-'; $ua ||= '-'; print "$ra - $user [$date] \"$meth $uri$proto\" $code $size \"$ref\" \"$ua\"\n"; } coronita-1.0.4/bin/run0100755000076600001440000000065610401033667013473 0ustar gabiusers#!/bin/bash # $Id: run,v 1.1 2006/02/28 11:44:55 krip Exp $ # sample coronita starter root=/cn/root ip=192.168.1.99 childs=16 grandchilds=500 uid=65534 cd $root && \ env - /cn/bin/coronita \ -a$(printf %u $(printf 0x%02x%02x%02x%02x \ $(echo $ip | tr . ' '))) \ -b$grandchilds \ -c$childs \ -u$uid \ >/dev/shm/cn.err 2>&1 & # to truncate every hour use a crontab line like # 42 * * * * true >/dev/shm/cn.err coronita-1.0.4/Makefile0100644000076600001440000000324310402324470013620 0ustar gabiusers# coronita -- a tiny webserver # Version 1.0 # Copyright (c) 2005 by Erik Grziwotz and Klaus Ripke, partner@malete.org # # 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # # see README for more information # $Id: Makefile,v 1.34 2006/03/02 16:02:41 krip Exp $ # standard make defines ifndef CC # suggest diet -Os gcc CC=gcc endif DBG=-fomit-frame-pointer STRIP=-s ifdef DEBUG DBG=-g -DDEBUG STRIP= endif # compile CFLAGS=$(DBG) -O2 -fno-strict-aliasing -Wall -W -Wshadow $(STRIP) LNSL= ifneq (,$(wildcard /usr/lib/libnls.so)) LNSL=-lsocket -lnsl -lsendfile endif ifdef MATRIXSSL # /opt/Crypto/matrixssl CNSSL=bin/sslio endif BINS=bin/coronita bin/htld $(CNSSL) all: $(BINS) .PHONY: all clean clean: -rm -f core localhost/.log $(BINS) bin/coronita: coronita.c $(CC) $(CFLAGS) -o $@ $< $(LNSL) bin/htld: htld.c $(CC) $(CFLAGS) -o $@ $< $(LNSL) bin/sslio: sslio.c $(CC) -I$(MATRIXSSL) $(CFLAGS) -o $@ $< $(LNSL) \ -L$(MATRIXSSL)/src -lmatrixssl # run it run: bin/coronita env - SERVER_SOFTWARE=coronita bin/coronita -p8080 coronita-1.0.4/localhost/coronita.txt0100644000076600001440000004046010402327744016540 0ustar gabiuserscoronita -- a tiny webserver The current release 1.0.4 has been tested on Linux (2.4/x86), Solaris (10/x86 and T1) and Mac OS (10.4/PPC). Coronita is - a standalone HTTP/1.0 webserver - heavily based on unix fork. Made for Linux and tested on Solaris. Should work on most *nixes with some patching of the sendfile code. - pretty fast in serving static content - very fast in serving "NCGI" (similar to NPH CGI) - supporting SSL (spawning sslio per connection) - not for the faint of heart. For speed and flexibility there is next to no double-checking or error handling. Run buggy CGIs under some graceful wrapper. Contribute a Perl script to check your setup before runnning a server. See issues below. * overview Coronita forks and monitors n childs. The childs loop accepting new connections. For each request, at most 8K are read as headers. Coronita serves HTTP/1.0, including HTTP/0.9 Simple-Requests and > http://rfc.net/rfc2068.html#s19.7.1 HTTP/1.0 persistent connections. Header unfolding and omitting the CR before LF is supported. All tabs are blanked, any other control char (0-31,127) aborts. Any host header (up to a ':', defaulting to "default") must correspond to a subdirectory (of ".") with at least 4 characters. The process chdir(2)s there and opens ".log" as fd 1. An unclean Request-URI (or host header) is refused (see below). After stripping the ?QUERY_STRING, the filename is stat(2)ed. If the specified file does not exist, and is not a dangling symlink, or is a directory, it's a 404. Coronita uses the error file .404 (not found) to handle most special cases. This is usually a NCGI script. If the file is a dangling symlink, a 301 redirect to the link contents is sent (so the link should better read as fully qualified URL http://...). If the file is a non-executable regular file: - a POST is handed over to .404 - a file which is not world readable (S_IROTH) is handed over to .404 - for a GET, If-Modified-Since is honoured with a 304, if appropriate - for a HEAD or (not simple) GET, a HTTP/1.0 header is written - for a GET, the file is copied or sendfile(2)d Else the file should be an executable regular file. Coronita uses fork, execve and wait to run a NCGI executable. Coronita forks a child (i.e. grandchild) if a connection is blocking or it should keep the connection alive after the request. No keep-alive is attempted, if the executable exits with a code other than 0. * request line The general syntax of a Request-URI ("abs_path") as of > http://rfc.net/rfc1945.html#s3.2.1 HTTP/1.0 (3.2.1) is / [path] [";" params] ["?" query]. Coronita follows > http://rfc.net/rfc2396.html#s3. URI: Generic Syntax (3.) by treating ";" as ordinary character and thus anything up to the first "?" as filename (including any "params", which have no special semantics anyway). RFC 1738 > http://rfc.net/rfc1738.html#s2.2. URLs (2.2) states that ``only (US_ASCII) alphanumerics, the special characters "$-_.+!*'(),", and reserved characters (";/?:@=&") used for their reserved purposes may be used unencoded within a URL´´. But ``on the other hand, characters that are not required to be encoded (including alphanumerics) may be encoded within the scheme-specific part of a URL, as long as they are not being used for a reserved purpose´´. RFC 2396 obsoletes 1738 (and 1808 "relative URLs"), makes "$+," reserved, "~" unreserved, and states in > http://rfc.net/rfc2396.html#s2.3. URLs (2.3) that escaping the unreserved characters (US-ASCII alphanum and "-_.!~*'()") ``should not be done´´. Well. > http://rfc.net/rfc1945.html#s3.2.1 HTTP/1.0 (3.2.1) refers to 1738 as source of ``definitive information´´, and immediatly violates it by allowing the unwise "[\]^`{|}~" and 128-255 as "national". Anyway, according to > http://rfc.net/rfc1945.html#s5.1.2 HTTP/1.0 (5.1.2) an ``origin server must decode the Request-URI in order to properly interpret the request´´. However, ``origin server´´ applies to the complete system including CGIs. Clearly the Request-URI's query part MUST be passed undecoded to CGIs, only it's parts may be decoded by some application code more or less carefully depending on the intended usage. For the filename, there is no reason to decode it whatsoever, since user agents do not encode it (at least as long as it looks "reasonable", especially does not contain blanks, which simply can not be send unencoded). To be on the safe, fast and convenient side, Coronita recommends to use URL-encoded representations of any weird characters both in the actual filenames and in URLS. Should some stupid user agent (probably IE 7) start to apply unwanted additional URL-encoding, the RFC's requirement still may be met by the .404 handler. So, Coronita does not do any URL-decoding at all. In addition to refusing any controls, a filename (path) is refused with a 400, if it does not start with "/" or any segment starts with a "." or "/". * request headers Coronita honours Host, If-Modified-Since and Connection, and collects Referer, User-Agent and Cookie for logging. Content-Type and Content-Length are recognized for CGIs. HTTP/1.0 specifies (RFC 1945, sec > http://rfc.net/rfc1945.html#s4.3 4.3 , > http://rfc.net/rfc1945.html#s5.2 5.2 ): - If-Modified-Since: honoured for GET/HEAD. Only the recommended RFC 1123 style dates are recognized, not other obsolete variants allowed by RFC 1945 3.3. - Referer, User-Agent: logged - Date, Pragma, Authorization, From, Entity-Headers: ignored HTTP/1.1 adds (RFC 2616 > http://rfc.net/rfc2616.html#s14.10 14.10 et al.): - Connection: close or keep-alive - Host: honoured - Range: ignored (scripts should check) - Transfer-Encoding: ignored (scripts handling POST should check) (... and mucho more) * response headers Coronita sends Date, Location, Content-Length, Content-Type, Last-Modified, Server, Connection and Keep-Alive. Dates are sent as of RFC 1123. HTTP/1.0 specifies (RFC 1945, sec > http://rfc.net/rfc1945.html#s4.3 4.3 , > http://rfc.net/rfc1945.html#s6.2 6.2 ): - Date: current date (of receiving complete request header) - Location: used with redirect - Server: optionally set at compiletime - WWW-Authenticate: not used and the entity header fields (sec > http://rfc.net/rfc1945.html#s7.1 7.1 ): - Content-Length: file size - Content-Type: text/html or as of file extension - Last-Modified: file's ctime - Expires: current date + configured ttl - Allow, Content-Encoding: not used HTTP/1.0 additionally specifies (RFC 1945, sec > http://rfc.net/rfc1945.html#sD.2 D.2 ) Accept, Accept-Charset, Accept-Encoding, Accept-Language, Content-Language, Link, MIME-Version, Retry-After, Title and URI, which are neither honoured nor sent, resp. HTTP/1.1 adds (RFC 2616, sec > http://rfc.net/rfc2616.html#s14.9 14.9 ): - Cache-Control: not used CGIs, however, are free to send any headers they seem fit, especially regarding Pragma: no-cache, Expires and Cache-Control. CGIs should NOT use a protocol version other than HTTP/1.0, as this would signal capabilities we do not have to proxies and clients. * CGI Coronita supports a variant of non-parsed header (NPH) CGI called NCGI. NCGI scripts talk directly to the client socket on fd 0 and are responsible for logging to fd 1 (since Coronita does not learn the requests outcome). In other words, most of the CGI processing logic is moved from the webserver to the script, resulting in more speed and flexibility. As a special application NCGI scripts can hijack the connection by backgrounding themselves and returning non-zero to Coronita, which is useful for large downloads, streaming or chat sessions. The supported > http://hoohoo.ncsa.uiuc.edu/cgi/env.html environment variables are: The fixed environment is passed unmodified as inherited. Suggested values to impress your CGI scripts are: - SERVER_SOFTWARE: Coronita - GATEWAY_INTERFACE: CGI/1.1 Per connection (unchanged on subsequent keep-alive requests): - REMOTE_ADDR: client IP address as of > http://rfc.net/rfc2373.html#p22 RFC 2373 - REMOTE_HOST, REMOTE_IDENT: not used - X_CONN: the port, with a '$' prepended, if using a filter like sslio Per request: - REQUEST_METHOD: GET, HEAD or POST - SCRIPT_NAME: the unmodified Request-URI up to ? for a found CGI - PATH_INFO: the unmodified Request-URI up to ? for a .404 - QUERY_STRING: everything after the ? - SERVER_NAME: as of Host header or "default", lowercased, port stripped to SERVER_PORT. - SERVER_PROTOCOL: HTTP/rev (actually the CLIENT protocol). This is unset for a HTTP/0.9 (Simple-)Request, indicating that a Simple-Response (entity body only) is expected. It is suggested that subrequests unset SERVER_PROTOCOL to include bodies only or use > http://rfc.net/rfc3875.html#s4.1.16. INCLUDED to ask for naked bodies (HTML fragments without header). - CONTENT_LENGTH, CONTENT_TYPE: as given - PATH_TRANSLATED, AUTH_TYPE, REMOTE_USER: not set by Coronita Coronita sets additional per-request variables: - X_KALI: request number (1,2,...) in connection, if keep-alive (unset else) - X_DATE, X_GTFM: request date in RFC 1123 (for response) and GTF+msec (for log) - X_IFMS: value of If-Modified-Since in secs In general, $ http$S://$SERVER_NAME[:$SERVER_PORT]$SCRIPT_NAME$PATH_INFO[?$QUERY_STRING] $ should reference the current resource (with S = 's', if X_CONN starts with a '$'); According to RFC 1945 > http://rfc.net/rfc1945.html#s4.2 4.2 header (field-)names are tokens and may thus contain not only alphanum and "-", but also "!#$%&´*+.^_´|~". Coronita ignores (silently drops) such headers. According to CGI/1.1 > http://rfc.net/rfc3875.html#s4.1.18. 4.1.18 , all other headers (i.e. but the special Connection, Host, If-Modified-Since, Content-Length and Content-Type) are passed per request with HTTP_ prependend, all alpha uppercased and any "-" converted to "_" (in the header name). Standard > http://hoohoo.ncsa.uiuc.edu/cgi/out.html parsed header CGI scripts must be run by some wrapper, which creates a proper HTTP response, does logging, compensates for a couple of deviations from > http://ietf.org/rfc/rfc3875.txt RFC 3875 "MUSTs" and may even support the > http://rfc.net/rfc3875.html#s4.4. command line (NPH scripts may check QUERY_STRING for a "="). > http://ietf.org/rfc/rfc1738.txt Uniform Resource Locators (URL) > http://ietf.org/rfc/rfc2396.txt update thereof > http://ietf.org/rfc/rfc1945.txt HTTP/1.0 > http://ietf.org/rfc/rfc2616.txt HTTP/1.1 > http://www.ietf.org/rfc/rfc2617.txt HTTP Authentication > http://hoohoo.ncsa.uiuc.edu/cgi/ CGI ("current") > http://ietf.org/rfc/rfc3875.txt CGI 1.1 > http://CGI-Spec.Golux.Com/draft-coar-cgi-v11-03-clean.html (old draft) (or go to > http://rfc.net/ RFC.net for nice HTML versions with useful links) > http://www.w3.org/TR/html4/interact/forms.html#h-17.13 HTML 4.01 forms * logging Log is written in tab separated lines to fd 1 (i.e. vhost/.log). Every line starts with - X_GTFM (request time with msec YYYYMMDDhhmmssttt) - REMOTE_ADDR - X_CONN[#X_KALI] (e.g. port#request) - msec (log time - request time) - code (3-digit response code or something like "LOG", "DBG") 0xx codes are used for severe errors (not generating a response). Scripts may use non-numeric response codes for debug logging. Request (i.e. non-debug) log lines continue with - size (complete response incl. headers) - B,H,G_ims_ or P_cl_ for body (simple), head, get and post, resp. - REQUEST_URI (up to '?') - QUERY_STRING - SERVER_PROTOCOL (with HTTP/1. stripped) - Refer(r)er - User-Agent - Cookie and optionally (in that suggested order) - REMOTE_USER - remarks (e.g. session id) - other notes like some post data * running and configuration $ CC='diet -Os gcc' make env - SERVER_SOFTWARE=for-CG-eyes-only bin/coronita -p8080 $ runs coronita listening on port 8080 (any address). Per extension and default mime types are compiled in. The command line has -options in any order. Anything from the first arg not starting with a '-' will be spawned as filter for every connection with fd 0 to the client and one end of a socketpair (to Coronita) on fd 1. Options have a single letter immediatly followed by some number. Options are: - a address (IP) as decimal. 2130706433 (printf %d 0x7f00000 is localhost). - b # backgrounded connections per child (default 256) - c # childs to spawn (default 8) - h ttl for text/html (time to live in seconds) default 0 (now) - i initial timeout in msec before backgrounding after accept (default 10) - p port - s sendfilelimit: larger files use sendfile (default 24K) - t ttl for other types (default 86400 - one day) - u uid to set after binding the socket (if real and effective are 0) If the effective uid is 0, as required to bind reserved ports, Coronita chroots to '.' and sets the real uid (if it is not 0, i.e. you made coronita setuid) or the specified uid (if real is 0). $ env - bin/coronita -p443 -u65535 bin/sslio 'cert.pem;ca.pem' $ runs coronita as SSL server using certificate chain from files cert.pem and ca.pem and the default keyfile priv.pem. Note: since this runs chrooted to ., you have to setup some minimal environment for sslio (instructions for sslio on linux with dietlibc): $ mkdir dev mknod dev/random c 1 8 mknod dev/urandom c 1 9 mkdir proc cp /proc/cpuinfo proc $ Sslio also expects to find file cert.pem and priv.pem as found in the matrixssl distro. Your scripts may also require some files in /etc (like passwd, group, resolv.conf) a/o /tmp and /var. * speed We performed speed tests comparing coronita against next to anything we could get hold of, and found it outperforming most others in most tests (1000 bytes OneK.txt, 15145 LICENSE(GPL).txt, 137582 bytes rfc1945.txt), when it comes to keep-alive a/o CGI. With keep alive on OneK.txt, 10 httpds and ab (apache bench) concurrency 10, we found coronita to top 10,000 requests/sec on average (12,000 sometimes) on a 800MHz Pentium III, kernel 2.4.13. See > http://www.fefe.de/fnord/SPEED FeFe's tests for other numbers. The http_load tests (no keep-alive) as of > http://www.acme.com/software/thttpd/benchmarks.html thttp benchmarks showed Coronita to be on par with thttp in static no-keepalive pages: doing the small test with -parallel 10, 100 and 250, thttpd went from about 3000/sec down to about 1700, Coronita from about 3700 to 2300 but a little bit less stable. However, these tests fry the TCP stack anyway. In another test we compared coronita to lighttpd on a much faster machine (P4 2.8 GHz, kernel 2.6.13) with keepalive on a 4K image. With concurrency 100, coronita does more than 13.500/sec, while lighty makes 11.500/sec. With concurrency 1000, numbers drop to 12.000 and 10.800, resp. On a Sun Fire X4200 with two single core Opteron 248 running Solaris 10 we got more than 30.000 requests/sec (-k -c100 1K file, almost the same locally and remote over Gbit ethernet) and still a whopping 12.500 without keepalive. However, once 32K sockets are in TIME_WAIT, throughput drops to some 500 requests a second. * discussion As a http daemon, Coronita only catches the worst of input. For example it completely ignores any URL encoding issues. The idea is that applications need to check anyway, e.g. when processing POST data. No attempt is made to try to prevent stupid or malicious users from symlinking /etc/passwd and things like that, since a webserver can not prevent their CGIs from doing much more evil. Run a chrooted/ulimited/niced/quotad... httpd for untrusted vhosts. Coronita strictly limits the amount of input and uses buffers of fixed but sufficiently large size for further processing. Please check the code for errors in these calculations! In general, functionality like index.html, directory index, checking for scripts somewhere in the path, authorization etc should be added via .404. The only extension considered is an external connection manager to exchange connections via an unix socket with coronita. This would allow for throttling like thttpd does and for delaying close to reduce the number of sockets in TIME_WAIT. * download > /tar/coronita-1.0.4.tar.gz source (45K) > /tar/coronita-1.0.4-bin.tar.gz static coronita binary (linux/dietlibc) (13K), > /tar/sslio.gz static sslio binary (48K) and the > htld hypertext linker > /tar/htld.gz binary (10K) * friends We owe much to FeFe's > http://www.fefe.de/fnord/ fnord and > http://www.fefe.de/dietlibc/ dietlibc See also > http://lighttpd.net/ lighttpd > http://www.mathopd.org/ mathopd > http://www.acme.com/software/thttpd/ thttpd > http://www.boa.org/ boa > http://linux.bytesex.org/misc/webfs.html webfs > http://cr.yp.to/publicfile.html publicfile --- $Id: coronita.txt,v 1.9 2006/03/04 15:19:00 krip Exp $ coronita-1.0.4/localhost/license.txt0100644000076600001440000003545110273115020016334 0ustar gabiusers GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS coronita-1.0.4/localhost/htld.txt0100644000076600001440000000707010273132075015652 0ustar gabiusersHTLD - the hypertext linker * overview HTLD does to hypertext files, what ld.so does to dynamically linked binaries. It resolves references to parts stored in independent files or variables, inserting them at the specified locations into the output stream. It actually is in no way confined to "hypertext" or even to text, however, this is a typical usage and there is special support for > http://www.ietf.org/rfc/rfc2396.txt URL and HTML encoding. There is a standalone htld binary, which is typically the interpreter of executable htld documents (just like ld.so and friends are the interpreters to run dynamically linked binaries). Engines for dynamic web content may also contain functions to resolve htld files. * variables and encoding Htld reads variables from their first occurrence in the environment variable QUERY_STRING. Htld urldecodes variables, refusing malformed %xx and any (C0) control character (less than 32) but HT, CR and LF. Htld - encodes as "HTML" by using entities lt, gt, amp and quot - encodes as "URL" by passing alphanum and "!'()*,-._~", encoding blank as + (violating RFC 2396 for aesthetical reasons) and everything else as (lowercase) %02x * the htld file format A htld file consist of a textual header, a blank line and a body. Header lines and the closing blank line are terminated by linefeed (10). The first line typically specifies the htld interpreter like '#!/bin/htld'. Other header lines contain linking instructions (ASCII digits 0-7) followed by parameters as tabulator (9) separated fields. Offsets are relative to the body and must be in ascending order. - 0 _header_ declares additional header to send - 1 _ctype_ declares content type - 2 _ttl_ declares cache time to live (Expires: now+_ttl_) in seconds. Use a single '-' for no cache. - 3 _defaults_ declares an URL encoded string to append to QUERY_STRING, effectively providing parameter defaults for instructions following this. - 4 _offset_ _var_ include the plain value of var at offset (after applying any URL decoding) - 5 _offset_ _var_ include the URL encoded value of var at offset (with URL decoding and encoding) - 6 _offset_ _var_ include the value of var at offset (with URL decoding and minimal HTML encoding of lt, gt, amp and quot) - 7 _offset_ _path_[?_query_] include the contents of file _path_ at offset. If the file starts with a #! line containing "htld", it is linked up recursively. See below for details. An include _path_ is handled by first replacing any $varname in _path_ by varname's URL encoded value. A value starting with '.' is refused at the beginning or after a '/' (a '/' in the value is encoded as %2f). Then anything following a question mark is stripped and prepended to QUERY_STRING during the include (effectively overriding vars; the original path, however, is untouched during recursive includes). The remaining path is used to stat the file to include, so it should usually be relative to the webroot. Offset may be 'H' or 'F' for headers and footers, resp. Header and footer instructions are ignored on recursive includes. The header file is typically used to include anything up to the opening body tag, so the htld doc's body is a proper HTML fragment suitable to be included elsewhere. Unlike server side includes as featured by Apache and other webservers, htld will in no way parse the body nor replace anything in the body, but rather require all locations for linking to be precomputed. Some ht compiler may be used to turn SSI-style comments in a html file into a htld linkable object. --- $Id: htld.txt,v 1.1 2005/07/31 11:21:33 krip Exp $ coronita-1.0.4/localhost/.4040100755000076600001440000000313710273407027014473 0ustar gabiusers#!/usr/bin/perl # $Id: .404,v 1.1 2005/08/01 11:57:11 krip Exp $ # sample NCGI .404 # as this does a plain echo, it SHOULD NOT BE USED in production $code = 404; $msg = 'nok'; # body $body = "not found:\n"; for (sort(keys(%ENV))) { $body .= $_.'='.$ENV{$_}."\n"; } # response $exit = 0; $conn = 'close'; if ($ENV{'X_KALI'}) { if ('GET' eq $ENV{'REQUEST_METHOD'}) { $conn = 'keep-alive'; } else { $exit = 1; # signal to drop conn } } $res = "HTTP/1.0 $code $msg\r Date: $ENV{'X_DATE'}\r Connection: $conn\r Content-type: text/plain\r Content-length: ".length($body) ."\r\n\r\n".$body; syswrite(STDIN, $res); # log $logconn = $ENV{'X_CONN'}; $logconn .= $ENV{'X_KALI'} if $ENV{'X_KALI'}; if (! $ENV{'SERVER_PROTOCOL'}) { $logmethod = 'B'; # simple body } elsif ('HEAD' eq $ENV{'REQUEST_METHOD'}) { $logmethod = 'H'; } elsif ('GET' eq $ENV{'REQUEST_METHOD'}) { $logmethod = 'G'.$ENV{'X_IFMS'}; } elsif ('POST' eq $ENV{'REQUEST_METHOD'}) { $logmethod = 'P'.$ENV{'CONTENT_LENGTH'}; } else { $logmethod = $ENV{'REQUEST_METHOD'}; # this is not the coronita we love } $logproto = $ENV{'SERVER_PROTOCOL'}; $logproto = substr($logproto, 7) if 'HTTP/1.' eq substr($logproto,0,7); syswrite(STDOUT, $ENV{'X_GTFM'}."\t". $ENV{'REMOTE_ADDR'}."\t". $logconn."\t". "0\t". # really should print msec request time # unfortunately, subsecond time is not in Perl base "$code\t". length($res)."\t". $logmethod."\t". $ENV{'PATH_INFO'}."\t". # since we are /.404, the URI is in PATH_INFO $ENV{'QUERY_STRING'}."\t". $logproto."\t". $ENV{'HTTP_REFERER'}."\t". $ENV{'HTTP_USER_AGENT'}."\t". $ENV{'HTTP_COOKIE'} ); exit($exit); coronita-1.0.4/localhost/htldtest0100755000076600001440000000153410273155067015744 0ustar gabiusers#!/opt/coronita/bin/htld 0 Foo: bar 1 text/plain; charset=ISO-8859-1 2 - 3 incl=htld.txt&t=txt%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F%3A%3B%3C%3D%3E%3F%0A&u=url%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F%3A%3B%3C%3D%3E%3F%0A&v=html%20%21%22%23%24%25%26%27%28%29%2A%2B%2C%2D%2E%2F%3A%3B%3C%3D%3E%3F%0A 4 100 t 5 200 u 6 300 v 7 F $incl?a=AA&b=BB 00 3456789012345678901234567890123456789012345678 01 3456789012345678901234567890123456789012345678 02 3456789012345678901234567890123456789012345678 03 3456789012345678901234567890123456789012345678 04 3456789012345678901234567890123456789012345678 05 3456789012345678901234567890123456789012345678 06 3456789012345678901234567890123456789012345678 07 3456789012345678901234567890123456789012345678 08 3456789012345678901234567890123456789012345678 09 3456789012345678901234567890123456789012345678 coronita-1.0.4/localhost/kilobyte.txt0100644000076600001440000000175010273143117016537 0ustar gabiusers00 3456789012345678901234567890123456789012345678 01 3456789012345678901234567890123456789012345678 02 3456789012345678901234567890123456789012345678 03 3456789012345678901234567890123456789012345678 04 3456789012345678901234567890123456789012345678 05 3456789012345678901234567890123456789012345678 06 3456789012345678901234567890123456789012345678 07 3456789012345678901234567890123456789012345678 08 3456789012345678901234567890123456789012345678 09 3456789012345678901234567890123456789012345678 10 3456789012345678901234567890123456789012345678 11 3456789012345678901234567890123456789012345678 12 3456789012345678901234567890123456789012345678 13 3456789012345678901234567890123456789012345678 14 3456789012345678901234567890123456789012345678 15 3456789012345678901234567890123456789012345678 16 3456789012345678901234567890123456789012345678 17 3456789012345678901234567890123456789012345678 18 3456789012345678901234567890123456789012345678 19 3456789012345678901234567890123456789012345678 coronita-1.0.4/coronita.c0100644000076600001440000011743410402327744014161 0ustar gabiusers/* coronita -- a tiny webserver Version 1.0 Copyright (c) 2005 by Erik Grziwotz and Klaus Ripke, partner@malete.org 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA see README for more information */ /* $Id: coronita.c,v 1.25 2006/03/04 15:19:00 krip Exp $ */ #ifdef __sun__ /* lotsa defines to get msg_controllen, htonl etc. */ # define _XOPEN_SOURCE # define _XOPEN_SOURCE_EXTENDED 1 /* XPG4v2 a.k.a SUS, see standards(5) */ # define __EXTENSIONS__ /* htonl :( */ #elif defined(__APPLE__) # define SENDFILE 1 /* in sys/socket.h */ #endif #include /* exit */ #include /* memcpy et al */ #include #include /* gmtime */ #include #include #include #include #include /* CORK */ #include #include #include #include #include #ifndef __APPLE__ #include #endif #include #include #include #ifdef __sun__ /* it IS in time.h, but don't want to -D_REENTRANT */ extern struct tm *gmtime_r(const time_t *secs, struct tm *res); #endif extern char **environ; /* character constants */ #define HT 9 #define LF 10 #define CR 13 #define SP 32 /* fixed length string data types */ #define GTF_MSEC_CHARS 18 /* YYYYMMDDhhmmssttt + 0 byte */ #define DATE1123_CHARS 30 /* Sun, 06 Nov 1994 08:49:37 GMT + 0 byte */ #define ADDR_CHARS 40 /* REMOTE_ADDR incl. 0 byte */ #define CONN_CHARS 32 /* X_CONN incl. 0 byte */ #define ENVLEN 128 /* max number env vars (incl. preset) */ #define PRELEN 64 /* max number of preset (inherited) env vars */ #define HTTPSIZ 8192 /* max request size (headers) */ /* string with length. if !c, l is undefined */ typedef struct { char *c; int l; } Str; #define STR(x) {x, sizeof x-1} #define STROFF(d, s, o) do { \ (d)->c = (s)->c + (o); \ (d)->l = (s)->l - (o); \ } while (0) enum { METH_BODY, /* HTTP/0.9 simple */ METH_HEAD, METH_GET, METH_POST, METH_OTHER }; enum { CT_NONE, CT_URLENC, /* application/x-www-form-urlencoded */ CT_MULTI, /* multipart/form-data */ CT_OTHER }; /* connection and request data CGI: more or less standard RFC 3875 ENV: extended environment S: from socket R: from request line M: modified header (Keep-Alive, Host, If-Modified-Since) H: header as is (Range, Content-Length+Type, Referer, User-Agent, Cookie) O: otherwise added */ enum { REQ_ADDR, /* S CGI REMOTE_ADDR, maxlen 39 */ REQ_CONN, /* S ENV X_CONN (PORT etc.), maxlen 31 */ REQ_KALI, /* M ENV X_KALI (number), maxlen 10 (where Connection: Keep...)*/ REQ_HOST, /* M CGI SERVER_NAME (from Host header) */ REQ_PORT, /* M CGI SERVER_PORT (") */ REQ_DATE, /* O ENV X_DATE, [DATE1123_CHARS] */ REQ_GTFM, /* O ENV X_GTFM, [GTF_MSEC_CHARS] */ REQ_METH, /* R CGI REQUEST_METHOD */ REQ_IFMS, /* M ENV X_IFMS from If-Modified-Since in UTC (number, GET) */ #define REQPASS REQ_COLE /* first header to pass as-is: */ REQ_COLE, /* H CGI CONTENT_LENGTH (POST) */ REQ_COTY, /* H CGI CONTENT_TYPE (POST) */ REQ_NAME, /* R CGI SCRIPT_NAME part of REQ_PATH */ REQ_INFO, /* R CGI PATH_INFO part of REQ_PATH */ #define REQLOG REQ_PATH /* plain logged args: */ REQ_PATH, /* R CGI REQUEST_URI (Apache; trad. misnamed: really the path) */ REQ_QRYS, /* R CGI QUERY_STRING */ REQ_PROT, /* R CGI SERVER_PROTOCOL */ REQ_REFR, /* H CGI HTTP_REFERER */ REQ_USAG, /* H CGI HTTP_USER_AGENT */ REQ_COOK, /* H CGI HTTP_COOKIE */ REQ_USER, /* O CGI REMOTE_USER (added by filters) */ REQ_USR0, /* O ENV X_USR0 for sid or logging remarks set by CGIs */ REQ_USR1, /* O ENV X_USR1 or logging POST data set by CGIs */ REQ_ARGS /* catch 22 */ }; #define REQKNOWN 8 /* 5H and 3M headers */ #define REQLEN 62 /* max number of params */ #define REQEXTRA (REQLEN-REQ_ARGS) /* 40 headers passed as HTTP_ */ #define HTTPLEN (1+REQKNOWN+REQEXTRA) /* max number of request lines */ /* to pass a request, we need: 72 ADDR_CHARS+CONN_CHARS 8K HTTPSIZ bytes for what we got (maybe minus some known header names) 160 = 4*REQEXTRA for 'HTTP_x=' from 'x: ' plus for exec CGI: 244 for the 22 known env names as above (including a =) plus some margin ... */ #define CGISIZ (HTTPSIZ+2048) /* including some margin */ typedef struct Req { Str args[REQLEN]; /* 22 known values + xtra HTTP_*=val strings */ int xtra; /* # of HTTP_ headers after REQ_ARGS */ /* parsed args */ int msec; /* start date milli sec parsed from REQ_GTFM */ long date; /* start date sec UTC parsed from REQ_GTFM */ long ifms; /* if-modified-since sec UTC parsed from REQ_IFMS */ unsigned kali; /* keep-alive (reqno) parsed from REQ_KALI */ int cole; /* content-length parsed from REQ_COLE (CGI) */ unsigned char coty; /* content-type encoded from REQ_COTY (CGI) */ unsigned char meth; /* method code encoded from REQ_METH (CGI) */ unsigned short mode; /* PATH's stat(2) mode */ /* response/logging */ unsigned short code; /* (status code) */ char lreq[14]; /* logged request method+arg, maxlen 13 (G) */ char stat[4]; /* logged status: maxlen 3 (from code) or 4 (WARN) */ long size; /* response incl. headers */ } Req; static const unsigned char b36val[256] = { 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,36,36,36,36,36,36, 36,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24, 25,26,27,28,29,30,31,32,33,34,35,36,36,36,36,36, 36,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24, 25,26,27,28,29,30,31,32,33,34,35,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36 }; static unsigned a2u (const char *p, int l) { unsigned ret = 0, d; while (l-- && 10 > (d = b36val[(unsigned char)*p++])) ret = 10*ret + d; return ret; } #if 0 # define a2u2(c,o) (10*(c[o]-'0')+c[o+1]-'0') #else /* a few bytes smaller */ static int a2u2(const char *c, int o) { return 10*(c[o]-'0')+c[o+1]-'0'; } #endif static int u2a (char *p, unsigned u) { if (u) { char buf[10], *d = buf+10, *e = d, *q = p; for (; u; u/=10) *--d = '0' + (u % 10); while (d < e) *q++ = *d++; return q-p; } *p = '0'; return 1; } /* u2a */ /* with kind permission (GPL) by FeFe.de, dietlibc, libugly/asctime_r.c */ static void u2a2 (char *c, unsigned u) { c[0]=u/10+'0'; c[1]=u%10+'0'; } enum { /* why die? -- must keep in sync */ DIE_ok, /* do NOT change */ DIE_eof, /* ok, but done -- do NOT change */ DIE_bad, DIE_args, DIE_env, DIE_sock, DIE_name, /* I've been through the desert on a horst with no name */ DIE_addr, DIE_bind, DIE_listen, DIE_basedir, DIE_chroot, DIE_setuid, DIE_wait, DIE_fork, DIE_accept, DIE_peer, DIE_recv, DIE_time, DIE_readlink, DIE_open, DIE_read, DIE_write, DIE_exec, DIE_dup, DIE_hard }; static void die (int code) __attribute__ ((noreturn)); #ifdef DEBUG # include # define D(format, args...) fprintf(stderr, format "\n" , ## args) const char * const death[DIE_hard] = { "ok", "eof", "bad", "args", "env", "sock", "name", "addr", "bind", "listen", "basedir", "chroot", "setuid", "wait", "fork", "accept", "peer", "recv", "time", "readlink", "open", "read", "write", "exec", "dup" }; #else # define D(format, args...) #endif static void die (int code) { char buf[256], *c=buf; c += u2a(c, code); *c++ = ':'; c += u2a(c, errno); #ifdef DEBUG { const char *msg = 0<=code && code<(int)(sizeof death/sizeof death[0]) ? death[code] : "hard"; int l = strlen(msg); const char *e = strerror(errno); *c++ = ' '; memcpy(c, msg, l); c += l; if (e) { *c++ = ':'; l = strlen(e); if (buf+255-c < l) l = buf+255-c; memcpy(c, e, l); c += l; } } #endif *c++ = '\n'; write(2, buf, c-buf); exit(code); } #define DIE(code) die(DIE_##code) #define DIE2(code, err) do {errno = err; DIE(code);} while (0) /* 2 die 4 */ static const char days[] = "Sun,Mon,Tue,Wed,Thu,Fri,Sat,"; static const char months[] = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec "; static const unsigned short mondays[12] = {0,31,59,90,120,151,181,212,243,273,304,334}; /* like BSD's timegm, but not fixing tm */ /* 1 29th Feb for every full 48 months since Feb 68 - best before end of 2099 */ #define gmseconds(t) (3600*(t).tm_hour + 60*(t).tm_min + (t).tm_sec \ + 86400*(/*days*/ (t).tm_mday-1 + mondays[(t).tm_mon] \ + 365*((t).tm_year-70) + (((t).tm_year-68)*12+(t).tm_mon-2)/48)) static int getmonth (const char *c) { #ifdef __i386__ int *m = ((int*)months)+12; int cmp = (0xffffff&*(int*)c) | (32<<24); while ((int*)months != m--) if (cmp == *m) return (m-(int*)months); #else const char *m = months+48; while (months <= (m -= 4)) if (*c == *m && c[1] == m[1] && c[2] == m[2]) return (m-months)>>2; #endif return 0; } /* 0123456789012345678901234567890 Sun, 06 Nov 1994 08:49:37 GMT ; RFC 822, updated by RFC 1123 Sunday, 06-Nov-94 08:49:37 GMT ; RFC 850, obsoleted by RFC 1036 Saturday, 1-Jan-83 ............ ; grrr ... same Sun Nov 6 08:49:37 1994 ; ANSI C's asctime() format */ static long /*time_t*/ date1945_parse (const char *c) /* RFC 1945 3.3 */ { struct tm t; int l = strlen(c); memset(&t, 0, sizeof t); switch (l) { case 29: /* 1123: Sun, 06 Nov 1994 08:49:37 GMT */ t.tm_year = 100*a2u2(c,12)+a2u2(c,14)-1900; t.tm_mon = getmonth(c+8); t.tm_mday = a2u2(c,5); t.tm_hour = a2u2(c,17); t.tm_min = a2u2(c,20); t.tm_sec = a2u2(c,23); return gmseconds(t); #if 0 case 24: /* ctim: Sun Nov 6 08:49:37 1994 */ t.tm_year = 100*a2u2(c,20)+a2u2(c,22)-1900; t.tm_mon = getmonth(c+4); t.tm_mday = c[6]-'0'; if (' ' != c[5]) t.tm_mday += 10*(c[5]-'0'); t.tm_hour = a2u2(c,11); t.tm_min = a2u2(c,14); t.tm_sec = a2u2(c,17); return gmseconds(t); default: /* 1036: Sunday, 06-Nov-94 08:49:37 GMT */ #endif } return 0; } /* with kind permission (GPL) by FeFe.de, dietlibc, libugly/asctime_r.c */ /* Sun, 06 Nov 1994 08:49:37 GMT */ /* 01234567890123456789012345678 */ static void date1123_make (char *c, struct tm *t) { #ifdef __i386__ # define CP4(d, s) *(int*)(d) = *(int*)(s) #else # define CP4(d, s) memcpy(d, s, 4) #endif CP4(c, days+(t->tm_wday<<2)); u2a2(c+5, t->tm_mday); CP4(c+8, months+(t->tm_mon<<2)); u2a2(c+12, (t->tm_year+1900)/100); u2a2(c+14, (t->tm_year+1900)%100); u2a2(c+17, t->tm_hour); u2a2(c+20, t->tm_min); u2a2(c+23, t->tm_sec); c[25] = c[16] = c[7] = c[4] = ' '; c[22] = c[19] = ':'; CP4(c+26, "GMT"); } static void gtfmsec_make (char *c, struct tm *t, int msec) { u2a2(c, (t->tm_year+1900)/100); u2a2(c+2, (t->tm_year+1900)%100); u2a2(c+4, t->tm_mon+1); u2a2(c+6, t->tm_mday); u2a2(c+8, t->tm_hour); u2a2(c+10, t->tm_min); u2a2(c+12, t->tm_sec); c[14] = msec/100+'0'; u2a2(c+15, msec%100); c[17] = 0; } typedef struct { Str key; Str val; } MT; #ifndef CHARSET # define CHARSET "; charset=ISO-8859-1" #endif static char Text_Html[] = "text/html" CHARSET; static char Text_Xml[] = "text/xml" CHARSET; static char Img_Jpeg[] = "image/jpeg"; static char Vid_Mpeg[] = "video/mpeg"; static char Vid_Qt[] = "video/quicktime"; static const Str text_html = STR(Text_Html); static const Str * const defct = &text_html; static MT mt[] = { {STR("gif"), STR("image/gif")}, {STR("jpeg"),STR(Img_Jpeg)}, {STR("jpg"), STR(Img_Jpeg)}, {STR("html"),STR(Text_Html)}, {STR("htm"), STR(Text_Html)}, {STR("xml"), STR(Text_Xml)}, {STR("txt"), STR("text/plain" CHARSET)}, {STR("css"), STR("text/css")}, {STR("ico"), STR("image/x-icon")}, {STR("swf"), STR("application/x-shockwave-flash")}, {STR("js"), STR("application/x-javascript")}, {STR("dvi"), STR("application/x-dvi")}, {STR("ps"), STR("application/postscript")}, {STR("pdf"), STR("application/pdf")}, {STR("png"), STR("image/png")}, {STR("mpeg"),STR(Vid_Mpeg)}, {STR("mpg"), STR(Vid_Mpeg)}, {STR("avi"), STR("video/x-msvideo")}, {STR("mov"), STR(Vid_Qt)}, {STR("qt"), STR(Vid_Qt)}, {STR("mp3"), STR("audio/mpeg")}, {STR("ogg"), STR("audio/x-oggvorbis")}, {STR("wav"), STR("audio/x-wav")}, {STR("pac"), STR("application/x-ns-proxy-autoconfig")}, {STR("sig"), STR("application/pgp-signature")}, {STR("zip"), STR("application/octet-stream" )}, {STR("bz2"), STR("application/octet-stream" )}, {STR("gz"), STR("application/octet-stream" )} }; static const Str *mtget (const Str *key) { MT *ent = mt, *end = mt + sizeof mt/sizeof mt[0]; for (; ent < end; ent++) if (key->l == ent->key.l && *key->c == *ent->key.c && !memcmp(key->c, ent->key.c, key->l)) return &ent->val; return 0; } /* default and text/html time to live */ static int dttl = 86400, httl /* = 0 */; /* request headers/env */ static const Str GET = STR("GET "); static const Str HEAD = STR("HEAD "); static const Str POST = STR("POST "); static const char HDR_COLE[] = "content-length: "; static const char HDR_COOK[] = "cookie: "; static const char HDR_COTY[] = "content-type: "; static const char HDR_HOST[] = "host: "; static const char HDR_IFMS[] = "if-modified-since: "; static const char HDR_KALI[] = "connection: keep-alive"; static const char HDR_REFR[] = "referer: "; static const char HDR_USAG[] = "user-agent: "; static const Str Default = STR("default"); static const Str Html = STR(".html"); /* response headers */ #ifndef KA_TIMO # define KA_TIMO 30 #endif #ifndef KA_TIMOSTR # define KA_TIMOSTR "Keep-Alive: timeout=30\r\n" #endif static const char Connection_ka[] = "Connection: Keep-Alive\r\n" KA_TIMOSTR; static const char Content_Length[] = "Content-Length: "; static const char Content_Type[] = "Content-Type: "; static const char Date[] = "Date: "; static const char Expires[] = "Expires: "; static const char Last_Modified[] = "Last-Modified: "; static const char Location[] = "Location: "; static const char HTTP_[] = "HTTP_"; static const Str cginames[REQ_ARGS] = { STR("REMOTE_ADDR="), STR("X_CONN="), STR("X_KALI="), STR("SERVER_NAME="), STR("SERVER_PORT="), STR("X_DATE="), STR("X_GTFM="), STR("REQUEST_METHOD="), STR("X_IFMS="), STR("CONTENT_LENGTH="), STR("CONTENT_TYPE="), STR("SCRIPT_NAME="), STR("PATH_INFO="), STR("REQUEST_URI="), STR("QUERY_STRING="), STR("SERVER_PROTOCOL="), STR("HTTP_REFERER="), STR("HTTP_USER_AGENT="), STR("HTTP_COOKIE="), STR("REMOTE_USER="), STR("X_USR0="), STR("X_USR1=") }; static const char dot404[] = ".404"; static char http40x[] = "HTTP/1.0 40x :(\r\nContent-Length: 9\r\n\r\nnot found"; #define HTTP_1_0_ 9 /* length up to code */ #define HTTP_1_0_40 11 /* pos of the x */ static char reqbuf[HTTPSIZ], resbuf[HTTPSIZ]; #define reqbufend (reqbuf+HTTPSIZ) static const int si=1, no; /* for setsockopt */ static Req req; #ifdef DEBUG static int pid, conns, reqs; #endif /* *xend is the next free env pointer after fixed/conn */ static char envbuf[CGISIZ], *env[ENVLEN], **fend, **cend, **end; /* a short string with id */ typedef struct { char *c; short l; short i; } Line; static Line *line; static int chkhdr (int id, const char *p) /* "case insensitive" */ { char *s = line->c; do if (*p++ != (0x20|*s++)) return 0; while (*p); req.args[id].l = line->l - ((req.args[id].c = s) - line->c); return line->i = id; } #define CHKHDR(i) chkhdr(REQ_##i, HDR_##i) /* dirty private macros to append to char *c */ /* cat a string */ #define CAT(n, l) do { memcpy(c, n, l); c += (l); } while(0) /* cat a string constant (name) */ #define CATC(n) CAT(n, sizeof n-1) /* cat a Str */ #define CATS(s) do { memcpy(c, (s).c, (s).l); c += (s).l; } while(0) /* ... including the 0 byte */ #define CATS0(s) do { memcpy(c, (s).c, (s).l+1); c += (s).l+1; } while(0) #define CATCS(n, s) do { CATC(n); CATS(s); } while(0) #define CATCRLF() do { *c++ = CR; *c++ = LF; } while(0) # define CATCGI(i) CATS(cginames[i]) # define ENDCGI(i) *++end = c #if 0 #define CATARG(i) do { if (req.args[REQ_##i].c) { \ CATCGI(REQ_##i); CATS0(req.args[REQ_##i]); ENDCGI(REQ_##i); } } while(0) #else static char *catarg (char *c, int i) { if (req.args[i].c) { CATCGI(i); CATS0(req.args[i]); ENDCGI(i); } return c; } #define CATARG(i) do {c = catarg(c, REQ_##i); } while (0) #endif static void childstatus (int child, int status) { char buf[64] = "child\t", *c = buf+6; c += u2a(c, child); *c++ = '\t'; c += u2a(c, status); *c++ = '\n'; write(2, buf, c-buf); } static char *append (char *c, Str *s) { if (s->c) { memcpy(c, s->c, s->l); c += s->l; } *c++ = HT; return c; } /* make a log line; return length */ /* parses sec, msec from gtf, unless sec */ /* defaults meth (from mc) and stat (from code) */ static int logline () { Str *s = req.args; char *c = resbuf, *e = resbuf+sizeof resbuf-REQ_ARGS-2/* some HT, LF and a 0 */; int i, l; long msecdiff; struct timeval tv; /* fixed part up to headers must not exceed sizeof resbuf */ /* print GTFM, ADDR, CONN#KALI */ c = append(c, s+REQ_GTFM); c = append(c, s+REQ_ADDR); c = append(c, s+REQ_CONN); if (req.kali) { c[-1] = '#'; c += u2a(c, req.kali); *c++ = HT; } /* compute request time msecdiff */ gettimeofday(&tv, 0); msecdiff = (tv.tv_sec - req.date)*1000 + tv.tv_usec/1000 - req.msec; if (0 <= msecdiff) c += u2a(c, (unsigned)msecdiff); /* else it's broken */ *c++ = HT; /* result stat as set or from code */ if (*req.stat) { for (l=0; l<4 && req.stat[l];) l++; } else { i = ((unsigned short)req.code)%1000; req.stat[0] = '0'+i/100; u2a2(req.stat+1,i%100); l = 3; } memcpy(c, req.stat, l); c += l; *c++ = HT; /* result size */ c += u2a(c, req.size); *c++ = HT; /* log req as set or from method+param */ if (*req.lreq) { for (l=0; l<(int)sizeof req.lreq && req.lreq[l];) l++; } else { long num = 0; l = 1; switch (req.meth) { case METH_BODY: req.lreq[0] = 'B'; break; case METH_HEAD: req.lreq[0] = 'H'; break; case METH_GET: req.lreq[0] = 'G'; num = req.ifms; break; case METH_POST: req.lreq[0] = 'P'; num = req.cole; break; default: req.lreq[0] = '#'; num = req.meth; } if (num) l += u2a(req.lreq+1, num); } memcpy(c, req.lreq, l); c += l; *c++ = HT; /* others next to unmodified */ for (i=REQLOG; i e-c) { memcpy(c, p, e-c); c = e; break; } memcpy(c, p, l); c += l; } *c++ = HT; } *c++ = LF; *c = 0; return c-resbuf; } #define SNDBUF 0x8000 /* 32 K */ #define RCVBUF HTTPSIZ /* 8 K */ static unsigned sendlim = 0x6000; /* 32-8 K */ static int bg = 256; /* max # backgrounded grandchilds per child */ static int nblock = MSG_DONTWAIT; /* cleared in childs */ static int offspring; /* # childs */ static int forked; enum { BG_RECV, BG_WRITE, BG_SENDF, BG_CGI, BG_KALI, BG_CW, BG_FAIL, BG_STATS }; static int bgstat[BG_STATS]; static int background (int why) /* 0 in child */ { int chld; D("backgrounding %d (%d)", offspring, pid); if (offspring) { while (0 < waitpid(-1, 0, WNOHANG) && --offspring); if (bg <= offspring) { bgstat[BG_FAIL]++; return -1; /* drop it */ } } if (!(chld = fork())) { #ifdef DEBUG pid = getpid(); #endif alarm(KA_TIMO+5); return offspring = nblock = 0; } if (0 < chld) { D("background() (%d) forked: %d", pid, chld); forked = 1; bgstat[why]++; offspring++; } return 1; } /* handle one request return keep_alive */ static int request () { int fd = -1, status, child, ttl; Line lines[HTTPLEN]; time_t tt; struct tm tm; struct stat st; char *c = reqbuf, *lf, *p, *q; const char *file; end = cend; (line = lines)->c = reqbuf; /* clear all but ADDR, CONN (KALI set l8r from kali) */ memset(req.args+2, 0, (REQ_ARGS-2)*sizeof req.args[0]); req.ifms = req.size = req.date = req.msec = 0; req.stat[0] = req.lreq[0] = 0; req.code = 400; #ifdef DEBUG reqs++; #endif if (!nblock) alarm(KA_TIMO+5); /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 1: get request headers */ for (;;) { /* fgets */ char *e; int got; got = recv(0, c, reqbufend-c, MSG_PEEK|nblock); D("%d.%d.%d: got %d+%d bytes (%d) from %s", pid, conns, req.kali, c-reqbuf, got, errno, req.args[REQ_CONN].c); if (0 >= got) { if (nblock && EAGAIN==errno) { if (background(BG_RECV)) return 0; continue; } goto closedread; } e = c+got; /* sol <= c start of next line */ for (lf = c; (lf = memchr(lf, LF, e - lf)); line->c = ++lf) { line->i = 0; if ((line->l = lf - line->c) && CR == lf[-1]) line->l--; D("< '%.*s'", line->l, line->c); line->c[line->l] = 0; if (!line->l) { if (line > lines) goto gotit; /* break 2 */ continue; /* allow leading blank lines (after bad POST in ka) */ } /* clean it -- could be done during LF scan ? */ /* prollem is stupid CR noise, which is legal exactly before LF */ q = (p = line->c)+line->l; do { if (!(0xe0 & *p) || 127 == *p) { /* replace tabs, die on others */ if (HT != *p) { D("bad char 0x%x off %d", *p, p-reqbuf); goto verybadreq; } *p = ' '; } } while (q != ++p); /* check headers */ if (line != lines) switch (0x20|*line->c) { case 'c': if ('o' == (0x20|line->c[1])) (void)(CHKHDR(KALI) ||CHKHDR(COTY) ||CHKHDR(COLE) ||CHKHDR(COOK)); break; case 'h': CHKHDR(HOST); break; case 'i': if (CHKHDR(IFMS)) req.ifms = date1945_parse(req.args[REQ_IFMS].c); break; case 'r': CHKHDR(REFR); break; case 'u': CHKHDR(USAG); break; case ' ': /* unfold */ /* if (lines+1 == l) goto badreq; well ... why not :) */ /* move back (incl blank and 0 byte) to cover preceeding [CR]LF */ memmove(line[-1].c+line[-1].l, line->c, line->l+1); line[-1].l += line->l; continue; } if ((lines+HTTPLEN) == ++line) goto badreq; /* too long */ /* if (!line->i) req.xtra++; addl. (unknown) header */ } /* for LF */ if (got != recv(0, resbuf, got, 0)) DIE(recv); /* clear from buf */ if (reqbufend == (c = e)) goto badreq; /* too long */ } /* for recv */ gotit: /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 2: get time, parse request line */ if (lines == line) goto badreq; /* too short */ /* time stuff #1 */ { struct timeval tv; if (gettimeofday(&tv, 0)) DIE(time); req.msec = tv.tv_usec/1000; tt = req.date = tv.tv_sec; gmtime_r(&tt, &tm); } /* now lf terminated header -- clear c to there */ lf++; if (lf-c != recv(0, resbuf, lf-c, 0)) DIE(recv); /* clear headers */ D("< %d.%d.%d: %d header lines", pid, conns, req.kali, line-lines); c = *end; /* add cleaned dates in CGI buffer land */ CATCGI(REQ_DATE); date1123_make(req.args[REQ_DATE].c = c, &tm); req.args[REQ_DATE].l = DATE1123_CHARS-1; c += DATE1123_CHARS; ENDCGI(REQ_DATE); CATCGI(REQ_GTFM); gtfmsec_make(req.args[REQ_GTFM].c = c, &tm, req.msec); req.args[REQ_GTFM].l = GTF_MSEC_CHARS-1; c += GTF_MSEC_CHARS; ENDCGI(REQ_GTFM); /* request line */ req.meth = METH_OTHER; switch (*lines->c) { case 'G': if (!memcmp(lines->c, GET.c, 4)) req.meth = METH_GET; break; case 'H': if (!memcmp(lines->c, HEAD.c, 5)) req.meth = METH_HEAD; break; case 'P': if (!memcmp(lines->c, POST.c, 5)) { req.meth = METH_POST; break; } /* default: send PUT et al. to .501 ? .405 ? */ } if (METH_OTHER == req.meth) { D("bad method"); goto badreq; } (req.args[REQ_METH].c = lines->c)[ req.args[REQ_METH].l = METH_GET==req.meth ? 3 : 4] = 0; STROFF(req.args+REQ_PATH, lines, req.args[REQ_METH].l+1); if (!(p = memchr(req.args[REQ_PATH].c, SP, req.args[REQ_PATH].l))) { if (METH_GET != req.meth) goto badreq; /* "violating" "HTTP/0.9", we allow some headers (Host), but no ka */ req.args[REQ_KALI].c = 0; req.meth = METH_BODY; } else { *p++ = 0; STROFF(req.args+REQ_PROT, req.args+REQ_PATH, p-req.args[REQ_PATH].c); req.args[REQ_PATH].l = p-req.args[REQ_PATH].c-1; } if ((p = memchr(req.args[REQ_PATH].c, '?', req.args[REQ_PATH].l))) { *p++ = 0; STROFF(req.args+REQ_QRYS, req.args+REQ_PATH, p-req.args[REQ_PATH].c); req.args[REQ_PATH].l = p-req.args[REQ_PATH].c-1; } if ('/' != *req.args[REQ_PATH].c) { D("path starts 0x%x", *req.args[REQ_PATH].c); goto verybadreq; } for (p = req.args[REQ_PATH].c; *p;) if ('/'==*p++ && ('.' == *p || '/' == *p)) { D("path has /. at %d", p - req.args[REQ_PATH].c); goto verybadreq; } /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 3: vhosting */ if (!req.args[REQ_HOST].c) req.args[REQ_HOST] = Default; else { if ((p = memchr(req.args[REQ_HOST].c, ':', req.args[REQ_HOST].l))) { int l = p-req.args[REQ_HOST].c; *p = 0; /* strip port - it's not reliably sent */ req.args[REQ_PORT].c = p+1; req.args[REQ_PORT].l = req.args[REQ_HOST].l-l-1; req.args[REQ_HOST].l = l; } if (!*req.args[REQ_HOST].c || '.' == *req.args[REQ_HOST].c || strchr(req.args[REQ_HOST].c, '/') || 4 > req.args[REQ_HOST].l ) { D("bad host '%s'", req.args[REQ_HOST].c); goto verybadreq; } for (p = req.args[REQ_HOST].c; *p; p++) /* lowercase */ if ('Z' >= *p && *p >= 'A') *p += 32; } if (chdir(req.args[REQ_HOST].c)) { D("unknown host '%s'", req.args[REQ_HOST].c); goto badreq; /* bad host */ } close(1); open(".log", O_CREAT|O_WRONLY|O_APPEND, 0640); /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 4: stat path and .404 */ req.code = 200; for (file = req.args[REQ_PATH].c+1;;) { if (lstat(file, &st)) goto notfound; if (S_ISLNK(st.st_mode)) { struct stat st2; if (stat(file, &st2)) { /* a) found dangling symlink - ok */ req.code = 301; st.st_size = 0; st.st_mode &= ~(S_IXUSR|S_IXGRP|S_IXOTH); break; } st = st2; /* deref */ } #define S_ISEXE(m) ((S_IXUSR|S_IXGRP|S_IXOTH)&(m)) if (S_ISREG(st.st_mode)) { if (S_ISEXE(st.st_mode) /* b) we (try to) execute */ || (METH_POST != req.meth && S_IROTH&st.st_mode) ) /* c) GET/HEAD on world readable file */ break; } notfound: /* nothing, dir, fifo, special files */ if (404 != req.code) { file = dot404; req.code = 404; req.mode = (unsigned short)st.st_mode; continue; } http40x[HTTP_1_0_40] = '4'; send(0, http40x, req.size = sizeof http40x-1, 0); goto broken; /* req.kali = 0; */ } if (req.args[REQ_KALI].c) req.kali++; else req.kali = 0; if (!S_ISEXE(st.st_mode)) { /* case a) or c) */ /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 5a: make response */ /* here we go: code 301 -> redir 301 code 404 (as regular file) -> 404 (regardles) not modified -> 304 else 200 */ c = resbuf; if (METH_BODY == req.meth && 301 != req.code) req.size = 0; /* send 200 or .404 file */ else { const Str *ct = 0; if (200 == req.code && METH_GET == req.meth && req.ifms && req.ifms >= st.st_mtime) req.code = 304; CAT(http40x, HTTP_1_0_); /* HTTP/1.0_ */ c += u2a(c, req.code); *c++ = ' '; *c++ = ':'; *c++ = ')'; CATCRLF(); CATC(Date); CAT(req.args[REQ_DATE].c, DATE1123_CHARS-1); CATCRLF(); #ifdef SERVER_SOFTWARE /* -DSERVER_SOFTWARE=Coronita */ { static const char srvsw[] = "Server: " SERVER_SOFTWARE "\r\n"; CATC(srvsw); } #endif switch (req.code) { case 301: CATC(Location); st.st_size = readlink(file, p = c, sizeof(resbuf)/2); if (0 >= (int)st.st_size) DIE(readlink); c += st.st_size; CATCRLF(); req.kali = 0; break; case 404: ct = &text_html; break; default: /* 200, 304 */ tt = st.st_mtime; CATC(Last_Modified); gmtime_r(&tt, &tm); date1123_make(c, &tm); c += DATE1123_CHARS-1; CATCRLF(); if (304 == req.code) goto skip_cl; p = q = req.args[REQ_PATH].c + req.args[REQ_PATH].l; while (req.args[REQ_PATH].c <= --p) if ('.' == *p) { Str ext; ext.l = q-(ext.c = ++p); ct = mtget(&ext); break; } if (!ct) ct = defct; ttl = Text_Html == ct->c ? httl : dttl; CATC(Expires); if (!ttl) /* now */ CAT(req.args[REQ_DATE].c, DATE1123_CHARS-1); else { tt = req.date + ttl; gmtime_r(&tt, &tm); date1123_make(c, &tm); c += DATE1123_CHARS-1; } CATCRLF(); } if (ct) { D("got ct %d '%.*s'", ct->l, ct->l, ct->c); CATC(Content_Type); CAT(ct->c, ct->l); CATCRLF(); } CATC(Content_Length); c += u2a(c, st.st_size); CATCRLF(); skip_cl: if (req.kali) CATC(Connection_ka); CATCRLF(); if (301 == req.code) CAT(p, st.st_size); /* append the link as text body */ req.size = c - resbuf; D("> '%.*s'", (int)req.size, resbuf); } /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 6a: send response */ { int wrote = 0; if (METH_HEAD == req.meth || (200 != req.code && 404 != req.code)) { /* 301, 304: send header only */ setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &si, 4); if (req.size != (wrote = send(0, resbuf, req.size, nblock))) goto trybg; } else { /* send body, optionally with header */ if (0 > (fd = open(file, O_RDONLY))) DIE(open); if ((int)st.st_size <= (int)sizeof resbuf - req.size) { if ((int)st.st_size != read(fd, c, st.st_size)) DIE(read); req.size += st.st_size; setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &si, 4); if (req.size != (wrote = send(0, resbuf, req.size, nblock))) goto trybg; } else { /* send body */ #if defined(__linux__) || defined(__sun__) if ((unsigned)st.st_size > sendlim) { /* try sendfile */ if (nblock && background(BG_SENDF)) goto abort; /* so we're backgrounded and have an alarm set */ /* raise the alarm time to 1sec/kb */ alarm((unsigned)st.st_size >> 10); { #if defined(__linux__) off_t off = 0; setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &no, 4); setsockopt(0, IPPROTO_TCP, TCP_CORK, &si, 4); if ((req.size && req.size != send(0, resbuf, req.size, 0)) || (int)st.st_size != sendfile(0, fd, &off, st.st_size) ) goto writerr; setsockopt(0, IPPROTO_TCP, TCP_CORK, &no, 4); req.size += st.st_size; #elif defined(__sun__) /* have nice sendfilev */ sendfilevec_t sfv[2]; size_t xferred; int nohead = !req.size; sfv[0].sfv_fd = SFV_FD_SELF; sfv[0].sfv_flag = 0; sfv[0].sfv_off = (off_t)resbuf; sfv[0].sfv_len = req.size; sfv[1].sfv_fd = fd; sfv[1].sfv_flag = 0; sfv[1].sfv_off = 0; sfv[1].sfv_len = st.st_size; req.size += st.st_size; if ((int)req.size != sendfilev(0, sfv+nohead, 2-nohead, &xferred)) goto writerr; #endif } } else { /* within sendlim: use mmap */ /* should work within alarm time */ #endif struct msghdr mh; struct iovec iov[2]; int nohead = !(iov[0].iov_len = req.size); char *map = mmap(0, iov[1].iov_len = st.st_size, PROT_READ, MAP_SHARED, fd, 0); iov[0].iov_base = resbuf; iov[1].iov_base = map; mh.msg_iov = iov+nohead; mh.msg_iovlen = 2-nohead; mh.msg_name = mh.msg_control = 0; mh.msg_namelen = mh.msg_controllen = 0; req.size += st.st_size; { int w; magain: w = sendmsg(0, &mh, nblock); if (0 < w) wrote += w; if (wrote != req.size) { if (!nblock || (0 > w && EAGAIN != errno)) { munmap(map, st.st_size); goto writerr; } if (background(BG_WRITE)) { munmap(map, st.st_size); goto abort; } if (nohead || wrote >= (int) iov[0].iov_len) { iov[1].iov_base += wrote - iov[0].iov_len; iov[1].iov_len -= wrote - iov[0].iov_len; mh.msg_iov = iov + 1; mh.msg_iovlen = 1; } else { iov[0].iov_base += wrote; iov[0].iov_len -= wrote; } goto magain; } } munmap(map, st.st_size); #if defined(__linux__) || defined(__sun__) } #endif } /* send body */ } if (0) { trybg: if (!nblock || (0 > wrote && EAGAIN != errno)) goto writerr; if (background(BG_WRITE)) goto abort; if (0 > wrote) wrote = 0; if (req.size - wrote != send(0, resbuf + wrote, req.size - wrote, nblock)) goto writerr; } D("> %d.%d.%d: wrote %ld bytes", pid, conns, req.kali, req.size); goto logit; } } /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 5b: make CGI env */ if (nblock && background(BG_CGI)) goto abort; /* background on CGI */ /* let the alarm untouched; the CGI may clear it */ /* if the CGI takes longer, we're not interested in doing keepalive */ c = *end; if (req.kali) { CATCGI(REQ_KALI); c += u2a(c, req.kali); *c++ = 0; ENDCGI(REQ_KALI); } CATARG(HOST); CATARG(PORT); CATARG(METH); if (404 == req.code) CATCGI(REQ_INFO); else CATCGI(REQ_NAME); CATS0(req.args[REQ_PATH]); ENDCGI(REQ_PATH); CATARG(QRYS); CATARG(PROT); if (req.ifms) { CATCGI(REQ_IFMS); c += u2a(c, req.ifms); *c++ = 0; ENDCGI(REQ_IFMS); } while (--line > lines) { int i; char ch, *sol = c; /* start of line */ if (line->i) { if (line->i < REQPASS) continue; CATCGI(line->i); CATS0(req.args[line->i]); ENDCGI(line->i); continue; } CATC(HTTP_); for (p = line->c; ;) { ch = *p++; if ('a' <= ch) { if ('z' >= ch) { *c++ = 0xdf & ch; continue; } goto skipheader; } if ('A' <= ch) { if ('Z' >= ch) { *c++ = ch; continue; } goto skipheader; } if ('-' == ch) { *c++ = '_'; continue; } if (':' == ch && SP == *p) { p++; break; } if ('0' <= ch && '9' >= ch) { *c++ = ch; continue; } goto skipheader; } *c++ = '='; i = line->l+1-(p-line->c); CAT(p, i); *++end = c; continue; skipheader: D("skipping header '%s' at off %d '%c'",line->c, p-line->c, ch); c = sol; } /* ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** PHASE 6b: exec CGI */ if (!(child = fork())) { char *argv[2]; argv[0] = req.args[REQ_PATH].c; argv[1] = 0; *end = 0; execve(file, argv, env); DIE(exec); } if (0 > child) DIE(fork); if (0 > (child = waitpid(-1, &status, 0))) DIE(wait); if (status) { childstatus(child, status); req.kali = 0; } goto done; closedread: if (reqbuf == c) goto abort; /* just empty */ goto verybadreq; badreq: http40x[HTTP_1_0_40] = '0'; send(0, http40x, sizeof http40x-1, MSG_DONTWAIT); verybadreq: /* not even worth an answer */ D("bad req"); req.code = 400; goto broken; writerr: D("%d.%d.%d: write err %d", pid, conns, req.kali, errno); req.code = 0; broken: req.kali = 0; logit: write(1, resbuf, logline()); if (0) { abort: req.kali = 0; } done: if (0 <= fd) close(fd); if (fchdir(4)) DIE(basedir); if (req.kali && nblock && background(BG_KALI)) req.kali = 0; return req.kali; } /* request */ static char **filter; static int inito = 10; /* msecs initial timeout */ /* parse args, prepare structures return: n a listening socket (must be > 2) never in the monitoring mother process */ static int setup (int argc, char **argv) { int addr = INADDR_ANY, childs = 8, uid = getuid(), curchilds; char **heritage = environ; static struct sockaddr_in sa; int port = 80; for (fend = env; *heritage; heritage++) { /* copy env */ if ((env+PRELEN) == fend) DIE(env); *fend++ = *heritage; } while (--argc && '-' == **++argv) { /* server args ... */ int arg = a2u(*argv+2, -1); switch ((*argv)[1]) { case 'a': addr = arg; break; case 'b': bg = arg; break; case 'c': childs = arg; break; case 'h': httl = arg; break; case 'i': inito = arg; break; case 'p': port = arg; break; case 's': sendlim = arg; break; case 't': dttl = arg; break; case 'u': if (!uid) uid = arg; break; /* only ruid 0 may set */ default: { static const char usage[] = "coronita [-cchilds -bbackground -hhtmlttl -ssendlimit -pport" " -tdefaultttl -uuid] [filter ...]\n\n"; write(2, usage, sizeof usage-1); exit(1); } } } if (argc) filter = argv; sa.sin_family = AF_INET; sa.sin_addr.s_addr = htonl(addr); sa.sin_port = htons(port); close(3); if (3 != socket(PF_INET, SOCK_STREAM, 0) || setsockopt(3, SOL_SOCKET, SO_REUSEADDR, &si, sizeof si) || bind(3, (struct sockaddr*)&sa, sizeof sa) || listen(3, 64) || fcntl(3, F_SETFD, FD_CLOEXEC) ) DIE(sock); close(4); if ((4 != open(".", O_RDONLY)) || fcntl(4, F_SETFD, FD_CLOEXEC)) DIE(basedir); if (!geteuid()) { if (chroot(".")) DIE(chroot); if (uid && setuid(uid)) DIE(setuid); } for (curchilds = 0;;) { int waitflg = 0, child, status; do { if (!(child = fork())) return 3; if (0 > child) DIE(fork); } while (++curchilds < childs); for (;; waitflg = WNOHANG) { if (0 > (child = waitpid(-1, &status, waitflg))) DIE(wait); if (!child) break; if (status) childstatus(child, status); if (!--curchilds) break; } } return -42; } /* setup */ static void chldhandler (int foo) { (void)foo; while (0 < waitpid(-1, 0, WNOHANG) && --offspring); } static void huphandler (int foo) { char buf[16*BG_STATS], *c = buf; int i; (void)foo; for (i=0; i /* mem* */ #include /* mkstemp */ #include /* file stuff */ #include #include /* F_SETFL */ #include /* gmtime */ #include #include #include #include #include /* gettimeofday */ #include /* writev */ #include /* IPPROTO_TCP */ #if defined(__sun__) || defined(__APPLE__) #include /* TCP_NODELAY */ #endif /* character constants */ #define HT 9 #define LF 10 #define CR 13 #define SP 32 /* fixed length string data types */ #define GTF_MSEC_CHARS 18 /* YYYYMMDDhhmmssttt + 0 byte */ #define DATE1123_CHARS 30 /* Sun, 06 Nov 1994 08:49:37 GMT + 0 byte */ #define ADDR_CHARS 40 /* REMOTE_ADDR incl. 0 byte */ #define CONN_CHARS 32 /* X_CONN incl. 0 byte */ #define ENVLEN 128 /* max number env vars (incl. preset) */ #define PRELEN 64 /* max number of preset (inherited) env vars */ #define HTTPSIZ 8192 /* max request size (headers) */ #define LOGSIZ 8192 /* max logline size */ #define CFGSIZ 4096 #define CFGLEN 64 extern char **environ; /* string with length. if !c, l is undefined */ typedef struct { char *c; int l; } Str; #define STR(x) {x, sizeof x-1} #define STROFF(d, s, o) do { \ (d)->c = (s)->c + (o); \ (d)->l = (s)->l - (o); \ } while (0) enum { METH_BODY, /* HTTP/0.9 simple */ METH_HEAD, METH_GET, METH_POST, METH_OTHER }; /* connection and request data CGI: more or less standard RFC 3875 ENV: extended environment S: from socket R: from request line M: modified header (Keep-Alive, Host, If-Modified-Since) H: header as is (Range, Content-Length+Type, Referer, User-Agent, Cookie) O: otherwise added */ enum { REQ_ADDR, /* S CGI REMOTE_ADDR, maxlen 39 */ REQ_CONN, /* S ENV X_CONN (PORT etc.), maxlen 31 */ REQ_KALI, /* M ENV X_KALI (number), maxlen 10 (where Connection: Keep...)*/ REQ_HOST, /* M CGI SERVER_NAME (from Host header) */ REQ_PORT, /* M CGI SERVER_PORT ( " ) */ REQ_DATE, /* O ENV X_DATE, [DATE1123_CHARS] */ REQ_GTFM, /* O ENV X_GTFM, [GTF_MSEC_CHARS] */ REQ_METH, /* R CGI REQUEST_METHOD */ REQ_IFMS, /* M ENV X_IFMS from If-Modified-Since in UTC (number, GET) */ #define REQPASS REQ_COLE /* first header to pass as-is: */ REQ_COLE, /* H CGI CONTENT_LENGTH (POST) */ REQ_COTY, /* H CGI CONTENT_TYPE (POST) */ REQ_NAME, /* R CGI SCRIPT_NAME part of REQ_PATH */ REQ_INFO, /* R CGI PATH_INFO part of REQ_PATH */ #define REQLOG REQ_PATH /* plain logged args: */ REQ_PATH, /* R CGI REQUEST_URI (Apache; trad. misnamed: really the path) */ REQ_QRYS, /* R CGI QUERY_STRING */ REQ_PROT, /* R CGI SERVER_PROTOCOL */ REQ_REFR, /* H CGI HTTP_REFERER */ REQ_USAG, /* H CGI HTTP_USER_AGENT */ REQ_COOK, /* H CGI HTTP_COOKIE */ REQ_USER, /* O CGI REMOTE_USER (added by filters) */ REQ_USR0, /* O ENV X_USR0 for sid or logging remarks set by CGIs */ REQ_USR1, /* O ENV X_USR1 or logging POST data set by CGIs */ REQ_ARGS /* catch 22 */ }; #define REQKNOWN 8 /* 5H and 3M headers */ #define REQLEN 62 /* max number of params */ #define REQEXTRA (REQLEN-REQ_ARGS) /* 40 headers passed as HTTP_ */ #define HTTPLEN (1+REQKNOWN+REQEXTRA) /* max number of request lines */ /* to pass a request, we need: 72 ADDR_CHARS+CONN_CHARS 8K HTTPSIZ bytes for what we got (maybe minus some known header names) 160 = 4*REQEXTRA for 'HTTP_x=' from 'x: ' plus with exec CGI: 244 for the 22 known env names as above (including a =) plus with UCGI: 256 = 8+4*REQLEN for the dictionary plus some margin to allow in-place editing */ #define CGISIZ (HTTPSIZ+2048) /* including some margin */ static const Str cginames[REQ_ARGS] = { STR("REMOTE_ADDR="), STR("X_CONN="), STR("X_KALI="), STR("SERVER_NAME="), STR("SERVER_PORT="), STR("X_DATE="), STR("X_GTFM="), STR("REQUEST_METHOD="), STR("X_IFMS="), STR("CONTENT_LENGTH="), STR("CONTENT_TYPE="), STR("SCRIPT_NAME="), STR("PATH_INFO="), STR("REQUEST_URI="), STR("QUERY_STRING="), STR("SERVER_PROTOCOL="), STR("HTTP_REFERER="), STR("HTTP_USER_AGENT="), STR("HTTP_COOKIE="), STR("REMOTE_USER="), STR("X_USR0="), STR("X_USR1=") }; static Str parm[REQLEN]; /* 22 known values + xtra HTTP_*=val strings */ static int xtra; /* # of HTTP_ headers after REQ_ARGS */ /* parsed args */ static int mili; /* start date milli sec parsed from REQ_GTFM */ static long date; /* start date sec UTC parsed from REQ_GTFM */ static long ifms; /* if-modified-since sec UTC parsed from REQ_IFMS */ static unsigned kali; /* keep-alive (reqno) parsed from REQ_KALI */ static int cole; /* content-length parsed from REQ_COLE (CGI) */ static unsigned char meth; /* method code encoded from REQ_METH (CGI) */ /* response/logging */ static unsigned short code; /* (status code) */ static char lreq[14]; /* logged request method+arg, maxlen 13 (G) */ static char status[4]; /* logged status: maxlen 3 (from code) or 4 (WARN) */ static long size; /* response incl. headers */ static const char b36dig[36] = { '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h', 'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z' }; static const unsigned char b36val[256] = { 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,36,36,36,36,36,36, 36,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24, 25,26,27,28,29,30,31,32,33,34,35,36,36,36,36,36, 36,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24, 25,26,27,28,29,30,31,32,33,34,35,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36, 36,36,36,36,36,36,36,36,36,36,36,36,36,36,36,36 }; static unsigned a2u ( const char *p, int l ) { unsigned ret = 0, d; while ( l-- && 10 > (d = b36val[(unsigned char)*p++]) ) ret = 10*ret + d; return ret; } static int u2a (char *p, unsigned u) { if ( u ) { char buf[10], *d = buf+10, *e = d, *q = p; for ( ; u; u/=10 ) *--d = '0' + (u % 10); while ( d < e ) *q++ = *d++; return q-p; } *p = '0'; return 1; } /* u2a */ /* with kind permission (GPL) by FeFe.de, dietlibc, libugly/asctime_r.c */ static void u2a2 (char *c, unsigned u) { c[0]=u/10+'0'; c[1]=u%10+'0'; } #ifdef __i386__ # define CP4(d, s) *(int*)(d) = *(int*)(s) #else # define CP4(d, s) memcpy(d, s, 4) #endif static const char days[] = "Sun,Mon,Tue,Wed,Thu,Fri,Sat,"; static const char months[] = "Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec "; static const unsigned short mondays[12] = {0,31,59,90,120,151,181,212,243,273,304,334}; static void gtfmsec_make (char *c, struct tm *t, int msec) { u2a2(c, (t->tm_year+1900)/100); u2a2(c+2, (t->tm_year+1900)%100); u2a2(c+4, t->tm_mon+1); u2a2(c+6, t->tm_mday); u2a2(c+8, t->tm_hour); u2a2(c+10, t->tm_min); u2a2(c+12, t->tm_sec); c[14] = msec/100+'0'; u2a2(c+15, msec%100); c[17] = 0; } /* like BSD's timegm, but not fixing tm */ /* 1 29th Feb for every full 48 months since Feb 68 - best before end of 2099 */ #define gmseconds(t) (3600*(t).tm_hour + 60*(t).tm_min + (t).tm_sec \ + 86400*(/*days*/ (t).tm_mday-1 + mondays[(t).tm_mon] \ + 365*((t).tm_year-70) + (((t).tm_year-68)*12+(t).tm_mon-2)/48)) #if 1 # define a2u2(c,o) (10*(c[o]-'0')+c[o+1]-'0') #else static int a2u2(const char *c, int o) { return 10*(c[o]-'0')+c[o+1]-'0'; } #endif /* fill any non-null of tm, sec and msec */ static void gtfmsec_parse (struct tm *tm, long *sec, int *msec, const char *c) { struct tm t; long s; t.tm_year = 100*a2u2(c,0)+a2u2(c,2)-1900; t.tm_mon = a2u2(c,4)-1; t.tm_mday = a2u2(c,6); t.tm_hour = a2u2(c,8); t.tm_min = a2u2(c,10); t.tm_sec = a2u2(c,12); #if 0 /* really BSD's timegm would be needed */ s = mktime(&t); s -= timezone; /* might be set by mktime */ #else s = gmseconds(t); #endif if (tm) *tm = t; if (sec) *sec = s; if (msec) *msec = 100*(c[14]-'0')+a2u2(c,15); } /* with kind permission (GPL) by FeFe.de, dietlibc, libugly/asctime_r.c */ /* Sun, 06 Nov 1994 08:49:37 GMT */ /* 01234567890123456789012345678 */ static void date1123_make (char *c, struct tm *t) { CP4(c, days+(t->tm_wday<<2)); u2a2(c+5, t->tm_mday); CP4(c+8, months+(t->tm_mon<<2)); u2a2(c+12, (t->tm_year+1900)/100); u2a2(c+14, (t->tm_year+1900)%100); u2a2(c+17, t->tm_hour); u2a2(c+20, t->tm_min); u2a2(c+23, t->tm_sec); c[25] = c[16] = c[7] = c[4] = ' '; c[22] = c[19] = ':'; CP4(c+26, "GMT"); } /* bit set for any char which requires encoding */ #define URLSPCL(c) (1&(urlspcl[((unsigned)(c))>>5]>>(0x1f&((unsigned)(c))))) static const unsigned urlspcl[8] = { 0xffffffffU, /* C0 controls */ 0xfc0088edU, /* ?>=< ;:98 7-0 /.-, +*)( '&%$ #"! */ 0x78000001U, /* _^]\ [ZYX W-D CBA@ */ 0xb8000001U, /* DEL~}| {zyx w-d cba` */ 0xffffffffU, 0xffffffffU, /* dark side */ 0xffffffffU, 0xffffffffU /* of the moon */ }; /* urlencode src to dst (which must not be == src and must have 3*len space) it encodes, strictly in accordance with RFC 2396, %xx (using lowercase hex) for <=32, >=127 and "#$%&+/:;<=>?@[\]^`{|} (i.e. it passes alphanum and !'()*,-._~) return encoded length (up to 3*len) */ static int urlenc (char *dst, char *src, int len) { unsigned char *d = (unsigned char*)dst, *s = (unsigned char*)src, *e=s+len; while (s < e) { unsigned char c = *s++; if (!URLSPCL(c)) { *d++ = c; continue; } *d++ = '%'; *d++ = b36dig[c>>4]; *d++ = b36dig[c&0x0f]; } return d - (unsigned char*)dst; } /* urldecode src to dst (which may be == src) decodes '+' to blank any malformed %xx as well as anything < 32 but HT, CR and LF (before or after decoding) is an error return decoded length or -1-offending offset on error */ static int urldec (char *dst, char *src, int len) { unsigned char *d = (unsigned char*)dst, *s = (unsigned char*)src, *e=s+len; for (;s < e; d++, s++) { if ('+' != *s) { if ('%' == (*d = *s)) { unsigned v1, v2; if (3>e-s || ~0xf&(v1 = b36val[*++s]) || ~0xf&(v2 = b36val[*++s])) goto err; *d = v1<<4 | v2; } if (0xe0&*d || HT == *d || LF == *d || CR == *d) continue; goto err; } *d = ' '; } return d - (unsigned char*)dst; err: return -1-(s - (unsigned char*)src); } /* encode <>&" as < > & and " return encoded length (up to 5*len) */ static int htmenc (char *dst, char *src, int len) { char *d = dst; while (len--) { char c = *src++; if (0x20 == (0xe0&c)) switch (c) { case '<': *d='&'; d[1]='l'; d[2]='t'; d[3]=';'; d+=4; continue; case '>': *d='&'; d[1]='g'; d[2]='t'; d[3]=';'; d+=4; continue; case '&': *d='&'; d[1]='a'; d[2]='m'; d[3]='p'; d[4]=';'; d+=5; continue; case '"': *d='&';d[1]='q';d[2]='u';d[3]='o';d[4]='t';d[5]=';';d+=6;continue; } *d++ = c; } return d - dst; } enum { /* why die? -- must keep debugdie.c in sync */ DIE_ok, /* do NOT change */ DIE_eof, /* ok, but done -- do NOT change */ DIE_bad, DIE_args, DIE_env, DIE_sock, DIE_name, /* I've been through the desert on a horst with no name */ DIE_addr, DIE_bind, DIE_listen, DIE_chroot, DIE_chdir, DIE_setgid, DIE_setuid, DIE_basedir, DIE_wait, DIE_fork, DIE_accept, DIE_peer, DIE_recv, DIE_time, DIE_readlink, DIE_open, DIE_read, DIE_write, DIE_ucgi, DIE_exec, DIE_select, DIE_ssl, DIE_hard }; #ifdef DEBUG # include # define D(format, args...) fprintf(stderr, format "\n" , ## args) void debugdie (int code) __attribute__ ((noreturn)); # define DIE(code) debugdie(DIE_##code) static const char * const death[DIE_hard] = { "ok", "eof", "bad", "args", "env", "sock", "name", "addr", "bind", "listen", "chroot", "chdir", "setgid", "setuid", "basedir", "wait", "fork", "accept", "peer", "recv", "time", "readlink", "open", "read", "write", "ucgi", "exec", "select", "ssl" }; void debugdie (int code) { char buf[256], *c=buf; c += u2a(c, code); *c++ = ':'; c += u2a(c, errno); { const char *msg = 0<=code && code<(int)(sizeof death/sizeof death[0]) ? death[code] : "hard"; int l = strlen(msg); const char *e = strerror(errno); *c++ = ' '; memcpy(c, msg, l); c += l; if ( e ) { *c++ = ':'; l = strlen(e); if (buf+255-c < l) l = buf+255-c; memcpy(c, e, l); c += l; } } *c++ = '\n'; write(2, buf, c-buf); exit(code); } #else # define D(format, args...) void die (int why) __attribute__ ((noreturn)); # define DIE(why) die(DIE_##why) void die (int why) { char buf[32], *c=buf; c += u2a(c, why); *c++ = ':'; c += u2a(c, errno); *c++ = '\n'; write(2, buf, c-buf); exit(why); } #endif #define DIE2(why, err) do {errno = err; DIE(why);} while (0) /* 2 die 4 */ #define CTYPSIZ 0x80 /* 128 byte content type */ #define CGIHSIZ 0x1000 /* 4K out headers; half for CGI */ #define CGIPSIZ 0x2000 /* 8K post buffer */ #define CGIBSIZ 0x10000 /* 64K body buffer */ static int err; /* 0=ok, 1=eof (done but close) or serious internal error */ static int hdo; /* pos in header buffer */ static int ttl; /* cache time to live (0 = none, <0 = now) */ static long lmt; /* last modified time (0 = none, <0 = now) */ static int ctl; /* ctype len */ static char ctb[CTYPSIZ]; /* ctype buffer */ static char hdb[CGIHSIZ]; /* header buffer; half for CGI */ typedef struct Qry Qry; struct Qry { Str str; Qry *nxt; }; /* the recursive htld function used by cgihtld */ int htld (const char *path, Qry *qry, Qry *tail, int depth); #define HTLDISIZ 0x4000 /* <=8K header + >= 8K body */ #define HTLDNEST 16 /* max recursion (nesting) depth */ enum { /* link commands */ HTLDHEADER, HTLDCTYPE, HTLDCACHE, HTLDDEFAULTS, HTLDVARTXT, HTLDVARURL, HTLDVARHTM, HTLDINCLUDE }; typedef struct { int ifd; /* fd */ int siz; /* body size */ int off; /* base offset of bdb in body */ int bdo; /* cur offset to bdb */ int len; /* filled length after bdb */ char *bdb; char buf[HTLDISIZ]; } IBuf; static char obf[CGIBSIZ]; static char * const end = obf + sizeof obf; /* end of available buffer */ static int tfd = -1; /* tempfile fd */ static char *cur = obf; /* cursor */ static int buffer (int n) { if (n > end - cur) { /* output time */ D("writing"); if (0 > tfd) { /* make tempfile */ const char tpl[] = "/tmp/htldXXXXXX"; char nam[sizeof tpl]; memcpy(nam, tpl, sizeof tpl); if (0 > (tfd = mkstemp(nam))) return -1; unlink(nam); fcntl(tfd, F_SETFL, O_APPEND); /* stream mode */ } D("flushing"); if (cur > obf) { int want = cur - obf; int got = write(tfd, obf, want); if (got != want) return -1; cur = obf; } } return 0; } /* buffer */ /* c.f. strstr */ static void *memmem (const void *hay, unsigned stack, const void *need, unsigned le) { const char * p = (char*)hay; const char * const e = p+stack-le+1; const char n = *(char*)need; for (; pstr.l > par->l) { char *p = qry->str.c, *qe = p+qry->str.l, *e = qe-par->l, *c; do { c = memchr(p, '&', qe-p); /* p < e, so there's at least par->l+1 space for par= */ if (!memcmp(p, par->c, par->l) && '=' == p[par->l]) { par->c = p += par->l+1; par->l = (c ? c : qe)-p; return 0; } } while (c && e > (p = c+1)); } } while (tail != qry && (qry = qry->nxt)); return -1; } /* cgigetpar */ static int cgiincpar (Str *par, int cmd) { int off = par->l, n; char *d; if (HTLDVARHTM == cmd) off *= 5; /* may need up to 6*8K = 48K */ else if (HTLDVARURL == cmd) off *= 3; else off = 0; n = off+par->l; if (n > end-cur && buffer(n)) return 500; d = cur; /* first decode it at d+off */ if (0 > (n = urldec(d+off, par->c, par->l))) return 400; /* then encode at d */ if (HTLDVARHTM == cmd) cur += htmenc(d, d+off, n); else if (HTLDVARURL == cmd) cur += urlenc(d, d+off, n); else /* plain */ cur += n; return 0; } /* cgiincpar */ const unsigned isident[8] = { /* 0-9A-Z_a-z */ 0x00000000U, /* C0 controls */ 0x03ff0000U, /* ?>=< ;:98 7-0 /.-, +*)( '&%$ #"! */ 0x87fffffeU, /* _^]\ [ZYX W-D CBA@ */ 0x07fffffeU, /* DEL~}| {zyx w-d cba` */ 0x00000000U, 0x00000000U, /* dark side */ 0x00000000U, 0x00000000U /* of the moon */ }; #define ISIDENT(c) (1&(isident[((unsigned)(c))>>5]>>(0x1f&((unsigned)(c))))) static int urlsubs (char *dst, char *de, char *s, char *se, Qry *qry, Qry *tail) { char buf[0x2000]; char *d = dst; Str par; while (s < se) { if ('$' != *s) { if (de == d) break; *d++ = *s++; continue; } if (se == (par.c = ++s)) break; while (se > s && ISIDENT(*s)) s++; if (!(par.l = s-par.c) || cgigetpar(&par, qry, tail)) continue; if ((int)sizeof buf < par.l) return -1; /* too long */ par.l = urldec(buf, par.c, par.l); if ('.'==buf[0] && (d==dst || '/'==d[-1]) ) return -1; /* bad . */ if (de-d < 3*par.l) return -1; /* too long */ d += urlenc(d, buf, par.l); } return d-dst; } /* urlsubs */ /* cp input up to offset */ static int htldcpto (IBuf *i, int off) { int len = off-i->off-i->bdo, n; /* D("cpto %d at %d+%d", off, i->off, i->bdo); */ if (0 >= len) return 0; /* already there */ if ((n = i->len-i->bdo)) { /* something to copy */ if (n > len) n = len; if (n > end-cur && buffer(n)) return 500; memcpy(cur, i->bdb+i->bdo, n); cur += n; i->bdo += n; D("ok %d/%d", n, len); if (!(len -= n)) return 0; } /* inbuffer exhausted -- still len todo */ i->off += i->bdo; i->len = i->bdo = 0; if (!(n = i->siz-i->off)) return 0; /* eof */ if (len > n) len = n; if (n > i->buf+HTLDISIZ-i->bdb) n = i->buf+HTLDISIZ-i->bdb; if (len < n) { /* <= HTLDISIZ <= CGIBSIZ */ if (len > end-cur && buffer(len)) return 500; if (n != read(i->ifd, i->bdb, n)) return 500; i->len = n; memcpy(cur, i->bdb, len); cur += i->bdo = len; } else do { /* read directly to outbuf */ if ((n = len) > end-cur) { int avail; buffer(n); if (0 == (avail = end-cur)) return 500; if (n > avail) n = avail; } if (n != read(i->ifd, cur, n)) return 500; cur += n; i->off += n; } while (len -= n); return 0; } /* htldcpto */ int htld (const char *path, Qry *qry, Qry *tail, int depth) { struct stat st; Qry dflt; /* defaults to append */ IBuf ib; char *soh = ib.buf, *eoh = ib.buf, *eob, *l, *eol; /* start/end of head */ int ret = 200, i; D("htld '%s'?'%.*s' %d", path, qry->str.l, qry->str.c, depth); if (0 > (ib.ifd = open(path, O_RDONLY))) return 404; if (fstat(ib.ifd, &st) || !S_ISREG(st.st_mode)) goto five00; ib.siz = st.st_size; ib.bdo = ib.off = 0; ib.bdb = ib.buf; if (0<=lmt && lmt= (ib.len = read(ib.ifd, ib.buf, HTLDISIZ))) goto five00; /* D("got %d", ib.len); */ if (3 > ib.len || '#' != ib.buf[0] || '!' != ib.buf[1] /* check for #! line */ || !(l = memchr(ib.buf, LF, ib.len)) || !memmem(ib.buf+2, l-ib.buf-2, "htld", 4) ) { #define S_ISEXE(m) ((S_IXUSR|S_IXGRP|S_IXOTH)&(m)) if (S_ISEXE(st.st_mode)) goto five00; /* never send exes */ goto headless; } soh = ++l; /* 2nd line = start of header */ eob = ib.buf + ib.len; while (eob>l && LF != *l && (l = memchr(l, LF, eob-l))) l++; if (eob <= l || !l) goto five00; /* freak out */ ib.bdb = 1+(eoh = l); /* properly terminated by blank line */ if (ib.bdb-ib.buf > HTLDISIZ/2) goto five00; /* too long */ ib.siz -= ib.bdb-ib.buf; ib.len = eob-ib.bdb; for (l = soh; LF!=*l; l=eol+1) { int cmd; unsigned off=0; char *arg; eol = memchr(l, LF, HTLDISIZ); if (3 > eol-l || HT != l[1]) continue; cmd = l[0] - '0'; arg = l+2; *eol = 0; if (HTLDVARTXT <= cmd) { /* out file up to offset */ if ('H' == *arg || 'F' == *arg) { if (depth) continue; off = 'H' == *arg++ ? 0 : ib.siz; } else { unsigned d; while (10 > (d = b36val[(unsigned char)*arg])) { off = 10*off + d; arg++; } } if (HT == *arg) arg++; if (off && htldcpto(&ib, off)) goto five00; } switch (cmd) { case HTLDHEADER: if (depth) continue; if ((i = eol-arg) > CGIHSIZ/2-hdo) goto five00; memcpy(hdb+hdo, arg, i); hdo += i; hdb[hdo++] = CR; hdb[hdo++] = LF; continue; case HTLDCTYPE: if (depth) continue; if ((ctl = eol-arg) > (int)sizeof ctb-1) goto five00; memcpy(ctb, arg, ctl); ctb[ctl] = 0; continue; case HTLDCACHE: i = eol==arg || '-'==*arg ? -1 : (signed) a2u(arg, eol-arg); if (!ttl || ttl > i) ttl = i; continue; case HTLDDEFAULTS: dflt.str.c = arg; dflt.str.l = eol-arg; dflt.nxt = 0; tail = tail->nxt = &dflt; continue; case HTLDVARTXT: case HTLDVARURL: case HTLDVARHTM: { Str par; par.c = arg; par.l = eol-arg; if (!cgigetpar(&par, qry, tail) && cgiincpar(&par, cmd)) goto five00; } continue; case HTLDINCLUDE: if (HTLDNEST == depth) goto five00; { char pbuf[0x800]; char qbuf[0x2000]; Qry sqry, *q = qry; char *eop = memchr(arg, '?', eol-arg); int pl; if (!eop) eop = eol; else { sqry.str.c = qbuf; if (0 > (sqry.str.l = urlsubs(qbuf, qbuf+sizeof qbuf, eop+1, eol, qry, tail) )) goto five00; sqry.nxt = qry; q = &sqry; } if (0 > (pl = urlsubs(pbuf, pbuf+sizeof pbuf-1, arg, eop, qry, tail) )) goto five00; pbuf[pl] = 0; htld(pbuf, q, tail, depth+1); } continue; } } headless: /* no more headers -- do rest of buffer */ if (htldcpto(&ib, ib.siz)) { five00: ret = 500; } close(ib.ifd); return ret; } /* htld */ #ifdef SCGI # define ofd 1 #else # define NCGI # define ofd !meth /* 1 iff METH_BODY (only) */ # ifdef __linux__ # include /* IPPROTO_TCP */ # include /* TCP_CORK */ # include # define SENDFILE # endif static const char http200ok[] = "HTTP/1.0 200 ok\r\n"; static const char Date[] = "Date: "; static const char Expires[] = "Expires: "; /* RFC1945 10.7: proxies */ static const char Last_Modified[] = "Last-Modified: "; static const char No_Cache[] = "Expires: Sat, 03 Mar 1973 09:46:40 GMT\r\n" /* for 1.0 proxies */ "Cache-Control: no-cache\r\n" /* RFC2616 14.9; addl for broken 1.1 proxies */ ; static const char Content_Length[] = "Content-Length: "; #ifndef KA_TIMO # define KA_TIMO 30 #endif #ifndef KA_TIMOSTR # define KA_TIMOSTR "Keep-Alive: timeout=30\r\n" #endif static const char ka[] = "\r\nConnection: Keep-Alive\r\n" KA_TIMOSTR "\r\n"; static char datbuf[DATE1123_CHARS]; static char gtfbuf[GTF_MSEC_CHARS]; #endif static char cc[] = "\r\n\r\n"; /* none: connection close */ static const char Content_Type[] = "Content-Type: "; static const char text_html[] = "text/html"; static const int si=1, no; static struct stat st; /* make a log line; return length */ /* parses sec, msec from gtf, unless sec */ /* defaults meth (from mc) and stat (from code) */ static char *append (char *c, Str *s) { if (s->c) { memcpy(c, s->c, s->l); c += s->l; } *c++ = HT; return c; } static int logline () { Str *s = parm; char *c = obf, *e = c+sizeof obf-REQ_ARGS-2/* some HT, LF and a 0 */; int i, l; long msecdiff; struct timeval tv; /* fixed part up to headers must not exceed sizeof buf */ /* print GTFM, ADDR, CONN#KALI */ c = append(c, s+REQ_GTFM); c = append(c, s+REQ_ADDR); c = append(c, s+REQ_CONN); if (kali) { c[-1] = '#'; c += u2a(c, kali); *c++ = HT; } /* compute request time msecdiff */ gettimeofday(&tv, 0); msecdiff = (tv.tv_sec - date)*1000 + tv.tv_usec/1000 - mili; if (0 <= msecdiff) c += u2a(c, (unsigned)msecdiff); /* else it's broken */ *c++ = HT; /* result stat as set or from code */ if (*status) { for (l=0; l<4 && status[l]; ) l++; } else { i = ((unsigned short)code)%1000; status[0] = '0'+i/100; u2a2(status+1,i%100); l = 3; } memcpy(c, status, l); c += l; *c++ = HT; /* result size */ c += u2a(c, size); *c++ = HT; /* log req as set or from method+param */ if (*lreq) { for (l=0; l<(int)sizeof lreq && lreq[l]; ) l++; } else { long num = 0; l = 1; switch (meth) { case METH_BODY: lreq[0] = 'B'; break; case METH_HEAD: lreq[0] = 'H'; break; case METH_GET: lreq[0] = 'G'; num = ifms; break; case METH_POST: lreq[0] = 'P'; num = cole; break; default: lreq[0] = '#'; num = meth; } if (num) l += u2a(lreq+1, num); } memcpy(c, lreq, l); c += l; *c++ = HT; /* others next to unmodified */ for (i=REQLOG; i e-c) { memcpy(c, p, e-c); c = e; break; } memcpy(c, p, l); c += l; } *c++ = HT; } *c++ = LF; *c = 0; return c-obf; } /* dirty private macros to append to char *c */ /* cat a string */ #define CAT(n, l) do { memcpy(c, n, l); c += (l); } while(0) /* cat a string constant (name) */ #define CATC(n) CAT(n, sizeof n-1) int main (int argc, char **argv) { int buffered, ret; #ifdef SENDFILE int corked = 0; #endif char abspath[4096]; Qry qry; char *path; char **e = environ; for (; *e; e++) { const Str *n; char c = **e; n = cginames+REQ_ARGS-1; do { if (c == *n->c && !memcmp(*e, n->c, n->l)) { int i = n-cginames; parm[i].l = strlen(parm[i].c = *e + n->l); goto nxt; } } while (cginames != n--); if ('H'==c && !memcmp("HTTP_", *e, 5)) { Str *dst = parm+REQ_ARGS+xtra++; dst->l = strlen(dst->c = *e); continue; } nxt: ; } if (parm[REQ_GTFM].c) gtfmsec_parse(0, &date, &mili, parm[REQ_GTFM].c); if (parm[REQ_KALI].c) kali = a2u(parm[REQ_KALI].c, -1); if (parm[REQ_IFMS].c) ifms = a2u(parm[REQ_IFMS].c, -1); if (parm[REQ_COLE].c) cole = a2u(parm[REQ_COLE].c, -1); if (!parm[REQ_PROT].c || (7 == parm[REQ_PROT].l && !memcmp("INCLUDE", parm[REQ_PROT].c, 7)) ) meth = METH_BODY; else if (parm[REQ_METH].c) { const char *c = parm[REQ_METH].c; meth = METH_OTHER; switch (*c) { case 'G': if (!memcmp(c, "GET", 4)) meth = METH_GET; break; case 'H': if (!memcmp(c, "HEAD", 5)) meth = METH_HEAD; break; case 'P': if (!memcmp(c, "POST", 5)) meth = METH_POST; break; } } if (!parm[REQ_PATH].c) parm[REQ_PATH] = parm[REQ_NAME].c ? parm[REQ_NAME] : parm[REQ_INFO]; if (1 < argc) { int l = 1+strlen(argv[1]); if (l >= (int)sizeof abspath) DIE(open); abspath[0] = '/'; /* cgihtld will skip initial char */ memcpy((parm[REQ_NAME].c = abspath)+1, argv[1], parm[REQ_NAME].l=l); } if (cole) kali = 0; /* unread POST */ err = 0; #ifdef NCGI memcpy(hdb, http200ok, hdo = sizeof http200ok-1); #endif if (!(path = parm[REQ_NAME].c) && !(path = parm[REQ_INFO].c)) ret = -1; else { path++; qry.str = parm[REQ_QRYS]; qry.nxt = 0; ret = htld(path, &qry, &qry, !meth); } if (ret < 100 || 999 < ret) { if (ret < 0) goto five00; if (ret) goto logo; goto nologo; } if (200 != (code = ret)) u2a(hdb+9, ret); st.st_size = 0; if (0 <= tfd && fstat(tfd, &st)) goto five00; buffered = cur - obf; if (!buffered && 0>tfd && 500<=ret) memcpy(obf, "sorry", buffered=5); #ifdef NCGI if (!ofd) { /* assume socket */ if (0 > tfd) setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &si, 4); # ifdef SENDFILE else { setsockopt(0, IPPROTO_TCP, TCP_NODELAY, &no, 4); /* must turn off */ setsockopt(0, IPPROTO_TCP, TCP_CORK, &si, 4); corked = 1; } # endif } #endif if (meth) { /* do headers */ char *b = hdb, *c = b+hdo; #ifdef NCGI struct tm tm; if (parm[REQ_GTFM].c) gtfmsec_parse(&tm, &date, &mili, parm[REQ_GTFM].c); else { struct timeval tv; time_t tt; if (gettimeofday(&tv, 0)) DIE(time); tt = date = tv.tv_sec; mili = tv.tv_usec/1000; gmtime_r(&tt, &tm); gtfmsec_make(parm[REQ_GTFM].c = gtfbuf, &tm, mili); parm[REQ_GTFM].l = GTF_MSEC_CHARS; } if (!parm[REQ_DATE].c) { date1123_make(parm[REQ_DATE].c = datbuf, &tm); parm[REQ_DATE].l = DATE1123_CHARS; } CATC(Date); CAT(parm[REQ_DATE].c, DATE1123_CHARS-1); *c++ = CR; *c++ = LF; if (lmt) { CATC(Last_Modified); if (0 > lmt) /* now */ memcpy(c, parm[REQ_DATE].c, DATE1123_CHARS-1); else { time_t tt = lmt; gmtime_r(&tt, &tm); date1123_make(c, &tm); } c += DATE1123_CHARS-1; *c++ = CR; *c++ = LF; } if (ttl) { if (0 > ttl) { CATC(No_Cache); } else { time_t tt = date + ttl; CATC(Expires); gmtime_r(&tt, &tm); date1123_make(c, &tm); c += DATE1123_CHARS-1; *c++ = CR; *c++ = LF; } } CATC(Content_Length); c += u2a(c, st.st_size + buffered); *c++ = CR; *c++ = LF; #endif CATC(Content_Type); if (ctl) { memcpy(c, ctb, ctl); c += ctl; } else { memcpy(c, text_html, sizeof text_html-1); c += sizeof text_html-1; } #ifdef NCGI if (err) kali=0; if (kali) CATC(ka); else #endif CATC(cc); size = c-b; D("headers '%.*s'", (int)size, hdb); if (buffered && 0>tfd) { /* most common case -- headers + in-memory body */ struct iovec iov[2]; iov[0].iov_base = b; iov[0].iov_len = size; iov[1].iov_base = obf; iov[1].iov_len = buffered; #ifdef NCGI if (!ofd) { struct msghdr mh; mh.msg_control = mh.msg_name = 0; mh.msg_controllen = mh.msg_namelen = 0; mh.msg_iov = iov; mh.msg_iovlen = 2; sendmsg(0, &mh, 0); } else #endif writev(1, iov, 2); size += buffered; buffered = 0; } else { #ifdef NCGI if (!ofd) send(0, b, size, 0); else #endif write(1, b, size); } } if (0 <= tfd) { int did; char *map; #ifdef SENDFILE off_t dummy=0; if ( ofd /* well; some can send _to_ pipes, terminals and even files */ || 0 > (did = sendfile(0, tfd, &dummy, st.st_size)) /* * kernels < about 2.4.22 (July 03) can not sendfile _from_ tmpfs * see kernel list: "tmpfs + sendfile bug?", * shmem_readpage (~2.4.22), shmem_file_sendfile (2.5.*) */ ) { # ifdef DEBUG if (!ofd) D("could not sendfile: %d", errno); /* catch 22: EINVAL */ # endif #endif map = mmap(0, st.st_size, PROT_READ, MAP_SHARED, tfd, 0); did = write(ofd, map, st.st_size); munmap(map, st.st_size); #ifdef SENDFILE } #endif D("copied %d fd %d to %d: %d", did, tfd, ofd, errno); if (0 > did) goto five00; size += did; } if (buffered) { int did = #ifdef NCGI !ofd ? send(0, obf, buffered, 0) : #endif write(1, obf, buffered); D("wrote %d to %d", did, ofd); if (0 < did) size += did; } if (0) { five00: kali = 0; code = 500; if (!(~1 & err)) err = DIE_bad; } #ifdef SENDFILE if (corked) setsockopt(0, IPPROTO_TCP, TCP_CORK, &no, 4); /* plopp */ #endif logo: #ifdef NCGI /* abuse buffer for logline */ if (meth) write(1, obf, logline()); #endif nologo: if (0 <= tfd) close(tfd); return err; } coronita-1.0.4/release0100755000076600001440000000034310402324471013525 0ustar gabiusers#!/bin/sh # ./release coronita-1.0 # make clean [ 0 -eq $# ] && exit ln -s . $1 find $1 -follow -type f | grep -v CVS | tar czvfT /tmp/$1.tar.gz - CC='diet -Os gcc' make tar czvf /tmp/$1-bin.tar.gz --exclude $1/bin/CVS $1/bin coronita-1.0.4/sslio.c0100644000076600001440000002360010273142440013455 0ustar gabiusers/* sslio for coronita -- a tiny webserver Version 1.0 Copyright (c) 2005 by Erik Grziwotz and Klaus Ripke, partner@malete.org some lines of code from matrixssl/examples Copyright (c) PeerSec Networks, 2002-2004. All Rights Reserved. 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA see README for more information for a statically linked <50KB executable on linux, use: diet -Os gcc -I/usr/local/matrixssl \ -O2 -fomit-frame-pointer -fno-strict-aliasing -s -o sslio \ sslio.c -L/usr/local/matrixssl/src -lmatrixssl where /usr/local/matrixssl is patched from matrixssl-1.2.2 according to http://malete.org/tar/matrixssl-1.2.2-diet.patch : in src/Makefile and examples/Makefile: - use CC from env (export CC='diet -Os gcc') - use SO = .a - blank out SHARED - remove -lpthread from LDFLAGS - build the $(LIBRARY): from $(OBJECTS) by ar cru $@ $^ in src/matrixConfig.h: - undef USE_CLIENT_SIDE_SSL - undef USE_MULTITHREADING (or get it patched from http://malete.org/tar/matrixssl-1.2.2-diet.tar.bz) sslio expects to inherit - a socket with SSL encrypted data on fd 0 - a socket with plaintext on fd 1 to turn a SSL socket on fd 0 into cleartext: const char *filter[] = {"./sslio", 0}; // or add args for certfile, keyfile int sp[2]; if (socketpair(PF_UNIX, SOCK_STREAM, 0, sp)) DIE(sock); if (!fork()) { // if our original socket is on int fd intead of 0: // dup2(fd, 0); close(fd); dup2(sp[0],1); close(sp[1]); execve(*filter, filter, environ); } dup2(sp[1],0); close(sp[1}); // or just use as is on sp[1] and close(fd) close(sp[0]); */ /* $Id: sslio.c,v 1.1 2005/07/31 12:33:36 krip Exp $ */ #include /* exit */ #include /* memcpy et al */ #include /* matrixssl uses stdio anyways :( */ #include #include #include #include #include #include #define CLIENT 0 /* clients ssl fd -- do not change */ #define SERVER 1 /* fd to our server -- do not change */ #define BOTH 2 /* select's n for both == 1+max(CLIENT,SERVER) */ /* server-side plaintext buffer */ static char tos[2*SSL_MAX_PLAINTEXT_LEN], froms[SSL_MAX_PLAINTEXT_LEN]; /* 16K */ /* client-side ciphertext buffer */ static char toc[SSL_MAX_BUF_SIZE], fromc[SSL_MAX_BUF_SIZE]; /* ~18K */ /* ======================= sslSocket.c ================================= */ /* * Copyright (c) PeerSec Networks, 2002-2004. All Rights Reserved. * The latest version of this code is available at http://www.matrixssl.org * * This software is open source; 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 General Public License does NOT permit incorporating this software * into proprietary programs. If you are unable to comply with the GPL, a * commercial license for this software may be purchased from PeerSec Networks * at http://www.peersec.com * * This program is distributed in 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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * http://www.gnu.org/copyleft/gpl.html */ /******************************************************************************/ static ssl_t *ssl; static sslBuf_t pb; static sslBuf_t ib; static sslBuf_t ob; #ifdef DEBUG # define D(format, args...) fprintf(stderr, format "\n" , ## args) static int toti, toto; #else # define D(format, args...) #endif static void die (int code) { printf("%d:%d", code, errno); exit(code); } #define DIE(code) die(DIE_##code) #define DIE2(code, err) do {errno = err; DIE(code);} while (0) /* 2 die 4 */ enum { /* why die? -- must keep in sync */ DIE_ok, /* do NOT change */ DIE_args, DIE_chroot, DIE_ssl, DIE_select, DIE_read, DIE_write, DIE_exec, DIE_hard }; static int sslRead (int tryread) { unsigned char error, alertLevel, alertDesc; if (ib.end == ib.start) { /* out of ciphertext */ int bytes; ib.start = ib.end = ib.buf; readMore: if (0 >= (bytes = recv(CLIENT, ib.end, ib.buf+ib.size-ib.end, 0))) DIE(read); D("recv %d bytes", bytes); ib.end += bytes; } pb.start = pb.end = pb.buf; error = alertLevel = alertDesc = 0; switch (matrixSslDecode(ssl, &ib, &pb, &error, &alertLevel, &alertDesc)) { case SSL_PROCESS_DATA: /* decoded an application data record */ return pb.end - pb.start; case SSL_SEND_RESPONSE: /* We've decoded a record that requires a response into tmp If there is no data to be flushed in the out buffer, we can write out the contents of the tmp buffer. Otherwise, we need to append the data to the outgoing data buffer and flush it out. */ D("responding %d", pb.end - pb.start); if (pb.end-pb.start != send(CLIENT, pb.start, pb.end-pb.start, 0)) DIE(write); pb.start = pb.end = pb.buf; case SSL_SUCCESS: /* record did not return data or require a response */ return 0; case SSL_PARTIAL: /* need more ciphertext */ if (ib.end-ib.start < ib.size) { if (ib.buf < ib.start) { memmove(ib.buf, ib.start, ib.end - ib.start); ib.end -= (ib.start - ib.buf); ib.start = ib.buf; } if (tryread) goto readMore; return 0; } DIE2(ssl, EINPROGRESS); /* basically a protocol error */ case SSL_ALERT: /* We've decoded an alert. The level and description passed into matrixSslDecode are filled in with the specifics. */ if (SSL_ALERT_CLOSE_NOTIFY == alertDesc) break; D("SSL: Closing on client alert %d: %d", alertLevel, alertDesc); DIE2(ssl, EPIPE); case SSL_FULL: DIE2(ssl, EMSGSIZE); default: case SSL_ERROR: /* There was an error decoding the data, or encoding the out buffer. There may be a response data in the out buffer, so try to send. We try a single hail-mary send of the data, and then close the socket. don't worry too much about a clean flush. */ D("SSL: Closing on protocol error %d", error); if (pb.start < pb.end) send(CLIENT, pb.start, pb.end - pb.start, MSG_DONTWAIT); DIE2(ssl, EBADMSG); } return -1; /* proper "EOF" */ } /* ======================= sslSocket.c ================================= */ static char *certfile = "cert.pem"; static char *privfile = "priv.pem"; static char usage[] = "usage: sslio [certfile [keyfile ]]\n" "certfile may be cert.pem;ca.pem... for ca chain\n\n"; static int len; static fd_set readable, writable; static void croak (int err) { write(2, usage, sizeof usage-1); DIE2(args, err); } int main (int argc, char **argv) { if (1 < argc) certfile = argv[1]; if (2 < argc) privfile = argv[2]; if (0 > matrixSslOpen()) DIE2(ssl, ENOSYS); { sslKeys_t *keys; if (0 > matrixSslReadKeys(&keys, certfile, privfile, 0, 0)) croak(ENOENT); if (0 > matrixSslNewSession(&ssl, keys, 0, SSL_FLAGS_SERVER)) DIE(ssl); } if (!geteuid()) { if (!chdir("ssl") && chroot(".")) DIE(chroot); if (setuid(getuid())) DIE(chroot); } ib.start = ib.end = ib.buf = fromc; ib.size = sizeof fromc; ob.size = sizeof toc; pb.start = pb.end = pb.buf = tos; pb.size = sizeof tos; /* Reading handshake records should always return 0 bytes, we aren't expecting any data yet. */ do if (sslRead(!0)) DIE(ssl); while (!matrixSslHandshakeIsComplete(ssl)); FD_ZERO(&readable); FD_ZERO(&writable); for (;;) { int tosl = 0, tosd = 0, tryread = !0, wrote; /* read from both */ D("waiting on both"); FD_SET(SERVER, &readable); FD_SET(CLIENT, &readable); if (0 >= select(BOTH, &readable, 0,0,0)) DIE(select); if (FD_ISSET(CLIENT, &readable)) { /* or closed connection ... */ decodeMore: if (0 > (tosl = sslRead(tryread))) break; D("from client: %d %d", tosl, toti += tosl); FD_CLR(CLIENT, &readable); } for (;;) { /* read/write server */ if (FD_ISSET(SERVER, &readable)) { D("server is readable"); /* as long as server is readable, we blocking copy to client */ while (0 < (len = recv(SERVER, froms, sizeof froms, MSG_DONTWAIT))) { D("from server: %d %d", len, toto += tosl); ob.start = ob.end = ob.buf = toc; len = matrixSslEncode(ssl, (unsigned char *)froms, len, &ob); if (0 >= len || len != send(CLIENT, ob.start, len, 0)) DIE(write); } D("from server done %d %d", len, errno); if (!len || EAGAIN != errno) { ob.start = ob.end = ob.buf = toc; matrixSslEncodeClosureAlert(ssl, &ob); send(CLIENT, ob.start, (ob.end - ob.start), MSG_DONTWAIT); exit(0); } } /* nothing more to read from server */ if (tosl <= tosd) break; D("writing server"); if (0 < (wrote = send(SERVER, pb.start+tosd, tosl-tosd, MSG_DONTWAIT))) { D("to server: %d", wrote); if (tosl <= (tosd += wrote)) { if (ib.start < ib.end) { /* try to decode more */ tosd = tryread = 0; /* but w/o reading from socket */ FD_CLR(SERVER, &readable); goto decodeMore; } break; /* again select on both */ } } else if (EAGAIN != errno) DIE(write); D("waiting server"); FD_SET(SERVER, &readable); FD_SET(SERVER, &writable); if (0 >= select(SERVER+1, &readable, &writable,0,0)) DIE(select); } } D("client closed conn"); exit(0); return 42; }