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         free(info);
 612         info = NULL;
 613 }
 614
 615 void download_provider_db_list_free(download_dbinfo_list *list)
 616 {
 617         TRACE_DEBUG_MSG("");
 618
 619         int i = 0;
 620         if (!list)
 621                 return;
 622
 623         if (list->count > 0 && list->item) {
 624                 for (i = 0; i < list->count; i++)
 625                         download_provider_db_info_free(&list->item[i]);
 626                 list->count = 0;
 627                 free(list->item);
 628                 list->item = NULL;
 629         }
 630         free(list);
 631         list = NULL;
 632 }
 633
 634 download_dbinfo *download_provider_db_get_info(int requestid)
 635 {
 636         if (requestid <= 0)
 637                 return NULL;
 638
 639         int errorcode;
 640         int buffer_length = 0;
 641         sqlite3_stmt *stmt = NULL;
 642         char *buffer = NULL;
 643         download_dbinfo *dbinfo = NULL;
 644
 645         if (_download_provider_sql_open() < 0) {
 646                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 647                                 sqlite3_errmsg(g_download_provider_db));
 648                 return NULL;
 649         }
 650
 651         errorcode =
 652                 sqlite3_prepare_v2(g_download_provider_db,
 653                         "SELECT uniqueid, packagename, notification, installpath, filename, creationdate, state, url, mimetype, savedpath FROM downloading WHERE uniqueid = ?",
 654                         -1, &stmt, NULL);
 655         if (errorcode != SQLITE_OK) {
 656                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 657                                 sqlite3_errmsg(g_download_provider_db));
 658                 _download_provider_sql_close(stmt);
 659                 return NULL;
 660         }
 661         if (sqlite3_bind_int(stmt, 1, requestid) != SQLITE_OK) {
 662                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 663                                 sqlite3_errmsg(g_download_provider_db));
 664                 _download_provider_sql_close(stmt);
 665                 return NULL;
 666         }
 667
 668         if ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
 669                 dbinfo = (download_dbinfo *) calloc(1, sizeof(download_dbinfo));
 670                 dbinfo->requestid = sqlite3_column_int(stmt, 0);
 671                 buffer = (char *)(sqlite3_column_text(stmt, 1));
 672                 dbinfo->packagename = NULL;
 673                 if (buffer) {
 674                         buffer_length = strlen(buffer);
 675                         dbinfo->packagename
 676                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 677                         memcpy(dbinfo->packagename, buffer,
 678                                         buffer_length * sizeof(char));
 679                         dbinfo->packagename[buffer_length] = '\0';
 680                 }
 681                 dbinfo->notification = sqlite3_column_int(stmt, 2);
 682                 buffer = (char *)(sqlite3_column_text(stmt, 3));
 683                 dbinfo->installpath = NULL;
 684                 if (buffer) {
 685                         buffer_length = strlen(buffer);
 686                         dbinfo->installpath
 687                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 688                         memcpy(dbinfo->installpath, buffer,
 689                                         buffer_length * sizeof(char));
 690                         dbinfo->installpath[buffer_length] = '\0';
 691                 }
 692                 buffer = (char *)(sqlite3_column_text(stmt, 4));
 693                 dbinfo->filename = NULL;
 694                 if (buffer) {
 695                         buffer_length = strlen(buffer);
 696                         dbinfo->filename
 697                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 698                         memcpy(dbinfo->filename, buffer,
 699                                         buffer_length * sizeof(char));
 700                         dbinfo->filename[buffer_length] = '\0';
 701                 }
 702                 buffer = (char *)(sqlite3_column_text(stmt, 5));
 703                 dbinfo->createdate = NULL;
 704                 if (buffer) {
 705                         buffer_length = strlen(buffer);
 706                         dbinfo->createdate
 707                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 708                         memcpy(dbinfo->createdate, buffer,
 709                                         buffer_length * sizeof(char));
 710                         dbinfo->createdate[buffer_length] = '\0';
 711                 }
 712                 dbinfo->state = sqlite3_column_int(stmt, 6);
 713                 buffer = (char *)(sqlite3_column_text(stmt, 7));
 714                 dbinfo->url = NULL;
 715                 if (buffer) {
 716                         buffer_length = strlen(buffer);
 717                         dbinfo->url
 718                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 719                         memcpy(dbinfo->url, buffer,
 720                                         buffer_length * sizeof(char));
 721                         dbinfo->url[buffer_length] = '\0';
 722                 }
 723                 buffer = (char *)(sqlite3_column_text(stmt, 8));
 724                 dbinfo->mimetype = NULL;
 725                 if (buffer) {
 726                         buffer_length = strlen(buffer);
 727                         dbinfo->mimetype
 728                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 729                         memcpy(dbinfo->mimetype, buffer,
 730                                         buffer_length * sizeof(char));
 731                         dbinfo->mimetype[buffer_length] = '\0';
 732                 }
 733                 buffer = (char *)(sqlite3_column_text(stmt, 9));
 734                 dbinfo->saved_path = NULL;
 735                 if (buffer) {
 736                         buffer_length = strlen(buffer);
 737                         dbinfo->saved_path
 738                                 = (char *)calloc(buffer_length + 1, sizeof(char));
 739                         memcpy(dbinfo->saved_path, buffer,
 740                                 buffer_length * sizeof(char));
 741                         dbinfo->saved_path[buffer_length] = '\0';
 742                 }
 743         } else {
 744                 TRACE_DEBUG_MSG("sqlite3_step is failed. [%s] errorcode[%d]",
 745                                 sqlite3_errmsg(g_download_provider_db), errorcode);
 746                 __download_provider_db_close();
 747                 download_provider_db_info_free(dbinfo);
 748                 return NULL;
 749         }
 750         _download_provider_sql_close(stmt);
 751         return dbinfo;
 752 }
 753
 754 download_request_info *download_provider_db_get_requestinfo(download_dbinfo *dbinfo)
 755 {
 756         if (!dbinfo || dbinfo->requestid <= 0)
 757                 return NULL;
 758
 759         download_request_info *requestinfo =
 760                 (download_request_info *) calloc(1, sizeof(download_request_info));
 761         requestinfo->requestid = dbinfo->requestid;
 762         if (dbinfo->packagename) {
 763                 requestinfo->client_packagename.length =
 764                         strlen(dbinfo->packagename);
 765                 if (requestinfo->client_packagename.length > 1) {
 766                         requestinfo->client_packagename.str
 767                                 =
 768                                 (char *)
 769                                 calloc((requestinfo->client_packagename.length + 1),
 770                                 sizeof(char));
 771                         memcpy(requestinfo->client_packagename.str,
 772                                         dbinfo->packagename,
 773                                         requestinfo->client_packagename.length *
 774                                 sizeof(char));
 775                         requestinfo->client_packagename.str[requestinfo->
 776                                                                 client_packagename.
 777                                                                 length] = '\0';
 778                 }
 779         }
 780         if (dbinfo->url) {
 781                 requestinfo->url.length = strlen(dbinfo->url);
 782                 if (requestinfo->url.length > 1) {
 783                         requestinfo->url.str
 784                                 =
 785                                 (char *)calloc((requestinfo->url.length + 1),
 786                                                 sizeof(char));
 787                         memcpy(requestinfo->url.str, dbinfo->url,
 788                                         requestinfo->url.length * sizeof(char));
 789                         requestinfo->url.str[requestinfo->url.length] = '\0';
 790                 }
 791         }
 792         if (dbinfo->installpath) {
 793                 requestinfo->install_path.length = strlen(dbinfo->installpath);
 794                 if (requestinfo->install_path.length > 1) {
 795                         requestinfo->install_path.str
 796                                 =
 797                                 (char *)
 798                                 calloc((requestinfo->install_path.length + 1),
 799                                         sizeof(char));
 800                         memcpy(requestinfo->install_path.str,
 801                                         dbinfo->installpath,
 802                                         requestinfo->install_path.length * sizeof(char));
 803                         requestinfo->install_path.str[requestinfo->install_path.
 804                                                                 length] = '\0';
 805                 }
 806         }
 807         if (dbinfo->filename) {
 808                 requestinfo->filename.length = strlen(dbinfo->filename);
 809                 if (requestinfo->filename.length > 1) {
 810                         requestinfo->filename.str
 811                                 =
 812                                 (char *)calloc((requestinfo->filename.length + 1),
 813                                                 sizeof(char));
 814                         memcpy(requestinfo->filename.str, dbinfo->filename,
 815                                         requestinfo->filename.length * sizeof(char));
 816                         requestinfo->filename.str[requestinfo->filename.
 817                                                         length] = '\0';
 818                 }
 819         }
 820         // disable callback.
 821         memset(&requestinfo->callbackinfo, 0x00, sizeof(callback_info));
 822         requestinfo->notification = dbinfo->notification;
 823         return requestinfo;
 824 }
 825
 826 int download_provider_db_history_new(download_clientinfo *clientinfo)
 827 {
 828         int errorcode;
 829         sqlite3_stmt *stmt = NULL;
 830
 831         if (!clientinfo || !clientinfo->requestinfo
 832                 || clientinfo->requestinfo->requestid <= 0) {
 833                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 834                 return -1;
 835         }
 836
 837         if (_download_provider_sql_open() < 0) {
 838                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 839                                 sqlite3_errmsg(g_download_provider_db));
 840                 return -1;
 841         }
 842
 843         errorcode =
 844                 sqlite3_prepare_v2(g_download_provider_db,
 845                                         "INSERT INTO history (uniqueid, packagename, filename, creationdate, state, mimetype, savedpath) VALUES (?, ?, ?, DATETIME('now'), ?, ?, ?)",
 846                                         -1, &stmt, NULL);
 847         if (errorcode != SQLITE_OK) {
 848                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 849                                 sqlite3_errmsg(g_download_provider_db));
 850                 _download_provider_sql_close(stmt);
 851                 return -1;
 852         }
 853         if (sqlite3_bind_int(stmt, 1, clientinfo->requestinfo->requestid) !=
 854                 SQLITE_OK) {
 855                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 856                                 sqlite3_errmsg(g_download_provider_db));
 857                 _download_provider_sql_close(stmt);
 858                 return -1;
 859         }
 860         if (clientinfo->requestinfo->client_packagename.length > 1) {
 861                 if (sqlite3_bind_text
 862                         (stmt, 2, clientinfo->requestinfo->client_packagename.str,
 863                          -1, NULL) != SQLITE_OK) {
 864                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 865                                         sqlite3_errmsg(g_download_provider_db));
 866                         _download_provider_sql_close(stmt);
 867                         return -1;
 868                 }
 869         }
 870         if (clientinfo->downloadinfo && sizeof(clientinfo->downloadinfo->content_name) > 1) {
 871                 if (sqlite3_bind_text
 872                         (stmt, 3, clientinfo->downloadinfo->content_name, -1,
 873                         NULL) != SQLITE_OK) {
 874                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 875                                         sqlite3_errmsg(g_download_provider_db));
 876                         _download_provider_sql_close(stmt);
 877                         return -1;
 878                 }
 879         }
 880         if (sqlite3_bind_int(stmt, 4, clientinfo->state) != SQLITE_OK) {
 881                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 882                                 sqlite3_errmsg(g_download_provider_db));
 883                 _download_provider_sql_close(stmt);
 884                 return -1;
 885         }
 886         if (clientinfo->downloadinfo && sizeof(clientinfo->downloadinfo->mime_type) > 1) {
 887                 if (sqlite3_bind_text
 888                         (stmt, 5, clientinfo->downloadinfo->mime_type, -1,
 889                         NULL) != SQLITE_OK) {
 890                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 891                                         sqlite3_errmsg(g_download_provider_db));
 892                         _download_provider_sql_close(stmt);
 893                         return -1;
 894                 }
 895         }
 896         if (clientinfo->tmp_saved_path) {
 897                 if (sqlite3_bind_text
 898                         (stmt, 6, clientinfo->tmp_saved_path, -1,
 899                         NULL) != SQLITE_OK) {
 900                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 901                                         sqlite3_errmsg(g_download_provider_db));
 902                         _download_provider_sql_close(stmt);
 903                         return -1;
 904                 }
 905         }
 906         errorcode = sqlite3_step(stmt);
 907         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 908                 _download_provider_sql_close(stmt);
 909                 download_provider_db_history_limit_rows();
 910                 return 0;
 911         }
 912         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 913                         sqlite3_errmsg(g_download_provider_db));
 914         __download_provider_db_close();
 915         return -1;
 916 }
 917
 918 int download_provider_db_history_remove(int uniqueid)
 919 {
 920         int errorcode;
 921         sqlite3_stmt *stmt = NULL;
 922
 923         if (uniqueid <= 0) {
 924                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 925                 return -1;
 926         }
 927
 928         if (_download_provider_sql_open() < 0) {
 929                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 930                                 sqlite3_errmsg(g_download_provider_db));
 931                 return -1;
 932         }
 933
 934         errorcode =
 935                 sqlite3_prepare_v2(g_download_provider_db,
 936                                         "delete from history where uniqueid = ?",
 937                                         -1, &stmt, NULL);
 938         if (errorcode != SQLITE_OK) {
 939                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 940                                 sqlite3_errmsg(g_download_provider_db));
 941                 _download_provider_sql_close(stmt);
 942                 return -1;
 943         }
 944         if (sqlite3_bind_int(stmt, 1, uniqueid) != SQLITE_OK) {
 945                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 946                                 sqlite3_errmsg(g_download_provider_db));
 947                 _download_provider_sql_close(stmt);
 948                 return -1;
 949         }
 950         errorcode = sqlite3_step(stmt);
 951         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 952                 _download_provider_sql_close(stmt);
 953                 return 0;
 954         }
 955         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 956                         sqlite3_errmsg(g_download_provider_db));
 957         __download_provider_db_close();
 958         return -1;
 959 }
 960
 961 int download_provider_db_history_limit_rows()
 962 {
 963         int errorcode;
 964         sqlite3_stmt *stmt = NULL;
 965
 966         if (_download_provider_sql_open() < 0) {
 967                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 968                                 sqlite3_errmsg(g_download_provider_db));
 969                 return -1;
 970         }
 971
 972         errorcode =
 973                 sqlite3_prepare_v2(g_download_provider_db,
 974                                         "DELETE FROM history where uniqueid NOT IN (SELECT uniqueid FROM history ORDER BY id DESC LIMIT ?)",
 975                                         -1, &stmt, NULL);
 976         if (errorcode != SQLITE_OK) {
 977                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 978                                 sqlite3_errmsg(g_download_provider_db));
 979                 _download_provider_sql_close(stmt);
 980                 return -1;
 981         }
 982         if (sqlite3_bind_int(stmt, 1, DOWNLOAD_PROVIDER_HISTORY_DB_LIMIT_ROWS)
 983                 != SQLITE_OK) {
 984                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 985                                 sqlite3_errmsg(g_download_provider_db));
 986                 _download_provider_sql_close(stmt);
 987                 return -1;
 988         }
 989         errorcode = sqlite3_step(stmt);
 990         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 991                 _download_provider_sql_close(stmt);
 992                 return 0;
 993         }
 994         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 995                         sqlite3_errmsg(g_download_provider_db));
 996         __download_provider_db_close();
 997         return -1;
 998 }
 999
1000 download_dbinfo *download_provider_db_history_get_info(int requestid)
1001 {
1002         if (requestid <= 0)
1003                 return NULL;
1004
1005         int errorcode;
1006         int buffer_length = 0;
1007         sqlite3_stmt *stmt = NULL;
1008         char *buffer = NULL;
1009         download_dbinfo *dbinfo = NULL;
1010
1011         if (_download_provider_sql_open() < 0) {
1012                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
1013                                 sqlite3_errmsg(g_download_provider_db));
1014                 return NULL;
1015         }
1016
1017         errorcode =
1018                 sqlite3_prepare_v2(g_download_provider_db,
1019                         "SELECT uniqueid, packagename, notification, installpath, filename, creationdate, state, url, mimetype, savedpath FROM history WHERE uniqueid = ?",
1020                         -1, &stmt, NULL);
1021         if (errorcode != SQLITE_OK) {
1022                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
1023                                 sqlite3_errmsg(g_download_provider_db));
1024                 _download_provider_sql_close(stmt);
1025                 return NULL;
1026         }
1027         if (sqlite3_bind_int(stmt, 1, requestid) != SQLITE_OK) {
1028                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
1029                                 sqlite3_errmsg(g_download_provider_db));
1030                 _download_provider_sql_close(stmt);
1031                 return NULL;
1032         }
1033
1034         if ((errorcode = sqlite3_step(stmt)) == SQLITE_ROW) {
1035                 dbinfo = (download_dbinfo *) calloc(1, sizeof(download_dbinfo));
1036                 dbinfo->requestid = sqlite3_column_int(stmt, 0);
1037                 buffer = (char *)(sqlite3_column_text(stmt, 1));
1038                 dbinfo->packagename = NULL;
1039                 if (buffer) {
1040                         buffer_length = strlen(buffer);
1041                         dbinfo->packagename
1042                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1043                         memcpy(dbinfo->packagename, buffer,
1044                                         buffer_length * sizeof(char));
1045                         dbinfo->packagename[buffer_length] = '\0';
1046                 }
1047                 dbinfo->notification = sqlite3_column_int(stmt, 2);
1048                 buffer = (char *)(sqlite3_column_text(stmt, 3));
1049                 dbinfo->installpath = NULL;
1050                 if (buffer) {
1051                         buffer_length = strlen(buffer);
1052                         dbinfo->installpath
1053                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1054                         memcpy(dbinfo->installpath, buffer,
1055                                         buffer_length * sizeof(char));
1056                         dbinfo->installpath[buffer_length] = '\0';
1057                 }
1058                 buffer = (char *)(sqlite3_column_text(stmt, 4));
1059                 dbinfo->filename = NULL;
1060                 if (buffer) {
1061                         buffer_length = strlen(buffer);
1062                         dbinfo->filename
1063                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1064                         memcpy(dbinfo->filename, buffer,
1065                                         buffer_length * sizeof(char));
1066                         dbinfo->filename[buffer_length] = '\0';
1067                 }
1068                 buffer = (char *)(sqlite3_column_text(stmt, 5));
1069                 dbinfo->createdate = NULL;
1070                 if (buffer) {
1071                         buffer_length = strlen(buffer);
1072                         dbinfo->createdate
1073                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1074                         memcpy(dbinfo->createdate, buffer,
1075                                         buffer_length * sizeof(char));
1076                         dbinfo->createdate[buffer_length] = '\0';
1077                 }
1078                 dbinfo->state = sqlite3_column_int(stmt, 6);
1079                 buffer = (char *)(sqlite3_column_text(stmt, 7));
1080                 dbinfo->url = NULL;
1081                 if (buffer) {
1082                         buffer_length = strlen(buffer);
1083                         dbinfo->url
1084                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1085                         memcpy(dbinfo->url, buffer,
1086                                         buffer_length * sizeof(char));
1087                         dbinfo->url[buffer_length] = '\0';
1088                 }
1089                 buffer = (char *)(sqlite3_column_text(stmt, 8));
1090                 dbinfo->mimetype = NULL;
1091                 if (buffer) {
1092                         buffer_length = strlen(buffer);
1093                         dbinfo->mimetype
1094                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1095                         memcpy(dbinfo->mimetype, buffer,
1096                                         buffer_length * sizeof(char));
1097                         dbinfo->mimetype[buffer_length] = '\0';
1098                 }
1099                 buffer = (char *)(sqlite3_column_text(stmt, 9));
1100                 dbinfo->saved_path = NULL;
1101                 if (buffer) {
1102                         buffer_length = strlen(buffer);
1103                         dbinfo->saved_path
1104                                 = (char *)calloc(buffer_length + 1, sizeof(char));
1105                         memcpy(dbinfo->saved_path, buffer,
1106                                 buffer_length * sizeof(char));
1107                         dbinfo->saved_path[buffer_length] = '\0';
1108                 }
1109         } else {
1110                 TRACE_DEBUG_MSG("sqlite3_step is failed. [%s] errorcode[%d]",
1111                                 sqlite3_errmsg(g_download_provider_db), errorcode);
1112                 __download_provider_db_close();
1113                 download_provider_db_info_free(dbinfo);
1114                 return NULL;
1115         }
1116         _download_provider_sql_close(stmt);
1117         return dbinfo;
1118 }