67 if(
NULL == container ||
NULL == name ||
NULL == value || 0 == (len = strlen(name)))
74 if(isupper((
int) name[i]))
81 if (
NULL == (container->
name = strdup (name)))
85 if (
NULL == (container->
value = malloc(
sizeof(
char *))))
87 free(container->
name);
92 if (
NULL == (container->
value[0] = strdup (value)))
94 free(container->
value);
95 free(container->
name);
105 if(0 == strcmp(pair->
name, name))
121 if (
NULL == (pair->
name = strdup (name)))
126 if (
NULL == (pair->
value = malloc(
sizeof(
char *))))
134 if (
NULL == (pair->
value[0] = strdup (value)))
154 if(0 == strcmp(pair->
value[i], value))
157 if(strlen(pair->
value[0]) > 0)
160 if (
NULL == (temp_value = malloc((pair->
num_values + 1) *
sizeof(
char *))))
171 pair->
value = temp_value;
178 if (
NULL == (temp_string = strdup (value)))
182 free(pair->
value[0]);
183 pair->
value[0] = temp_string;
196 if(
NULL == container ||
NULL == name ||
NULL == num_values)
203 if(strcmp(name, temp->
name) == 0)
206 return (
const char *
const *)temp->
value;
225 container = container->
next;
228 free(temp->
value[i]);
245 if(
NULL == container)
270 ret = iterator(iterator_cls, temp->
name, (
const char *
const *)temp->
value, temp->
num_values);
283 free(response->
data);
304 struct SPDYF_Control_Frame *control_frame;
305 struct SPDYF_Data_Frame *data_frame;
310 || ((0 == data_size) && (
NULL != response->
rcb))
311 || ((0 < data_size) && (
NULL == response->
rcb)),
312 "either data or request->rcb must not be null");
328 head = response_to_queue;
330 if(
NULL == (data_frame = malloc(
sizeof(
struct SPDYF_Data_Frame))))
332 free(response_to_queue);
335 memset(data_frame, 0,
sizeof(
struct SPDYF_Data_Frame));
336 data_frame->control_bit = 0;
337 data_frame->stream_id = stream->
stream_id;
338 if(is_last && closestream)
343 response_to_queue->
is_data = is_data;
344 response_to_queue->
stream = stream;
347 response_to_queue->
frqcb = frqcb;
348 response_to_queue->
frqcb_cls = frqcb_cls;
349 response_to_queue->
rrcb = rrcb;
350 response_to_queue->
rrcb_cls = rrcb_cls;
352 response_to_queue->
data = data + i;
356 response_to_queue->
response = response;
358 response_to_queue->
prev = prev;
360 prev->
next = response_to_queue;
361 prev = response_to_queue;
370 response_to_queue = head;
373 free(response_to_queue);
388 if(
NULL == (data_frame = malloc(
sizeof(
struct SPDYF_Data_Frame))))
390 free(response_to_queue);
393 memset(data_frame, 0,
sizeof(
struct SPDYF_Data_Frame));
394 data_frame->control_bit = 0;
395 data_frame->stream_id = stream->
stream_id;
396 if(closestream &&
NULL == response->
rcb)
404 if(
NULL == (control_frame = malloc(
sizeof(
struct SPDYF_Control_Frame))))
406 free(response_to_queue);
409 memset(control_frame, 0,
sizeof(
struct SPDYF_Control_Frame));
410 control_frame->control_bit = 1;
420 response_to_queue->
is_data = is_data;
421 response_to_queue->
stream = stream;
422 response_to_queue->
frqcb = frqcb;
423 response_to_queue->
frqcb_cls = frqcb_cls;
424 response_to_queue->
rrcb = rrcb;
425 response_to_queue->
rrcb_cls = rrcb_cls;
426 response_to_queue->
data = data;
427 response_to_queue->
data_size = data_size;
428 response_to_queue->
response = response;
430 return response_to_queue;
443 free(response_queue->
data);
450 free(response_queue);
460 int32_t num_pairs = 0;
466 unsigned int value_offset;
472 for(j=0; j<num_containers; ++j)
474 iterator = container[j];
475 while(iterator !=
NULL)
478 size += 4 + strlen(iterator->
name);
488 size += strlen(iterator->
value[i]);
492 iterator = iterator->
next;
496 if(
NULL == (*stream = malloc(size)))
502 num_pairs = htonl(num_pairs);
503 memcpy(*stream, &num_pairs, 4);
507 for(j=0; j<num_containers; ++j)
509 iterator = container[j];
510 while(iterator !=
NULL)
512 name_size = strlen(iterator->
name);
513 temp = htonl(name_size);
514 memcpy(*stream + offset, &temp, 4);
516 strncpy(*stream + offset, iterator->
name, name_size);
519 value_offset = offset;
525 memset(*stream + offset, 0, 1);
531 strncpy(*stream + offset, iterator->
value[i], strlen(iterator->
value[i]));
532 offset += strlen(iterator->
value[i]);
535 value_size = offset - value_offset - 4;
536 value_size = htonl(value_size);
537 memcpy(*stream + value_offset, &value_size, 4);
539 iterator = iterator->
next;
558 unsigned int offset = 0;
559 unsigned int value_end_offset;
569 memcpy(&num_pairs, stream, 4);
571 num_pairs = ntohl(num_pairs);
575 for(i = 0; i < num_pairs; ++i)
578 memcpy(&name_size, stream + offset, 4);
580 name_size = ntohl(name_size);
582 if(
NULL == (name = strndup(stream + offset, name_size)))
590 memcpy(&value_size, stream + offset, 4);
592 value_size = ntohl(value_size);
593 value_end_offset = offset + value_size;
597 if(
NULL == (value = strndup(stream + offset, value_size)))
603 offset += strlen(value);
604 if(offset < value_end_offset)
617 while(offset < value_end_offset);
621 if(offset != value_end_offset)
struct SPDYF_Response_Queue * SPDYF_response_queue_create(bool is_data, void *data, size_t data_size, struct SPDY_Response *response, struct SPDYF_Stream *stream, bool closestream, SPDYF_ResponseQueueResultCallback frqcb, void *frqcb_cls, SPDY_ResponseResultCallback rrcb, void *rrcb_cls)
const char *const * SPDY_name_value_lookup(struct SPDY_NameValue *container, const char *name, int *num_values)
int SPDYF_name_value_from_stream(void *stream, size_t size, struct SPDY_NameValue **container)
int SPDY_name_value_add(struct SPDY_NameValue *container, const char *name, const char *value)
struct SPDYF_Control_Frame * control_frame
TCP connection/SPDY session handling.
int SPDYF_handler_write_data(struct SPDY_Session *session)
void SPDYF_response_queue_destroy(struct SPDYF_Response_Queue *response_queue)
int(* process_response_handler)(struct SPDY_Session *session)
internal functions and macros for the framing layer
internal and public structures – most of the structs used by the library are defined here ...
struct SPDYF_Response_Queue * prev
int SPDYF_name_value_is_empty(struct SPDY_NameValue *container)
SPDYF_ResponseQueueResultCallback frqcb
#define SPDY_MAX_SUPPORTED_FRAME_SIZE
SPDY_ResponseCallback rcb
struct SPDY_NameValue * next
int(* SPDY_NameValueIterator)(void *cls, const char *name, const char *const *value, int num_values)
void(* SPDY_ResponseResultCallback)(void *cls, struct SPDY_Response *response, struct SPDY_Request *request, enum SPDY_RESPONSE_RESULT status, bool streamopened)
void(* SPDYF_ResponseQueueResultCallback)(void *cls, struct SPDYF_Response_Queue *response_queue, enum SPDY_RESPONSE_RESULT status)
void SPDY_name_value_destroy(struct SPDY_NameValue *container)
struct SPDYF_Data_Frame * data_frame
ssize_t SPDYF_name_value_to_stream(struct SPDY_NameValue *container[], int num_containers, void **stream)
#define SPDYF_ASSERT(expr, msg)
int SPDY_name_value_iterate(struct SPDY_NameValue *container, SPDY_NameValueIterator iterator, void *iterator_cls)
struct SPDY_NameValue * prev
SPDY_ResponseResultCallback rrcb
void SPDY_destroy_response(struct SPDY_Response *response)
struct SPDYF_Response_Queue * next
struct SPDY_NameValue * SPDY_name_value_create()
int SPDYF_handler_write_syn_reply(struct SPDY_Session *session)
struct SPDYF_Stream * stream
struct SPDY_Response * response