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;
  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;
  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 > 0) {
 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 && clientinfo->downloadinfo->content_name) {
 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 > 0) {
 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 && clientinfo->downloadinfo->mime_type) {
 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;
 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 <= 0
 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                         || !clientinfo->downloadinfo->content_name) {
 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;
 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;
 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_list_free(download_dbinfo_list *list)
 582 {
 583         TRACE_DEBUG_MSG("");
 584
 585         int i = 0;
 586         if (!list)
 587                 return;
 588
 589         if (list->count > 0 && list->item) {
 590                 for (i = 0; i < list->count; i++) {
 591                         list->item[i].requestid = 0;
 592                         if (list->item[i].packagename)
 593                                 free(list->item[i].packagename);
 594                         list->item[i].packagename = NULL;
 595                         if (list->item[i].installpath)
 596                                 free(list->item[i].installpath);
 597                         list->item[i].installpath = NULL;
 598                         if (list->item[i].filename)
 599                                 free(list->item[i].filename);
 600                         list->item[i].filename = NULL;
 601                         if (list->item[i].createdate)
 602                                 free(list->item[i].createdate);
 603                         list->item[i].createdate = NULL;
 604                         if (list->item[i].url)
 605                                 free(list->item[i].url);
 606                         list->item[i].url = NULL;
 607                         if (list->item[i].mimetype)
 608                                 free(list->item[i].mimetype);
 609                         list->item[i].mimetype = NULL;
 610                         if (list->item[i].etag)
 611                                 free(list->item[i].etag);
 612                         list->item[i].etag = NULL;
 613                         if (list->item[i].saved_path)
 614                                 free(list->item[i].saved_path);
 615                         list->item[i].saved_path = NULL;
 616                 }
 617                 free(list->item);
 618                 list->item = NULL;
 619         }
 620         free(list);
 621         list = NULL;
 622 }
 623
 624 download_request_info *download_provider_db_get_requestinfo(download_dbinfo *dbinfo)
 625 {
 626         if (!dbinfo || dbinfo->requestid <= 0)
 627                 return NULL;
 628
 629         download_request_info *requestinfo =
 630                 (download_request_info *) calloc(1, sizeof(download_request_info));
 631         requestinfo->requestid = dbinfo->requestid;
 632         if (dbinfo->packagename) {
 633                 requestinfo->client_packagename.length =
 634                         strlen(dbinfo->packagename);
 635                 if (requestinfo->client_packagename.length > 0) {
 636                         requestinfo->client_packagename.str
 637                                 =
 638                                 (char *)
 639                                 calloc((requestinfo->client_packagename.length + 1),
 640                                 sizeof(char));
 641                         memcpy(requestinfo->client_packagename.str,
 642                                         dbinfo->packagename,
 643                                         requestinfo->client_packagename.length *
 644                                 sizeof(char));
 645                         requestinfo->client_packagename.str[requestinfo->
 646                                                                 client_packagename.
 647                                                                 length] = '\0';
 648                 }
 649         }
 650         if (dbinfo->url) {
 651                 requestinfo->url.length = strlen(dbinfo->url);
 652                 if (requestinfo->url.length > 0) {
 653                         requestinfo->url.str
 654                                 =
 655                                 (char *)calloc((requestinfo->url.length + 1),
 656                                                 sizeof(char));
 657                         memcpy(requestinfo->url.str, dbinfo->url,
 658                                         requestinfo->url.length * sizeof(char));
 659                         requestinfo->url.str[requestinfo->url.length] = '\0';
 660                 }
 661         }
 662         if (dbinfo->installpath) {
 663                 requestinfo->install_path.length = strlen(dbinfo->installpath);
 664                 if (requestinfo->install_path.length > 0) {
 665                         requestinfo->install_path.str
 666                                 =
 667                                 (char *)
 668                                 calloc((requestinfo->install_path.length + 1),
 669                                         sizeof(char));
 670                         memcpy(requestinfo->install_path.str,
 671                                         dbinfo->installpath,
 672                                         requestinfo->install_path.length * sizeof(char));
 673                         requestinfo->install_path.str[requestinfo->install_path.
 674                                                                 length] = '\0';
 675                 }
 676         }
 677         if (dbinfo->filename) {
 678                 requestinfo->filename.length = strlen(dbinfo->filename);
 679                 if (requestinfo->filename.length > 0) {
 680                         requestinfo->filename.str
 681                                 =
 682                                 (char *)calloc((requestinfo->filename.length + 1),
 683                                                 sizeof(char));
 684                         memcpy(requestinfo->filename.str, dbinfo->filename,
 685                                         requestinfo->filename.length * sizeof(char));
 686                         requestinfo->filename.str[requestinfo->filename.
 687                                                         length] = '\0';
 688                 }
 689         }
 690         // disable callback.
 691         memset(&requestinfo->callbackinfo, 0x00, sizeof(callback_info));
 692         requestinfo->notification = dbinfo->notification;
 693         return requestinfo;
 694 }
 695
 696 int download_provider_db_history_new(download_clientinfo *clientinfo)
 697 {
 698         int errorcode;
 699         sqlite3_stmt *stmt;
 700
 701         if (!clientinfo || !clientinfo->requestinfo
 702                 || clientinfo->requestinfo->requestid <= 0) {
 703                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 704                 return -1;
 705         }
 706
 707         if (_download_provider_sql_open() < 0) {
 708                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 709                                 sqlite3_errmsg(g_download_provider_db));
 710                 return -1;
 711         }
 712
 713         errorcode =
 714                 sqlite3_prepare_v2(g_download_provider_db,
 715                                         "INSERT INTO history (uniqueid, packagename, filename, creationdate, state, mimetype, savedpath) VALUES (?, ?, ?, DATETIME('now'), ?, ?, ?)",
 716                                         -1, &stmt, NULL);
 717         if (errorcode != SQLITE_OK) {
 718                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 719                                 sqlite3_errmsg(g_download_provider_db));
 720                 _download_provider_sql_close(stmt);
 721                 return -1;
 722         }
 723         if (sqlite3_bind_int(stmt, 1, clientinfo->requestinfo->requestid) !=
 724                 SQLITE_OK) {
 725                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 726                                 sqlite3_errmsg(g_download_provider_db));
 727                 _download_provider_sql_close(stmt);
 728                 return -1;
 729         }
 730         if (clientinfo->requestinfo->client_packagename.length > 0) {
 731                 if (sqlite3_bind_text
 732                         (stmt, 2, clientinfo->requestinfo->client_packagename.str,
 733                          -1, NULL) != SQLITE_OK) {
 734                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 735                                         sqlite3_errmsg(g_download_provider_db));
 736                         _download_provider_sql_close(stmt);
 737                         return -1;
 738                 }
 739         }
 740         if (clientinfo->downloadinfo && clientinfo->downloadinfo->content_name) {
 741                 if (sqlite3_bind_text
 742                         (stmt, 3, clientinfo->downloadinfo->content_name, -1,
 743                         NULL) != SQLITE_OK) {
 744                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 745                                         sqlite3_errmsg(g_download_provider_db));
 746                         _download_provider_sql_close(stmt);
 747                         return -1;
 748                 }
 749         }
 750         if (sqlite3_bind_int(stmt, 4, clientinfo->state) != SQLITE_OK) {
 751                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 752                                 sqlite3_errmsg(g_download_provider_db));
 753                 _download_provider_sql_close(stmt);
 754                 return -1;
 755         }
 756         if (clientinfo->downloadinfo && clientinfo->downloadinfo->mime_type) {
 757                 if (sqlite3_bind_text
 758                         (stmt, 5, clientinfo->downloadinfo->mime_type, -1,
 759                         NULL) != SQLITE_OK) {
 760                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 761                                         sqlite3_errmsg(g_download_provider_db));
 762                         _download_provider_sql_close(stmt);
 763                         return -1;
 764                 }
 765         }
 766         if (clientinfo->tmp_saved_path) {
 767                 if (sqlite3_bind_text
 768                         (stmt, 6, clientinfo->tmp_saved_path, -1,
 769                         NULL) != SQLITE_OK) {
 770                         TRACE_DEBUG_MSG("sqlite3_bind_text is failed. [%s]",
 771                                         sqlite3_errmsg(g_download_provider_db));
 772                         _download_provider_sql_close(stmt);
 773                         return -1;
 774                 }
 775         }
 776         errorcode = sqlite3_step(stmt);
 777         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 778                 _download_provider_sql_close(stmt);
 779                 download_provider_db_history_limit_rows();
 780                 return 0;
 781         }
 782         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 783                         sqlite3_errmsg(g_download_provider_db));
 784         __download_provider_db_close();
 785         return -1;
 786 }
 787
 788 int download_provider_db_history_remove(int uniqueid)
 789 {
 790         int errorcode;
 791         sqlite3_stmt *stmt;
 792
 793         if (uniqueid <= 0) {
 794                 TRACE_DEBUG_MSG("[NULL-CHECK]");
 795                 return -1;
 796         }
 797
 798         if (_download_provider_sql_open() < 0) {
 799                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 800                                 sqlite3_errmsg(g_download_provider_db));
 801                 return -1;
 802         }
 803
 804         errorcode =
 805                 sqlite3_prepare_v2(g_download_provider_db,
 806                                         "delete from history where uniqueid = ?",
 807                                         -1, &stmt, NULL);
 808         if (errorcode != SQLITE_OK) {
 809                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 810                                 sqlite3_errmsg(g_download_provider_db));
 811                 _download_provider_sql_close(stmt);
 812                 return -1;
 813         }
 814         if (sqlite3_bind_int(stmt, 1, uniqueid) != SQLITE_OK) {
 815                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 816                                 sqlite3_errmsg(g_download_provider_db));
 817                 _download_provider_sql_close(stmt);
 818                 return -1;
 819         }
 820         errorcode = sqlite3_step(stmt);
 821         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 822                 _download_provider_sql_close(stmt);
 823                 return 0;
 824         }
 825         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 826                         sqlite3_errmsg(g_download_provider_db));
 827         __download_provider_db_close();
 828         return -1;
 829 }
 830
 831 int download_provider_db_history_limit_rows()
 832 {
 833         int errorcode;
 834         sqlite3_stmt *stmt;
 835
 836         if (_download_provider_sql_open() < 0) {
 837                 TRACE_DEBUG_MSG("db_util_open is failed [%s]",
 838                                 sqlite3_errmsg(g_download_provider_db));
 839                 return -1;
 840         }
 841
 842         errorcode =
 843                 sqlite3_prepare_v2(g_download_provider_db,
 844                                         "DELETE FROM history where uniqueid NOT IN (SELECT uniqueid FROM history ORDER BY id DESC LIMIT ?)",
 845                                         -1, &stmt, NULL);
 846         if (errorcode != SQLITE_OK) {
 847                 TRACE_DEBUG_MSG("sqlite3_prepare_v2 is failed. [%s]",
 848                                 sqlite3_errmsg(g_download_provider_db));
 849                 _download_provider_sql_close(stmt);
 850                 return -1;
 851         }
 852         if (sqlite3_bind_int(stmt, 1, DOWNLOAD_PROVIDER_HISTORY_DB_LIMIT_ROWS)
 853                 != SQLITE_OK) {
 854                 TRACE_DEBUG_MSG("sqlite3_bind_int is failed. [%s]",
 855                                 sqlite3_errmsg(g_download_provider_db));
 856                 _download_provider_sql_close(stmt);
 857                 return -1;
 858         }
 859         errorcode = sqlite3_step(stmt);
 860         if (errorcode == SQLITE_OK || errorcode == SQLITE_DONE) {
 861                 _download_provider_sql_close(stmt);
 862                 return 0;
 863         }
 864         TRACE_DEBUG_MSG("sqlite3_step is failed [%s]",
 865                         sqlite3_errmsg(g_download_provider_db));
 866         __download_provider_db_close();
 867         return -1;
 868 }