src/agent/download-agent-http-queue.c

   1 /*
   2  * Download Agent
   3  *
   4  * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Jungki Kwak <jungki.kwak@samsung.com>, Keunsoon Lee <keunsoon.lee@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *     http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  * @file                download-agent-http-queue.c
  21  * @brief               Including functions regarding http queue
  22  * @author              Keunsoon Lee(keunsoon.lee@samsung.com)
  23  ***/
  24
  25 #include "download-agent-http-queue.h"
  26 #include "download-agent-http-mgr.h"
  27 #include "download-agent-debug.h"
  28 #include "download-agent-pthread.h"
  29
  30 void init_q_event_data_http(q_event_t *q_event);
  31 void init_q_event_control(q_event_t *q_event);
  32
  33 void Q_init_queue(queue_t *queue)
  34 {
  35         queue->having_data = DA_FALSE;
  36         queue->control_head = DA_NULL;
  37         queue->data_head = DA_NULL;
  38         queue->queue_size = 0;
  39
  40         _da_thread_mutex_init(&(queue->mutex_queue), DA_NULL);
  41         _da_thread_cond_init(&(queue->cond_queue), DA_NULL);
  42 }
  43
  44 void Q_destroy_queue(queue_t *queue)
  45 {
  46         q_event_t *event = DA_NULL;
  47
  48         DA_LOG_FUNC_START(HTTPManager);
  49
  50         do {
  51                 Q_pop_event(queue, &event);
  52                 Q_destroy_q_event(&event);
  53         } while(event);
  54
  55         queue->having_data = DA_FALSE;
  56         queue->control_head = DA_NULL;
  57         queue->data_head = DA_NULL;
  58         queue->queue_size = 0;
  59
  60         _da_thread_mutex_destroy(&(queue->mutex_queue));
  61         _da_thread_cond_destroy(&(queue->cond_queue));
  62 }
  63
  64 void Q_init_q_event(q_event_t *q_event)
  65 {
  66         switch(q_event->event_type) {
  67                 case Q_EVENT_TYPE_DATA_HTTP:
  68                         init_q_event_data_http(q_event);
  69                         break;
  70                 case Q_EVENT_TYPE_CONTROL:
  71                         init_q_event_control(q_event);
  72                         break;
  73         }
  74
  75         q_event->size = 0;
  76         q_event->next = DA_NULL;
  77 }
  78
  79 void Q_destroy_q_event(q_event_t **in_q_event)
  80 {
  81         q_event_t *q_event = DA_NULL;
  82         q_event = *in_q_event;
  83
  84         if(q_event == DA_NULL)
  85                 return;
  86
  87 //      DA_LOG(HTTPManager, "destroying size = %d", q_event->size);
  88
  89         switch(q_event->event_type)     {
  90                 case Q_EVENT_TYPE_DATA_HTTP:
  91                         init_q_event_data_http(q_event);
  92                         q_event->size = 0;
  93                         q_event->next = DA_NULL;
  94                         free(q_event);
  95                         break;
  96                 case Q_EVENT_TYPE_CONTROL:
  97                         init_q_event_control(q_event);
  98                         q_event->size = 0;
  99                         q_event->next = DA_NULL;
 100                         free(q_event);
 101                         break;
 102         }
 103 }
 104
 105 da_result_t  Q_make_control_event(q_event_type_control control_type, q_event_t **out_event)
 106 {
 107         da_result_t  ret = DA_RESULT_OK;
 108         q_event_t *q_event = DA_NULL;
 109
 110         DA_LOG_FUNC_START(HTTPManager);
 111
 112         q_event = (q_event_t *)calloc(1, sizeof(q_event_t));
 113         if(q_event == DA_NULL) {
 114                 DA_LOG_ERR(HTTPManager, "calloc fail for q_event");
 115                 ret = DA_ERR_FAIL_TO_MEMALLOC;
 116
 117                 *out_event = DA_NULL;
 118         } else {
 119                 q_event->event_type = Q_EVENT_TYPE_CONTROL;
 120                 q_event->type.q_event_control.control_type = control_type;
 121                 q_event->next = DA_NULL;
 122
 123                 *out_event = q_event;
 124         }
 125
 126         return ret;
 127 }
 128
 129 da_result_t  Q_make_http_data_event(q_event_type_data data_type, q_event_t **out_event)
 130 {
 131         da_result_t  ret = DA_RESULT_OK;
 132         q_event_t *q_event = DA_NULL;
 133
 134 //      DA_LOG_FUNC_START(HTTPManager);
 135
 136         q_event = (q_event_t *)calloc(1, sizeof(q_event_t));
 137         if(q_event == DA_NULL) {
 138                 DA_LOG_ERR(HTTPManager, "calloc fail for q_event");
 139                 ret = DA_ERR_FAIL_TO_MEMALLOC;
 140                 *out_event = DA_NULL;
 141         } else {
 142                 q_event->event_type = Q_EVENT_TYPE_DATA_HTTP;
 143                 q_event->type.q_event_data_http.data_type = data_type;
 144                 q_event->next = DA_NULL;
 145
 146                 *out_event = q_event;
 147
 148 //              DA_LOG(HTTPManager, "made event = %x", *out_event);
 149         }
 150
 151         return ret;
 152
 153 }
 154
 155 da_result_t  Q_set_status_code_on_http_data_event(q_event_t *q_event, int status_code)
 156 {
 157         da_result_t  ret = DA_RESULT_OK;
 158
 159 //      DA_LOG_FUNC_START(HTTPManager);
 160
 161         if(q_event->event_type != Q_EVENT_TYPE_DATA_HTTP) {
 162                 DA_LOG_ERR(HTTPManager, "status_code can be set only for Q_EVENT_TYPE_DATA_HTTP.");
 163                 ret = DA_ERR_INVALID_ARGUMENT;
 164                 goto ERR;
 165         }
 166
 167         q_event->type.q_event_data_http.status_code = status_code;
 168
 169 //      DA_LOG(HTTPManager, "status_code = %d, q_event = %x", q_event->type.q_event_data_http.status_code, q_event);
 170
 171 ERR:
 172         return ret;
 173
 174 }
 175
 176 da_result_t  Q_set_http_body_on_http_data_event(q_event_t *q_event, int body_len, char *body_data)
 177 {
 178         da_result_t  ret = DA_RESULT_OK;
 179
 180 //      DA_LOG_FUNC_START(HTTPManager);
 181
 182         if(q_event->event_type != Q_EVENT_TYPE_DATA_HTTP) {
 183                 DA_LOG_ERR(HTTPManager, "http body can be set only for Q_EVENT_TYPE_DATA_HTTP.");
 184                 ret = DA_ERR_INVALID_ARGUMENT;
 185                 goto ERR;
 186         }
 187
 188         q_event->type.q_event_data_http.body_len = body_len;
 189         q_event->type.q_event_data_http.body_data = body_data;
 190         q_event->size = body_len;
 191
 192 //      DA_LOG(HTTPManager, "body_len = %d, body_data = %x, q_event = %x", q_event->type.q_event_data_http.body_len, q_event->type.q_event_data_http.body_data, q_event);
 193
 194 ERR:
 195         return ret;
 196
 197 }
 198
 199 da_result_t  Q_set_error_type_on_http_data_event(q_event_t *q_event, int error_type)
 200 {
 201         da_result_t  ret = DA_RESULT_OK;
 202
 203 //      DA_LOG_FUNC_START(HTTPManager);
 204
 205         if(q_event->event_type != Q_EVENT_TYPE_DATA_HTTP) {
 206                 DA_LOG_ERR(HTTPManager, "error_type can be set only for Q_EVENT_TYPE_DATA_HTTP.");
 207                 ret = DA_ERR_INVALID_ARGUMENT;
 208                 goto ERR;
 209         }
 210
 211         q_event->type.q_event_data_http.error_type = error_type;
 212
 213         DA_LOG(HTTPManager, "error_type = %d, q_event = %p", q_event->type.q_event_data_http.error_type, q_event);
 214
 215 ERR:
 216         return ret;
 217
 218 }
 219
 220 da_bool_t Q_push_event(const queue_t *in_queue, const q_event_t *in_event)
 221 {
 222         da_bool_t b_ret = DA_FALSE;
 223         queue_t *queue = (queue_t *)in_queue;
 224
 225         _da_thread_mutex_lock (&(queue->mutex_queue));
 226         b_ret = Q_push_event_without_lock(in_queue, in_event);
 227         _da_thread_mutex_unlock (&(queue->mutex_queue));
 228
 229         return b_ret;
 230 }
 231
 232 da_bool_t Q_push_event_without_lock(const queue_t *in_queue, const q_event_t *in_event)
 233 {
 234         da_bool_t b_ret = DA_FALSE;
 235         queue_t *queue = (queue_t *)in_queue;
 236         q_event_t *event = (q_event_t *)in_event;
 237         q_event_type event_type;
 238         q_event_t *head = DA_NULL;
 239         q_event_t *cur = DA_NULL;
 240
 241 //      DA_LOG_FUNC_START(HTTPManager);
 242 //      DA_LOG(HTTPManager, "queue = %x", in_queue);
 243
 244         event_type = event->event_type;
 245
 246 //      _da_thread_mutex_lock (&(queue->mutex_queue));
 247
 248         if(event_type == Q_EVENT_TYPE_CONTROL) {
 249                 head = queue->control_head;
 250                 if(head == DA_NULL) {
 251                         queue->control_head = event;
 252                 } else {
 253                         cur = head;
 254
 255                         while(cur->next != DA_NULL) {
 256                                 cur = cur->next;
 257                         }
 258                         cur->next= event;
 259                 }
 260                 b_ret = DA_TRUE;
 261         } else {
 262                 if((event->size == 0) || (queue->queue_size < MAX_QUEUE_SIZE)) {
 263                         head = queue->data_head;
 264                         if(head == DA_NULL)     {
 265                                 queue->data_head = event;
 266                         } else {
 267                                 cur = head;
 268                                 while(cur->next != DA_NULL) {
 269                                         cur = cur->next;
 270                                 }
 271                                 cur->next= event ;
 272                         }
 273
 274                         queue->queue_size += event->size;
 275 //                      DA_LOG(HTTPManager, "queue size is %d", queue->queue_size);
 276
 277                         b_ret = DA_TRUE;
 278                 } else {
 279                         DA_LOG_CRITICAL(HTTPManager, "rejected event's size is %d queue_size %d", event->size, queue->queue_size);
 280                         b_ret = DA_FALSE;
 281                 }
 282         }
 283
 284         queue->having_data = DA_TRUE;
 285         Q_wake_up(queue);
 286 //      _da_thread_mutex_unlock (&(queue->mutex_queue));
 287         return b_ret;
 288 }
 289
 290 void Q_pop_event(const queue_t *in_queue, q_event_t **out_event)
 291 {
 292         queue_t *queue = (queue_t*)in_queue;
 293
 294 //      DA_LOG_FUNC_START(HTTPManager);
 295 //      DA_LOG(HTTPManager, "queue = %x", in_queue);
 296
 297         /** Pop Priority
 298           * 1. If there are control event, control event should pop first
 299           * 2. If there is no control event, data event should pop
 300           * 3. If there is no control and data event on queue, pop NULL
 301          */
 302
 303         _da_thread_mutex_lock (&(queue->mutex_queue));
 304
 305         if(queue->control_head != DA_NULL) {/* Priority 1 */
 306                 *out_event = queue->control_head;
 307                 queue->control_head = queue->control_head->next;
 308         } else {
 309                 if(queue->data_head != DA_NULL) {/* Priority 2 */
 310                         *out_event = queue->data_head;
 311                         queue->data_head = queue->data_head->next;
 312                         queue->queue_size -= (*out_event)->size;
 313 //                      DA_LOG(HTTPManager, "queue size is %d", queue->queue_size);
 314                 } else {/* Priority 3 */
 315                         *out_event = DA_NULL;
 316                 }
 317         }
 318
 319         if((queue->control_head == DA_NULL) && (queue->data_head == DA_NULL)) {
 320                 queue->having_data = DA_FALSE;
 321         } else {
 322                 queue->having_data = DA_TRUE;
 323         }
 324
 325         _da_thread_mutex_unlock (&(queue->mutex_queue));
 326
 327 }
 328
 329 void Q_goto_sleep(const queue_t *in_queue)
 330 {
 331 //      DA_LOG_FUNC_START(HTTPManager);
 332         DA_LOG(HTTPManager, "sleep for %p", in_queue);
 333
 334 //** SHOULD NOT use mutex **//
 335
 336 //      _da_thread_mutex_lock (&(in_queue->mutex_queue));
 337         _da_thread_cond_wait((pthread_cond_t*)(&(in_queue->cond_queue)),(pthread_mutex_t*) (&(in_queue->mutex_queue)));
 338 //      _da_thread_mutex_unlock (&(in_queue->mutex_queue));
 339 }
 340
 341 void Q_wake_up(const queue_t *in_queue)
 342 {
 343 //      DA_LOG_FUNC_START(HTTPManager);
 344         DA_LOG(HTTPManager, "wake up for %p", in_queue);
 345
 346 //** SHOULD NOT use mutex **//
 347
 348 //      _da_thread_mutex_lock (&(in_queue->mutex_queue));
 349         _da_thread_cond_signal((pthread_cond_t*)(&(in_queue->cond_queue)));
 350 //      _da_thread_mutex_unlock (&(in_queue->mutex_queue));
 351 }
 352
 353 void init_q_event_data_http(q_event_t *q_event)
 354 {
 355         q_event_data_http_t *q_event_data_http;
 356
 357 //      DA_LOG_FUNC_START(HTTPManager);
 358
 359         if(q_event->event_type == Q_EVENT_TYPE_DATA_HTTP) {
 360                 q_event_data_http = &(q_event->type.q_event_data_http);
 361
 362                 if(q_event_data_http) {
 363                         q_event_data_http->status_code = DA_NULL;
 364                         if(q_event_data_http->http_response_msg) {
 365                                 http_msg_response_destroy(&(q_event_data_http->http_response_msg));
 366                         }
 367
 368                         if(q_event_data_http->body_len > 0 ) {
 369                                 if (q_event_data_http->body_data) {
 370                                         free(q_event_data_http->body_data);
 371                                         q_event_data_http->body_data = DA_NULL;
 372                                 }
 373                         }
 374                         q_event_data_http->error_type = DA_NULL;
 375                 }
 376         }
 377 }
 378
 379 void init_q_event_control(q_event_t *q_event)
 380 {
 381         q_event_control_t *q_event_control;
 382
 383 //      DA_LOG_FUNC_START(HTTPManager);
 384
 385         if(q_event->event_type == Q_EVENT_TYPE_CONTROL) {
 386                 q_event_control = &(q_event->type.q_event_control);
 387                 if(q_event_control) {
 388                         q_event_control->control_type = DA_NULL;
 389                 }
 390         }
 391
 392 }