GCOV - Varnish Cache


/*-
 * Copyright (c) 2006 Verdens Gang AS
 * Copyright (c) 2006-2011 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@phk.freebsd.dk>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 *
 * Session management
 *
 * The overall goal here is to hold as little state as possible for an
 * idle session.  This leads to various nasty-ish overloads of struct
 * sess fields, for instance ->fd being negative ->reason.
 *
 */
//lint --e{766}

#include "config.h"

#include "cache_int.h"

#include <stdio.h>
#include <stdlib.h>

#include "cache_pool.h"
#include "cache_transport.h"

#include "vsa.h"
#include "vtcp.h"
#include "vtim.h"
#include "waiter/waiter.h"

static const struct {
        const char              *type;
} sess_attr[SA_LAST] = {
#define SESS_ATTR(UC, lc, typ, len) [SA_##UC] = { #typ },
#include "tbl/sess_attr.h"
};

enum sess_close {
        SCE_NULL = 0,
#define SESS_CLOSE_C(nm, stat, err, desc) SCE_##nm,
#include "tbl/sess_close.h"
        SCE_MAX,
};

const struct stream_close SC_NULL[1] = {{
        .magic = STREAM_CLOSE_MAGIC,
        .idx = SCE_NULL,
        .is_err = 0,
        .name = "null",
        .desc = "Not Closing",
}};

#define SESS_CLOSE_C(nm, stat, err, text) \
        const struct stream_close SC_##nm[1] = {{ \
                .magic = STREAM_CLOSE_MAGIC, \
                .idx = SCE_##nm, \
                .is_err = err, \
                .name = #nm, \
                .desc = text, \
        }};
#include "tbl/sess_close.h"

static const stream_close_t sc_lookup[SCE_MAX] = {
        [SCE_NULL] = SC_NULL,
#define SESS_CLOSE_C(nm, stat, err, desc) \
        [SCE_##nm] = SC_##nm,
#include "tbl/sess_close.h"
};

/*--------------------------------------------------------------------*/

void
SES_SetTransport(struct worker *wrk, struct sess *sp, struct req *req,
    const struct transport *xp)
{

        CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
        CHECK_OBJ_NOTNULL(xp, TRANSPORT_MAGIC);
        assert(xp->number > 0);

        sp->sattr[SA_TRANSPORT] = xp->number;
        req->transport = xp;
        wrk->task->func = xp->new_session;
        wrk->task->priv = req;
}

/*--------------------------------------------------------------------*/

#define SES_NOATTR_OFFSET 0xffff

static int
ses_get_attr(const struct sess *sp, enum sess_attr a, void **dst)
{
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        assert(a < SA_LAST);
        AN(dst);

        if (sp->sattr[a] == SES_NOATTR_OFFSET) {
                *dst = NULL;
                return (-1);
        }
        *dst = WS_AtOffset(sp->ws, sp->sattr[a], 0);
        return (0);
}

static int
ses_set_attr(const struct sess *sp, enum sess_attr a, const void *src, int sz)
{
        void *dst;
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        assert(a < SA_LAST);
        AN(src);
        assert(sz > 0);

        if (sp->sattr[a] == SES_NOATTR_OFFSET)
                return (-1);
        dst = WS_AtOffset(sp->ws, sp->sattr[a], sz);
        AN(dst);
        vmemcpy(dst, src, sz);
        return (0);
}

static int
ses_res_attr(struct sess *sp, enum sess_attr a, void **dst, ssize_t *szp)
{
        unsigned o;
        ssize_t sz;

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        assert(a < SA_LAST);
        AN(dst);
        sz = *szp;
        *szp = 0;
        assert(sz >= 0);
        if (WS_ReserveSize(sp->ws, sz) == 0)
                return (0);
        o = WS_ReservationOffset(sp->ws);
        if (o >= SES_NOATTR_OFFSET) {
                WS_Release(sp->ws, 0);
                return (0);
        }
        *dst = WS_Reservation(sp->ws);
        *szp = sz;
        sp->sattr[a] = (uint16_t)o;
        WS_Release(sp->ws, sz);
        return (1);
}

#define SESS_ATTR(UP, low, typ, len)                                    \
        int                                                             \
        SES_Set_##low(const struct sess *sp, const typ *src)            \
        {                                                               \
                assert(len > 0);                                        \
                return (ses_set_attr(sp, SA_##UP, src, len));           \
        }                                                               \
                                                                        \
        int                                                             \
        SES_Get_##low(const struct sess *sp, typ **dst)                 \
        {                                                               \
                assert(len > 0);                                        \
                return (ses_get_attr(sp, SA_##UP, (void**)dst));        \
        }                                                               \
                                                                        \
        int                                                             \
        SES_Reserve_##low(struct sess *sp, typ **dst, ssize_t *sz)      \
        {                                                               \
                assert(len > 0);                                        \
                AN(sz);                                                 \
                *sz = len;                                              \
                return (ses_res_attr(sp, SA_##UP, (void**)dst, sz));    \
        }

#include "tbl/sess_attr.h"

int
SES_Set_String_Attr(struct sess *sp, enum sess_attr a, const char *src)
{
        void *q;
        ssize_t l, sz;

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        AN(src);

        assert(a <  SA_LAST);
        if (vstrcmp(sess_attr[a].type, "char"))
                WRONG("wrong sess_attr: not char");

        l = sz = vstrlen(src) + 1;
        if (! ses_res_attr(sp, a, &q, &sz))
                return (0);
        assert(l == sz);
        strcpy(q, src);
        return (1);
}

const char *
SES_Get_String_Attr(const struct sess *sp, enum sess_attr a)
{
        void *q;

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);

        assert(a <  SA_LAST);
        if (vstrcmp(sess_attr[a].type, "char"))
                WRONG("wrong sess_attr: not char");

        if (ses_get_attr(sp, a, &q) < 0)
                return (NULL);
        return (q);
}

/*--------------------------------------------------------------------*/

void
HTC_Status(enum htc_status_e e, const char **name, const char **desc)
{

        switch (e) {
#define HTC_STATUS(e, n, s, l)                          \
        case HTC_S_ ## e:                               \
                *name = s;                              \
                *desc = l;                              \
                return;
#include "tbl/htc.h"
        default:
                WRONG("HTC_Status");
        }
}

/*--------------------------------------------------------------------*/

void
HTC_RxInit(struct http_conn *htc, struct ws *ws)
{
        unsigned rollback;
        int l;

        CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
        htc->ws = ws;

        /* NB: HTTP/1 keep-alive triggers a rollback, so does the first
         * request of a session or an h2 request where the rollback is a
         * no-op in terms of workspace usage.
         */
        rollback = !strcasecmp(ws->id, "req") && htc->body_status == NULL;
        l = WS_Pipeline(htc->ws, htc->pipeline_b, htc->pipeline_e, rollback);
        xxxassert(l >= 0);

        htc->rxbuf_b = WS_Reservation(ws);
        htc->rxbuf_e = htc->rxbuf_b + l;
        htc->pipeline_b = NULL;
        htc->pipeline_e = NULL;
}

void
HTC_RxPipeline(struct http_conn *htc, char *p)
{

        CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
        assert(p >= htc->rxbuf_b);
        assert(p <= htc->rxbuf_e);
        if (p == htc->rxbuf_e) {
                htc->pipeline_b = NULL;
                htc->pipeline_e = NULL;
        } else {
                htc->pipeline_b = p;
                htc->pipeline_e = htc->rxbuf_e;
        }
}

/*----------------------------------------------------------------------
 * Receive a request/packet/whatever, with timeouts
 *
 * maxbytes is the maximum number of bytes the caller expects to need to
 * reach a complete work unit. Note that due to pipelining the actual
 * number of bytes passed to func in htc->rxbuf_b through htc->rxbuf_e may
 * be larger.
 *
 * *t1 becomes time of first non-idle rx
 * *t2 becomes time of complete rx
 * ti is when we return IDLE if nothing has arrived
 * tn is when we timeout on non-complete (total timeout)
 * td is max timeout between reads
 */

enum htc_status_e
HTC_RxStuff(struct http_conn *htc, htc_complete_f *func,
    vtim_real *t1, vtim_real *t2, vtim_real ti, vtim_real tn, vtim_dur td,
    int maxbytes)
{
        vtim_dur tmo;
        vtim_real now;
        enum htc_status_e hs;
        unsigned l, r;
        ssize_t z;

        CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
        AN(htc->rfd);
        assert(*htc->rfd > 0);
        AN(htc->rxbuf_b);
        AN(WS_Reservation(htc->ws));

        l = pdiff(htc->rxbuf_b, htc->rxbuf_e);
        r = WS_ReservationSize(htc->ws);
        assert(l <= r);

        AZ(isnan(tn) && isnan(td));
        if (t1 != NULL)
                assert(isnan(*t1));

        if (l == r) {
                /* Can't work with a zero size buffer */
                WS_ReleaseP(htc->ws, htc->rxbuf_b);
                return (HTC_S_OVERFLOW);
        }
        z = r;
        if (z < maxbytes)
                maxbytes = z;   /* Cap maxbytes at available WS */

        while (1) {
                now = VTIM_real();
                AZ(htc->pipeline_b);
                AZ(htc->pipeline_e);
                l = pdiff(htc->rxbuf_b, htc->rxbuf_e);
                assert(l <= r);

                hs = func(htc);
                if (hs == HTC_S_OVERFLOW || hs == HTC_S_JUNK) {
                        WS_ReleaseP(htc->ws, htc->rxbuf_b);
                        return (hs);
                }
                if (hs == HTC_S_COMPLETE) {
                        WS_ReleaseP(htc->ws, htc->rxbuf_e);
                        /* Got it, run with it */
                        if (t1 != NULL && isnan(*t1))
                                *t1 = now;
                        if (t2 != NULL)
                                *t2 = now;
                        return (HTC_S_COMPLETE);
                }
                if (hs == HTC_S_MORE) {
                        /* Working on it */
                        if (t1 != NULL && isnan(*t1))
                                *t1 = now;
                } else if (hs == HTC_S_EMPTY)
                        htc->rxbuf_e = htc->rxbuf_b;
                else
                        WRONG("htc_status_e");

                // htc_complete_f can not return HTC_S_EOF
                //
                // all but HTC_S_EMPTY and HTC_S_MORE have been handled

                if (hs == HTC_S_EMPTY && !isnan(ti) && (isnan(tn) || ti < tn))
                        tmo = ti - now;
                else if (isnan(tn))
                        tmo = td;
                else if (isnan(td))
                        tmo = tn - now;
                else if (td < tn - now)
                        tmo = td;
                else
                        tmo = tn - now;

                AZ(isnan(tmo));
                z = maxbytes - (htc->rxbuf_e - htc->rxbuf_b);
                if (z <= 0) {
                        /* maxbytes reached but not HTC_S_COMPLETE. Return
                         * overflow. */
                        WS_ReleaseP(htc->ws, htc->rxbuf_b);
                        return (HTC_S_OVERFLOW);
                }
                if (tmo <= 0.0)
                        tmo = 1e-3;
                z = VTCP_read(*htc->rfd, htc->rxbuf_e, z, tmo);
                if (z == 0 || z == -1) {
                        WS_ReleaseP(htc->ws, htc->rxbuf_b);
                        return (HTC_S_EOF);
                } else if (z > 0)
                        htc->rxbuf_e += z;
                else if (z == -2) {
                        WS_ReleaseP(htc->ws, htc->rxbuf_b);
                        switch (hs) {
                        case HTC_S_EMPTY:
                        case HTC_S_MORE:
                                return (hs);
                        default:
                                WRONG("htc_status_e (read timeout)");
                        }
                }
        }
}

/*--------------------------------------------------------------------
 * Get a new session, preferably by recycling an already ready one
 *
 * Layout is:
 *      struct sess
 *      workspace
 */

struct sess *
SES_New(struct pool *pp)
{
        struct sess *sp;
        unsigned sz;
        char *p, *e;

        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
        sp = MPL_Get(pp->mpl_sess, &sz);
        AN(sp);
        INIT_OBJ(sp, SESS_MAGIC);
        sp->pool = pp;
        sp->refcnt = 1;
        memset(sp->sattr, 0xff, sizeof sp->sattr);

        e = (char*)sp + sz;
        p = (char*)(sp + 1);
        p = (void*)PRNDUP(p);
        assert(p < e);
        WS_Init(sp->ws, "ses", p, e - p);

        sp->t_open = NAN;
        sp->t_idle = NAN;
        sp->timeout_idle = NAN;
        sp->timeout_linger = NAN;
        sp->send_timeout = NAN;
        sp->idle_send_timeout = NAN;
        Lck_New(&sp->mtx, lck_sess);
        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        return (sp);
}

/*--------------------------------------------------------------------
 * Handle a session (from waiter)
 */

static void v_matchproto_(waiter_handle_f)
ses_handle(struct waited *wp, enum wait_event ev, vtim_real now)
{
        struct sess *sp;
        struct pool *pp;
        struct pool_task *tp;
        const struct transport *xp;

        CHECK_OBJ_NOTNULL(wp, WAITED_MAGIC);
        CAST_OBJ_NOTNULL(sp, wp->priv1, SESS_MAGIC);
        CAST_OBJ_NOTNULL(xp, wp->priv2, TRANSPORT_MAGIC);
        assert(WS_Reservation(sp->ws) == wp);
        FINI_OBJ(wp);

        /* The WS was reserved in SES_Wait() */
        WS_Release(sp->ws, 0);

        switch (ev) {
        case WAITER_TIMEOUT:
                SES_Delete(sp, SC_RX_CLOSE_IDLE, now);
                break;
        case WAITER_REMCLOSE:
                SES_Delete(sp, SC_REM_CLOSE, now);
                break;
        case WAITER_ACTION:
                pp = sp->pool;
                CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
                /* SES_Wait() guarantees the next will not assert. */
                assert(sizeof *tp <= WS_ReserveSize(sp->ws, sizeof *tp));
                tp = WS_Reservation(sp->ws);
                tp->func = xp->unwait;
                tp->priv = sp;
                if (Pool_Task(pp, tp, TASK_QUEUE_REQ))
                        SES_Delete(sp, SC_OVERLOAD, now);
                break;
        case WAITER_CLOSE:
                WRONG("Should not see WAITER_CLOSE on client side");
                break;
        default:
                WRONG("Wrong event in ses_handle");
        }
}

/*--------------------------------------------------------------------
 */

void
SES_Wait(struct sess *sp, const struct transport *xp)
{
        struct pool *pp;
        struct waited *wp;
        unsigned u;

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        CHECK_OBJ_NOTNULL(xp, TRANSPORT_MAGIC);
        pp = sp->pool;
        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
        assert(sp->fd > 0);
        /*
         * XXX: waiter_epoll prevents us from zeroing the struct because
         * XXX: it keeps state across calls.
         */
        VTCP_nonblocking(sp->fd);

        /*
         * Put struct waited on the workspace. Make sure that the
         * workspace can hold enough space for both struct waited
         * and pool_task, as pool_task will be needed when coming
         * off the waiter again.
         */
        u = WS_ReserveAll(sp->ws);
        if (u < sizeof (struct waited) || u < sizeof(struct pool_task)) {
                WS_MarkOverflow(sp->ws);
                SES_Delete(sp, SC_OVERLOAD, NAN);
                return;
        }

        wp = WS_Reservation(sp->ws);
        INIT_OBJ(wp, WAITED_MAGIC);
        wp->fd = sp->fd;
        wp->priv1 = sp;
        wp->priv2 = xp;
        wp->idle = sp->t_idle;
        wp->func = ses_handle;
        wp->tmo = SESS_TMO(sp, timeout_idle);
        if (Wait_Enter(pp->waiter, wp))
                SES_Delete(sp, SC_PIPE_OVERFLOW, NAN);
}

/*--------------------------------------------------------------------
 * Update sc_ counters by reason
 *
 * assuming that the approximation of non-atomic global counters is sufficient.
 * if not: update to per-wrk
 */

static void
ses_close_acct(stream_close_t reason)
{

        CHECK_OBJ_NOTNULL(reason, STREAM_CLOSE_MAGIC);
        switch (reason->idx) {
#define SESS_CLOSE_C(reason, stat, err, desc)           \
        case SCE_ ## reason:                            \
                VSC_C_main->sc_ ## stat++;              \
                break;
#include "tbl/sess_close.h"

        default:
                WRONG("Wrong event in ses_close_acct");
        }
        if (reason->is_err)
                VSC_C_main->sess_closed_err++;
}

/*--------------------------------------------------------------------
 * Close a session's connection.
 * XXX: Technically speaking we should catch a t_end timestamp here
 * XXX: for SES_Delete() to use.
 */

void
SES_Close(struct sess *sp, stream_close_t reason)
{
        int i;

        CHECK_OBJ_NOTNULL(reason, STREAM_CLOSE_MAGIC);
        assert(reason->idx > 0);
        assert(sp->fd > 0);
        i = close(sp->fd);
        assert(i == 0 || errno != EBADF); /* XXX EINVAL seen */
        sp->fd = -reason->idx;
        ses_close_acct(reason);
}

/*--------------------------------------------------------------------
 * Report and dismantle a session.
 */

void
SES_Delete(struct sess *sp, stream_close_t reason, vtim_real now)
{

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        CHECK_OBJ_NOTNULL(reason, STREAM_CLOSE_MAGIC);

        if (reason != SC_NULL)
                SES_Close(sp, reason);
        assert(sp->fd < 0);

        if (isnan(now))
                now = VTIM_real();
        AZ(isnan(sp->t_open));
        if (now < sp->t_open) {
                VSL(SLT_Debug, sp->vxid,
                    "Clock step (now=%f < t_open=%f)",
                    now, sp->t_open);
                if (now + cache_param->clock_step < sp->t_open)
                        WRONG("Clock step detected");
                now = sp->t_open; /* Do not log negatives */
        }

        if (reason == SC_NULL) {
                assert(sp->fd < 0 && -sp->fd < SCE_MAX);
                reason = sc_lookup[-sp->fd];
        }

        CHECK_OBJ_NOTNULL(reason, STREAM_CLOSE_MAGIC);
        VSL(SLT_SessClose, sp->vxid, "%s %.3f", reason->name, now - sp->t_open);
        VSL(SLT_End, sp->vxid, "%s", "");
        if (WS_Overflowed(sp->ws))
                VSC_C_main->ws_session_overflow++;
        SES_Rel(sp);
}

void
SES_DeleteHS(struct sess *sp, enum htc_status_e hs, vtim_real now)
{
        stream_close_t reason;

        switch (hs) {
        case HTC_S_JUNK:
                reason = SC_RX_JUNK;
                break;
        case HTC_S_MORE:
                reason = SC_RX_TIMEOUT;
                break;
        case HTC_S_OVERFLOW:
                reason = SC_RX_OVERFLOW;
                break;
        case HTC_S_EOF:
                reason = SC_REM_CLOSE;
                break;
        default:
                WRONG("htc_status (bad)");
        }
        SES_Delete(sp, reason, now);
}


/*--------------------------------------------------------------------
 */

void
SES_Ref(struct sess *sp)
{

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        Lck_Lock(&sp->mtx);
        assert(sp->refcnt > 0);
        sp->refcnt++;
        Lck_Unlock(&sp->mtx);
}

void
SES_Rel(struct sess *sp)
{
        int i;

        CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
        CHECK_OBJ_NOTNULL(sp->pool, POOL_MAGIC);

        Lck_Lock(&sp->mtx);
        assert(sp->refcnt > 0);
        i = --sp->refcnt;
        Lck_Unlock(&sp->mtx);
        if (i)
                return;
        Lck_Delete(&sp->mtx);
#ifdef ENABLE_WORKSPACE_EMULATOR
        WS_Rollback(sp->ws, 0);
#endif
        MPL_Free(sp->pool->mpl_sess, sp);
}

/*--------------------------------------------------------------------
 * Create and delete pools
 */

void
SES_NewPool(struct pool *pp, unsigned pool_no)
{
        char nb[4 /* "sess" */ + 10 /* "%u" */ + 1];

        CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
        bprintf(nb, "req%u", pool_no);
        pp->mpl_req = MPL_New(nb, &cache_param->pool_req,
            &cache_param->workspace_client);
        bprintf(nb, "sess%u", pool_no);
        pp->mpl_sess = MPL_New(nb, &cache_param->pool_sess,
            &cache_param->workspace_session);

        bprintf(nb, "pool%u", pool_no);
        pp->waiter = Waiter_New(nb);
}

void
SES_DestroyPool(struct pool *pp)
{
        Waiter_Destroy(&pp->waiter);
        MPL_Destroy(&pp->mpl_req);
        MPL_Destroy(&pp->mpl_sess);
}

		vinyl-cache/bin/vinyld/cache/cache_session.c
0		/*-
1		* Copyright (c) 2006 Verdens Gang AS
2		* Copyright (c) 2006-2011 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		* Session management
31		*
32		* The overall goal here is to hold as little state as possible for an
33		* idle session. This leads to various nasty-ish overloads of struct
34		* sess fields, for instance ->fd being negative ->reason.
35		*
36		*/
37		//lint --e{766}
38
39		#include "config.h"
40
41		#include "cache_int.h"
42
43		#include <stdio.h>
44		#include <stdlib.h>
45
46		#include "cache_pool.h"
47		#include "cache_transport.h"
48
49		#include "vsa.h"
50		#include "vtcp.h"
51		#include "vtim.h"
52		#include "waiter/waiter.h"
53
54		static const struct {
55		const char *type;
56		} sess_attr[SA_LAST] = {
57		#define SESS_ATTR(UC, lc, typ, len) [SA_##UC] = { #typ },
58		#include "tbl/sess_attr.h"
59		};
60
61		enum sess_close {
62		SCE_NULL = 0,
63		#define SESS_CLOSE_C(nm, stat, err, desc) SCE_##nm,
64		#include "tbl/sess_close.h"
65		SCE_MAX,
66		};
67
68		const struct stream_close SC_NULL[1] = {{
69		.magic = STREAM_CLOSE_MAGIC,
70		.idx = SCE_NULL,
71		.is_err = 0,
72		.name = "null",
73		.desc = "Not Closing",
74		}};
75
76		#define SESS_CLOSE_C(nm, stat, err, text) \
77		const struct stream_close SC_##nm[1] = {{ \
78		.magic = STREAM_CLOSE_MAGIC, \
79		.idx = SCE_##nm, \
80		.is_err = err, \
81		.name = #nm, \
82		.desc = text, \
83		}};
84		#include "tbl/sess_close.h"
85
86		static const stream_close_t sc_lookup[SCE_MAX] = {
87		[SCE_NULL] = SC_NULL,
88		#define SESS_CLOSE_C(nm, stat, err, desc) \
89		[SCE_##nm] = SC_##nm,
90		#include "tbl/sess_close.h"
91		};
92
93		/--------------------------------------------------------------------/
94
95		void
96	53692	SES_SetTransport(struct worker wrk, struct sess sp, struct req *req,
97		const struct transport *xp)
98		{
99
100	53692	CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
101	53692	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
102	53692	CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
103	53692	CHECK_OBJ_NOTNULL(xp, TRANSPORT_MAGIC);
104	53692	assert(xp->number > 0);
105
106	53692	sp->sattr[SA_TRANSPORT] = xp->number;
107	53692	req->transport = xp;
108	53692	wrk->task->func = xp->new_session;
109	53692	wrk->task->priv = req;
110	53692	}
111
112		/--------------------------------------------------------------------/
113
114		#define SES_NOATTR_OFFSET 0xffff
115
116		static int
117	569014	ses_get_attr(const struct sess sp, enum sess_attr a, void *dst)
118		{
119	569014	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
120	569014	assert(a < SA_LAST);
121	569014	AN(dst);
122
123	569014	if (sp->sattr[a] == SES_NOATTR_OFFSET) {
124	48664	*dst = NULL;
125	48664	return (-1);
126		}
127	520350	*dst = WS_AtOffset(sp->ws, sp->sattr[a], 0);
128	520350	return (0);
129	569014	}
130
131		static int
132	279623	ses_set_attr(const struct sess sp, enum sess_attr a, const void src, int sz)
133		{
134		void *dst;
135	279623	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
136	279623	assert(a < SA_LAST);
137	279623	AN(src);
138	279623	assert(sz > 0);
139
140	279623	if (sp->sattr[a] == SES_NOATTR_OFFSET)
141	0	return (-1);
142	279623	dst = WS_AtOffset(sp->ws, sp->sattr[a], sz);
143	279623	AN(dst);
144	279623	vmemcpy(dst, src, sz);
145	279623	return (0);
146	279623	}
147
148		static int
149	242777	ses_res_attr(struct sess sp, enum sess_attr a, void dst, ssize_t szp)
150		{
151		unsigned o;
152		ssize_t sz;
153
154	242777	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
155	242777	assert(a < SA_LAST);
156	242777	AN(dst);
157	242777	sz = *szp;
158	242777	*szp = 0;
159	242777	assert(sz >= 0);
160	242777	if (WS_ReserveSize(sp->ws, sz) == 0)
161	21	return (0);
162	242756	o = WS_ReservationOffset(sp->ws);
163	242756	if (o >= SES_NOATTR_OFFSET) {
164	0	WS_Release(sp->ws, 0);
165	0	return (0);
166		}
167	242756	*dst = WS_Reservation(sp->ws);
168	242756	*szp = sz;
169	242756	sp->sattr[a] = (uint16_t)o;
170	242756	WS_Release(sp->ws, sz);
171	242756	return (1);
172	242777	}
173
174		#define SESS_ATTR(UP, low, typ, len) \
175		int \
176		SES_Set_##low(const struct sess sp, const typ src) \
177		{ \
178		assert(len > 0); \
179		return (ses_set_attr(sp, SA_##UP, src, len)); \
180		} \
181		\
182		int \
183		SES_Get_##low(const struct sess sp, typ *dst) \
184		{ \
185		assert(len > 0); \
186		return (ses_get_attr(sp, SA_##UP, (void**)dst)); \
187		} \
188		\
189		int \
190		SES_Reserve_##low(struct sess sp, typ dst, ssize_t sz) \
191		{ \
192		assert(len > 0); \
193		AN(sz); \
194		*sz = len; \
195		return (ses_res_attr(sp, SA_##UP, (void**)dst, sz)); \
196		}
197
198		#include "tbl/sess_attr.h"
199
200		int
201	100422	SES_Set_String_Attr(struct sess sp, enum sess_attr a, const char src)
202		{
203		void *q;
204		ssize_t l, sz;
205
206	100422	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
207	100422	AN(src);
208
209	100422	assert(a < SA_LAST);
210	100422	if (vstrcmp(sess_attr[a].type, "char"))
211	0	WRONG("wrong sess_attr: not char");
212
213	100422	l = sz = vstrlen(src) + 1;
214	100422	if (! ses_res_attr(sp, a, &q, &sz))
215	0	return (0);
216	100422	assert(l == sz);
217	100422	strcpy(q, src);
218	100422	return (1);
219	100422	}
220
221		const char *
222	177092	SES_Get_String_Attr(const struct sess *sp, enum sess_attr a)
223		{
224		void *q;
225
226	177092	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
227
228	177092	assert(a < SA_LAST);
229	177092	if (vstrcmp(sess_attr[a].type, "char"))
230	0	WRONG("wrong sess_attr: not char");
231
232	177092	if (ses_get_attr(sp, a, &q) < 0)
233	0	return (NULL);
234	177092	return (q);
235	177092	}
236
237		/--------------------------------------------------------------------/
238
239		void
240	2352	HTC_Status(enum htc_status_e e, const char name, const char desc)
241		{
242
243	2352	switch (e) {
244		#define HTC_STATUS(e, n, s, l) \
245		case HTC_S_ ## e: \
246		*name = s; \
247		*desc = l; \
248		return;
249		#include "tbl/htc.h"
250		default:
251	0	WRONG("HTC_Status");
252		}
253	2352	}
254
255		/--------------------------------------------------------------------/
256
257		void
258	188293	HTC_RxInit(struct http_conn htc, struct ws ws)
259		{
260		unsigned rollback;
261		int l;
262
263	188293	CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
264	188293	htc->ws = ws;
265
266		/* NB: HTTP/1 keep-alive triggers a rollback, so does the first
267		* request of a session or an h2 request where the rollback is a
268		* no-op in terms of workspace usage.
269		*/
270	188293	rollback = !strcasecmp(ws->id, "req") && htc->body_status == NULL;
271	188293	l = WS_Pipeline(htc->ws, htc->pipeline_b, htc->pipeline_e, rollback);
272	188293	xxxassert(l >= 0);
273
274	188293	htc->rxbuf_b = WS_Reservation(ws);
275	188293	htc->rxbuf_e = htc->rxbuf_b + l;
276	188293	htc->pipeline_b = NULL;
277	188293	htc->pipeline_e = NULL;
278	188293	}
279
280		void
281	145994	HTC_RxPipeline(struct http_conn htc, char p)
282		{
283
284	145994	CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
285	145994	assert(p >= htc->rxbuf_b);
286	145994	assert(p <= htc->rxbuf_e);
287	145994	if (p == htc->rxbuf_e) {
288	109375	htc->pipeline_b = NULL;
289	109375	htc->pipeline_e = NULL;
290	109375	} else {
291	36619	htc->pipeline_b = p;
292	36619	htc->pipeline_e = htc->rxbuf_e;
293		}
294	145994	}
295
296		/*----------------------------------------------------------------------
297		* Receive a request/packet/whatever, with timeouts
298		*
299		* maxbytes is the maximum number of bytes the caller expects to need to
300		* reach a complete work unit. Note that due to pipelining the actual
301		* number of bytes passed to func in htc->rxbuf_b through htc->rxbuf_e may
302		* be larger.
303		*
304		* *t1 becomes time of first non-idle rx
305		* *t2 becomes time of complete rx
306		* ti is when we return IDLE if nothing has arrived
307		* tn is when we timeout on non-complete (total timeout)
308		* td is max timeout between reads
309		*/
310
311		enum htc_status_e
312	188233	HTC_RxStuff(struct http_conn htc, htc_complete_f func,
313		vtim_real t1, vtim_real t2, vtim_real ti, vtim_real tn, vtim_dur td,
314		int maxbytes)
315		{
316		vtim_dur tmo;
317		vtim_real now;
318		enum htc_status_e hs;
319		unsigned l, r;
320		ssize_t z;
321
322	188233	CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
323	188233	AN(htc->rfd);
324	188233	assert(*htc->rfd > 0);
325	188233	AN(htc->rxbuf_b);
326	188233	AN(WS_Reservation(htc->ws));
327
328	188233	l = pdiff(htc->rxbuf_b, htc->rxbuf_e);
329	188233	r = WS_ReservationSize(htc->ws);
330	188233	assert(l <= r);
331
332	188233	AZ(isnan(tn) && isnan(td));
333	188233	if (t1 != NULL)
334	138752	assert(isnan(*t1));
335
336	188233	if (l == r) {
337		/* Can't work with a zero size buffer */
338	63	WS_ReleaseP(htc->ws, htc->rxbuf_b);
339	63	return (HTC_S_OVERFLOW);
340		}
341	188170	z = r;
342	188170	if (z < maxbytes)
343	2331	maxbytes = z; /* Cap maxbytes at available WS */
344
345	340931	while (1) {
346	340931	now = VTIM_real();
347	340931	AZ(htc->pipeline_b);
348	340931	AZ(htc->pipeline_e);
349	340931	l = pdiff(htc->rxbuf_b, htc->rxbuf_e);
350	340931	assert(l <= r);
351
352	340931	hs = func(htc);
353	340931	if (hs == HTC_S_OVERFLOW \|\| hs == HTC_S_JUNK) {
354	105	WS_ReleaseP(htc->ws, htc->rxbuf_b);
355	105	return (hs);
356		}
357	340826	if (hs == HTC_S_COMPLETE) {
358	146860	WS_ReleaseP(htc->ws, htc->rxbuf_e);
359		/* Got it, run with it */
360	146860	if (t1 != NULL && isnan(*t1))
361	79740	*t1 = now;
362	146860	if (t2 != NULL)
363	79674	*t2 = now;
364	146860	return (HTC_S_COMPLETE);
365		}
366	193966	if (hs == HTC_S_MORE) {
367		/* Working on it */
368	30127	if (t1 != NULL && isnan(*t1))
369	21291	*t1 = now;
370	193966	} else if (hs == HTC_S_EMPTY)
371	163839	htc->rxbuf_e = htc->rxbuf_b;
372		else
373	0	WRONG("htc_status_e");
374
375		// htc_complete_f can not return HTC_S_EOF
376		//
377		// all but HTC_S_EMPTY and HTC_S_MORE have been handled
378
379	193966	if (hs == HTC_S_EMPTY && !isnan(ti) && (isnan(tn) \|\| ti < tn))
380	163702	tmo = ti - now;
381	30264	else if (isnan(tn))
382	874	tmo = td;
383	29390	else if (isnan(td))
384	29390	tmo = tn - now;
385	0	else if (td < tn - now)
386	0	tmo = td;
387		else
388	0	tmo = tn - now;
389
390	193966	AZ(isnan(tmo));
391	193966	z = maxbytes - (htc->rxbuf_e - htc->rxbuf_b);
392	193966	if (z <= 0) {
393		/* maxbytes reached but not HTC_S_COMPLETE. Return
394		* overflow. */
395	420	WS_ReleaseP(htc->ws, htc->rxbuf_b);
396	420	return (HTC_S_OVERFLOW);
397		}
398	193546	if (tmo <= 0.0)
399	4328	tmo = 1e-3;
400	193546	z = VTCP_read(*htc->rfd, htc->rxbuf_e, z, tmo);
401	193546	if (z == 0 \|\| z == -1) {
402	35332	WS_ReleaseP(htc->ws, htc->rxbuf_b);
403	35332	return (HTC_S_EOF);
404	158214	} else if (z > 0)
405	152761	htc->rxbuf_e += z;
406	5453	else if (z == -2) {
407	5453	WS_ReleaseP(htc->ws, htc->rxbuf_b);
408	5453	switch (hs) {
409		case HTC_S_EMPTY:
410		case HTC_S_MORE:
411	5453	return (hs);
412		default:
413	0	WRONG("htc_status_e (read timeout)");
414	0	}
415	0	}
416		}
417	188233	}
418
419		/*--------------------------------------------------------------------
420		* Get a new session, preferably by recycling an already ready one
421		*
422		* Layout is:
423		* struct sess
424		* workspace
425		*/
426
427		struct sess *
428	49191	SES_New(struct pool *pp)
429		{
430		struct sess *sp;
431		unsigned sz;
432		char p, e;
433
434	49191	CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
435	49191	sp = MPL_Get(pp->mpl_sess, &sz);
436	49191	AN(sp);
437	49191	INIT_OBJ(sp, SESS_MAGIC);
438	49191	sp->pool = pp;
439	49191	sp->refcnt = 1;
440	49191	memset(sp->sattr, 0xff, sizeof sp->sattr);
441
442	49191	e = (char*)sp + sz;
443	49191	p = (char*)(sp + 1);
444	49191	p = (void*)PRNDUP(p);
445	49191	assert(p < e);
446	49191	WS_Init(sp->ws, "ses", p, e - p);
447
448	49191	sp->t_open = NAN;
449	49191	sp->t_idle = NAN;
450	49191	sp->timeout_idle = NAN;
451	49191	sp->timeout_linger = NAN;
452	49191	sp->send_timeout = NAN;
453	49191	sp->idle_send_timeout = NAN;
454	49191	Lck_New(&sp->mtx, lck_sess);
455	49191	CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
456	49191	return (sp);
457		}
458
459		/*--------------------------------------------------------------------
460		* Handle a session (from waiter)
461		*/
462
463		static void v_matchproto_(waiter_handle_f)
464	5221	ses_handle(struct waited *wp, enum wait_event ev, vtim_real now)
465		{
466		struct sess *sp;
467		struct pool *pp;
468		struct pool_task *tp;
469		const struct transport *xp;
470
471	5221	CHECK_OBJ_NOTNULL(wp, WAITED_MAGIC);
472	5221	CAST_OBJ_NOTNULL(sp, wp->priv1, SESS_MAGIC);
473	5221	CAST_OBJ_NOTNULL(xp, wp->priv2, TRANSPORT_MAGIC);
474	5221	assert(WS_Reservation(sp->ws) == wp);
475	5221	FINI_OBJ(wp);
476
477		/* The WS was reserved in SES_Wait() */
478	5221	WS_Release(sp->ws, 0);
479
480	5221	switch (ev) {
481		case WAITER_TIMEOUT:
482	420	SES_Delete(sp, SC_RX_CLOSE_IDLE, now);
483	420	break;
484		case WAITER_REMCLOSE:
485	581	SES_Delete(sp, SC_REM_CLOSE, now);
486	581	break;
487		case WAITER_ACTION:
488	4220	pp = sp->pool;
489	4220	CHECK_OBJ_NOTNULL(pp, POOL_MAGIC);
490		/* SES_Wait() guarantees the next will not assert. */
491	4220	assert(sizeof tp <= WS_ReserveSize(sp->ws, sizeof tp));
492	4220	tp = WS_Reservation(sp->ws);
493	4220	tp->func = xp->unwait;
494	4220	tp->priv = sp;
495	4220	if (Pool_Task(pp, tp, TASK_QUEUE_REQ))
496	144	SES_Delete(sp, SC_OVERLOAD, now);
497	4220	break;
498		case WAITER_CLOSE:
499	0	WRONG("Should not see WAITER_CLOSE on client side");