URI: 
       thttpd.h - plan9port - [fork] Plan 9 from user space
  HTML git clone git://src.adamsgaard.dk/plan9port
   DIR Log
   DIR Files
   DIR Refs
   DIR README
   DIR LICENSE
       ---
       thttpd.h (5971B)
       ---
            1 #ifndef _HTTPD_H_
            2 #define _HTTPD_H_ 1
            3 #if defined(__cplusplus)
            4 extern "C" { 
            5 #endif
            6 
            7 AUTOLIB(httpd)
            8 /*
            9 #pragma        lib        "libhttpd.a"
           10 #pragma        src        "/sys/src/libhttpd"
           11 */
           12 
           13 typedef struct HConnect                HConnect;
           14 typedef struct HContent                HContent;
           15 typedef struct HContents        HContents;
           16 typedef struct HETag                HETag;
           17 typedef struct HFields                HFields;
           18 typedef struct Hio                Hio;
           19 typedef struct Htmlesc                Htmlesc;
           20 typedef struct HttpHead                HttpHead;
           21 typedef struct HttpReq                HttpReq;
           22 typedef struct HRange                HRange;
           23 typedef struct HSPairs                HSPairs;
           24 
           25 #ifndef _HAVE_BIN
           26 typedef struct Bin                Bin;
           27 #define _HAVE_BIN
           28 #endif
           29 
           30 enum
           31 {
           32         HMaxWord        = 32*1024,
           33         HBufSize        = 32*1024,
           34 
           35         /*
           36          * error messages
           37          */
           38         HInternal        = 0,
           39         HTempFail,
           40         HUnimp,
           41         HBadReq,
           42         HBadSearch,
           43         HNotFound,
           44         HUnauth,
           45         HSyntax,
           46         HNoSearch,
           47         HNoData,
           48         HExpectFail,
           49         HUnkVers,
           50         HBadCont,
           51         HOK
           52 };
           53 
           54 /*
           55  * table of html character escape codes
           56  */
           57 struct Htmlesc
           58 {
           59         char                *name;
           60         Rune                value;
           61 };
           62 
           63 struct HContent
           64 {
           65         HContent        *next;
           66         char                *generic;
           67         char                *specific;
           68         float                q;                        /* desirability of this kind of file */
           69         int                mxb;                        /* max uchars until worthless */
           70 };
           71 
           72 struct HContents
           73 {
           74         HContent        *type;
           75         HContent         *encoding;
           76 };
           77 
           78 /*
           79  * generic http header with a list of tokens,
           80  * each with an optional list of parameters
           81  */
           82 struct HFields
           83 {
           84         char                *s;
           85         HSPairs                *params;
           86         HFields                *next;
           87 };
           88 
           89 /*
           90  * list of pairs a strings
           91  * used for tag=val pairs for a search or form submission,
           92  * and attribute=value pairs in headers.
           93  */
           94 struct HSPairs
           95 {
           96         char                *s;
           97         char                *t;
           98         HSPairs                *next;
           99 };
          100 
          101 /*
          102  * byte ranges within a file
          103  */
          104 struct HRange
          105 {
          106         int                suffix;                        /* is this a suffix request? */
          107         ulong                start;
          108         ulong                stop;                        /* ~0UL -> not given */
          109         HRange                *next;
          110 };
          111 
          112 /*
          113  * list of http/1.1 entity tags
          114  */
          115 struct HETag
          116 {
          117         char                *etag;
          118         int                weak;
          119         HETag                *next;
          120 };
          121 
          122 /*
          123  * HTTP custom IO
          124  * supports chunked transfer encoding
          125  * and initialization of the input buffer from a string.
          126  */
          127 enum
          128 {
          129         Hnone,
          130         Hread,
          131         Hend,
          132         Hwrite,
          133         Herr,
          134 
          135         Hsize = HBufSize
          136 };
          137 
          138 struct Hio {
          139         Hio                *hh;                        /* next lower layer Hio, or nil if reads from fd */
          140         int                fd;                        /* associated file descriptor */
          141         ulong                seek;                        /* of start */
          142         uchar                state;                        /* state of the file */
          143         uchar                xferenc;                /* chunked transfer encoding state */
          144         uchar                *pos;                        /* current position in the buffer */
          145         uchar                *stop;                        /* last character active in the buffer */
          146         uchar                *start;                        /* start of data buffer */
          147         ulong                bodylen;                /* remaining length of message body */
          148         uchar                buf[Hsize+32];
          149 };
          150 
          151 /*
          152  * request line
          153  */
          154 struct HttpReq
          155 {
          156         char                *meth;
          157         char                *uri;
          158         char                *urihost;
          159         char                *search;
          160         int                vermaj;
          161         int                vermin;
          162         HSPairs        *searchpairs;
          163 };
          164 
          165 /*
          166  * header lines
          167  */
          168 struct HttpHead
          169 {
          170         int                closeit;                /* http1.1 close connection after this request? */
          171         uchar                persist;                /* http/1.1 requests a persistent connection */
          172 
          173         uchar                expectcont;                /* expect a 100-continue */
          174         uchar                expectother;                /* expect anything else; should reject with ExpectFail */
          175         ulong                contlen;                /* if != ~0UL, length of included message body */
          176         HFields                *transenc;                /* if present, encoding of included message body */
          177         char                *client;
          178         char                *host;
          179         HContent        *okencode;
          180         HContent        *oklang;
          181         HContent        *oktype;
          182         HContent        *okchar;
          183         ulong                ifmodsince;
          184         ulong                ifunmodsince;
          185         ulong                ifrangedate;
          186         HETag                *ifmatch;
          187         HETag                *ifnomatch;
          188         HETag                *ifrangeetag;
          189         HRange                *range;
          190         char                *authuser;                /* authorization info */
          191         char                *authpass;
          192 
          193         /*
          194          * experimental headers
          195          */
          196         int                fresh_thresh;
          197         int                fresh_have;
          198 };
          199 
          200 /*
          201  * all of the state for a particular connection
          202  */
          203 struct HConnect
          204 {
          205         void                *private;                /* for the library clients */
          206         void                (*replog)(HConnect*, char*, ...);        /* called when reply sent */
          207 
          208         HttpReq                req;
          209         HttpHead        head;
          210 
          211         Bin                *bin;
          212 
          213         ulong                reqtime;                /* time at start of request */
          214         char                xferbuf[HBufSize];        /* buffer for making up or transferring data */
          215         uchar                header[HBufSize + 2];        /* room for \n\0 */
          216         uchar                *hpos;
          217         uchar                *hstop;
          218         Hio                hin;
          219         Hio                hout;
          220 };
          221 
          222 /*
          223  * configuration for all connections within the server
          224  */
          225 extern        char*                hmydomain;
          226 extern        char*                hversion;
          227 extern        Htmlesc                htmlesc[];
          228 
          229 /*
          230  * .+2,/^$/ | sort -bd +1
          231  */
          232 void                        *halloc(HConnect *c, ulong size);
          233 Hio                        *hbodypush(Hio *hh, ulong len, HFields *te);
          234 int                        hbuflen(Hio *h, void *p);
          235 int                        hcheckcontent(HContent*, HContent*, char*, int);
          236 void                        hclose(Hio*);
          237 ulong                        hdate2sec(char*);
          238 int                        hdatefmt(Fmt*);
          239 int                        hfail(HConnect*, int, ...);
          240 int                        hflush(Hio*);
          241 int                        hlflush(Hio*);
          242 int                        hgetc(Hio*);
          243 int                        hgethead(HConnect *c, int many);
          244 int                        hinit(Hio*, int, int);
          245 int                        hiserror(Hio *h);
          246 int                        hload(Hio*, char*);
          247 char                        *hlower(char*);
          248 HContent                *hmkcontent(HConnect *c, char *generic, char *specific, HContent *next);
          249 HFields                        *hmkhfields(HConnect *c, char *s, HSPairs *p, HFields *next);
          250 char                        *hmkmimeboundary(HConnect *c);
          251 HSPairs                        *hmkspairs(HConnect *c, char *s, char *t, HSPairs *next);
          252 int                        hmoved(HConnect *c, char *uri);
          253 void                        hokheaders(HConnect *c);
          254 int                        hparseheaders(HConnect*, int timeout);
          255 HSPairs                        *hparsequery(HConnect *c, char *search);
          256 int                        hparsereq(HConnect *c, int timeout);
          257 int                        hprint(Hio*, char*, ...);
          258 int                        hputc(Hio*, int);
          259 void                        *hreadbuf(Hio *h, void *vsave);
          260 int                        hredirected(HConnect *c, char *how, char *uri);
          261 void                        hreqcleanup(HConnect *c);
          262 HFields                        *hrevhfields(HFields *hf);
          263 HSPairs                        *hrevspairs(HSPairs *sp);
          264 char                        *hstrdup(HConnect *c, char *s);
          265 int                        http11(HConnect*);
          266 int                        httpfmt(Fmt*);
          267 char                        *httpunesc(HConnect *c, char *s);
          268 int                        hunallowed(HConnect *, char *allowed);
          269 int                        hungetc(Hio *h);
          270 char                        *hunload(Hio*);
          271 int                        hurlfmt(Fmt*);
          272 char                        *hurlunesc(HConnect *c, char *s);
          273 int                        hwrite(Hio*, void*, int);
          274 int                        hxferenc(Hio*, int);
          275 
          276 /*
          277 #pragma                        varargck        argpos        hprint        2
          278 */
          279 /*
          280  * D is httpd format date conversion
          281  * U is url escape convertsion
          282  * H is html escape conversion
          283  */
          284 /*
          285 #pragma        varargck        type        "D"        long
          286 #pragma        varargck        type        "D"        ulong
          287 #pragma        varargck        type        "U"        char*
          288 #pragma        varargck        type        "H"        char*
          289 */
          290 
          291 #if defined(__cplusplus)
          292 }
          293 #endif
          294 #endif