release/src/router/minidlna/sql.c

   1 /* MiniDLNA media server
   2  * Copyright (C) 2008-2009  Justin Maggard
   3  *
   4  * This file is part of MiniDLNA.
   5  *
   6  * MiniDLNA is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * MiniDLNA is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with MiniDLNA. If not, see <http://www.gnu.org/licenses/>.
  17  */
  18 #include <stdio.h>
  19 #include <string.h>
  20 #include <unistd.h>
  21
  22 #include "sql.h"
  23 #include "log.h"
  24
  25 int
  26 sql_exec(sqlite3 *db, const char *fmt, ...)
  27 {
  28         int ret;
  29         char *errMsg = NULL;
  30         char *sql;
  31         va_list ap;
  32         //DPRINTF(E_DEBUG, L_DB_SQL, "SQL: %s\n", sql);
  33
  34         va_start(ap, fmt);
  35
  36         sql = sqlite3_vmprintf(fmt, ap);
  37         ret = sqlite3_exec(db, sql, 0, 0, &errMsg);
  38         if( ret != SQLITE_OK )
  39         {
  40                 DPRINTF(E_ERROR, L_DB_SQL, "SQL ERROR %d [%s]\n%s\n", ret, errMsg, sql);
  41                 if (errMsg)
  42                         sqlite3_free(errMsg);
  43         }
  44         sqlite3_free(sql);
  45
  46         return ret;
  47 }
  48
  49 int
  50 sql_get_table(sqlite3 *db, const char *sql, char ***pazResult, int *pnRow, int *pnColumn)
  51 {
  52         int ret;
  53         char *errMsg = NULL;
  54         //DPRINTF(E_DEBUG, L_DB_SQL, "SQL: %s\n", sql);
  55
  56         ret = sqlite3_get_table(db, sql, pazResult, pnRow, pnColumn, &errMsg);
  57         if( ret != SQLITE_OK )
  58         {
  59                 DPRINTF(E_ERROR, L_DB_SQL, "SQL ERROR %d [%s]\n%s\n", ret, errMsg, sql);
  60                 if (errMsg)
  61                         sqlite3_free(errMsg);
  62         }
  63
  64         return ret;
  65 }
  66
  67 int
  68 sql_get_int_field(sqlite3 *db, const char *fmt, ...)
  69 {
  70         va_list         ap;
  71         int             counter, result;
  72         char            *sql;
  73         int             ret;
  74         sqlite3_stmt    *stmt;
  75
  76         va_start(ap, fmt);
  77
  78         sql = sqlite3_vmprintf(fmt, ap);
  79
  80         //DPRINTF(E_DEBUG, L_DB_SQL, "sql: %s\n", sql);
  81
  82         switch (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL))
  83         {
  84                 case SQLITE_OK:
  85                         break;
  86                 default:
  87                         DPRINTF(E_ERROR, L_DB_SQL, "prepare failed: %s\n%s\n", sqlite3_errmsg(db), sql);
  88                         sqlite3_free(sql);
  89                         return -1;
  90         }
  91         sqlite3_free(sql);
  92
  93         for (counter = 0;
  94              ((result = sqlite3_step(stmt)) == SQLITE_BUSY || result == SQLITE_LOCKED) && counter < 2;
  95              counter++) {
  96                  /* While SQLITE_BUSY has a built in timeout,
  97                     SQLITE_LOCKED does not, so sleep */
  98                  if (result == SQLITE_LOCKED)
  99                         sleep(1);
 100         }
 101
 102         switch (result)
 103         {
 104                 case SQLITE_DONE:
 105                         /* no rows returned */
 106                         ret = 0;
 107                         break;
 108                 case SQLITE_ROW:
 109                         if (sqlite3_column_type(stmt, 0) == SQLITE_NULL)
 110                         {
 111                                 ret = 0;
 112                                 break;
 113                         }
 114                         ret = sqlite3_column_int(stmt, 0);
 115                         break;
 116                 default:
 117                         DPRINTF(E_WARN, L_DB_SQL, "%s: step failed: %s\n", __func__, sqlite3_errmsg(db));
 118                         ret = -1;
 119                         break;
 120         }
 121
 122         sqlite3_finalize(stmt);
 123         return ret;
 124 }
 125
 126 char *
 127 sql_get_text_field(void *db, const char *fmt, ...)
 128 {
 129         va_list         ap;
 130         int             counter, result, len;
 131         char            *sql;
 132         char            *str;
 133         sqlite3_stmt    *stmt;
 134
 135         va_start(ap, fmt);
 136
 137         if (db == NULL)
 138         {
 139                 DPRINTF(E_WARN, L_DB_SQL, "%s: db is NULL", __func__);
 140                 return NULL;
 141         }
 142
 143         sql = sqlite3_vmprintf(fmt, ap);
 144
 145         //DPRINTF(E_DEBUG, L_DB_SQL, "sql: %s\n", sql);
 146
 147         switch (sqlite3_prepare_v2(db, sql, -1, &stmt, NULL))
 148         {
 149                 case SQLITE_OK:
 150                         break;
 151                 default:
 152                         DPRINTF(E_ERROR, L_DB_SQL, "prepare failed: %s\n%s\n", sqlite3_errmsg(db), sql);
 153                         sqlite3_free(sql);
 154                         return NULL;
 155         }
 156         sqlite3_free(sql);
 157
 158         for (counter = 0;
 159              ((result = sqlite3_step(stmt)) == SQLITE_BUSY || result == SQLITE_LOCKED) && counter < 2;
 160              counter++)
 161         {
 162                 /* While SQLITE_BUSY has a built in timeout,
 163                  * SQLITE_LOCKED does not, so sleep */
 164                 if (result == SQLITE_LOCKED)
 165                         sleep(1);
 166         }
 167
 168         switch (result)
 169         {
 170                 case SQLITE_DONE:
 171                         /* no rows returned */
 172                         str = NULL;
 173                         break;
 174
 175                 case SQLITE_ROW:
 176                         if (sqlite3_column_type(stmt, 0) == SQLITE_NULL)
 177                         {
 178                                 str = NULL;
 179                                 break;
 180                         }
 181
 182                         len = sqlite3_column_bytes(stmt, 0);
 183                         if ((str = sqlite3_malloc(len + 1)) == NULL)
 184                         {
 185                                 DPRINTF(E_ERROR, L_DB_SQL, "malloc failed");
 186                                 break;
 187                         }
 188
 189                         strncpy(str, (char *)sqlite3_column_text(stmt, 0), len + 1);
 190                         break;
 191
 192                 default:
 193                         DPRINTF(E_WARN, L_DB_SQL, "%s: step failed: %s", __func__, sqlite3_errmsg(db));
 194                         str = NULL;
 195                         break;
 196         }
 197
 198         sqlite3_finalize(stmt);
 199         return str;
 200 }