Debian Codegraph @

src/cd-mapping-db.c

raw
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
2 *
3 * Copyright (C) 2010-2011 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 <errno.h>
25 #include <gio/gio.h>
26 #include <glib-object.h>
27 #include <glib/gstdio.h>
28 #include <sqlite3.h>
29
30 #include "cd-common.h"
31 #include "cd-mapping-db.h"
32
33 static void cd_mapping_db_finalize (GObject *object);
34
35 #define GET_PRIVATE(o) (cd_mapping_db_get_instance_private (o))
36
37 typedef struct
38 {
39 sqlite3 *db;
40 } CdMappingDbPrivate;
41
42 static gpointer cd_mapping_db_object = NULL;
43
44 G_DEFINE_TYPE_WITH_PRIVATE (CdMappingDb, cd_mapping_db, G_TYPE_OBJECT)
45
46 static gint
47 cd_mapping_db_convert_cb (void *data, gint argc, gchar **argv, gchar **col_name)
48 {
49 CdMappingDb *mdb = (CdMappingDb *) data;
50 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
51 gchar *statement;
52 gint rc;
53
54 statement = sqlite3_mprintf ("INSERT INTO mappings_v2 (device, profile, timestamp) "
55 "VALUES ('%q', '%q', '%q')",
56 argv[0], argv[1], argv[2]);
57 rc = sqlite3_exec (priv->db, statement,
58 NULL, NULL, NULL);
59 sqlite3_free (statement);
60 return rc;
61 }
62
63 static gboolean
64 cd_mapping_db_open (CdMappingDb *mdb,
65 const gchar *filename,
66 gboolean retry,
67 GError **error)
68 {
69 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
70 gint rc;
71 g_autofree gchar *path = NULL;
72
73 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), FALSE);
74 g_return_val_if_fail (priv->db == NULL, FALSE);
75
76 /* ensure the path exists */
77 path = g_path_get_dirname (filename);
78 if (!cd_main_mkdir_with_parents (path, error))
79 return FALSE;
80
81 g_debug ("CdMappingDb: trying to open database '%s'", filename);
82 g_info ("Using mapping database file %s", filename);
83 rc = sqlite3_open (filename, &priv->db);
84 if (rc != SQLITE_OK) {
85 g_set_error (error,
86 CD_CLIENT_ERROR,
87 CD_CLIENT_ERROR_INTERNAL,
88 "Can't open database: %s\n",
89 sqlite3_errmsg (priv->db));
90 sqlite3_close (priv->db);
91 return FALSE;
92 }
93
94 /* sanity check of the database */
95 rc = sqlite3_exec (priv->db, "PRAGMA quick_check", NULL, NULL, NULL);
96 if (rc != SQLITE_OK) {
97 /* Database appears to be mangled, so wipe it and try again */
98 sqlite3_close (priv->db);
99 priv->db = NULL;
100
101 if (retry) {
102 if (g_unlink (filename) != 0) {
103 g_set_error (error,
104 CD_CLIENT_ERROR,
105 CD_CLIENT_ERROR_INTERNAL,
106 "Cannot remove damaged database: %s",
107 g_strerror (errno));
108 return FALSE;
109 }
110
111 return cd_mapping_db_open (mdb, filename, FALSE, error);
112 } else {
113 g_set_error (error,
114 CD_CLIENT_ERROR,
115 CD_CLIENT_ERROR_INTERNAL,
116 "Cannot open mapping database: %s",
117 sqlite3_errmsg(priv->db));
118 return FALSE;
119 }
120 }
121
122 return TRUE;
123 }
124
125 gboolean
126 cd_mapping_db_load (CdMappingDb *mdb,
127 const gchar *filename,
128 GError **error)
129 {
130 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
131 const gchar *statement;
132 gint rc;
133 g_autofree gchar *path = NULL;
134
135 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), FALSE);
136 g_return_val_if_fail (priv->db == NULL, FALSE);
137
138 if (!cd_mapping_db_open (mdb, filename, TRUE, error))
139 return FALSE;
140
141 /* we don't need to keep doing fsync */
142 rc = sqlite3_exec (priv->db, "PRAGMA synchronous=OFF",
143 NULL, NULL, NULL);
144 if (rc != SQLITE_OK) {
145 g_set_error (error,
146 CD_CLIENT_ERROR,
147 CD_CLIENT_ERROR_INTERNAL,
148 "Failed to turn off synchronous operations: SQL error: %s",
149 sqlite3_errmsg(priv->db));
150 return FALSE;
151 }
152 /* check mappings */
153 rc = sqlite3_exec (priv->db, "SELECT * FROM mappings LIMIT 1",
154 NULL, NULL, NULL);
155 if (rc != SQLITE_OK) {
156 g_debug ("CdMappingDb: creating table to repair: %s", sqlite3_errmsg(priv->db));
157 statement = "CREATE TABLE mappings ("
158 "timestamp INTEGER DEFAULT 0,"
159 "device TEXT,"
160 "profile TEXT);";
161 sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
162 }
163
164 /* check mappings has timestamp (since 0.1.8) */
165 rc = sqlite3_exec (priv->db,
166 "SELECT timestamp FROM mappings LIMIT 1",
167 NULL, NULL, NULL);
168 if (rc != SQLITE_OK) {
169 g_debug ("CdMappingDb: altering table to repair: %s", sqlite3_errmsg(priv->db));
170 statement = "ALTER TABLE mappings ADD COLUMN timestamp INTEGER DEFAULT 0;";
171 sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
172 }
173
174 /* check mappings version 2 exists (since 0.1.29) */
175 rc = sqlite3_exec (priv->db, "SELECT * FROM mappings_v2 LIMIT 1",
176 NULL, NULL, NULL);
177 if (rc != SQLITE_OK) {
178 g_debug ("CdMappingDb: altering table to convert: %s", sqlite3_errmsg(priv->db));
179 statement = "CREATE TABLE mappings_v2 ("
180 "timestamp INTEGER DEFAULT 0,"
181 "device TEXT,"
182 "profile TEXT,"
183 "PRIMARY KEY (device, profile));";
184 sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
185
186 /* copy all the mapping data from v1 to v2 */
187 statement = "SELECT device, profile, timestamp FROM mappings;";
188 rc = sqlite3_exec (priv->db,
189 statement,
190 cd_mapping_db_convert_cb,
191 mdb,
192 NULL);
193 if (rc != SQLITE_OK) {
194 g_set_error (error,
195 CD_CLIENT_ERROR,
196 CD_CLIENT_ERROR_INTERNAL,
197 "Failed to migrate mappings: SQL error: %s",
198 sqlite3_errmsg(priv->db));
199 return FALSE;
200 }
201
202 /* remove old table data */
203 statement = "DELETE FROM mappings;";
204 rc = sqlite3_exec (priv->db, statement,
205 NULL, NULL, NULL);
206 if (rc != SQLITE_OK) {
207 g_set_error (error,
208 CD_CLIENT_ERROR,
209 CD_CLIENT_ERROR_INTERNAL,
210 "Failed to migrate mappings: SQL error: %s",
211 sqlite3_errmsg(priv->db));
212 return FALSE;
213 }
214 }
215 return TRUE;
216 }
217
218 gboolean
219 cd_mapping_db_empty (CdMappingDb *mdb,
220 GError **error)
221 {
222 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
223 const gchar *statement;
224 gint rc;
225
226 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), FALSE);
227 g_return_val_if_fail (priv->db != NULL, FALSE);
228
229 statement = "DELETE FROM mappings_v2;";
230 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
231 if (rc != SQLITE_OK) {
232 g_set_error (error,
233 CD_CLIENT_ERROR,
234 CD_CLIENT_ERROR_INTERNAL,
235 "SQL error: %s",
236 sqlite3_errmsg(priv->db));
237 return FALSE;
238 }
239 return TRUE;
240 }
241
242 gboolean
243 cd_mapping_db_add (CdMappingDb *mdb,
244 const gchar *device_id,
245 const gchar *profile_id,
246 GError **error)
247 {
248 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
249 gboolean ret = TRUE;
250 gchar *statement;
251 gint rc;
252 gint64 timestamp;
253
254 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), FALSE);
255 g_return_val_if_fail (priv->db != NULL, FALSE);
256
257 g_debug ("CdMappingDb: add %s<=>%s",
258 device_id, profile_id);
259 timestamp = g_get_real_time ();
260 statement = sqlite3_mprintf ("INSERT OR REPLACE INTO mappings_v2 (device, profile, timestamp) "
261 "VALUES ('%q', '%q', %"G_GINT64_FORMAT")",
262 device_id, profile_id, timestamp);
263
264 /* insert the entry */
265 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
266 if (rc != SQLITE_OK) {
267 g_set_error (error,
268 CD_CLIENT_ERROR,
269 CD_CLIENT_ERROR_INTERNAL,
270 "SQL error: %s",
271 sqlite3_errmsg(priv->db));
272 ret = FALSE;
273 goto out;
274 }
275 out:
276 sqlite3_free (statement);
277 return ret;
278 }
279
280 /**
281 * cd_mapping_db_clear_timestamp:
282 *
283 * Setting a timestamp to zero means that the soft-auto-add should not
284 * be done as the user has explicitly removed it.
285 *
286 * If the mapping does not exist then it will be automatically added.
287 **/
288 gboolean
289 cd_mapping_db_clear_timestamp (CdMappingDb *mdb,
290 const gchar *device_id,
291 const gchar *profile_id,
292 GError **error)
293 {
294 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
295 gboolean ret = TRUE;
296 gchar *statement;
297 gint rc;
298
299 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), FALSE);
300 g_return_val_if_fail (priv->db != NULL, FALSE);
301
302 g_debug ("CdMappingDb: clearing timestamp %s<=>%s",
303 device_id, profile_id);
304 statement = sqlite3_mprintf ("INSERT OR REPLACE INTO mappings_v2 (device, profile, timestamp) "
305 "VALUES ('%q', '%q', 0);",
306 device_id, profile_id);
307
308 /* update the entry */
309 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
310 if (rc != SQLITE_OK) {
311 g_set_error (error,
312 CD_CLIENT_ERROR,
313 CD_CLIENT_ERROR_INTERNAL,
314 "SQL error: %s",
315 sqlite3_errmsg(priv->db));
316 ret = FALSE;
317 goto out;
318 }
319 out:
320 sqlite3_free (statement);
321 return ret;
322 }
323
324 /**
325 * cd_mapping_db_remove:
326 *
327 * You probably don't want to use this function. See the related
328 * cd_mapping_db_clear_timestamp() for more details.
329 **/
330 gboolean
331 cd_mapping_db_remove (CdMappingDb *mdb,
332 const gchar *device_id,
333 const gchar *profile_id,
334 GError **error)
335 {
336 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
337 gboolean ret = TRUE;
338 gchar *statement;
339 gint rc;
340
341 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), FALSE);
342 g_return_val_if_fail (priv->db != NULL, FALSE);
343
344 g_debug ("CdMappingDb: remove %s<=>%s", device_id, profile_id);
345 statement = sqlite3_mprintf ("DELETE FROM mappings_v2 WHERE "
346 "device = '%q' AND profile = '%q';",
347 device_id, profile_id);
348
349 /* remove the entry */
350 rc = sqlite3_exec (priv->db, statement, NULL, NULL, NULL);
351 if (rc != SQLITE_OK) {
352 g_set_error (error,
353 CD_CLIENT_ERROR,
354 CD_CLIENT_ERROR_INTERNAL,
355 "SQL error: %s",
356 sqlite3_errmsg(priv->db));
357 ret = FALSE;
358 goto out;
359 }
360 out:
361 sqlite3_free (statement);
362 return ret;
363 }
364
365 static gint
366 cd_mapping_db_sqlite_cb (void *data,
367 gint argc,
368 gchar **argv,
369 gchar **col_name)
370 {
371 GPtrArray *array = (GPtrArray *) data;
372
373 /* should only be one entry */
374 g_debug ("CdMappingDb: got sql entry %s", argv[0]);
375 g_ptr_array_add (array, g_strdup (argv[0]));
376 return 0;
377 }
378
379 /**
380 * cd_mapping_db_get_profiles:
381 *
382 * The returned values are returned with the oldest assigned profile in
383 * the first position and the newest assigned profile in last posision.
384 **/
385 GPtrArray *
386 cd_mapping_db_get_profiles (CdMappingDb *mdb,
387 const gchar *device_id,
388 GError **error)
389 {
390 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
391 gchar *statement;
392 gint rc;
393 GPtrArray *array = NULL;
394 g_autoptr(GPtrArray) array_tmp = NULL;
395
396 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), NULL);
397 g_return_val_if_fail (priv->db != NULL, NULL);
398
399 g_debug ("CdMappingDb: get profiles for %s", device_id);
400 statement = sqlite3_mprintf ("SELECT profile FROM mappings_v2 WHERE "
401 "device = '%q' AND timestamp > 0 "
402 "ORDER BY timestamp ASC;", device_id);
403
404 /* remove the entry */
405 array_tmp = g_ptr_array_new_with_free_func (g_free);
406 rc = sqlite3_exec (priv->db,
407 statement,
408 cd_mapping_db_sqlite_cb,
409 array_tmp,
410 NULL);
411 if (rc != SQLITE_OK) {
412 g_set_error (error,
413 CD_CLIENT_ERROR,
414 CD_CLIENT_ERROR_INTERNAL,
415 "SQL error: %s",
416 sqlite3_errmsg(priv->db));
417 goto out;
418 }
419
420 /* success */
421 array = g_ptr_array_ref (array_tmp);
422 out:
423 sqlite3_free (statement);
424 return array;
425 }
426
427 /**
428 * cd_mapping_db_get_devices:
429 *
430 * The returned values are returned with the oldest assigned profile in
431 * the first position and the newest assigned profile in last posision.
432 **/
433 GPtrArray *
434 cd_mapping_db_get_devices (CdMappingDb *mdb,
435 const gchar *profile_id,
436 GError **error)
437 {
438 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
439 gchar *statement;
440 gint rc;
441 GPtrArray *array = NULL;
442 g_autoptr(GPtrArray) array_tmp = NULL;
443
444 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), NULL);
445 g_return_val_if_fail (priv->db != NULL, NULL);
446
447 g_debug ("CdMappingDb: get devices for %s", profile_id);
448 statement = sqlite3_mprintf ("SELECT device FROM mappings_v2 WHERE "
449 "profile = '%q' AND timestamp > 0 "
450 "ORDER BY timestamp ASC;", profile_id);
451
452 /* remove the entry */
453 array_tmp = g_ptr_array_new_with_free_func (g_free);
454 rc = sqlite3_exec (priv->db,
455 statement,
456 cd_mapping_db_sqlite_cb,
457 array_tmp,
458 NULL);
459 if (rc != SQLITE_OK) {
460 g_set_error (error,
461 CD_CLIENT_ERROR,
462 CD_CLIENT_ERROR_INTERNAL,
463 "SQL error: %s",
464 sqlite3_errmsg(priv->db));
465 goto out;
466 }
467
468 /* success */
469 array = g_ptr_array_ref (array_tmp);
470 out:
471 sqlite3_free (statement);
472 return array;
473 }
474
475 static gint
476 cd_mapping_db_sqlite_timestamp_cb (void *data,
477 gint argc,
478 gchar **argv,
479 gchar **col_name)
480 {
481 guint64 *timestamp = (guint64 *) data;
482
483 /* should only be one entry */
484 g_debug ("CdMappingDb: got sql entry %s", argv[0]);
485 *timestamp = g_ascii_strtoull (argv[0], NULL, 10);
486 return 0;
487 }
488
489 /**
490 * cd_mapping_db_get_timestamp:
491 *
492 * Gets when the profile was added to the device.
493 *
494 * Return value: %G_MAXUINT64 for error or not found
495 **/
496 guint64
497 cd_mapping_db_get_timestamp (CdMappingDb *mdb,
498 const gchar *device_id,
499 const gchar *profile_id,
500 GError **error)
501 {
502 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
503 gchar *statement;
504 gint rc;
505 guint64 timestamp = G_MAXUINT64;
506
507 g_return_val_if_fail (CD_IS_MAPPING_DB (mdb), G_MAXUINT64);
508 g_return_val_if_fail (priv->db != NULL, G_MAXUINT64);
509
510 g_debug ("CdMappingDb: get checksum for %s<->%s",
511 device_id, profile_id);
512 statement = sqlite3_mprintf ("SELECT timestamp FROM mappings_v2 WHERE "
513 "device = '%q' AND profile = '%q' "
514 "LIMIT 1;", device_id, profile_id);
515
516 /* query the checksum */
517 rc = sqlite3_exec (priv->db,
518 statement,
519 cd_mapping_db_sqlite_timestamp_cb,
520 &timestamp,
521 NULL);
522 if (rc != SQLITE_OK) {
523 g_set_error (error,
524 CD_CLIENT_ERROR,
525 CD_CLIENT_ERROR_INTERNAL,
526 "SQL error: %s",
527 sqlite3_errmsg(priv->db));
528 goto out;
529 }
530
531 /* nothing found */
532 if (timestamp == G_MAXUINT64) {
533 g_set_error (error,
534 CD_CLIENT_ERROR,
535 CD_CLIENT_ERROR_INTERNAL,
536 "device and profile %s<>%s not found",
537 device_id, profile_id);
538 goto out;
539 }
540 out:
541 sqlite3_free (statement);
542 return timestamp;
543 }
544
545 static void
546 cd_mapping_db_class_init (CdMappingDbClass *klass)
547 {
548 GObjectClass *object_class = G_OBJECT_CLASS (klass);
549 object_class->finalize = cd_mapping_db_finalize;
550 }
551
552 static void
553 cd_mapping_db_init (CdMappingDb *mdb)
554 {
555 }
556
557 static void
558 cd_mapping_db_finalize (GObject *object)
559 {
560 CdMappingDb *mdb = CD_MAPPING_DB (object);
561 CdMappingDbPrivate *priv = GET_PRIVATE (mdb);
562
563 /* close the database */
564 sqlite3_close (priv->db);
565
566 G_OBJECT_CLASS (cd_mapping_db_parent_class)->finalize (object);
567 }
568
569 CdMappingDb *
570 cd_mapping_db_new (void)
571 {
572 if (cd_mapping_db_object != NULL) {
573 g_object_ref (cd_mapping_db_object);
574 } else {
575 cd_mapping_db_object = g_object_new (CD_TYPE_MAPPING_DB, NULL);
576 g_object_add_weak_pointer (cd_mapping_db_object, &cd_mapping_db_object);
577 }
578 return CD_MAPPING_DB (cd_mapping_db_object);
579 }
580