git.sip-router.org Git - sip-router/blob - src/modules/http_async_client/async_http.c

   1 /**
   2  * Copyright 2016 (C) Federico Cabiddu <federico.cabiddu@gmail.com>
   3  * Copyright 2016 (C) Giacomo Vacca <giacomo.vacca@gmail.com>
   4  * Copyright 2016 (C) Orange - Camille Oudot <camille.oudot@orange.com>
   5  *
   6  * This file is part of Kamailio, a free SIP server.
   7  *
   8  * This file is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version
  12  *
  13  *
  14  * This file is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  */
  24
  25 /*! \file
  26  * \brief  Kamailio http_async_client :: Include file
  27  * \ingroup http_async_client
  28  */
  29
  30
  31 #include <stdio.h>
  32 #include <unistd.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #include <sys/socket.h>
  37 #include <sys/types.h>
  38 #include <netinet/in.h>
  39 #include <arpa/inet.h>
  40 #include <fcntl.h>
  41
  42 #include <event2/event.h>
  43
  44 #include "../../core/sr_module.h"
  45 #include "../../core/dprint.h"
  46 #include "../../core/ut.h"
  47 #include "../../core/cfg/cfg_struct.h"
  48 #include "../../core/receive.h"
  49 #include "../../core/fmsg.h"
  50 #include "../../core/kemi.h"
  51 #include "../../modules/tm/tm_load.h"
  52
  53 #include "async_http.h"
  54
  55 /* tm */
  56 extern struct tm_binds tmb;
  57
  58 struct sip_msg *ah_reply = NULL;
  59 str ah_error = {NULL, 0};
  60
  61 async_http_worker_t *workers = NULL;
  62 int num_workers = 1;
  63
  64 struct query_params ah_params;
  65 unsigned int q_idx;
  66 char q_id[MAX_ID_LEN+1];
  67
  68 int async_http_init_worker(int prank, async_http_worker_t* worker)
  69 {
  70         LM_DBG("initializing worker process: %d\n", prank);
  71         worker->evbase = event_base_new();
  72         LM_DBG("base event %p created\n", worker->evbase);
  73
  74         worker->g = shm_malloc(sizeof(struct http_m_global));
  75         if(worker->g==NULL) {
  76                 LM_ERR("out of shared memory\n");
  77                 return -1;
  78         }
  79         memset(worker->g, 0, sizeof(http_m_global_t));
  80         LM_DBG("initialized global struct %p\n", worker->g);
  81
  82         init_socket(worker);
  83
  84         LM_INFO("started worker process: %d\n", prank);
  85
  86         return 0;
  87 }
  88
  89 void async_http_run_worker(async_http_worker_t* worker)
  90 {
  91         init_http_multi(worker->evbase, worker->g);
  92         event_base_dispatch(worker->evbase);
  93 }
  94
  95 int async_http_init_sockets(async_http_worker_t *worker)
  96 {
  97         if (socketpair(PF_UNIX, SOCK_DGRAM, 0, worker->notication_socket) < 0) {
  98                 LM_ERR("opening tasks dgram socket pair\n");
  99                 return -1;
 100         }
 101         LM_INFO("inter-process event notification sockets initialized\n");
 102         return 0;
 103 }
 104
 105 static inline char *strfindcasestrz(str *haystack, char *needlez)
 106 {
 107     int i,j;
 108     str needle;
 109
 110     needle.s = needlez;
 111     needle.len = strlen(needlez);
 112     for(i=0;i<haystack->len-needle.len;i++) {
 113         for(j=0;j<needle.len;j++) {
 114             if ( !((haystack->s[i+j]==needle.s[j]) ||
 115                     ( isalpha((int)haystack->s[i+j])
 116                         && ((haystack->s[i+j])^(needle.s[j]))==0x20 )) )
 117                 break;
 118         }
 119         if (j==needle.len)
 120             return haystack->s+i;
 121     }
 122     return 0;
 123 }
 124
 125 void async_http_cb(struct http_m_reply *reply, void *param)
 126 {
 127         async_query_t *aq = NULL;
 128         cfg_action_t *act = NULL;
 129         int ri;
 130         unsigned int tindex;
 131         unsigned int tlabel;
 132         struct cell *t = NULL;
 133         char *p;
 134         str newbuf = {0, 0};
 135         sip_msg_t *fmsg = NULL;
 136         sr_kemi_eng_t *keng = NULL;
 137         str cbname = {0, 0};
 138         str evname = str_init("http_async_client:callback");
 139
 140         aq = param;
 141
 142         /* clean process-local result variables */
 143         ah_error.s = NULL;
 144         ah_error.len = 0;
 145         memset(ah_reply, 0, sizeof(struct sip_msg));
 146
 147         keng = sr_kemi_eng_get();
 148         if(keng==NULL) {
 149                 ri = route_lookup(&main_rt, aq->cbname);
 150                 if(ri<0) {
 151                         LM_ERR("unable to find route block [%s]\n", aq->cbname);
 152                         goto done;
 153                 }
 154                 act = main_rt.rlist[ri];
 155                 if(act==NULL) {
 156                         LM_ERR("empty action lists in route block [%s]\n", aq->cbname);
 157                         goto done;
 158                 }
 159         }
 160
 161         if (reply->result != NULL) {
 162                 LM_DBG("query result = %.*s [%d]\n", reply->result->len, reply->result->s, reply->result->len);
 163         }
 164
 165         /* set process-local result variables */
 166         if (reply->result == NULL) {
 167                 /* error */
 168                 ah_error.s = reply->error;
 169                 ah_error.len = strlen(ah_error.s);
 170         } else {
 171                 /* success */
 172                 /* check for HTTP Via header
 173          * - HTTP Via format is different that SIP Via
 174          * - workaround: replace with Hia to be ignored by SIP parser
 175          */
 176         if((p=strfindcasestrz(reply->result, "\nVia:"))!=NULL)
 177         {
 178                 p++;
 179                 *p = 'H';
 180                 LM_DBG("replaced HTTP Via with Hia [[\n%.*s]]\n", reply->result->len, reply->result->s);
 181         }
 182
 183                 ah_reply->buf = reply->result->s;
 184                 ah_reply->len = reply->result->len;
 185
 186                 if (parse_msg(reply->result->s, reply->result->len, ah_reply) != 0) {
 187                         LM_DBG("failed to parse the http_reply\n");
 188                 } else {
 189                         if (ah_reply->first_line.u.reply.statuscode == 100) {
 190                                 newbuf.s = get_body( ah_reply );
 191                                 newbuf.len = reply->result->s + reply->result->len - newbuf.s;
 192
 193                                 if (!(newbuf.len < 0)) {
 194                                         memset(ah_reply, 0, sizeof(struct sip_msg));
 195                                         ah_reply->buf = newbuf.s;
 196                                         ah_reply->len = newbuf.len;
 197
 198                                         if (parse_msg(ah_reply->buf, ah_reply->len, ah_reply) != 0) {
 199                                                 LM_DBG("failed to parse the http_reply\n");
 200                                         } else {
 201                                                 LM_DBG("successfully parsed http reply %p\n", ah_reply);
 202                                         }
 203                                 } else {
 204                                         /* this should not happen! */
 205                                         LM_WARN("something got wrong parsing the 100 Continue: got %d len\n", newbuf.len);
 206                                 }
 207
 208                         } else {
 209                                 LM_DBG("successfully parsed http reply %p\n", ah_reply);
 210                         }
 211                 }
 212         }
 213
 214         strncpy(q_id, aq->id, strlen(aq->id));
 215
 216         q_id[strlen(aq->id)] = '\0';
 217
 218         cfg_update();
 219
 220         if (aq->query_params.suspend_transaction) {
 221                 tindex = aq->tindex;
 222                 tlabel = aq->tlabel;
 223
 224                 if (tmb.t_lookup_ident(&t, tindex, tlabel) < 0) {
 225                         LM_ERR("transaction not found %d:%d\n", tindex, tlabel);
 226                         LM_DBG("freeing query %p\n", aq);
 227                         free_async_query(aq);
 228                         return;
 229                 }
 230                 // we bring the list of AVPs of the transaction to the current context
 231                 set_avp_list(AVP_TRACK_FROM | AVP_CLASS_URI, &t->uri_avps_from);
 232                 set_avp_list(AVP_TRACK_TO | AVP_CLASS_URI, &t->uri_avps_to);
 233                 set_avp_list(AVP_TRACK_FROM | AVP_CLASS_USER, &t->user_avps_from);
 234                 set_avp_list(AVP_TRACK_TO | AVP_CLASS_USER, &t->user_avps_to);
 235                 set_avp_list(AVP_TRACK_FROM | AVP_CLASS_DOMAIN, &t->domain_avps_from);
 236                 set_avp_list(AVP_TRACK_TO | AVP_CLASS_DOMAIN, &t->domain_avps_to);
 237
 238                 if (t)
 239                         tmb.unref_cell(t);
 240
 241                 LM_DBG("resuming transaction (%d:%d)\n", tindex, tlabel);
 242
 243                 if(keng==NULL) {
 244                         if(act!=NULL) {
 245                                 tmb.t_continue(tindex, tlabel, act);
 246                         }
 247                 } else {
 248                         cbname.s = aq->cbname;
 249                         cbname.len = aq->cbname_len;
 250                         tmb.t_continue_cb(tindex, tlabel, &cbname, &evname);
 251                 }
 252         } else {
 253                 fmsg = faked_msg_next();
 254                 if(keng==NULL) {
 255                         if(act!=NULL) {
 256                                 if (run_top_route(act, fmsg, 0)<0) {
 257                                         LM_ERR("failure inside run_top_route\n");
 258                                 }
 259                         }
 260                 } else {
 261                         cbname.s = aq->cbname;
 262                         cbname.len = aq->cbname_len;
 263                         if(keng->froute(fmsg, EVENT_ROUTE, &cbname, &evname)<0) {
 264                                 LM_ERR("error running event route kemi callback\n");
 265                         }
 266                 }
 267                 ksr_msg_env_reset();
 268         }
 269
 270 done:
 271         free_sip_msg(ah_reply);
 272         free_async_query(aq);
 273
 274         return;
 275 }
 276
 277 void notification_socket_cb(int fd, short event, void *arg)
 278 {
 279         (void)fd; /* unused */
 280         (void)event; /* unused */
 281         const async_http_worker_t *worker = (async_http_worker_t *) arg;
 282
 283         int received;
 284         int i, len;
 285         async_query_t *aq;
 286
 287         http_m_params_t query_params;
 288
 289         str query;
 290
 291         if ((received = recvfrom(worker->notication_socket[0],
 292                         &aq, sizeof(async_query_t*),
 293                         0, NULL, 0)) < 0) {
 294                 LM_ERR("failed to read from socket (%d: %s)\n", errno, strerror(errno));
 295                 return;
 296         }
 297
 298         if(received != sizeof(async_query_t*)) {
 299                 LM_ERR("invalid query size %d\n", received);
 300                 return;
 301         }
 302
 303         query = ((str)aq->query);
 304
 305         memset(&query_params, 0, sizeof(http_m_params_t));
 306         query_params.timeout = aq->query_params.timeout;
 307         query_params.tls_verify_peer = aq->query_params.tls_verify_peer;
 308         query_params.tls_verify_host = aq->query_params.tls_verify_host;
 309         query_params.authmethod = aq->query_params.authmethod;
 310
 311         for (i = 0 ; i < aq->query_params.headers.len ; i++) {
 312                 query_params.headers = curl_slist_append(query_params.headers, aq->query_params.headers.t[i]);
 313         }
 314         query_params.method  = aq->query_params.method;
 315
 316         if (aq->query_params.tls_client_cert) {
 317                 len = strlen(aq->query_params.tls_client_cert);
 318                 query_params.tls_client_cert = shm_malloc(len+1);
 319
 320                 if(query_params.tls_client_cert == NULL) {
 321                         LM_ERR("Error allocating query_params.tls_client_cert\n");
 322                         goto done;
 323                 }
 324
 325                 strncpy(query_params.tls_client_cert, aq->query_params.tls_client_cert, len);
 326                 query_params.tls_client_cert[len] = '\0';
 327         }
 328
 329         if (aq->query_params.tls_client_key) {
 330                 len = strlen(aq->query_params.tls_client_key);
 331                 query_params.tls_client_key = shm_malloc(len+1);
 332
 333                 if(query_params.tls_client_key == NULL) {
 334                         LM_ERR("Error allocating query_params.tls_client_key\n");
 335                         goto done;
 336                 }
 337
 338                 strncpy(query_params.tls_client_key, aq->query_params.tls_client_key, len);
 339                 query_params.tls_client_key[len] = '\0';
 340         }
 341
 342         if (aq->query_params.tls_ca_path) {
 343                 len = strlen(aq->query_params.tls_ca_path);
 344                 query_params.tls_ca_path = shm_malloc(len+1);
 345
 346                 if(query_params.tls_ca_path == NULL) {
 347                         LM_ERR("Error allocating query_params.tls_ca_path\n");
 348                         goto done;
 349                 }
 350
 351                 strncpy(query_params.tls_ca_path, aq->query_params.tls_ca_path, len);
 352                 query_params.tls_ca_path[len] = '\0';
 353         }
 354
 355         if (aq->query_params.body.s && aq->query_params.body.len > 0) {
 356                 if (shm_str_dup(&query_params.body, &(aq->query_params.body)) < 0) {
 357                         LM_ERR("Error allocating query_params.body\n");
 358                         goto done;
 359                 }
 360         }
 361
 362         if (aq->query_params.username) {
 363                 len = strlen(aq->query_params.username);
 364                 query_params.username = shm_malloc(len+1);
 365
 366                 if(query_params.username == NULL) {
 367                         LM_ERR("error in shm_malloc\n");
 368                         goto done;
 369                 }
 370
 371                 strncpy(query_params.username, aq->query_params.username, len);
 372                 query_params.username[len] = '\0';
 373         }
 374
 375         if (aq->query_params.password) {
 376                 len = strlen(aq->query_params.password);
 377                 query_params.password = shm_malloc(len+1);
 378
 379                 if(query_params.password == NULL) {
 380                         LM_ERR("error in shm_malloc\n");
 381                         goto done;
 382                 }
 383
 384                 strncpy(query_params.password, aq->query_params.password, len);
 385                 query_params.password[len] = '\0';
 386         }
 387
 388         LM_DBG("query received: [%.*s] (%p)\n", query.len, query.s, aq);
 389
 390         if (new_request(&query, &query_params, async_http_cb, aq) < 0) {
 391                 LM_ERR("Cannot create request for %.*s\n", query.len, query.s);
 392                 free_async_query(aq);
 393         }
 394
 395 done:
 396         if (query_params.tls_client_cert) {
 397                 shm_free(query_params.tls_client_cert);
 398                 query_params.tls_client_cert = NULL;
 399         }
 400         if (query_params.tls_client_key) {
 401                 shm_free(query_params.tls_client_key);
 402                 query_params.tls_client_key = NULL;
 403         }
 404         if (query_params.tls_ca_path) {
 405                 shm_free(query_params.tls_ca_path);
 406                 query_params.tls_ca_path = NULL;
 407         }
 408         if (query_params.body.s && query_params.body.len > 0) {
 409                 shm_free(query_params.body.s);
 410                 query_params.body.s = NULL;
 411                 query_params.body.len = 0;
 412         }
 413
 414         if (query_params.username) {
 415                 shm_free(query_params.username);
 416                 query_params.username = NULL;
 417         }
 418
 419         if (query_params.password) {
 420                 shm_free(query_params.password);
 421                 query_params.password = NULL;
 422         }
 423
 424         return;
 425 }
 426
 427 int init_socket(async_http_worker_t *worker)
 428 {
 429         worker->socket_event = event_new(worker->evbase, worker->notication_socket[0], EV_READ|EV_PERSIST, notification_socket_cb, worker);
 430         event_add(worker->socket_event, NULL);
 431         return (0);
 432 }
 433
 434 int async_send_query(sip_msg_t *msg, str *query, str *cbname)
 435 {
 436         async_query_t *aq;
 437         unsigned int tindex = 0;
 438         unsigned int tlabel = 0;
 439         short suspend = 0;
 440         int dsize;
 441         int len;
 442         tm_cell_t *t = 0;
 443
 444         if(query==0) {
 445                 LM_ERR("invalid parameters\n");
 446                 return -1;
 447         }
 448         if(cbname->len>=MAX_CBNAME_LEN-1) {
 449                 LM_ERR("callback name is too long: %d / %.*s\n", cbname->len,
 450                                 cbname->len, cbname->s);
 451                 return -1;
 452         }
 453
 454         t = tmb.t_gett();
 455         if (t==NULL || t==T_UNDEFINED) {
 456                 LM_DBG("no pre-existing transaction, switching to transaction-less behavior\n");
 457         } else if (!ah_params.suspend_transaction) {
 458                 LM_DBG("transaction won't be suspended\n");
 459         } else {
 460                 if(tmb.t_suspend==NULL) {
 461                         LM_ERR("http async query is disabled - tm module not loaded\n");
 462                         return -1;
 463                 }
 464
 465                 if(tmb.t_suspend(msg, &tindex, &tlabel)<0) {
 466                         LM_ERR("failed to suspend request processing\n");
 467                         return -1;
 468                 }
 469
 470                 suspend = 1;
 471
 472                 LM_DBG("transaction suspended [%u:%u]\n", tindex, tlabel);
 473         }
 474         dsize = sizeof(async_query_t);
 475         aq = (async_query_t*)shm_malloc(dsize);
 476
 477         if(aq==NULL)
 478         {
 479                 LM_ERR("no more shm\n");
 480                 goto error;
 481         }
 482         memset(aq,0,dsize);
 483
 484         if(shm_str_dup(&aq->query, query)<0) {
 485                 goto error;
 486         }
 487
 488         memcpy(aq->cbname, cbname->s, cbname->len);
 489         aq->cbname[cbname->len] = '\0';
 490         aq->cbname_len = cbname->len;
 491         aq->tindex = tindex;
 492         aq->tlabel = tlabel;
 493
 494         aq->query_params.tls_verify_peer = ah_params.tls_verify_peer;
 495         aq->query_params.tls_verify_host = ah_params.tls_verify_host;
 496         aq->query_params.suspend_transaction = suspend;
 497         aq->query_params.timeout = ah_params.timeout;
 498         aq->query_params.headers = ah_params.headers;
 499         aq->query_params.method = ah_params.method;
 500         aq->query_params.authmethod = ah_params.authmethod;
 501
 502         q_idx++;
 503         snprintf(q_id, MAX_ID_LEN+1, "%u-%u", (unsigned int)getpid(), q_idx);
 504         strncpy(aq->id, q_id, strlen(q_id));
 505
 506         aq->query_params.tls_client_cert = NULL;
 507         if (ah_params.tls_client_cert) {
 508                 len = strlen(ah_params.tls_client_cert);
 509                 aq->query_params.tls_client_cert = shm_malloc(len+1);
 510
 511                 if(aq->query_params.tls_client_cert == NULL) {
 512                         LM_ERR("Error allocating aq->query_params.tls_client_cert\n");
 513                         goto error;
 514                 }
 515
 516                 strncpy(aq->query_params.tls_client_cert, ah_params.tls_client_cert, len);
 517                 aq->query_params.tls_client_cert[len] = '\0';
 518         }
 519
 520         aq->query_params.tls_client_key = NULL;
 521         if (ah_params.tls_client_key) {
 522                 len = strlen(ah_params.tls_client_key);
 523                 aq->query_params.tls_client_key = shm_malloc(len+1);
 524
 525                 if(aq->query_params.tls_client_key == NULL) {
 526                         LM_ERR("Error allocating aq->query_params.tls_client_key\n");
 527                         goto error;
 528                 }
 529
 530                 strncpy(aq->query_params.tls_client_key, ah_params.tls_client_key, len);
 531                 aq->query_params.tls_client_key[len] = '\0';
 532         }
 533
 534         aq->query_params.tls_ca_path = NULL;
 535         if (ah_params.tls_ca_path) {
 536                 len = strlen(ah_params.tls_ca_path);
 537                 aq->query_params.tls_ca_path = shm_malloc(len+1);
 538
 539                 if(aq->query_params.tls_ca_path == NULL) {
 540                         LM_ERR("Error allocating aq->query_params.tls_ca_path\n");
 541                         goto error;
 542                 }
 543
 544                 strncpy(aq->query_params.tls_ca_path, ah_params.tls_ca_path, len);
 545                 aq->query_params.tls_ca_path[len] = '\0';
 546         }
 547
 548         aq->query_params.body.s = NULL;
 549         aq->query_params.body.len = 0;
 550         if (ah_params.body.s && ah_params.body.len > 0) {
 551                 if (shm_str_dup(&aq->query_params.body, &(ah_params.body)) < 0) {
 552                         LM_ERR("Error allocating aq->query_params.body\n");
 553                         goto error;
 554                 }
 555         }
 556
 557         aq->query_params.username = NULL;
 558         if (ah_params.username) {
 559                 len = strlen(ah_params.username);
 560                 aq->query_params.username = shm_malloc(len+1);
 561
 562                 if(aq->query_params.username == NULL) {
 563                         LM_ERR("error in shm_malloc\n");
 564                         goto error;
 565                 }
 566
 567                 strncpy(aq->query_params.username, ah_params.username, len);
 568                 aq->query_params.username[len] = '\0';
 569         }
 570
 571         aq->query_params.password = NULL;
 572         if (ah_params.password) {
 573                 len = strlen(ah_params.password);
 574                 aq->query_params.password = shm_malloc(len+1);
 575
 576                 if(aq->query_params.password == NULL) {
 577                         LM_ERR("error in shm_malloc\n");
 578                         goto error;
 579                 }
 580
 581                 strncpy(aq->query_params.password, ah_params.password, len);
 582                 aq->query_params.password[len] = '\0';
 583         }
 584
 585         set_query_params(&ah_params);
 586
 587         if(async_push_query(aq)<0) {
 588                 LM_ERR("failed to relay query: %.*s\n", query->len, query->s);
 589                 goto error;
 590         }
 591
 592         if (suspend)  {
 593                 /* force exit in config */
 594                 return 0;
 595         }
 596
 597         /* continue route processing */
 598         return 1;
 599
 600 error:
 601
 602         if (suspend) {
 603                 tmb.t_cancel_suspend(tindex, tlabel);
 604         }
 605         free_async_query(aq);
 606         return -1;
 607 }
 608
 609 int async_push_query(async_query_t *aq)
 610 {
 611         int len;
 612         int worker;
 613         static unsigned long rr = 0; /* round robin */
 614
 615         str query;
 616
 617         query = ((str)aq->query);
 618
 619         worker = rr++ % num_workers;
 620         len = write(workers[worker].notication_socket[1], &aq, sizeof(async_query_t*));
 621         if(len<=0) {
 622                 LM_ERR("failed to pass the query to async workers\n");
 623                 return -1;
 624         }
 625         LM_DBG("query sent [%.*s] (%p) to worker %d\n", query.len, query.s, aq, worker + 1);
 626         return 0;
 627 }
 628
 629 void init_query_params(struct query_params *p) {
 630         memset(&ah_params, 0, sizeof(struct query_params));
 631         set_query_params(p);
 632 }
 633
 634 void set_query_params(struct query_params *p) {
 635         int len;
 636         p->headers.len = 0;
 637         p->headers.t = NULL;
 638         p->tls_verify_host = tls_verify_host;
 639         p->tls_verify_peer = tls_verify_peer;
 640         p->suspend_transaction = 1;
 641         p->timeout = http_timeout;
 642         p->method = AH_METH_DEFAULT;
 643         p->authmethod = default_authmethod;
 644
 645         if (p->tls_client_cert) {
 646                 shm_free(p->tls_client_cert);
 647                 p->tls_client_cert = NULL;
 648         }
 649         if (tls_client_cert) {
 650                 len = strlen(tls_client_cert);
 651                 p->tls_client_cert = shm_malloc(len+1);
 652
 653                 if (p->tls_client_cert == NULL) {
 654                         LM_ERR("Error allocating tls_client_cert\n");
 655                         return;
 656                 }
 657
 658                 strncpy(p->tls_client_cert, tls_client_cert, len);
 659                 p->tls_client_cert[len] = '\0';
 660         }
 661
 662         if (p->tls_client_key) {
 663                 shm_free(p->tls_client_key);
 664                 p->tls_client_key = NULL;
 665         }
 666         if (tls_client_key) {
 667                 len = strlen(tls_client_key);
 668                 p->tls_client_key = shm_malloc(len+1);
 669
 670                 if (p->tls_client_key == NULL) {
 671                         LM_ERR("Error allocating tls_client_key\n");
 672                         return;
 673                 }
 674
 675                 strncpy(p->tls_client_key, tls_client_key, len);
 676                 p->tls_client_key[len] = '\0';
 677         }
 678
 679         if (p->tls_ca_path) {
 680                 shm_free(p->tls_ca_path);
 681                 p->tls_ca_path = NULL;
 682         }
 683         if (tls_ca_path) {
 684                 len = strlen(tls_ca_path);
 685                 p->tls_ca_path = shm_malloc(len+1);
 686
 687                 if (p->tls_ca_path == NULL) {
 688                         LM_ERR("Error allocating tls_ca_path\n");
 689                         return;
 690                 }
 691
 692                 strncpy(p->tls_ca_path, tls_ca_path, len);
 693                 p->tls_ca_path[len] = '\0';
 694         }
 695
 696         if (p->body.s && p->body.len > 0) {
 697                 shm_free(p->body.s);
 698                 p->body.s = NULL;
 699                 p->body.len = 0;
 700         }
 701
 702         if (p->username) {
 703                 shm_free(p->username);
 704                 p->username = NULL;
 705         }
 706
 707         if (p->password) {
 708                 shm_free(p->password);
 709                 p->password = NULL;
 710         }
 711 }
 712
 713 int header_list_add(struct header_list *hl, str* hdr) {
 714         char *tmp;
 715
 716         hl->len++;
 717         hl->t = shm_reallocxf(hl->t, hl->len * sizeof(char*));
 718         if (!hl->t) {
 719                 LM_ERR("shm memory allocation failure\n");
 720                 return -1;
 721         }
 722         hl->t[hl->len - 1] = shm_malloc(hdr->len + 1);
 723         tmp = hl->t[hl->len - 1];
 724         if (!tmp) {
 725                 LM_ERR("shm memory allocation failure\n");
 726                 return -1;
 727         }
 728         memcpy(tmp, hdr->s, hdr->len);
 729         *(tmp + hdr->len) = '\0';
 730
 731         LM_DBG("stored new http header: [%s]\n", tmp);
 732         return 1;
 733 }
 734
 735 int query_params_set_method(struct query_params *qp, str *meth) {
 736         if (strncasecmp(meth->s, "GET", meth->len) == 0) {
 737                 qp->method = AH_METH_GET;
 738         } else if (strncasecmp(meth->s, "POST",meth->len) == 0) {
 739                 qp->method = AH_METH_POST;
 740         } else if (strncasecmp(meth->s, "PUT", meth->len) == 0) {
 741                 qp->method = AH_METH_PUT;
 742         } else if (strncasecmp(meth->s, "DELETE", meth->len) == 0) {
 743                 qp->method = AH_METH_DELETE;
 744         } else {
 745                 LM_ERR("Unsupported method: %.*s\n", meth->len, meth->s);
 746                 return -1;
 747         }
 748         return 1;
 749 }