static void
cmd_http_gunzip_body(CMD_ARGS)
{
int i;
z_stream vz;
struct http *hp;
char *p;
unsigned l;
(void)av;
(void)cmd;
(void)vl;
CAST_OBJ_NOTNULL(hp, priv, HTTP_MAGIC);
memset(&vz, 0, sizeof vz);
AN(hp->body);
if (hp->body[0] != (char)0x1f || hp->body[1] != (char)0x8b)
vtc_log(hp->vl, hp->fatal,
"Gunzip error: Body lacks gzip magics");
vz.next_in = TRUST_ME(hp->body);
vz.avail_in = hp->bodyl;
l = hp->bodyl * 10;
p = calloc(l, 1);
AN(p);
vz.next_out = TRUST_ME(p);
vz.avail_out = l;
assert(Z_OK == inflateInit2(&vz, 31));
i = inflate(&vz, Z_FINISH);
assert(vz.total_out < l);
hp->bodyl = vz.total_out;
memcpy(hp->body, p, hp->bodyl);
free(p);
vtc_log(hp->vl, 3, "new bodylen %u", hp->bodyl);
vtc_dump(hp->vl, 4, "body", hp->body, hp->bodyl);
bprintf(hp->bodylen, "%u", hp->bodyl);
vtc_log(hp->vl, 4, "startbit = %ju %ju/%ju",
(uintmax_t)vz.start_bit,
(uintmax_t)vz.start_bit >> 3, (uintmax_t)vz.start_bit & 7);
vtc_log(hp->vl, 4, "lastbit = %ju %ju/%ju",
(uintmax_t)vz.last_bit,
(uintmax_t)vz.last_bit >> 3, (uintmax_t)vz.last_bit & 7);
vtc_log(hp->vl, 4, "stopbit = %ju %ju/%ju",
(uintmax_t)vz.stop_bit,
(uintmax_t)vz.stop_bit >> 3, (uintmax_t)vz.stop_bit & 7);
if (i != Z_STREAM_END)
vtc_log(hp->vl, hp->fatal,
"Gunzip error = %d (%s) in:%jd out:%jd",
i, vz.msg, (intmax_t)vz.total_in, (intmax_t)vz.total_out);
assert(Z_OK == inflateEnd(&vz));
hp->body[hp->bodyl] = '\0';
}
size_t
V1L_Write(const struct worker *wrk, const void *ptr, ssize_t len)
{
struct v1l *v1l;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
v1l = wrk->v1l;
CHECK_OBJ_NOTNULL(v1l, V1L_MAGIC);
AN(v1l->wfd);
if (len == 0 || *v1l->wfd < 0)
return (0);
if (len == -1)
len = strlen(ptr);
if (v1l->niov >= v1l->siov - (v1l->ciov < v1l->siov ? 1 : 0))
(void)V1L_Flush(wrk);
v1l->iov[v1l->niov].iov_base = TRUST_ME(ptr);
v1l->iov[v1l->niov].iov_len = len;
v1l->liov += len;
v1l->niov++;
if (v1l->ciov < v1l->siov) {
assert(v1l->niov < v1l->siov);
v1l->cliov += len;
}
return (len);
}
static void
wsl(struct vsl_log *vsl, enum VSL_tag_e tag, int id, const char *fmt,
va_list ap)
{
char *p;
unsigned n, mlen;
txt t;
AN(fmt);
mlen = cache_param->shm_reclen;
if (strchr(fmt, '%') == NULL) {
t.b = TRUST_ME(fmt);
t.e = strchr(t.b, '\0');
wslr(vsl, tag, id, t);
} else {
assert(vsl->wlp < vsl->wle);
/* Wrap if we cannot fit a full size record */
if (VSL_END(vsl->wlp, mlen) >= vsl->wle)
VSL_Flush(vsl, 1);
p = VSL_DATA(vsl->wlp);
n = vsnprintf(p, mlen, fmt, ap);
if (n > mlen)
n = mlen; /* we truncate long fields */
vsl_hdr(tag, vsl->wlp, n, id);
vsl->wlp = VSL_END(vsl->wlp, n);
assert(vsl->wlp < vsl->wle);
vsl->wlr++;
}
if (cache_param->diag_bitmap & 0x10000)
VSL_Flush(vsl, 0);
}
unsigned
WRW_Write(const struct worker *wrk, const void *ptr, int len)
{
struct wrw *wrw;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
wrw = wrk->wrw;
CHECK_OBJ_NOTNULL(wrw, WRW_MAGIC);
AN(wrw->wfd);
if (len == 0 || *wrw->wfd < 0)
return (0);
if (len == -1)
len = strlen(ptr);
if (wrw->niov >= wrw->siov - (wrw->ciov < wrw->siov ? 1 : 0))
(void)WRW_Flush(wrk);
wrw->iov[wrw->niov].iov_base = TRUST_ME(ptr);
wrw->iov[wrw->niov].iov_len = len;
wrw->liov += len;
wrw->niov++;
if (wrw->ciov < wrw->siov) {
assert(wrw->niov < wrw->siov);
wrw->cliov += len;
}
return (len);
}
void
VGZ_Obuf(struct vgz *vg, void *ptr, ssize_t len)
{
CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
vg->vz.next_out = TRUST_ME(ptr);
vg->vz.avail_out = len;
}
uint16_t
http_DissectResponse(struct worker *w, const struct http_conn *htc,
struct http *hp)
{
int j;
uint16_t retval = 0;
char *p;
CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
hp->logtag = HTTP_Rx;
if (http_splitline(w, htc->fd, hp, htc,
HTTP_HDR_PROTO, HTTP_HDR_STATUS, HTTP_HDR_RESPONSE))
retval = 503;
if (retval == 0 && memcmp(hp->hd[HTTP_HDR_PROTO].b, "HTTP/1.", 7))
retval = 503;
if (retval == 0 && Tlen(hp->hd[HTTP_HDR_STATUS]) != 3)
retval = 503;
if (retval == 0) {
hp->status = 0;
p = hp->hd[HTTP_HDR_STATUS].b;
for (j = 100; j != 0; j /= 10) {
if (!vct_isdigit(*p)) {
retval = 503;
break;
}
hp->status += (uint16_t)(j * (*p - '0'));
p++;
}
if (*p != '\0')
retval = 503;
}
if (retval != 0) {
WSLR(w, SLT_HttpGarbage, htc->fd, htc->rxbuf);
assert(retval >= 100 && retval <= 999);
hp->status = retval;
} else {
http_ProtoVer(hp);
}
if (hp->hd[HTTP_HDR_RESPONSE].b == NULL ||
!Tlen(hp->hd[HTTP_HDR_RESPONSE])) {
/* Backend didn't send a response string, use the standard */
hp->hd[HTTP_HDR_RESPONSE].b =
TRUST_ME(http_StatusMessage(hp->status));
hp->hd[HTTP_HDR_RESPONSE].e =
strchr(hp->hd[HTTP_HDR_RESPONSE].b, '\0');
}
return (retval);
}
void
VGZ_Ibuf(struct vgz *vg, const void *ptr, ssize_t len)
{
CHECK_OBJ_NOTNULL(vg, VGZ_MAGIC);
AZ(vg->vz.avail_in);
vg->vz.next_in = TRUST_ME(ptr);
vg->vz.avail_in = len;
}
void
http_SetH(const struct http *to, unsigned n, const char *fm)
{
assert(n < to->shd);
AN(fm);
to->hd[n].b = TRUST_ME(fm);
to->hd[n].e = strchr(to->hd[n].b, '\0');
to->hdf[n] = 0;
}
static void
vws_pass(void *priv, const struct sess *sp)
{
int r;
struct vws *vws;
CAST_OBJ_NOTNULL(vws, priv, VWS_MAGIC);
while((r = port_send(vws->dport, 0, TRUST_ME(sp))) == -1 &&
errno == EAGAIN);
AZ(r);
}
static int
vws_enter(void *priv, struct waited *wp)
{
int r;
struct vws *vws;
CAST_OBJ_NOTNULL(vws, priv, VWS_MAGIC);
r = port_send(vws->dport, 0, TRUST_ME(wp));
if (r == -1 && errno == EAGAIN)
return (-1);
AZ(r);
return (0);
}
static void
vca_ports_pass(struct sess *sp)
{
int r;
r = port_send(solaris_dport, 0, TRUST_ME(sp));
if (r == -1 && errno == EAGAIN) {
VSC_C_main->sess_pipe_overflow++;
vca_close_session(sp, "session pipe overflow");
SES_Delete(sp);
return;
}
AZ(r);
}
static void
gzip_body(const struct http *hp, const char *txt, char **body, int *bodylen)
{
int l, i;
z_stream vz;
memset(&vz, 0, sizeof vz);
l = strlen(txt);
*body = calloc(l + OVERHEAD, 1);
AN(*body);
vz.next_in = TRUST_ME(txt);
vz.avail_in = l;
vz.next_out = TRUST_ME(*body);
vz.avail_out = l + OVERHEAD;
assert(Z_OK == deflateInit2(&vz,
hp->gziplevel, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY));
assert(Z_STREAM_END == deflate(&vz, Z_FINISH));
i = vz.stop_bit & 7;
if (hp->gzipresidual >= 0 && hp->gzipresidual != i)
vtc_log(hp->vl, hp->fatal,
"Wrong gzip residual got %d wanted %d",
i, hp->gzipresidual);
*bodylen = vz.total_out;
vtc_log(hp->vl, 4, "startbit = %ju %ju/%ju",
(uintmax_t)vz.start_bit,
(uintmax_t)vz.start_bit >> 3, (uintmax_t)vz.start_bit & 7);
vtc_log(hp->vl, 4, "lastbit = %ju %ju/%ju",
(uintmax_t)vz.last_bit,
(uintmax_t)vz.last_bit >> 3, (uintmax_t)vz.last_bit & 7);
vtc_log(hp->vl, 4, "stopbit = %ju %ju/%ju",
(uintmax_t)vz.stop_bit,
(uintmax_t)vz.stop_bit >> 3, (uintmax_t)vz.stop_bit & 7);
assert(Z_OK == deflateEnd(&vz));
}
void
xxx(void)
{
z_stream vz;
int n;
char ibuf[200];
char obuf[200];
int fl[8];
int i, j;
for (n = 0; n < 8; n++)
fl[n] = 9999;
memset(&vz, 0, sizeof vz);
for(n = 0; n < 999999999; n++) {
*ibuf = 0;
for (j = 0; j < 7; j++) {
sprintf(strchr(ibuf, 0), "%x",
(unsigned)random() & 0xffff);
vz.next_in = TRUST_ME(ibuf);
vz.avail_in = strlen(ibuf);
vz.next_out = TRUST_ME(obuf);
vz.avail_out = sizeof obuf;
assert(Z_OK == deflateInit2(&vz,
9, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY));
assert(Z_STREAM_END == deflate(&vz, Z_FINISH));
i = vz.stop_bit & 7;
if (fl[i] > strlen(ibuf)) {
printf("%d %jd <%s>\n", i, vz.stop_bit, ibuf);
fl[i] = strlen(ibuf);
}
assert(Z_OK == deflateEnd(&vz));
}
}
printf("FOO\n");
}
int
tweak_string(struct vsb *vsb, const struct parspec *par, const char *arg)
{
char **p = TRUST_ME(par->priv);
AN(p);
/* XXX should have tweak_generic_string */
if (arg == NULL) {
VSB_quote(vsb, *p, -1, 0);
} else {
REPLACE(*p, arg);
}
return (0);
}
uint16_t
HTTP1_DissectResponse(struct http *hp, const struct http_conn *htc)
{
uint16_t retval = 0;
char *p;
CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
if (htc_splitline(hp, htc, 0))
retval = 503;
if (retval == 0 && memcmp(hp->hd[HTTP_HDR_PROTO].b, "HTTP/1.", 7))
retval = 503;
if (retval == 0 && Tlen(hp->hd[HTTP_HDR_STATUS]) != 3)
retval = 503;
if (retval == 0) {
p = hp->hd[HTTP_HDR_STATUS].b;
if (p[0] >= '1' && p[0] <= '9' &&
p[1] >= '0' && p[1] <= '9' &&
p[2] >= '0' && p[2] <= '9')
hp->status =
100 * (p[0] - '0') + 10 * (p[1] - '0') + p[2] - '0';
else
retval = 503;
}
if (retval != 0) {
VSLbt(hp->vsl, SLT_HttpGarbage, htc->rxbuf);
assert(retval >= 100 && retval <= 999);
hp->status = retval;
} else
htc_proto_ver(hp);
if (hp->hd[HTTP_HDR_RESPONSE].b == NULL ||
!Tlen(hp->hd[HTTP_HDR_RESPONSE])) {
/* Backend didn't send a response string, use the standard */
hp->hd[HTTP_HDR_RESPONSE].b =
TRUST_ME(http_StatusMessage(hp->status));
hp->hd[HTTP_HDR_RESPONSE].e =
strchr(hp->hd[HTTP_HDR_RESPONSE].b, '\0');
}
return (retval);
}
unsigned
WRW_Write(struct sess *sp, const void *ptr, int len)
{
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
AN(sp->wrkvar.wfd);
if (len == 0 || *sp->wrkvar.wfd < 0)
return (0);
if (len == -1)
len = strlen(ptr);
if (sp->wrkvar.niov == sp->wrkvar.siov)
assert(0 == 1);
assert(len > 0);
sp->wrkvar.iov[sp->wrkvar.niov].iov_base = TRUST_ME(ptr);
sp->wrkvar.iov[sp->wrkvar.niov].iov_len = len;
sp->wrkvar.liov += len;
sp->wrkvar.niov++;
return (len);
}
static void
wrw_IOVReorder(struct sess *sp, ssize_t written)
{
struct iovec iov[IOV_MAX];
char *ptr;
ssize_t offset = 0, diff, liov_new;
unsigned i, j, niov_new;
/* XXX need better algorithm that the current has three nasty loops */
for (i = 0; i < sp->wrkvar.niov; i++) {
if (sp->wrkvar.iov[i].iov_len + offset > written)
break;
offset += sp->wrkvar.iov[i].iov_len;
}
liov_new = 0;
niov_new = sp->wrkvar.niov - i;
for (j = 0; j < niov_new; i++, j++) {
if (j == 0) {
ptr = sp->wrkvar.iov[i].iov_base;
diff = written - offset;
iov[j].iov_base = TRUST_ME(ptr + diff);
iov[j].iov_len = sp->wrkvar.iov[i].iov_len - diff;
assert((ssize_t)iov[j].iov_len > 0);
} else {
iov[j].iov_base = sp->wrkvar.iov[i].iov_base;
iov[j].iov_len = sp->wrkvar.iov[i].iov_len;
}
liov_new += iov[j].iov_len;
}
sp->wrkvar.liov = liov_new;
sp->wrkvar.niov = niov_new;
for (i = 0 ; i < niov_new; i++) {
sp->wrkvar.iov[i].iov_base = iov[i].iov_base;
sp->wrkvar.iov[i].iov_len = iov[i].iov_len;
assert((ssize_t)sp->wrkvar.iov[i].iov_len > 0);
}
}
unsigned
WRW_Write(struct worker *w, const void *ptr, int len)
{
struct wrw *wrw;
CHECK_OBJ_NOTNULL(w, WORKER_MAGIC);
wrw = &w->wrw;
AN(wrw->wfd);
if (len == 0 || *wrw->wfd < 0)
return (0);
if (len == -1)
len = strlen(ptr);
if (wrw->niov == wrw->siov + (wrw->ciov < wrw->siov ? 1 : 0))
(void)WRW_Flush(w);
wrw->iov[wrw->niov].iov_base = TRUST_ME(ptr);
wrw->iov[wrw->niov].iov_len = len;
wrw->liov += len;
if (wrw->ciov < wrw->siov)
wrw->cliov += len;
wrw->niov++;
return (len);
}
