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         MAP_DEBUG(">>>>> START __free_route_response");
1400
1401         MapzenRouteResponseData *routeData = (MapzenRouteResponseData *) (ptr);
1402         if (routeData) {
1403                 MAP_DEBUG(">>>>> __free_route_response PROCESS: routeData");
1404                  mapzen_route_resp_s *route_info = routeData->routeResponse;
1405                 if (route_info) {
1406                         MAP_DEBUG(">>>>> __free_route_response PROCESS: route_info");
1407
1408                         GList *segment_data = NULL;
1409                         MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segment_data");
1410                         segment_data = g_list_first(route_info->segments);
1411                         while (segment_data) {
1412                                 mapzen_route_segment *segment = (mapzen_route_segment *) segment_data->data;
1413
1414                                 GList *maneuver_data = NULL;
1415                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE maneuver_data");
1416                                 maneuver_data = g_list_first(segment->maneuvers);
1417                                 while (maneuver_data) {
1418                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: maneuver_data");
1419                                         mapzen_route_maneuver *maneuver = (mapzen_route_maneuver *) maneuver_data->data;
1420
1421                                         if (maneuver->instruction) {
1422                                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: instruction");
1423                                                 g_free(maneuver->instruction);
1424                                                 maneuver->instruction = NULL;
1425                                         }
1426
1427                                         if (maneuver->street_name) {
1428                                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: street_name");
1429                                                 g_free(maneuver->street_name);
1430                                                 maneuver->street_name = NULL;
1431                                         }
1432
1433                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segments->maneuvers g_list_remove");
1434                                         segment->maneuvers = g_list_remove(segment->maneuvers, (gpointer)maneuver);
1435                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST segments->maneuvers g_list_remove");
1436
1437                                         g_free(maneuver);
1438                                         maneuver = NULL;
1439
1440                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segment->maneuvers g_list_first");
1441                                         /* Fetching the next item from Maneuver/Segment list */
1442                                         maneuver_data = g_list_first(segment->maneuvers);
1443                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST segment->maneuvers g_list_first");
1444                                 } /* Loop over maneuvers */
1445
1446                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (maneuver_data)");
1447                                 g_list_free(segment->maneuvers);
1448                                 segment->maneuvers = NULL;
1449
1450                                 GList *segmentShapePoints = NULL;
1451                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segmentShapePoints");
1452                                 segmentShapePoints = g_list_first(segment->shapePoints);
1453                                 while (segmentShapePoints) {
1454                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: segmentShapePoints");
1455                                         coords_s *data = (coords_s *) segmentShapePoints->data;
1456
1457                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_remove");
1458                                         segment->shapePoints = g_list_remove(segment->shapePoints, (gpointer)data);
1459                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_remove");
1460
1461                                         g_free(data);
1462                                         data = NULL;
1463
1464                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_first");
1465                                         segmentShapePoints = g_list_first(segment->shapePoints);
1466                                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_first");
1467                                 }
1468
1469                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (segmentShapePoints)");
1470                                 g_list_free(segment->shapePoints);
1471                                 segment->shapePoints = NULL;
1472
1473                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE route_info->segments g_list_remove");
1474                                 route_info->segments = g_list_remove(route_info->segments, (gpointer)segment);
1475                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST route_info->segments g_list_remove");
1476
1477                                 g_free(segment);
1478                                 segment = NULL;
1479
1480                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE route_info->segments g_list_first");
1481                                 /* Fetching the next item from Maneuver/Segment list */
1482                                 segment_data = g_list_first(route_info->segments);
1483                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST route_info->segments g_list_first");
1484
1485                         } /* Loop over segments */
1486
1487                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (segment_data)");
1488                         g_list_free(route_info->segments);
1489                         route_info->segments = NULL;
1490
1491                         GList *shapePoints = NULL;
1492                         MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE shapePoints");
1493                         shapePoints = g_list_first(route_info->shapePoints);
1494                         while (shapePoints) {
1495                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: shapePoints");
1496                                 coords_s *data = (coords_s *) shapePoints->data;
1497
1498                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_remove");
1499                                 route_info->shapePoints = g_list_remove(route_info->shapePoints, (gpointer)data);
1500                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_remove");
1501
1502                                 g_free(data);
1503                                 data = NULL;
1504
1505                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_first");
1506                                 shapePoints = g_list_first(route_info->shapePoints);
1507                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_first");
1508                         }
1509                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (shapePoints)");
1510                         g_list_free(route_info->shapePoints);
1511                         route_info->shapePoints = NULL;
1512
1513                         if (route_info->language) {
1514                                 MAP_DEBUG(">>>>> __free_route_response PROCESS: language");
1515                                 g_free(route_info->language);
1516                                 route_info->language = NULL;
1517                         }
1518
1519                         MAP_DEBUG(">>>>> __free_route_response PROCESS: g_free(route_info)");
1520                         g_free(route_info);
1521                         route_info = NULL;
1522                 }
1523                 MAP_DEBUG(">>>>> __free_route_response PROCESS: POST route_info");
1524
1525                 if (routeData->user_data) {
1526                         MAP_DEBUG(">>>>> __free_route_response PROCESS: user_data");
1527                         g_free(routeData->user_data);
1528                         routeData->user_data = NULL;
1529                         MAP_DEBUG(">>>>> __free_route_response PROCESS: POST user_data");
1530                 }
1531         }
1532         MAP_DEBUG(">>>>> END __free_route_response");
1533 }
1534
1535 int mapzen_init_queue()
1536 {
1537         pthread_mutex_init(&__requestLock, NULL);
1538
1539         /* Queue initialize */
1540         responseQueue = g_async_queue_new();
1541
1542         /* Initialise Curl Service */
1543         int ret = init_curl();
1544
1545         if (ret != MAPZEN_ERROR_NONE)
1546                 return MAPZEN_ERROR_UNKNOWN;
1547
1548         pthread_mutex_lock(&__requestLock);
1549         requestList = NULL;
1550         pthread_mutex_unlock(&__requestLock);
1551         reqCancelList = NULL;
1552         __ResponseQueueLen = 0;
1553         __response_timer_running = false;
1554
1555         return MAPZEN_ERROR_NONE;
1556 }
1557
1558 int mapzen_deinit_queue()
1559 {
1560         deinit_curl();
1561
1562         g_list_free(reqCancelList);
1563         reqCancelList = NULL;
1564
1565         pthread_mutex_destroy(&__requestLock);
1566
1567         /* Free the queue */
1568         if (responseQueue) {
1569                 g_async_queue_ref(responseQueue);
1570                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1571                 MAP_DEBUG("Queue len : %d", __ResponseQueueLen);
1572
1573                 while (__ResponseQueueLen > 0) {
1574                         gpointer data = g_async_queue_try_pop(responseQueue);
1575                         if (!data) {
1576                                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1577                                 continue;
1578                         }
1579
1580                         MapzenQueueData *response = (MapzenQueueData *) data;
1581
1582                         switch (response->type) {
1583                         case RESP_TYPE_GEOCODE:
1584                                 {
1585                                         MapzenGeocodeResponseData *geocodeData = (MapzenGeocodeResponseData *) (response->data);
1586                                         if (geocodeData) {
1587                                                 __free_geocode_response(geocodeData);
1588
1589                                                 g_free(geocodeData);
1590                                                 geocodeData = NULL;
1591                                         }
1592                                 }
1593                                 break;
1594                         case RESP_TYPE_REVGEOCODE:
1595                                 {
1596                                         MapzenRevGeocodeResponseData *revGeocodeData = (MapzenRevGeocodeResponseData *) (response->data);
1597                                         if (revGeocodeData) {
1598                                                 __free_revgeocode_response(revGeocodeData);
1599
1600                                                 g_free(revGeocodeData);
1601                                                 revGeocodeData = NULL;
1602                                         }
1603                                 }
1604                                 break;
1605                         case RESP_TYPE_PLACES:
1606                                 {
1607                                         MapzenPlaceResponseData *placeData = (MapzenPlaceResponseData *) (response->data);
1608                                         if (placeData != NULL) {
1609                                                 __free_place_response(placeData);
1610
1611                                                 g_free(placeData);
1612                                                 placeData = NULL;
1613                                         }
1614                                 }
1615                                 break;
1616                         case RESP_TYPE_PLACES_DETAILS:
1617                                 {
1618                                         MapzenPlaceDetailsResponseData *placeData = (MapzenPlaceDetailsResponseData *) (response->data);
1619                                         if (placeData != NULL) {
1620                                                 __free_place_details_response(placeData);
1621
1622                                                 g_free(placeData);
1623                                                 placeData = NULL;
1624                                         }
1625                                 }
1626                                 break;
1627                         case RESP_TYPE_PLACES_LIST:
1628                                 {
1629                                         MapzenPlaceListResponseData *placeData = (MapzenPlaceListResponseData *) (response->data);
1630                                         if (placeData != NULL) {
1631                                                 __free_place_list_response(placeData);
1632
1633                                                 g_free(placeData);
1634                                                 placeData = NULL;
1635                                         }
1636                                 }
1637                                 break;
1638                         case RESP_TYPE_ROUTE:
1639                                 {
1640                                         MapzenRouteResponseData *routeData = (MapzenRouteResponseData *) (response->data);
1641                                         if (routeData != NULL) {
1642                                                 __free_route_response(routeData);
1643
1644                                                 g_free(routeData);
1645                                                 routeData = NULL;
1646                                         }
1647                                 }
1648                                 break;
1649                         default:
1650                                 break;
1651                         }
1652
1653                         __ResponseQueueLen = g_async_queue_length(responseQueue);
1654
1655                         if (response) {
1656                                 g_free(response);
1657                                 response = NULL;
1658                         }
1659                 }
1660                 g_async_queue_unref(responseQueue);
1661                 responseQueue = NULL;
1662         }
1663
1664         return MAPZEN_ERROR_NONE;
1665 }
1666
1667 int mapzen_push_to_queue(mapzen_resp_type type, gpointer data)
1668 {
1669         MAP_DEBUG("Pushing to Queue....");
1670
1671         MapzenQueueData *queueData = (MapzenQueueData *)g_malloc0(sizeof(MapzenQueueData));
1672         if (!queueData) return MAPZEN_ERROR_OUT_OF_MEMORY;
1673
1674         queueData->type = type;
1675         queueData->data = data;
1676
1677         g_async_queue_ref(responseQueue);
1678         g_async_queue_push(responseQueue, (gpointer)queueData);
1679         g_async_queue_unref(responseQueue);
1680
1681         if (!__response_timer_running) {
1682                 MAP_DEBUG(">>>>>>>>>>>>>>>>>>>>>>> TRIGGER RESPONSE TIMER <<<<<<<<<<<<<<<<<<<<<<<<<");
1683                 g_timeout_add_seconds(1, __timeout_cb, NULL);   /* timeout : 1 sec */
1684         } else {
1685                 __ResponseQueueLen = g_async_queue_length(responseQueue);
1686                 MAP_DEBUG(">>>>>>>>>>>>>>>>>> Timer already running. Response Queue Len [%d] <<<<<<<<<<<<<<<<<", __ResponseQueueLen);
1687         }
1688
1689         return MAPZEN_ERROR_NONE;
1690 }
1691
1692 int start_geocode_service(mapzen_geocode_req_s *req_details, mapzen_geocode_cb callback, int request_id, void *user_data)
1693 {
1694         int num_running_req = get_num_running_requests();
1695
1696         if (num_running_req >= CURL_MAX_CONNECTS) {
1697                 /* Add the request to queue */
1698                 add_to_geocode_list(req_details, callback, request_id, user_data);
1699         } else {
1700                 MapzenGeocodeQueryData *queryData = (MapzenGeocodeQueryData *)g_malloc0(sizeof(MapzenGeocodeQueryData));
1701
1702                 if (queryData != NULL) {
1703                         queryData->requestId = request_id;
1704                         queryData->geocode_cb = callback;
1705                         queryData->user_data = user_data;
1706
1707                         if (req_details->boundary != NULL) {
1708                                 if (req_details->boundary->type == MAPZEN_BOUNDARY_RECT) {
1709                                         MAP_DEBUG("TOP LEFT >>><<< LATITUDE : %f, LONGITUDE : %f", req_details->boundary->rect.top_left.latitude, req_details->boundary->rect.top_left.longitude);
1710                                         MAP_DEBUG("BOTTOM RIGHT >>><<< LATITUDE : %f, LONGITUDE : %f", req_details->boundary->rect.bottom_right.latitude, req_details->boundary->rect.bottom_right.longitude);
1711
1712                                         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);
1713
1714                                 } else if (req_details->boundary->type == MAPZEN_BOUNDARY_CIRCLE) {
1715
1716                                         coords_s circle = req_details->boundary->circle.center;
1717                                         MAP_DEBUG("User input LATITUDE : %f, LONGITUDE : %f", circle.latitude, circle.longitude);
1718                                         query_geocode_within_circle(req_details->maps_key, req_details->address, circle, req_details->boundary->circle.radius, req_details->num_res, queryData);
1719
1720                                 } else {
1721                                         query_geocode(req_details->maps_key, req_details->address, req_details->num_res, queryData);
1722                                 }
1723
1724                         } else {
1725                                 MAP_DEBUG("BOUNDARY is NULL.. NORMAL GEOCODE QUERY WITHOUT BOUNDS");
1726
1727                                 query_geocode(req_details->maps_key, req_details->address, req_details->num_res, queryData);
1728                         }
1729                 }
1730
1731                 if (req_details) {
1732                         if (req_details->address) {
1733                                 g_free(req_details->address);
1734                                 req_details->address = NULL;
1735                         }
1736                         if (req_details->maps_key) {
1737                                 g_free(req_details->maps_key);
1738                                 req_details->maps_key = NULL;
1739                         }
1740                         if (req_details->boundary) {
1741                                 g_free(req_details->boundary);
1742                                 req_details->boundary = NULL;
1743                         }
1744                         g_free(req_details);
1745                         req_details = NULL;
1746                 }
1747         }
1748
1749         return MAPZEN_ERROR_NONE;
1750 }
1751
1752 int start_reversegeocode_service(mapzen_revgeocode_req_s *req_details, mapzen_reverse_geocode_cb callback, int request_id, void *user_data)
1753 {
1754         int num_running_req = get_num_running_requests();
1755
1756         if (num_running_req >= CURL_MAX_CONNECTS) {
1757                 /* Add the request to queue */
1758                 add_to_revgeocode_list(req_details, callback, request_id, user_data);
1759         } else {
1760                 MapzenRevGeocodeQueryData *queryData = (MapzenRevGeocodeQueryData *)g_malloc0(sizeof(MapzenRevGeocodeQueryData));
1761
1762                 if (queryData != NULL) {
1763                         queryData->requestId = request_id;
1764                         queryData->reverse_geocode_cb = callback;
1765                         queryData->user_data = user_data;
1766
1767                         coords_s coords = req_details->coordinates;
1768
1769                         query_revgeocode(req_details->maps_key, coords.latitude, coords.longitude, queryData);
1770                 }
1771
1772                 if (req_details) {
1773                         if (req_details->maps_key) {
1774                                 g_free(req_details->maps_key);
1775                                 req_details->maps_key = NULL;
1776                         }
1777                         g_free(req_details);
1778                         req_details = NULL;
1779                 }
1780         }
1781
1782         return MAPZEN_ERROR_NONE;
1783 }
1784
1785 int start_route_service(mapzen_route_req_s *req_details, mapzen_route_cb callback, int request_id, void *user_data)
1786 {
1787         int num_running_req = get_num_running_requests();
1788
1789         if (num_running_req >= CURL_MAX_CONNECTS) {
1790                 /* Add the request to queue */
1791                 add_to_route_list(req_details, callback, request_id, user_data);
1792         } else {
1793                 MapzenRouteQueryData *queryData = (MapzenRouteQueryData *)g_malloc0(sizeof(MapzenRouteQueryData));
1794
1795                 if (queryData != NULL) {
1796                         queryData->requestId = request_id;
1797                         queryData->route_cb = callback;
1798                         queryData->origin = req_details->from;
1799                         queryData->destination = req_details->to;
1800                         queryData->unit = req_details->unit;
1801                         queryData->user_data = user_data;
1802
1803                         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);
1804                 }
1805
1806                 if (req_details) {
1807                         if (req_details->maps_key) {
1808                                 g_free(req_details->maps_key);
1809                                 req_details->maps_key = NULL;
1810                         }
1811                         if (req_details->way_points) {
1812                                 if (g_list_length(req_details->way_points) > 0) {
1813                                         GList *list = NULL;
1814                                         list = g_list_first(req_details->way_points);
1815                                         while (list) {
1816                                                 coords_s *data = (coords_s *)list->data;
1817                                                 if (data) {
1818                                                         req_details->way_points = g_list_remove(req_details->way_points, (gpointer)data);
1819
1820                                                         g_free(data);
1821                                                         data = NULL;
1822                                                 }
1823                                                 list = g_list_first(req_details->way_points);
1824                                         }
1825                                 }
1826                                 g_list_free(req_details->way_points);
1827                                 req_details->way_points = NULL;
1828                         }
1829                         g_free(req_details);
1830                         req_details = NULL;
1831                 }
1832         }
1833
1834         return MAPZEN_ERROR_NONE;
1835 }
1836
1837 int start_place_service(mapzen_search_req_s *req_details, mapzen_place_search_cb callback, int request_id, void *user_data)
1838 {
1839         MAP_DEBUG("Inside start_place_service.");
1840
1841         int num_running_req = get_num_running_requests();
1842
1843         if (num_running_req >= CURL_MAX_CONNECTS) {
1844                 /* Add the request to queue */
1845                 add_to_place_list(req_details, callback, request_id, user_data);
1846         } else {
1847                 MapzenPlaceQueryData *queryData = (MapzenPlaceQueryData *)g_malloc0(sizeof(MapzenPlaceQueryData));
1848
1849                 if (queryData != NULL) {
1850                         queryData->requestId = request_id;
1851                         queryData->place_search_cb = callback;
1852                         queryData->user_data = user_data;
1853
1854                         query_places(req_details->maps_key, req_details->search_string, req_details->categories, req_details->boundary, req_details->num_res, queryData, REQ_TYPE_PLACES);
1855                 }
1856
1857                 if (req_details) {
1858                         if (req_details->maps_key) {
1859                                 g_free(req_details->maps_key);
1860                                 req_details->maps_key = NULL;
1861                         }
1862                         if (req_details->boundary) {
1863                                 g_free(req_details->boundary);
1864                                 req_details->boundary = NULL;
1865                         }
1866                         if (req_details->search_string) {
1867                                 g_free(req_details->search_string);
1868                                 req_details->search_string = NULL;
1869                         }
1870                         if (req_details->categories) {
1871                                 g_free(req_details->categories);
1872                                 req_details->categories = NULL;
1873                         }
1874                         g_free(req_details);
1875                         req_details = NULL;
1876                 }
1877         }
1878
1879         return MAPZEN_ERROR_NONE;
1880 }
1881
1882 int start_place_details_service(mapzen_get_details_req_s *req_details, mapzen_get_place_details_cb callback, int request_id, void *user_data)
1883 {
1884         MAP_DEBUG("Inside start_place_service.");
1885
1886         int num_running_req = get_num_running_requests();
1887
1888         if (num_running_req >= CURL_MAX_CONNECTS) {
1889                 /* Add the request to queue */
1890                 add_to_place_details_list(req_details, callback, request_id, user_data);
1891         } else {
1892                 MapzenPlaceDetailsQueryData *queryData = (MapzenPlaceDetailsQueryData *)g_malloc0(sizeof(MapzenPlaceDetailsQueryData));
1893
1894                 if (queryData != NULL) {
1895                         queryData->requestId = request_id;
1896                         queryData->get_place_details_cb = callback;
1897                         queryData->user_data = user_data;
1898
1899                         query_place_details(req_details->maps_key, req_details->uri, queryData);
1900                 }
1901
1902                 if (req_details) {
1903                         if (req_details->maps_key) {
1904                                 g_free(req_details->maps_key);
1905                                 req_details->maps_key = NULL;
1906                         }
1907                         if (req_details->uri) {
1908                                 g_free(req_details->uri);
1909                                 req_details->uri = NULL;
1910                         }
1911                         g_free(req_details);
1912                         req_details = NULL;
1913                 }
1914         }
1915
1916         return MAPZEN_ERROR_NONE;
1917 }
1918
1919 int start_places_list_service(mapzen_search_req_s *req_details, mapzen_place_list_search_cb callback, int request_id, void *user_data)
1920 {
1921         MAP_DEBUG("Inside start_places_list_service.");
1922
1923         int num_running_req = get_num_running_requests();
1924
1925         if (num_running_req >= CURL_MAX_CONNECTS) {
1926                 /* Add the request to queue */
1927                 add_to_places_list(req_details, callback, request_id, user_data);
1928         } else {
1929                 MapzenPlaceListQueryData *queryData = (MapzenPlaceListQueryData *)g_malloc0(sizeof(MapzenPlaceListQueryData));
1930
1931                 if (queryData != NULL) {
1932                         queryData->requestId = request_id;
1933                         queryData->place_list_search_cb = callback;
1934                         queryData->user_data = user_data;
1935
1936                         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);
1937                 }
1938
1939                 if (req_details) {
1940                         if (req_details->maps_key) {
1941                                 g_free(req_details->maps_key);
1942                                 req_details->maps_key = NULL;
1943                         }
1944                         if (req_details->boundary) {
1945                                 g_free(req_details->boundary);
1946                                 req_details->boundary = NULL;
1947                         }
1948                         if (req_details->search_string) {
1949                                 g_free(req_details->search_string);
1950                                 req_details->search_string = NULL;
1951                         }
1952                         if (req_details->categories) {
1953                                 g_free(req_details->categories);
1954                                 req_details->categories = NULL;
1955                         }
1956                         g_free(req_details);
1957                         req_details = NULL;
1958                 }
1959         }
1960
1961         return MAPZEN_ERROR_NONE;
1962 }