src/mapzen/mapzen_queue.c

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19 #include "mapzen_queue.h"
  20 #include "mapzen_geocode.h"
  21 #include "mapzen_revgeocode.h"
  22 #include "mapzen_route.hpp"
  23 #include "mapzen_place.h"
  24 #include "mapzen_restcurl.h"
  25 #include "mapzen_util.h"
  26 #include "mapzen_debug.h"
  27
  28 pthread_mutex_t __requestLock;
  29 static GAsyncQueue *responseQueue = NULL;
  30 int __ResponseQueueLen = 0;
  31 bool __response_timer_running = false;
  32
  33 /* Request List */
  34 GList *requestList = NULL;
  35
  36 /* Request Cancel List */
  37 GList *reqCancelList = NULL;
  38
  39 static void __free_geocode_response(void *ptr);
  40 static void __free_revgeocode_response(void *ptr);
  41 static void __free_place_response(void *ptr);
  42 static void __free_place_details_response(void *ptr);
  43 static void __free_place_list_response(void *ptr);
  44 static void __free_route_response(void *ptr);
  45
  46 int add_to_geocode_list(mapzen_geocode_req_s *req_details, mapzen_geocode_cb callback, int request_id, void *user_data)
  47 {
  48         mapzen_request_s *req = (mapzen_request_s *)g_malloc0(sizeof(mapzen_request_s));
  49
  50         if (req != NULL) {
  51
  52                 req->type = REQ_TYPE_GEOCODE;
  53
  54                 mapzen_geocode_req *data = (mapzen_geocode_req *)g_malloc0(sizeof(mapzen_geocode_req));
  55
  56                 if (data != NULL) {
  57                         data->req_details = req_details;
  58                         data->requestId = request_id;
  59                         data->geocode_cb = callback;
  60                         data->user_data = user_data;
  61
  62                         req->request = data;
  63
  64                         MAP_DEBUG("Added GEOCODE REQUEST to geocode List");
  65
  66                         pthread_mutex_lock(&__requestLock);
  67                         if (requestList == NULL)
  68                                 requestList = g_list_append(requestList, (gpointer)req);
  69                         else
  70                                 requestList = g_list_insert_before(requestList, NULL, (gpointer)req);
  71                         pthread_mutex_unlock(&__requestLock);
  72                 }
  73         }
  74
  75         return MAPZEN_ERROR_NONE;
  76 }
  77
  78 int add_to_revgeocode_list(mapzen_revgeocode_req_s *req_details, mapzen_reverse_geocode_cb callback, int request_id, void *user_data)
  79 {
  80         mapzen_request_s *req = (mapzen_request_s *)g_malloc0(sizeof(mapzen_request_s));
  81
  82         if (req != NULL) {
  83
  84                 req->type = REQ_TYPE_REVGEOCODE;
  85
  86                 mapzen_revgeocode_req *data = (mapzen_revgeocode_req *)g_malloc0(sizeof(mapzen_revgeocode_req));
  87
  88                 if (data != NULL) {
  89                         data->req_details = req_details;
  90                         data->requestId = request_id;
  91                         data->revgeocode_cb = callback;
  92                         data->user_data = user_data;
  93
  94                         req->request = data;
  95
  96                         MAP_DEBUG("Added REVERSE GEOCODE request to geocode List");
  97
  98                         pthread_mutex_lock(&__requestLock);
  99                         if (requestList == NULL)
 100                                 requestList = g_list_append(requestList, (gpointer)req);
 101                         else
 102                                 requestList = g_list_insert_before(requestList, NULL, (gpointer)req);
 103                         pthread_mutex_unlock(&__requestLock);
 104                 }
 105         }
 106
 107         return MAPZEN_ERROR_NONE;
 108 }
 109
 110 int add_to_place_list(mapzen_search_req_s *req_details, mapzen_place_search_cb callback, int request_id, void *user_data)
 111 {
 112         mapzen_request_s *req = (mapzen_request_s *)g_malloc0(sizeof(mapzen_request_s));
 113
 114         if (req != NULL) {
 115
 116                 req->type = REQ_TYPE_PLACES;
 117
 118                 mapzen_search_place_req *data = (mapzen_search_place_req *)g_malloc0(sizeof(mapzen_search_place_req));
 119
 120                 if (data != NULL) {
 121                         data->req_details = req_details;
 122                         data->requestId = request_id;
 123                         data->search_place_cb = callback;
 124                         data->user_data = user_data;
 125
 126                         req->request = data;
 127
 128                         MAP_DEBUG("Added PLACE request to places List");
 129
 130                         pthread_mutex_lock(&__requestLock);
 131                         if (requestList == NULL)
 132                                 requestList = g_list_append(requestList, (gpointer)req);
 133                         else
 134                                 requestList = g_list_insert_before(requestList, NULL, (gpointer)req);
 135                         pthread_mutex_unlock(&__requestLock);
 136                 }
 137         }
 138
 139         return MAPZEN_ERROR_NONE;
 140 }
 141
 142 int add_to_place_details_list(mapzen_get_details_req_s *req_details, mapzen_get_place_details_cb callback, int request_id, void *user_data)
 143 {
 144         mapzen_request_s *req = (mapzen_request_s *)g_malloc0(sizeof(mapzen_request_s));
 145
 146         if (req != NULL) {
 147
 148                 req->type = REQ_TYPE_PLACES_DETAILS;
 149
 150                 mapzen_get_place_details_req *data = (mapzen_get_place_details_req *)g_malloc0(sizeof(mapzen_get_place_details_req));
 151
 152                 if (data != NULL) {
 153                         data->req_details = req_details;
 154                         data->requestId = request_id;
 155                         data->get_place_details_cb = callback;
 156                         data->user_data = user_data;
 157
 158                         req->request = data;
 159
 160                         MAP_DEBUG("Added PLACE Details request to places List");
 161
 162                         pthread_mutex_lock(&__requestLock);
 163                         if (requestList == NULL)
 164                                 requestList = g_list_append(requestList, (gpointer)req);
 165                         else
 166                                 requestList = g_list_insert_before(requestList, NULL, (gpointer)req);
 167                         pthread_mutex_unlock(&__requestLock);
 168                 }
 169         }
 170
 171         return MAPZEN_ERROR_NONE;
 172 }
 173
 174 int add_to_places_list(mapzen_search_req_s *req_details, mapzen_place_list_search_cb callback, int request_id, void *user_data)
 175 {
 176
 177         MAP_DEBUG("add_to_place_list");
 178
 179
 180         mapzen_request_s *req = (mapzen_request_s *)g_malloc0(sizeof(mapzen_request_s));
 181
 182         if (req != NULL) {
 183
 184                 req->type = REQ_TYPE_PLACES_LIST;
 185
 186                 mapzen_search_place_list_req *data = (mapzen_search_place_list_req *)g_malloc0(sizeof(mapzen_search_place_list_req));
 187
 188                 if (data != NULL) {
 189                         data->req_details = req_details;
 190                         data->requestId = request_id;
 191                         data->search_place_list_cb = callback;
 192                         data->user_data = user_data;
 193
 194                         req->request = data;
 195
 196                         MAP_DEBUG("Added PLACE request to places List");
 197
 198                         pthread_mutex_lock(&__requestLock);
 199                         if (requestList == NULL)
 200                                 requestList = g_list_append(requestList, (gpointer)req);
 201                         else
 202                                 requestList = g_list_insert_before(requestList, NULL, (gpointer)req);
 203                         pthread_mutex_unlock(&__requestLock);
 204                 }
 205         }
 206
 207         return MAPZEN_ERROR_NONE;
 208 }
 209
 210 int add_to_route_list(mapzen_route_req_s *req_details, mapzen_route_cb callback, int request_id, void *user_data)
 211 {
 212
 213         MAP_DEBUG("add_to_place_list");
 214
 215
 216         mapzen_request_s *req = (mapzen_request_s *)g_malloc0(sizeof(mapzen_request_s));
 217
 218         if (req != NULL) {
 219
 220                 req->type = REQ_TYPE_ROUTE;
 221
 222                 mapzen_route_req *data = (mapzen_route_req *)g_malloc0(sizeof(mapzen_route_req));
 223
 224                 if (data != NULL) {
 225                         data->req_details = req_details;
 226                         data->requestId = request_id;
 227                         data->route_cb = callback;
 228                         data->user_data = user_data;
 229
 230                         req->request = data;
 231
 232                         MAP_DEBUG("Added request to route List");
 233
 234                         pthread_mutex_lock(&__requestLock);
 235                         if (requestList == NULL)
 236                                 requestList = g_list_append(requestList, (gpointer)req);
 237                         else
 238                                 requestList = g_list_insert_before(requestList, NULL, (gpointer)req);
 239                         pthread_mutex_unlock(&__requestLock);
 240                 }
 241
 242         }
 243
 244         return MAPZEN_ERROR_NONE;
 245 }
 246
 247 static int __add_to_cancel_list(int request_id)
 248 {
 249         if (reqCancelList == NULL)
 250                 reqCancelList = g_list_append(reqCancelList, (gpointer) GINT_TO_POINTER(request_id));
 251         else
 252                 reqCancelList = g_list_insert_before(reqCancelList, NULL, (gpointer) GINT_TO_POINTER(request_id));
 253
 254         return MAPZEN_ERROR_NONE;
 255 }
 256
 257 static int __remove_from_cancel_list(int request_id)
 258 {
 259         if (g_list_length(reqCancelList) != 0)
 260                 reqCancelList = g_list_remove(reqCancelList, (gpointer) GINT_TO_POINTER(request_id));
 261
 262         return MAPZEN_ERROR_NONE;
 263 }
 264
 265 int remove_from_request_list(int request_id)
 266 {
 267         bool is_request_cancelled = false;
 268         GList *list = NULL;
 269         pthread_mutex_lock(&__requestLock);
 270         list = g_list_first(requestList);
 271         pthread_mutex_unlock(&__requestLock);
 272         mapzen_request_s *req = NULL;
 273
 274         while (list != NULL) {
 275                 req = (mapzen_request_s *) list->data;
 276
 277                 if (req != NULL) {
 278                         if (req->type == REQ_TYPE_GEOCODE) {
 279                                 mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 280
 281                                 if (geocode_req->requestId == request_id) {
 282                                         /* Means the request is pending in queue. Not started yet */
 283                                         /* Deleting the request from the request queue */
 284                                         pthread_mutex_lock(&__requestLock);
 285                                         requestList = g_list_remove(requestList, (gpointer)req);
 286                                         pthread_mutex_unlock(&__requestLock);
 287                                         mapzen_geocode_req_s *geocode_req_details = (mapzen_geocode_req_s *)geocode_req->req_details;
 288
 289                                         if (geocode_req_details)
 290                                                 g_free(geocode_req_details);
 291                                         geocode_req_details = NULL;
 292
 293                                         g_free(geocode_req);
 294                                         geocode_req = NULL;
 295
 296                                         g_free(req);
 297                                         req = NULL;
 298
 299                                         __remove_from_cancel_list(request_id);
 300
 301                                         is_request_cancelled = true;
 302                                         break;
 303                                 }
 304                         } else if (req->type == REQ_TYPE_REVGEOCODE) {
 305                                 mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *)req->request;
 306
 307                                 if (revgeocode_req->requestId == request_id) {
 308                                         /* Means the request is pending in queue. Not started yet */
 309                                         /* Deleting the request from the request queue */
 310                                         pthread_mutex_lock(&__requestLock);
 311                                         requestList = g_list_remove(requestList, (gpointer)req);
 312                                         pthread_mutex_unlock(&__requestLock);
 313                                         mapzen_revgeocode_req_s *reverse_geocode_req_details = (mapzen_revgeocode_req_s *)revgeocode_req->req_details;
 314
 315                                         if (reverse_geocode_req_details)
 316                                                 g_free(reverse_geocode_req_details);
 317                                         reverse_geocode_req_details = NULL;
 318
 319                                         g_free(revgeocode_req);
 320                                         revgeocode_req = NULL;
 321
 322                                         g_free(req);
 323                                         req = NULL;
 324
 325                                         __remove_from_cancel_list(request_id);
 326
 327                                         is_request_cancelled = true;
 328                                         break;
 329                                 }
 330                         } else if (req->type == REQ_TYPE_ROUTE) {
 331                                 mapzen_route_req *route_req = (mapzen_route_req *) req->request;
 332
 333                                 if (route_req->requestId == request_id) {
 334                                         /* Means the request is pending in queue. Not started yet */
 335                                         /* Deleting the request from the request queue */
 336                                         pthread_mutex_lock(&__requestLock);
 337                                         requestList = g_list_remove(requestList, (gpointer)req);
 338                                         pthread_mutex_unlock(&__requestLock);
 339                                         mapzen_route_req_s *route_req_details = (mapzen_route_req_s *)route_req->req_details;
 340
 341                                         if (route_req_details)
 342                                                 g_free(route_req_details);
 343                                         route_req_details = NULL;
 344
 345                                         g_free(route_req);
 346                                         route_req = NULL;
 347
 348                                         g_free(req);
 349                                         req = NULL;
 350
 351                                         __remove_from_cancel_list(request_id);
 352
 353                                         is_request_cancelled = true;
 354                                         break;
 355                                 }
 356                         } else if (req->type == REQ_TYPE_PLACES) {
 357                                 mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 358
 359                                 if (places_req->requestId == request_id) {
 360                                         /* Means the request is pending in queue. Not started yet */
 361                                         /* Deleting the request from the request queue */
 362                                         pthread_mutex_lock(&__requestLock);
 363                                         requestList = g_list_remove(requestList, (gpointer)req);
 364                                         pthread_mutex_unlock(&__requestLock);
 365                                         mapzen_search_req_s *place_req_details = (mapzen_search_req_s *)places_req->req_details;
 366
 367                                         if (place_req_details)
 368                                                 g_free(place_req_details);
 369                                         place_req_details = NULL;
 370
 371                                         g_free(places_req);
 372                                         places_req = NULL;
 373
 374                                         g_free(req);
 375                                         req = NULL;
 376
 377                                         __remove_from_cancel_list(request_id);
 378
 379                                         is_request_cancelled = true;
 380                                         break;
 381                                 }
 382                         } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
 383                                 mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
 384
 385                                 if (places_req->requestId == request_id) {
 386                                         /* Means the request is pending in queue. Not started yet */
 387                                         /* Deleting the request from the request queue */
 388                                         pthread_mutex_lock(&__requestLock);
 389                                         requestList = g_list_remove(requestList, (gpointer)req);
 390                                         pthread_mutex_unlock(&__requestLock);
 391                                         mapzen_get_details_req_s *place_req_details = (mapzen_get_details_req_s *)places_req->req_details;
 392
 393                                         if (place_req_details)
 394                                                 g_free(place_req_details);
 395                                         place_req_details = NULL;
 396
 397                                         g_free(places_req);
 398                                         places_req = NULL;
 399
 400                                         g_free(req);
 401                                         req = NULL;
 402
 403                                         __remove_from_cancel_list(request_id);
 404
 405                                         is_request_cancelled = true;
 406                                         break;
 407                                 }
 408                         } else if (req->type == REQ_TYPE_PLACES_LIST) {
 409                                 mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
 410
 411                                 if (places_req->requestId == request_id) {
 412                                         /* Means the request is pending in queue. Not started yet */
 413                                         /* Deleting the request from the request queue */
 414                                         pthread_mutex_lock(&__requestLock);
 415                                         requestList = g_list_remove(requestList, (gpointer)req);
 416                                         pthread_mutex_unlock(&__requestLock);
 417                                         mapzen_search_req_s *place_req_details = (mapzen_search_req_s *)places_req->req_details;
 418
 419                                         if (place_req_details)
 420                                                 g_free(place_req_details);
 421                                         place_req_details = NULL;
 422
 423                                         g_free(places_req);
 424                                         places_req = NULL;
 425
 426                                         g_free(req);
 427                                         req = NULL;
 428
 429                                         __remove_from_cancel_list(request_id);
 430
 431                                         is_request_cancelled = true;
 432                                         break;
 433                                 }
 434                         }
 435                 }
 436
 437                 list = g_list_next(list);
 438         }
 439
 440         if (!is_request_cancelled) {
 441                 /* Means it is currently running. */
 442                 /* Cancel the request */
 443                 cancel_request(request_id);
 444                 /* add to cancel list */
 445                 __add_to_cancel_list(request_id);
 446         }
 447
 448         return MAPZEN_ERROR_NONE;
 449 }
 450
 451 static bool __is_request_in_cancel_list(int requestId)
 452 {
 453         bool match_id = false;
 454
 455         GList *list = NULL;
 456         list = g_list_first(reqCancelList);
 457
 458         while (list != NULL) {
 459
 460                 int id = (int) GPOINTER_TO_INT(list->data);
 461
 462                 if (id == requestId) {
 463                         match_id = true;
 464                         break;
 465                 }
 466
 467                 list = g_list_next(list);
 468         }
 469
 470         return match_id;
 471 }
 472
 473 mapzen_request_s *get_next_request()
 474 {
 475         if (g_list_length(requestList) > 0) {
 476                 pthread_mutex_lock(&__requestLock);
 477                 GList *list = g_list_first(requestList);
 478                 pthread_mutex_unlock(&__requestLock);
 479
 480                 if (list) {
 481                         mapzen_request_s *req = (mapzen_request_s *) list->data;
 482                         return req;
 483                 } else {
 484                         return NULL;
 485                 }
 486         }
 487
 488         return NULL;
 489 }
 490
 491 static gboolean __timeout_cb(gpointer data)
 492 {
 493         MAP_DEBUG("timeout_cb");
 494         __response_timer_running = true;
 495         g_async_queue_ref(responseQueue);
 496
 497         __ResponseQueueLen = g_async_queue_length(responseQueue);
 498         MAP_DEBUG("Queue Len :: [%d]", __ResponseQueueLen);
 499         while (__ResponseQueueLen > 0) {
 500                 gpointer data = g_async_queue_try_pop(responseQueue);
 501                 if (!data)
 502                         continue;
 503
 504                 MapzenQueueData *response = (MapzenQueueData *) data;
 505
 506                 switch (response->type) {
 507                 case RESP_TYPE_GEOCODE:
 508                         {
 509                                 MAP_DEBUG("Got geocode response..");
 510                                 MapzenGeocodeResponseData *geocodeData = (MapzenGeocodeResponseData *) (response->data);
 511                                 if (geocodeData) {
 512                                         if (__is_request_in_cancel_list(geocodeData->requestId) == false) {
 513                                                 /* Deliver results to consumer */
 514                                                 geocodeData->geocode_cb(geocodeData->error, geocodeData->requestId, geocodeData->coords, geocodeData->user_data);
 515                                         } else {
 516                                                 /* If present in cancel list, dont trigger the response. */
 517                                                 /* Remove the requestId from cancel list. */
 518                                                 __remove_from_cancel_list(geocodeData->requestId);
 519                                         }
 520                                         __free_geocode_response(geocodeData);
 521
 522                                         g_free(geocodeData);
 523                                         geocodeData = NULL;
 524                                 }
 525
 526                                 /* Start the Next valid request */
 527                                 if (get_num_running_requests() < CURL_MAX_CONNECTS) {
 528                                         MAP_DEBUG("Fetching the next request from the request list....");
 529                                         mapzen_request_s *req = get_next_request();
 530                                         if (req) {
 531                                                 pthread_mutex_lock(&__requestLock);
 532                                                 requestList = g_list_remove(requestList, (gpointer)req);
 533                                                 pthread_mutex_unlock(&__requestLock);
 534
 535                                                 if (req->type == REQ_TYPE_GEOCODE) {
 536                                                         mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 537                                                         if (geocode_req != NULL) {
 538                                                                 start_geocode_service(geocode_req->req_details, geocode_req->geocode_cb, geocode_req->requestId, geocode_req->user_data);
 539
 540                                                                 g_free(geocode_req);
 541                                                                 geocode_req = NULL;
 542                                                         }
 543                                                 } else if (req->type == REQ_TYPE_REVGEOCODE) {
 544                                                         mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *) req->request;
 545                                                         if (revgeocode_req != NULL) {
 546                                                                 start_reversegeocode_service(revgeocode_req->req_details, revgeocode_req->revgeocode_cb, revgeocode_req->requestId, revgeocode_req->user_data);
 547
 548                                                                 g_free(revgeocode_req);
 549                                                                 revgeocode_req = NULL;
 550                                                         }
 551                                                 } else if (req->type == REQ_TYPE_PLACES) {
 552                                                         mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 553                                                         if (places_req) {
 554                                                                 start_place_service(places_req->req_details, places_req->search_place_cb, places_req->requestId, places_req->user_data);
 555
 556                                                                 g_free(places_req);
 557                                                                 places_req = NULL;
 558                                                         }
 559                                                 } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
 560                                                         mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
 561                                                         if (places_req) {
 562                                                                 start_place_details_service(places_req->req_details, places_req->get_place_details_cb, places_req->requestId, places_req->user_data);
 563
 564                                                                 g_free(places_req);
 565                                                                 places_req = NULL;
 566                                                         }
 567                                                 } else if (req->type == REQ_TYPE_PLACES_LIST) {
 568                                                         mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
 569                                                         if (places_req) {
 570                                                                 start_places_list_service(places_req->req_details, places_req->search_place_list_cb, places_req->requestId, places_req->user_data);
 571
 572                                                                 g_free(places_req);
 573                                                                 places_req = NULL;
 574                                                         }
 575                                                 } else if (req->type == REQ_TYPE_ROUTE) {
 576                                                         mapzen_route_req *route_req = (mapzen_route_req *) req->request;
 577                                                         if (route_req) {
 578                                                                 start_route_service(route_req->req_details, route_req->route_cb, route_req->requestId, route_req->user_data);
 579
 580                                                                 g_free(route_req);
 581                                                                 route_req = NULL;
 582                                                         }
 583                                                 }
 584
 585                                                 g_free(req);
 586                                                 req = NULL;
 587                                         } else {
 588                                                 MAP_DEBUG("No request in queue or request type is wrong");
 589                                         }
 590                                 } else {
 591                                         MAP_DEBUG("Libcurl request queue is FULL..");
 592                                 }
 593                         }
 594                         break;
 595
 596                 case RESP_TYPE_REVGEOCODE:
 597                         {
 598                                 MapzenRevGeocodeResponseData *revGeocodeData = (MapzenRevGeocodeResponseData *) (response->data);
 599                                 if (revGeocodeData) {
 600                                         if (__is_request_in_cancel_list(revGeocodeData->requestId) == false) {
 601                                                 /* Deliver results to consumer */
 602                                                 revGeocodeData->reverse_geocode_cb(revGeocodeData->error, revGeocodeData->requestId, revGeocodeData->addressDetails, revGeocodeData->user_data);
 603                                         } else {
 604                                                 /* If present in cancel list, dont trigger the response. */
 605                                                 /* Remove the requestId from cancel list. */
 606                                                 __remove_from_cancel_list(revGeocodeData->requestId);
 607                                         }
 608                                         __free_revgeocode_response(revGeocodeData);
 609
 610                                         g_free(revGeocodeData);
 611                                         revGeocodeData = NULL;
 612                                 }
 613
 614                                 /* Start the Next valid request */
 615                                 MAP_DEBUG(">> Condition Check <<");
 616                                 if (get_num_running_requests() < CURL_MAX_CONNECTS) {
 617                                         MAP_DEBUG("Fetching the next request from the request list....");
 618                                         mapzen_request_s *req = get_next_request();
 619                                         if (req) {
 620                                                 pthread_mutex_lock(&__requestLock);
 621                                                 requestList = g_list_remove(requestList, (gpointer)req);
 622                                                 pthread_mutex_unlock(&__requestLock);
 623
 624                                                 if (req->type == REQ_TYPE_GEOCODE) {
 625                                                         mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 626                                                         if (geocode_req != NULL) {
 627                                                                 start_geocode_service(geocode_req->req_details, geocode_req->geocode_cb, geocode_req->requestId, geocode_req->user_data);
 628
 629                                                                 g_free(geocode_req);
 630                                                                 geocode_req = NULL;
 631                                                         }
 632                                                 } else if (req->type == REQ_TYPE_REVGEOCODE) {
 633                                                         mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *) req->request;
 634                                                         if (revgeocode_req != NULL) {
 635                                                                 start_reversegeocode_service(revgeocode_req->req_details, revgeocode_req->revgeocode_cb, revgeocode_req->requestId, revgeocode_req->user_data);
 636
 637                                                                 g_free(revgeocode_req);
 638                                                                 revgeocode_req = NULL;
 639                                                         }
 640                                                 } else if (req->type == REQ_TYPE_PLACES) {
 641                                                         mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 642                                                         if (places_req) {
 643                                                                 start_place_service(places_req->req_details, places_req->search_place_cb, places_req->requestId, places_req->user_data);
 644
 645                                                                 g_free(places_req);
 646                                                                 places_req = NULL;
 647                                                         }
 648                                                 } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
 649                                                         mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
 650                                                         if (places_req) {
 651                                                                 start_place_details_service(places_req->req_details, places_req->get_place_details_cb, places_req->requestId, places_req->user_data);
 652
 653                                                                 g_free(places_req);
 654                                                                 places_req = NULL;
 655                                                         }
 656                                                 } else if (req->type == REQ_TYPE_PLACES_LIST) {
 657                                                         mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
 658                                                         if (places_req) {
 659                                                                 start_places_list_service(places_req->req_details, places_req->search_place_list_cb, places_req->requestId, places_req->user_data);
 660
 661                                                                 g_free(places_req);
 662                                                                 places_req = NULL;
 663                                                         }
 664                                                 } else if (req->type == REQ_TYPE_ROUTE) {
 665                                                         mapzen_route_req *route_req = (mapzen_route_req *) req->request;
 666                                                         if (route_req) {
 667                                                                 start_route_service(route_req->req_details, route_req->route_cb, route_req->requestId, route_req->user_data);
 668
 669                                                                 g_free(route_req);
 670                                                                 route_req = NULL;
 671                                                         }
 672                                                 }
 673
 674                                                 g_free(req);
 675                                                 req = NULL;
 676                                         } else {
 677                                                 MAP_DEBUG("No request in queue or request type is wrong");
 678                                         }
 679                                 } else {
 680                                         MAP_DEBUG("Libcurl request queue is FULL..");
 681                                 }
 682                         }
 683                         break;
 684
 685                 case RESP_TYPE_ROUTE:
 686                         {
 687                                 MapzenRouteResponseData *routeData = (MapzenRouteResponseData *) (response->data);
 688                                 if (routeData != NULL) {
 689                                         if (__is_request_in_cancel_list(routeData->requestId) == false) {
 690                                                 /* Deliver results to consumer */
 691                                                 routeData->route_cb(routeData->error, routeData->requestId, routeData->routeResponse, routeData->user_data);
 692                                         } else {
 693                                                 /* If present in cancel list, dont trigger the response. */
 694                                                 /* Remove the requestId from cancel list. */
 695                                                 __remove_from_cancel_list(routeData->requestId);
 696                                         }
 697                                         __free_route_response(routeData);
 698
 699                                         g_free(routeData);
 700                                         routeData = NULL;
 701                                 }
 702
 703                                 /* Start the Next valid request */
 704                                 if (get_num_running_requests() < CURL_MAX_CONNECTS) {
 705                                         MAP_DEBUG("Fetching the next request from the request list....");
 706                                         mapzen_request_s *req = get_next_request();
 707                                         if (req) {
 708                                                 pthread_mutex_lock(&__requestLock);
 709                                                 requestList = g_list_remove(requestList, (gpointer)req);
 710                                                 pthread_mutex_unlock(&__requestLock);
 711
 712                                                 if (req->type == REQ_TYPE_GEOCODE) {
 713                                                         mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 714                                                         if (geocode_req != NULL) {
 715                                                                 start_geocode_service(geocode_req->req_details, geocode_req->geocode_cb, geocode_req->requestId, geocode_req->user_data);
 716
 717                                                                 g_free(geocode_req);
 718                                                                 geocode_req = NULL;
 719                                                         }
 720                                                 } else if (req->type == REQ_TYPE_REVGEOCODE) {
 721                                                         mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *) req->request;
 722                                                         if (revgeocode_req != NULL) {
 723                                                                 start_reversegeocode_service(revgeocode_req->req_details, revgeocode_req->revgeocode_cb, revgeocode_req->requestId, revgeocode_req->user_data);
 724
 725                                                                 g_free(revgeocode_req);
 726                                                                 revgeocode_req = NULL;
 727                                                         }
 728                                                 } else if (req->type == REQ_TYPE_PLACES) {
 729                                                         mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 730                                                         if (places_req) {
 731                                                                 start_place_service(places_req->req_details, places_req->search_place_cb, places_req->requestId, places_req->user_data);
 732
 733                                                                 g_free(places_req);
 734                                                                 places_req = NULL;
 735                                                         }
 736                                                 } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
 737                                                         mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
 738                                                         if (places_req) {
 739                                                                 start_place_details_service(places_req->req_details, places_req->get_place_details_cb, places_req->requestId, places_req->user_data);
 740
 741                                                                 g_free(places_req);
 742                                                                 places_req = NULL;
 743                                                         }
 744                                                 } else if (req->type == REQ_TYPE_PLACES_LIST) {
 745                                                         mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
 746                                                         if (places_req) {
 747                                                                 start_places_list_service(places_req->req_details, places_req->search_place_list_cb, places_req->requestId, places_req->user_data);
 748
 749                                                                 g_free(places_req);
 750                                                                 places_req = NULL;
 751                                                         }
 752                                                 } else if (req->type == REQ_TYPE_ROUTE) {
 753                                                         mapzen_route_req *route_req = (mapzen_route_req *) req->request;
 754                                                         if (route_req) {
 755                                                                 start_route_service(route_req->req_details, route_req->route_cb, route_req->requestId, route_req->user_data);
 756
 757                                                                 g_free(route_req);
 758                                                                 route_req = NULL;
 759                                                         }
 760                                                 }
 761
 762                                                 g_free(req);
 763                                                 req = NULL;
 764                                         } else {
 765                                                 MAP_DEBUG("No request in queue or request type is wrong");
 766                                         }
 767                                 } else {
 768                                         MAP_DEBUG("Libcurl request queue is FULL..");
 769                                 }
 770                         }
 771                         break;
 772
 773                 case RESP_TYPE_PLACES:
 774                         {
 775                                 MapzenPlaceResponseData *placesData = (MapzenPlaceResponseData *) (response->data);
 776                                 if (placesData != NULL) {
 777                                         MAP_DEBUG("Sending places result.");
 778                                         if (__is_request_in_cancel_list(placesData->requestId) == false) {
 779                                                 /* Deliver results to consumer */
 780                                                 placesData->place_search_cb(placesData->error, placesData->requestId, placesData->places, placesData->user_data);
 781                                         } else {
 782                                                 /* If present in cancel list, dont trigger the response. */
 783                                                 /* Remove the requestId from cancel list. */
 784                                                 __remove_from_cancel_list(placesData->requestId);
 785                                         }
 786                                         __free_place_response(placesData);
 787
 788                                         g_free(placesData);
 789                                         placesData = NULL;
 790                                 }
 791
 792                                 /* Start the Next valid request */
 793                                 if (get_num_running_requests() < CURL_MAX_CONNECTS) {
 794                                         MAP_DEBUG("Fetching the next request from the request list....");
 795                                         mapzen_request_s *req = get_next_request();
 796                                         if (req) {
 797                                                 pthread_mutex_lock(&__requestLock);
 798                                                 requestList = g_list_remove(requestList, (gpointer)req);
 799                                                 pthread_mutex_unlock(&__requestLock);
 800
 801                                                 if (req->type == REQ_TYPE_GEOCODE) {
 802                                                         mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 803                                                         if (geocode_req != NULL) {
 804                                                                 start_geocode_service(geocode_req->req_details, geocode_req->geocode_cb, geocode_req->requestId, geocode_req->user_data);
 805
 806                                                                 g_free(geocode_req);
 807                                                                 geocode_req = NULL;
 808                                                         }
 809                                                 } else if (req->type == REQ_TYPE_REVGEOCODE) {
 810                                                         mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *) req->request;
 811                                                         if (revgeocode_req != NULL) {
 812                                                                 start_reversegeocode_service(revgeocode_req->req_details, revgeocode_req->revgeocode_cb, revgeocode_req->requestId, revgeocode_req->user_data);
 813
 814                                                                 g_free(revgeocode_req);
 815                                                                 revgeocode_req = NULL;
 816                                                         }
 817                                                 } else if (req->type == REQ_TYPE_PLACES) {
 818                                                         mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 819                                                         if (places_req) {
 820                                                                 start_place_service(places_req->req_details, places_req->search_place_cb, places_req->requestId, places_req->user_data);
 821
 822                                                                 g_free(places_req);
 823                                                                 places_req = NULL;
 824                                                         }
 825                                                 } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
 826                                                         mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
 827                                                         if (places_req) {
 828                                                                 start_place_details_service(places_req->req_details, places_req->get_place_details_cb, places_req->requestId, places_req->user_data);
 829
 830                                                                 g_free(places_req);
 831                                                                 places_req = NULL;
 832                                                         }
 833                                                 } else if (req->type == REQ_TYPE_PLACES_LIST) {
 834                                                         mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
 835                                                         if (places_req) {
 836                                                                 start_places_list_service(places_req->req_details, places_req->search_place_list_cb, places_req->requestId, places_req->user_data);
 837
 838                                                                 g_free(places_req);
 839                                                                 places_req = NULL;
 840                                                         }
 841                                                 } else if (req->type == REQ_TYPE_ROUTE) {
 842                                                         mapzen_route_req *route_req = (mapzen_route_req *) req->request;
 843                                                         if (route_req) {
 844                                                                 start_route_service(route_req->req_details, route_req->route_cb, route_req->requestId, route_req->user_data);
 845
 846                                                                 g_free(route_req);
 847                                                                 route_req = NULL;
 848                                                         }
 849                                                 }
 850
 851                                                 g_free(req);
 852                                                 req = NULL;
 853                                         } else {
 854                                                 MAP_DEBUG("No request in queue or request type is wrong");
 855                                         }
 856                                 } else {
 857                                         MAP_DEBUG("Libcurl request queue is FULL..");
 858                                 }
 859                         }
 860                         break;
 861                 case RESP_TYPE_PLACES_DETAILS:
 862                         {
 863                                 MapzenPlaceDetailsResponseData *placesData = (MapzenPlaceDetailsResponseData *) (response->data);
 864                                 if (placesData != NULL) {
 865                                         MAP_DEBUG("Sending places details result.");
 866                                         if (__is_request_in_cancel_list(placesData->requestId) == false) {
 867                                                 /* Deliver results to consumer */
 868                                                 placesData->get_place_details_cb(placesData->error, placesData->requestId, placesData->places, placesData->user_data);
 869                                         } else {
 870                                                 /* If present in cancel list, dont trigger the response. */
 871                                                 /* Remove the requestId from cancel list. */
 872                                                 __remove_from_cancel_list(placesData->requestId);
 873                                         }
 874                                         __free_place_details_response(placesData);
 875
 876                                         g_free(placesData);
 877                                         placesData = NULL;
 878                                 }
 879
 880                                 /* Start the Next valid request */
 881                                 if (get_num_running_requests() < CURL_MAX_CONNECTS) {
 882                                         MAP_DEBUG("Fetching the next request from the request list....");
 883                                         mapzen_request_s *req = get_next_request();
 884                                         if (req) {
 885                                                 pthread_mutex_lock(&__requestLock);
 886                                                 requestList = g_list_remove(requestList, (gpointer)req);
 887                                                 pthread_mutex_unlock(&__requestLock);
 888
 889                                                 if (req->type == REQ_TYPE_GEOCODE) {
 890                                                         mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 891                                                         if (geocode_req != NULL) {
 892                                                                 start_geocode_service(geocode_req->req_details, geocode_req->geocode_cb, geocode_req->requestId, geocode_req->user_data);
 893
 894                                                                 g_free(geocode_req);
 895                                                                 geocode_req = NULL;
 896                                                         }
 897                                                 } else if (req->type == REQ_TYPE_REVGEOCODE) {
 898                                                         mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *) req->request;
 899                                                         if (revgeocode_req != NULL) {
 900                                                                 start_reversegeocode_service(revgeocode_req->req_details, revgeocode_req->revgeocode_cb, revgeocode_req->requestId, revgeocode_req->user_data);
 901
 902                                                                 g_free(revgeocode_req);
 903                                                                 revgeocode_req = NULL;
 904                                                         }
 905                                                 } else if (req->type == REQ_TYPE_PLACES) {
 906                                                         mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 907                                                         if (places_req) {
 908                                                                 start_place_service(places_req->req_details, places_req->search_place_cb, places_req->requestId, places_req->user_data);
 909
 910                                                                 g_free(places_req);
 911                                                                 places_req = NULL;
 912                                                         }
 913                                                 } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
 914                                                         mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
 915                                                         if (places_req) {
 916                                                                 start_place_details_service(places_req->req_details, places_req->get_place_details_cb, places_req->requestId, places_req->user_data);
 917
 918                                                                 g_free(places_req);
 919                                                                 places_req = NULL;
 920                                                         }
 921                                                 } else if (req->type == REQ_TYPE_PLACES_LIST) {
 922                                                         mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
 923                                                         if (places_req) {
 924                                                                 start_places_list_service(places_req->req_details, places_req->search_place_list_cb, places_req->requestId, places_req->user_data);
 925
 926                                                                 g_free(places_req);
 927                                                                 places_req = NULL;
 928                                                         }
 929                                                 } else if (req->type == REQ_TYPE_ROUTE) {
 930                                                         mapzen_route_req *route_req = (mapzen_route_req *) req->request;
 931                                                         if (route_req) {
 932                                                                 start_route_service(route_req->req_details, route_req->route_cb, route_req->requestId, route_req->user_data);
 933
 934                                                                 g_free(route_req);
 935                                                                 route_req = NULL;
 936                                                         }
 937                                                 }
 938
 939                                                 g_free(req);
 940                                                 req = NULL;
 941                                         } else {
 942                                                 MAP_DEBUG("No request in queue or request type is wrong");
 943                                         }
 944                                 } else {
 945                                         MAP_DEBUG("Libcurl request queue is FULL..");
 946                                 }
 947                         }
 948                         break;
 949                 case RESP_TYPE_PLACES_LIST:
 950                         {
 951                                 MapzenPlaceListResponseData *placesData = (MapzenPlaceListResponseData *) (response->data);
 952                                 if (placesData != NULL) {
 953                                         MAP_DEBUG("Sending places list result.");
 954                                         if (__is_request_in_cancel_list(placesData->requestId) == false) {
 955                                                 /* Deliver results to consumer */
 956                                                 placesData->place_list_search_cb(placesData->error, placesData->requestId, placesData->places, placesData->user_data);
 957                                         } else {
 958                                                 /* If present in cancel list, dont trigger the response. */
 959                                                 /* Remove the requestId from cancel list. */
 960                                                 __remove_from_cancel_list(placesData->requestId);
 961                                         }
 962                                         __free_place_list_response(placesData);
 963
 964                                         g_free(placesData);
 965                                         placesData = NULL;
 966                                 }
 967
 968                                 /* Start the Next valid request */
 969                                 if (get_num_running_requests() < CURL_MAX_CONNECTS) {
 970                                         MAP_DEBUG("Fetching the next request from the request list....");
 971                                         mapzen_request_s *req = get_next_request();
 972                                         if (req) {
 973                                                 pthread_mutex_lock(&__requestLock);
 974                                                 requestList = g_list_remove(requestList, (gpointer)req);
 975                                                 pthread_mutex_unlock(&__requestLock);
 976
 977                                                 if (req->type == REQ_TYPE_GEOCODE) {
 978                                                         mapzen_geocode_req *geocode_req = (mapzen_geocode_req *) req->request;
 979                                                         if (geocode_req != NULL) {
 980                                                                 start_geocode_service(geocode_req->req_details, geocode_req->geocode_cb, geocode_req->requestId, geocode_req->user_data);
 981
 982                                                                 g_free(geocode_req);
 983                                                                 geocode_req = NULL;
 984                                                         }
 985                                                 } else if (req->type == REQ_TYPE_REVGEOCODE) {
 986                                                         mapzen_revgeocode_req *revgeocode_req = (mapzen_revgeocode_req *) req->request;
 987                                                         if (revgeocode_req != NULL) {
 988                                                                 start_reversegeocode_service(revgeocode_req->req_details, revgeocode_req->revgeocode_cb, revgeocode_req->requestId, revgeocode_req->user_data);
 989
 990                                                                 g_free(revgeocode_req);
 991                                                                 revgeocode_req = NULL;
 992                                                         }
 993                                                 } else if (req->type == REQ_TYPE_PLACES) {
 994                                                         mapzen_search_place_req *places_req = (mapzen_search_place_req *) req->request;
 995                                                         if (places_req) {
 996                                                                 start_place_service(places_req->req_details, places_req->search_place_cb, places_req->requestId, places_req->user_data);
 997
 998                                                                 g_free(places_req);
 999                                                                 places_req = NULL;
1000                                                         }
1001                                                 } else if (req->type == REQ_TYPE_PLACES_DETAILS) {
1002                                                         mapzen_get_place_details_req *places_req = (mapzen_get_place_details_req *) req->request;
1003                                                         if (places_req) {
1004                                                                 start_place_details_service(places_req->req_details, places_req->get_place_details_cb, places_req->requestId, places_req->user_data);
1005
1006                                                                 g_free(places_req);
1007                                                                 places_req = NULL;
1008                                                         }
1009                                                 } else if (req->type == REQ_TYPE_PLACES_LIST) {
1010                                                         mapzen_search_place_list_req *places_req = (mapzen_search_place_list_req *) req->request;
1011                                                         if (places_req) {
1012                                                                 start_places_list_service(places_req->req_details, places_req->search_place_list_cb, places_req->requestId, places_req->user_data);
1013
1014                                                                 g_free(places_req);
1015                                                                 places_req = NULL;
1016                                                         }
1017                                                 } else if (req->type == REQ_TYPE_ROUTE) {
1018                                                         mapzen_route_req *route_req = (mapzen_route_req *) req->request;
1019                                                         if (route_req) {
1020                                                                 start_route_service(route_req->req_details, route_req->route_cb, route_req->requestId, route_req->user_data);
1021
1022                                                                 g_free(route_req);
1023                                                                 route_req = NULL;
1024                                                         }
1025                                                 }
1026
1027                                                 g_free(req);
1028                                                 req = NULL;
1029                                         } else {
1030                                                 MAP_DEBUG("No request in queue or request type is wrong");
1031                                         }
1032                                 } else {
1033                                         MAP_DEBUG("Libcurl request queue is FULL..");
1034                                 }
1035                         }
1036                         break;
1037                 default:
1038                         MAP_DEBUG("UNKNOWN RESPONSE TYPE");
1039                         break;
1040                 }
1041
1042                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1043
1044                 if (response) {
1045                         g_free(response);
1046                         response = NULL;
1047                 }
1048         };
1049
1050         g_async_queue_unref(responseQueue);
1051
1052         __response_timer_running = false;
1053
1054         return false;
1055 }
1056
1057 static void __free_geocode_response(void *ptr)
1058 {
1059         MapzenGeocodeResponseData *geocodeData = (MapzenGeocodeResponseData *) (ptr);
1060
1061         if (geocodeData) {
1062                 GList *coords = NULL;
1063                 coords = g_list_first(geocodeData->coords);
1064
1065                 while (coords) {
1066                         coords_s *data = (coords_s *) coords->data;
1067
1068                         if (data) {
1069                                 geocodeData->coords = g_list_remove(geocodeData->coords, (gpointer)data);
1070
1071                                 g_free(data);
1072                                 data = NULL;
1073                         }
1074                         coords = g_list_first(geocodeData->coords);
1075                 }
1076
1077                 g_list_free(geocodeData->coords);
1078                 geocodeData->coords = NULL;
1079
1080                 if (geocodeData->user_data) {
1081                         g_free(geocodeData->user_data);
1082                         geocodeData->user_data = NULL;
1083                 }
1084         }
1085 }
1086
1087 static void __free_revgeocode_response(void *ptr)
1088 {
1089         MapzenRevGeocodeResponseData *revGeocodeData = (MapzenRevGeocodeResponseData *) (ptr);
1090         if (revGeocodeData) {
1091                 if (revGeocodeData->addressDetails) {
1092                         if (revGeocodeData->addressDetails->street) {
1093                                 g_free(revGeocodeData->addressDetails->street);
1094                                 revGeocodeData->addressDetails->street = NULL;
1095                         }
1096                         if (revGeocodeData->addressDetails->neighbourhood) {
1097                                 g_free(revGeocodeData->addressDetails->neighbourhood);
1098                                 revGeocodeData->addressDetails->neighbourhood = NULL;
1099                         }
1100                         if (revGeocodeData->addressDetails->localadmin) {
1101                                 g_free(revGeocodeData->addressDetails->localadmin);
1102                                 revGeocodeData->addressDetails->localadmin = NULL;
1103                         }
1104                         if (revGeocodeData->addressDetails->county) {
1105                                 g_free(revGeocodeData->addressDetails->county);
1106                                 revGeocodeData->addressDetails->county = NULL;
1107                         }
1108                         if (revGeocodeData->addressDetails->region) {
1109                                 g_free(revGeocodeData->addressDetails->region);
1110                                 revGeocodeData->addressDetails->region = NULL;
1111                         }
1112                         if (revGeocodeData->addressDetails->country) {
1113                                 g_free(revGeocodeData->addressDetails->country);
1114                                 revGeocodeData->addressDetails->country = NULL;
1115                         }
1116                         if (revGeocodeData->addressDetails->country_a) {
1117                                 g_free(revGeocodeData->addressDetails->country_a);
1118                                 revGeocodeData->addressDetails->country_a = NULL;
1119                         }
1120                         if (revGeocodeData->addressDetails->postalcode) {
1121                                 g_free(revGeocodeData->addressDetails->postalcode);
1122                                 revGeocodeData->addressDetails->postalcode = NULL;
1123                         }
1124
1125                         g_free(revGeocodeData->addressDetails);
1126                         revGeocodeData->addressDetails = NULL;
1127                 }
1128
1129                 if (revGeocodeData->user_data) {
1130                         g_free(revGeocodeData->user_data);
1131                         revGeocodeData->user_data = NULL;
1132                 }
1133         }
1134 }
1135
1136 static void __free_place_response(void *ptr)
1137 {
1138         MapzenPlaceResponseData *placeData = (MapzenPlaceResponseData *) (ptr);
1139         if (placeData) {
1140                 GList *place = NULL;
1141                 place = g_list_first(placeData->places);
1142
1143                 while (place) {
1144                         mapzen_place_resp_s *mapzen_place = (mapzen_place_resp_s *) place->data;
1145
1146                         if (mapzen_place->address) {
1147                                         if (mapzen_place->address->street) {
1148                                                 g_free(mapzen_place->address->street);
1149                                                 mapzen_place->address->street = NULL;
1150                                         }
1151                                         if (mapzen_place->address->neighbourhood) {
1152                                                 g_free(mapzen_place->address->neighbourhood);
1153                                                 mapzen_place->address->neighbourhood = NULL;
1154                                         }
1155                                         if (mapzen_place->address->housenumber) {
1156                                                 g_free(mapzen_place->address->housenumber);
1157                                                 mapzen_place->address->housenumber = NULL;
1158                                         }
1159                                         if (mapzen_place->address->localadmin) {
1160                                                 g_free(mapzen_place->address->localadmin);
1161                                                 mapzen_place->address->localadmin = NULL;
1162                                         }
1163                                         if (mapzen_place->address->county) {
1164                                                 g_free(mapzen_place->address->county);
1165                                                 mapzen_place->address->county = NULL;
1166                                         }
1167                                         if (mapzen_place->address->region) {
1168                                                 g_free(mapzen_place->address->region);
1169                                                 mapzen_place->address->region = NULL;
1170                                         }
1171                                         if (mapzen_place->address->country) {
1172                                                 g_free(mapzen_place->address->country);
1173                                                 mapzen_place->address->country = NULL;
1174                                         }
1175                                         if (mapzen_place->address->country_a) {
1176                                                 g_free(mapzen_place->address->country_a);
1177                                                 mapzen_place->address->country_a = NULL;
1178                                         }
1179                                         if (mapzen_place->address->postalcode) {
1180                                                 g_free(mapzen_place->address->postalcode);
1181                                                 mapzen_place->address->postalcode = NULL;
1182                                         }
1183                                 g_free(mapzen_place->address);
1184                                 mapzen_place->address = NULL;
1185                         }
1186
1187                         if (mapzen_place->categories) {
1188                                 if (g_list_length(mapzen_place->categories) > 0) {
1189
1190                                         g_list_foreach(mapzen_place->categories, (GFunc)g_free, NULL);
1191                                         g_list_free(mapzen_place->categories);
1192                                         mapzen_place->categories = NULL;
1193                                 }
1194                         }
1195
1196                         if (mapzen_place->place_id) {
1197                                 g_free(mapzen_place->place_id);
1198                                 mapzen_place->place_id = NULL;
1199                         }
1200
1201                         if (mapzen_place->display_name) {
1202                                 g_free(mapzen_place->display_name);
1203                                 mapzen_place->display_name = NULL;
1204                         }
1205
1206                         placeData->places = g_list_remove(placeData->places, (gpointer)mapzen_place);
1207
1208                         g_free(mapzen_place);
1209                         mapzen_place = NULL;
1210
1211                         place = g_list_first(placeData->places);
1212                 }
1213                 g_list_free(placeData->places);
1214                 placeData->places = NULL;
1215
1216                 if (placeData->user_data) {
1217                         g_free(placeData->user_data);
1218                         placeData->user_data = NULL;
1219                 }
1220         }
1221 }
1222
1223 static void __free_place_details_response(void *ptr)
1224 {
1225         MapzenPlaceDetailsResponseData *placeData = (MapzenPlaceDetailsResponseData *) (ptr);
1226         if (placeData) {
1227                 GList *place = NULL;
1228                 place = g_list_first(placeData->places);
1229
1230                 while (place) {
1231                         mapzen_place_resp_s *mapzen_place = (mapzen_place_resp_s *) place->data;
1232
1233                         if (mapzen_place->address) {
1234                                         if (mapzen_place->address->street) {
1235                                                 g_free(mapzen_place->address->street);
1236                                                 mapzen_place->address->street = NULL;
1237                                         }
1238                                         if (mapzen_place->address->neighbourhood) {
1239                                                 g_free(mapzen_place->address->neighbourhood);
1240                                                 mapzen_place->address->neighbourhood = NULL;
1241                                         }
1242                                         if (mapzen_place->address->housenumber) {
1243                                                 g_free(mapzen_place->address->housenumber);
1244                                                 mapzen_place->address->housenumber = NULL;
1245                                         }
1246                                         if (mapzen_place->address->localadmin) {
1247                                                 g_free(mapzen_place->address->localadmin);
1248                                                 mapzen_place->address->localadmin = NULL;
1249                                         }
1250                                         if (mapzen_place->address->county) {
1251                                                 g_free(mapzen_place->address->county);
1252                                                 mapzen_place->address->county = NULL;
1253                                         }
1254                                         if (mapzen_place->address->region) {
1255                                                 g_free(mapzen_place->address->region);
1256                                                 mapzen_place->address->region = NULL;
1257                                         }
1258                                         if (mapzen_place->address->country) {
1259                                                 g_free(mapzen_place->address->country);
1260                                                 mapzen_place->address->country = NULL;
1261                                         }
1262                                         if (mapzen_place->address->country_a) {
1263                                                 g_free(mapzen_place->address->country_a);
1264                                                 mapzen_place->address->country_a = NULL;
1265                                         }
1266                                         if (mapzen_place->address->postalcode) {
1267                                                 g_free(mapzen_place->address->postalcode);
1268                                                 mapzen_place->address->postalcode = NULL;
1269                                         }
1270                                 g_free(mapzen_place->address);
1271                                 mapzen_place->address = NULL;
1272                         }
1273
1274                         if (mapzen_place->categories) {
1275                                 if (g_list_length(mapzen_place->categories) > 0) {
1276
1277                                         g_list_foreach(mapzen_place->categories, (GFunc)g_free, NULL);
1278                                         g_list_free(mapzen_place->categories);
1279                                         mapzen_place->categories = NULL;
1280                                 }
1281                         }
1282
1283                         if (mapzen_place->place_id) {
1284                                 g_free(mapzen_place->place_id);
1285                                 mapzen_place->place_id = NULL;
1286                         }
1287
1288                         if (mapzen_place->display_name) {
1289                                 g_free(mapzen_place->display_name);
1290                                 mapzen_place->display_name = NULL;
1291                         }
1292
1293                         placeData->places = g_list_remove(placeData->places, (gpointer)mapzen_place);
1294
1295                         g_free(mapzen_place);
1296                         mapzen_place = NULL;
1297
1298                         place = g_list_first(placeData->places);
1299                 }
1300                 g_list_free(placeData->places);
1301                 placeData->places = NULL;
1302
1303                 if (placeData->user_data) {
1304                         g_free(placeData->user_data);
1305                         placeData->user_data = NULL;
1306                 }
1307         }
1308 }
1309
1310 static void __free_place_list_response(void *ptr)
1311 {
1312         MapzenPlaceListResponseData *placeData = (MapzenPlaceListResponseData *) (ptr);
1313         if (placeData) {
1314                 GList *place = NULL;
1315                 place = g_list_first(placeData->places);
1316
1317                 while (place) {
1318                         mapzen_place_resp_s *mapzen_place = (mapzen_place_resp_s *) place->data;
1319
1320                         if (mapzen_place->address) {
1321                                         if (mapzen_place->address->street) {
1322                                                 g_free(mapzen_place->address->street);
1323                                                 mapzen_place->address->street = NULL;
1324                                         }
1325                                         if (mapzen_place->address->neighbourhood) {
1326                                                 g_free(mapzen_place->address->neighbourhood);
1327                                                 mapzen_place->address->neighbourhood = NULL;
1328                                         }
1329                                         if (mapzen_place->address->housenumber) {
1330                                                 g_free(mapzen_place->address->housenumber);
1331                                                 mapzen_place->address->housenumber = NULL;
1332                                         }
1333                                         if (mapzen_place->address->localadmin) {
1334                                                 g_free(mapzen_place->address->localadmin);
1335                                                 mapzen_place->address->localadmin = NULL;
1336                                         }
1337                                         if (mapzen_place->address->county) {
1338                                                 g_free(mapzen_place->address->county);
1339                                                 mapzen_place->address->county = NULL;
1340                                         }
1341                                         if (mapzen_place->address->region) {
1342                                                 g_free(mapzen_place->address->region);
1343                                                 mapzen_place->address->region = NULL;
1344                                         }
1345                                         if (mapzen_place->address->country) {
1346                                                 g_free(mapzen_place->address->country);
1347                                                 mapzen_place->address->country = NULL;
1348                                         }
1349                                         if (mapzen_place->address->country_a) {
1350                                                 g_free(mapzen_place->address->country_a);
1351                                                 mapzen_place->address->country_a = NULL;
1352                                         }
1353                                         if (mapzen_place->address->postalcode) {
1354                                                 g_free(mapzen_place->address->postalcode);
1355                                                 mapzen_place->address->postalcode = NULL;
1356                                         }
1357                                 g_free(mapzen_place->address);
1358                                 mapzen_place->address = NULL;
1359                         }
1360
1361                         if (mapzen_place->categories) {
1362                                 if (g_list_length(mapzen_place->categories) > 0) {
1363
1364                                         g_list_foreach(mapzen_place->categories, (GFunc)g_free, NULL);
1365                                         g_list_free(mapzen_place->categories);
1366                                         mapzen_place->categories = NULL;
1367                                 }
1368                         }
1369
1370                         if (mapzen_place->place_id) {
1371                                 g_free(mapzen_place->place_id);
1372                                 mapzen_place->place_id = NULL;
1373                         }
1374
1375                         if (mapzen_place->display_name) {
1376                                 g_free(mapzen_place->display_name);
1377                                 mapzen_place->display_name = NULL;
1378                         }
1379
1380                         placeData->places = g_list_remove(placeData->places, (gpointer)mapzen_place);
1381
1382                         g_free(mapzen_place);
1383                         mapzen_place = NULL;
1384
1385                         place = g_list_first(placeData->places);
1386                 }
1387                 g_list_free(placeData->places);
1388                 placeData->places = NULL;
1389
1390                 if (placeData->user_data) {
1391                         g_free(placeData->user_data);
1392                         placeData->user_data = NULL;
1393                 }
1394         }
1395 }
1396
1397 static void __free_route_response(void *ptr)
1398 {
1399         MapzenRouteResponseData *routeData = (MapzenRouteResponseData *) (ptr);
1400         if (routeData) {
1401                  mapzen_route_resp_s *route_info = routeData->routeResponse;
1402                 if (route_info) {
1403                         GList *maneuver_data = NULL;
1404                         maneuver_data = g_list_first(route_info->maneuvers);
1405                         while (maneuver_data) {
1406                                 mapzen_route_maneuver *maneuver = (mapzen_route_maneuver *) maneuver_data->data;
1407
1408                                 if (maneuver->instruction) {
1409                                         g_free(maneuver->instruction);
1410                                         maneuver->instruction = NULL;
1411                                 }
1412                                 if (maneuver->formatted_time) {
1413                                         g_free(maneuver->formatted_time);
1414                                         maneuver->formatted_time = NULL;
1415                                 }
1416                                 if (maneuver->direction_name) {
1417                                         g_free(maneuver->direction_name);
1418                                         maneuver->direction_name = NULL;
1419                                 }
1420                                 if (maneuver->street_name) {
1421                                         g_free(maneuver->street_name);
1422                                         maneuver->street_name = NULL;
1423                                 }
1424
1425                                 route_info->maneuvers = g_list_remove(route_info->maneuvers, (gpointer)maneuver);
1426
1427                                 g_free(maneuver);
1428                                 maneuver = NULL;
1429
1430                                 /* Fetching the next item from Maneuver/Segment list */
1431                                 maneuver_data = g_list_first(route_info->maneuvers);
1432                         }
1433                         g_list_free(route_info->maneuvers);
1434                         route_info->maneuvers = NULL;
1435
1436                         GList *shapePoints = NULL;
1437                         shapePoints = g_list_first(route_info->shapePoints);
1438                         while (shapePoints) {
1439                                 coords_s *data = (coords_s *) shapePoints->data;
1440
1441                                 route_info->shapePoints = g_list_remove(route_info->shapePoints, (gpointer)data);
1442
1443                                 g_free(data);
1444                                 data = NULL;
1445
1446                                 shapePoints = g_list_first(route_info->shapePoints);
1447                         }
1448                         g_list_free(route_info->shapePoints);
1449                         route_info->shapePoints = NULL;
1450
1451                         if (route_info->formatted_time) {
1452                                 g_free(route_info->formatted_time);
1453                                 route_info->formatted_time = NULL;
1454                         }
1455                         g_free(route_info);
1456                         route_info = NULL;
1457                 }
1458                 if (routeData->user_data) {
1459                         g_free(routeData->user_data);
1460                         routeData->user_data = NULL;
1461                 }
1462         }
1463 }
1464
1465 int mapzen_init_queue()
1466 {
1467         pthread_mutex_init(&__requestLock, NULL);
1468
1469         /* Queue initialize */
1470         responseQueue = g_async_queue_new();
1471
1472         /* Initialise Curl Service */
1473         int ret = init_curl();
1474
1475         if (ret != MAPZEN_ERROR_NONE)
1476                 return MAPZEN_ERROR_UNKNOWN;
1477
1478         pthread_mutex_lock(&__requestLock);
1479         requestList = NULL;
1480         pthread_mutex_unlock(&__requestLock);
1481         reqCancelList = NULL;
1482         __ResponseQueueLen = 0;
1483         __response_timer_running = false;
1484
1485         return MAPZEN_ERROR_NONE;
1486 }
1487
1488 int mapzen_deinit_queue()
1489 {
1490         deinit_curl();
1491
1492         g_list_free(reqCancelList);
1493         reqCancelList = NULL;
1494
1495         pthread_mutex_destroy(&__requestLock);
1496
1497         /* Free the queue */
1498         if (responseQueue) {
1499                 g_async_queue_ref(responseQueue);
1500                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1501                 MAP_DEBUG("Queue len : %d", __ResponseQueueLen);
1502
1503                 while (__ResponseQueueLen > 0) {
1504                         gpointer data = g_async_queue_try_pop(responseQueue);
1505                         if (!data) {
1506                                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1507                                 continue;
1508                         }
1509
1510                         MapzenQueueData *response = (MapzenQueueData *) data;
1511
1512                         switch (response->type) {
1513                         case RESP_TYPE_GEOCODE:
1514                                 {
1515                                         MapzenGeocodeResponseData *geocodeData = (MapzenGeocodeResponseData *) (response->data);
1516                                         if (geocodeData) {
1517                                                 __free_geocode_response(geocodeData);
1518
1519                                                 g_free(geocodeData);
1520                                                 geocodeData = NULL;
1521                                         }
1522                                 }
1523                                 break;
1524                         case RESP_TYPE_REVGEOCODE:
1525                                 {
1526                                         MapzenRevGeocodeResponseData *revGeocodeData = (MapzenRevGeocodeResponseData *) (response->data);
1527                                         if (revGeocodeData) {
1528                                                 __free_revgeocode_response(revGeocodeData);
1529
1530                                                 g_free(revGeocodeData);
1531                                                 revGeocodeData = NULL;
1532                                         }
1533                                 }
1534                                 break;
1535                         case RESP_TYPE_PLACES:
1536                                 {
1537                                         MapzenPlaceResponseData *placeData = (MapzenPlaceResponseData *) (response->data);
1538                                         if (placeData != NULL) {
1539                                                 __free_place_response(placeData);
1540
1541                                                 g_free(placeData);
1542                                                 placeData = NULL;
1543                                         }
1544                                 }
1545                                 break;
1546                         case RESP_TYPE_PLACES_DETAILS:
1547                                 {
1548                                         MapzenPlaceDetailsResponseData *placeData = (MapzenPlaceDetailsResponseData *) (response->data);
1549                                         if (placeData != NULL) {
1550                                                 __free_place_details_response(placeData);
1551
1552                                                 g_free(placeData);
1553                                                 placeData = NULL;
1554                                         }
1555                                 }
1556                                 break;
1557                         case RESP_TYPE_PLACES_LIST:
1558                                 {
1559                                         MapzenPlaceListResponseData *placeData = (MapzenPlaceListResponseData *) (response->data);
1560                                         if (placeData != NULL) {
1561                                                 __free_place_list_response(placeData);
1562
1563                                                 g_free(placeData);
1564                                                 placeData = NULL;
1565                                         }
1566                                 }
1567                                 break;
1568                         case RESP_TYPE_ROUTE:
1569                                 {
1570                                         MapzenRouteResponseData *routeData = (MapzenRouteResponseData *) (response->data);
1571                                         if (routeData != NULL) {
1572                                                 __free_route_response(routeData);
1573
1574                                                 g_free(routeData);
1575                                                 routeData = NULL;
1576                                         }
1577                                 }
1578                                 break;
1579                         default:
1580                                 break;
1581                         }
1582
1583                         __ResponseQueueLen = g_async_queue_length(responseQueue);
1584
1585                         if (response) {
1586                                 g_free(response);
1587                                 response = NULL;
1588                         }
1589                 }
1590                 g_async_queue_unref(responseQueue);
1591                 responseQueue = NULL;
1592         }
1593
1594         return MAPZEN_ERROR_NONE;
1595 }
1596
1597 int mapzen_push_to_queue(mapzen_resp_type type, gpointer data)
1598 {
1599         MAP_DEBUG("Pushing to Queue....");
1600
1601         MapzenQueueData *queueData = (MapzenQueueData *)g_malloc0(sizeof(MapzenQueueData));
1602         if (!queueData) return MAPZEN_ERROR_OUT_OF_MEMORY;
1603
1604         queueData->type = type;
1605         queueData->data = data;
1606
1607         g_async_queue_ref(responseQueue);
1608         g_async_queue_push(responseQueue, (gpointer)queueData);
1609         g_async_queue_unref(responseQueue);
1610
1611         if (!__response_timer_running) {
1612                 MAP_DEBUG(">>>>>>>>>>>>>>>>>>>>>>> TRIGGER RESPONSE TIMER <<<<<<<<<<<<<<<<<<<<<<<<<");
1613                 g_timeout_add_seconds(1, __timeout_cb, NULL);   /* timeout : 1 sec */
1614         } else {
1615                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1616                 MAP_DEBUG(">>>>>>>>>>>>>>>>>> Timer already running. Response Queue Len [%d] <<<<<<<<<<<<<<<<<", __ResponseQueueLen);
1617         }
1618
1619         return MAPZEN_ERROR_NONE;
1620 }
1621
1622 int start_geocode_service(mapzen_geocode_req_s *req_details, mapzen_geocode_cb callback, int request_id, void *user_data)
1623 {
1624         int num_running_req = get_num_running_requests();
1625
1626         if (num_running_req >= CURL_MAX_CONNECTS) {
1627                 /* Add the request to queue */
1628                 add_to_geocode_list(req_details, callback, request_id, user_data);
1629         } else {
1630                 MapzenGeocodeQueryData *queryData = (MapzenGeocodeQueryData *)g_malloc0(sizeof(MapzenGeocodeQueryData));
1631
1632                 if (queryData != NULL) {
1633                         queryData->requestId = request_id;
1634                         queryData->geocode_cb = callback;
1635                         queryData->user_data = user_data;
1636
1637                         if (req_details->boundary != NULL) {
1638                                 if (req_details->boundary->type == MAPZEN_BOUNDARY_RECT) {
1639                                         MAP_DEBUG("TOP LEFT >>><<< LATITUDE : %f, LONGITUDE : %f", req_details->boundary->rect.top_left.latitude, req_details->boundary->rect.top_left.longitude);
1640                                         MAP_DEBUG("BOTTOM RIGHT >>><<< LATITUDE : %f, LONGITUDE : %f", req_details->boundary->rect.bottom_right.latitude, req_details->boundary->rect.bottom_right.longitude);
1641
1642                                         query_geocode_within_bounding_box(req_details->maps_key, req_details->address, req_details->boundary->rect.top_left, req_details->boundary->rect.bottom_right, req_details->num_res, queryData);
1643
1644                                 } else if (req_details->boundary->type == MAPZEN_BOUNDARY_CIRCLE) {
1645
1646                                         coords_s circle = req_details->boundary->circle.center;
1647                                         MAP_DEBUG("User input LATITUDE : %f, LONGITUDE : %f", circle.latitude, circle.longitude);
1648                                         query_geocode_within_circle(req_details->maps_key, req_details->address, circle, req_details->boundary->circle.radius, req_details->num_res, queryData);
1649
1650                                 } else {
1651                                         query_geocode(req_details->maps_key, req_details->address, req_details->num_res, queryData);
1652                                 }
1653
1654                         } else {
1655                                 MAP_DEBUG("BOUNDARY is NULL.. NORMAL GEOCODE QUERY WITHOUT BOUNDS");
1656
1657                                 query_geocode(req_details->maps_key, req_details->address, req_details->num_res, queryData);
1658                         }
1659                 }
1660
1661                 if (req_details) {
1662                         if (req_details->address) {
1663                                 g_free(req_details->address);
1664                                 req_details->address = NULL;
1665                         }
1666                         if (req_details->maps_key) {
1667                                 g_free(req_details->maps_key);
1668                                 req_details->maps_key = NULL;
1669                         }
1670                         if (req_details->boundary) {
1671                                 g_free(req_details->boundary);
1672                                 req_details->boundary = NULL;
1673                         }
1674                         g_free(req_details);
1675                         req_details = NULL;
1676                 }
1677         }
1678
1679         return MAPZEN_ERROR_NONE;
1680 }
1681
1682 int start_reversegeocode_service(mapzen_revgeocode_req_s *req_details, mapzen_reverse_geocode_cb callback, int request_id, void *user_data)
1683 {
1684         int num_running_req = get_num_running_requests();
1685
1686         if (num_running_req >= CURL_MAX_CONNECTS) {
1687                 /* Add the request to queue */
1688                 add_to_revgeocode_list(req_details, callback, request_id, user_data);
1689         } else {
1690                 MapzenRevGeocodeQueryData *queryData = (MapzenRevGeocodeQueryData *)g_malloc0(sizeof(MapzenRevGeocodeQueryData));
1691
1692                 if (queryData != NULL) {
1693                         queryData->requestId = request_id;
1694                         queryData->reverse_geocode_cb = callback;
1695                         queryData->user_data = user_data;
1696
1697                         coords_s coords = req_details->coordinates;
1698
1699                         query_revgeocode(req_details->maps_key, coords.latitude, coords.longitude, queryData);
1700                 }
1701
1702                 if (req_details) {
1703                         if (req_details->maps_key) {
1704                                 g_free(req_details->maps_key);
1705                                 req_details->maps_key = NULL;
1706                         }
1707                         g_free(req_details);
1708                         req_details = NULL;
1709                 }
1710         }
1711
1712         return MAPZEN_ERROR_NONE;
1713 }
1714
1715 int start_route_service(mapzen_route_req_s *req_details, mapzen_route_cb callback, int request_id, void *user_data)
1716 {
1717         int num_running_req = get_num_running_requests();
1718
1719         if (num_running_req >= CURL_MAX_CONNECTS) {
1720                 /* Add the request to queue */
1721                 add_to_route_list(req_details, callback, request_id, user_data);
1722         } else {
1723                 MapzenRouteQueryData *queryData = (MapzenRouteQueryData *)g_malloc0(sizeof(MapzenRouteQueryData));
1724
1725                 if (queryData != NULL) {
1726                         queryData->requestId = request_id;
1727                         queryData->route_cb = callback;
1728                         queryData->origin = req_details->from;
1729                         queryData->destination = req_details->to;
1730                         queryData->unit = req_details->unit;
1731                         queryData->user_data = user_data;
1732
1733                         query_route(req_details->maps_key, req_details->from, req_details->to, req_details->type, req_details->avoids, req_details->driving_style, req_details->way_points, queryData);
1734                 }
1735
1736                 if (req_details) {
1737                         if (req_details->maps_key) {
1738                                 g_free(req_details->maps_key);
1739                                 req_details->maps_key = NULL;
1740                         }
1741                         if (req_details->way_points) {
1742                                 if (g_list_length(req_details->way_points) > 0) {
1743                                         GList *list = NULL;
1744                                         list = g_list_first(req_details->way_points);
1745                                         while (list) {
1746                                                 coords_s *data = (coords_s *)list->data;
1747                                                 if (data) {
1748                                                         req_details->way_points = g_list_remove(req_details->way_points, (gpointer)data);
1749
1750                                                         g_free(data);
1751                                                         data = NULL;
1752                                                 }
1753                                                 list = g_list_first(req_details->way_points);
1754                                         }
1755                                 }
1756                                 g_list_free(req_details->way_points);
1757                                 req_details->way_points = NULL;
1758                         }
1759                         g_free(req_details);
1760                         req_details = NULL;
1761                 }
1762         }
1763
1764         return MAPZEN_ERROR_NONE;
1765 }
1766
1767 int start_place_service(mapzen_search_req_s *req_details, mapzen_place_search_cb callback, int request_id, void *user_data)
1768 {
1769         MAP_DEBUG("Inside start_place_service.");
1770
1771         int num_running_req = get_num_running_requests();
1772
1773         if (num_running_req >= CURL_MAX_CONNECTS) {
1774                 /* Add the request to queue */
1775                 add_to_place_list(req_details, callback, request_id, user_data);
1776         } else {
1777                 MapzenPlaceQueryData *queryData = (MapzenPlaceQueryData *)g_malloc0(sizeof(MapzenPlaceQueryData));
1778
1779                 if (queryData != NULL) {
1780                         queryData->requestId = request_id;
1781                         queryData->place_search_cb = callback;
1782                         queryData->user_data = user_data;
1783
1784                         query_places(req_details->maps_key, req_details->search_string, req_details->categories, req_details->boundary, req_details->num_res, queryData, REQ_TYPE_PLACES);
1785                 }
1786
1787                 if (req_details) {
1788                         if (req_details->maps_key) {
1789                                 g_free(req_details->maps_key);
1790                                 req_details->maps_key = NULL;
1791                         }
1792                         if (req_details->boundary) {
1793                                 g_free(req_details->boundary);
1794                                 req_details->boundary = NULL;
1795                         }
1796                         if (req_details->search_string) {
1797                                 g_free(req_details->search_string);
1798                                 req_details->search_string = NULL;
1799                         }
1800                         if (req_details->categories) {
1801                                 g_free(req_details->categories);
1802                                 req_details->categories = NULL;
1803                         }
1804                         g_free(req_details);
1805                         req_details = NULL;
1806                 }
1807         }
1808
1809         return MAPZEN_ERROR_NONE;
1810 }
1811
1812 int start_place_details_service(mapzen_get_details_req_s *req_details, mapzen_get_place_details_cb callback, int request_id, void *user_data)
1813 {
1814         MAP_DEBUG("Inside start_place_service.");
1815
1816         int num_running_req = get_num_running_requests();
1817
1818         if (num_running_req >= CURL_MAX_CONNECTS) {
1819                 /* Add the request to queue */
1820                 add_to_place_details_list(req_details, callback, request_id, user_data);
1821         } else {
1822                 MapzenPlaceDetailsQueryData *queryData = (MapzenPlaceDetailsQueryData *)g_malloc0(sizeof(MapzenPlaceDetailsQueryData));
1823
1824                 if (queryData != NULL) {
1825                         queryData->requestId = request_id;
1826                         queryData->get_place_details_cb = callback;
1827                         queryData->user_data = user_data;
1828
1829                         query_place_details(req_details->maps_key, req_details->uri, queryData);
1830                 }
1831
1832                 if (req_details) {
1833                         if (req_details->maps_key) {
1834                                 g_free(req_details->maps_key);
1835                                 req_details->maps_key = NULL;
1836                         }
1837                         if (req_details->uri) {
1838                                 g_free(req_details->uri);
1839                                 req_details->uri = NULL;
1840                         }
1841                         g_free(req_details);
1842                         req_details = NULL;
1843                 }
1844         }
1845
1846         return MAPZEN_ERROR_NONE;
1847 }
1848
1849 int start_places_list_service(mapzen_search_req_s *req_details, mapzen_place_list_search_cb callback, int request_id, void *user_data)
1850 {
1851         MAP_DEBUG("Inside start_places_list_service.");
1852
1853         int num_running_req = get_num_running_requests();
1854
1855         if (num_running_req >= CURL_MAX_CONNECTS) {
1856                 /* Add the request to queue */
1857                 add_to_places_list(req_details, callback, request_id, user_data);
1858         } else {
1859                 MapzenPlaceListQueryData *queryData = (MapzenPlaceListQueryData *)g_malloc0(sizeof(MapzenPlaceListQueryData));
1860
1861                 if (queryData != NULL) {
1862                         queryData->requestId = request_id;
1863                         queryData->place_list_search_cb = callback;
1864                         queryData->user_data = user_data;
1865
1866                         query_places(req_details->maps_key, req_details->search_string, req_details->categories, req_details->boundary, req_details->num_res, queryData, REQ_TYPE_PLACES_LIST);
1867                 }
1868
1869                 if (req_details) {
1870                         if (req_details->maps_key) {
1871                                 g_free(req_details->maps_key);
1872                                 req_details->maps_key = NULL;
1873                         }
1874                         if (req_details->boundary) {
1875                                 g_free(req_details->boundary);
1876                                 req_details->boundary = NULL;
1877                         }
1878                         if (req_details->search_string) {
1879                                 g_free(req_details->search_string);
1880                                 req_details->search_string = NULL;
1881                         }
1882                         if (req_details->categories) {
1883                                 g_free(req_details->categories);
1884                                 req_details->categories = NULL;
1885                         }
1886                         g_free(req_details);
1887                         req_details = NULL;
1888                 }
1889         }
1890
1891         return MAPZEN_ERROR_NONE;
1892 }