00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00026 #include "platform.h"
00027 #include "structures.h"
00028 #include "internal.h"
00029 #include "session.h"
00030
00031 #include <ctype.h>
00032
00033
00034 int
00035 SPDYF_name_value_is_empty(struct SPDY_NameValue *container)
00036 {
00037 SPDYF_ASSERT(NULL != container, "NULL is not an empty container!");
00038 return (NULL == container->name && NULL == container->value) ? SPDY_YES : SPDY_NO;
00039 }
00040
00041 struct SPDY_NameValue *
00042 SPDY_name_value_create ()
00043 {
00044 struct SPDY_NameValue *pair;
00045
00046 if(NULL == (pair = malloc(sizeof(struct SPDY_NameValue))))
00047 return NULL;
00048
00049 memset (pair, 0, sizeof (struct SPDY_NameValue));
00050
00051 return pair;
00052 }
00053
00054
00055 int
00056 SPDY_name_value_add (struct SPDY_NameValue *container,
00057 const char *name,
00058 const char *value)
00059 {
00060 unsigned int i;
00061 unsigned int len;
00062 struct SPDY_NameValue *pair;
00063 struct SPDY_NameValue *temp;
00064 char **temp_value;
00065 char *temp_string;
00066
00067 if(NULL == container || NULL == name || 0 == (len = strlen(name)))
00068 return SPDY_INPUT_ERROR;
00069
00070 for(i=0; i<len; ++i)
00071 {
00072 if(isupper((int) name[i]))
00073 return SPDY_INPUT_ERROR;
00074 }
00075
00076 if(SPDYF_name_value_is_empty(container))
00077 {
00078
00079 if (NULL == (container->name = strdup (name)))
00080 {
00081 return SPDY_NO;
00082 }
00083 if (NULL == (container->value = malloc(sizeof(char *))))
00084 {
00085 free(container->name);
00086 return SPDY_NO;
00087 }
00088 if (NULL == (container->value[0] = strdup (value)))
00089 {
00090 free(container->value);
00091 free(container->name);
00092 return SPDY_NO;
00093 }
00094 container->num_values = 1;
00095 return SPDY_YES;
00096 }
00097
00098 pair = container;
00099 while(NULL != pair)
00100 {
00101 if(0 == strcmp(pair->name, name))
00102 {
00103
00104 break;
00105 }
00106 pair = pair->next;
00107 }
00108
00109 if(NULL == pair)
00110 {
00111
00112 if(NULL == (pair = malloc(sizeof(struct SPDY_NameValue))))
00113 return SPDY_NO;
00114
00115 memset(pair, 0, sizeof(struct SPDY_NameValue));
00116
00117 if (NULL == (pair->name = strdup (name)))
00118 {
00119 free(pair);
00120 return SPDY_NO;
00121 }
00122 if (NULL == (pair->value = malloc(sizeof(char *))))
00123 {
00124 free(pair->name);
00125 free(pair);
00126 return SPDY_NO;
00127 }
00128 if (NULL == (pair->value[0] = strdup (value)))
00129 {
00130 free(pair->value);
00131 free(pair->name);
00132 free(pair);
00133 return SPDY_NO;
00134 }
00135 pair->num_values = 1;
00136
00137 temp = container;
00138 while(NULL != temp->next)
00139 temp = temp->next;
00140 temp->next = pair;
00141 pair->prev = temp;
00142
00143 return SPDY_YES;
00144 }
00145
00146
00147 for(i=0; i<pair->num_values; ++i)
00148 if(0 == strcmp(pair->value[i], value))
00149 return SPDY_NO;
00150
00151 if(strlen(pair->value[0]) > 0)
00152 {
00153
00154 if (NULL == (temp_value = malloc((pair->num_values + 1) * sizeof(char *))))
00155 {
00156 return SPDY_NO;
00157 }
00158 memcpy(temp_value, pair->value, pair->num_values * sizeof(char *));
00159 if (NULL == (temp_value[pair->num_values] = strdup (value)))
00160 {
00161 free(temp_value);
00162 return SPDY_NO;
00163 }
00164 free(pair->value);
00165 pair->value = temp_value;
00166 ++pair->num_values;
00167 return SPDY_YES;
00168 }
00169
00170
00171
00172 if (NULL == (temp_string = strdup (value)))
00173 {
00174 return SPDY_NO;
00175 }
00176 free(pair->value[0]);
00177 pair->value[0] = temp_string;
00178
00179 return SPDY_YES;
00180 }
00181
00182
00183 const char * const *
00184 SPDY_name_value_lookup (struct SPDY_NameValue *container,
00185 const char *name,
00186 int *num_values)
00187 {
00188 struct SPDY_NameValue *temp = container;
00189
00190 if(NULL == container || NULL == name || NULL == num_values)
00191 return NULL;
00192 if(SPDYF_name_value_is_empty(container))
00193 return NULL;
00194
00195 do
00196 {
00197 if(strcmp(name, temp->name) == 0)
00198 {
00199 *num_values = temp->num_values;
00200 return (const char * const *)temp->value;
00201 }
00202
00203 temp = temp->next;
00204 }
00205 while(NULL != temp);
00206
00207 return NULL;
00208 }
00209
00210
00211 void
00212 SPDY_name_value_destroy (struct SPDY_NameValue *container)
00213 {
00214 unsigned int i;
00215 struct SPDY_NameValue *temp = container;
00216
00217 while(NULL != temp)
00218 {
00219 container = container->next;
00220 free(temp->name);
00221 for(i=0; i<temp->num_values; ++i)
00222 free(temp->value[i]);
00223 free(temp->value);
00224 free(temp);
00225 temp=container;
00226 }
00227 }
00228
00229
00230 int
00231 SPDY_name_value_iterate (struct SPDY_NameValue *container,
00232 SPDY_NameValueIterator iterator,
00233 void *iterator_cls)
00234 {
00235 int count;
00236 int ret;
00237 struct SPDY_NameValue *temp = container;
00238
00239 if(NULL == container)
00240 return SPDY_INPUT_ERROR;
00241
00242
00243 if(SPDYF_name_value_is_empty(container))
00244 return 0;
00245
00246 count = 0;
00247
00248 if(NULL == iterator)
00249 {
00250 do
00251 {
00252 ++count;
00253 temp=temp->next;
00254 }
00255 while(NULL != temp);
00256
00257 return count;
00258 }
00259
00260
00261 do
00262 {
00263 ++count;
00264 ret = iterator(iterator_cls, temp->name, (const char * const *)temp->value, temp->num_values);
00265 temp=temp->next;
00266 }
00267 while(NULL != temp && SPDY_YES == ret);
00268
00269 return count;
00270 }
00271
00272 void
00273 SPDY_destroy_response(struct SPDY_Response *response)
00274 {
00275 if(NULL == response)
00276 return;
00277 free(response->data);
00278 free(response->headers);
00279 free(response);
00280 }
00281
00282
00283 struct SPDYF_Response_Queue *
00284 SPDYF_response_queue_create(bool is_data,
00285 void *data,
00286 size_t data_size,
00287 struct SPDY_Response *response,
00288 struct SPDYF_Stream *stream,
00289 bool closestream,
00290 SPDYF_ResponseQueueResultCallback frqcb,
00291 void *frqcb_cls,
00292 SPDY_ResponseResultCallback rrcb,
00293 void *rrcb_cls)
00294 {
00295 struct SPDYF_Response_Queue *head = NULL;
00296 struct SPDYF_Response_Queue *prev;
00297 struct SPDYF_Response_Queue *response_to_queue;
00298 struct SPDYF_Control_Frame *control_frame;
00299 struct SPDYF_Data_Frame *data_frame;
00300 unsigned int i;
00301 bool is_last;
00302
00303 SPDYF_ASSERT((! is_data)
00304 || ((0 == data_size) && (NULL != response->rcb))
00305 || ((0 < data_size) && (NULL == response->rcb)),
00306 "either data or request->rcb must not be null");
00307
00308 if (is_data && (data_size > SPDY_MAX_SUPPORTED_FRAME_SIZE))
00309 {
00310
00311
00312 prev=NULL;
00313 for(i = 0; i < data_size; i += SPDY_MAX_SUPPORTED_FRAME_SIZE)
00314 {
00315 is_last = (i + SPDY_MAX_SUPPORTED_FRAME_SIZE) >= data_size;
00316
00317 if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
00318 goto free_and_fail;
00319
00320 memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
00321 if(0 == i)
00322 head = response_to_queue;
00323
00324 if(NULL == (data_frame = malloc(sizeof(struct SPDYF_Data_Frame))))
00325 {
00326 free(response_to_queue);
00327 goto free_and_fail;
00328 }
00329 memset(data_frame, 0, sizeof(struct SPDYF_Data_Frame));
00330 data_frame->control_bit = 0;
00331 data_frame->stream_id = stream->stream_id;
00332 if(is_last && closestream)
00333 data_frame->flags |= SPDY_DATA_FLAG_FIN;
00334
00335 response_to_queue->data_frame = data_frame;
00336 response_to_queue->process_response_handler = &SPDYF_handler_write_data;
00337 response_to_queue->is_data = is_data;
00338 response_to_queue->stream = stream;
00339 if(is_last)
00340 {
00341 response_to_queue->frqcb = frqcb;
00342 response_to_queue->frqcb_cls = frqcb_cls;
00343 response_to_queue->rrcb = rrcb;
00344 response_to_queue->rrcb_cls = rrcb_cls;
00345 }
00346 response_to_queue->data = data + i;
00347 response_to_queue->data_size = is_last
00348 ? (data_size - 1) % SPDY_MAX_SUPPORTED_FRAME_SIZE + 1
00349 : SPDY_MAX_SUPPORTED_FRAME_SIZE;
00350 response_to_queue->response = response;
00351
00352 response_to_queue->prev = prev;
00353 if(NULL != prev)
00354 prev->next = response_to_queue;
00355 prev = response_to_queue;
00356 }
00357
00358 return head;
00359
00360
00361 free_and_fail:
00362 while(NULL != head)
00363 {
00364 response_to_queue = head;
00365 head = head->next;
00366 free(response_to_queue->data_frame);
00367 free(response_to_queue);
00368 }
00369 return NULL;
00370 }
00371
00372
00373
00374 if(NULL == (response_to_queue = malloc(sizeof(struct SPDYF_Response_Queue))))
00375 {
00376 return NULL;
00377 }
00378 memset(response_to_queue, 0, sizeof(struct SPDYF_Response_Queue));
00379
00380 if(is_data)
00381 {
00382 if(NULL == (data_frame = malloc(sizeof(struct SPDYF_Data_Frame))))
00383 {
00384 free(response_to_queue);
00385 return NULL;
00386 }
00387 memset(data_frame, 0, sizeof(struct SPDYF_Data_Frame));
00388 data_frame->control_bit = 0;
00389 data_frame->stream_id = stream->stream_id;
00390 if(closestream && NULL == response->rcb)
00391 data_frame->flags |= SPDY_DATA_FLAG_FIN;
00392
00393 response_to_queue->data_frame = data_frame;
00394 response_to_queue->process_response_handler = &SPDYF_handler_write_data;
00395 }
00396 else
00397 {
00398 if(NULL == (control_frame = malloc(sizeof(struct SPDYF_Control_Frame))))
00399 {
00400 free(response_to_queue);
00401 return NULL;
00402 }
00403 memset(control_frame, 0, sizeof(struct SPDYF_Control_Frame));
00404 control_frame->control_bit = 1;
00405 control_frame->version = SPDY_VERSION;
00406 control_frame->type = SPDY_CONTROL_FRAME_TYPES_SYN_REPLY;
00407 if(closestream)
00408 control_frame->flags |= SPDY_SYN_REPLY_FLAG_FIN;
00409
00410 response_to_queue->control_frame = control_frame;
00411 response_to_queue->process_response_handler = &SPDYF_handler_write_syn_reply;
00412 }
00413
00414 response_to_queue->is_data = is_data;
00415 response_to_queue->stream = stream;
00416 response_to_queue->frqcb = frqcb;
00417 response_to_queue->frqcb_cls = frqcb_cls;
00418 response_to_queue->rrcb = rrcb;
00419 response_to_queue->rrcb_cls = rrcb_cls;
00420 response_to_queue->data = data;
00421 response_to_queue->data_size = data_size;
00422 response_to_queue->response = response;
00423
00424 return response_to_queue;
00425 }
00426
00427
00428 void
00429 SPDYF_response_queue_destroy(struct SPDYF_Response_Queue *response_queue)
00430 {
00431
00432
00433 if(!response_queue->is_data
00434 && (SPDY_CONTROL_FRAME_TYPES_RST_STREAM == response_queue->control_frame->type
00435 || SPDY_CONTROL_FRAME_TYPES_GOAWAY == response_queue->control_frame->type))
00436 {
00437 free(response_queue->data);
00438 }
00439 if(response_queue->is_data)
00440 free(response_queue->data_frame);
00441 else
00442 free(response_queue->control_frame);
00443
00444 free(response_queue);
00445 }
00446
00447
00448 ssize_t
00449 SPDYF_name_value_to_stream(struct SPDY_NameValue * container[],
00450 int num_containers,
00451 void **stream)
00452 {
00453 size_t size;
00454 int32_t num_pairs = 0;
00455 int32_t value_size;
00456 int32_t name_size;
00457 int32_t temp;
00458 unsigned int i;
00459 unsigned int offset;
00460 unsigned int value_offset;
00461 struct SPDY_NameValue * iterator;
00462 int j;
00463
00464 size = 4;
00465
00466 for(j=0; j<num_containers; ++j)
00467 {
00468 iterator = container[j];
00469 while(iterator != NULL)
00470 {
00471 ++num_pairs;
00472 size += 4 + strlen(iterator->name);
00473
00474 SPDYF_ASSERT(iterator->num_values>0, "num_values is 0");
00475
00476 size += 4;
00477
00478 for(i=0; i<iterator->num_values; ++i)
00479 {
00480 size += strlen(iterator->value[i]);
00481 if(i) ++size;
00482 }
00483
00484 iterator = iterator->next;
00485 }
00486 }
00487
00488 if(NULL == (*stream = malloc(size)))
00489 {
00490 return -1;
00491 }
00492
00493
00494 num_pairs = htonl(num_pairs);
00495 memcpy(*stream, &num_pairs, 4);
00496 offset = 4;
00497
00498
00499 for(j=0; j<num_containers; ++j)
00500 {
00501 iterator = container[j];
00502 while(iterator != NULL)
00503 {
00504 name_size = strlen(iterator->name);
00505 temp = htonl(name_size);
00506 memcpy(*stream + offset, &temp, 4);
00507 offset += 4;
00508 strncpy(*stream + offset, iterator->name, name_size);
00509 offset += name_size;
00510
00511 value_offset = offset;
00512 offset += 4;
00513 for(i=0; i<iterator->num_values; ++i)
00514 {
00515 if(i )
00516 {
00517 memset(*stream + offset, 0, 1);
00518 ++offset;
00519
00520 }
00521 strncpy(*stream + offset, iterator->value[i], strlen(iterator->value[i]));
00522 offset += strlen(iterator->value[i]);
00523 }
00524 value_size = offset - value_offset - 4;
00525 value_size = htonl(value_size);
00526 memcpy(*stream + value_offset, &value_size, 4);
00527
00528 iterator = iterator->next;
00529 }
00530 }
00531
00532 SPDYF_ASSERT(offset == size,"offset is wrong");
00533
00534 return size;
00535 }
00536
00537
00538 int
00539 SPDYF_name_value_from_stream(void *stream,
00540 size_t size,
00541 struct SPDY_NameValue ** container)
00542 {
00543 int32_t num_pairs;
00544 int32_t value_size;
00545 int32_t name_size;
00546 int i;
00547 unsigned int offset = 0;
00548 unsigned int value_end_offset;
00549 char *name;
00550 char *value;
00551
00552 if(NULL == (*container = SPDY_name_value_create ()))
00553 {
00554 return SPDY_NO;
00555 }
00556
00557
00558 memcpy(&num_pairs, stream, 4);
00559 offset = 4;
00560 num_pairs = ntohl(num_pairs);
00561
00562 if(num_pairs > 0)
00563 {
00564 for(i = 0; i < num_pairs; ++i)
00565 {
00566
00567 memcpy(&name_size, stream + offset, 4);
00568 offset += 4;
00569 name_size = ntohl(name_size);
00570
00571 if(NULL == (name = strndup(stream + offset, name_size)))
00572 {
00573 SPDY_name_value_destroy(*container);
00574 return SPDY_NO;
00575 }
00576 offset+=name_size;
00577
00578
00579 memcpy(&value_size, stream + offset, 4);
00580 offset += 4;
00581 value_size = ntohl(value_size);
00582 value_end_offset = offset + value_size;
00583
00584 do
00585 {
00586 if(NULL == (value = strndup(stream + offset, value_size)))
00587 {
00588 free(name);
00589 SPDY_name_value_destroy(*container);
00590 return SPDY_NO;
00591 }
00592 offset += strlen(value);
00593 if(offset < value_end_offset)
00594 ++offset;
00595
00596
00597 if(SPDY_YES != SPDY_name_value_add(*container, name, value))
00598 {
00599 free(name);
00600 free(value);
00601 SPDY_name_value_destroy(*container);
00602 return SPDY_NO;
00603 }
00604 free(value);
00605 }
00606 while(offset < value_end_offset);
00607
00608 free(name);
00609
00610 if(offset != value_end_offset)
00611 {
00612 SPDY_name_value_destroy(*container);
00613 return SPDY_INPUT_ERROR;
00614 }
00615 }
00616 }
00617
00618 if(offset == size)
00619 return SPDY_YES;
00620
00621 SPDY_name_value_destroy(*container);
00622 return SPDY_INPUT_ERROR;
00623 }