source: bin/varnishd/cache/cache.h @ 41a973

Revision 41a973, 28.6 KB checked in by Poul-Henning Kamp <phk@…>, 2 years ago (diff)

Remove unused cruft from the HTTP header table.

Eliminate the HTTPH_A_DELIVER filter which only took out "Date:"
because we always overwrite Date: anyway.

  • Property mode set to 100644
Line 
1/*-
2 * Copyright (c) 2006 Verdens Gang AS
3 * Copyright (c) 2006-2011 Varnish Software AS
4 * All rights reserved.
5 *
6 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 *
29 */
30
31/*
32 * This macro can be used in .h files to isolate bits that the manager
33 * should not (need to) see, such as pthread mutexes etc.
34 */
35#define VARNISH_CACHE_CHILD     1
36
37#include "common/common.h"
38
39#include "vapi/vsc_int.h"
40#include "vapi/vsl_int.h"
41
42#include <sys/socket.h>
43
44#include <pthread.h>
45#ifdef HAVE_PTHREAD_NP_H
46#include <pthread_np.h>
47#endif
48#include <stdarg.h>
49#include <string.h>
50#include <limits.h>
51#include <unistd.h>
52
53#if defined(HAVE_EPOLL_CTL)
54#include <sys/epoll.h>
55#endif
56
57
58#include "common/params.h"
59
60enum body_status {
61#define BODYSTATUS(U,l) BS_##U,
62#include "tbl/body_status.h"
63#undef BODYSTATUS
64};
65
66static inline const char *
67body_status(enum body_status e)
68{
69        switch(e) {
70#define BODYSTATUS(U,l) case BS_##U: return (#l);
71#include "tbl/body_status.h"
72#undef BODYSTATUS
73        default:
74                return ("?");
75        }
76}
77
78/*
79 * NB: HDR_STATUS is only used in cache_http.c, everybody else uses the
80 * http->status integer field.
81 */
82
83enum {
84        /* Fields from the first line of HTTP proto */
85        HTTP_HDR_REQ,
86        HTTP_HDR_URL,
87        HTTP_HDR_PROTO,
88        HTTP_HDR_STATUS,
89        HTTP_HDR_RESPONSE,
90        /* HTTP header lines */
91        HTTP_HDR_FIRST,
92};
93
94struct SHA256Context;
95struct VSC_C_lck;
96struct ban;
97struct busyobj;
98struct cli;
99struct cli_proto;
100struct director;
101struct iovec;
102struct mempool;
103struct objcore;
104struct object;
105struct objhead;
106struct pool;
107struct poolparam;
108struct sess;
109struct sesspool;
110struct vbc;
111struct vbo;
112struct vef_priv;
113struct vrt_backend;
114struct vsb;
115struct waitinglist;
116struct worker;
117
118#define DIGEST_LEN              32
119
120/*--------------------------------------------------------------------*/
121
122typedef struct {
123        char                    *b;
124        char                    *e;
125} txt;
126
127/*--------------------------------------------------------------------*/
128
129enum step {
130#define STEP(l, u, arg) STP_##u,
131#include "tbl/steps.h"
132#undef STEP
133};
134
135/*--------------------------------------------------------------------*/
136struct lock { void *priv; };    // Opaque
137
138/*--------------------------------------------------------------------
139 * Workspace structure for quick memory allocation.
140 */
141
142struct ws {
143        unsigned                magic;
144#define WS_MAGIC                0x35fac554
145        unsigned                overflow;       /* workspace overflowed */
146        const char              *id;            /* identity */
147        char                    *s;             /* (S)tart of buffer */
148        char                    *f;             /* (F)ree pointer */
149        char                    *r;             /* (R)eserved length */
150        char                    *e;             /* (E)nd of buffer */
151};
152
153/*--------------------------------------------------------------------
154 * HTTP Request/Response/Header handling structure.
155 */
156
157enum httpwhence {
158        HTTP_Rx  = 1,
159        HTTP_Tx  = 2,
160        HTTP_Obj = 3
161};
162
163/* NB: remember to update http_Copy() if you add fields */
164struct http {
165        unsigned                magic;
166#define HTTP_MAGIC              0x6428b5c9
167
168        enum httpwhence         logtag;
169
170        struct ws               *ws;
171        txt                     *hd;
172        unsigned char           *hdf;
173#define HDF_FILTER              (1 << 0)        /* Filtered by Connection */
174        uint16_t                shd;            /* Size of hd space */
175        uint16_t                nhd;            /* Next free hd */
176        uint16_t                status;
177        uint8_t                 protover;
178        uint8_t                 conds;          /* If-* headers present */
179};
180
181/*--------------------------------------------------------------------
182 * HTTP Protocol connection structure
183 */
184
185struct http_conn {
186        unsigned                magic;
187#define HTTP_CONN_MAGIC         0x3e19edd1
188
189        int                     fd;
190        unsigned                vsl_id;
191        unsigned                maxbytes;
192        unsigned                maxhdr;
193        struct ws               *ws;
194        txt                     rxbuf;
195        txt                     pipeline;
196};
197
198/*--------------------------------------------------------------------*/
199
200struct acct {
201#define ACCT(foo)       uint64_t        foo;
202#include "tbl/acct_fields.h"
203#undef ACCT
204};
205
206/*--------------------------------------------------------------------*/
207
208#define L0(t, n)
209#define L1(t, n)                t n;
210#define VSC_F(n, t, l, f, e,d)  L##l(t, n)
211struct dstat {
212#include "tbl/vsc_f_main.h"
213};
214#undef VSC_F
215#undef L0
216#undef L1
217
218/* Fetch processors --------------------------------------------------*/
219
220typedef void vfp_begin_f(struct worker *, size_t );
221typedef int vfp_bytes_f(struct worker *, struct http_conn *, ssize_t);
222typedef int vfp_end_f(struct worker *);
223
224struct vfp {
225        vfp_begin_f     *begin;
226        vfp_bytes_f     *bytes;
227        vfp_end_f       *end;
228};
229
230extern struct vfp vfp_gunzip;
231extern struct vfp vfp_gzip;
232extern struct vfp vfp_testgzip;
233extern struct vfp vfp_esi;
234
235/*--------------------------------------------------------------------*/
236
237struct exp {
238        double                  ttl;
239        double                  grace;
240        double                  keep;
241        double                  age;
242        double                  entered;
243};
244
245/*--------------------------------------------------------------------*/
246
247struct wrw {
248        int                     *wfd;
249        unsigned                werr;   /* valid after WRW_Flush() */
250        struct iovec            *iov;
251        unsigned                siov;
252        unsigned                niov;
253        ssize_t                 liov;
254        ssize_t                 cliov;
255        unsigned                ciov;   /* Chunked header marker */
256};
257
258/*--------------------------------------------------------------------*/
259
260struct stream_ctx {
261        unsigned                magic;
262#define STREAM_CTX_MAGIC        0x8213728b
263
264        struct vgz              *vgz;
265        void                    *obuf;
266        ssize_t                 obuf_len;
267        ssize_t                 obuf_ptr;
268
269        /* Next byte we will take from storage */
270        ssize_t                 stream_next;
271
272        /* First byte of storage if we free it as we go (pass) */
273        ssize_t                 stream_front;
274};
275
276/*--------------------------------------------------------------------*/
277
278struct wrk_accept {
279        unsigned                magic;
280#define WRK_ACCEPT_MAGIC        0x8c4b4d59
281
282        /* Accept stuff */
283        struct sockaddr_storage acceptaddr;
284        socklen_t               acceptaddrlen;
285        int                     acceptsock;
286        struct listen_sock      *acceptlsock;
287};
288
289/*--------------------------------------------------------------------*/
290
291enum e_do_what {
292        pool_do_inval = 0,
293        pool_do_sess,
294        pool_do_accept,
295        pool_do_nothing,
296        pool_do_die,
297};
298
299struct worker {
300        unsigned                magic;
301#define WORKER_MAGIC            0x6391adcf
302        struct pool             *pool;
303        struct objhead          *nobjhead;
304        struct objcore          *nobjcore;
305        struct waitinglist      *nwaitinglist;
306        struct vbo              *nvbo;
307        void                    *nhashpriv;
308        struct dstat            stats;
309
310        /* Pool stuff */
311        enum e_do_what          do_what;
312
313        double                  lastused;
314
315        struct wrw              wrw;
316
317        pthread_cond_t          cond;
318
319        VTAILQ_ENTRY(worker)    list;
320        struct sess             *sp;
321
322        struct VCL_conf         *vcl;
323
324        uint32_t                *wlb, *wlp, *wle;
325        unsigned                wlr;
326
327        struct ws               ws[1];
328
329        struct busyobj          *busyobj;
330
331        /* Stream state */
332        struct stream_ctx       *sctx;
333
334        /* Timeouts */
335        double                  connect_timeout;
336        double                  first_byte_timeout;
337        double                  between_bytes_timeout;
338
339        /* Delivery mode */
340        unsigned                res_mode;
341#define RES_LEN                 (1<<1)
342#define RES_EOF                 (1<<2)
343#define RES_CHUNKED             (1<<3)
344#define RES_ESI                 (1<<4)
345#define RES_ESI_CHILD           (1<<5)
346#define RES_GUNZIP              (1<<6)
347
348        /* Temporary accounting */
349        struct acct             acct_tmp;
350};
351
352/* LRU ---------------------------------------------------------------*/
353
354struct lru {
355        unsigned                magic;
356#define LRU_MAGIC               0x3fec7bb0
357        VTAILQ_HEAD(,objcore)   lru_head;
358        struct lock             mtx;
359};
360
361/* Storage -----------------------------------------------------------*/
362
363struct storage {
364        unsigned                magic;
365#define STORAGE_MAGIC           0x1a4e51c0
366
367#ifdef SENDFILE_WORKS
368        int                     fd;
369        off_t                   where;
370#endif
371
372        VTAILQ_ENTRY(storage)   list;
373        struct stevedore        *stevedore;
374        void                    *priv;
375
376        unsigned char           *ptr;
377        unsigned                len;
378        unsigned                space;
379};
380
381/* Object core structure ---------------------------------------------
382 * Objects have sideways references in the binary heap and the LRU list
383 * and we want to avoid paging in a lot of objects just to move them up
384 * or down the binheap or to move a unrelated object on the LRU list.
385 * To avoid this we use a proxy object, objcore, to hold the relevant
386 * housekeeping fields parts of an object.
387 */
388
389typedef struct object *getobj_f(struct worker *wrk, struct objcore *oc);
390typedef unsigned getxid_f(struct worker *wrk, struct objcore *oc);
391typedef void updatemeta_f(struct objcore *oc);
392typedef void freeobj_f(struct objcore *oc);
393typedef struct lru *getlru_f(const struct objcore *oc);
394
395struct objcore_methods {
396        getobj_f        *getobj;
397        getxid_f        *getxid;
398        updatemeta_f    *updatemeta;
399        freeobj_f       *freeobj;
400        getlru_f        *getlru;
401};
402
403struct objcore {
404        unsigned                magic;
405#define OBJCORE_MAGIC           0x4d301302
406        unsigned                refcnt;
407        struct objcore_methods  *methods;
408        void                    *priv;
409        unsigned                priv2;
410        struct objhead          *objhead;
411        struct busyobj          *busyobj;
412        double                  timer_when;
413        unsigned                flags;
414#define OC_F_BUSY               (1<<1)
415#define OC_F_PASS               (1<<2)
416#define OC_F_LRUDONTMOVE        (1<<4)
417#define OC_F_PRIV               (1<<5)          /* Stevedore private flag */
418#define OC_F_LURK               (3<<6)          /* Ban-lurker-color */
419        unsigned                timer_idx;
420        VTAILQ_ENTRY(objcore)   list;
421        VTAILQ_ENTRY(objcore)   lru_list;
422        VTAILQ_ENTRY(objcore)   ban_list;
423        struct ban              *ban;
424};
425
426static inline unsigned
427oc_getxid(struct worker *wrk, struct objcore *oc)
428{
429        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
430
431        AN(oc->methods);
432        AN(oc->methods->getxid);
433        return (oc->methods->getxid(wrk, oc));
434}
435
436static inline struct object *
437oc_getobj(struct worker *wrk, struct objcore *oc)
438{
439
440        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
441        AZ(oc->flags & OC_F_BUSY);
442        AN(oc->methods);
443        AN(oc->methods->getobj);
444        return (oc->methods->getobj(wrk, oc));
445}
446
447static inline void
448oc_updatemeta(struct objcore *oc)
449{
450
451        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
452        AN(oc->methods);
453        if (oc->methods->updatemeta != NULL)
454                oc->methods->updatemeta(oc);
455}
456
457static inline void
458oc_freeobj(struct objcore *oc)
459{
460
461        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
462        AN(oc->methods);
463        AN(oc->methods->freeobj);
464        oc->methods->freeobj(oc);
465}
466
467static inline struct lru *
468oc_getlru(const struct objcore *oc)
469{
470
471        CHECK_OBJ_NOTNULL(oc, OBJCORE_MAGIC);
472        AN(oc->methods);
473        AN(oc->methods->getlru);
474        return (oc->methods->getlru(oc));
475}
476
477/* Busy Object structure ---------------------------------------------
478 *
479 * The busyobj structure captures the aspects of an object related to,
480 * and while it is being fetched from the backend.
481 *
482 * One of these aspects will be how much has been fetched, which
483 * streaming delivery will make use of.
484 *
485 * XXX: many fields from worker needs to move here.
486 */
487
488struct busyobj {
489        unsigned                magic;
490#define BUSYOBJ_MAGIC           0x23b95567
491        struct vbo              *vbo;
492
493        uint8_t                 *vary;
494        unsigned                is_gzip;
495        unsigned                is_gunzip;
496
497        struct vfp              *vfp;
498        struct vep_state        *vep;
499        unsigned                fetch_failed;
500        struct vgz              *vgz_rx;
501
502        struct vbc              *vbc;
503        struct http             *bereq;
504        struct http             *beresp;
505        struct object           *fetch_obj;
506        struct exp              exp;
507        struct http_conn        htc;
508
509        enum body_status        body_status;
510        struct vef_priv         *vef_priv;
511
512        unsigned                should_close;
513        char                    *h_content_length;
514
515        unsigned                do_esi;
516        unsigned                do_gzip;
517        unsigned                do_gunzip;
518        unsigned                do_stream;
519};
520
521/* Object structure --------------------------------------------------*/
522
523VTAILQ_HEAD(storagehead, storage);
524
525struct object {
526        unsigned                magic;
527#define OBJECT_MAGIC            0x32851d42
528        unsigned                xid;
529        struct storage          *objstore;
530        struct objcore          *objcore;
531
532        struct ws               ws_o[1];
533
534        uint8_t                 *vary;
535        unsigned                hits;
536        uint16_t                response;
537
538        /* XXX: make bitmap */
539        uint8_t                 gziped;
540        /* Bit positions in the gzip stream */
541        ssize_t                 gzip_start;
542        ssize_t                 gzip_last;
543        ssize_t                 gzip_stop;
544
545        ssize_t                 len;
546
547        struct exp              exp;
548
549        double                  last_modified;
550        double                  last_lru;
551
552        struct http             *http;
553
554        struct storagehead      store;
555
556        struct storage          *esidata;
557
558        double                  last_use;
559
560};
561
562/*--------------------------------------------------------------------*/
563
564struct req {
565        unsigned                magic;
566#define REQ_MAGIC               0x2751aaa1
567
568        unsigned                xid;
569        int                     restarts;
570        int                     esi_level;
571        int                     disable_esi;
572        uint8_t                 hash_ignore_busy;
573        uint8_t                 hash_always_miss;
574
575        /* The busy objhead we sleep on */
576        struct objhead          *hash_objhead;
577
578        /* Built Vary string */
579        uint8_t                 *vary_b;
580        uint8_t                 *vary_l;
581        uint8_t                 *vary_e;
582
583        unsigned char           digest[DIGEST_LEN];
584
585        const char              *doclose;
586        struct exp              exp;
587        unsigned                cur_method;
588        unsigned                handling;
589        unsigned char           sendbody;
590        unsigned char           wantbody;
591
592        uint16_t                err_code;
593        const char              *err_reason;
594
595        struct director         *director;
596        struct VCL_conf         *vcl;
597
598        uint64_t                req_bodybytes;
599        char                    *ws_req;        /* WS above request data */
600
601        double                  t_resp;
602
603        struct http_conn        htc[1];
604        char                    *client_identity;
605
606        /* HTTP request */
607        struct http             *http;
608        struct http             *http0;
609        struct http             *resp;
610
611        struct ws               ws[1];
612        struct object           *obj;
613        struct objcore          *objcore;
614        /* Lookup stuff */
615        struct SHA256Context    *sha256ctx;
616        /* This is only here so VRT can find it */
617        const char              *storage_hint;
618
619        /* ESI delivery stuff */
620        int                     gzip_resp;
621        ssize_t                 l_crc;
622        uint32_t                crc;
623
624
625};
626
627/*--------------------------------------------------------------------
628 * Struct sess is a high memory-load structure because sessions typically
629 * hang around the waiter for relatively long time.
630 *
631 * The size goal for struct sess + struct memitem is <512 bytes
632 *
633 * Getting down to the next relevant size (<256 bytes because of how malloc
634 * works, is not realistic without a lot of code changes.
635 */
636
637struct sess {
638        unsigned                magic;
639#define SESS_MAGIC              0x2c2f9c5a
640
641        enum step               step;
642        int                     fd;
643        unsigned                vsl_id;
644
645        /* Cross references ------------------------------------------*/
646
647        struct sesspool         *sesspool;
648        struct worker           *wrk;
649        struct req              *req;
650
651        VTAILQ_ENTRY(sess)      list;
652
653        /* Session related fields ------------------------------------*/
654
655        socklen_t               sockaddrlen;
656        socklen_t               mysockaddrlen;
657        struct sockaddr_storage sockaddr;
658        struct sockaddr_storage mysockaddr;
659        struct listen_sock      *mylsock;
660
661        /* formatted ascii client address */
662        char                    addr[ADDR_BUFSIZE];
663        char                    port[PORT_BUFSIZE];
664
665        struct acct             acct_ses;
666
667        /* Timestamps, all on TIM_real() timescale */
668        double                  t_open;         /* fd accepted */
669        double                  t_idle;         /* fd accepted or resp sent */
670        double                  t_req;
671
672#if defined(HAVE_EPOLL_CTL)
673        struct epoll_event ev;
674#endif
675};
676
677/* Prototypes etc ----------------------------------------------------*/
678
679/* cache_acceptor.c */
680void VCA_Init(void);
681void VCA_Shutdown(void);
682int VCA_Accept(struct listen_sock *ls, struct wrk_accept *wa);
683void VCA_SetupSess(struct worker *w);
684void VCA_FailSess(struct worker *w);
685
686/* cache_backend.c */
687void VBE_UseHealth(const struct director *vdi);
688
689struct vbc *VDI_GetFd(const struct director *, struct sess *sp);
690int VDI_Healthy(const struct director *, const struct sess *sp);
691void VDI_CloseFd(struct worker *wrk, struct vbc **vbp);
692void VDI_RecycleFd(struct worker *wrk, struct vbc **vbp);
693void VDI_AddHostHeader(struct worker *wrk, const struct vbc *vbc);
694void VBE_Poll(void);
695void VDI_Init(void);
696
697/* cache_backend_cfg.c */
698void VBE_InitCfg(void);
699struct backend *VBE_AddBackend(struct cli *cli, const struct vrt_backend *vb);
700
701/* cache_backend_poll.c */
702void VBP_Init(void);
703
704/* cache_ban.c */
705struct ban *BAN_New(void);
706int BAN_AddTest(struct cli *, struct ban *, const char *, const char *,
707    const char *);
708void BAN_Free(struct ban *b);
709void BAN_Insert(struct ban *b);
710void BAN_Init(void);
711void BAN_NewObjCore(struct objcore *oc);
712void BAN_DestroyObj(struct objcore *oc);
713int BAN_CheckObject(struct object *o, const struct sess *sp);
714void BAN_Reload(const uint8_t *ban, unsigned len);
715struct ban *BAN_TailRef(void);
716void BAN_Compile(void);
717struct ban *BAN_RefBan(struct objcore *oc, double t0, const struct ban *tail);
718void BAN_TailDeref(struct ban **ban);
719double BAN_Time(const struct ban *ban);
720
721/* cache_busyobj.c */
722void VBO_Init(void);
723struct busyobj *VBO_GetBusyObj(struct worker *wrk);
724void VBO_RefBusyObj(const struct busyobj *busyobj);
725void VBO_DerefBusyObj(struct worker *wrk, struct busyobj **busyobj);
726void VBO_Free(struct vbo **vbo);
727
728/* cache_center.c [CNT] */
729void CNT_Session(struct sess *sp);
730void CNT_Init(void);
731
732/* cache_cli.c [CLI] */
733void CLI_Init(void);
734void CLI_Run(void);
735void CLI_AddFuncs(struct cli_proto *p);
736extern pthread_t cli_thread;
737#define ASSERT_CLI() do {assert(pthread_self() == cli_thread);} while (0)
738
739/* cache_expiry.c */
740void EXP_Clr(struct exp *e);
741double EXP_Get_ttl(const struct exp *e);
742double EXP_Get_grace(const struct exp *e);
743double EXP_Get_keep(const struct exp *e);
744void EXP_Set_ttl(struct exp *e, double v);
745void EXP_Set_grace(struct exp *e, double v);
746void EXP_Set_keep(struct exp *e, double v);
747
748double EXP_Ttl(const struct sess *, const struct object*);
749double EXP_Grace(const struct sess *, const struct object*);
750void EXP_Insert(struct object *o);
751void EXP_Inject(struct objcore *oc, struct lru *lru, double when);
752void EXP_Init(void);
753void EXP_Rearm(const struct object *o);
754int EXP_Touch(struct objcore *oc);
755int EXP_NukeOne(struct worker *w, struct lru *lru);
756
757/* cache_fetch.c */
758struct storage *FetchStorage(struct worker *w, ssize_t sz);
759int FetchError(struct worker *w, const char *error);
760int FetchError2(struct worker *w, const char *error, const char *more);
761int FetchHdr(struct sess *sp, int need_host_hdr);
762int FetchBody(struct worker *w, struct object *obj);
763int FetchReqBody(const struct sess *sp);
764void Fetch_Init(void);
765
766/* cache_gzip.c */
767struct vgz;
768
769enum vgz_flag { VGZ_NORMAL, VGZ_ALIGN, VGZ_RESET, VGZ_FINISH };
770struct vgz *VGZ_NewUngzip(struct worker *wrk, const char *id);
771struct vgz *VGZ_NewGzip(struct worker *wrk, const char *id);
772void VGZ_Ibuf(struct vgz *, const void *, ssize_t len);
773int VGZ_IbufEmpty(const struct vgz *vg);
774void VGZ_Obuf(struct vgz *, void *, ssize_t len);
775int VGZ_ObufFull(const struct vgz *vg);
776int VGZ_ObufStorage(struct worker *w, struct vgz *vg);
777int VGZ_Gzip(struct vgz *, const void **, size_t *len, enum vgz_flag);
778int VGZ_Gunzip(struct vgz *, const void **, size_t *len);
779int VGZ_Destroy(struct vgz **, int vsl_id);
780void VGZ_UpdateObj(const struct vgz*, struct object *);
781int VGZ_WrwGunzip(struct worker *w, struct vgz *, const void *ibuf,
782    ssize_t ibufl, char *obuf, ssize_t obufl, ssize_t *obufp);
783
784/* Return values */
785#define VGZ_ERROR       -1
786#define VGZ_OK          0
787#define VGZ_END         1
788#define VGZ_STUCK       2
789
790/* cache_http.c */
791unsigned HTTP_estimate(unsigned nhttp);
792void HTTP_Copy(struct http *to, const struct http * const fm);
793struct http *HTTP_create(void *p, uint16_t nhttp);
794const char *http_StatusMessage(unsigned);
795unsigned http_EstimateWS(const struct http *fm, unsigned how, uint16_t *nhd);
796void HTTP_Init(void);
797void http_ClrHeader(struct http *to);
798unsigned http_Write(struct worker *w, unsigned vsl_id, const struct http *hp,
799    int resp);
800void http_CopyResp(struct http *to, const struct http *fm);
801void http_SetResp(struct http *to, const char *proto, uint16_t status,
802    const char *response);
803void http_FilterFields(struct worker *w, unsigned vsl_id, struct http *to,
804    const struct http *fm, unsigned how);
805void http_FilterHeader(const struct sess *sp, unsigned how);
806void http_PutProtocol(struct worker *w, unsigned vsl_id, const struct http *to,
807    const char *protocol);
808void http_PutStatus(struct http *to, uint16_t status);
809void http_PutResponse(struct worker *w, unsigned vsl_id, const struct http *to,
810    const char *response);
811void http_PrintfHeader(struct worker *w, unsigned vsl_id, struct http *to,
812    const char *fmt, ...)
813    __printflike(4, 5);
814void http_SetHeader(struct worker *w, unsigned vsl_id, struct http *to,
815    const char *hdr);
816void http_SetH(const struct http *to, unsigned n, const char *fm);
817void http_ForceGet(const struct http *to);
818void http_Setup(struct http *ht, struct ws *ws);
819int http_GetHdr(const struct http *hp, const char *hdr, char **ptr);
820int http_GetHdrData(const struct http *hp, const char *hdr,
821    const char *field, char **ptr);
822int http_GetHdrField(const struct http *hp, const char *hdr,
823    const char *field, char **ptr);
824double http_GetHdrQ(const struct http *hp, const char *hdr, const char *field);
825uint16_t http_GetStatus(const struct http *hp);
826const char *http_GetReq(const struct http *hp);
827int http_HdrIs(const struct http *hp, const char *hdr, const char *val);
828uint16_t http_DissectRequest(const struct sess *sp);
829uint16_t http_DissectResponse(struct worker *w, const struct http_conn *htc,
830    struct http *sp);
831const char *http_DoConnection(const struct http *hp);
832void http_CopyHome(struct worker *w, unsigned vsl_id, const struct http *hp);
833void http_Unset(struct http *hp, const char *hdr);
834void http_CollectHdr(struct http *hp, const char *hdr);
835
836/* cache_httpconn.c */
837void HTC_Init(struct http_conn *htc, struct ws *ws, int fd, unsigned vsl_id,
838    unsigned maxbytes, unsigned maxhdr);
839int HTC_Reinit(struct http_conn *htc);
840int HTC_Rx(struct http_conn *htc);
841ssize_t HTC_Read(struct worker *w, struct http_conn *htc, void *d, size_t len);
842int HTC_Complete(struct http_conn *htc);
843
844#define HTTPH(a, b, c) extern char b[];
845#include "tbl/http_headers.h"
846#undef HTTPH
847
848/* cache_main.c */
849extern volatile struct params * cache_param;
850void THR_SetName(const char *name);
851const char* THR_GetName(void);
852void THR_SetSession(const struct sess *sp);
853const struct sess * THR_GetSession(void);
854
855/* cache_lck.c */
856
857/* Internal functions, call only through macros below */
858void Lck__Lock(struct lock *lck, const char *p, const char *f, int l);
859void Lck__Unlock(struct lock *lck, const char *p, const char *f, int l);
860int Lck__Trylock(struct lock *lck, const char *p, const char *f, int l);
861void Lck__New(struct lock *lck, struct VSC_C_lck *, const char *);
862void Lck__Assert(const struct lock *lck, int held);
863
864/* public interface: */
865void LCK_Init(void);
866void Lck_Delete(struct lock *lck);
867int Lck_CondWait(pthread_cond_t *cond, struct lock *lck, struct timespec *ts);
868
869#define Lck_New(a, b) Lck__New(a, b, #b)
870#define Lck_Lock(a) Lck__Lock(a, __func__, __FILE__, __LINE__)
871#define Lck_Unlock(a) Lck__Unlock(a, __func__, __FILE__, __LINE__)
872#define Lck_Trylock(a) Lck__Trylock(a, __func__, __FILE__, __LINE__)
873#define Lck_AssertHeld(a) Lck__Assert(a, 1)
874
875#define LOCK(nam) extern struct VSC_C_lck *lck_##nam;
876#include "tbl/locks.h"
877#undef LOCK
878
879/* cache_mempool.c */
880void MPL_AssertSane(void *item);
881struct mempool * MPL_New(const char *name, volatile struct poolparam *pp,
882    volatile unsigned *cur_size);
883void MPL_Destroy(struct mempool **mpp);
884void *MPL_Get(struct mempool *mpl, unsigned *size);
885void MPL_Free(struct mempool *mpl, void *item);
886
887
888/* cache_panic.c */
889void PAN_Init(void);
890
891/* cache_pipe.c */
892void PipeSession(struct sess *sp);
893
894/* cache_pool.c */
895void Pool_Init(void);
896void Pool_Work_Thread(void *priv, struct worker *w);
897int Pool_Schedule(struct pool *pp, struct sess *sp);
898
899#define WRW_IsReleased(w)       ((w)->wrw.wfd == NULL)
900int WRW_Error(const struct worker *w);
901void WRW_Chunked(struct worker *w);
902void WRW_EndChunk(struct worker *w);
903void WRW_Reserve(struct worker *w, int *fd);
904unsigned WRW_Flush(struct worker *w);
905unsigned WRW_FlushRelease(struct worker *w);
906unsigned WRW_Write(struct worker *w, const void *ptr, int len);
907unsigned WRW_WriteH(struct worker *w, const txt *hh, const char *suf);
908#ifdef SENDFILE_WORKS
909void WRW_Sendfile(struct worker *w, int fd, off_t off, unsigned len);
910#endif  /* SENDFILE_WORKS */
911
912/* cache_session.c [SES] */
913struct sess *SES_New(struct sesspool *pp);
914struct sess *SES_Alloc(void);
915void SES_Close(struct sess *sp, const char *reason);
916void SES_Delete(struct sess *sp, const char *reason, double now);
917void SES_Charge(struct sess *sp);
918struct sesspool *SES_NewPool(struct pool *pp, unsigned pool_no);
919void SES_DeletePool(struct sesspool *sp);
920int SES_Schedule(struct sess *sp);
921void SES_Handle(struct sess *sp, double now);
922void SES_GetReq(struct sess *sp);
923void SES_ReleaseReq(struct sess *sp);
924
925/* cache_shmlog.c */
926extern struct VSC_C_main *VSC_C_main;
927void VSM_Init(void);
928void *VSM_Alloc(unsigned size, const char *class, const char *type,
929    const char *ident);
930void VSM_Free(void *ptr);
931#ifdef VSL_ENDMARKER
932void VSL(enum VSL_tag_e tag, int id, const char *fmt, ...)
933    __printflike(3, 4);
934void WSLR(struct worker *w, enum VSL_tag_e tag, int id, txt t);
935void WSL(struct worker *w, enum VSL_tag_e tag, int id, const char *fmt, ...)
936    __printflike(4, 5);
937void WSLB(struct worker *w, enum VSL_tag_e tag, const char *fmt, ...)
938    __printflike(3, 4);
939
940void WSL_Flush(struct worker *w, int overflow);
941
942#define DSL(flag, tag, id, ...)                                 \
943        do {                                                    \
944                if (cache_param->diag_bitmap & (flag))          \
945                        VSL((tag), (id), __VA_ARGS__);          \
946        } while (0)
947
948#define WSP(sess, tag, ...)                                     \
949        WSL((sess)->wrk, tag, (sess)->vsl_id, __VA_ARGS__)
950
951#define WSPR(sess, tag, txt)                                    \
952        WSLR((sess)->wrk, tag, (sess)->vsl_id, txt)
953
954#define INCOMPL() do {                                                  \
955        VSL(SLT_Debug, 0, "INCOMPLETE AT: %s(%d)", __func__, __LINE__); \
956        fprintf(stderr,                                                 \
957            "INCOMPLETE AT: %s(%d)\n",                                  \
958            (const char *)__func__, __LINE__);                          \
959        abort();                                                        \
960        } while (0)
961#endif
962
963/* cache_response.c */
964void RES_BuildHttp(const struct sess *sp);
965void RES_WriteObj(struct sess *sp);
966void RES_StreamStart(struct sess *sp);
967void RES_StreamEnd(struct sess *sp);
968void RES_StreamPoll(struct worker *);
969
970/* cache_vary.c */
971struct vsb *VRY_Create(const struct sess *sp, const struct http *hp);
972int VRY_Match(const struct sess *sp, const uint8_t *vary);
973void VRY_Validate(const uint8_t *vary);
974
975/* cache_vcl.c */
976void VCL_Init(void);
977void VCL_Refresh(struct VCL_conf **vcc);
978void VCL_Rel(struct VCL_conf **vcc);
979void VCL_Poll(void);
980const char *VCL_Return_Name(unsigned method);
981
982#define VCL_MET_MAC(l,u,b) void VCL_##l##_method(struct sess *);
983#include "tbl/vcl_returns.h"
984#undef VCL_MET_MAC
985
986/* cache_vrt.c */
987
988char *VRT_String(struct ws *ws, const char *h, const char *p, va_list ap);
989char *VRT_StringList(char *d, unsigned dl, const char *p, va_list ap);
990
991void ESI_Deliver(struct sess *);
992void ESI_DeliverChild(const struct sess *);
993
994/* cache_vrt_vmod.c */
995void VMOD_Init(void);
996
997/* cache_waiter.c */
998void WAIT_Enter(struct sess *sp);
999void WAIT_Init(void);
1000const char *WAIT_GetName(void);
1001
1002/* cache_wrk.c */
1003
1004void WRK_Init(void);
1005int WRK_TrySumStat(struct worker *w);
1006void WRK_SumStat(struct worker *w);
1007void *WRK_thread(void *priv);
1008typedef void *bgthread_t(struct sess *, void *priv);
1009void WRK_BgThread(pthread_t *thr, const char *name, bgthread_t *func,
1010    void *priv);
1011
1012/* cache_ws.c */
1013
1014void WS_Init(struct ws *ws, const char *id, void *space, unsigned len);
1015unsigned WS_Reserve(struct ws *ws, unsigned bytes);
1016void WS_Release(struct ws *ws, unsigned bytes);
1017void WS_ReleaseP(struct ws *ws, char *ptr);
1018void WS_Assert(const struct ws *ws);
1019void WS_Reset(struct ws *ws, char *p);
1020char *WS_Alloc(struct ws *ws, unsigned bytes);
1021char *WS_Snapshot(struct ws *ws);
1022unsigned WS_Free(const struct ws *ws);
1023
1024/* rfc2616.c */
1025void RFC2616_Ttl(const struct sess *sp);
1026enum body_status RFC2616_Body(const struct sess *sp);
1027unsigned RFC2616_Req_Gzip(const struct sess *sp);
1028int RFC2616_Do_Cond(const struct sess *sp);
1029
1030/* stevedore.c */
1031struct object *STV_NewObject(struct worker *wrk, const char *hint, unsigned len,
1032    uint16_t nhttp);
1033struct storage *STV_alloc(struct worker *w, size_t size);
1034void STV_trim(struct storage *st, size_t size);
1035void STV_free(struct storage *st);
1036void STV_open(void);
1037void STV_close(void);
1038void STV_Freestore(struct object *o);
1039
1040/* storage_synth.c */
1041struct vsb *SMS_Makesynth(struct object *obj);
1042void SMS_Finish(struct object *obj);
1043void SMS_Init(void);
1044
1045/* storage_persistent.c */
1046void SMP_Init(void);
1047void SMP_Ready(void);
1048void SMP_NewBan(const uint8_t *ban, unsigned len);
1049
1050/*
1051 * A normal pointer difference is signed, but we never want a negative value
1052 * so this little tool will make sure we don't get that.
1053 */
1054
1055static inline unsigned
1056pdiff(const void *b, const void *e)
1057{
1058
1059        assert(b <= e);
1060        return
1061            ((unsigned)((const unsigned char *)e - (const unsigned char *)b));
1062}
1063
1064static inline void
1065Tcheck(const txt t)
1066{
1067
1068        AN(t.b);
1069        AN(t.e);
1070        assert(t.b <= t.e);
1071}
1072
1073/*
1074 * unsigned length of a txt
1075 */
1076
1077static inline unsigned
1078Tlen(const txt t)
1079{
1080
1081        Tcheck(t);
1082        return ((unsigned)(t.e - t.b));
1083}
1084
1085static inline void
1086Tadd(txt *t, const char *p, int l)
1087{
1088        Tcheck(*t);
1089
1090        if (l <= 0) {
1091        } if (t->b + l < t->e) {
1092                memcpy(t->b, p, l);
1093                t->b += l;
1094        } else {
1095                t->b = t->e;
1096        }
1097}
1098
1099static inline void
1100AssertObjBusy(const struct object *o)
1101{
1102        AN(o->objcore);
1103        AN (o->objcore->flags & OC_F_BUSY);
1104        AN(o->objcore->busyobj);
1105}
1106
1107static inline void
1108AssertObjCorePassOrBusy(const struct objcore *oc)
1109{
1110        if (oc != NULL)
1111                AN (oc->flags & OC_F_BUSY);
1112}
1113
1114/*
1115 * We want to cache the most recent timestamp in wrk->lastused to avoid
1116 * extra timestamps in cache_pool.c.  Hide this detail with a macro
1117 */
1118#define W_TIM_real(w) ((w)->lastused = VTIM_real())
Note: See TracBrowser for help on using the repository browser.