source: bin/varnishd/cache.h @ 073d2b

Revision 073d2b, 20.6 KB checked in by Poul-Henning Kamp <phk@…>, 3 years ago (diff)

o->smp_index is no longer needed, we have it in oc->priv2.

git-svn-id:  http://www.varnish-cache.org/svn/trunk/varnish-cache@5572 d4fa192b-c00b-0410-8231-f00ffab90ce4

  • Property mode set to 100644
Line 
1/*-
2 * Copyright (c) 2006 Verdens Gang AS
3 * Copyright (c) 2006-2010 Redpill Linpro 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 * $Id$
30 */
31
32/*
33 * This macro can be used in .h files to isolate bits that the manager
34 * should not (need to) see, such as pthread mutexes etc.
35 */
36#define VARNISH_CACHE_CHILD     1
37
38#include <sys/time.h>
39#include <sys/uio.h>
40#include <sys/socket.h>
41
42#include <pthread.h>
43#ifdef HAVE_PTHREAD_NP_H
44#include <pthread_np.h>
45#endif
46#include <stdarg.h>
47#include <stdint.h>
48#include <string.h>
49#include <limits.h>
50#include <unistd.h>
51
52#if defined(HAVE_EPOLL_CTL)
53#include <sys/epoll.h>
54#endif
55
56#include "vqueue.h"
57
58#include "vsb.h"
59
60#include "libvarnish.h"
61
62#include "common.h"
63#include "heritage.h"
64#include "miniobj.h"
65
66#include "vsc.h"
67#include "vsl.h"
68#include "vtypes.h"
69
70/*
71 * NB: HDR_STATUS is only used in cache_http.c, everybody else uses the
72 * http->status integer field.
73 */
74
75enum {
76        /* Fields from the first line of HTTP proto */
77        HTTP_HDR_REQ,
78        HTTP_HDR_URL,
79        HTTP_HDR_PROTO,
80        HTTP_HDR_STATUS,
81        HTTP_HDR_RESPONSE,
82        /* HTTP header lines */
83        HTTP_HDR_FIRST,
84};
85
86struct cli;
87struct vsb;
88struct sess;
89struct director;
90struct object;
91struct objhead;
92struct objcore;
93struct workreq;
94struct esidata;
95struct vrt_backend;
96struct cli_proto;
97struct ban;
98struct SHA256Context;
99struct vsc_lck;
100
101struct lock { void *priv; };            // Opaque
102
103#define DIGEST_LEN              32
104
105
106/*--------------------------------------------------------------------
107 * Pointer aligment magic
108 */
109
110#define PALGN           (sizeof(void *) - 1)
111#define PAOK(p)         (((uintptr_t)(p) & PALGN) == 0)
112#define PRNDDN(p)       ((uintptr_t)(p) & ~PALGN)
113#define PRNDUP(p)       (((uintptr_t)(p) + PALGN) & ~PALGN)
114
115/*--------------------------------------------------------------------*/
116
117typedef struct {
118        char                    *b;
119        char                    *e;
120} txt;
121
122/*--------------------------------------------------------------------*/
123
124enum step {
125#define STEP(l, u)      STP_##u,
126#include "steps.h"
127#undef STEP
128};
129
130/*--------------------------------------------------------------------
131 * Workspace structure for quick memory allocation.
132 */
133
134struct ws {
135        unsigned                magic;
136#define WS_MAGIC                0x35fac554
137        const char              *id;            /* identity */
138        char                    *s;             /* (S)tart of buffer */
139        char                    *f;             /* (F)ree pointer */
140        char                    *r;             /* (R)eserved length */
141        char                    *e;             /* (E)nd of buffer */
142        int                     overflow;       /* workspace overflowed */
143};
144
145/*--------------------------------------------------------------------
146 * HTTP Request/Response/Header handling structure.
147 */
148
149enum httpwhence {
150        HTTP_Rx  = 1,
151        HTTP_Tx  = 2,
152        HTTP_Obj = 3
153};
154
155/* NB: remember to update http_Copy() if you add fields */
156struct http {
157        unsigned                magic;
158#define HTTP_MAGIC              0x6428b5c9
159
160        struct ws               *ws;
161
162        unsigned char           conds;          /* If-* headers present */
163        enum httpwhence         logtag;
164        int                     status;
165        double                  protover;
166
167        unsigned                shd;            /* Size of hd space */
168        txt                     *hd;
169        unsigned char           *hdf;
170#define HDF_FILTER              (1 << 0)        /* Filtered by Connection */
171#define HDF_COPY                (1 << 1)        /* Copy this field */
172        unsigned                nhd;            /* Next free hd */
173};
174
175/*--------------------------------------------------------------------
176 * HTTP Protocol connection structure
177 */
178
179struct http_conn {
180        unsigned                magic;
181#define HTTP_CONN_MAGIC         0x3e19edd1
182
183        int                     fd;
184        struct ws               *ws;
185        txt                     rxbuf;
186        txt                     pipeline;
187};
188
189/*--------------------------------------------------------------------*/
190
191struct acct {
192        double                  first;
193#define ACCT(foo)       uint64_t        foo;
194#include "acct_fields.h"
195#undef ACCT
196};
197
198/*--------------------------------------------------------------------*/
199
200#define L0(n)
201#define L1(n)                   int n;
202#define VSC_F(n, t, l, f, e)    L##l(n)
203#define VSC_DO_MAIN
204struct dstat {
205#include "vsc_fields.h"
206};
207#undef VSC_F
208#undef VSC_DO_MAIN
209#undef L0
210#undef L1
211
212/*--------------------------------------------------------------------*/
213
214struct worker {
215        unsigned                magic;
216#define WORKER_MAGIC            0x6391adcf
217        struct objhead          *nobjhead;
218        struct objcore          *nobjcore;
219        void                    *nhashpriv;
220        struct dstat            stats;
221
222        double                  lastused;
223
224        pthread_cond_t          cond;
225
226        VTAILQ_ENTRY(worker)    list;
227        struct workreq          *wrq;
228
229        int                     *wfd;
230        unsigned                werr;   /* valid after WRK_Flush() */
231        struct iovec            *iov;
232        unsigned                siov;
233        unsigned                niov;
234        ssize_t                 liov;
235
236        struct VCL_conf         *vcl;
237
238        uint32_t                *wlb, *wlp, *wle;
239        unsigned                wlr;
240
241        struct SHA256Context    *sha256ctx;
242
243        struct http_conn        htc[1];
244        struct ws               ws[1];
245        struct http             *http[3];
246        struct http             *bereq;
247        struct http             *beresp1;
248        struct http             *beresp;
249        struct http             *resp;
250
251        enum body_status        body_status;
252        unsigned                cacheable;
253        double                  age;
254        double                  entered;
255        double                  ttl;
256        double                  grace;
257        unsigned                do_esi;
258
259        /* Timeouts */
260        double                  connect_timeout;
261        double                  first_byte_timeout;
262        double                  between_bytes_timeout;
263
264};
265
266/* Work Request for worker thread ------------------------------------*/
267
268/*
269 * This is a worker-function.
270 * XXX: typesafety is probably not worth fighting for
271 */
272
273typedef void workfunc(struct worker *, void *priv);
274
275struct workreq {
276        VTAILQ_ENTRY(workreq)   list;
277        workfunc                *func;
278        void                    *priv;
279};
280
281/* Storage -----------------------------------------------------------*/
282
283struct storage {
284        unsigned                magic;
285#define STORAGE_MAGIC           0x1a4e51c0
286        VTAILQ_ENTRY(storage)   list;
287        struct stevedore        *stevedore;
288        void                    *priv;
289
290        unsigned char           *ptr;
291        unsigned                len;
292        unsigned                space;
293
294        int                     fd;
295        off_t                   where;
296};
297
298/* Object core structure ---------------------------------------------
299 * Objects have sideways references in the binary heap and the LRU list
300 * and we want to avoid paging in a lot of objects just to move them up
301 * or down the binheap or to move a unrelated object on the LRU list.
302 * To avoid this we use a proxy object, objcore, to hold the relevant
303 * housekeeping fields parts of an object.
304 */
305
306typedef struct object *getobj_f(struct worker *wrk, struct objcore *oc);
307typedef void updatemeta_f(struct objcore *oc);
308typedef void freeobj_f(struct objcore *oc);
309
310struct objcore_methods {
311        getobj_f        *getobj;
312        updatemeta_f    *updatemeta;
313        freeobj_f       *freeobj;
314};
315
316extern struct objcore_methods default_oc_methods;
317
318struct objcore {
319        unsigned                magic;
320#define OBJCORE_MAGIC           0x4d301302
321        unsigned                refcnt;
322        struct objcore_methods  *methods;
323        void                    *priv;
324        unsigned                priv2;
325        struct objhead          *objhead;
326        double                  timer_when;
327        unsigned                flags;
328#define OC_F_ONLRU              (1<<0)
329#define OC_F_BUSY               (1<<1)
330#define OC_F_PASS               (1<<2)
331#define OC_F_LRUDONTMOVE        (1<<4)
332#define OC_F_PRIV               (1<<5)          /* Stevedore private flag */
333        unsigned                timer_idx;
334        VTAILQ_ENTRY(objcore)   list;
335        VLIST_ENTRY(objcore)    lru_list;
336        VTAILQ_ENTRY(objcore)   ban_list;
337        struct ban              *ban;
338};
339
340static inline struct object *
341oc_getobj(struct worker *wrk, struct objcore *oc)
342{
343
344        return (oc->methods->getobj(wrk, oc));
345}
346
347static inline void
348oc_updatemeta(struct objcore *oc)
349{
350
351        if (oc->methods->updatemeta != NULL)
352                oc->methods->updatemeta(oc);
353}
354
355static inline void
356oc_freeobj(struct objcore *oc)
357{
358
359        oc->methods->freeobj(oc);
360}
361
362/*--------------------------------------------------------------------*/
363
364struct lru {
365        unsigned                magic;
366#define LRU_MAGIC               0x3fec7bb0
367        VLIST_HEAD(,objcore)    lru_head;
368        struct objcore          senteniel;
369};
370
371/* Object structure --------------------------------------------------*/
372
373struct object {
374        unsigned                magic;
375#define OBJECT_MAGIC            0x32851d42
376        unsigned                xid;
377        struct storage          *objstore;
378        struct objcore          *objcore;
379
380        struct ws               ws_o[1];
381        unsigned char           *vary;
382
383        double                  ban_t;
384        unsigned                response;
385
386        unsigned                cacheable;
387
388        unsigned                len;
389
390        double                  ttl;
391        double                  age;
392        double                  entered;
393        double                  grace;
394
395        double                  last_modified;
396        double                  last_lru;
397
398        struct http             *http;
399
400        VTAILQ_HEAD(, storage)  store;
401
402        struct esidata          *esidata;
403
404        double                  last_use;
405
406        int                     hits;
407};
408
409/* -------------------------------------------------------------------*/
410
411struct sess {
412        unsigned                magic;
413#define SESS_MAGIC              0x2c2f9c5a
414        int                     fd;
415        int                     id;
416        unsigned                xid;
417
418        int                     restarts;
419        int                     esis;
420        int                     disable_esi;
421
422        uint8_t                 hash_ignore_busy;
423        uint8_t                 hash_always_miss;
424
425        struct worker           *wrk;
426
427        socklen_t               sockaddrlen;
428        socklen_t               mysockaddrlen;
429        struct sockaddr_storage *sockaddr;
430        struct sockaddr_storage *mysockaddr;
431        struct listen_sock      *mylsock;
432
433        /* formatted ascii client address */
434        char                    *addr;
435        char                    *port;
436        char                    *client_identity;
437
438        /* HTTP request */
439        const char              *doclose;
440        struct http             *http;
441        struct http             *http0;
442
443        struct ws               ws[1];
444        char                    *ws_ses;        /* WS above session data */
445        char                    *ws_req;        /* WS above request data */
446
447        unsigned char           digest[DIGEST_LEN];
448
449        struct http_conn        htc[1];
450
451        /* Timestamps, all on TIM_real() timescale */
452        double                  t_open;
453        double                  t_req;
454        double                  t_resp;
455        double                  t_end;
456
457        /* Acceptable grace period */
458        double                  grace;
459
460        enum step               step;
461        unsigned                cur_method;
462        unsigned                handling;
463        unsigned char           pass;
464        unsigned char           sendbody;
465        unsigned char           wantbody;
466        int                     err_code;
467        const char              *err_reason;
468
469        VTAILQ_ENTRY(sess)      list;
470
471        struct director         *director;
472        struct vbc              *vbc;
473        struct object           *obj;
474        struct objcore          *objcore;
475        struct VCL_conf         *vcl;
476
477        /* The busy objhead we sleep on */
478        struct objhead          *hash_objhead;
479
480        /* Various internal stuff */
481        struct sessmem          *mem;
482
483        struct workreq          workreq;
484        struct acct             acct_tmp;
485        struct acct             acct_req;
486        struct acct             acct_ses;
487
488#if defined(HAVE_EPOLL_CTL)
489        struct epoll_event ev;
490#endif
491};
492
493/* -------------------------------------------------------------------*/
494
495/* Backend connection */
496struct vbc {
497        unsigned                magic;
498#define VBC_MAGIC               0x0c5e6592
499        VTAILQ_ENTRY(vbc)       list;
500        struct backend          *backend;
501        struct vdi_simple       *vdis;
502        int                     fd;
503
504        struct sockaddr_storage *addr;
505        socklen_t               addrlen;
506
507        uint8_t                 recycled;
508
509        /* Timeouts */
510        double                  first_byte_timeout;
511        double                  between_bytes_timeout;
512};
513
514/* Prototypes etc ----------------------------------------------------*/
515
516/* cache_acceptor.c */
517void vca_return_session(struct sess *sp);
518void vca_close_session(struct sess *sp, const char *why);
519void VCA_Prep(struct sess *sp);
520void VCA_Init(void);
521void VCA_Shutdown(void);
522const char *VCA_waiter_name(void);
523extern pthread_t VCA_thread;
524
525/* cache_backend.c */
526void VBE_UseHealth(const struct director *vdi);
527
528struct vbc *VDI_GetFd(const struct director *, struct sess *sp);
529int VDI_Healthy(const struct director *, const struct sess *sp);
530void VDI_CloseFd(struct sess *sp);
531void VDI_RecycleFd(struct sess *sp);
532void VDI_AddHostHeader(const struct sess *sp);
533void VBE_Poll(void);
534
535/* cache_backend_cfg.c */
536void VBE_Init(void);
537struct backend *VBE_AddBackend(struct cli *cli, const struct vrt_backend *vb);
538
539/* cache_backend_poll.c */
540void VBP_Init(void);
541
542/* cache_ban.c */
543struct ban *BAN_New(void);
544int BAN_AddTest(struct cli *, struct ban *, const char *, const char *,
545    const char *);
546void BAN_Free(struct ban *b);
547void BAN_Insert(struct ban *b);
548void BAN_Init(void);
549void BAN_NewObj(struct object *o);
550void BAN_DestroyObj(struct objcore *oc);
551int BAN_CheckObject(struct object *o, const struct sess *sp);
552void BAN_Reload(double t0, unsigned flags, const char *ban);
553struct ban *BAN_TailRef(void);
554void BAN_Compile(void);
555struct ban *BAN_RefBan(struct objcore *oc, double t0, const struct ban *tail);
556void BAN_Deref(struct ban **ban);
557
558/* cache_center.c [CNT] */
559void CNT_Session(struct sess *sp);
560void CNT_Init(void);
561
562/* cache_cli.c [CLI] */
563void CLI_Init(void);
564void CLI_Run(void);
565void CLI_AddFuncs(struct cli_proto *p);
566extern pthread_t cli_thread;
567#define ASSERT_CLI() do {assert(pthread_self() == cli_thread);} while (0)
568
569/* cache_expiry.c */
570void EXP_Insert(struct object *o);
571void EXP_Inject(struct objcore *oc, struct lru *lru, double ttl);
572void EXP_Init(void);
573void EXP_Rearm(const struct object *o);
574int EXP_Touch(const struct object *o);
575int EXP_NukeOne(const struct sess *sp, const struct lru *lru);
576
577/* cache_fetch.c */
578int FetchHdr(struct sess *sp);
579int FetchBody(struct sess *sp);
580int FetchReqBody(struct sess *sp);
581void Fetch_Init(void);
582
583/* cache_http.c */
584unsigned HTTP_estimate(unsigned nhttp);
585void HTTP_Copy(struct http *to, const struct http * const fm);
586struct http *HTTP_create(void *p, unsigned nhttp);
587const char *http_StatusMessage(unsigned);
588unsigned http_EstimateWS(const struct http *fm, unsigned how, unsigned *nhd);
589void HTTP_Init(void);
590void http_ClrHeader(struct http *to);
591unsigned http_Write(struct worker *w, const struct http *hp, int resp);
592void http_CopyResp(struct http *to, const struct http *fm);
593void http_SetResp(struct http *to, const char *proto, int status,
594    const char *response);
595void http_FilterFields(struct worker *w, int fd, struct http *to,
596    const struct http *fm, unsigned how);
597void http_FilterHeader(const struct sess *sp, unsigned how);
598void http_PutProtocol(struct worker *w, int fd, const struct http *to,
599    const char *protocol);
600void http_PutStatus(struct http *to, int status);
601void http_PutResponse(struct worker *w, int fd, const struct http *to,
602    const char *response);
603void http_PrintfHeader(struct worker *w, int fd, struct http *to,
604    const char *fmt, ...);
605void http_SetHeader(struct worker *w, int fd, struct http *to, const char *hdr);
606void http_SetH(const struct http *to, unsigned n, const char *fm);
607void http_ForceGet(const struct http *to);
608void http_Setup(struct http *ht, struct ws *ws);
609int http_GetHdr(const struct http *hp, const char *hdr, char **ptr);
610int http_GetHdrField(const struct http *hp, const char *hdr,
611    const char *field, char **ptr);
612int http_GetStatus(const struct http *hp);
613const char *http_GetReq(const struct http *hp);
614int http_HdrIs(const struct http *hp, const char *hdr, const char *val);
615int http_DissectRequest(struct sess *sp);
616int http_DissectResponse(struct worker *w, const struct http_conn *htc,
617    struct http *sp);
618const char *http_DoConnection(const struct http *hp);
619void http_CopyHome(struct worker *w, int fd, const struct http *hp);
620void http_Unset(struct http *hp, const char *hdr);
621void http_CollectHdr(struct http *hp, const char *hdr);
622
623/* cache_httpconn.c */
624void HTC_Init(struct http_conn *htc, struct ws *ws, int fd);
625int HTC_Reinit(struct http_conn *htc);
626int HTC_Rx(struct http_conn *htc);
627int HTC_Read(struct http_conn *htc, void *d, unsigned len);
628int HTC_Complete(struct http_conn *htc);
629
630#define HTTPH(a, b, c, d, e, f, g) extern char b[];
631#include "http_headers.h"
632#undef HTTPH
633
634/* cache_main.c */
635void THR_SetName(const char *name);
636const char* THR_GetName(void);
637void THR_SetSession(const struct sess *sp);
638const struct sess * THR_GetSession(void);
639
640/* cache_lck.c */
641
642/* Internal functions, call only through macros below */
643void Lck__Lock(struct lock *lck, const char *p, const char *f, int l);
644void Lck__Unlock(struct lock *lck, const char *p, const char *f, int l);
645int Lck__Trylock(struct lock *lck, const char *p, const char *f, int l);
646void Lck__New(struct lock *lck, struct vsc_lck *, const char *);
647void Lck__Assert(const struct lock *lck, int held);
648
649/* public interface: */
650void LCK_Init(void);
651void Lck_Delete(struct lock *lck);
652void Lck_CondWait(pthread_cond_t *cond, struct lock *lck);
653
654#define Lck_New(a, b) Lck__New(a, b, #b)
655#define Lck_Lock(a) Lck__Lock(a, __func__, __FILE__, __LINE__)
656#define Lck_Unlock(a) Lck__Unlock(a, __func__, __FILE__, __LINE__)
657#define Lck_Trylock(a) Lck__Trylock(a, __func__, __FILE__, __LINE__)
658#define Lck_AssertHeld(a) Lck__Assert(a, 1)
659#define Lck_AssertNotHeld(a) Lck__Assert(a, 0)
660
661#define LOCK(nam) extern struct vsc_lck *lck_##nam;
662#include "locks.h"
663#undef LOCK
664
665/* cache_panic.c */
666void PAN_Init(void);
667
668/* cache_pipe.c */
669void PipeSession(struct sess *sp);
670
671/* cache_pool.c */
672void WRK_Init(void);
673int WRK_Queue(struct workreq *wrq);
674int WRK_QueueSession(struct sess *sp);
675void WRK_SumStat(struct worker *w);
676
677void WRW_Reserve(struct worker *w, int *fd);
678unsigned WRW_Flush(struct worker *w);
679unsigned WRW_FlushRelease(struct worker *w);
680unsigned WRW_Write(struct worker *w, const void *ptr, int len);
681unsigned WRW_WriteH(struct worker *w, const txt *hh, const char *suf);
682#ifdef SENDFILE_WORKS
683void WRW_Sendfile(struct worker *w, int fd, off_t off, unsigned len);
684#endif  /* SENDFILE_WORKS */
685
686typedef void *bgthread_t(struct sess *, void *priv);
687void WRK_BgThread(pthread_t *thr, const char *name, bgthread_t *func,
688    void *priv);
689
690/* cache_session.c [SES] */
691void SES_Init(void);
692struct sess *SES_New(void);
693struct sess *SES_Alloc(void);
694void SES_Delete(struct sess *sp);
695void SES_Charge(struct sess *sp);
696
697/* cache_shmlog.c */
698void VSL_Init(void);
699#ifdef VSL_ENDMARKER
700void VSL(enum vsl_tag tag, int id, const char *fmt, ...);
701void WSLR(struct worker *w, enum vsl_tag tag, int id, txt t);
702void WSL(struct worker *w, enum vsl_tag tag, int id, const char *fmt, ...);
703void WSL_Flush(struct worker *w, int overflow);
704
705#define DSL(flag, tag, id, ...)                                 \
706        do {                                                    \
707                if (params->diag_bitmap & (flag))               \
708                        VSL((tag), (id), __VA_ARGS__);          \
709        } while (0)
710
711#define WSP(sess, tag, ...)                                     \
712        WSL((sess)->wrk, tag, (sess)->fd, __VA_ARGS__)
713
714#define WSPR(sess, tag, txt)                                    \
715        WSLR((sess)->wrk, tag, (sess)->fd, txt)
716
717#define INCOMPL() do {                                                  \
718        VSL(SLT_Debug, 0, "INCOMPLETE AT: %s(%d)", __func__, __LINE__); \
719        fprintf(stderr,                                                 \
720            "INCOMPLETE AT: %s(%d)\n",                                  \
721            (const char *)__func__, __LINE__);                          \
722        abort();                                                        \
723        } while (0)
724#endif
725
726/* cache_response.c */
727void RES_BuildHttp(struct sess *sp);
728void RES_WriteObj(struct sess *sp);
729
730/* cache_vary.c */
731struct vsb *VRY_Create(const struct sess *sp, const struct http *hp);
732int VRY_Match(const struct sess *sp, const unsigned char *vary);
733
734/* cache_vcl.c */
735void VCL_Init(void);
736void VCL_Refresh(struct VCL_conf **vcc);
737void VCL_Rel(struct VCL_conf **vcc);
738void VCL_Get(struct VCL_conf **vcc);
739void VCL_Poll(void);
740
741#define VCL_MET_MAC(l,u,b) void VCL_##l##_method(struct sess *);
742#include "vcl_returns.h"
743#undef VCL_MET_MAC
744
745/* cache_vrt.c */
746
747char *VRT_String(struct ws *ws, const char *h, const char *p, va_list ap);
748char *VRT_StringList(char *d, unsigned dl, const char *p, va_list ap);
749
750/* cache_vrt_esi.c */
751
752void ESI_Deliver(struct sess *);
753void ESI_Destroy(struct object *);
754void ESI_Parse(struct sess *);
755
756/* cache_vrt_vmod.c */
757void VMOD_Init(void);
758
759/* cache_ws.c */
760
761void WS_Init(struct ws *ws, const char *id, void *space, unsigned len);
762unsigned WS_Reserve(struct ws *ws, unsigned bytes);
763void WS_Release(struct ws *ws, unsigned bytes);
764void WS_ReleaseP(struct ws *ws, char *ptr);
765void WS_Assert(const struct ws *ws);
766void WS_Reset(struct ws *ws, char *p);
767char *WS_Alloc(struct ws *ws, unsigned bytes);
768char *WS_Dup(struct ws *ws, const char *);
769char *WS_Snapshot(struct ws *ws);
770unsigned WS_Free(const struct ws *ws);
771
772/* rfc2616.c */
773double RFC2616_Ttl(const struct sess *sp);
774enum body_status RFC2616_Body(const struct sess *sp);
775
776/* storage_synth.c */
777struct vsb *SMS_Makesynth(struct object *obj);
778void SMS_Finish(struct object *obj);
779
780/* storage_persistent.c */
781void SMP_Ready(void);
782void SMP_NewBan(double t0, const char *ban);
783
784/*
785 * A normal pointer difference is signed, but we never want a negative value
786 * so this little tool will make sure we don't get that.
787 */
788
789static inline unsigned
790pdiff(const void *b, const void *e)
791{
792
793        assert(b <= e);
794        return
795            ((unsigned)((const unsigned char *)e - (const unsigned char *)b));
796}
797
798static inline void
799Tcheck(const txt t)
800{
801
802        AN(t.b);
803        AN(t.e);
804        assert(t.b <= t.e);
805}
806
807/*
808 * unsigned length of a txt
809 */
810
811static inline unsigned
812Tlen(const txt t)
813{
814
815        Tcheck(t);
816        return ((unsigned)(t.e - t.b));
817}
818
819static inline void
820Tadd(txt *t, const char *p, int l)
821{
822        Tcheck(*t);
823
824        if (l <= 0) {
825        } if (t->b + l < t->e) {
826                memcpy(t->b, p, l);
827                t->b += l;
828        } else {
829                t->b = t->e;
830        }
831}
832
833static inline void
834AssertObjBusy(const struct object *o)
835{
836        AN(o->objcore);
837        AN (o->objcore->flags & OC_F_BUSY);
838}
839
840static inline void
841AssertObjPassOrBusy(const struct object *o)
842{
843        if (o->objcore != NULL)
844                AN (o->objcore->flags & OC_F_BUSY);
845}
Note: See TracBrowser for help on using the repository browser.