uint16_t
HTTP1_DissectRequest(struct http_conn *htc, struct http *hp)
{
uint16_t retval;
const char *p;
const char *b = NULL, *e;
CHECK_OBJ_NOTNULL(htc, HTTP_CONN_MAGIC);
CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
retval = http1_splitline(hp, htc,
HTTP1_Req, cache_param->http_req_hdr_len);
if (retval != 0)
return (retval);
hp->protover = http1_proto_ver(hp);
if (hp->protover == 0)
return (400);
if (http_CountHdr(hp, H_Host) > 1)
return (400);
if (http_CountHdr(hp, H_Content_Length) > 1)
return (400);
/* RFC2616, section 5.2, point 1 */
if (!strncasecmp(hp->hd[HTTP_HDR_URL].b, "http://", 7))
b = hp->hd[HTTP_HDR_URL].b + 7;
else if (FEATURE(FEATURE_HTTPS_SCHEME) &&
!strncasecmp(hp->hd[HTTP_HDR_URL].b, "https://", 8))
b = hp->hd[HTTP_HDR_URL].b + 8;
if (b) {
e = strchr(b, '/');
if (e) {
http_Unset(hp, H_Host);
http_PrintfHeader(hp, "Host: %.*s", (int)(e - b), b);
hp->hd[HTTP_HDR_URL].b = e;
}
}
htc->body_status = http1_body_status(hp, htc, 1);
if (htc->body_status == BS_ERROR)
return (400);
p = http_GetMethod(hp);
AN(p);
if (htc->body_status == BS_EOF) {
assert(hp->protover == 10);
/* RFC1945 8.3 p32 and D.1.1 p58 */
if (!strcasecmp(p, "post") || !strcasecmp(p, "put"))
return (400);
htc->body_status = BS_NONE;
}
/* HEAD with a body is a hard error */
if (htc->body_status != BS_NONE && !strcasecmp(p, "head"))
return (400);
return (retval);
}
pan_ic(const char *func, const char *file, int line, const char *cond,
int err, enum vas_e kind)
{
const char *q;
struct req *req;
struct busyobj *bo;
AZ(pthread_mutex_lock(&panicstr_mtx)); /* Won't be released,
we're going to die
anyway */
switch(kind) {
case VAS_WRONG:
VSB_printf(pan_vsp,
"Wrong turn at %s:%d:\n%s\n", file, line, cond);
break;
case VAS_VCL:
VSB_printf(pan_vsp,
"Panic from VCL:\n %s\n", cond);
break;
case VAS_MISSING:
VSB_printf(pan_vsp,
"Missing errorhandling code in %s(), %s line %d:\n"
" Condition(%s) not true.",
func, file, line, cond);
break;
case VAS_INCOMPLETE:
VSB_printf(pan_vsp,
"Incomplete code in %s(), %s line %d:\n",
func, file, line);
break;
default:
case VAS_ASSERT:
VSB_printf(pan_vsp,
"Assert error in %s(), %s line %d:\n"
" Condition(%s) not true.\n",
func, file, line, cond);
break;
}
if (err)
VSB_printf(pan_vsp, "errno = %d (%s)\n", err, strerror(err));
q = THR_GetName();
if (q != NULL)
VSB_printf(pan_vsp, "thread = (%s)\n", q);
VSB_printf(pan_vsp, "ident = %s,%s\n",
VSB_data(vident) + 1, WAIT_GetName());
pan_backtrace();
if (!FEATURE(FEATURE_SHORT_PANIC)) {
req = THR_GetRequest();
if (req != NULL) {
pan_req(req);
VSL_Flush(req->vsl, 0);
}
bo = THR_GetBusyobj();
if (bo != NULL) {
pan_busyobj(bo);
VSL_Flush(bo->vsl, 0);
}
}
VSB_printf(pan_vsp, "\n");
VSB_bcat(pan_vsp, "", 1); /* NUL termination */
if (FEATURE(FEATURE_NO_COREDUMP))
exit(4);
else
abort();
}
void
child_main(void)
{
setbuf(stdout, NULL);
setbuf(stderr, NULL);
printf("Child starts\n");
cache_param = heritage.param;
AZ(pthread_key_create(&req_key, NULL));
AZ(pthread_key_create(&bo_key, NULL));
AZ(pthread_key_create(&name_key, NULL));
THR_SetName("cache-main");
VSM_Init(); /* First, LCK needs it. */
LCK_Init(); /* Second, locking */
Lck_New(&vxid_lock, lck_vxid);
CLI_Init();
PAN_Init();
VFP_Init();
VCL_Init();
HTTP_Init();
VBO_Init();
VBP_Init();
VBE_InitCfg();
Pool_Init();
V1P_Init();
EXP_Init();
HSH_Init(heritage.hash);
BAN_Init();
VCA_Init();
SMP_Init();
STV_open();
VMOD_Init();
BAN_Compile();
VRND_Seed();
srand48(random());
CLI_AddFuncs(debug_cmds);
/* Wait for persistent storage to load if asked to */
if (FEATURE(FEATURE_WAIT_SILO))
SMP_Ready();
CLI_Run();
BAN_Shutdown();
STV_close();
printf("Child dies\n");
}
vep_do_include(struct vep_state *vep, enum dowhat what)
{
const char *p, *q, *h;
ssize_t l;
Debug("DO_INCLUDE(%d)\n", what);
if (what == DO_ATTR) {
Debug("ATTR (%s) (%s)\n", vep->match_hit->match,
VSB_data(vep->attr_vsb));
if (vep->include_src != NULL) {
vep_error(vep,
"ESI 1.0 <esi:include> "
"has multiple src= attributes");
vep->state = VEP_TAGERROR;
VSB_delete(vep->attr_vsb);
VSB_delete(vep->include_src);
vep->attr_vsb = NULL;
vep->include_src = NULL;
return;
}
vep->include_src = vep->attr_vsb;
return;
}
assert(what == DO_TAG);
if (!vep->emptytag)
vep_warn(vep,
"ESI 1.0 <esi:include> lacks final '/'");
if (vep->include_src == NULL) {
vep_error(vep,
"ESI 1.0 <esi:include> lacks src attr");
return;
}
/*
* Strictly speaking, we ought to spit out any piled up skip before
* emitting the VEC for the include, but objectively that makes no
* difference and robs us of a chance to collapse another skip into
* this on so we don't do that.
* However, we cannot tolerate any verbatim stuff piling up.
* The mark_skip() before calling dostuff should have taken
* care of that. Make sure.
*/
assert(vep->o_wait == 0 || vep->last_mark == SKIP);
/* XXX: what if it contains NUL bytes ?? */
p = VSB_data(vep->include_src);
l = VSB_len(vep->include_src);
h = 0;
if (l > 7 && !memcmp(p, "http://", 7)) {
h = p + 7;
p = strchr(h, '/');
AN(p);
Debug("HOST <%.*s> PATH <%s>\n", (int)(p-h),h, p);
VSB_printf(vep->vsb, "%c", VEC_INCL);
VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0);
} else if (l > 8 && !memcmp(p, "https://", 8)) {
if (!FEATURE(FEATURE_ESI_IGNORE_HTTPS)) {
vep_warn(vep,
"ESI 1.0 <esi:include> with https:// ignored");
vep->state = VEP_TAGERROR;
vep->attr_vsb = NULL;
vep->include_src = NULL;
return;
}
vep_warn(vep,
"ESI 1.0 <esi:include> https:// treated as http://");
h = p + 8;
p = strchr(h, '/');
AN(p);
VSB_printf(vep->vsb, "%c", VEC_INCL);
VSB_printf(vep->vsb, "Host: %.*s%c", (int)(p-h), h, 0);
} else if (*p == '/') {
VSB_printf(vep->vsb, "%c", VEC_INCL);
VSB_printf(vep->vsb, "%c", 0);
} else {
VSB_printf(vep->vsb, "%c", VEC_INCL);
VSB_printf(vep->vsb, "%c", 0);
/* Look for the last / before a '?' */
h = NULL;
for (q = vep->url; *q && *q != '?'; q++)
if (*q == '/')
h = q;
if (h == NULL)
h = q + 1;
Debug("INCL:: [%.*s]/[%s]\n",
(int)(h - vep->url), vep->url, p);
VSB_printf(vep->vsb, "%.*s/", (int)(h - vep->url), vep->url);
}
l -= (p - VSB_data(vep->include_src));
for (q = p; *q != '\0'; ) {
if (*q == '&') {
#define R(w,f,r) \
if (q + w <= p + l && !memcmp(q, f, w)) { \
VSB_printf(vep->vsb, "%c", r); \
q += w; \
continue; \
}
R(6, "'", '\'');
R(6, """, '"');
R(4, "<", '<');
R(4, ">", '>');
R(5, "&", '&');
}
VSB_printf(vep->vsb, "%c", *q++);
}
#undef R
VSB_printf(vep->vsb, "%c", 0);
VSB_delete(vep->include_src);
vep->include_src = NULL;
}
void
VEP_Parse(struct vep_state *vep, const char *p, size_t l)
{
const char *e;
struct vep_match *vm;
int i;
CHECK_OBJ_NOTNULL(vep, VEP_MAGIC);
assert(l > 0);
if (vep->startup) {
/*
* We must force the GZIP header out as a SKIP string,
* otherwise an object starting with <esi:include would
* have its GZIP header appear after the included object
* (e000026.vtc)
*/
vep->ver_p = "";
vep->last_mark = SKIP;
vep_mark_common(vep, vep->ver_p, VERBATIM);
vep->startup = 0;
AZ(vep->hack_p);
vep->hack_p = p;
}
vep->ver_p = p;
e = p + l;
while (p < e) {
AN(vep->state);
i = e - p;
if (i > 10)
i = 10;
Debug("EP %s %d (%.*s) [%.*s]\n",
vep->state,
vep->remove,
vep->tag_i, vep->tag,
i, p);
assert(p >= vep->ver_p);
/******************************************************
* SECTION A
*/
if (vep->state == VEP_START) {
if (FEATURE(FEATURE_ESI_REMOVE_BOM) && *p == '\xeb') {
vep->match = vep_match_bom;
vep->state = VEP_MATCH;
} else
vep->state = VEP_BOM;
} else if (vep->state == VEP_BOM) {
vep_mark_skip(vep, p);
if (FEATURE(FEATURE_ESI_DISABLE_XML_CHECK))
vep->state = VEP_NEXTTAG;
else
vep->state = VEP_TESTXML;
} else if (vep->state == VEP_TESTXML) {
/*
* If the first non-whitespace char is different
* from '<' we assume this is not XML.
*/
while (p < e && vct_islws(*p))
p++;
vep_mark_verbatim(vep, p);
if (p < e && *p == '<') {
p++;
vep->state = VEP_STARTTAG;
} else if (p < e && *p == '\xeb') {
VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror,
"No ESI processing, "
"first char not '<' but BOM."
" (See feature esi_remove_bom)"
);
vep->state = VEP_NOTXML;
} else if (p < e) {
VSLb(vep->vc->wrk->vsl, SLT_ESI_xmlerror,
"No ESI processing, "
"first char not '<'."
" (See feature esi_disable_xml_check)"
);
vep->state = VEP_NOTXML;
}
} else if (vep->state == VEP_NOTXML) {
/*
* This is not recognized as XML, just skip thru
* vfp_esi_end() will handle the rest
*/
p = e;
vep_mark_verbatim(vep, p);
/******************************************************
* SECTION B
*/
} else if (vep->state == VEP_NOTMYTAG) {
if (FEATURE(FEATURE_ESI_IGNORE_OTHER_ELEMENTS)) {
p++;
vep->state = VEP_NEXTTAG;
} else {
vep->tag_i = 0;
while (p < e) {
if (*p++ == '>') {
vep->state = VEP_NEXTTAG;
break;
}
}
}
if (p == e && !vep->remove)
vep_mark_verbatim(vep, p);
} else if (vep->state == VEP_NEXTTAG) {
/*
* Hunt for start of next tag and keep an eye
* out for end of EsiCmt if armed.
*/
vep->emptytag = 0;
vep->endtag = 0;
vep->attr = NULL;
vep->dostuff = NULL;
while (p < e && *p != '<') {
if (vep->esicmt_p == NULL) {
p++;
continue;
}
if (*p != *vep->esicmt_p) {
p++;
vep->esicmt_p = vep->esicmt;
continue;
}
if (!vep->remove &&
vep->esicmt_p == vep->esicmt)
vep_mark_verbatim(vep, p);
p++;
if (*++vep->esicmt_p == '\0') {
vep->esi_found = 1;
vep->esicmt = NULL;
vep->esicmt_p = NULL;
/*
* The end of the esicmt
* should not be emitted.
* But the stuff before should
*/
vep_mark_skip(vep, p);
}
}
if (p < e) {
if (!vep->remove)
vep_mark_verbatim(vep, p);
assert(*p == '<');
p++;
vep->state = VEP_STARTTAG;
} else if (vep->esicmt_p == vep->esicmt && !vep->remove)
vep_mark_verbatim(vep, p);
/******************************************************
* SECTION C
*/
} else if (vep->state == VEP_STARTTAG) {
/*
* Start of tag, set up match table
*/
if (p < e) {
if (*p == '/') {
vep->endtag = 1;
p++;
}
vep->match = vep_match_starttag;
vep->state = VEP_MATCH;
}
} else if (vep->state == VEP_COMMENT) {
/*
* We are in a comment, find out if it is an
* ESI comment or a regular comment
*/
if (vep->esicmt == NULL)
vep->esicmt_p = vep->esicmt = "esi";
while (p < e) {
if (*p != *vep->esicmt_p) {
vep->esicmt_p = vep->esicmt = NULL;
vep->until_p = vep->until = "-->";
vep->until_s = VEP_NEXTTAG;
vep->state = VEP_UNTIL;
break;
}
p++;
if (*++vep->esicmt_p != '\0')
continue;
if (vep->remove)
vep_error(vep,
"ESI 1.0 Nested <!--esi"
" element in <esi:remove>");
vep->esicmt_p = vep->esicmt = "-->";
vep->state = VEP_NEXTTAG;
vep_mark_skip(vep, p);
break;
}
} else if (vep->state == VEP_CDATA) {
/*
* Easy: just look for the end of CDATA
*/
vep->until_p = vep->until = "]]>";
vep->until_s = VEP_NEXTTAG;
vep->state = VEP_UNTIL;
} else if (vep->state == VEP_ESITAG) {
vep->in_esi_tag = 1;
vep->esi_found = 1;
vep_mark_skip(vep, p);
vep->match = vep_match_esi;
vep->state = VEP_MATCH;
} else if (vep->state == VEP_ESIINCLUDE) {
if (vep->remove) {
vep_error(vep,
"ESI 1.0 <esi:include> element"
" nested in <esi:remove>");
vep->state = VEP_TAGERROR;
} else if (vep->endtag) {
vep_error(vep,
"ESI 1.0 </esi:include> illegal end-tag");
vep->state = VEP_TAGERROR;
} else {
vep->dostuff = vep_do_include;
vep->state = VEP_INTAG;
vep->attr = vep_match_attr_include;
}
} else if (vep->state == VEP_ESIREMOVE) {
vep->dostuff = vep_do_remove;
vep->state = VEP_INTAG;
} else if (vep->state == VEP_ESICOMMENT) {
if (vep->remove) {
vep_error(vep,
"ESI 1.0 <esi:comment> element"
" nested in <esi:remove>");
vep->state = VEP_TAGERROR;
} else if (vep->endtag) {
vep_error(vep,
"ESI 1.0 </esi:comment> illegal end-tag");
vep->state = VEP_TAGERROR;
} else {
vep->dostuff = vep_do_comment;
vep->state = VEP_INTAG;
}
} else if (vep->state == VEP_ESIBOGON) {
vep_error(vep,
"ESI 1.0 <esi:bogus> element");
vep->state = VEP_TAGERROR;
/******************************************************
* SECTION D
*/
} else if (vep->state == VEP_INTAG) {
vep->tag_i = 0;
while (p < e && vct_islws(*p) && !vep->emptytag) {
p++;
vep->canattr = 1;
}
if (p < e && *p == '/' && !vep->emptytag) {
p++;
vep->emptytag = 1;
vep->canattr = 0;
}
if (p < e && *p == '>') {
p++;
AN(vep->dostuff);
vep_mark_skip(vep, p);
vep->dostuff(vep, DO_TAG);
vep->in_esi_tag = 0;
vep->state = VEP_NEXTTAG;
} else if (p < e && vep->emptytag) {
vep_error(vep,
"XML 1.0 '>' does not follow '/' in tag");
vep->state = VEP_TAGERROR;
} else if (p < e && vep->canattr &&
vct_isxmlnamestart(*p)) {
vep->state = VEP_ATTR;
} else if (p < e) {
vep_error(vep,
"XML 1.0 Illegal attribute start char");
vep->state = VEP_TAGERROR;
}
} else if (vep->state == VEP_TAGERROR) {
while (p < e && *p != '>')
p++;
if (p < e) {
p++;
vep_mark_skip(vep, p);
vep->in_esi_tag = 0;
vep->state = VEP_NEXTTAG;
}
/******************************************************
* SECTION E
*/
} else if (vep->state == VEP_ATTR) {
AZ(vep->attr_delim);
if (vep->attr == NULL) {
p++;
AZ(vep->attr_vsb);
vep->state = VEP_SKIPATTR;
} else {
vep->match = vep->attr;
vep->state = VEP_MATCH;
}
} else if (vep->state == VEP_SKIPATTR) {
while (p < e && vct_isxmlname(*p))
p++;
if (p < e && *p == '=') {
p++;
vep->state = VEP_ATTRDELIM;
} else if (p < e && *p == '>') {
vep->state = VEP_INTAG;
} else if (p < e && *p == '/') {
vep->state = VEP_INTAG;
} else if (p < e && vct_issp(*p)) {
vep->state = VEP_INTAG;
} else if (p < e) {
vep_error(vep,
"XML 1.0 Illegal attr char");
vep->state = VEP_TAGERROR;
}
} else if (vep->state == VEP_ATTRGETVAL) {
vep->attr_vsb = VSB_new_auto();
vep->state = VEP_ATTRDELIM;
} else if (vep->state == VEP_ATTRDELIM) {
AZ(vep->attr_delim);
if (*p == '"' || *p == '\'') {
vep->attr_delim = *p++;
vep->state = VEP_ATTRVAL;
} else if (!vct_issp(*p)) {
vep->attr_delim = ' ';
vep->state = VEP_ATTRVAL;
} else {
vep_error(vep,
"XML 1.0 Illegal attribute delimiter");
vep->state = VEP_TAGERROR;
}
} else if (vep->state == VEP_ATTRVAL) {
while (p < e && *p != '>' && *p != vep->attr_delim &&
(vep->attr_delim != ' ' || !vct_issp(*p))) {
if (vep->attr_vsb != NULL)
VSB_bcat(vep->attr_vsb, p, 1);
p++;
}
if (p < e && *p == '>') {
vep_error(vep,
"XML 1.0 Missing end attribute delimiter");
vep->state = VEP_TAGERROR;
vep->attr_delim = 0;
if (vep->attr_vsb != NULL) {
AZ(VSB_finish(vep->attr_vsb));
VSB_delete(vep->attr_vsb);
vep->attr_vsb = NULL;
}
} else if (p < e) {
vep->attr_delim = 0;
p++;
vep->state = VEP_INTAG;
if (vep->attr_vsb != NULL) {
AZ(VSB_finish(vep->attr_vsb));
AN(vep->dostuff);
vep->dostuff(vep, DO_ATTR);
vep->attr_vsb = NULL;
}
}
/******************************************************
* Utility Section
*/
} else if (vep->state == VEP_MATCH) {
/*
* Match against a table
*/
vm = vep_match(vep, p, e);
vep->match_hit = vm;
if (vm != NULL) {
if (vm->match != NULL)
p += strlen(vm->match);
vep->state = *vm->state;
vep->match = NULL;
vep->tag_i = 0;
} else {
memcpy(vep->tag, p, e - p);
vep->tag_i = e - p;
vep->state = VEP_MATCHBUF;
p = e;
}
} else if (vep->state == VEP_MATCHBUF) {
/*
* Match against a table while split over input
* sections.
*/
AN(vep->match);
do {
if (*p == '>') {
for (vm = vep->match;
vm->match != NULL; vm++)
continue;
AZ(vm->match);
} else {
vep->tag[vep->tag_i++] = *p++;
vm = vep_match(vep,
vep->tag, vep->tag + vep->tag_i);
if (vm && vm->match == NULL) {
vep->tag_i--;
p--;
}
}
} while (vm == NULL && p < e);
vep->match_hit = vm;
if (vm == NULL) {
assert(p == e);
} else {
vep->state = *vm->state;
vep->match = NULL;
}
} else if (vep->state == VEP_UNTIL) {
/*
* Skip until we see magic string
*/
while (p < e) {
if (*p++ != *vep->until_p++) {
vep->until_p = vep->until;
} else if (*vep->until_p == '\0') {
vep->state = vep->until_s;
break;
}
}
if (p == e && !vep->remove)
vep_mark_verbatim(vep, p);
} else {
Debug("*** Unknown state %s\n", vep->state);
INCOMPL();
}
}
/*
* We must always mark up the storage we got, try to do so
* in the most efficient way, in particular with respect to
* minimizing and limiting use of pending.
*/
if (p == vep->ver_p)
;
else if (vep->in_esi_tag)
vep_mark_skip(vep, p);
else if (vep->remove)
vep_mark_skip(vep, p);
else
vep_mark_pending(vep, p);
}
#define FEATURE(feature_name, ...) { \
.name = feature_name, \
.channel_id = 0, \
.methods = (char *[]){__VA_ARGS__, NULL} \
}
typedef struct {
char *name, **methods;
size_t name_length;
uint64_t channel_id;
} Feature;
static Feature features[] = {
FEATURE("python",
"python_execute",
"python_execute_file",
"python_do_range",
"python_eval"),
FEATURE("clipboard",
"clipboard_get",
"clipboard_set")
};
static PMap(cstr_t) *registered_providers = NULL;
#ifdef INCLUDE_GENERATED_DECLARATIONS
# include "os/provider.c.generated.h"
#endif
pan_ic(const char *func, const char *file, int line, const char *cond,
enum vas_e kind)
{
const char *q;
struct req *req;
struct busyobj *bo;
struct sigaction sa;
int err = errno;
AZ(pthread_mutex_lock(&panicstr_mtx)); /* Won't be released,
we're going to die
anyway */
/*
* should we trigger a SIGSEGV while handling a panic, our sigsegv
* handler would hide the panic, so we need to reset the handler to
* default
*/
memset(&sa, 0, sizeof sa);
sa.sa_handler = SIG_DFL;
(void)sigaction(SIGSEGV, &sa, NULL);
/* Set SIGABRT back to default so the final abort() has the
desired effect */
(void)sigaction(SIGABRT, &sa, NULL);
switch(kind) {
case VAS_WRONG:
VSB_printf(pan_vsb,
"Wrong turn at %s:%d:\n%s\n", file, line, cond);
break;
case VAS_VCL:
VSB_printf(pan_vsb,
"Panic from VCL:\n %s\n", cond);
break;
case VAS_MISSING:
VSB_printf(pan_vsb,
"Missing errorhandling code in %s(), %s line %d:\n"
" Condition(%s) not true.",
func, file, line, cond);
break;
case VAS_INCOMPLETE:
VSB_printf(pan_vsb,
"Incomplete code in %s(), %s line %d:\n",
func, file, line);
break;
default:
case VAS_ASSERT:
VSB_printf(pan_vsb,
"Assert error in %s(), %s line %d:\n"
" Condition(%s) not true.\n",
func, file, line, cond);
break;
}
if (err)
VSB_printf(pan_vsb, "errno = %d (%s)\n", err, strerror(err));
q = THR_GetName();
if (q != NULL)
VSB_printf(pan_vsb, "thread = (%s)\n", q);
VSB_printf(pan_vsb, "version = %s\n", VCS_version);
VSB_printf(pan_vsb, "ident = %s,%s\n",
VSB_data(vident) + 1, Waiter_GetName());
pan_backtrace(pan_vsb);
if (!FEATURE(FEATURE_SHORT_PANIC)) {
req = THR_GetRequest();
if (req != NULL) {
pan_req(pan_vsb, req);
VSL_Flush(req->vsl, 0);
}
bo = THR_GetBusyobj();
if (bo != NULL) {
pan_busyobj(pan_vsb, bo);
VSL_Flush(bo->vsl, 0);
}
}
VSB_printf(pan_vsb, "\n");
VSB_bcat(pan_vsb, "", 1); /* NUL termination */
if (FEATURE(FEATURE_NO_COREDUMP))
exit(4);
else
abort();
}
//
#include "pch.h"
#include <CPUInfo.h>
static const char *processorTypeStr[] = {
"Original OEM processor"
,"Intel(R) OverDrive(R) processor"
,"Dual processor"
,"Intel(R) reserved"
};
#define FEATURE(name,description) name##_FLAG,#name,description
const FeatureFlagText FeatureInfo::featureFlagText[] = {
FEATURE( FPU ,"Floating Point Unit On-Chip. The processor contains an x87 FPU"),
FEATURE( VME ,"Virtual 8086 Mode Enhancements. Virtual 8086 mode enhancements, including CR4.VME for controlling the feature, CR4.PVI for protected mode virtual interrupts, software interrupt indirection, expansion of the TSS with the software indirection bitmap, and EFLAGS.VIF and EFLAGS.VIP flags"),
FEATURE( DE ,"Debugging Extensions. Support for I/O breakpoints, including CR4.DE for controlling the feature, and optional trapping of accesses to DR4 and DR5"),
FEATURE( PSE ,"Page Size Extension. Large pages of size 4Mbyte are supported, including CR4.PSE for controlling the feature, the defined dirty bit in PDE (Page Directory Entries), optional reserved bit trapping in CR3, PDEs, and PTEs"),
FEATURE( TSC ,"Time Stamp Counter. The RDTSC instruction is supported, including CR4.TSD for controlling privilege"),
FEATURE( MSR ,"Model Specific Registers RDMSR and WRMSR Instructions. The RDMSR and WRMSR instructions are supported. Some of the MSRs are implementation dependent"),
FEATURE( PAE ,"Physical Address Extension. Physical addresses greater than 32 bits are supported: extended page table entry formats, an extra level in the page translation tables is defined, 2 Mbyte pages are supported instead of 4 Mbyte pages if PAE bit is 1. The actual number of address bits beyond 32 is not defined, and is implementation specific"),
FEATURE( MCE ,"Machine Check Exception. Exception 18 is defined for Machine Checks, including CR4.MCE for controlling the feature. This feature does not define the model-specific implementations of machine-check error logging, reporting, and processor shutdowns. Machine Check exception handlers may have to depend on processor version to do model specific processing of the exception, or test for the presence of the Machine Check feature"),
FEATURE( CX8 ,"CMPXCHG8B Instruction. The compare-and-exchange 8 bytes (64 bits) instruction is supported (implicitly locked and atomic)"),
FEATURE( APIC ,"APIC On-Chip. The processor contains an Advanced Programmable Interrupt Controller (APIC), responding to memory mapped commands in the physical address range FFFE0000H to FFFE0FFFH (by default - some processors permit the APIC to be relocated)"),
FEATURE( SEP ,"SYSENTER and SYSEXIT Instructions. The SYSENTER and SYSEXIT and associated MSRs are supported"),
FEATURE( MTRR ,"Memory Type Range Registers. MTRRs are supported. The MTRRcap MSR contains feature bits that describe what memory types are supported, how many variable MTRRs are supported, and whether fixed MTRRs are supported"),
FEATURE( PGE ,"PTE Global Bit. The global bit in page directory entries (PDEs) and page table entries (PTEs) is supported, indicating TLB entries that are common to different processes and need not be flushed. The CR4.PGE bit controls this feature"),
FEATURE( MCA ,"Machine Check Architecture. The Machine Check Architecture, which provides a compatible mechanism for error reporting in P6 family, Pentium® 4, and Intel® Xeon® processors is supported. The MCG_CAP MSR contains feature bits describing how many banks of error reporting MSRs are supported"),
FEATURE( CMOV ,"Conditional Move Instructions. The conditional move instruction CMOV is supported. In addition, if x87 FPU is present as indicated by the CPUID.FPU feature bit, then the FCOMI and FCMOV instructions are supported"),
FEATURE( PAT ,"Page Attribute Table. Page Attribute Table is supported. This feature augments the Memory Type Range Registers (MTRRs), allowing an operating system to specify attributes of memory on a 4K granularity through a linear address"),
static void
HTTP1_Session(struct worker *wrk, struct req *req)
{
enum htc_status_e hs;
struct sess *sp;
const char *st;
int i;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
sp = req->sp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
/*
* Whenever we come in from the acceptor or waiter, we need to set
* blocking mode. It would be simpler to do this in the acceptor
* or waiter, but we'd rather do the syscall in the worker thread.
*/
if (http1_getstate(sp) == H1NEWREQ)
VTCP_blocking(sp->fd);
req->transport = &HTTP1_transport;
while (1) {
st = http1_getstate(sp);
if (st == H1NEWREQ) {
CHECK_OBJ_NOTNULL(req->transport, TRANSPORT_MAGIC);
assert(isnan(req->t_prev));
assert(isnan(req->t_req));
AZ(req->vcl);
AZ(req->esi_level);
AN(req->htc->ws->r);
hs = HTC_RxStuff(req->htc, HTTP1_Complete,
&req->t_first, &req->t_req,
sp->t_idle + cache_param->timeout_linger,
sp->t_idle + cache_param->timeout_idle,
NAN,
cache_param->http_req_size);
AZ(req->htc->ws->r);
if (hs < HTC_S_EMPTY) {
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
Req_Cleanup(sp, wrk, req);
Req_Release(req);
switch (hs) {
case HTC_S_CLOSE:
SES_Delete(sp, SC_REM_CLOSE, NAN);
return;
case HTC_S_TIMEOUT:
SES_Delete(sp, SC_RX_TIMEOUT, NAN);
return;
case HTC_S_OVERFLOW:
SES_Delete(sp, SC_RX_OVERFLOW, NAN);
return;
case HTC_S_EOF:
SES_Delete(sp, SC_REM_CLOSE, NAN);
return;
default:
WRONG("htc_status (bad)");
}
}
if (hs == HTC_S_IDLE) {
wrk->stats->sess_herd++;
Req_Cleanup(sp, wrk, req);
Req_Release(req);
SES_Wait(sp, &HTTP1_transport);
return;
}
if (hs != HTC_S_COMPLETE)
WRONG("htc_status (nonbad)");
if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
if (!FEATURE(FEATURE_HTTP2)) {
SES_Close(req->sp, SC_REQ_HTTP20);
AZ(req->ws->r);
AZ(wrk->aws->r);
http1_setstate(sp, H1CLEANUP);
continue;
}
http1_setstate(sp, NULL);
H2_PU_Sess(wrk, sp, req);
return;
}
i = http1_dissect(wrk, req);
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
if (i) {
assert(req->doclose > 0);
SES_Close(req->sp, req->doclose);
AZ(req->ws->r);
AZ(wrk->aws->r);
http1_setstate(sp, H1CLEANUP);
continue;
}
if (http_HdrIs(req->http, H_Upgrade, "h2c")) {
if (!FEATURE(FEATURE_HTTP2)) {
VSLb(req->vsl, SLT_Debug,
"H2 upgrade attempt");
} else if (req->htc->body_status != BS_NONE) {
VSLb(req->vsl, SLT_Debug,
"H2 upgrade attempt has body");
} else {
http1_setstate(sp, NULL);
req->err_code = 2;
H2_OU_Sess(wrk, sp, req);
return;
}
}
req->req_step = R_STP_TRANSPORT;
http1_setstate(sp, H1PROC);
} else if (st == H1PROC) {
req->task.func = http1_req;
req->task.priv = req;
wrk->stats->client_req++;
CNT_Embark(wrk, req);
if (req->req_step == R_STP_TRANSPORT)
VCL_TaskEnter(req->vcl, req->privs);
if (CNT_Request(req) == REQ_FSM_DISEMBARK)
return;
AZ(req->vcl0);
req->task.func = NULL;
req->task.priv = NULL;
AZ(req->ws->r);
AZ(wrk->aws->r);
http1_setstate(sp, H1CLEANUP);
} else if (st == H1CLEANUP) {
AZ(wrk->aws->r);
AZ(req->ws->r);
if (sp->fd >= 0 && req->doclose != SC_NULL)
SES_Close(sp, req->doclose);
if (sp->fd < 0) {
wrk->stats->sess_closed++;
Req_Cleanup(sp, wrk, req);
Req_Release(req);
SES_Delete(sp, SC_NULL, NAN);
return;
}
Req_Cleanup(sp, wrk, req);
HTC_RxInit(req->htc, req->ws);
if (req->htc->rxbuf_e != req->htc->rxbuf_b)
wrk->stats->sess_readahead++;
http1_setstate(sp, H1NEWREQ);
} else {
WRONG("Wrong H1 session state");
}
}
}
void
HTTP1_Session(struct worker *wrk, struct req *req)
{
enum htc_status_e hs;
struct sess *sp;
const char *st;
int i;
CHECK_OBJ_NOTNULL(wrk, WORKER_MAGIC);
CHECK_OBJ_NOTNULL(req, REQ_MAGIC);
sp = req->sp;
CHECK_OBJ_NOTNULL(sp, SESS_MAGIC);
/*
* Whenever we come in from the acceptor or waiter, we need to set
* blocking mode. It would be simpler to do this in the acceptor
* or waiter, but we'd rather do the syscall in the worker thread.
* On systems which return errors for ioctl, we close early
*/
if (http1_getstate(sp) == H1NEWREQ && VTCP_blocking(sp->fd)) {
if (errno == ECONNRESET)
SES_Close(sp, SC_REM_CLOSE);
else
SES_Close(sp, SC_TX_ERROR);
AN(Req_Cleanup(sp, wrk, req));
return;
}
while (1) {
st = http1_getstate(sp);
if (st == H1NEWREQ) {
assert(isnan(req->t_prev));
assert(isnan(req->t_req));
AZ(req->vcl);
AZ(req->esi_level);
hs = HTC_RxStuff(req->htc, HTTP1_Complete,
&req->t_first, &req->t_req,
sp->t_idle + cache_param->timeout_linger,
sp->t_idle + cache_param->timeout_idle,
cache_param->http_req_size);
XXXAZ(req->htc->ws->r);
if (hs < HTC_S_EMPTY) {
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
CNT_AcctLogCharge(wrk->stats, req);
Req_Release(req);
switch(hs) {
case HTC_S_CLOSE:
SES_Delete(sp, SC_REM_CLOSE, NAN);
return;
case HTC_S_TIMEOUT:
SES_Delete(sp, SC_RX_TIMEOUT, NAN);
return;
case HTC_S_OVERFLOW:
SES_Delete(sp, SC_RX_OVERFLOW, NAN);
return;
case HTC_S_EOF:
SES_Delete(sp, SC_REM_CLOSE, NAN);
return;
default:
WRONG("htc_status (bad)");
}
}
if (hs == HTC_S_IDLE) {
wrk->stats->sess_herd++;
Req_Release(req);
SES_Wait(sp, &HTTP1_transport);
return;
}
if (hs != HTC_S_COMPLETE)
WRONG("htc_status (nonbad)");
if (H2_prism_complete(req->htc) == HTC_S_COMPLETE) {
if (!FEATURE(FEATURE_HTTP2)) {
VSLb(req->vsl, SLT_Debug,
"H2 attempt");
SES_Close(req->sp, req->doclose);
http1_setstate(sp, H1CLEANUP);
continue;
}
VSLb(req->vsl, SLT_Debug,
"H2 Prior Knowledge Upgrade");
http1_setstate(sp, NULL);
req->err_code = 1;
SES_SetTransport(wrk, sp, req, &H2_transport);
return;
}
i = http1_dissect(wrk, req);
req->acct.req_hdrbytes +=
req->htc->rxbuf_e - req->htc->rxbuf_b;
if (i) {
SES_Close(req->sp, req->doclose);
http1_setstate(sp, H1CLEANUP);
continue;
}
if (req->htc->body_status == BS_NONE && /* XXX */
http_HdrIs(req->http, H_Upgrade, "h2c")) {
if (!FEATURE(FEATURE_HTTP2)) {
VSLb(req->vsl, SLT_Debug,
"H2 upgrade attempt");
SES_Close(req->sp, req->doclose);
http1_setstate(sp, H1CLEANUP);
continue;
}
VSLb(req->vsl, SLT_Debug,
"H2 Upgrade");
http1_setstate(sp, NULL);
req->err_code = 2;
SES_SetTransport(wrk, sp, req, &H2_transport);
return;
}
req->req_step = R_STP_RECV;
http1_setstate(sp, H1PROC);
} else if (st == H1BUSY) {
/*
* Return from waitinglist.
* Check to see if the remote has left.
*/
if (VTCP_check_hup(sp->fd)) {
AN(req->hash_objhead);
(void)HSH_DerefObjHead(wrk, &req->hash_objhead);
AZ(req->hash_objhead);
SES_Close(sp, SC_REM_CLOSE);
AN(Req_Cleanup(sp, wrk, req));
return;
}
http1_setstate(sp, H1PROC);
} else if (st == H1PROC) {
req->transport = &HTTP1_transport;
req->task.func = http1_req;
req->task.priv = req;
if (CNT_Request(wrk, req) == REQ_FSM_DISEMBARK)
return;
req->transport = NULL;
req->task.func = NULL;
req->task.priv = NULL;
http1_setstate(sp, H1CLEANUP);
} else if (st == H1CLEANUP) {
if (Req_Cleanup(sp, wrk, req))
return;
HTC_RxInit(req->htc, req->ws);
if (req->htc->rxbuf_e != req->htc->rxbuf_b)
wrk->stats->sess_readahead++;
http1_setstate(sp, H1NEWREQ);
} else {
WRONG("Wrong H1 session state");
}
}
}
