static int read_request(struct http_server_t *self_p,
struct http_server_connection_t *connection_p,
struct http_server_request_t *request_p)
{
int res;
char buf[128];
char *header_p;
char *value_p;
/* Read the intial line in the request. */
if (read_initial_request_line(&connection_p->socket,
buf,
request_p) != 0) {
return (-EIO);
}
memset(&request_p->headers, 0, sizeof(request_p->headers));
/* Read the header lines. */
while (1) {
res = read_header_line(&connection_p->socket,
buf,
&header_p,
&value_p);
if (res == 1) {
break;
} else if (res < 0) {
return (-EIO);
}
log_object_print(NULL, LOG_DEBUG, FSTR("%s: %s\r\n"), header_p, value_p);
/* Save the header field in the request object. */
if (strcmp(header_p, "Sec-WebSocket-Key") == 0) {
request_p->headers.sec_websocket_key.present = 1;
strncpy(request_p->headers.sec_websocket_key.value,
value_p,
sizeof(request_p->headers.sec_websocket_key.value));
} else if (strcmp(header_p, "Content-Type") == 0) {
request_p->headers.content_type.present = 1;
strncpy(request_p->headers.content_type.value,
value_p,
sizeof(request_p->headers.content_type.value));
} else if (strcmp(header_p, "Content-Length") == 0) {
if (std_strtol(value_p, &request_p->headers.content_length.value) != NULL) {
request_p->headers.content_length.present = 1;
}
} else if (strcmp(header_p, "Authorization") == 0) {
request_p->headers.authorization.present = 1;
strncpy(request_p->headers.authorization.value,
value_p,
sizeof(request_p->headers.authorization.value));
}
}
return (0);
}
int blizzard::http::parse_header_line()
{
char * key = read_header_line();
if (!key)
{
return -1;
}
if (0 == *key)
{
if (method == BLZ_METHOD_POST)
{
state_ = sReadingPost;
in_post.append_data((char*)in_headers.get_data() + in_headers.marker(), in_headers.get_data_size() - in_headers.marker());
}
else
{
state_ = sReadyToHandle;
}
return 0;
}
state_ = sDone;
while (*key == ' ') key++;
char * val = strchr(key, ':');
if (!val)
{
return 400;
}
*val++ = 0;
while (*val == ' ') val++;
if (header_items_num < MAX_HEADER_ITEMS && *key)
{
header_items[header_items_num].key = key;
header_items[header_items_num].value = val;
header_items_num++;
}
if (0 == strncasecmp(key, "content-length", 14))
{
int sz = atoi(val);
in_post.resize(sz);
}
else if (0 == strcasecmp(key, "expect") && 0 == strcasecmp(val, "100-continue")) // EVIL HACK for answering on "Expect: 100-continue"
{
const char * ret_str = "HTTP/1.1 100 Continue\r\n\r\n";
int ret_str_sz = 25; // strlen(ret_str);
ssize_t wr = write(fd, ret_str, ret_str_sz);
if (wr == -1 || wr < ret_str_sz)
{
log_warn("client didn't receive '100 Continue'");
}
}
state_ = sReadingHeaders;
return 0;
}
int blizzard::http::parse_title()
{
char * line = read_header_line();
if (!line)
{
return -1;
}
state_ = sDone;
char * mthd = line;
while (*mthd == ' ') mthd++;
char * url = strchr(mthd, ' ');
if (!url)
{
return 400;
}
while (*url == ' ') *url++ = 0;
char * version = strchr(url, ' ');
if (!version)
{
return 400;
}
while (*version == ' ') *version++ = 0;
if (strncasecmp(version, "HTTP/", 5))
{
return 400;
}
version += 5;
char * mnr = strchr(version, '.');
if (!mnr)
{
return 400;
}
char * delim = strchr(url, '?');
if (!delim)
{
delim = url - 1;
}
else
{
*delim++ = 0;
}
switch (mthd[0])
{
case 'g':
case 'G':
method = BLZ_METHOD_GET;
break;
case 'h':
case 'H':
method = BLZ_METHOD_HEAD;
break;
case 'p':
case 'P':
if (mthd[1] == 'o' || mthd[1] == 'O')
{
method = BLZ_METHOD_POST;
}
break;
default:
method = BLZ_METHOD_UNDEF;
return 501;
}
protocol_major = atoi(version);
protocol_minor = atoi(mnr + 1);
uri_path = url;
uri_params = delim;
state_ = sReadingHeaders;
return 0;
}
time_series_t *read_data(char *file, int n_var, char **var)
{
int i;
char *name;
int n_data; /* number of relevant data columns */
int *col; /* positions of relevant columns in data file */
int *index; /* corresponding indices in variable list */
int n_time; /* number of data rows */
time_series_t *ts;
/* alloc mem */
ASSIGN_NEW_MEMORY_BLOCK(ts, 1, time_series_t, NULL);
/* alloc mem for index lists */
ts->n_var = n_var;
ASSIGN_NEW_MEMORY_BLOCK(ts->var, n_var, char *, NULL);
ASSIGN_NEW_MEMORY_BLOCK(ts->data, n_var, double *, NULL);
ASSIGN_NEW_MEMORY_BLOCK(ts->data2, n_var, double *, NULL);
/* initialize index lists */
for ( i=0; i<n_var; i++ )
{
ASSIGN_NEW_MEMORY_BLOCK(name, strlen(var[i])+1, char , NULL);
strcpy(name, var[i]);
ts->var[i] = name;
ts->data[i] = NULL;
ts->data2[i] = NULL;
}
/* alloc temp mem for column info */
ASSIGN_NEW_MEMORY_BLOCK(col, n_var, int, NULL);
ASSIGN_NEW_MEMORY_BLOCK(index, n_var, int, NULL);
/* read header line */
n_data = read_header_line(file, n_var, var, col, index);
ts->n_data = n_data;
/* count number of lines */
n_time = read_columns(file, 0, NULL, NULL, NULL);
ts->n_time = n_time;
/* alloc mem for data */
for ( i=0; i<n_data; i++ )
{
ASSIGN_NEW_MEMORY_BLOCK(ts->data[index[i]], n_time, double, NULL);
ASSIGN_NEW_MEMORY_BLOCK(ts->data2[index[i]], n_time, double, NULL);
}
ASSIGN_NEW_MEMORY_BLOCK(ts->time, n_time, double, NULL);
/* read data */
read_columns(file, n_data, col, index, ts);
/* free temp mem */
free(col);
free(index);
/* initialize interpolation type */
ts->type = 3;
/* calculate second derivatives */
for ( i=0; i<n_var; i++ )
if ( ts->data[i] != NULL )
{
if ( spline(ts->n_time, ts->time, ts->data[i], ts->data2[i]) != 1 )
return NULL; /* ran out of memory during spline routine */
}
ts->last = 0;
/* alloc mem for warnings */
ASSIGN_NEW_MEMORY_BLOCK(ts->mess, 2, char *, NULL);
ASSIGN_NEW_MEMORY_BLOCK(ts->warn, 2, int, NULL);
/* initialize warnings */
ts->mess[0] = "argument out of range (left) ";
ts->mess[1] = "argument out of range (right)";
for ( i=0; i<2; i++ )
ts->warn[i] = 0;
return ts;
}
int
read_seno_dtree_file(dtree_t **out_dt,
const char *file_name)
{
uint32 n_base;
uint32 n_cd;
char tree_id[64];
float32 ent;
uint32 key, l_key, r_key, n_key = 0, *k2q = NULL;
char q_str[1024], *rem_q_str;
FILE *fp;
int i, j, n_quest;
dtree_t *dt;
bt_node_t *node;
bt_t *tree;
comp_quest_t *q;
float32 *q2ent;
*out_dt = dt = (dtree_t *)ckd_calloc(1, sizeof(dtree_t));
dt->tree = tree = bt_new();
fp = fopen(file_name, "r");
if (fp == NULL) {
E_WARN_SYSTEM("Unable to open %s for reading", file_name);
return S3_ERROR;
}
for (n_quest = 0; fgets(q_str, 1024, fp) != NULL; n_quest++);
--n_quest; /* account for header line */
dt->n_quest = n_quest;
rewind(fp);
read_header_line(&n_base, tree_id, &n_cd, fp);
for (i = 0; read_node_line(&ent, &key, &l_key, &r_key, q_str, fp) > 0; i++) {
if (n_key < l_key)
n_key = l_key;
if (n_key < r_key)
n_key = r_key;
}
++n_key;
dt->n_key = n_key;
rewind(fp);
read_header_line(&n_base, tree_id, &n_cd, fp);
E_INFO("Reading tree %s (%u base phones, %u CD phones, %u quest)\n",
tree_id, n_base, n_cd, n_quest);
dt->quest = q = (comp_quest_t *)ckd_calloc(n_quest,
sizeof(comp_quest_t));
dt->k2q = k2q = (uint32 *)ckd_calloc(n_key, sizeof(uint32));
dt->q2ent = q2ent = (float32 *)ckd_calloc(n_quest, sizeof(float32));
for (i = 0; i < n_key; i++) {
k2q[i] = NO_MAP;
}
for (i = 0; read_node_line(&ent, &key, &l_key, &r_key, q_str, fp) > 0; i++) {
if (tree->root) {
E_INFO("%u\n", key);
node = bt_find_node(tree, key);
if (node) {
/* grow left and right children */
bt_add_left(node, l_key);
bt_add_right(node, r_key);
}
else {
E_FATAL("Find node w/ key %u failed\n", key);
}
}
else {
E_INFO("root %u\n", key);
tree->root = bt_new_node(key);
bt_add_left(tree->root, l_key);
bt_add_right(tree->root, r_key);
}
k2q[key] = i;
q2ent[i] = ent;
parse_compound_q(&q[i], q_str);
}
assert(i == n_quest);
return S3_SUCCESS;
}
