From: phk Date: Sat, 29 Sep 2007 20:53:53 +0000 (+0000) Subject: Another cleanup commit: X-Git-Url: https://err.no/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=20567a45a103d9a768c8ccdb8dcf5892f700c276;p=varnish Another cleanup commit: Get rid of the httptag enum, we can use the HTTP_T values instead. Introduce WSP macro to wrap log entries which has a session. Add our own vctyp() character classifier to simplify HTTP protocol message parsing. Unify http_DissectRequest() and http_DissectResponse() processing. Unify writing of the 5 byte SHMLOG header and other minor cleanups to shmlog code. Silence some signed/unsigned/int width warnings in FlexeLint git-svn-id: svn+ssh://projects.linpro.no/svn/varnish/trunk@2056 d4fa192b-c00b-0410-8231-f00ffab90ce4 --- diff --git a/varnish-cache/bin/varnishd/cache.h b/varnish-cache/bin/varnishd/cache.h index 25d53fb1..fcaa870d 100644 --- a/varnish-cache/bin/varnishd/cache.h +++ b/varnish-cache/bin/varnishd/cache.h @@ -47,21 +47,22 @@ #include "miniobj.h" enum { + /* Fields from the first line of HTTP proto */ HTTP_HDR_REQ, HTTP_HDR_URL, HTTP_HDR_PROTO, HTTP_HDR_STATUS, HTTP_HDR_RESPONSE, - /* add more here */ + /* HTTP header lines */ HTTP_HDR_FIRST, - HTTP_HDR_MAX = 32 + HTTP_HDR_MAX = 32 /* XXX: should be #defined */ }; /* Note: intentionally not IOV_MAX */ #define MAX_IOVS (HTTP_HDR_MAX * 2) /* Amount of per-worker logspace */ -#define WLOGSPACE 8192 +#define WLOGSPACE 8192 /* XXX: param ? */ struct cli; struct vsb; @@ -73,6 +74,13 @@ struct addrinfo; /*--------------------------------------------------------------------*/ +typedef struct { + char *b; + char *e; +} txt; + +/*--------------------------------------------------------------------*/ + enum step { #define STEP(l, u) STP_##u, #include "steps.h" @@ -85,24 +93,19 @@ enum step { struct ws { char *s; /* (S)tart of buffer */ - char *e; /* (E)nd of buffer */ char *f; /* (F)ree pointer */ char *r; /* (R)eserved length */ + char *e; /* (E)nd of buffer */ }; /*-------------------------------------------------------------------- * HTTP Request/Response/Header handling structure. */ -typedef struct { - char *b; - char *e; -} txt; - enum httpwhence { - HTTP_Rx, - HTTP_Tx, - HTTP_Obj + HTTP_Rx = 1, + HTTP_Tx = 2, + HTTP_Obj = 3 }; struct http { @@ -120,6 +123,10 @@ struct http { unsigned nhd; }; +/*-------------------------------------------------------------------- + * HTTP Protocol connection structure + */ + struct http_conn { unsigned magic; #define HTTP_CONN_MAGIC 0x3e19edd1 @@ -471,7 +478,7 @@ const char *http_GetReq(const struct http *hp); const char *http_GetProto(const struct http *hp); int http_HdrIs(const struct http *hp, const char *hdr, const char *val); int http_DissectRequest(struct sess *sp); -int http_DissectResponse(struct worker *w, struct http_conn *htc, struct http *sp); +int http_DissectResponse(struct worker *w, const struct http_conn *htc, struct http *sp); const char *http_DoConnection(struct http *hp); void http_CopyHome(struct worker *w, int fd, struct http *hp); void http_Unset(struct http *hp, const char *hdr); @@ -516,6 +523,11 @@ void VSL(enum shmlogtag tag, int id, const char *fmt, ...); void WSLR(struct worker *w, enum shmlogtag tag, int id, txt t); void WSL(struct worker *w, enum shmlogtag tag, int id, const char *fmt, ...); void WSL_Flush(struct worker *w); +#define WSP(sess, tag, fmt, ...) \ + WSL((sess)->wrk, tag, (sess)->fd, fmt, __VA_ARGS__) +#define WSPR(sess, tag, txt) \ + WSLR((sess)->wrk, tag, (sess)->fd, txt) + #define INCOMPL() do { \ VSL(SLT_Debug, 0, "INCOMPLETE AT: %s(%d)", __func__, __LINE__); \ fprintf(stderr,"INCOMPLETE AT: %s(%d)\n", (const char *)__func__, __LINE__); \ diff --git a/varnish-cache/bin/varnishd/cache_acceptor.c b/varnish-cache/bin/varnishd/cache_acceptor.c index 1ce0d6d4..ed0cdaab 100644 --- a/varnish-cache/bin/varnishd/cache_acceptor.c +++ b/varnish-cache/bin/varnishd/cache_acceptor.c @@ -241,7 +241,7 @@ vca_close_session(struct sess *sp, const char *why) { int i; - VSL(SLT_SessionClose, sp->fd, why); + WSP(sp, SLT_SessionClose, "%s", why); if (sp->fd >= 0) { i = close(sp->fd); assert(i == 0 || errno != EBADF); /* XXX EINVAL seen */ diff --git a/varnish-cache/bin/varnishd/cache_backend_random.c b/varnish-cache/bin/varnishd/cache_backend_random.c index 34933a2d..c33e3e8d 100644 --- a/varnish-cache/bin/varnishd/cache_backend_random.c +++ b/varnish-cache/bin/varnishd/cache_backend_random.c @@ -305,8 +305,7 @@ ber_GetFd(const struct sess *sp) assert(vc->fd >= 0); assert(vc->backend == sp->backend); WSL(sp->wrk, SLT_BackendXID, vc->fd, "%u", sp->xid); - WSL(sp->wrk, SLT_Backend, sp->fd, "%d %s", vc->fd, - sp->backend->vcl_name); + WSP(sp, SLT_Backend, "%d %s", vc->fd, sp->backend->vcl_name); return (vc); } return (NULL); diff --git a/varnish-cache/bin/varnishd/cache_backend_round_robin.c b/varnish-cache/bin/varnishd/cache_backend_round_robin.c index bf1736ac..b15400f9 100644 --- a/varnish-cache/bin/varnishd/cache_backend_round_robin.c +++ b/varnish-cache/bin/varnishd/cache_backend_round_robin.c @@ -290,8 +290,7 @@ brr_GetFd(const struct sess *sp) assert(vc->fd >= 0); assert(vc->backend == sp->backend); WSL(sp->wrk, SLT_BackendXID, vc->fd, "%u", sp->xid); - WSL(sp->wrk, SLT_Backend, sp->fd, "%d %s", vc->fd, - sp->backend->vcl_name); + WSP(sp, SLT_Backend, "%d %s", vc->fd, sp->backend->vcl_name); return (vc); } return (NULL); diff --git a/varnish-cache/bin/varnishd/cache_backend_simple.c b/varnish-cache/bin/varnishd/cache_backend_simple.c index bb85518a..a12b7961 100644 --- a/varnish-cache/bin/varnishd/cache_backend_simple.c +++ b/varnish-cache/bin/varnishd/cache_backend_simple.c @@ -263,8 +263,7 @@ bes_GetFd(const struct sess *sp) assert(vc->fd >= 0); assert(vc->backend == sp->backend); WSL(sp->wrk, SLT_BackendXID, vc->fd, "%u", sp->xid); - WSL(sp->wrk, SLT_Backend, sp->fd, "%d %s", vc->fd, - sp->backend->vcl_name); + WSP(sp, SLT_Backend, "%d %s", vc->fd, sp->backend->vcl_name); return (vc); } return (NULL); diff --git a/varnish-cache/bin/varnishd/cache_center.c b/varnish-cache/bin/varnishd/cache_center.c index 1d5bb93e..cb11cf1f 100644 --- a/varnish-cache/bin/varnishd/cache_center.c +++ b/varnish-cache/bin/varnishd/cache_center.c @@ -526,8 +526,7 @@ cnt_lookup(struct sess *sp) * We hit a busy object, disembark worker thread and expect * hash code to restart us, still in STP_LOOKUP, later. */ - WSL(sp->wrk, SLT_Debug, sp->fd, - "on waiting list on obj %u", sp->obj->xid); + WSP(sp, SLT_Debug, "on waiting list on obj %u", sp->obj->xid); /* * There is a non-zero risk that we come here more than once * before we get through, in that case cnt_recv must be set @@ -549,7 +548,7 @@ cnt_lookup(struct sess *sp) if (sp->obj->pass) { VSL_stats->cache_hitpass++; - WSL(sp->wrk, SLT_HitPass, sp->fd, "%u", sp->obj->xid); + WSP(sp, SLT_HitPass, "%u", sp->obj->xid); HSH_Deref(sp->obj); sp->obj = NULL; sp->step = STP_PASS; @@ -557,7 +556,7 @@ cnt_lookup(struct sess *sp) } VSL_stats->cache_hit++; - WSL(sp->wrk, SLT_Hit, sp->fd, "%u", sp->obj->xid); + WSP(sp, SLT_Hit, "%u", sp->obj->xid); sp->step = STP_HIT; return (0); } @@ -745,8 +744,7 @@ cnt_recv(struct sess *sp) /* Assign XID and log */ sp->xid = ++xids; /* XXX not locked */ - WSL(sp->wrk, SLT_ReqStart, sp->fd, - "%s %s %u", sp->addr, sp->port, sp->xid); + WSP(sp, SLT_ReqStart, "%s %s %u", sp->addr, sp->port, sp->xid); /* Borrow VCL reference from worker thread */ VCL_Refresh(&sp->wrk->vcl); diff --git a/varnish-cache/bin/varnishd/cache_fetch.c b/varnish-cache/bin/varnishd/cache_fetch.c index 89c85f00..8087ca7b 100644 --- a/varnish-cache/bin/varnishd/cache_fetch.c +++ b/varnish-cache/bin/varnishd/cache_fetch.c @@ -358,7 +358,7 @@ Fetch(struct sess *sp) mklen = 1; } else if (http_GetHdr(hp, H_Transfer_Encoding, &b)) { /* XXX: AUGH! */ - VSL(SLT_Debug, vc->fd, "Invalid Transfer-Encoding"); + WSL(sp->wrk, SLT_Debug, vc->fd, "Invalid Transfer-Encoding"); VBE_ClosedFd(sp->wrk, vc); return (-1); } else if (strcmp(http_GetProto(hp), "HTTP/1.1")) { diff --git a/varnish-cache/bin/varnishd/cache_hash.c b/varnish-cache/bin/varnishd/cache_hash.c index 68cff7a1..ac89e290 100644 --- a/varnish-cache/bin/varnishd/cache_hash.c +++ b/varnish-cache/bin/varnishd/cache_hash.c @@ -133,7 +133,7 @@ HSH_Compare(const struct sess *sp, const struct objhead *obj) assert(*b == '\0'); b++; assert(b == obj->hash + obj->hashlen); - VSL(SLT_Debug, sp->fd, "Hash Match: %s", obj->hash); + WSP(sp, SLT_Debug, "Hash Match: %s", obj->hash); return (0); } @@ -152,7 +152,7 @@ HSH_Copy(const struct sess *sp, const struct objhead *obj) *b++ = '#'; } *b++ = '\0'; - VSL(SLT_Debug, sp->fd, "Hash: %s", obj->hash); + WSP(sp, SLT_Debug, "Hash: %s", obj->hash); assert(b <= obj->hash + obj->hashlen); } @@ -204,7 +204,7 @@ HSH_Lookup(struct sess *sp) } else if (BAN_CheckObject(o, h->hd[HTTP_HDR_URL].b, oh->hash)) { o->ttl = 0; - VSL(SLT_ExpBan, 0, "%u was banned", o->xid); + WSP(sp, SLT_ExpBan, "%u was banned", o->xid); if (o->heap_idx != 0) EXP_TTLchange(o); } else if (o->vary == NULL || VRY_Match(sp, o->vary)) diff --git a/varnish-cache/bin/varnishd/cache_http.c b/varnish-cache/bin/varnishd/cache_http.c index 84870d1c..4eb331d4 100644 --- a/varnish-cache/bin/varnishd/cache_http.c +++ b/varnish-cache/bin/varnishd/cache_http.c @@ -51,48 +51,54 @@ #include "http_headers.h" #undef HTTPH -enum httptag { - HTTP_T_Request, - HTTP_T_Response, - HTTP_T_Status, - HTTP_T_URL, - HTTP_T_Protocol, - HTTP_T_Header, +#define C_SP (1<<0) +#define C_CRLF (1<<1) +#define C_LWS (C_CRLF | C_SP) +#define C_CTL (1<<2) + +static unsigned char vctyptab[256] = { + ['\t'] = C_SP, + ['\n'] = C_CRLF, + ['\r'] = C_CRLF, + [' '] = C_SP, }; -#define LOGMTX2(ax, bx) \ - [HTTP_T_##bx] = SLT_##ax##bx +#define vctyp(x, y) (vctyptab[(int)(x)] & (y)) + +#define LOGMTX2(ax, bx, cx) [bx] = SLT_##ax##cx #define LOGMTX1(ax) { \ - LOGMTX2(ax, Request), \ - LOGMTX2(ax, Response), \ - LOGMTX2(ax, Status), \ - LOGMTX2(ax, URL), \ - LOGMTX2(ax, Protocol), \ - LOGMTX2(ax, Header), \ + LOGMTX2(ax, HTTP_HDR_REQ, Request), \ + LOGMTX2(ax, HTTP_HDR_RESPONSE, Response), \ + LOGMTX2(ax, HTTP_HDR_STATUS, Status), \ + LOGMTX2(ax, HTTP_HDR_URL, URL), \ + LOGMTX2(ax, HTTP_HDR_PROTO, Protocol), \ + LOGMTX2(ax, HTTP_HDR_FIRST, Header), \ } -static enum shmlogtag logmtx[3][7] = { +static enum shmlogtag logmtx[][HTTP_HDR_FIRST + 1] = { [HTTP_Rx] = LOGMTX1(Rx), [HTTP_Tx] = LOGMTX1(Tx), [HTTP_Obj] = LOGMTX1(Obj) }; static enum shmlogtag -http2shmlog(const struct http *hp, enum httptag t) +http2shmlog(const struct http *hp, int t) { CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); - assert(/* hp->logtag >= HTTP_Rx && */hp->logtag <= HTTP_Obj); - assert(/* t >= HTTP_T_Request && */t <= HTTP_T_Header); + if (t > HTTP_HDR_FIRST) + t = HTTP_HDR_FIRST; + assert(hp->logtag >= HTTP_Rx && hp->logtag <= HTTP_Obj); + assert(t >= HTTP_HDR_REQ && t <= HTTP_HDR_FIRST); return (logmtx[hp->logtag][t]); } static void -WSLH(struct worker *w, enum httptag t, int fd, const struct http *hp, unsigned hdr) +WSLH(struct worker *w, int fd, const struct http *hp, unsigned hdr) { - WSLR(w, http2shmlog(hp, t), fd, hp->hd[hdr]); + WSLR(w, http2shmlog(hp, hdr), fd, hp->hd[hdr]); } /*--------------------------------------------------------------------*/ @@ -378,7 +384,7 @@ http_dissect_hdrs(struct worker *w, struct http *hp, int fd, char *p, txt t) hp->hdf[hp->nhd] = 0; hp->hd[hp->nhd].b = p; hp->hd[hp->nhd].e = q; - WSLH(w, HTTP_T_Header, fd, hp, hp->nhd); + WSLH(w, fd, hp, hp->nhd); hp->nhd++; } else { VSL_stats->losthdr++; @@ -388,132 +394,117 @@ http_dissect_hdrs(struct worker *w, struct http *hp, int fd, char *p, txt t) return (0); } -/*--------------------------------------------------------------------*/ +/*-------------------------------------------------------------------- + * Deal with first line of HTTP protocol message. + */ -int -http_DissectRequest(struct sess *sp) +static int +http_splitline(struct worker *w, int fd, struct http *hp, const struct http_conn *htc, int h1, int h2, int h3) { char *p; - struct http_conn *htc; - struct http *hp; - CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); - htc = sp->htc; CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC); - hp = sp->http; CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); - /* Assert a NUL at rx.e */ + /* XXX: Assert a NUL at rx.e ? */ Tcheck(htc->rxbuf); - hp->logtag = HTTP_Rx; - for (p = htc->rxbuf.b ; isspace(*p); p++) + /* Skip leading LWS */ + for (p = htc->rxbuf.b ; vctyp(*p, C_LWS); p++) continue; - /* First, the request type (GET/HEAD etc) */ - hp->hd[HTTP_HDR_REQ].b = p; - for (; isalpha(*p); p++) + /* First field cannot contain SP, CRLF or CTL */ + hp->hd[h1].b = p; + for (; !vctyp(*p, C_SP); p++) + if (vctyp(*p, C_CRLF | C_CTL)) + return (400); + hp->hd[h1].e = p; + + /* Skip SP */ + for (; vctyp(*p, C_SP); p++) ; - hp->hd[HTTP_HDR_REQ].e = p; - WSLH(sp->wrk, HTTP_T_Request, sp->fd, hp, HTTP_HDR_REQ); - *p++ = '\0'; - /* Next find the URI */ - while (isspace(*p) && *p != '\n') - p++; - if (*p == '\n') { - WSLR(sp->wrk, SLT_HttpGarbage, sp->fd, htc->rxbuf); - return (400); - } - hp->hd[HTTP_HDR_URL].b = p; - while (!isspace(*p)) - p++; - hp->hd[HTTP_HDR_URL].e = p; - WSLH(sp->wrk, HTTP_T_URL, sp->fd, hp, HTTP_HDR_URL); - if (*p == '\n') { - WSLR(sp->wrk, SLT_HttpGarbage, sp->fd, htc->rxbuf); - return (400); - } - *p++ = '\0'; + /* Second field cannot contain SP, CRLF or CTL */ + hp->hd[h2].b = p; + for (; !vctyp(*p, C_SP); p++) + if (vctyp(*p, C_CRLF | C_CTL)) + return (400); + hp->hd[h2].e = p; - /* Finally, look for protocol */ - while (isspace(*p) && *p != '\n') - p++; - if (*p == '\n') { - WSLR(sp->wrk, SLT_HttpGarbage, sp->fd, htc->rxbuf); - return (400); + /* Skip SP */ + for (; vctyp(*p, C_SP); p++) + ; + + /* Third field is optional and cannot contain CTL */ + if (!vctyp(*p, C_CRLF)) { + hp->hd[h3].b = p; + for (; !vctyp(*p, C_CRLF); p++) + if (vctyp(*p, C_CTL)) + return (400); + hp->hd[h3].e = p; } - hp->hd[HTTP_HDR_PROTO].b = p; - while (!isspace(*p)) - p++; - hp->hd[HTTP_HDR_PROTO].e = p; - WSLH(sp->wrk, HTTP_T_Protocol, sp->fd, hp, HTTP_HDR_PROTO); - if (*p != '\n') - *p++ = '\0'; - while (isspace(*p) && *p != '\n') - p++; - if (*p != '\n') { - WSLR(sp->wrk, SLT_HttpGarbage, sp->fd, htc->rxbuf); - return (400); + + /* Skip CRLF */ + for (; vctyp(*p, C_CRLF); p++) + if (vctyp(*p, C_CTL)) + return (400); + + *hp->hd[h1].e = '\0'; + WSLH(w, fd, hp, h1); + + *hp->hd[h2].e = '\0'; + WSLH(w, fd, hp, h2); + + if (hp->hd[h3].e != NULL) { + *hp->hd[h3].e = '\0'; + WSLH(w, fd, hp, h3); } - *p++ = '\0'; - return (http_dissect_hdrs(sp->wrk, hp, sp->fd, p, htc->rxbuf)); + return (http_dissect_hdrs(w, hp, fd, p, htc->rxbuf)); } /*--------------------------------------------------------------------*/ int -http_DissectResponse(struct worker *w, struct http_conn *htc, struct http *hp) +http_DissectRequest(struct sess *sp) { - char *p, *q; + struct http_conn *htc; + struct http *hp; + int i; + CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); + htc = sp->htc; CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC); + hp = sp->http; CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); - /* Assert a NUL at rx.e (?) */ - Tcheck(htc->rxbuf); + hp->logtag = HTTP_Rx; - for (p = htc->rxbuf.b ; isspace(*p); p++) - continue; + i = http_splitline(sp->wrk, sp->fd, hp, htc, + HTTP_HDR_REQ, HTTP_HDR_URL, HTTP_HDR_PROTO); - if (memcmp(p, "HTTP/1.", 7)) { - WSLR(w, SLT_HttpGarbage, htc->fd, htc->rxbuf); - return (400); - } - /* First, protocol */ - hp->hd[HTTP_HDR_PROTO].b = p; - while (!isspace(*p)) - p++; - hp->hd[HTTP_HDR_PROTO].e = p; - WSLH(w, HTTP_T_Protocol, htc->fd, hp, HTTP_HDR_PROTO); - *p++ = '\0'; + if (i != 0) + WSPR(sp, SLT_HttpGarbage, htc->rxbuf); + return (i); +} - /* Next find the status */ - while (isspace(*p)) - p++; - hp->hd[HTTP_HDR_STATUS].b = p; - while (!isspace(*p)) - p++; - hp->hd[HTTP_HDR_STATUS].e = p; - WSLH(w, HTTP_T_Status, htc->fd, hp, HTTP_HDR_STATUS); - *p++ = '\0'; +/*--------------------------------------------------------------------*/ - /* Next find the response */ - while (isspace(*p)) - p++; - hp->hd[HTTP_HDR_RESPONSE].b = p; - while (*p != '\n') - p++; - for (q = p; q > hp->hd[HTTP_HDR_RESPONSE].b && - isspace(q[-1]); q--) - continue; - *q = '\0'; - hp->hd[HTTP_HDR_RESPONSE].e = q; - WSLH(w, HTTP_T_Response, htc->fd, hp, HTTP_HDR_RESPONSE); - p++; +int +http_DissectResponse(struct worker *w, const struct http_conn *htc, struct http *hp) +{ + int i; + + CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC); + CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC); + hp->logtag = HTTP_Rx; + + i = http_splitline(w, htc->fd, hp, htc, + HTTP_HDR_PROTO, HTTP_HDR_STATUS, HTTP_HDR_RESPONSE); - return (http_dissect_hdrs(w, hp, htc->fd, p, htc->rxbuf)); + if (i != 0 || memcmp(hp->hd[HTTP_HDR_PROTO].b, "HTTP/1.", 7)) + WSLR(w, SLT_HttpGarbage, htc->fd, htc->rxbuf); + return (i); } /*--------------------------------------------------------------------*/ @@ -657,34 +648,19 @@ void http_CopyHome(struct worker *w, int fd, struct http *hp) { unsigned u, l; - enum httptag htt; char *p; for (u = 0; u < hp->nhd; u++) { if (hp->hd[u].b == NULL) continue; - switch (u) { - case HTTP_HDR_PROTO: - htt = HTTP_T_Protocol; - break; - case HTTP_HDR_STATUS: - htt = HTTP_T_Status; - break; - case HTTP_HDR_RESPONSE: - htt = HTTP_T_Response; - break; - default: - htt = HTTP_T_Header; - break; - } if (hp->hd[u].b >= hp->ws->s && hp->hd[u].e <= hp->ws->e) { - WSLH(w, htt, fd, hp, u); + WSLH(w, fd, hp, u); continue; } l = Tlen(hp->hd[u]); p = WS_Alloc(hp->ws, l + 1); if (p != NULL) { - WSLH(w, htt, fd, hp, u); + WSLH(w, fd, hp, u); memcpy(p, hp->hd[u].b, l + 1); hp->hd[u].b = p; hp->hd[u].e = p + l; @@ -818,25 +794,25 @@ http_Write(struct worker *w, const struct http *hp, int resp) if (resp) { AN(hp->hd[HTTP_HDR_STATUS].b); l = WRK_WriteH(w, &hp->hd[HTTP_HDR_PROTO], " "); - WSLH(w, HTTP_T_Protocol, *w->wfd, hp, HTTP_HDR_PROTO); + WSLH(w, *w->wfd, hp, HTTP_HDR_PROTO); l += WRK_WriteH(w, &hp->hd[HTTP_HDR_STATUS], " "); - WSLH(w, HTTP_T_Status, *w->wfd, hp, HTTP_HDR_STATUS); + WSLH(w, *w->wfd, hp, HTTP_HDR_STATUS); l += WRK_WriteH(w, &hp->hd[HTTP_HDR_RESPONSE], "\r\n"); - WSLH(w, HTTP_T_Response, *w->wfd, hp, HTTP_HDR_RESPONSE); + WSLH(w, *w->wfd, hp, HTTP_HDR_RESPONSE); } else { AN(hp->hd[HTTP_HDR_URL].b); l = WRK_WriteH(w, &hp->hd[HTTP_HDR_REQ], " "); - WSLH(w, HTTP_T_Request, *w->wfd, hp, HTTP_HDR_REQ); + WSLH(w, *w->wfd, hp, HTTP_HDR_REQ); l += WRK_WriteH(w, &hp->hd[HTTP_HDR_URL], " "); - WSLH(w, HTTP_T_URL, *w->wfd, hp, HTTP_HDR_URL); + WSLH(w, *w->wfd, hp, HTTP_HDR_URL); l += WRK_WriteH(w, &hp->hd[HTTP_HDR_PROTO], "\r\n"); - WSLH(w, HTTP_T_Protocol, *w->wfd, hp, HTTP_HDR_PROTO); + WSLH(w, *w->wfd, hp, HTTP_HDR_PROTO); } for (u = HTTP_HDR_FIRST; u < hp->nhd; u++) { AN(hp->hd[u].b); AN(hp->hd[u].e); l += WRK_WriteH(w, &hp->hd[u], "\r\n"); - WSLH(w, HTTP_T_Header, *w->wfd, hp, u); + WSLH(w, *w->wfd, hp, u); } l += WRK_Write(w, "\r\n", -1); return (l); @@ -847,7 +823,13 @@ http_Write(struct worker *w, const struct http *hp, int resp) void HTTP_Init(void) { + int i; #define HTTPH(a, b, c, d, e, f, g) b[0] = (char)strlen(b + 1); #include "http_headers.h" #undef HTTPH + + for (i = 1; i < 32; i++) + if (vctyptab[i] == 0) + vctyptab[i] = C_CTL; + vctyptab[127] = C_CTL; } diff --git a/varnish-cache/bin/varnishd/cache_response.c b/varnish-cache/bin/varnishd/cache_response.c index 8dc4cea5..244d326d 100644 --- a/varnish-cache/bin/varnishd/cache_response.c +++ b/varnish-cache/bin/varnishd/cache_response.c @@ -69,7 +69,7 @@ res_do_304(struct sess *sp) { char lm[64]; - WSL(sp->wrk, SLT_Length, sp->fd, "%u", 0); + WSP(sp, SLT_Length, "%u", 0); http_ClrHeader(sp->http); sp->http->logtag = HTTP_Tx; @@ -119,7 +119,7 @@ RES_BuildHttp(struct sess *sp) if (sp->obj->response == 200 && sp->http->conds && res_do_conds(sp)) return; - WSL(sp->wrk, SLT_Length, sp->fd, "%u", sp->obj->len); + WSP(sp, SLT_Length, "%u", sp->obj->len); http_ClrHeader(sp->http); sp->http->logtag = HTTP_Tx; diff --git a/varnish-cache/bin/varnishd/cache_vcl.c b/varnish-cache/bin/varnishd/cache_vcl.c index 7be68f67..3a19250f 100644 --- a/varnish-cache/bin/varnishd/cache_vcl.c +++ b/varnish-cache/bin/varnishd/cache_vcl.c @@ -304,10 +304,9 @@ VCL_##func##_method(struct sess *sp) \ { \ \ sp->handling = 0; \ - WSL(sp->wrk, SLT_VCL_call, sp->fd, "%s", #func); \ + WSP(sp, SLT_VCL_call, "%s", #func); \ sp->vcl->func##_func(sp); \ - WSL(sp->wrk, SLT_VCL_return, sp->fd, "%s", \ - vcl_handlingname(sp->handling)); \ + WSP(sp, SLT_VCL_return, "%s", vcl_handlingname(sp->handling)); \ assert(sp->handling & bitmap); \ assert(!(sp->handling & ~bitmap)); \ } diff --git a/varnish-cache/bin/varnishd/cache_vrt.c b/varnish-cache/bin/varnishd/cache_vrt.c index 6acabdb9..908e296d 100644 --- a/varnish-cache/bin/varnishd/cache_vrt.c +++ b/varnish-cache/bin/varnishd/cache_vrt.c @@ -68,7 +68,7 @@ VRT_count(const struct sess *sp, unsigned u) CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); if (params->vcl_trace) - WSL(sp->wrk, SLT_VCL_trace, sp->fd, "%u %d.%d", u, + WSP(sp, SLT_VCL_trace, "%u %d.%d", u, sp->vcl->ref[u].line, sp->vcl->ref[u].pos); } @@ -169,7 +169,7 @@ VRT_SetHdr(const struct sess *sp , enum gethdr_e where, const char *hdr, const c } else { b = vrt_assemble_string(hp, hdr + 1, p, ap); if (b == NULL) { - VSL(SLT_LostHeader, sp->fd, hdr + 1); + WSP(sp, SLT_LostHeader, "%s", hdr + 1); } else { http_Unset(hp, hdr); http_SetHeader(sp->wrk, sp->fd, hp, b); @@ -228,7 +228,7 @@ VRT_l_obj_status(const struct sess *sp, int num) assert(num >= 100 && num <= 999); p = WS_Alloc(sp->obj->http.ws, 4); if (p == NULL) - WSL(sp->wrk, SLT_LostHeader, sp->fd, "obj.status"); + WSP(sp, SLT_LostHeader, "%s", "obj.status"); else sprintf(p, "%d", num); http_SetH(&sp->obj->http, HTTP_HDR_STATUS, p); @@ -250,7 +250,7 @@ VRT_l_resp_status(const struct sess *sp, int num) assert(num >= 100 && num <= 999); p = WS_Alloc(sp->http->ws, 4); if (p == NULL) - WSL(sp->wrk, SLT_LostHeader, sp->fd, "resp.status"); + WSP(sp, SLT_LostHeader, "%s", "resp.status"); else sprintf(p, "%d", num); http_SetH(sp->http, HTTP_HDR_STATUS, p); @@ -284,7 +284,7 @@ VRT_l_obj_ttl(const struct sess *sp, double a) CHECK_OBJ_NOTNULL(sp, SESS_MAGIC); CHECK_OBJ_NOTNULL(sp->obj, OBJECT_MAGIC); /* XXX */ - WSL(sp->wrk, SLT_TTL, sp->fd, "%u VCL %.0f %.0f", + WSP(sp, SLT_TTL, "%u VCL %.0f %.0f", sp->obj->xid, a, sp->t_req); if (a < 0) a = 0; diff --git a/varnish-cache/bin/varnishd/cache_vrt_acl.c b/varnish-cache/bin/varnishd/cache_vrt_acl.c index 23fed962..33aef1fe 100644 --- a/varnish-cache/bin/varnishd/cache_vrt_acl.c +++ b/varnish-cache/bin/varnishd/cache_vrt_acl.c @@ -67,17 +67,17 @@ vrt_acl_vsl(const struct sess *sp, const char *acln, const struct vrt_acl *ap, i if (acln != NULL) { if (ap->name == NULL) { assert(r == 0); - VSL(SLT_VCL_acl, sp->fd, "NO_MATCH %s", acln); + WSP(sp, SLT_VCL_acl, "NO_MATCH %s", acln); return (r); } if (ap->priv == NULL) { assert(r == 0); - VSL(SLT_VCL_acl, sp->fd, "FAIL %s %s", acln, ap->desc); + WSP(sp, SLT_VCL_acl, "FAIL %s %s", acln, ap->desc); return (r); } - VSL(SLT_VCL_acl, sp->fd, "%s %s %s", - r ? "MATCH" : "NEG_MATCH", acln, ap->desc); + WSP(sp, SLT_VCL_acl, "%s %s %s", + r ? "MATCH" : "NEG_MATCH", acln, ap->desc); } return (r); } diff --git a/varnish-cache/bin/varnishd/flint.lnt b/varnish-cache/bin/varnishd/flint.lnt index a1148931..1e2a1447 100644 --- a/varnish-cache/bin/varnishd/flint.lnt +++ b/varnish-cache/bin/varnishd/flint.lnt @@ -70,20 +70,21 @@ // Review all below this line /////////////////////////////////////////////// +-e732 // Loss of sign (arg. no. 2) (int to unsigned +-e737 // [45] Loss of sign in promotion from int to unsigned +-e713 // Loss of precision (assignment) (unsigned long long to long long) +-e574 // Signed-unsigned mix with relational +-e712 // Loss of precision (assignment) (long long to +-e747 // Significant prototype coercion (arg. no. 2) long + /* -e767 // Macro redef (system queue.h vs ours ) --e574 // Signed-unsigned mix with relational --e712 // Loss of precision (assignment) (long long to --e747 // Significant prototype coercion (arg. no. 2) long --e713 // Loss of precision (assignment) (unsigned long long to long long) -e506 // Constant value boolean -e818 // Pointer parameter '...' could be declared as pointing to const -e774 // Boolean within 'if' always evaluates to False -e534 // Ignoring return value of function -e557 // unrecog format --e732 // Loss of sign (arg. no. 2) (int to unsigned --e737 // [45] Loss of sign in promotion from int to unsigned */ diff --git a/varnish-cache/bin/varnishd/rfc2616.c b/varnish-cache/bin/varnishd/rfc2616.c index 862f2cb9..28beeb48 100644 --- a/varnish-cache/bin/varnishd/rfc2616.c +++ b/varnish-cache/bin/varnishd/rfc2616.c @@ -155,7 +155,7 @@ RFC2616_Ttl(const struct sess *sp, const struct http *hp, struct object *obj) } /* calculated TTL, Our time, Date, Expires, max-age, age */ - WSL(sp->wrk, SLT_TTL, sp->fd, "%u RFC %d %d %d %d %d %d", sp->xid, + WSP(sp, SLT_TTL, "%u RFC %d %d %d %d %d %d", sp->xid, (int)(ttd - obj->entered), (int)obj->entered, (int)h_date, (int)h_expires, (int)u1, (int)u2); diff --git a/varnish-cache/bin/varnishd/shmlog.c b/varnish-cache/bin/varnishd/shmlog.c index 76724c39..b99ca72c 100644 --- a/varnish-cache/bin/varnishd/shmlog.c +++ b/varnish-cache/bin/varnishd/shmlog.c @@ -66,10 +66,6 @@ static struct shmloghead *loghead; static unsigned char *logstart; static MTX vsl_mtx; -/* - * This variant copies a byte-range directly to the log, without - * taking the detour over sprintf() - */ static void vsl_wrap(void) @@ -80,7 +76,23 @@ vsl_wrap(void) loghead->ptr = 0; } -/*--------------------------------------------------------------------*/ +static void +vsl_hdr(enum shmlogtag tag, unsigned char *p, unsigned len, int id) +{ + + p[1] = len & 0xff; + p[2] = (id >> 8) & 0xff; + p[3] = id & 0xff; + p[4 + len] = '\0'; + p[5 + len] = SLT_ENDMARKER; + /* XXX: Write barrier here */ + p[0] = tag; +} + +/*-------------------------------------------------------------------- + * This variant copies a byte-range directly to the log, without + * taking the detour over sprintf() + */ void VSLR(enum shmlogtag tag, int id, txt t) @@ -108,17 +120,11 @@ VSLR(enum shmlogtag tag, int id, txt t) vsl_wrap(); p = logstart + loghead->ptr; loghead->ptr += 5 + l; - p[5 + l] = SLT_ENDMARKER; assert(loghead->ptr < loghead->size); UNLOCKSHM(&vsl_mtx); - p[1] = l & 0xff; - p[2] = (id >> 8) & 0xff; - p[3] = id & 0xff; memcpy(p + 4, t.b, l); - p[4 + l] = '\0'; - /* XXX: memory barrier */ - p[0] = tag; + vsl_hdr(tag, p, l, id); } /*--------------------------------------------------------------------*/ @@ -138,35 +144,25 @@ VSL(enum shmlogtag tag, int id, const char *fmt, ...) t.b = (void*)(uintptr_t)fmt; t.e = strchr(fmt, '\0'); VSLR(tag, id, t); - return; + } else { + LOCKSHM(&vsl_mtx); + VSL_stats->shm_writes++; + VSL_stats->shm_records++; + assert(loghead->ptr < loghead->size); + + /* Wrap if we cannot fit a full size record */ + if (loghead->ptr + 5 + 255 + 1 >= loghead->size) + vsl_wrap(); + + p = logstart + loghead->ptr; + n = vsnprintf((char *)(p + 4), 256, fmt, ap); + if (n > 255) + n = 255; /* we truncate long fields */ + vsl_hdr(tag, p, n, id); + loghead->ptr += 5 + n; + assert(loghead->ptr < loghead->size); + UNLOCKSHM(&vsl_mtx); } - - LOCKSHM(&vsl_mtx); - VSL_stats->shm_writes++; - VSL_stats->shm_records++; - assert(loghead->ptr < loghead->size); - - /* Wrap if we cannot fit a full size record */ - if (loghead->ptr + 5 + 255 + 1 >= loghead->size) - vsl_wrap(); - - p = logstart + loghead->ptr; - n = 0; - n = vsnprintf((char *)(p + 4), 256, fmt, ap); - if (n > 255) - n = 255; /* we truncate long fields */ - p[1] = n & 0xff; - p[2] = (id >> 8) & 0xff; - p[3] = id & 0xff; - p[4 + n] = '\0';; - p[5 + n] = SLT_ENDMARKER; - p[0] = tag; - - loghead->ptr += 5 + n; - assert(loghead->ptr < loghead->size); - - UNLOCKSHM(&vsl_mtx); - va_end(ap); } @@ -192,6 +188,7 @@ WSL_Flush(struct worker *w) p[l] = SLT_ENDMARKER; loghead->ptr += l; assert(loghead->ptr < loghead->size); + /* XXX: memory barrier here */ p[0] = w->wlog[0]; UNLOCKSHM(&vsl_mtx); w->wlp = w->wlog; @@ -223,14 +220,8 @@ WSLR(struct worker *w, enum shmlogtag tag, int id, txt t) p = w->wlp; w->wlp += 5 + l; assert(w->wlp < w->wle); - p[5 + l] = SLT_ENDMARKER; - - p[1] = l & 0xff; - p[2] = (id >> 8) & 0xff; - p[3] = id & 0xff; memcpy(p + 4, t.b, l); - p[4 + l] = '\0'; - p[0] = tag; + vsl_hdr(tag, p, l, id); w->wlr++; } @@ -251,30 +242,22 @@ WSL(struct worker *w, enum shmlogtag tag, int id, const char *fmt, ...) t.b = (void*)(uintptr_t)fmt; t.e = strchr(fmt, '\0'); WSLR(w, tag, id, t); - return; + } else { + assert(w->wlp < w->wle); + + /* Wrap if we cannot fit a full size record */ + if (w->wlp + 5 + 255 + 1 >= w->wle) + WSL_Flush(w); + + p = w->wlp; + n = vsnprintf((char *)(p + 4), 256, fmt, ap); + if (n > 255) + n = 255; /* we truncate long fields */ + vsl_hdr(tag, p, n, id); + w->wlp += 5 + n; + assert(w->wlp < w->wle); + w->wlr++; } - - assert(w->wlp < w->wle); - - /* Wrap if we cannot fit a full size record */ - if (w->wlp + 5 + 255 + 1 >= w->wle) - WSL_Flush(w); - - p = w->wlp; - n = 0; - n = vsnprintf((char *)(p + 4), 256, fmt, ap); - if (n > 255) - n = 255; /* we truncate long fields */ - p[1] = n & 0xff; - p[2] = (id >> 8) & 0xff; - p[3] = id & 0xff; - p[4 + n] = '\0';; - p[5 + n] = SLT_ENDMARKER; - p[0] = tag; - - w->wlp += 5 + n; - assert(w->wlp < w->wle); - w->wlr++; va_end(ap); }