discover: Recognise and open LUKS encrypted partitions
[petitboot] / discover / device-handler.c
1 #include <assert.h>
2 #include <inttypes.h>
3 #include <stdlib.h>
4 #include <stdbool.h>
5 #include <unistd.h>
6 #include <string.h>
7 #include <errno.h>
8 #include <mntent.h>
9 #include <locale.h>
10 #include <sys/stat.h>
11 #include <sys/wait.h>
12 #include <sys/mount.h>
13
14 #include <talloc/talloc.h>
15 #include <list/list.h>
16 #include <log/log.h>
17 #include <types/types.h>
18 #include <system/system.h>
19 #include <process/process.h>
20 #include <url/url.h>
21 #include <i18n/i18n.h>
22 #include <pb-config/pb-config.h>
23
24 #include <sys/sysmacros.h>
25 #include <sys/types.h>
26 #include <sys/socket.h>
27 #include <netdb.h>
28 #include <arpa/inet.h>
29
30 #include "device-handler.h"
31 #include "discover-server.h"
32 #include "devmapper.h"
33 #include "user-event.h"
34 #include "platform.h"
35 #include "event.h"
36 #include "parser.h"
37 #include "resource.h"
38 #include "paths.h"
39 #include "sysinfo.h"
40 #include "boot.h"
41 #include "udev.h"
42 #include "network.h"
43 #include "ipmi.h"
44
45 enum default_priority {
46         DEFAULT_PRIORITY_TEMP_USER      = 1,
47         DEFAULT_PRIORITY_REMOTE         = 2,
48         DEFAULT_PRIORITY_LOCAL_FIRST    = 3,
49         DEFAULT_PRIORITY_LOCAL_LAST     = 0xfe,
50         DEFAULT_PRIORITY_DISABLED       = 0xff,
51 };
52
53 static int default_rescan_timeout = 5 * 60; /* seconds */
54
55 struct progress_info {
56         unsigned int                    percentage;
57         unsigned long                   size;           /* size in bytes */
58
59         const struct process_info       *procinfo;
60         struct list_item        list;
61 };
62
63 struct crypt_info {
64         struct discover_device  *source_device;
65         char                    *dm_name;
66
67         struct list_item        list;
68 };
69
70 struct device_handler {
71         struct discover_server  *server;
72         int                     dry_run;
73
74         struct pb_udev          *udev;
75         struct network          *network;
76         struct user_event       *user_event;
77
78         struct discover_device  **devices;
79         unsigned int            n_devices;
80
81         struct ramdisk_device   **ramdisks;
82         unsigned int            n_ramdisks;
83
84         struct waitset          *waitset;
85         struct waiter           *timeout_waiter;
86         bool                    autoboot_enabled;
87         unsigned int            sec_to_boot;
88         struct autoboot_option  *temp_autoboot;
89
90         struct discover_boot_option *default_boot_option;
91         struct discover_boot_option *last_boot_option;
92         int                     default_boot_option_priority;
93
94         struct list             unresolved_boot_options;
95
96         struct boot_task        *pending_boot;
97         bool                    pending_boot_is_default;
98
99         struct list             progress;
100         unsigned int            n_progress;
101
102         struct plugin_option    **plugins;
103         unsigned int            n_plugins;
104         bool                    plugin_installing;
105
106         struct list             crypt_devices;
107 };
108
109 static int mount_device(struct discover_device *dev);
110 static int umount_device(struct discover_device *dev);
111
112 static int device_handler_init_sources(struct device_handler *handler);
113 static void device_handler_reinit_sources(struct device_handler *handler);
114
115 static void device_handler_update_lang(const char *lang);
116
117 void discover_context_add_boot_option(struct discover_context *ctx,
118                 struct discover_boot_option *boot_option)
119 {
120         boot_option->source = ctx->parser;
121         list_add_tail(&ctx->boot_options, &boot_option->list);
122         talloc_steal(ctx, boot_option);
123 }
124
125 /**
126  * device_handler_get_device_count - Get the count of current handler devices.
127  */
128
129 int device_handler_get_device_count(const struct device_handler *handler)
130 {
131         return handler->n_devices;
132 }
133
134 /**
135  * device_handler_get_device - Get a handler device by index.
136  */
137
138 const struct discover_device *device_handler_get_device(
139         const struct device_handler *handler, unsigned int index)
140 {
141         if (index >= handler->n_devices) {
142                 assert(0 && "bad index");
143                 return NULL;
144         }
145
146         return handler->devices[index];
147 }
148
149 /**
150  * device_handler_get_plugin_count - Get the count of current handler plugins.
151  */
152 int device_handler_get_plugin_count(const struct device_handler *handler)
153 {
154         return handler->n_plugins;
155 }
156
157 /**
158  * discover_handler_get_plugin - Get a handler plugin by index.
159  */
160 const struct plugin_option *device_handler_get_plugin(
161         const struct device_handler *handler, unsigned int index)
162 {
163         if (index >= handler->n_plugins) {
164                 assert(0 && "bad index");
165                 return NULL;
166         }
167
168         return handler->plugins[index];
169 }
170
171 struct network *device_handler_get_network(
172                 const struct device_handler *handler)
173 {
174         return handler->network;
175 }
176
177 struct discover_boot_option *discover_boot_option_create(
178                 struct discover_context *ctx,
179                 struct discover_device *device)
180 {
181         struct discover_boot_option *opt;
182
183         opt = talloc_zero(ctx, struct discover_boot_option);
184         opt->option = talloc_zero(opt, struct boot_option);
185         opt->device = device;
186
187         return opt;
188 }
189
190 static int device_match_uuid(struct discover_device *dev, const char *uuid)
191 {
192         return dev->uuid && !strcmp(dev->uuid, uuid);
193 }
194
195 static int device_match_label(struct discover_device *dev, const char *label)
196 {
197         return dev->label && !strcmp(dev->label, label);
198 }
199
200 static int device_match_id(struct discover_device *dev, const char *id)
201 {
202         return !strcmp(dev->device->id, id);
203 }
204
205 static int device_match_serial(struct discover_device *dev, const char *serial)
206 {
207         const char *val = discover_device_get_param(dev, "ID_SERIAL");
208         return val && !strcmp(val, serial);
209 }
210
211 static struct discover_device *device_lookup(
212                 struct device_handler *device_handler,
213                 int (match_fn)(struct discover_device *, const char *),
214                 const char *str)
215 {
216         struct discover_device *dev;
217         unsigned int i;
218
219         if (!str)
220                 return NULL;
221
222         for (i = 0; i < device_handler->n_devices; i++) {
223                 dev = device_handler->devices[i];
224
225                 if (match_fn(dev, str))
226                         return dev;
227         }
228
229         return NULL;
230 }
231
232 struct discover_device *device_lookup_by_name(struct device_handler *handler,
233                 const char *name)
234 {
235         if (!strncmp(name, "/dev/", strlen("/dev/")))
236                 name += strlen("/dev/");
237
238         return device_lookup_by_id(handler, name);
239 }
240
241 struct discover_device *device_lookup_by_uuid(
242                 struct device_handler *device_handler,
243                 const char *uuid)
244 {
245         return device_lookup(device_handler, device_match_uuid, uuid);
246 }
247
248 struct discover_device *device_lookup_by_label(
249                 struct device_handler *device_handler,
250                 const char *label)
251 {
252         return device_lookup(device_handler, device_match_label, label);
253 }
254
255 struct discover_device *device_lookup_by_id(
256                 struct device_handler *device_handler,
257                 const char *id)
258 {
259         return device_lookup(device_handler, device_match_id, id);
260 }
261
262 struct discover_device *device_lookup_by_serial(
263                 struct device_handler *device_handler,
264                 const char *serial)
265 {
266         return device_lookup(device_handler, device_match_serial, serial);
267 }
268
269 void device_handler_destroy(struct device_handler *handler)
270 {
271         talloc_free(handler);
272 }
273
274 static int destroy_device(void *arg)
275 {
276         struct discover_device *dev = arg;
277         struct process *p;
278
279         umount_device(dev);
280
281         devmapper_destroy_snapshot(dev);
282
283         if (dev->crypt_device) {
284                 const char *argv[] = {
285                         pb_system_apps.cryptsetup,
286                         "luksClose",
287                         dev->device->id,
288                         NULL
289                 };
290
291                 p = process_create(dev);
292                 p->path = pb_system_apps.cryptsetup;
293                 p->argv = argv;
294
295                 if (process_run_async(p)) {
296                         pb_log("Failed to run cryptsetup\n");
297                         return -1;
298                 }
299         }
300
301         return 0;
302 }
303
304 struct discover_device *discover_device_create(struct device_handler *handler,
305                 const char *uuid, const char *id)
306 {
307         struct discover_device *dev;
308
309         if (uuid)
310                 dev = device_lookup_by_uuid(handler, uuid);
311         else
312                 dev = device_lookup_by_id(handler, id);
313
314         if (dev)
315                 return dev;
316
317         dev = talloc_zero(handler, struct discover_device);
318         dev->device = talloc_zero(dev, struct device);
319         dev->device->id = talloc_strdup(dev->device, id);
320         dev->uuid = talloc_strdup(dev, uuid);
321         list_init(&dev->params);
322         list_init(&dev->boot_options);
323
324         talloc_set_destructor(dev, destroy_device);
325
326         return dev;
327 }
328
329 struct discover_device_param {
330         char                    *name;
331         char                    *value;
332         struct list_item        list;
333 };
334
335 void discover_device_set_param(struct discover_device *device,
336                 const char *name, const char *value)
337 {
338         struct discover_device_param *param;
339         bool found = false;
340
341         list_for_each_entry(&device->params, param, list) {
342                 if (!strcmp(param->name, name)) {
343                         found = true;
344                         break;
345                 }
346         }
347
348         if (!found) {
349                 if (!value)
350                         return;
351                 param = talloc(device, struct discover_device_param);
352                 param->name = talloc_strdup(param, name);
353                 list_add(&device->params, &param->list);
354         } else {
355                 if (!value) {
356                         list_remove(&param->list);
357                         talloc_free(param);
358                         return;
359                 }
360                 talloc_free(param->value);
361         }
362
363         param->value = talloc_strdup(param, value);
364 }
365
366 const char *discover_device_get_param(struct discover_device *device,
367                 const char *name)
368 {
369         struct discover_device_param *param;
370
371         list_for_each_entry(&device->params, param, list) {
372                 if (!strcmp(param->name, name))
373                         return param->value;
374         }
375         return NULL;
376 }
377
378 static void set_env_variables(const struct config *config)
379 {
380         if (config->http_proxy)
381                 setenv("http_proxy", config->http_proxy, 1);
382         else
383                 unsetenv("http_proxy");
384
385         if (config->https_proxy)
386                 setenv("https_proxy", config->https_proxy, 1);
387         else
388                 unsetenv("https_proxy");
389
390         /* Reduce noise in the log from LVM listing open file descriptors */
391         setenv("LVM_SUPPRESS_FD_WARNINGS", "1", 1);
392 }
393
394 struct device_handler *device_handler_init(struct discover_server *server,
395                 struct waitset *waitset, int dry_run)
396 {
397         struct device_handler *handler;
398         int rc;
399
400         handler = talloc_zero(NULL, struct device_handler);
401         handler->server = server;
402         handler->waitset = waitset;
403         handler->dry_run = dry_run;
404         handler->autoboot_enabled = config_autoboot_active(config_get());
405
406         list_init(&handler->unresolved_boot_options);
407
408         list_init(&handler->progress);
409         list_init(&handler->crypt_devices);
410
411         /* set up our mount point base */
412         pb_mkdir_recursive(mount_base());
413
414         parser_init();
415
416         if (config_get()->safe_mode)
417                 return handler;
418
419         set_env_variables(config_get());
420
421         rc = device_handler_init_sources(handler);
422         if (rc) {
423                 talloc_free(handler);
424                 return NULL;
425         }
426
427         return handler;
428 }
429
430 void device_handler_reinit(struct device_handler *handler)
431 {
432         struct discover_boot_option *opt, *tmp;
433         struct crypt_info *crypt, *c;
434         struct ramdisk_device *ramdisk;
435         struct config *config;
436         unsigned int i;
437
438         device_handler_cancel_default(handler);
439         /* Cancel any pending non-default boot */
440         if (handler->pending_boot) {
441                 boot_cancel(handler->pending_boot);
442                 handler->pending_boot = NULL;
443                 handler->pending_boot_is_default = false;
444         }
445
446         /* Cancel any remaining async jobs */
447         process_stop_async_all();
448         pending_network_jobs_cancel();
449
450         /* free unresolved boot options */
451         list_for_each_entry_safe(&handler->unresolved_boot_options,
452                         opt, tmp, list)
453                 talloc_free(opt);
454         list_init(&handler->unresolved_boot_options);
455
456         /* drop all devices */
457         for (i = 0; i < handler->n_devices; i++) {
458                 struct discover_device *device = handler->devices[i];
459                 discover_server_notify_device_remove(handler->server,
460                                 device->device);
461                 ramdisk = device->ramdisk;
462                 if (device->requery_waiter)
463                         waiter_remove(device->requery_waiter);
464                 talloc_free(device);
465                 talloc_free(ramdisk);
466         }
467
468         talloc_free(handler->devices);
469         handler->devices = NULL;
470         handler->n_devices = 0;
471         talloc_free(handler->ramdisks);
472         handler->ramdisks = NULL;
473         handler->n_ramdisks = 0;
474
475         /* drop any known plugins */
476         for (i = 0; i < handler->n_plugins; i++)
477                 talloc_free(handler->plugins[i]);
478         talloc_free(handler->plugins);
479         handler->plugins = NULL;
480         handler->n_plugins = 0;
481
482         discover_server_notify_plugins_remove(handler->server);
483
484         /* forget encrypted devices */
485         list_for_each_entry_safe(&handler->crypt_devices, crypt, c, list)
486                 talloc_free(crypt);
487         list_init(&handler->crypt_devices);
488
489         set_env_variables(config_get());
490
491         /* If the safe mode warning was active disable it now */
492         if (config_get()->safe_mode) {
493                 config = config_copy(handler, config_get());
494                 config->safe_mode = false;
495                 config_set(config);
496                 discover_server_notify_config(handler->server, config);
497         }
498
499         /* Force rediscovery on SCSI devices */
500         process_run_simple(handler, pb_system_apps.scsi_rescan, NULL);
501
502         device_handler_reinit_sources(handler);
503 }
504
505 void device_handler_remove(struct device_handler *handler,
506                 struct discover_device *device)
507 {
508         struct discover_boot_option *opt, *tmp;
509         unsigned int i;
510
511         if (device->requery_waiter)
512                 waiter_remove(device->requery_waiter);
513
514         list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
515                 if (opt == handler->default_boot_option) {
516                         pb_log("Default option %s cancelled since device removed",
517                                         opt->option->name);
518                         device_handler_cancel_default(handler);
519                         break;
520                 }
521         }
522
523         for (i = 0; i < handler->n_devices; i++)
524                 if (handler->devices[i] == device)
525                         break;
526
527         if (i == handler->n_devices) {
528                 talloc_free(device);
529                 return;
530         }
531
532         /* Free any unresolved options, as they're currently allocated
533          * against the handler */
534         list_for_each_entry_safe(&handler->unresolved_boot_options,
535                         opt, tmp, list) {
536                 if (opt->device != device)
537                         continue;
538                 list_remove(&opt->list);
539                 talloc_free(opt);
540         }
541
542         /* if this is a network device, we have to unregister it from the
543          * network code */
544         if (device->device->type == DEVICE_TYPE_NETWORK)
545                 network_unregister_device(handler->network, device);
546
547         handler->n_devices--;
548         memmove(&handler->devices[i], &handler->devices[i + 1],
549                 (handler->n_devices - i) * sizeof(handler->devices[0]));
550         handler->devices = talloc_realloc(handler, handler->devices,
551                 struct discover_device *, handler->n_devices);
552
553         if (device->notified)
554                 discover_server_notify_device_remove(handler->server,
555                                                         device->device);
556
557         talloc_free(device);
558 }
559
560 void device_handler_status(struct device_handler *handler,
561                 struct status *status)
562 {
563         pb_debug("%s: %s\n", __func__, status->message);
564         discover_server_notify_boot_status(handler->server, status);
565 }
566
567 static void _device_handler_vstatus(struct device_handler *handler,
568                 enum status_type type, const char *fmt, va_list ap)
569 {
570         struct status status;
571
572         status.type = type;
573         status.message = talloc_vasprintf(handler, fmt, ap);
574         status.backlog = false;
575         status.boot_active = false;
576
577         device_handler_status(handler, &status);
578
579         talloc_free(status.message);
580 }
581
582 static void _device_handler_vdevstatus(struct device_handler *handler,
583                 struct discover_device *device, enum status_type type,
584                 const char *fmt, va_list ap)
585 {
586         char *msg;
587
588         msg = talloc_asprintf(handler, "[%s] %s",
589                         device ? device->device->id : "unknown", fmt);
590         _device_handler_vstatus(handler, type, msg, ap);
591         talloc_free(msg);
592 }
593
594 void device_handler_status_dev_info(struct device_handler *handler,
595                 struct discover_device *dev, const char *fmt, ...)
596 {
597         va_list ap;
598
599         va_start(ap, fmt);
600         _device_handler_vdevstatus(handler, dev, STATUS_INFO, fmt, ap);
601         va_end(ap);
602 }
603
604 void device_handler_status_dev_err(struct device_handler *handler,
605                 struct discover_device *dev, const char *fmt, ...)
606 {
607         va_list ap;
608
609         va_start(ap, fmt);
610         _device_handler_vdevstatus(handler, dev, STATUS_ERROR, fmt, ap);
611         va_end(ap);
612 }
613
614 void device_handler_status_info(struct device_handler *handler,
615                 const char *fmt, ...)
616 {
617         va_list ap;
618
619         va_start(ap, fmt);
620         _device_handler_vstatus(handler, STATUS_INFO, fmt, ap);
621         va_end(ap);
622 }
623
624 void device_handler_status_err(struct device_handler *handler,
625                 const char *fmt, ...)
626 {
627         va_list ap;
628
629         va_start(ap, fmt);
630         _device_handler_vstatus(handler, STATUS_ERROR, fmt, ap);
631         va_end(ap);
632 }
633
634 void device_handler_status_download(struct device_handler *handler,
635                 const struct process_info *procinfo,
636                 unsigned int percentage, unsigned int size, char suffix)
637 {
638         struct progress_info *p, *progress = NULL;
639         uint64_t current_converted, current = 0;
640         const char *units = " kMGTP";
641         unsigned long size_bytes;
642         char *update = NULL;
643         double total = 0;
644         unsigned int i;
645         int unit = 0;
646
647         list_for_each_entry(&handler->progress, p, list)
648                 if (p->procinfo == procinfo)
649                         progress = p;
650
651         if (!progress) {
652                 pb_log("Registering new progress struct\n");
653                 progress = talloc_zero(handler, struct progress_info);
654                 if (!progress) {
655                         pb_log("Failed to allocate room for progress struct\n");
656                         return;
657                 }
658                 progress->procinfo = procinfo;
659                 list_add(&handler->progress, &progress->list);
660                 handler->n_progress++;
661         }
662
663         size_bytes = size;
664         for (i = 0; i < strlen(units); i++) {
665                 if (units[i] == suffix)
666                         break;
667         }
668
669         if (i >= strlen(units)) {
670             pb_log("Couldn't recognise suffix '%c'\n", suffix);
671             size_bytes = 0;
672         } else {
673                 while (i--)
674                         size_bytes <<= 10;
675         }
676
677         progress->percentage = percentage;
678         progress->size = size_bytes;
679
680         /*
681          * Aggregate the info we have and update status. If a progress struct
682          * has zero for both percentage and size we assume progress information
683          * is unavailable and fall back to a generic progress message.
684          */
685         list_for_each_entry(&handler->progress, p, list) {
686                 uint64_t c;
687                 double t;
688                 if (!p->percentage || !p->size) {
689                         update = talloc_asprintf(handler,
690                                         _("%u downloads in progress..."),
691                                         handler->n_progress);
692                         current = total = 0;
693                         break;
694                 }
695
696                 c = p->size;
697                 t = (100 * c) / p->percentage;
698
699                 current += c;
700                 total += t;
701         }
702
703         if (total) {
704                 current_converted = current;
705                 while (current_converted >= 1000) {
706                         current_converted >>= 10;
707                         unit++;
708                 }
709                 update = talloc_asprintf(handler,
710                                 _("%u %s downloading: %.0f%% - %" PRIu64 "%cB"),
711                                 handler->n_progress,
712                                 ngettext("item", "items", handler->n_progress),
713                                 (current / total) * 100, current_converted,
714                                 units[unit]);
715         }
716
717         if (!update) {
718                 pb_log_fn("failed to allocate new status\n");
719         } else {
720                 device_handler_status_info(handler, "%s\n", update);
721                 talloc_free(update);
722         }
723 }
724
725 static void device_handler_plugin_scan_device(struct device_handler *handler,
726                 struct discover_device *dev)
727 {
728         int rc;
729
730         pb_debug("Scanning %s for plugin files\n", dev->device->id);
731
732         rc = process_run_simple(handler, pb_system_apps.pb_plugin,
733                                 "scan", dev->mount_path,
734                                 NULL);
735         if (rc)
736                 pb_log("Error from pb-plugin scan %s\n",
737                                 dev->mount_path);
738 }
739
740 void device_handler_status_download_remove(struct device_handler *handler,
741                 struct process_info *procinfo)
742 {
743         struct progress_info *p, *tmp;
744
745         list_for_each_entry_safe(&handler->progress, p, tmp, list)
746                 if (p->procinfo == procinfo) {
747                         list_remove(&p->list);
748                         talloc_free(p);
749                         handler->n_progress--;
750                 }
751 }
752
753 static void device_handler_boot_status_cb(void *arg, struct status *status)
754 {
755         struct device_handler *handler = arg;
756
757         /* boot had failed; update handler state to allow a new default if one
758          * is found later
759          */
760         if (status->type == STATUS_ERROR) {
761                 handler->pending_boot = NULL;
762                 handler->default_boot_option = NULL;
763         }
764
765         device_handler_status(handler, status);
766 }
767
768 static void countdown_status(struct device_handler *handler,
769                 struct discover_boot_option *opt, unsigned int sec)
770 {
771         struct status status;
772
773         status.type = STATUS_INFO;
774         status.message = talloc_asprintf(handler,
775                         _("Booting in %d sec: [%s] %s"), sec,
776                         opt->device->device->id, opt->option->name);
777         status.backlog = false;
778
779         device_handler_status(handler, &status);
780
781         talloc_free(status.message);
782 }
783
784 static int default_timeout(void *arg)
785 {
786         struct device_handler *handler = arg;
787         struct discover_boot_option *opt;
788
789         if (!handler->default_boot_option)
790                 return 0;
791
792         if (handler->pending_boot)
793                 return 0;
794
795         opt = handler->default_boot_option;
796
797         handler->last_boot_option = opt;
798
799         if (handler->sec_to_boot) {
800                 countdown_status(handler, opt, handler->sec_to_boot);
801                 handler->sec_to_boot--;
802                 handler->timeout_waiter = waiter_register_timeout(
803                                                 handler->waitset, 1000,
804                                                 default_timeout, handler);
805                 return 0;
806         }
807
808         handler->timeout_waiter = NULL;
809
810         pb_log("Timeout expired, booting default option %s\n", opt->option->id);
811
812         platform_pre_boot();
813
814         handler->pending_boot = boot(handler, handler->default_boot_option,
815                         NULL, handler->dry_run, device_handler_boot_status_cb,
816                         handler);
817         handler->pending_boot_is_default = true;
818         return 0;
819 }
820
821 struct {
822         enum ipmi_bootdev       ipmi_type;
823         enum device_type        device_type;
824 } device_type_map[] = {
825         { IPMI_BOOTDEV_NETWORK, DEVICE_TYPE_NETWORK },
826         { IPMI_BOOTDEV_DISK, DEVICE_TYPE_DISK },
827         { IPMI_BOOTDEV_DISK, DEVICE_TYPE_USB },
828         { IPMI_BOOTDEV_CDROM, DEVICE_TYPE_OPTICAL },
829 };
830
831 static bool ipmi_device_type_matches(enum ipmi_bootdev ipmi_type,
832                 enum device_type device_type)
833 {
834         unsigned int i;
835
836         for (i = 0; i < ARRAY_SIZE(device_type_map); i++) {
837                 if (device_type_map[i].device_type == device_type)
838                         return device_type_map[i].ipmi_type == ipmi_type;
839         }
840
841         return false;
842 }
843
844 static bool autoboot_option_matches(struct autoboot_option *opt,
845                 struct discover_device *dev)
846 {
847         if (opt->boot_type == BOOT_DEVICE_UUID)
848                 if (!strcmp(opt->uuid, dev->uuid))
849                         return true;
850
851         if (opt->boot_type == BOOT_DEVICE_TYPE)
852                 if (opt->type == dev->device->type ||
853                     opt->type == DEVICE_TYPE_ANY)
854                         return true;
855
856         return false;
857 }
858
859 static int autoboot_option_priority(const struct config *config,
860                                 struct discover_boot_option *opt)
861 {
862         struct autoboot_option *auto_opt;
863         unsigned int i;
864
865         for (i = 0; i < config->n_autoboot_opts; i++) {
866                 auto_opt = &config->autoboot_opts[i];
867                 if (autoboot_option_matches(auto_opt, opt->device))
868                         return DEFAULT_PRIORITY_LOCAL_FIRST + i;
869         }
870
871         return -1;
872 }
873
874 /*
875  * We have different priorities to resolve conflicts between boot options that
876  * report to be the default for their device. This function assigns a priority
877  * for these options.
878  */
879 static enum default_priority default_option_priority(
880                 struct device_handler *handler,
881                 struct discover_boot_option *opt)
882 {
883         const struct config *config;
884
885         /* Temporary user-provided autoboot options have highest priority */
886         if (handler->temp_autoboot) {
887                 if (autoboot_option_matches(handler->temp_autoboot,
888                                         opt->device))
889                         return DEFAULT_PRIORITY_TEMP_USER;
890
891                 pb_debug("handler: disabled default priority due to "
892                                 "temporary user override\n");
893                 return DEFAULT_PRIORITY_DISABLED;
894         }
895
896         config = config_get();
897
898         /* Next highest priority to IPMI-configured boot options. If we have an
899          * IPMI bootdev configuration set, then we don't allow any other
900          * defaults */
901         if (config->ipmi_bootdev) {
902                 bool ipmi_match = ipmi_device_type_matches(config->ipmi_bootdev,
903                                 opt->device->device->type);
904                 if (ipmi_match)
905                         return DEFAULT_PRIORITY_REMOTE;
906
907                 pb_debug("handler: disabled default priority due to "
908                                 "non-matching IPMI type %x\n",
909                                 config->ipmi_bootdev);
910                 return DEFAULT_PRIORITY_DISABLED;
911         }
912
913         /* Next, try to match the option against the user-defined autoboot
914          * options, either by device UUID or type. */
915         if (config->n_autoboot_opts) {
916                 int boot_match = autoboot_option_priority(config, opt);
917                 if (boot_match > 0)
918                         return boot_match;
919         } else {
920                 /* If there is no specific boot order, boot any device */
921                 return DEFAULT_PRIORITY_LOCAL_FIRST;
922         }
923
924         /* If the option didn't match any entry in the array, it is disabled */
925         pb_debug("handler: disabled default priority due to "
926                         "non-matching UUID or type\n");
927         return DEFAULT_PRIORITY_DISABLED;
928 }
929
930 static void set_default(struct device_handler *handler,
931                 struct discover_boot_option *opt)
932 {
933         enum default_priority cur_prio, new_prio;
934
935         if (!handler->autoboot_enabled)
936                 return;
937
938         pb_debug("handler: new default option: %s\n", opt->option->id);
939
940         new_prio = default_option_priority(handler, opt);
941
942         /* Anything outside our range prevents a default boot */
943         if (new_prio >= DEFAULT_PRIORITY_DISABLED)
944                 return;
945
946         pb_debug("handler: calculated priority %d\n", new_prio);
947
948         /* Resolve any conflicts: if we have a new default option, it only
949          * replaces the current if it has a higher priority. */
950         if (handler->default_boot_option) {
951
952                 cur_prio = handler->default_boot_option_priority;
953
954                 if (new_prio < cur_prio) {
955                         pb_log("handler: new prio %d beats "
956                                         "old prio %d for %s\n",
957                                         new_prio, cur_prio,
958                                         handler->default_boot_option
959                                                 ->option->id);
960                         handler->default_boot_option = opt;
961                         handler->default_boot_option_priority = new_prio;
962                         /* extend the timeout a little, so the user sees some
963                          * indication of the change */
964                         handler->sec_to_boot += 2;
965                 }
966
967                 return;
968         }
969
970         if (handler->default_boot_option)
971                 handler->default_boot_option->option->is_autoboot_default = false;
972         opt->option->is_autoboot_default = true;
973
974         handler->sec_to_boot = config_get()->autoboot_timeout_sec;
975         handler->default_boot_option = opt;
976         handler->default_boot_option_priority = new_prio;
977
978         pb_log("handler: boot option %s set as default, timeout %u sec.\n",
979                opt->option->id, handler->sec_to_boot);
980
981         default_timeout(handler);
982 }
983
984 static char *autoboot_option_desc(void *ctx, const struct autoboot_option *opt)
985 {
986         const char *type, *val;
987
988         if (opt->boot_type == BOOT_DEVICE_TYPE) {
989                 type = _("device type");
990                 val = device_type_display_name(opt->type);
991         } else if (opt->boot_type == BOOT_DEVICE_UUID) {
992                 type = _("device UUID");
993                 val = opt->uuid;
994         } else {
995                 type = _("unknown specifier");
996                 val = NULL;
997         }
998
999         return talloc_asprintf(ctx, "%s = %s", type, val);
1000 }
1001
1002 void device_handler_apply_temp_autoboot(struct device_handler *handler,
1003                 struct autoboot_option *opt)
1004 {
1005         unsigned int i;
1006         char *desc;
1007
1008         handler->temp_autoboot = talloc_steal(handler, opt);
1009
1010         desc = autoboot_option_desc(handler, opt);
1011         device_handler_status_info(handler,
1012                         _("Applying temporary autoboot override: %s"),
1013                         desc);
1014         talloc_free(desc);
1015
1016         if (!handler->autoboot_enabled)
1017                 return;
1018
1019         if (!handler->default_boot_option)
1020                 return;
1021
1022         if (autoboot_option_matches(opt, handler->default_boot_option->device))
1023                 return;
1024
1025         /* cancel the default, and rescan available options */
1026         device_handler_cancel_default(handler);
1027
1028         handler->autoboot_enabled = true;
1029
1030         for (i = 0; i < handler->n_devices; i++) {
1031                 struct discover_device *dev = handler->devices[i];
1032                 struct discover_boot_option *boot_opt;
1033
1034                 if (!autoboot_option_matches(opt, dev))
1035                         continue;
1036
1037                 list_for_each_entry(&dev->boot_options, boot_opt, list) {
1038                         if (boot_opt->option->is_default) {
1039                                 set_default(handler, boot_opt);
1040                                 break;
1041                         }
1042                 }
1043         }
1044 }
1045
1046 static bool resource_is_resolved(struct resource *res)
1047 {
1048         return !res || res->resolved;
1049 }
1050
1051 /* We only use this in an assert, which will disappear if we're compiling
1052  * with NDEBUG, so we need the 'used' attribute for these builds */
1053 static bool __attribute__((used)) boot_option_is_resolved(
1054                 struct discover_boot_option *opt)
1055 {
1056         return resource_is_resolved(opt->boot_image) &&
1057                 resource_is_resolved(opt->initrd) &&
1058                 resource_is_resolved(opt->dtb) &&
1059                 resource_is_resolved(opt->args_sig_file) &&
1060                 resource_is_resolved(opt->icon);
1061 }
1062
1063 static bool resource_resolve(struct resource *res, const char *name,
1064                 struct discover_boot_option *opt,
1065                 struct device_handler *handler)
1066 {
1067         struct parser *parser = opt->source;
1068
1069         if (resource_is_resolved(res))
1070                 return true;
1071
1072         pb_debug("Attempting to resolve resource %s->%s with parser %s\n",
1073                         opt->option->id, name, parser->name);
1074         parser->resolve_resource(handler, res);
1075
1076         return res->resolved;
1077 }
1078
1079 static bool boot_option_resolve(struct discover_boot_option *opt,
1080                 struct device_handler *handler)
1081 {
1082         return resource_resolve(opt->boot_image, "boot_image", opt, handler) &&
1083                 resource_resolve(opt->initrd, "initrd", opt, handler) &&
1084                 resource_resolve(opt->dtb, "dtb", opt, handler) &&
1085                 resource_resolve(opt->args_sig_file, "args_sig_file", opt,
1086                         handler) &&
1087                 resource_resolve(opt->icon, "icon", opt, handler);
1088 }
1089
1090 static void boot_option_finalise(struct device_handler *handler,
1091                 struct discover_boot_option *opt)
1092 {
1093         assert(boot_option_is_resolved(opt));
1094
1095         /* check that the parsers haven't set any of the final data */
1096         assert(!opt->option->boot_image_file);
1097         assert(!opt->option->initrd_file);
1098         assert(!opt->option->dtb_file);
1099         assert(!opt->option->icon_file);
1100         assert(!opt->option->device_id);
1101         assert(!opt->option->args_sig_file);
1102
1103         if (opt->boot_image)
1104                 opt->option->boot_image_file = opt->boot_image->url->full;
1105         if (opt->initrd)
1106                 opt->option->initrd_file = opt->initrd->url->full;
1107         if (opt->dtb)
1108                 opt->option->dtb_file = opt->dtb->url->full;
1109         if (opt->icon)
1110                 opt->option->icon_file = opt->icon->url->full;
1111         if (opt->args_sig_file)
1112                 opt->option->args_sig_file = opt->args_sig_file->url->full;
1113
1114         opt->option->device_id = opt->device->device->id;
1115
1116         if (opt->option->is_default)
1117                 set_default(handler, opt);
1118 }
1119
1120 static void notify_boot_option(struct device_handler *handler,
1121                 struct discover_boot_option *opt)
1122 {
1123         struct discover_device *dev = opt->device;
1124
1125         if (!dev->notified)
1126                 discover_server_notify_device_add(handler->server,
1127                                                   opt->device->device);
1128         dev->notified = true;
1129         discover_server_notify_boot_option_add(handler->server, opt->option);
1130 }
1131
1132 static void process_boot_option_queue(struct device_handler *handler)
1133 {
1134         struct discover_boot_option *opt, *tmp;
1135
1136         list_for_each_entry_safe(&handler->unresolved_boot_options,
1137                         opt, tmp, list) {
1138
1139                 pb_debug("queue: attempting resolution for %s\n",
1140                                 opt->option->id);
1141
1142                 if (!boot_option_resolve(opt, handler))
1143                         continue;
1144
1145                 pb_debug("\tresolved!\n");
1146
1147                 list_remove(&opt->list);
1148                 list_add_tail(&opt->device->boot_options, &opt->list);
1149                 talloc_steal(opt->device, opt);
1150                 boot_option_finalise(handler, opt);
1151                 notify_boot_option(handler, opt);
1152         }
1153 }
1154
1155 struct discover_context *device_handler_discover_context_create(
1156                 struct device_handler *handler,
1157                 struct discover_device *device)
1158 {
1159         struct discover_context *ctx;
1160
1161         ctx = talloc_zero(handler, struct discover_context);
1162         ctx->handler = handler;
1163         ctx->device = device;
1164         list_init(&ctx->boot_options);
1165
1166         return ctx;
1167 }
1168
1169 void device_handler_add_device(struct device_handler *handler,
1170                 struct discover_device *device)
1171 {
1172         handler->n_devices++;
1173         handler->devices = talloc_realloc(handler, handler->devices,
1174                                 struct discover_device *, handler->n_devices);
1175         handler->devices[handler->n_devices - 1] = device;
1176
1177         if (device->device->type == DEVICE_TYPE_NETWORK)
1178                 network_register_device(handler->network, device);
1179 }
1180
1181 void device_handler_add_ramdisk(struct device_handler *handler,
1182                 const char *path)
1183 {
1184         struct ramdisk_device *dev;
1185         unsigned int i;
1186
1187         if (!path)
1188                 return;
1189
1190         for (i = 0; i < handler->n_ramdisks; i++)
1191                 if (!strcmp(handler->ramdisks[i]->path, path))
1192                         return;
1193
1194         dev = talloc_zero(handler, struct ramdisk_device);
1195         if (!dev) {
1196                 pb_log("Failed to allocate memory to track %s\n", path);
1197                 return;
1198         }
1199
1200         dev->path = talloc_strdup(handler, path);
1201
1202         handler->ramdisks = talloc_realloc(handler, handler->ramdisks,
1203                                 struct ramdisk_device *,
1204                                 handler->n_ramdisks + 1);
1205         if (!handler->ramdisks) {
1206                 pb_log("Failed to reallocate memory"
1207                        "- ramdisk tracking inconsistent!\n");
1208                 return;
1209         }
1210
1211         handler->ramdisks[i] = dev;
1212         i = handler->n_ramdisks++;
1213 }
1214
1215 struct ramdisk_device *device_handler_get_ramdisk(
1216                 struct device_handler *handler)
1217 {
1218         unsigned int i;
1219         char *name;
1220         dev_t id;
1221
1222         /* Check if free ramdisk exists */
1223         for (i = 0; i < handler->n_ramdisks; i++)
1224                 if (!handler->ramdisks[i]->snapshot &&
1225                     !handler->ramdisks[i]->origin &&
1226                     !handler->ramdisks[i]->base)
1227                         return handler->ramdisks[i];
1228
1229         /* Otherwise create a new one */
1230         name = talloc_asprintf(handler, "/dev/ram%d",
1231                         handler->n_ramdisks);
1232         if (!name) {
1233                 pb_debug("Failed to allocate memory to name /dev/ram%d",
1234                         handler->n_ramdisks);
1235                 return NULL;
1236         }
1237
1238         id = makedev(1, handler->n_ramdisks);
1239         if (mknod(name, S_IFBLK, id)) {
1240                 if (errno == EEXIST) {
1241                         /* We haven't yet received updates for existing
1242                          * ramdisks - add and use this one */
1243                         pb_debug("Using untracked ramdisk %s\n", name);
1244                 } else {
1245                         pb_log("Failed to create new ramdisk %s: %s\n",
1246                                name, strerror(errno));
1247                         return NULL;
1248                 }
1249         }
1250         device_handler_add_ramdisk(handler, name);
1251         talloc_free(name);
1252
1253         return handler->ramdisks[i];
1254 }
1255
1256 void device_handler_release_ramdisk(struct discover_device *device)
1257 {
1258         struct ramdisk_device *ramdisk = device->ramdisk;
1259
1260         talloc_free(ramdisk->snapshot);
1261         talloc_free(ramdisk->origin);
1262         talloc_free(ramdisk->base);
1263
1264         ramdisk->snapshot = ramdisk->origin = ramdisk->base = NULL;
1265         ramdisk->sectors = 0;
1266
1267         device->ramdisk = NULL;
1268 }
1269
1270 /*
1271  * Check if a device name matches the name of an encrypted device that has been
1272  * opened. If it matches remove it from the list and remove the original crypt
1273  * discover device.
1274  */
1275 bool device_handler_found_crypt_device(struct device_handler *handler,
1276                 const char *name)
1277 {
1278         struct crypt_info *crypt, *c;
1279
1280         list_for_each_entry_safe(&handler->crypt_devices, crypt, c, list) {
1281                 if (!strncmp(crypt->dm_name, name, strlen(crypt->dm_name))) {
1282                         device_handler_remove(handler, crypt->source_device);
1283                         list_remove(&crypt->list);
1284                         talloc_free(crypt);
1285                         return true;
1286                 }
1287         }
1288
1289         return false;
1290 }
1291
1292 static void cryptsetup_cb(struct process *process)
1293 {
1294         struct device_handler *handler = process->data;
1295         struct crypt_info *crypt, *c;
1296
1297         if (process->exit_status == 0)
1298                 return;
1299         device_handler_status_err(handler,
1300                         _("Failed to open encrypted device %s"),
1301                         process->argv[2]);
1302
1303         /*
1304          * Failed to open the device; stop tracking it, but don't remove
1305          * the source device.
1306          */
1307         list_for_each_entry_safe(&handler->crypt_devices, crypt, c, list) {
1308                 if (!strncmp(crypt->dm_name, process->argv[3],
1309                                         strlen(crypt->dm_name))) {
1310                         list_remove(&crypt->list);
1311                         talloc_free(crypt);
1312                         break;
1313                 }
1314         }
1315 }
1316
1317 void device_handler_open_encrypted_dev(struct device_handler *handler,
1318                 char *password, char *device_id)
1319 {
1320         struct discover_device *dev;
1321         struct crypt_info *crypt;
1322         const char *device_path, **argv;
1323         struct process *p;
1324         char *name;
1325         int result;
1326
1327         dev = device_lookup_by_id(handler, device_id);
1328         if (!dev) {
1329                 pb_log_fn("Can't find device %s\n", device_id);
1330                 device_handler_status_err(handler,
1331                                 _("Encrypted device %s does not exist"),
1332                                 device_id);
1333                 return;
1334         }
1335
1336         device_path = dev->device_path;
1337         name = talloc_asprintf(handler, "luks_%s", device_id);
1338
1339         p = process_create(handler);
1340         /* talloc argv under the process so we can access it in cryptsetup_cb */
1341         argv = talloc_zero_array(p, const char *, 6);
1342         argv[0] = talloc_strdup(argv, pb_system_apps.cryptsetup);
1343         argv[1] = talloc_asprintf(argv, "luksOpen");
1344         argv[2] = talloc_strdup(argv, device_path);
1345         argv[3] = talloc_strdup(argv, name);
1346         argv[4] = talloc_asprintf(argv, "-");
1347         argv[5] = NULL;
1348
1349         p->path = pb_system_apps.cryptsetup;
1350         p->argv = (const char **)argv;
1351         p->exit_cb = cryptsetup_cb;
1352         p->data = handler;
1353         p->keep_stdout = true;
1354         p->pipe_stdin = talloc_asprintf(p, "%s\n", password);
1355
1356         result = process_run_async(p);
1357         if (result) {
1358                 pb_log("Failed to run cryptsetup\n");
1359                 return;
1360         }
1361
1362         crypt = talloc(handler, struct crypt_info);
1363         crypt->source_device = dev;
1364         crypt->dm_name = name;
1365         talloc_steal(crypt, name);
1366         list_add(&handler->crypt_devices, &crypt->list);
1367 }
1368
1369 void device_handler_add_encrypted_dev(struct device_handler *handler,
1370                 struct discover_device *dev)
1371 {
1372         system_info_register_blockdev(dev->device->id, dev->uuid, "");
1373         discover_server_notify_device_add(handler->server,
1374                                           dev->device);
1375         dev->notified = true;
1376         if (!device_lookup_by_uuid(handler, dev->uuid))
1377                 device_handler_add_device(handler, dev);
1378 }
1379
1380 /* Start discovery on a hotplugged device. The device will be in our devices
1381  * array, but has only just been initialised by the hotplug source.
1382  */
1383 int device_handler_discover(struct device_handler *handler,
1384                 struct discover_device *dev)
1385 {
1386         struct discover_context *ctx;
1387         int rc;
1388
1389         device_handler_status_dev_info(handler, dev,
1390                 /*
1391                  * TRANSLATORS: this string will be passed the type of the
1392                  * device (eg "disk" or "network"), which will be translated
1393                  * accordingly.
1394                  */
1395                 _("Processing new %s device"),
1396                 device_type_display_name(dev->device->type));
1397
1398         /* create our context */
1399         ctx = device_handler_discover_context_create(handler, dev);
1400
1401         rc = mount_device(dev);
1402         if (rc)
1403                 goto out;
1404
1405         /* add this device to our system info */
1406         system_info_register_blockdev(dev->device->id, dev->uuid,
1407                         dev->mount_path);
1408
1409         /* run the parsers. This will populate the ctx's boot_option list. */
1410         iterate_parsers(ctx);
1411
1412         /* add discovered stuff to the handler */
1413         device_handler_discover_context_commit(handler, ctx);
1414
1415         process_boot_option_queue(handler);
1416
1417         /* Check this device for pb-plugins */
1418         device_handler_plugin_scan_device(handler, dev);
1419 out:
1420         talloc_unlink(handler, ctx);
1421
1422         return 0;
1423 }
1424
1425 struct requery_data {
1426         struct device_handler   *handler;
1427         struct discover_device  *device;
1428 };
1429
1430 static int device_handler_requery_timeout_fn(void *data)
1431 {
1432         struct discover_boot_option *opt, *tmp;
1433         struct requery_data *rqd = data;
1434         struct device_handler *handler;
1435         struct discover_device *device;
1436         bool autoboot;
1437
1438         handler = rqd->handler;
1439         device = rqd->device;
1440
1441         talloc_free(rqd);
1442
1443         /* network_requery_device may re-add a timeout, so clear the device
1444          * waiter here, so we can potentially start a new one. */
1445         device->requery_waiter = NULL;
1446
1447         /* We keep the device around, but get rid of the parsed boot
1448          * options on that device. That involves delaring out the lists,
1449          * and potentially cancelling a default.
1450          */
1451         list_for_each_entry_safe(&handler->unresolved_boot_options,
1452                         opt, tmp, list) {
1453                 if (opt->device != device)
1454                         continue;
1455                 list_remove(&opt->list);
1456                 talloc_free(opt);
1457         }
1458
1459         /* Track whether autoboot was enabled, if we cancel a default option
1460          * it will be switched off.
1461          */
1462         autoboot = handler->autoboot_enabled;
1463
1464         list_for_each_entry_safe(&device->boot_options, opt, tmp, list) {
1465                 if (opt == handler->default_boot_option) {
1466                         pb_log("Default option %s cancelled since device is being requeried\n",
1467                                         opt->option->name);
1468                         device_handler_cancel_default(handler);
1469                 }
1470                 list_remove(&opt->list);
1471                 talloc_free(opt);
1472         }
1473
1474         handler->autoboot_enabled = autoboot;
1475
1476         discover_server_notify_device_remove(handler->server, device->device);
1477         device->notified = false;
1478
1479         network_requery_device(handler->network, device);
1480
1481         return 0;
1482 }
1483
1484 /* Schedule a requery in timeout (seconds).
1485  *
1486  * Special values of timeout:
1487  *   0: no requery
1488  *  -1: use default
1489  */
1490 void device_handler_start_requery_timeout( struct device_handler *handler,
1491                 struct discover_device *dev, int timeout)
1492 {
1493         struct requery_data *rqd;
1494
1495         if (dev->requery_waiter)
1496                 return;
1497
1498         if (timeout == -1)
1499                 timeout = default_rescan_timeout;
1500         else if (timeout == 0)
1501                 return;
1502
1503         rqd = talloc(dev, struct requery_data);
1504         rqd->handler = handler;
1505         rqd->device = dev;
1506
1507         pb_debug("starting requery timeout for device %s, in %d sec\n",
1508                         dev->device->id, timeout);
1509
1510         dev->requery_waiter = waiter_register_timeout(handler->waitset,
1511                         timeout * 1000, device_handler_requery_timeout_fn, rqd);
1512 }
1513
1514 static int event_requery_timeout(struct event *event)
1515 {
1516         int timeout = -1;
1517         unsigned long x;
1518         const char *str;
1519         char *endp;
1520
1521         if (!event)
1522                 return timeout;
1523
1524         str = event_get_param(event, "reboottime");
1525         if (!str)
1526                 return timeout;
1527
1528         x = strtoul(str, &endp, 0);
1529         if (endp != str)
1530                 timeout = x;
1531
1532         return timeout;
1533 }
1534
1535
1536 /* Incoming dhcp event */
1537 int device_handler_dhcp(struct device_handler *handler,
1538                 struct discover_device *dev, struct event *event)
1539 {
1540         struct discover_context *ctx;
1541         const char *ip;
1542
1543         if (event_get_param(event, "ipv6"))
1544                 ip = event_get_param(event, "ipv6");
1545         else
1546                 ip = event_get_param(event, "ip");
1547
1548         device_handler_status_dev_info(handler, dev,
1549                         _("Processing DHCP lease response (ip: %s)"), ip);
1550
1551         pending_network_jobs_start();
1552
1553         /* create our context */
1554         ctx = device_handler_discover_context_create(handler, dev);
1555         talloc_steal(ctx, event);
1556         ctx->event = event;
1557
1558         device_handler_start_requery_timeout(handler, dev,
1559                         event_requery_timeout(event));
1560
1561         iterate_parsers(ctx);
1562
1563         device_handler_discover_context_commit(handler, ctx);
1564
1565         talloc_unlink(handler, ctx);
1566
1567         return 0;
1568 }
1569
1570 struct discover_boot_option *device_handler_find_option_by_name(
1571                 struct device_handler *handler, const char *device,
1572                 const char *name)
1573 {
1574         size_t len = strlen(name);
1575         unsigned int i;
1576
1577         for (i = 0; i < handler->n_devices; i++) {
1578                 struct discover_device *dev = handler->devices[i];
1579                 struct discover_boot_option *opt;
1580
1581                 list_for_each_entry(&dev->boot_options, opt, list)
1582                         /* Match exactly, partial matches can be quite common */
1583                         if (strlen(opt->option->name) == len &&
1584                                         !strcmp(opt->option->name, name))
1585                                 if (!dev || !strcmp(opt->option->device_id, device))
1586                                         return opt;
1587         }
1588
1589         return NULL;
1590 }
1591
1592 static struct discover_boot_option *find_boot_option_by_id(
1593                 struct device_handler *handler, const char *id)
1594 {
1595         unsigned int i;
1596
1597         for (i = 0; i < handler->n_devices; i++) {
1598                 struct discover_device *dev = handler->devices[i];
1599                 struct discover_boot_option *opt;
1600
1601                 list_for_each_entry(&dev->boot_options, opt, list)
1602                         if (!strcmp(opt->option->id, id))
1603                                 return opt;
1604         }
1605
1606         return NULL;
1607 }
1608
1609 void device_handler_boot(struct device_handler *handler,
1610                 bool change_default, struct boot_command *cmd)
1611 {
1612         struct discover_boot_option *opt = NULL;
1613
1614         if (cmd->option_id && strlen(cmd->option_id))
1615                 opt = find_boot_option_by_id(handler, cmd->option_id);
1616
1617         /* Don't allow a normal client to change the default */
1618         if (!change_default && handler->last_boot_option &&
1619                         opt != handler->last_boot_option) {
1620                 pb_log("Non-root user tried to change boot option\n");
1621                 device_handler_status_err(handler,
1622                                 "Must be root to change default boot option\n");
1623                 return;
1624         }
1625
1626         if (handler->pending_boot)
1627                 boot_cancel(handler->pending_boot);
1628
1629         platform_pre_boot();
1630
1631         handler->pending_boot = boot(handler, opt, cmd, handler->dry_run,
1632                         device_handler_boot_status_cb, handler);
1633         handler->pending_boot_is_default = false;
1634 }
1635
1636 void device_handler_cancel_default(struct device_handler *handler)
1637 {
1638         if (handler->timeout_waiter)
1639                 waiter_remove(handler->timeout_waiter);
1640
1641         handler->timeout_waiter = NULL;
1642         handler->autoboot_enabled = false;
1643
1644         /* we only send status if we had a default boot option queued */
1645         if (!handler->default_boot_option)
1646                 return;
1647
1648         pb_log("Cancelling default boot option\n");
1649
1650         if (handler->pending_boot && handler->pending_boot_is_default) {
1651                 boot_cancel(handler->pending_boot);
1652                 handler->pending_boot = NULL;
1653                 handler->pending_boot_is_default = false;
1654         }
1655
1656         handler->default_boot_option = NULL;
1657
1658         device_handler_status_info(handler, _("Default boot cancelled"));
1659 }
1660
1661 void device_handler_update_config(struct device_handler *handler,
1662                 struct config *config)
1663 {
1664         int rc;
1665
1666         rc = config_set(config);
1667         if (rc) {
1668                 device_handler_status_err(handler,
1669                                 "Failed to update configuration!");
1670                 return;
1671         }
1672
1673         discover_server_notify_config(handler->server, config);
1674         device_handler_update_lang(config->lang);
1675         device_handler_reinit(handler);
1676 }
1677
1678 static char *device_from_addr(void *ctx, struct pb_url *url)
1679 {
1680         char *ipaddr, *buf, *tok, *dev = NULL;
1681         bool ipv6_route;
1682         const char *delim = " ";
1683         struct sockaddr_in *ipv4;
1684         struct sockaddr_in6 *ipv6;
1685         struct addrinfo *res;
1686         struct process *p;
1687         int rc;
1688
1689         /* Confirm url->host is either a valid hostname, or a
1690          * valid IPv4 or IPv6 address */
1691         rc = getaddrinfo(url->host, NULL, NULL, &res);
1692         if (rc) {
1693                 pb_debug("%s: Invalid URL\n",__func__);
1694                 return NULL;
1695         }
1696
1697         switch (res->ai_family) {
1698         case AF_INET:   /* ipv4 */
1699                 ipaddr = talloc_array(ctx,char,INET_ADDRSTRLEN);
1700                 ipv4 = (struct sockaddr_in *) res->ai_addr;
1701                 inet_ntop(AF_INET, &(ipv4->sin_addr), ipaddr, INET_ADDRSTRLEN);
1702                 ipv6_route = false;
1703                 break;
1704         case AF_INET6:  /* ipv6 */
1705                 ipaddr = talloc_array(ctx,char,INET6_ADDRSTRLEN);
1706                 ipv6 = (struct sockaddr_in6 *) res->ai_addr;
1707                 inet_ntop(AF_INET6, &(ipv6->sin6_addr), ipaddr, INET6_ADDRSTRLEN);
1708                 ipv6_route = true;
1709                 break;
1710         default:        /* error */
1711                 freeaddrinfo(res);
1712                 return NULL;
1713         }
1714         freeaddrinfo(res);
1715
1716         const char *argv[] = {
1717                 pb_system_apps.ip,
1718                 ipv6_route ? "-6" : "-4",
1719                 "route", "show", "to", "match",
1720                 ipaddr,
1721                 NULL
1722         };
1723
1724         p = process_create(ctx);
1725
1726         p->path = pb_system_apps.ip;
1727         p->argv = argv;
1728         p->keep_stdout = true;
1729
1730         rc = process_run_sync(p);
1731
1732         if (rc || p->exit_status) {
1733                 /* ip has complained for some reason; most likely
1734                  * there is no route to the host - bail out */
1735                 pb_debug("%s: `ip` returns non-zero exit status\n", __func__);
1736                 pb_debug("ip buf: %s\n", p->stdout_buf);
1737                 process_release(p);
1738                 return NULL;
1739         }
1740
1741         buf = p->stdout_buf;
1742         /* If a route is found, ip-route output will be of the form
1743          * "... dev DEVNAME ... " */
1744         tok = strtok(buf, delim);
1745         while (tok) {
1746                 if (!strcmp(tok, "dev")) {
1747                         tok = strtok(NULL, delim);
1748                         dev = talloc_strdup(ctx, tok);
1749                         break;
1750                 }
1751                 tok = strtok(NULL, delim);
1752         }
1753
1754         process_release(p);
1755         if (dev)
1756                 pb_debug("%s: Found interface '%s'\n", __func__,dev);
1757         return dev;
1758 }
1759
1760 static void process_url_cb(struct load_url_result *result, void *data)
1761 {
1762         struct device_handler *handler;
1763         struct discover_context *ctx;
1764         struct discover_device *dev;
1765         struct event *event = data;
1766         const char *mac;
1767
1768         if (result->status != LOAD_OK) {
1769                 pb_log_fn("Load failed for %s\n", result->url->full);
1770                 return;
1771         }
1772
1773         if (!event)
1774                 return;
1775
1776         handler = talloc_parent(event);
1777         if (!handler)
1778                 return;
1779
1780         event->device = device_from_addr(event, result->url);
1781         if (!event->device) {
1782                 pb_log("Downloaded a file but can't find its interface - pretending it was local\n");
1783                 event->device = talloc_asprintf(event, "local");
1784         }
1785
1786         mac = event_get_param(event, "mac");
1787         char *url = talloc_asprintf(event, "file://%s", result->local);
1788         event_set_param(event, "pxeconffile-local", url);
1789
1790         dev = discover_device_create(handler, mac, event->device);
1791         ctx = device_handler_discover_context_create(handler, dev);
1792         talloc_steal(ctx, event);
1793         ctx->event = event;
1794
1795         iterate_parsers(ctx);
1796
1797         device_handler_discover_context_commit(handler, ctx);
1798
1799         talloc_unlink(handler, ctx);
1800 }
1801
1802 void device_handler_process_url(struct device_handler *handler,
1803                 const char *url, const char *mac, const char *ip)
1804 {
1805         struct discover_context *ctx;
1806         struct discover_device *dev;
1807         bool allow_async = false;
1808         struct pb_url *pb_url;
1809         struct event *event;
1810
1811         event = talloc_zero(handler, struct event);
1812         event->type = EVENT_TYPE_USER;
1813         event->action = EVENT_ACTION_URL;
1814
1815         pb_url = pb_url_parse(event, url);
1816         if (!pb_url || (pb_url->scheme != pb_url_file && !pb_url->host)) {
1817                 device_handler_status_err(handler, _("Invalid config URL!"));
1818                 talloc_free(event);
1819                 return;
1820         }
1821
1822         if (url[strlen(url) - 1] == '/') {
1823                 event_set_param(event, "pxepathprefix", url);
1824                 event_set_param(event, "mac", mac);
1825                 event_set_param(event, "ip", ip);
1826                 event->device = device_from_addr(event, pb_url);
1827                 if (!event->device) {
1828                         device_handler_status_err(handler,
1829                                         _("Unable to route to host %s"),
1830                                         pb_url->host);
1831                         talloc_free(event);
1832                         return;
1833                 }
1834         } else {
1835                 event_set_param(event, "pxeconffile", url);
1836                 allow_async = true;
1837         }
1838
1839         if (pb_url->scheme == pb_url_file)
1840                 event->device = talloc_asprintf(event, "local");
1841         else if (allow_async) {
1842                 /* If file is remote load asynchronously before passing to
1843                  * parser. This allows us to wait for network to be available */
1844                 if (!load_url_async(handler, pb_url, process_url_cb, event,
1845                                         NULL, handler)) {
1846                         pb_log("Failed to load url %s\n", pb_url->full);
1847                         device_handler_status_err(handler, _("Failed to load URL!"));
1848                         talloc_free(event);
1849                 }
1850                 return;
1851         }
1852
1853         /* If path is local we can parse straight away */
1854
1855         dev = discover_device_create(handler, mac, event->device);
1856         if (pb_url->scheme == pb_url_file)
1857                 dev->device->type = DEVICE_TYPE_ANY;
1858         ctx = device_handler_discover_context_create(handler, dev);
1859         talloc_steal(ctx, event);
1860         ctx->event = event;
1861
1862         iterate_parsers(ctx);
1863
1864         device_handler_discover_context_commit(handler, ctx);
1865
1866         talloc_unlink(handler, ctx);
1867 }
1868
1869 static void plugin_install_cb(struct process *process)
1870 {
1871         struct device_handler *handler = process->data;
1872
1873         if (!handler) {
1874                 pb_log_fn("Missing data!\n");
1875                 return;
1876         }
1877
1878         handler->plugin_installing = false;
1879         if (process->exit_status) {
1880                 device_handler_status_err(handler, "Plugin failed to install!");
1881                 pb_log("Failed to install plugin:\n%s\n", process->stdout_buf);
1882         }
1883 }
1884
1885 void device_handler_install_plugin(struct device_handler *handler,
1886                 const char *plugin_file)
1887 {
1888         struct process *p;
1889         int result;
1890
1891         if (handler->plugin_installing) {
1892                 pb_log("Plugin install cancelled - install already running");
1893                 return;
1894         }
1895
1896         p = process_create(handler);
1897         if (!p) {
1898                 pb_log("install_plugin: Failed to create process\n");
1899                 return;
1900         }
1901
1902         const char *argv[] = {
1903                 pb_system_apps.pb_plugin,
1904                 "install",
1905                 "auto",
1906                 plugin_file,
1907                 NULL
1908         };
1909
1910         p->path = pb_system_apps.pb_plugin;
1911         p->argv = argv;
1912         p->exit_cb = plugin_install_cb;
1913         p->data = handler;
1914         p->keep_stdout = true;
1915
1916         result = process_run_async(p);
1917
1918         if (result)
1919                 device_handler_status_err(handler, "Could not install plugin");
1920         else
1921                 handler->plugin_installing = true;
1922 }
1923
1924 #ifndef PETITBOOT_TEST
1925
1926 /**
1927  * context_commit - Commit a temporary discovery context to the handler,
1928  * and notify the clients about any new options / devices
1929  */
1930 void device_handler_discover_context_commit(struct device_handler *handler,
1931                 struct discover_context *ctx)
1932 {
1933         struct discover_device *dev = ctx->device;
1934         struct discover_boot_option *opt, *tmp;
1935
1936         if (!device_lookup_by_uuid(handler, dev->uuid))
1937                 device_handler_add_device(handler, dev);
1938
1939         /* move boot options from the context to the device */
1940         list_for_each_entry_safe(&ctx->boot_options, opt, tmp, list) {
1941                 list_remove(&opt->list);
1942
1943                 /* All boot options need at least a kernel image */
1944                 if (!opt->boot_image || !opt->boot_image->url) {
1945                         pb_log("boot option %s is missing boot image, ignoring\n",
1946                                 opt->option->id);
1947                         talloc_free(opt);
1948                         continue;
1949                 }
1950
1951                 if (boot_option_resolve(opt, handler)) {
1952                         pb_log("boot option %s is resolved, "
1953                                         "sending to clients\n",
1954                                         opt->option->id);
1955                         list_add_tail(&dev->boot_options, &opt->list);
1956                         talloc_steal(dev, opt);
1957                         boot_option_finalise(handler, opt);
1958                         notify_boot_option(handler, opt);
1959                 } else {
1960                         if (!opt->source->resolve_resource) {
1961                                 pb_log("parser %s gave us an unresolved "
1962                                         "resource (%s), but no way to "
1963                                         "resolve it\n",
1964                                         opt->source->name, opt->option->id);
1965                                 talloc_free(opt);
1966                         } else {
1967                                 pb_log("boot option %s is unresolved, "
1968                                                 "adding to queue\n",
1969                                                 opt->option->id);
1970                                 list_add(&handler->unresolved_boot_options,
1971                                                 &opt->list);
1972                                 talloc_steal(handler, opt);
1973                         }
1974                 }
1975         }
1976 }
1977
1978 void device_handler_add_plugin_option(struct device_handler *handler,
1979                 struct plugin_option *opt)
1980 {
1981         struct plugin_option *tmp;
1982         unsigned int i;
1983
1984         for (i = 0; i < handler->n_plugins; i++) {
1985                 tmp = handler->plugins[i];
1986                 /* If both id and version match, ignore */
1987                 if (strncmp(opt->id, tmp->id, strlen(opt->id)) == 0 &&
1988                                 strcmp(opt->version, tmp->version) == 0) {
1989                         pb_log("discover: Plugin '%s' already exists, ignoring\n",
1990                                         opt->id);
1991                         return;
1992                 }
1993         }
1994
1995         handler->plugins = talloc_realloc(handler, handler->plugins,
1996                         struct plugin_option *, handler->n_plugins + 1);
1997         if (!handler->plugins) {
1998                 pb_log("Failed to allocate memory for new plugin\n");
1999                 handler->n_plugins = 0;
2000                 return;
2001         }
2002
2003         handler->plugins[handler->n_plugins++] = opt;
2004         discover_server_notify_plugin_option_add(handler->server, opt);
2005 }
2006
2007 static void device_handler_update_lang(const char *lang)
2008 {
2009         const char *cur_lang;
2010
2011         if (!lang)
2012                 return;
2013
2014         cur_lang = setlocale(LC_ALL, NULL);
2015         if (cur_lang && !strcmp(cur_lang, lang))
2016                 return;
2017
2018         setlocale(LC_ALL, lang);
2019 }
2020
2021 static int device_handler_init_sources(struct device_handler *handler)
2022 {
2023         /* init our device sources: udev, network and user events */
2024         handler->user_event = user_event_init(handler, handler->waitset);
2025         if (!handler->user_event)
2026                 return -1;
2027
2028         handler->network = network_init(handler, handler->waitset,
2029                         handler->dry_run);
2030         if (!handler->network)
2031                 return -1;
2032
2033         handler->udev = udev_init(handler, handler->waitset);
2034         if (!handler->udev)
2035                 return -1;
2036
2037         return 0;
2038 }
2039
2040 static void device_handler_reinit_sources(struct device_handler *handler)
2041 {
2042         /* if we haven't initialised sources previously (becuase we started in
2043          * safe mode), then init once here. */
2044         if (!(handler->udev || handler->network || handler->user_event)) {
2045                 device_handler_init_sources(handler);
2046                 return;
2047         }
2048
2049         system_info_reinit();
2050
2051         network_shutdown(handler->network);
2052         handler->network = network_init(handler, handler->waitset,
2053                         handler->dry_run);
2054
2055         udev_reinit(handler->udev);
2056 }
2057
2058 static inline const char *get_device_path(struct discover_device *dev)
2059 {
2060         return dev->ramdisk ? dev->ramdisk->snapshot : dev->device_path;
2061 }
2062
2063 static char *check_subvols(struct discover_device *dev)
2064 {
2065         const char *fstype = discover_device_get_param(dev, "ID_FS_TYPE");
2066         struct stat sb;
2067         char *path;
2068         int rc;
2069
2070         if (strncmp(fstype, "btrfs", strlen("btrfs")))
2071                 return dev->mount_path;
2072
2073         /* On btrfs a device's root may be under a subvolume path */
2074         path = join_paths(dev, dev->mount_path, "@");
2075         rc = stat(path, &sb);
2076         if (!rc && S_ISDIR(sb.st_mode)) {
2077                 pb_debug("Using '%s' for btrfs root path\n", path);
2078                 return path;
2079         }
2080
2081         talloc_free(path);
2082         return dev->mount_path;
2083 }
2084
2085 static bool check_existing_mount(struct discover_device *dev)
2086 {
2087         struct stat devstat, mntstat;
2088         const char *device_path;
2089         struct mntent *mnt;
2090         FILE *fp;
2091         int rc;
2092
2093         device_path = get_device_path(dev);
2094
2095         rc = stat(device_path, &devstat);
2096         if (rc) {
2097                 pb_debug("%s: stat failed: %s\n", __func__, strerror(errno));
2098                 return false;
2099         }
2100
2101         if (!S_ISBLK(devstat.st_mode)) {
2102                 pb_debug("%s: %s isn't a block device?\n", __func__,
2103                                 dev->device_path);
2104                 return false;
2105         }
2106
2107         fp = fopen("/proc/self/mounts", "r");
2108
2109         for (;;) {
2110                 mnt = getmntent(fp);
2111                 if (!mnt)
2112                         break;
2113
2114                 if (!mnt->mnt_fsname || mnt->mnt_fsname[0] != '/')
2115                         continue;
2116
2117                 rc = stat(mnt->mnt_fsname, &mntstat);
2118                 if (rc)
2119                         continue;
2120
2121                 if (!S_ISBLK(mntstat.st_mode))
2122                         continue;
2123
2124                 if (mntstat.st_rdev == devstat.st_rdev) {
2125                         dev->mount_path = talloc_strdup(dev, mnt->mnt_dir);
2126                         dev->root_path = check_subvols(dev);
2127                         dev->mounted_rw = !!hasmntopt(mnt, "rw");
2128                         dev->mounted = true;
2129                         dev->unmount = false;
2130
2131                         pb_debug("%s: %s is already mounted (r%c) at %s\n",
2132                                         __func__, dev->device_path,
2133                                         dev->mounted_rw ? 'w' : 'o',
2134                                         mnt->mnt_dir);
2135                         break;
2136                 }
2137         }
2138
2139         fclose(fp);
2140
2141         return mnt != NULL;
2142 }
2143
2144 /*
2145  * Attempt to mount a filesystem safely, while handling certain filesytem-
2146  * specific options
2147  */
2148 static int try_mount(const char *device_path, const char *mount_path,
2149                              const char *fstype, unsigned long flags,
2150                              bool have_snapshot)
2151 {
2152         const char *fs, *safe_opts;
2153         int rc;
2154
2155         /* Mount ext3 as ext4 instead so 'norecovery' can be used */
2156         if (strncmp(fstype, "ext3", strlen("ext3")) == 0) {
2157                 pb_debug("Mounting ext3 filesystem as ext4\n");
2158                 fs = "ext4";
2159         } else
2160                 fs = fstype;
2161
2162         if (strncmp(fs, "xfs", strlen("xfs")) == 0 ||
2163             strncmp(fs, "ext4", strlen("ext4")) == 0)
2164                 safe_opts = "norecovery";
2165         else
2166                 safe_opts = NULL;
2167
2168         errno = 0;
2169         /* If no snapshot is available don't attempt recovery */
2170         if (!have_snapshot)
2171                 return mount(device_path, mount_path, fs, flags, safe_opts);
2172
2173         rc = mount(device_path, mount_path, fs, flags, NULL);
2174
2175         if (!rc)
2176                 return rc;
2177
2178         /* Mounting failed; some filesystems will fail to mount if a recovery
2179          * journal exists (eg. cross-endian XFS), so try again with norecovery
2180          * where that option is available.
2181          * If mounting read-write just return the error as norecovery is not a
2182          * valid option */
2183         if ((flags & MS_RDONLY) != MS_RDONLY || !safe_opts)
2184                 return rc;
2185
2186         errno = 0;
2187         return mount(device_path, mount_path, fs, flags, safe_opts);
2188 }
2189
2190 static int mount_device(struct discover_device *dev)
2191 {
2192         const char *fstype, *device_path;
2193         int rc;
2194
2195         if (!dev->device_path)
2196                 return -1;
2197
2198         if (dev->mounted)
2199                 return 0;
2200
2201         if (check_existing_mount(dev))
2202                 return 0;
2203
2204         fstype = discover_device_get_param(dev, "ID_FS_TYPE");
2205         if (!fstype)
2206                 return 0;
2207
2208         dev->mount_path = join_paths(dev, mount_base(),
2209                                         dev->device_path);
2210
2211         if (pb_mkdir_recursive(dev->mount_path)) {
2212                 pb_log("couldn't create mount directory %s: %s\n",
2213                                 dev->mount_path, strerror(errno));
2214                 goto err_free;
2215         }
2216
2217         device_path = get_device_path(dev);
2218
2219         pb_log("mounting device %s read-only\n", dev->device_path);
2220         rc = try_mount(device_path, dev->mount_path, fstype,
2221                        MS_RDONLY | MS_SILENT, dev->ramdisk);
2222
2223         /* If mount fails clean up any snapshot and try again */
2224         if (rc && dev->ramdisk) {
2225                 pb_log("couldn't mount snapshot for %s: mount failed: %s\n",
2226                                 device_path, strerror(errno));
2227                 pb_log("falling back to actual device\n");
2228
2229                 devmapper_destroy_snapshot(dev);
2230
2231                 device_path = get_device_path(dev);
2232                 pb_log("mounting device %s read-only\n", dev->device_path);
2233                 rc = try_mount(device_path, dev->mount_path, fstype,
2234                                MS_RDONLY | MS_SILENT, dev->ramdisk);
2235         }
2236
2237         if (!rc) {
2238                 dev->mounted = true;
2239                 dev->mounted_rw = false;
2240                 dev->unmount = true;
2241                 dev->root_path = check_subvols(dev);
2242                 return 0;
2243         }
2244
2245         pb_log("couldn't mount device %s: mount failed: %s\n",
2246                         device_path, strerror(errno));
2247
2248         pb_rmdir_recursive(mount_base(), dev->mount_path);
2249 err_free:
2250         talloc_free(dev->mount_path);
2251         dev->mount_path = NULL;
2252         return -1;
2253 }
2254
2255 static int umount_device(struct discover_device *dev)
2256 {
2257         const char *device_path;
2258         int rc;
2259
2260         if (!dev->mounted || !dev->unmount)
2261                 return 0;
2262
2263         device_path = get_device_path(dev);
2264
2265         pb_log("unmounting device %s\n", device_path);
2266         rc = umount(dev->mount_path);
2267         if (rc)
2268                 return -1;
2269
2270         dev->mounted = false;
2271
2272         pb_rmdir_recursive(mount_base(), dev->mount_path);
2273
2274         talloc_free(dev->mount_path);
2275         dev->mount_path = NULL;
2276         dev->root_path = NULL;
2277
2278         return 0;
2279 }
2280
2281 int device_request_write(struct discover_device *dev, bool *release)
2282 {
2283         const char *fstype, *device_path;
2284         const struct config *config;
2285         int rc;
2286
2287         *release = false;
2288
2289         config = config_get();
2290         if (!config->allow_writes)
2291                 return -1;
2292
2293         if (!dev->mounted)
2294                 return -1;
2295
2296         if (dev->mounted_rw)
2297                 return 0;
2298
2299         fstype = discover_device_get_param(dev, "ID_FS_TYPE");
2300
2301         device_path = get_device_path(dev);
2302
2303         pb_log("remounting device %s read-write\n", device_path);
2304
2305         rc = umount(dev->mount_path);
2306         if (rc) {
2307                 pb_log("Failed to unmount %s: %s\n",
2308                        dev->mount_path, strerror(errno));
2309                 return -1;
2310         }
2311
2312         rc = try_mount(device_path, dev->mount_path, fstype,
2313                        MS_SILENT, dev->ramdisk);
2314         if (rc)
2315                 goto mount_ro;
2316
2317         dev->mounted_rw = true;
2318         *release = true;
2319         return 0;
2320
2321 mount_ro:
2322         pb_log("Unable to remount device %s read-write: %s\n",
2323                device_path, strerror(errno));
2324         rc = try_mount(device_path, dev->mount_path, fstype,
2325                        MS_RDONLY | MS_SILENT, dev->ramdisk);
2326         if (rc)
2327                 pb_log("Unable to recover mount for %s: %s\n",
2328                        device_path, strerror(errno));
2329         return -1;
2330 }
2331
2332 void device_release_write(struct discover_device *dev, bool release)
2333 {
2334         const char *fstype, *device_path;
2335
2336         if (!release)
2337                 return;
2338
2339         device_path = get_device_path(dev);
2340
2341         fstype = discover_device_get_param(dev, "ID_FS_TYPE");
2342
2343         pb_log("remounting device %s read-only\n", device_path);
2344
2345         if (umount(dev->mount_path)) {
2346                 pb_log("Failed to unmount %s\n", dev->mount_path);
2347                 return;
2348         }
2349         dev->mounted_rw = dev->mounted = false;
2350
2351         if (dev->ramdisk) {
2352                 devmapper_merge_snapshot(dev);
2353                 /* device_path becomes stale after merge */
2354                 device_path = get_device_path(dev);
2355         }
2356
2357         if (try_mount(device_path, dev->mount_path, fstype,
2358                        MS_RDONLY | MS_SILENT, dev->ramdisk))
2359                 pb_log("Failed to remount %s read-only: %s\n",
2360                        device_path, strerror(errno));
2361         else
2362                 dev->mounted = true;
2363 }
2364
2365 void device_sync_snapshots(struct device_handler *handler, const char *device)
2366 {
2367         struct discover_device *dev = NULL;
2368         unsigned int i;
2369
2370         if (device) {
2371                 /* Find matching device and sync */
2372                 dev = device_lookup_by_name(handler, device);
2373                 if (!dev) {
2374                         pb_log("%s: device name '%s' unrecognised\n",
2375                                 __func__, device);
2376                         return;
2377                 }
2378                 if (dev->ramdisk)
2379                         device_release_write(dev, true);
2380                 else
2381                         pb_log("%s has no snapshot to merge, skipping\n",
2382                                 dev->device->id);
2383                 return;
2384         }
2385
2386         /* Otherwise sync all relevant devices */
2387         for (i = 0; i < handler->n_devices; i++) {
2388                 dev = handler->devices[i];
2389                 if (dev->device->type != DEVICE_TYPE_DISK &&
2390                         dev->device->type != DEVICE_TYPE_USB)
2391                         continue;
2392                 if (dev->ramdisk)
2393                         device_release_write(dev, true);
2394                 else
2395                         pb_log("%s has no snapshot to merge, skipping\n",
2396                                 dev->device->id);
2397         }
2398 }
2399
2400 #else
2401
2402 void device_handler_discover_context_commit(
2403                 struct device_handler *handler __attribute__((unused)),
2404                 struct discover_context *ctx __attribute__((unused)))
2405 {
2406         pb_log_fn("stubbed out for test cases\n");
2407 }
2408
2409 static void device_handler_update_lang(const char *lang __attribute__((unused)))
2410 {
2411 }
2412
2413 static int device_handler_init_sources(
2414                 struct device_handler *handler __attribute__((unused)))
2415 {
2416         return 0;
2417 }
2418
2419 static void device_handler_reinit_sources(
2420                 struct device_handler *handler __attribute__((unused)))
2421 {
2422 }
2423
2424 static int umount_device(struct discover_device *dev __attribute__((unused)))
2425 {
2426         return 0;
2427 }
2428
2429 static int __attribute__((unused)) mount_device(
2430                 struct discover_device *dev __attribute__((unused)))
2431 {
2432         return 0;
2433 }
2434
2435 int device_request_write(struct discover_device *dev __attribute__((unused)),
2436                 bool *release)
2437 {
2438         *release = true;
2439         return 0;
2440 }
2441
2442 void device_release_write(struct discover_device *dev __attribute__((unused)),
2443         bool release __attribute__((unused)))
2444 {
2445 }
2446
2447 void device_sync_snapshots(
2448                 struct device_handler *handler __attribute__((unused)),
2449                 const char *device __attribute__((unused)))
2450 {
2451 }
2452
2453 #endif