Code Coverage: vinyl-cache/bin/vinyld/http1/cache_http1_deliver.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2006 Verdens Gang AS
2
 * Copyright (c) 2006-2015 Varnish Software AS
3
 * All rights reserved.
4
 *
5
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
6
 *
7
 * SPDX-License-Identifier: BSD-2-Clause
8
 *
9
 * Redistribution and use in source and binary forms, with or without
10
 * modification, are permitted provided that the following conditions
11
 * are met:
12
 * 1. Redistributions of source code must retain the above copyright
13
 *    notice, this list of conditions and the following disclaimer.
14
 * 2. Redistributions in binary form must reproduce the above copyright
15
 *    notice, this list of conditions and the following disclaimer in the
16
 *    documentation and/or other materials provided with the distribution.
17
 *
18
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
19
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
21
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
22
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
24
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
25
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
26
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
27
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
28
 * SUCH DAMAGE.
29
 */
30
31
#include "config.h"
32
33
#include "cache/cache_int.h"
34
#include "cache/cache_filter.h"
35
#include "cache_http1.h"
36
#include "cache/cache_transport.h"
37
38
#include "vtcp.h"
39
40
/*--------------------------------------------------------------------*/
41
42
static void
43
v1d_error(struct req *req, struct v1l **v1lp, const char *msg)
44 103
{
45 103
        static const char r_500[] =
46 103
            "HTTP/1.1 500 Internal Server Error\r\n"
47 103
            "Server: Vinyl-Cache\r\n"
48 103
            "Connection: close\r\n\r\n";
49 103
        uint64_t bytes;
50
51 103
        AN(v1lp);
52 103
        if (*v1lp != NULL)
53 103
                (void) V1L_Close(v1lp, &bytes);
54
55 103
        VSLbs(req->vsl, SLT_Error, TOSTRAND(msg));
56 103
        VSLb(req->vsl, SLT_RespProtocol, "HTTP/1.1");
57 103
        VSLb(req->vsl, SLT_RespStatus, "500");
58 103
        VSLb(req->vsl, SLT_RespReason, "Internal Server Error");
59
60 103
        req->wrk->stats->client_resp_500++;
61 103
        VTCP_Assert(write(req->sp->fd, r_500, sizeof r_500 - 1));
62 103
        req->doclose = SC_TX_EOF;
63
64 103
        req->acct.resp_bodybytes += VDP_Close(req->vdc, req->objcore, req->boc);
65 103
}
66
67
/*--------------------------------------------------------------------
68
 */
69
70
enum vtr_deliver_e v_matchproto_(vtr_deliver_f)
71
V1D_Deliver(struct req *req, int sendbody)
72 3900
{
73 3900
        struct vrt_ctx ctx[1];
74 3900
        int err = 0, chunked = 0;
75 3900
        stream_close_t sc;
76 3900
        uint64_t bytes;
77 3900
        struct v1l *v1l;
78
79 3900
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
80 3900
        CHECK_OBJ_ORNULL(req->boc, BOC_MAGIC);
81 3900
        CHECK_OBJ_NOTNULL(req->objcore, OBJCORE_MAGIC);
82
83 3900
        req->doclose = http_EnsureConnection(req->resp, req->doclose);
84
85 3900
        CHECK_OBJ_NOTNULL(req->wrk, WORKER_MAGIC);
86
87 3900
        v1l = V1L_Open(req->wrk->aws, &req->sp->fd, req->vsl,
88 3900
            req->t_prev + SESS_TMO(req->sp, send_timeout),
89 3900
            cache_param->http1_iovs);
90
91 3900
        if (v1l == NULL) {
92 0
                v1d_error(req, &v1l, "Failure to init v1d (workspace_thread overflow)");
93 0
                return (VTR_D_DONE);
94 0
        }
95
96 3900
        if (sendbody) {
97 2606
                if (!http_GetHdr(req->resp, H_Content_Length, NULL)) {
98 292
                        if (req->http->protover == 11) {
99 288
                                chunked = 1;
100 288
                                http_SetHeader(req->resp,
101 288
                                    "Transfer-Encoding: chunked");
102 288
                        } else {
103 4
                                req->doclose = SC_TX_EOF;
104 4
                        }
105 292
                }
106 2606
                INIT_OBJ(ctx, VRT_CTX_MAGIC);
107 2606
                VCL_Req2Ctx(ctx, req);
108 2606
                if (VDP_Push(ctx, req->vdc, req->ws, VDP_v1l, v1l)) {
109 57
                        v1d_error(req, &v1l, "Failure to push v1d processor");
110 57
                        return (VTR_D_DONE);
111 57
                }
112 2606
        }
113
114 3843
        if (WS_Overflowed(req->ws)) {
115 45
                v1d_error(req, &v1l, "workspace_client overflow");
116 45
                return (VTR_D_DONE);
117 45
        }
118
119 3798
        if (WS_Overflowed(req->sp->ws)) {
120 1
                v1d_error(req, &v1l, "workspace_session overflow");
121 1
                return (VTR_D_DONE);
122 1
        }
123
124 3797
        if (WS_Overflowed(req->wrk->aws)) {
125 0
                v1d_error(req, &v1l, "workspace_thread overflow");
126 0
                return (VTR_D_DONE);
127 0
        }
128
129 3797
        req->acct.resp_hdrbytes += HTTP1_Write(v1l, req->resp, HTTP1_Resp);
130
131 3797
        if (sendbody) {
132 2542
                if (chunked)
133 287
                        V1L_Chunked(v1l);
134 2542
                err = VDP_DeliverObj(req->vdc, req->objcore);
135 2542
                if (!err && chunked)
136 264
                        V1L_EndChunk(v1l);
137 2542
        }
138
139 3797
        sc = V1L_Close(&v1l, &bytes);
140
141 3797
        req->acct.resp_bodybytes += VDP_Close(req->vdc, req->objcore, req->boc);
142
143 3797
        if (sc == SC_NULL && err && req->sp->fd >= 0) {
144 21
                if (req->objcore->flags & OC_F_FAILED)
145 15
                        sc = SC_TX_ERROR;
146 6
                else
147 6
                        sc = SC_REM_CLOSE;
148 21
        }
149 3797
        if (sc != SC_NULL)
150 32
                Req_Fail(req, sc);
151 3797
        return (VTR_D_DONE);
152 3797
}