Debian Codegraph @

src/cd-device-db.c

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2010 Richard Hughes <[email protected]>
4 *
5 * Licensed under the GNU General Public License Version 2
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20 */
21
22 #include "config.h"
23
24 #include <gio/gio.h>
25 #include <glib-object.h>
26 #include <sqlite3.h>
27
28 #include "cd-common.h"
29 #include "cd-device-db.h"
30
31 static void cd_device_db_finalize (GObject *object);
32
33 #define GET_PRIVATE(o) (cd_device_db_get_instance_private (o))
34
35 typedef struct
36 {
37 sqlite3 *db;
38 } CdDeviceDbPrivate;
39
40 static gpointer cd_device_db_object = NULL;
41
42 G_DEFINE_TYPE_WITH_PRIVATE (CdDeviceDb, cd_device_db, G_TYPE_OBJECT)
43
44 gboolean
45 cd_device_db_load (CdDeviceDb *ddb,
46 const gchar *filename,
47 GError **error)
48 {
49 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
50 const gchar *statement;
51 gint rc;
52 g_autofree gchar *path = NULL;
53
54 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), FALSE);
55 g_return_val_if_fail (priv->db == NULL, FALSE);
56
57 /* ensure the path exists */
58 path = g_path_get_dirname (filename);
59 if (!cd_main_mkdir_with_parents (path, error))
60 return FALSE;
61
62 g_debug ("CdDeviceDb: trying to open database '%s'", filename);
63 g_info ("Using device database file %s", filename);
64 rc = sqlite3_open (filename, &priv->db);
65 if (rc != SQLITE_OK) {
66 g_set_error (error,
67 CD_CLIENT_ERROR,
68 CD_CLIENT_ERROR_INTERNAL,
69 "Can't open database: %s\n",
70 sqlite3_errmsg (priv->db));
71 sqlite3_close (priv->db);
72 return FALSE;
73 }
74
75 /* we don't need to keep doing fsync */
76 sqlite3_exec (priv->db, "PRAGMA synchronous=OFF",
77 NULL, NULL, NULL);
78
79 /* check devices */
80 rc = sqlite3_exec (priv->db, "SELECT * FROM devices LIMIT 1",
81 NULL, NULL, NULL);
82 if (rc != SQLITE_OK) {
83 g_debug ("CdDeviceDb: creating table to repair: %s", sqlite3_errmsg(priv->db));
84 statement = "CREATE TABLE devices ("
85 "device_id TEXT PRIMARY KEY,"
86 "device TEXT);";
87 sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
88 }
89
90 /* check properties version 2 */
91 rc = sqlite3_exec (priv->db, "SELECT * FROM properties_v2 LIMIT 1",
92 NULL, NULL, NULL);
93 if (rc != SQLITE_OK) {
94 statement = "CREATE TABLE properties_v2 ("
95 "device_id TEXT,"
96 "property TEXT,"
97 "value TEXT,"
98 "PRIMARY KEY (device_id, property));";
99 sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
100 }
101 return TRUE;
102 }
103
104 gboolean
105 cd_device_db_empty (CdDeviceDb *ddb,
106 GError **error)
107 {
108 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
109 const gchar *statement;
110 gint rc;
111
112 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), FALSE);
113 g_return_val_if_fail (priv->db != NULL, FALSE);
114
115 statement = "DELETE FROM devices;DELETE FROM properties_v2;";
116 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
117 if (rc != SQLITE_OK) {
118 g_set_error (error,
119 CD_CLIENT_ERROR,
120 CD_CLIENT_ERROR_INTERNAL,
121 "SQL error: %s",
122 sqlite3_errmsg(priv->db));
123 return FALSE;
124 }
125 return TRUE;
126 }
127
128 gboolean
129 cd_device_db_add (CdDeviceDb *ddb,
130 const gchar *device_id,
131 GError **error)
132 {
133 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
134 gboolean ret = TRUE;
135 gchar *statement;
136 gint rc;
137
138 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), FALSE);
139 g_return_val_if_fail (priv->db != NULL, FALSE);
140
141 g_debug ("CdDeviceDb: add device %s", device_id);
142 statement = sqlite3_mprintf ("INSERT INTO devices (device_id) "
143 "VALUES ('%q')",
144 device_id);
145
146 /* insert the entry */
147 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
148 if (rc != SQLITE_OK) {
149 g_set_error (error,
150 CD_CLIENT_ERROR,
151 CD_CLIENT_ERROR_INTERNAL,
152 "SQL error: %s",
153 sqlite3_errmsg(priv->db));
154 ret = FALSE;
155 goto out;
156 }
157 out:
158 sqlite3_free (statement);
159 return ret;
160 }
161
162 gboolean
163 cd_device_db_set_property (CdDeviceDb *ddb,
164 const gchar *device_id,
165 const gchar *property,
166 const gchar *value,
167 GError **error)
168 {
169 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
170 gboolean ret = TRUE;
171 gchar *statement;
172 gint rc;
173
174 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), FALSE);
175 g_return_val_if_fail (priv->db != NULL, FALSE);
176
177 g_debug ("CdDeviceDb: add device property %s [%s=%s]",
178 device_id, property, value);
179 statement = sqlite3_mprintf ("INSERT OR REPLACE INTO properties_v2 (device_id, property, value) "
180 "VALUES ('%q', '%q', '%q');",
181 device_id, property, value);
182
183 /* insert the entry */
184 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
185 if (rc != SQLITE_OK) {
186 g_set_error (error,
187 CD_CLIENT_ERROR,
188 CD_CLIENT_ERROR_INTERNAL,
189 "SQL error: %s",
190 sqlite3_errmsg(priv->db));
191 ret = FALSE;
192 goto out;
193 }
194 out:
195 sqlite3_free (statement);
196 return ret;
197 }
198
199 gboolean
200 cd_device_db_remove (CdDeviceDb *ddb,
201 const gchar *device_id,
202 GError **error)
203 {
204 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
205 gboolean ret = TRUE;
206 gchar *statement1 = NULL;
207 gchar *statement2 = NULL;
208 gint rc;
209
210 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), FALSE);
211 g_return_val_if_fail (priv->db != NULL, FALSE);
212
213 /* remove the entry */
214 g_debug ("CdDeviceDb: remove device %s", device_id);
215 statement1 = sqlite3_mprintf ("DELETE FROM devices WHERE "
216 "device_id = '%q';",
217 device_id);
218 rc = sqlite3_exec (priv->db, statement1, NULL, NULL, NULL);
219 if (rc != SQLITE_OK) {
220 g_set_error (error,
221 CD_CLIENT_ERROR,
222 CD_CLIENT_ERROR_INTERNAL,
223 "SQL error: %s",
224 sqlite3_errmsg(priv->db));
225 ret = FALSE;
226 goto out;
227 }
228 statement2 = sqlite3_mprintf ("DELETE FROM properties_v2 WHERE "
229 "device_id = '%q';",
230 device_id);
231 rc = sqlite3_exec (priv->db, statement2, NULL, NULL, NULL);
232 if (rc != SQLITE_OK) {
233 g_set_error (error,
234 CD_CLIENT_ERROR,
235 CD_CLIENT_ERROR_INTERNAL,
236 "SQL error: %s",
237 sqlite3_errmsg(priv->db));
238 ret = FALSE;
239 goto out;
240 }
241 out:
242 sqlite3_free (statement1);
243 sqlite3_free (statement2);
244 return ret;
245 }
246
247 static gint
248 cd_device_db_sqlite_cb (void *data,
249 gint argc,
250 gchar **argv,
251 gchar **col_name)
252 {
253 GPtrArray *array = (GPtrArray *) data;
254
255 /* should only be one entry */
256 g_debug ("CdDeviceDb: got sql result %s", argv[0]);
257 g_ptr_array_add (array, g_strdup (argv[0]));
258 return 0;
259 }
260
261 gchar *
262 cd_device_db_get_property (CdDeviceDb *ddb,
263 const gchar *device_id,
264 const gchar *property,
265 GError **error)
266 {
267 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
268 gchar *statement;
269 gint rc;
270 gchar *value = NULL;
271 g_autoptr(GPtrArray) array_tmp = NULL;
272
273 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), NULL);
274 g_return_val_if_fail (priv->db != NULL, NULL);
275
276 g_debug ("CdDeviceDb: get property %s for %s", property, device_id);
277 statement = sqlite3_mprintf ("SELECT value FROM properties_v2 WHERE "
278 "device_id = '%q' AND "
279 "property = '%q' LIMIT 1;",
280 device_id, property);
281
282 /* remove the entry */
283 array_tmp = g_ptr_array_new_with_free_func (g_free);
284 rc = sqlite3_exec (priv->db,
285 statement,
286 cd_device_db_sqlite_cb,
287 array_tmp,
288 NULL);
289 if (rc != SQLITE_OK) {
290 g_set_error (error,
291 CD_CLIENT_ERROR,
292 CD_CLIENT_ERROR_INTERNAL,
293 "SQL error: %s",
294 sqlite3_errmsg(priv->db));
295 goto out;
296 }
297
298 /* never set */
299 if (array_tmp->len == 0) {
300 g_set_error (error,
301 CD_CLIENT_ERROR,
302 CD_CLIENT_ERROR_INTERNAL,
303 "no such property %s for %s",
304 property, device_id);
305 goto out;
306 }
307
308 /* success */
309 value = g_strdup (g_ptr_array_index (array_tmp, 0));
310 out:
311 sqlite3_free (statement);
312 return value;
313 }
314
315 GPtrArray *
316 cd_device_db_get_devices (CdDeviceDb *ddb,
317 GError **error)
318 {
319 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
320 gchar *statement;
321 gint rc;
322 GPtrArray *array = NULL;
323 g_autoptr(GPtrArray) array_tmp = NULL;
324
325 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), NULL);
326 g_return_val_if_fail (priv->db != NULL, NULL);
327
328 /* get all the devices */
329 g_debug ("CdDeviceDb: get devices");
330 statement = sqlite3_mprintf ("SELECT device_id FROM devices;");
331 array_tmp = g_ptr_array_new_with_free_func (g_free);
332 rc = sqlite3_exec (priv->db,
333 statement,
334 cd_device_db_sqlite_cb,
335 array_tmp,
336 NULL);
337 if (rc != SQLITE_OK) {
338 g_set_error (error,
339 CD_CLIENT_ERROR,
340 CD_CLIENT_ERROR_INTERNAL,
341 "SQL error: %s",
342 sqlite3_errmsg(priv->db));
343 goto out;
344 }
345
346 /* success */
347 array = g_ptr_array_ref (array_tmp);
348 out:
349 sqlite3_free (statement);
350 return array;
351 }
352
353 GPtrArray *
354 cd_device_db_get_properties (CdDeviceDb *ddb,
355 const gchar *device_id,
356 GError **error)
357 {
358 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
359 gchar *statement;
360 gint rc;
361 GPtrArray *array = NULL;
362 g_autoptr(GPtrArray) array_tmp = NULL;
363
364 g_return_val_if_fail (CD_IS_DEVICE_DB (ddb), NULL);
365 g_return_val_if_fail (priv->db != NULL, NULL);
366
367 /* get all the devices */
368 g_debug ("CdDeviceDb: get properties for device %s", device_id);
369 statement = sqlite3_mprintf ("SELECT property FROM properties_v2 "
370 "WHERE device_id = '%q';",
371 device_id);
372 array_tmp = g_ptr_array_new_with_free_func (g_free);
373 rc = sqlite3_exec (priv->db,
374 statement,
375 cd_device_db_sqlite_cb,
376 array_tmp,
377 NULL);
378 if (rc != SQLITE_OK) {
379 g_set_error (error,
380 CD_CLIENT_ERROR,
381 CD_CLIENT_ERROR_INTERNAL,
382 "SQL error: %s",
383 sqlite3_errmsg(priv->db));
384 goto out;
385 }
386
387 /* success */
388 array = g_ptr_array_ref (array_tmp);
389 out:
390 sqlite3_free (statement);
391 return array;
392 }
393
394 static void
395 cd_device_db_class_init (CdDeviceDbClass *klass)
396 {
397 GObjectClass *object_class = G_OBJECT_CLASS (klass);
398 object_class->finalize = cd_device_db_finalize;
399 }
400
401 static void
402 cd_device_db_init (CdDeviceDb *ddb)
403 {
404 }
405
406 static void
407 cd_device_db_finalize (GObject *object)
408 {
409 CdDeviceDb *ddb = CD_DEVICE_DB (object);
410 CdDeviceDbPrivate *priv = GET_PRIVATE (ddb);
411
412 /* close the database */
413 sqlite3_close (priv->db);
414
415 G_OBJECT_CLASS (cd_device_db_parent_class)->finalize (object);
416 }
417
418 CdDeviceDb *
419 cd_device_db_new (void)
420 {
421 if (cd_device_db_object != NULL) {
422 g_object_ref (cd_device_db_object);
423 } else {
424 cd_device_db_object = g_object_new (CD_TYPE_DEVICE_DB, NULL);
425 g_object_add_weak_pointer (cd_device_db_object, &cd_device_db_object);
426 }
427 return CD_DEVICE_DB (cd_device_db_object);
428 }