src/download-provider-db.c

   1 #include <db-util.h>
   2
   3 #include <string.h>
   4 #include <errno.h>
   5
   6 #include "download-provider-config.h"
   7 #include "download-provider-db.h"
   8 #include "download-provider-log.h"
   9
  10 __thread sqlite3 *g_download_provider_db = 0;
  11
  12 void __download_provider_db_close()
  13 {
  14         if (g_download_provider_db) {
  15                 db_util_close(g_download_provider_db);
  16         }
  17         g_download_provider_db = 0;
  18 }
  19
  20 int __download_provider_db_open()
  21 {
  22         if (db_util_open(DOWNLOAD_PROVIDER_DOWNLOADING_DB_NAME,
  23                          &g_download_provider_db,
  24                          DB_UTIL_REGISTER_HOOK_METHOD) != SQLITE_OK) {
  25                 TRACE_DEBUG_MSG("failed db_util_open [%s][%s]",
  26                                 DOWNLOAD_PROVIDER_DOWNLOADING_DB_NAME,
  27                                 sqlite3_errmsg(g_download_provider_db));
  28                 __download_provider_db_close();
  29                 return -1;
  30         }
  31         return g_download_provider_db ? 0 : -1;
  32 }
  33
  34 void _download_provider_sql_close(sqlite3_stmt *stmt)
  35 {
  36         if (sqlite3_finalize(stmt) != SQLITE_OK)
  37                 TRACE_DEBUG_MSG("failed sqlite3_finalize [%s]",
  38                                 sqlite3_errmsg(g_download_provider_db));
  39
  40         __download_provider_db_close();
  41 }
  42
  43 int _download_provider_sql_open()
  44 {
  45         __download_provider_db_close();
  46         return __download_provider_db_open();
  47 }
  48
  49 int download_provider_db_requestinfo_remove(int uniqueid)
  50 {
  51         int errorcode;
  52         sqlite3_stmt *stmt = NULL;
  53
  54         if (uniqueid <= 0) {
  55                 TRACE_DEBUG_MSG("[NULL-CHECK]");
  56                 return -1;
  57         }
  58
  59         if (_download_provider_sql_open() < 0) {
  60                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
  61                                 sqlite3_errmsg(g_download_provider_db));
  62                 return -1;
  63         }
  64
  65         errorcode =
  66             sqlite3_prepare_v2(g_download_provider_db,
  67                                "delete from downloading where uniqueid = ?",
  68                                -1, &stmt, NULL);
  69         if (errorcode != SQLITE_OK) {
  70                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
  71                                 sqlite3_errmsg(g_download_provider_db));
  72                 _download_provider_sql_close(stmt);
  73                 return -1;
  74         }
  75         if (sqlite3_bind_int(stmt, 1, uniqueid) != SQLITE_OK) {
  76                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
  77                                 sqlite3_errmsg(g_download_provider_db));
  78                 _download_provider_sql_close(stmt);
  79                 return -1;
  80         }
  81         errorcode = sqlite3_step(stmt);
  82         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
  83                 _download_provider_sql_close(stmt);
  84                 return 0;
  85         }
  86         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
  87                         sqlite3_errmsg(g_download_provider_db));
  88         __download_provider_db_close();
  89         return -1;
  90 }
  91
  92 int download_provider_db_requestinfo_new(download_clientinfo *clientinfo)
  93 {
  94         int errorcode;
  95         sqlite3_stmt *stmt = NULL;
  96
  97         if (!clientinfo || !clientinfo->requestinfo
  98                 || clientinfo->requestinfo->requestid <= 0) {
  99                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 100                 return -1;
 101         }
 102
 103         if (_download_provider_sql_open() < 0) {
 104                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 105                                 sqlite3_errmsg(g_download_provider_db));
 106                 return -1;
 107         }
 108
 109         errorcode =
 110             sqlite3_prepare_v2(g_download_provider_db,
 111                                "INSERT INTO downloading (uniqueid, packagename, notification, installpath, filename, creationdate, state, url, mimetype, savedpath) VALUES (?, ?, ?, ?, ?, DATETIME('now'), ?, ?, ?, ?)",
 112                                -1, &stmt, NULL);
 113         if (errorcode != SQLITE_OK) {
 114                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 115                                 sqlite3_errmsg(g_download_provider_db));
 116                 _download_provider_sql_close(stmt);
 117                 return -1;
 118         }
 119         if (sqlite3_bind_int(stmt, 1, clientinfo->requestinfo->requestid) !=
 120             SQLITE_OK) {
 121                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 122                                 sqlite3_errmsg(g_download_provider_db));
 123                 _download_provider_sql_close(stmt);
 124                 return -1;
 125         }
 126         if (clientinfo->requestinfo->client_packagename.length > 1) {
 127                 if (sqlite3_bind_text
 128                     (stmt, 2, clientinfo->requestinfo->client_packagename.str,
 129                      -1, NULL) != SQLITE_OK) {
 130                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 131                                         sqlite3_errmsg(g_download_provider_db));
 132                         _download_provider_sql_close(stmt);
 133                         return -1;
 134                 }
 135         }
 136         // notification
 137         if (sqlite3_bind_int(stmt, 3, clientinfo->requestinfo->notification) !=
 138             SQLITE_OK) {
 139                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 140                                 sqlite3_errmsg(g_download_provider_db));
 141                 _download_provider_sql_close(stmt);
 142                 return -1;
 143         }
 144         if (clientinfo->downloadinfo && sizeof(clientinfo->downloadinfo->content_name) > 1) {
 145                 if (sqlite3_bind_text
 146                     (stmt, 5, clientinfo->downloadinfo->content_name, -1,
 147                      NULL) != SQLITE_OK) {
 148                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 149                                         sqlite3_errmsg(g_download_provider_db));
 150                         _download_provider_sql_close(stmt);
 151                         return -1;
 152                 }
 153         }
 154         if (sqlite3_bind_int(stmt, 6, clientinfo->state) != SQLITE_OK) {
 155                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 156                                 sqlite3_errmsg(g_download_provider_db));
 157                 _download_provider_sql_close(stmt);
 158                 return -1;
 159         }
 160         if (clientinfo->requestinfo->url.length > 1) {
 161                 if (sqlite3_bind_text
 162                     (stmt, 7, clientinfo->requestinfo->url.str, -1,
 163                      NULL) != SQLITE_OK) {
 164                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 165                                         sqlite3_errmsg(g_download_provider_db));
 166                         _download_provider_sql_close(stmt);
 167                         return -1;
 168                 }
 169         }
 170         if (clientinfo->downloadinfo && sizeof(clientinfo->downloadinfo->mime_type) > 1) {
 171                 if (sqlite3_bind_text
 172                     (stmt, 8, clientinfo->downloadinfo->mime_type, -1,
 173                      NULL) != SQLITE_OK) {
 174                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 175                                         sqlite3_errmsg(g_download_provider_db));
 176                         _download_provider_sql_close(stmt);
 177                         return -1;
 178                 }
 179         }
 180         if (clientinfo->tmp_saved_path) {
 181                 if (sqlite3_bind_text
 182                     (stmt, 9, clientinfo->tmp_saved_path, -1,
 183                      NULL) != SQLITE_OK) {
 184                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 185                                         sqlite3_errmsg(g_download_provider_db));
 186                         _download_provider_sql_close(stmt);
 187                         return -1;
 188                 }
 189         }
 190         errorcode = sqlite3_step(stmt);
 191         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 192                 _download_provider_sql_close(stmt);
 193                 return 0;
 194         }
 195         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 196                         sqlite3_errmsg(g_download_provider_db));
 197         __download_provider_db_close();
 198         return -1;
 199 }
 200
 201 int download_provider_db_requestinfo_update_column(download_clientinfo *clientinfo,
 202                                                    download_db_column_type type)
 203 {
 204         int errorcode;
 205         sqlite3_stmt *stmt = NULL;
 206
 207         if (!clientinfo || !clientinfo->requestinfo
 208                 || clientinfo->requestinfo->requestid <= 0) {
 209                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 210                 return -1;
 211         }
 212
 213         if (_download_provider_sql_open() < 0) {
 214                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 215                                 sqlite3_errmsg(g_download_provider_db));
 216                 return -1;
 217         }
 218
 219         switch (type) {
 220         case DOWNLOAD_DB_PACKAGENAME:
 221                 if (clientinfo->requestinfo->client_packagename.length <= 1
 222                         || !clientinfo->requestinfo->client_packagename.str) {
 223                         TRACE_DEBUG_MSG("[NULL-CHECK] type [%d]", type);
 224                         _download_provider_sql_close(stmt);
 225                         return -1;
 226                 }
 227                 errorcode =
 228                         sqlite3_prepare_v2(g_download_provider_db,
 229                                                 "UPDATE downloading SET packagename = ? WHERE uniqueid = ?",
 230                                                 -1, &stmt, NULL);
 231                 if (errorcode != SQLITE_OK) {
 232                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 233                                         sqlite3_errmsg(g_download_provider_db));
 234                         _download_provider_sql_close(stmt);
 235                         return -1;
 236                 }
 237                 if (sqlite3_bind_text
 238                         (stmt, 1, clientinfo->requestinfo->client_packagename.str,
 239                          -1, NULL) != SQLITE_OK) {
 240                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 241                                         sqlite3_errmsg(g_download_provider_db));
 242                         _download_provider_sql_close(stmt);
 243                         return -1;
 244                 }
 245                 break;
 246         case DOWNLOAD_DB_NOTIFICATION:
 247                 errorcode =
 248                         sqlite3_prepare_v2(g_download_provider_db,
 249                                                 "UPDATE downloading SET notification = ? WHERE uniqueid = ?",
 250                                                 -1, &stmt, NULL);
 251                 if (errorcode != SQLITE_OK) {
 252                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 253                                         sqlite3_errmsg(g_download_provider_db));
 254                         _download_provider_sql_close(stmt);
 255                         return -1;
 256                 }
 257                 if (sqlite3_bind_int
 258                         (stmt, 1,
 259                         clientinfo->requestinfo->notification) != SQLITE_OK) {
 260                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 261                                         sqlite3_errmsg(g_download_provider_db));
 262                         _download_provider_sql_close(stmt);
 263                         return -1;
 264                 }
 265                 break;
 266         case DOWNLOAD_DB_STATE:
 267                 errorcode =
 268                         sqlite3_prepare_v2(g_download_provider_db,
 269                                                 "UPDATE downloading SET state = ? WHERE uniqueid = ?",
 270                                                 -1, &stmt, NULL);
 271                 if (errorcode != SQLITE_OK) {
 272                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 273                                         sqlite3_errmsg(g_download_provider_db));
 274                         _download_provider_sql_close(stmt);
 275                         return -1;
 276                 }
 277                 if (sqlite3_bind_int(stmt, 1, clientinfo->state) != SQLITE_OK) {
 278                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 279                                         sqlite3_errmsg(g_download_provider_db));
 280                         _download_provider_sql_close(stmt);
 281                         return -1;
 282                 }
 283                 break;
 284         case DOWNLOAD_DB_MIMETYPE:
 285                 if (!clientinfo->downloadinfo) {
 286                         TRACE_DEBUG_MSG("[NULL-CHECK] type [%d]", type);
 287                         _download_provider_sql_close(stmt);
 288                         return -1;
 289                 }
 290                 errorcode =
 291                         sqlite3_prepare_v2(g_download_provider_db,
 292                                                 "UPDATE downloading SET mimetype = ? WHERE uniqueid = ?",
 293                                                 -1, &stmt, NULL);
 294                 if (errorcode != SQLITE_OK) {
 295                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 296                                         sqlite3_errmsg(g_download_provider_db));
 297                         _download_provider_sql_close(stmt);
 298                         return -1;
 299                 }
 300                 if (sqlite3_bind_text
 301                         (stmt, 1, clientinfo->downloadinfo->mime_type, -1,
 302                         NULL) != SQLITE_OK) {
 303                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 304                                         sqlite3_errmsg(g_download_provider_db));
 305                         _download_provider_sql_close(stmt);
 306                         return -1;
 307                 }
 308                 break;
 309         case DOWNLOAD_DB_FILENAME:
 310                 if (!clientinfo->downloadinfo
 311                         || sizeof(clientinfo->downloadinfo->content_name) < 1) {
 312                         TRACE_DEBUG_MSG("[NULL-CHECK] type [%d]", type);
 313                         _download_provider_sql_close(stmt);
 314                         return -1;
 315                 }
 316                 errorcode =
 317                         sqlite3_prepare_v2(g_download_provider_db,
 318                                                 "UPDATE downloading SET filename = ? WHERE uniqueid = ?",
 319                                                 -1, &stmt, NULL);
 320                 if (errorcode != SQLITE_OK) {
 321                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 322                                         sqlite3_errmsg(g_download_provider_db));
 323                         _download_provider_sql_close(stmt);
 324                         return -1;
 325                 }
 326                 if (sqlite3_bind_text
 327                         (stmt, 1, clientinfo->downloadinfo->content_name, -1,
 328                         NULL) != SQLITE_OK) {
 329                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 330                                         sqlite3_errmsg(g_download_provider_db));
 331                         _download_provider_sql_close(stmt);
 332                         return -1;
 333                 }
 334                 break;
 335         case DOWNLOAD_DB_SAVEDPATH:
 336                 if (!clientinfo->tmp_saved_path) {
 337                         TRACE_DEBUG_MSG("[NULL-CHECK] type [%d]", type);
 338                         _download_provider_sql_close(stmt);
 339                         return -1;
 340                 }
 341                 errorcode =
 342                         sqlite3_prepare_v2(g_download_provider_db,
 343                                                 "UPDATE downloading SET savedpath = ? WHERE uniqueid = ?",
 344                                                 -1, &stmt, NULL);
 345                 if (errorcode != SQLITE_OK) {
 346                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 347                                         sqlite3_errmsg(g_download_provider_db));
 348                         _download_provider_sql_close(stmt);
 349                         return -1;
 350                 }
 351                 if (sqlite3_bind_text
 352                         (stmt, 1, clientinfo->tmp_saved_path, -1,
 353                         NULL) != SQLITE_OK) {
 354                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 355                                         sqlite3_errmsg(g_download_provider_db));
 356                         _download_provider_sql_close(stmt);
 357                         return -1;
 358                 }
 359                 break;
 360         default:
 361                 TRACE_DEBUG_MSG("Wrong type [%d]", type);
 362                 return -1;
 363         }
 364
 365         if (sqlite3_bind_int(stmt, 2, clientinfo->requestinfo->requestid) !=
 366                 SQLITE_OK) {
 367                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 368                                 sqlite3_errmsg(g_download_provider_db));
 369                 _download_provider_sql_close(stmt);
 370                 return -1;
 371         }
 372
 373         errorcode = sqlite3_step(stmt);
 374         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 375                 _download_provider_sql_close(stmt);
 376                 return 0;
 377         }
 378         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 379                         sqlite3_errmsg(g_download_provider_db));
 380         __download_provider_db_close();
 381         return -1;
 382 }
 383
 384 download_dbinfo_list *download_provider_db_get_list(int state)
 385 {
 386         int errorcode;
 387         int listcount;
 388         int i = 0;
 389         int buffer_length = 0;
 390         sqlite3_stmt *stmt = NULL;
 391         char *buffer;
 392         download_dbinfo_list *m_list = NULL;
 393
 394         listcount = download_provider_db_list_count(state);
 395         if (listcount <= 0)
 396                 return NULL;
 397
 398         if (_download_provider_sql_open() < 0) {
 399                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 400                                 sqlite3_errmsg(g_download_provider_db));
 401                 return NULL;
 402         }
 403
 404         if (state != DOWNLOAD_STATE_NONE) {
 405                 errorcode =
 406                         sqlite3_prepare_v2(g_download_provider_db,
 407                                                 "SELECT uniqueid, packagename, notification, installpath, filename, creationdate, state, url, mimetype, savedpath FROM downloading WHERE state = ?",
 408                                                 -1, &stmt, NULL);
 409                 if (errorcode != SQLITE_OK) {
 410                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 411                                         sqlite3_errmsg(g_download_provider_db));
 412                         _download_provider_sql_close(stmt);
 413                         return NULL;
 414                 }
 415                 if (sqlite3_bind_int(stmt, 1, state) != SQLITE_OK) {
 416                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 417                                         sqlite3_errmsg(g_download_provider_db));
 418                         _download_provider_sql_close(stmt);
 419                         return NULL;
 420                 }
 421         } else {
 422                 errorcode =
 423                         sqlite3_prepare_v2(g_download_provider_db,
 424                                                 "SELECT uniqueid, packagename, notification, installpath, filename, creationdate, state, url, mimetype, savedpath FROM downloading",
 425                                                 -1, &stmt, NULL);
 426                 if (errorcode != SQLITE_OK) {
 427                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 428                                         sqlite3_errmsg(g_download_provider_db));
 429                         _download_provider_sql_close(stmt);
 430                         return NULL;
 431                 }
 432         }
 433         m_list = (download_dbinfo_list *) calloc(1, sizeof(download_dbinfo_list));
 434         m_list->item =
 435                 (download_dbinfo *) calloc(listcount, sizeof(download_dbinfo));
 436         m_list->count = listcount;
 437
 438         while ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW
 439                         && (i < listcount)) {
 440                 m_list->item[i].requestid = sqlite3_column_int(stmt, 0);
 441                 buffer = (char *)(sqlite3_column_text(stmt, 1));
 442                 m_list->item[i].packagename = NULL;
 443                 if (buffer) {
 444                         buffer_length = strlen(buffer);
 445                         m_list->item[i].packagename
 446                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 447                         memcpy(m_list->item[i].packagename, buffer,
 448                                         buffer_length * sizeof(char));
 449                         m_list->item[i].packagename[buffer_length] = '\0';
 450                 }
 451                 m_list->item[i].notification = sqlite3_column_int(stmt, 2);
 452                 buffer = (char *)(sqlite3_column_text(stmt, 3));
 453                 m_list->item[i].installpath = NULL;
 454                 if (buffer) {
 455                         buffer_length = strlen(buffer);
 456                         m_list->item[i].installpath
 457                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 458                         memcpy(m_list->item[i].installpath, buffer,
 459                                         buffer_length * sizeof(char));
 460                         m_list->item[i].installpath[buffer_length] = '\0';
 461                 }
 462                 buffer = (char *)(sqlite3_column_text(stmt, 4));
 463                 m_list->item[i].filename = NULL;
 464                 if (buffer) {
 465                         buffer_length = strlen(buffer);
 466                         m_list->item[i].filename
 467                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 468                         memcpy(m_list->item[i].filename, buffer,
 469                                         buffer_length * sizeof(char));
 470                         m_list->item[i].filename[buffer_length] = '\0';
 471                 }
 472                 buffer = (char *)(sqlite3_column_text(stmt, 5));
 473                 m_list->item[i].createdate = NULL;
 474                 if (buffer) {
 475                         buffer_length = strlen(buffer);
 476                         m_list->item[i].createdate
 477                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 478                         memcpy(m_list->item[i].createdate, buffer,
 479                                         buffer_length * sizeof(char));
 480                         m_list->item[i].createdate[buffer_length] = '\0';
 481                 }
 482                 m_list->item[i].state = sqlite3_column_int(stmt, 6);
 483                 buffer = (char *)(sqlite3_column_text(stmt, 7));
 484                 m_list->item[i].url = NULL;
 485                 if (buffer) {
 486                         buffer_length = strlen(buffer);
 487                         m_list->item[i].url
 488                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 489                         memcpy(m_list->item[i].url, buffer,
 490                                         buffer_length * sizeof(char));
 491                         m_list->item[i].url[buffer_length] = '\0';
 492                 }
 493                 buffer = (char *)(sqlite3_column_text(stmt, 8));
 494                 m_list->item[i].mimetype = NULL;
 495                 if (buffer) {
 496                         buffer_length = strlen(buffer);
 497                         m_list->item[i].mimetype
 498                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 499                         memcpy(m_list->item[i].mimetype, buffer,
 500                                         buffer_length * sizeof(char));
 501                         m_list->item[i].mimetype[buffer_length] = '\0';
 502                 }
 503                 buffer = (char *)(sqlite3_column_text(stmt, 9));
 504                 m_list->item[i].saved_path = NULL;
 505                 if (buffer) {
 506                         buffer_length = strlen(buffer);
 507                         m_list->item[i].saved_path
 508                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 509                         memcpy(m_list->item[i].saved_path, buffer,
 510                                 buffer_length * sizeof(char));
 511                         m_list->item[i].saved_path[buffer_length] = '\0';
 512                 }
 513                 i++;
 514         }
 515         m_list->count = i;
 516
 517         if (i <= 0) {
 518                 TRACE_DEBUG_MSG("sqlite3_step is failed. [%s]",
 519                                 sqlite3_errmsg(g_download_provider_db));
 520                 __download_provider_db_close();
 521                 download_provider_db_list_free(m_list);
 522                 return NULL;
 523         }
 524         _download_provider_sql_close(stmt);
 525         return m_list;
 526 }
 527
 528 int download_provider_db_list_count(int state)
 529 {
 530         int errorcode;
 531         int count = 0;
 532         sqlite3_stmt *stmt = NULL;
 533
 534         if (_download_provider_sql_open() < 0) {
 535                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 536                                 sqlite3_errmsg(g_download_provider_db));
 537                 return -1;
 538         }
 539
 540         if (state != DOWNLOAD_STATE_NONE) {
 541                 errorcode =
 542                         sqlite3_prepare_v2(g_download_provider_db,
 543                                                 "SELECT count(*) FROM downloading WHERE state = ?",
 544                                                 -1, &stmt, NULL);
 545                 if (errorcode != SQLITE_OK) {
 546                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 547                                         sqlite3_errmsg(g_download_provider_db));
 548                         _download_provider_sql_close(stmt);
 549                         return -1;
 550                 }
 551                 if (sqlite3_bind_int(stmt, 1, state) != SQLITE_OK) {
 552                         TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 553                                         sqlite3_errmsg(g_download_provider_db));
 554                         _download_provider_sql_close(stmt);
 555                         return -1;
 556                 }
 557         } else {
 558                 errorcode =
 559                         sqlite3_prepare_v2(g_download_provider_db,
 560                                                 "SELECT count(*) FROM downloading",
 561                                                 -1, &stmt, NULL);
 562                 if (errorcode != SQLITE_OK) {
 563                         TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 564                                         sqlite3_errmsg(g_download_provider_db));
 565                         _download_provider_sql_close(stmt);
 566                         return -1;
 567                 }
 568         }
 569         errorcode = sqlite3_step(stmt);
 570         if (errorcode == SQLITE_ROW) {
 571                 count = sqlite3_column_int(stmt, 0);
 572                 _download_provider_sql_close(stmt);
 573                 return count;
 574         }
 575         TRACE_DEBUG_MSG("sqlite3_step is failed. [%s]",
 576                         sqlite3_errmsg(g_download_provider_db));
 577         __download_provider_db_close();
 578         return 0;
 579 }
 580
 581 void download_provider_db_info_free(download_dbinfo *info)
 582 {
 583         if (!info)
 584                 return;
 585
 586         info->requestid = 0;
 587         if (info->packagename)
 588                 free(info->packagename);
 589         info->packagename = NULL;
 590         if (info->installpath)
 591                 free(info->installpath);
 592         info->installpath = NULL;
 593         if (info->filename)
 594                 free(info->filename);
 595         info->filename = NULL;
 596         if (info->createdate)
 597                 free(info->createdate);
 598         info->createdate = NULL;
 599         if (info->url)
 600                 free(info->url);
 601         info->url = NULL;
 602         if (info->mimetype)
 603                 free(info->mimetype);
 604         info->mimetype = NULL;
 605         if (info->etag)
 606                 free(info->etag);
 607         info->etag = NULL;
 608         if (info->saved_path)
 609                 free(info->saved_path);
 610         info->saved_path = NULL;
 611 }
 612
 613 void download_provider_db_list_free(download_dbinfo_list *list)
 614 {
 615         int i = 0;
 616         if (!list)
 617                 return;
 618
 619         if (list->count > 0 && list->item) {
 620                 for (i = 0; i < list->count; i++)
 621                         download_provider_db_info_free(&list->item[i]);
 622                 list->count = 0;
 623                 free(list->item);
 624                 list->item = NULL;
 625         }
 626         free(list);
 627         list = NULL;
 628 }
 629
 630 download_dbinfo *download_provider_db_get_info(int requestid)
 631 {
 632         if (requestid <= 0)
 633                 return NULL;
 634
 635         int errorcode;
 636         int buffer_length = 0;
 637         sqlite3_stmt *stmt = NULL;
 638         char *buffer = NULL;
 639         download_dbinfo *dbinfo = NULL;
 640
 641         if (_download_provider_sql_open() < 0) {
 642                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 643                                 sqlite3_errmsg(g_download_provider_db));
 644                 return NULL;
 645         }
 646
 647         errorcode =
 648                 sqlite3_prepare_v2(g_download_provider_db,
 649                         "SELECT uniqueid, packagename, notification, installpath, filename, creationdate, state, url, mimetype, savedpath FROM downloading WHERE uniqueid = ?",
 650                         -1, &stmt, NULL);
 651         if (errorcode != SQLITE_OK) {
 652                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 653                                 sqlite3_errmsg(g_download_provider_db));
 654                 _download_provider_sql_close(stmt);
 655                 return NULL;
 656         }
 657         if (sqlite3_bind_int(stmt, 1, requestid) != SQLITE_OK) {
 658                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 659                                 sqlite3_errmsg(g_download_provider_db));
 660                 _download_provider_sql_close(stmt);
 661                 return NULL;
 662         }
 663
 664         if ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
 665                 dbinfo = (download_dbinfo *) calloc(1, sizeof(download_dbinfo));
 666                 dbinfo->requestid = sqlite3_column_int(stmt, 0);
 667                 buffer = (char *)(sqlite3_column_text(stmt, 1));
 668                 dbinfo->packagename = NULL;
 669                 if (buffer) {
 670                         buffer_length = strlen(buffer);
 671                         dbinfo->packagename
 672                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 673                         memcpy(dbinfo->packagename, buffer,
 674                                         buffer_length * sizeof(char));
 675                         dbinfo->packagename[buffer_length] = '\0';
 676                 }
 677                 dbinfo->notification = sqlite3_column_int(stmt, 2);
 678                 buffer = (char *)(sqlite3_column_text(stmt, 3));
 679                 dbinfo->installpath = NULL;
 680                 if (buffer) {
 681                         buffer_length = strlen(buffer);
 682                         dbinfo->installpath
 683                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 684                         memcpy(dbinfo->installpath, buffer,
 685                                         buffer_length * sizeof(char));
 686                         dbinfo->installpath[buffer_length] = '\0';
 687                 }
 688                 buffer = (char *)(sqlite3_column_text(stmt, 4));
 689                 dbinfo->filename = NULL;
 690                 if (buffer) {
 691                         buffer_length = strlen(buffer);
 692                         dbinfo->filename
 693                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 694                         memcpy(dbinfo->filename, buffer,
 695                                         buffer_length * sizeof(char));
 696                         dbinfo->filename[buffer_length] = '\0';
 697                 }
 698                 buffer = (char *)(sqlite3_column_text(stmt, 5));
 699                 dbinfo->createdate = NULL;
 700                 if (buffer) {
 701                         buffer_length = strlen(buffer);
 702                         dbinfo->createdate
 703                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 704                         memcpy(dbinfo->createdate, buffer,
 705                                         buffer_length * sizeof(char));
 706                         dbinfo->createdate[buffer_length] = '\0';
 707                 }
 708                 dbinfo->state = sqlite3_column_int(stmt, 6);
 709                 buffer = (char *)(sqlite3_column_text(stmt, 7));
 710                 dbinfo->url = NULL;
 711                 if (buffer) {
 712                         buffer_length = strlen(buffer);
 713                         dbinfo->url
 714                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 715                         memcpy(dbinfo->url, buffer,
 716                                         buffer_length * sizeof(char));
 717                         dbinfo->url[buffer_length] = '\0';
 718                 }
 719                 buffer = (char *)(sqlite3_column_text(stmt, 8));
 720                 dbinfo->mimetype = NULL;
 721                 if (buffer) {
 722                         buffer_length = strlen(buffer);
 723                         dbinfo->mimetype
 724                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 725                         memcpy(dbinfo->mimetype, buffer,
 726                                         buffer_length * sizeof(char));
 727                         dbinfo->mimetype[buffer_length] = '\0';
 728                 }
 729                 buffer = (char *)(sqlite3_column_text(stmt, 9));
 730                 dbinfo->saved_path = NULL;
 731                 if (buffer) {
 732                         buffer_length = strlen(buffer);
 733                         dbinfo->saved_path
 734                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 735                         memcpy(dbinfo->saved_path, buffer,
 736                                 buffer_length * sizeof(char));
 737                         dbinfo->saved_path[buffer_length] = '\0';
 738                 }
 739         } else {
 740                 TRACE_DEBUG_MSG("sqlite3_step is failed. [%s] errorcode[%d]",
 741                                 sqlite3_errmsg(g_download_provider_db), errorcode);
 742                 __download_provider_db_close();
 743                 download_provider_db_info_free(dbinfo);
 744                 free(dbinfo);
 745                 return NULL;
 746         }
 747         _download_provider_sql_close(stmt);
 748         return dbinfo;
 749 }
 750
 751 download_request_info *download_provider_db_get_requestinfo(download_dbinfo *dbinfo)
 752 {
 753         if (!dbinfo || dbinfo->requestid <= 0)
 754                 return NULL;
 755
 756         download_request_info *requestinfo =
 757                 (download_request_info *) calloc(1, sizeof(download_request_info));
 758         requestinfo->requestid = dbinfo->requestid;
 759         if (dbinfo->packagename) {
 760                 requestinfo->client_packagename.length =
 761                         strlen(dbinfo->packagename);
 762                 if (requestinfo->client_packagename.length > 1) {
 763                         requestinfo->client_packagename.str
 764                                 =
 765                                 (char *)
 766                                 calloc((requestinfo->client_packagename.length + 1),
 767                                 sizeof(char));
 768                         memcpy(requestinfo->client_packagename.str,
 769                                         dbinfo->packagename,
 770                                         requestinfo->client_packagename.length *
 771                                 sizeof(char));
 772                         requestinfo->client_packagename.str[requestinfo->
 773                                                                 client_packagename.
 774                                                                 length] = '\0';
 775                 }
 776         }
 777         if (dbinfo->url) {
 778                 requestinfo->url.length = strlen(dbinfo->url);
 779                 if (requestinfo->url.length > 1) {
 780                         requestinfo->url.str
 781                                 =
 782                                 (char *)calloc((requestinfo->url.length + 1),
 783                                                 sizeof(char));
 784                         memcpy(requestinfo->url.str, dbinfo->url,
 785                                         requestinfo->url.length * sizeof(char));
 786                         requestinfo->url.str[requestinfo->url.length] = '\0';
 787                 }
 788         }
 789         if (dbinfo->installpath) {
 790                 requestinfo->install_path.length = strlen(dbinfo->installpath);
 791                 if (requestinfo->install_path.length > 1) {
 792                         requestinfo->install_path.str
 793                                 =
 794                                 (char *)
 795                                 calloc((requestinfo->install_path.length + 1),
 796                                         sizeof(char));
 797                         memcpy(requestinfo->install_path.str,
 798                                         dbinfo->installpath,
 799                                         requestinfo->install_path.length * sizeof(char));
 800                         requestinfo->install_path.str[requestinfo->install_path.
 801                                                                 length] = '\0';
 802                 }
 803         }
 804         if (dbinfo->filename) {
 805                 requestinfo->filename.length = strlen(dbinfo->filename);
 806                 if (requestinfo->filename.length > 1) {
 807                         requestinfo->filename.str
 808                                 =
 809                                 (char *)calloc((requestinfo->filename.length + 1),
 810                                                 sizeof(char));
 811                         memcpy(requestinfo->filename.str, dbinfo->filename,
 812                                         requestinfo->filename.length * sizeof(char));
 813                         requestinfo->filename.str[requestinfo->filename.
 814                                                         length] = '\0';
 815                 }
 816         }
 817         // disable callback.
 818         memset(&requestinfo->callbackinfo, 0x00, sizeof(callback_info));
 819         requestinfo->notification = dbinfo->notification;
 820         return requestinfo;
 821 }
 822
 823 int download_provider_db_history_new(download_clientinfo *clientinfo)
 824 {
 825         int errorcode;
 826         sqlite3_stmt *stmt = NULL;
 827
 828         if (!clientinfo || !clientinfo->requestinfo
 829                 || clientinfo->requestinfo->requestid <= 0) {
 830                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 831                 return -1;
 832         }
 833
 834         if (_download_provider_sql_open() < 0) {
 835                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 836                                 sqlite3_errmsg(g_download_provider_db));
 837                 return -1;
 838         }
 839
 840         errorcode =
 841                 sqlite3_prepare_v2(g_download_provider_db,
 842                                         "INSERT INTO history (uniqueid, packagename, filename, creationdate, state, mimetype, savedpath) VALUES (?, ?, ?, DATETIME('now'), ?, ?, ?)",
 843                                         -1, &stmt, NULL);
 844         if (errorcode != SQLITE_OK) {
 845                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 846                                 sqlite3_errmsg(g_download_provider_db));
 847                 _download_provider_sql_close(stmt);
 848                 return -1;
 849         }
 850         if (sqlite3_bind_int(stmt, 1, clientinfo->requestinfo->requestid) !=
 851                 SQLITE_OK) {
 852                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 853                                 sqlite3_errmsg(g_download_provider_db));
 854                 _download_provider_sql_close(stmt);
 855                 return -1;
 856         }
 857         if (clientinfo->requestinfo->client_packagename.length > 1) {
 858                 if (sqlite3_bind_text
 859                         (stmt, 2, clientinfo->requestinfo->client_packagename.str,
 860                          -1, NULL) != SQLITE_OK) {
 861                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 862                                         sqlite3_errmsg(g_download_provider_db));
 863                         _download_provider_sql_close(stmt);
 864                         return -1;
 865                 }
 866         }
 867         if (clientinfo->downloadinfo && sizeof(clientinfo->downloadinfo->content_name) > 1) {
 868                 if (sqlite3_bind_text
 869                         (stmt, 3, clientinfo->downloadinfo->content_name, -1,
 870                         NULL) != SQLITE_OK) {
 871                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 872                                         sqlite3_errmsg(g_download_provider_db));
 873                         _download_provider_sql_close(stmt);
 874                         return -1;
 875                 }
 876         }
 877         if (sqlite3_bind_int(stmt, 4, clientinfo->state) != SQLITE_OK) {
 878                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 879                                 sqlite3_errmsg(g_download_provider_db));
 880                 _download_provider_sql_close(stmt);
 881                 return -1;
 882         }
 883         if (clientinfo->downloadinfo && sizeof(clientinfo->downloadinfo->mime_type) > 1) {
 884                 if (sqlite3_bind_text
 885                         (stmt, 5, clientinfo->downloadinfo->mime_type, -1,
 886                         NULL) != SQLITE_OK) {
 887                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 888                                         sqlite3_errmsg(g_download_provider_db));
 889                         _download_provider_sql_close(stmt);
 890                         return -1;
 891                 }
 892         }
 893         if (clientinfo->tmp_saved_path) {
 894                 if (sqlite3_bind_text
 895                         (stmt, 6, clientinfo->tmp_saved_path, -1,
 896                         NULL) != SQLITE_OK) {
 897                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 898                                         sqlite3_errmsg(g_download_provider_db));
 899                         _download_provider_sql_close(stmt);
 900                         return -1;
 901                 }
 902         }
 903         errorcode = sqlite3_step(stmt);
 904         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 905                 _download_provider_sql_close(stmt);
 906                 download_provider_db_history_limit_rows();
 907                 return 0;
 908         }
 909         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 910                         sqlite3_errmsg(g_download_provider_db));
 911         __download_provider_db_close();
 912         return -1;
 913 }
 914
 915 int download_provider_db_history_remove(int uniqueid)
 916 {
 917         int errorcode;
 918         sqlite3_stmt *stmt = NULL;
 919
 920         if (uniqueid <= 0) {
 921                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 922                 return -1;
 923         }
 924
 925         if (_download_provider_sql_open() < 0) {
 926                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 927                                 sqlite3_errmsg(g_download_provider_db));
 928                 return -1;
 929         }
 930
 931         errorcode =
 932                 sqlite3_prepare_v2(g_download_provider_db,
 933                                         "delete from history where uniqueid = ?",
 934                                         -1, &stmt, NULL);
 935         if (errorcode != SQLITE_OK) {
 936                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 937                                 sqlite3_errmsg(g_download_provider_db));
 938                 _download_provider_sql_close(stmt);
 939                 return -1;
 940         }
 941         if (sqlite3_bind_int(stmt, 1, uniqueid) != SQLITE_OK) {
 942                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 943                                 sqlite3_errmsg(g_download_provider_db));
 944                 _download_provider_sql_close(stmt);
 945                 return -1;
 946         }
 947         errorcode = sqlite3_step(stmt);
 948         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 949                 _download_provider_sql_close(stmt);
 950                 return 0;
 951         }
 952         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 953                         sqlite3_errmsg(g_download_provider_db));
 954         __download_provider_db_close();
 955         return -1;
 956 }
 957
 958 int download_provider_db_history_limit_rows()
 959 {
 960         int errorcode;
 961         sqlite3_stmt *stmt = NULL;
 962
 963         if (_download_provider_sql_open() < 0) {
 964                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 965                                 sqlite3_errmsg(g_download_provider_db));
 966                 return -1;
 967         }
 968
 969         errorcode =
 970                 sqlite3_prepare_v2(g_download_provider_db,
 971                                         "DELETE FROM history where uniqueid NOT IN (SELECT uniqueid FROM history ORDER BY id DESC LIMIT ?)",
 972                                         -1, &stmt, NULL);
 973         if (errorcode != SQLITE_OK) {
 974                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 975                                 sqlite3_errmsg(g_download_provider_db));
 976                 _download_provider_sql_close(stmt);
 977                 return -1;
 978         }
 979         if (sqlite3_bind_int(stmt, 1, DOWNLOAD_PROVIDER_HISTORY_DB_LIMIT_ROWS)
 980                 != SQLITE_OK) {
 981                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 982                                 sqlite3_errmsg(g_download_provider_db));
 983                 _download_provider_sql_close(stmt);
 984                 return -1;
 985         }
 986         errorcode = sqlite3_step(stmt);
 987         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 988                 _download_provider_sql_close(stmt);
 989                 return 0;
 990         }
 991         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 992                         sqlite3_errmsg(g_download_provider_db));
 993         __download_provider_db_close();
 994         return -1;
 995 }
 996
 997 download_dbinfo *download_provider_db_history_get_info(int requestid)
 998 {
 999         if (requestid <= 0)
1000                 return NULL;
1001
1002         int errorcode;
1003         int buffer_length = 0;
1004         sqlite3_stmt *stmt = NULL;
1005         char *buffer = NULL;
1006         download_dbinfo *dbinfo = NULL;
1007
1008         if (_download_provider_sql_open() < 0) {
1009                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
1010                                 sqlite3_errmsg(g_download_provider_db));
1011                 return NULL;
1012         }
1013
1014         errorcode =
1015                 sqlite3_prepare_v2(g_download_provider_db,
1016                         "SELECT packagename, filename, creationdate, state, mimetype, savedpath FROM history WHERE uniqueid = ?",
1017                         -1, &stmt, NULL);
1018         if (errorcode != SQLITE_OK) {
1019                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
1020                                 sqlite3_errmsg(g_download_provider_db));
1021                 _download_provider_sql_close(stmt);
1022                 return NULL;
1023         }
1024         if (sqlite3_bind_int(stmt, 1, requestid) != SQLITE_OK) {
1025                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
1026                                 sqlite3_errmsg(g_download_provider_db));
1027                 _download_provider_sql_close(stmt);
1028                 return NULL;
1029         }
1030
1031         if ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
1032                 dbinfo = (download_dbinfo *) calloc(1, sizeof(download_dbinfo));
1033                 dbinfo->requestid = requestid;
1034                 buffer = (char *)(sqlite3_column_text(stmt, 0));
1035                 dbinfo->packagename = NULL;
1036                 if (buffer) {
1037                         buffer_length = strlen(buffer);
1038                         dbinfo->packagename
1039                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1040                         memcpy(dbinfo->packagename, buffer,
1041                                         buffer_length * sizeof(char));
1042                         dbinfo->packagename[buffer_length] = '\0';
1043                 }
1044                 buffer = (char *)(sqlite3_column_text(stmt, 1));
1045                 dbinfo->filename = NULL;
1046                 if (buffer) {
1047                         buffer_length = strlen(buffer);
1048                         dbinfo->filename
1049                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1050                         memcpy(dbinfo->filename, buffer,
1051                                         buffer_length * sizeof(char));
1052                         dbinfo->filename[buffer_length] = '\0';
1053                 }
1054                 buffer = (char *)(sqlite3_column_text(stmt, 2));
1055                 dbinfo->createdate = NULL;
1056                 if (buffer) {
1057                         buffer_length = strlen(buffer);
1058                         dbinfo->createdate
1059                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1060                         memcpy(dbinfo->createdate, buffer,
1061                                         buffer_length * sizeof(char));
1062                         dbinfo->createdate[buffer_length] = '\0';
1063                 }
1064                 dbinfo->state = sqlite3_column_int(stmt, 3);
1065                 buffer = (char *)(sqlite3_column_text(stmt, 4));
1066                 dbinfo->mimetype = NULL;
1067                 if (buffer) {
1068                         buffer_length = strlen(buffer);
1069                         dbinfo->mimetype
1070                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1071                         memcpy(dbinfo->mimetype, buffer,
1072                                         buffer_length * sizeof(char));
1073                         dbinfo->mimetype[buffer_length] = '\0';
1074                 }
1075                 buffer = (char *)(sqlite3_column_text(stmt, 5));
1076                 dbinfo->saved_path = NULL;
1077                 if (buffer) {
1078                         buffer_length = strlen(buffer);
1079                         dbinfo->saved_path
1080                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1081                         memcpy(dbinfo->saved_path, buffer,
1082                                 buffer_length * sizeof(char));
1083                         dbinfo->saved_path[buffer_length] = '\0';
1084                 }
1085         } else {
1086                 TRACE_DEBUG_MSG("sqlite3_step is failed. [%s] errorcode[%d]",
1087                                 sqlite3_errmsg(g_download_provider_db), errorcode);
1088                 __download_provider_db_close();
1089                 download_provider_db_info_free(dbinfo);
1090                 free(dbinfo);
1091                 return NULL;
1092         }
1093         _download_provider_sql_close(stmt);
1094         return dbinfo;
1095 }