+ unsigned int i;
+ char *name;
+ dev_t id;
+
+ /* Check if free ramdisk exists */
+ for (i = 0; i < handler->n_ramdisks; i++)
+ if (!handler->ramdisks[i]->snapshot &&
+ !handler->ramdisks[i]->origin &&
+ !handler->ramdisks[i]->base)
+ return handler->ramdisks[i];
+
+ /* Otherwise create a new one */
+ name = talloc_asprintf(handler, "/dev/ram%d",
+ handler->n_ramdisks);
+ if (!name) {
+ pb_debug("Failed to allocate memory to name /dev/ram%d",
+ handler->n_ramdisks);
+ return NULL;
+ }
+
+ id = makedev(1, handler->n_ramdisks);
+ if (mknod(name, S_IFBLK, id)) {
+ if (errno == EEXIST) {
+ /* We haven't yet received updates for existing
+ * ramdisks - add and use this one */
+ pb_debug("Using untracked ramdisk %s\n", name);
+ } else {
+ pb_log("Failed to create new ramdisk %s: %s\n",
+ name, strerror(errno));
+ return NULL;
+ }
+ }
+ device_handler_add_ramdisk(handler, name);
+ talloc_free(name);
+
+ return handler->ramdisks[i];
+}
+
+void device_handler_release_ramdisk(struct discover_device *device)
+{
+ struct ramdisk_device *ramdisk = device->ramdisk;
+
+ talloc_free(ramdisk->snapshot);
+ talloc_free(ramdisk->origin);
+ talloc_free(ramdisk->base);
+
+ ramdisk->snapshot = ramdisk->origin = ramdisk->base = NULL;
+ ramdisk->sectors = 0;
+
+ device->ramdisk = NULL;
+}
+
+/* Start discovery on a hotplugged device. The device will be in our devices
+ * array, but has only just been initialised by the hotplug source.
+ */
+int device_handler_discover(struct device_handler *handler,
+ struct discover_device *dev)
+{
+ struct discover_context *ctx;
+ struct boot_status *status;
+ int rc;
+
+ status = talloc_zero(handler, struct boot_status);
+ status->type = BOOT_STATUS_INFO;
+ /*
+ * TRANSLATORS: this string will be passed the type and identifier
+ * of the device. For example, the first parameter could be "Disk",
+ * (which will be translated accordingly) and the second a Linux device
+ * identifier like 'sda1' (which will not be translated)
+ */
+ status->message = talloc_asprintf(status, _("Processing %s device %s"),
+ device_type_display_name(dev->device->type),
+ dev->device->id);
+ boot_status(handler, status);
+
+ process_boot_option_queue(handler);
+
+ /* create our context */
+ ctx = device_handler_discover_context_create(handler, dev);
+
+ rc = mount_device(dev);
+ if (rc)
+ goto out;
+
+ /* add this device to our system info */
+ system_info_register_blockdev(dev->device->id, dev->uuid,
+ dev->mount_path);
+
+ /* run the parsers. This will populate the ctx's boot_option list. */
+ iterate_parsers(ctx);
+
+ /* add discovered stuff to the handler */
+ device_handler_discover_context_commit(handler, ctx);
+
+out:
+ /*
+ * TRANSLATORS: the format specifier in this string is a Linux
+ * device identifier, like 'sda1'
+ */
+ status->message = talloc_asprintf(status,_("Processing %s complete"),
+ dev->device->id);
+ boot_status(handler, status);
+
+ talloc_free(status);
+ talloc_free(ctx);
+
+ return 0;
+}
+
+/* Incoming dhcp event */
+int device_handler_dhcp(struct device_handler *handler,
+ struct discover_device *dev, struct event *event)
+{
+ struct discover_context *ctx;
+ struct boot_status *status;
+
+ status = talloc_zero(handler, struct boot_status);
+ status->type = BOOT_STATUS_INFO;
+ /*
+ * TRANSLATORS: this format specifier will be the name of a network
+ * device, like 'eth0'.
+ */
+ status->message = talloc_asprintf(status, _("Processing dhcp event on %s"),
+ dev->device->id);
+ boot_status(handler, status);
+
+ /* create our context */
+ ctx = device_handler_discover_context_create(handler, dev);
+ ctx->event = event;
+
+ iterate_parsers(ctx);
+
+ device_handler_discover_context_commit(handler, ctx);
+
+ /*
+ * TRANSLATORS: this format specifier will be the name of a network
+ * device, like 'eth0'.
+ */
+ status->message = talloc_asprintf(status,_("Processing %s complete"),
+ dev->device->id);
+ boot_status(handler, status);
+
+ talloc_free(status);
+ talloc_free(ctx);
+
+ return 0;
+}
+
+/* incoming conf event */
+int device_handler_conf(struct device_handler *handler,
+ struct discover_device *dev, struct pb_url *url)
+{
+ struct discover_context *ctx;
+ struct boot_status *status;
+
+ status = talloc_zero(handler, struct boot_status);
+ status->type = BOOT_STATUS_INFO;
+ status->message = talloc_asprintf(status, _("Processing user config"));
+ boot_status(handler, status);
+
+ /* create our context */
+ ctx = device_handler_discover_context_create(handler, dev);
+ ctx->conf_url = url;
+
+ iterate_parsers(ctx);
+
+ device_handler_discover_context_commit(handler, ctx);
+
+ status->message = talloc_asprintf(status,
+ _("Processing user config complete"));
+ boot_status(handler, status);
+
+ talloc_free(status);
+ talloc_free(ctx);
+
+ return 0;
+}
+
+static struct discover_boot_option *find_boot_option_by_id(
+ struct device_handler *handler, const char *id)
+{
+ unsigned int i;
+
+ for (i = 0; i < handler->n_devices; i++) {
+ struct discover_device *dev = handler->devices[i];
+ struct discover_boot_option *opt;
+
+ list_for_each_entry(&dev->boot_options, opt, list)
+ if (!strcmp(opt->option->id, id))
+ return opt;
+ }
+
+ return NULL;
+}
+
+void device_handler_boot(struct device_handler *handler,
+ struct boot_command *cmd)
+{
+ struct discover_boot_option *opt = NULL;
+
+ if (cmd->option_id && strlen(cmd->option_id))
+ opt = find_boot_option_by_id(handler, cmd->option_id);
+
+ if (handler->pending_boot)
+ boot_cancel(handler->pending_boot);
+
+ platform_pre_boot();
+
+ handler->pending_boot = boot(handler, opt, cmd, handler->dry_run,
+ boot_status, handler);
+ handler->pending_boot_is_default = false;
+}
+
+void device_handler_cancel_default(struct device_handler *handler)
+{
+ struct boot_status status;
+
+ if (handler->timeout_waiter)
+ waiter_remove(handler->timeout_waiter);
+
+ handler->timeout_waiter = NULL;
+ handler->autoboot_enabled = false;
+
+ /* we only send status if we had a default boot option queued */
+ if (!handler->default_boot_option)
+ return;
+
+ pb_log("Cancelling default boot option\n");
+
+ if (handler->pending_boot && handler->pending_boot_is_default) {
+ boot_cancel(handler->pending_boot);
+ handler->pending_boot = NULL;
+ handler->pending_boot_is_default = false;
+ }
+
+ handler->default_boot_option = NULL;
+
+ status.type = BOOT_STATUS_INFO;
+ status.progress = -1;
+ status.detail = NULL;
+ status.message = _("Default boot cancelled");
+
+ discover_server_notify_boot_status(handler->server, &status);
+}
+
+void device_handler_update_config(struct device_handler *handler,
+ struct config *config)
+{
+ int rc;
+
+ rc = config_set(config);
+ if (rc)
+ return;
+
+ discover_server_notify_config(handler->server, config);
+ device_handler_update_lang(config->lang);
+ device_handler_reinit(handler);
+}
+
+static char *device_from_addr(void *ctx, struct pb_url *url)
+{
+ char *ipaddr, *buf, *tok, *dev = NULL;
+ const char *delim = " ";
+ struct sockaddr_in *ip;
+ struct sockaddr_in si;
+ struct addrinfo *res;
+ struct process *p;
+ int rc;
+
+ /* Note: IPv4 only */
+ rc = inet_pton(AF_INET, url->host, &(si.sin_addr));
+ if (rc > 0) {
+ ipaddr = url->host;
+ } else {
+ /* need to turn hostname into a valid IP */
+ rc = getaddrinfo(url->host, NULL, NULL, &res);
+ if (rc) {
+ pb_debug("%s: Invalid URL\n",__func__);
+ return NULL;
+ }
+ ipaddr = talloc_array(ctx,char,INET_ADDRSTRLEN);
+ ip = (struct sockaddr_in *) res->ai_addr;
+ inet_ntop(AF_INET, &(ip->sin_addr), ipaddr, INET_ADDRSTRLEN);
+ freeaddrinfo(res);
+ }
+
+ const char *argv[] = {
+ pb_system_apps.ip,
+ "route", "show", "to", "match",
+ ipaddr,
+ NULL
+ };
+
+ p = process_create(ctx);
+
+ p->path = pb_system_apps.ip;
+ p->argv = argv;
+ p->keep_stdout = true;
+
+ rc = process_run_sync(p);
+
+ if (rc) {
+ /* ip has complained for some reason; most likely
+ * there is no route to the host - bail out */
+ pb_debug("%s: No route to %s\n",__func__,url->host);
+ return NULL;
+ }
+
+ buf = p->stdout_buf;
+ /* If a route is found, ip-route output will be of the form
+ * "... dev DEVNAME ... " */
+ tok = strtok(buf, delim);
+ while (tok) {
+ if (!strcmp(tok, "dev")) {
+ tok = strtok(NULL, delim);
+ dev = talloc_strdup(ctx, tok);
+ break;
+ }
+ tok = strtok(NULL, delim);
+ }
+
+ process_release(p);
+ if (dev)
+ pb_debug("%s: Found interface '%s'\n", __func__,dev);
+ return dev;
+}
+
+void device_handler_process_url(struct device_handler *handler,
+ const char *url, const char *mac, const char *ip)
+{
+ struct discover_context *ctx;
+ struct discover_device *dev;
+ struct boot_status *status;
+ struct pb_url *pb_url;
+ struct event *event;
+ struct param *param;
+
+ status = talloc(handler, struct boot_status);
+
+ status->type = BOOT_STATUS_ERROR;
+ status->progress = 0;
+ status->detail = talloc_asprintf(status,
+ _("Received config URL %s"), url);
+
+ if (!handler->network) {
+ status->message = talloc_asprintf(handler,
+ _("No network configured"));
+ goto msg;
+ }
+
+ event = talloc(handler, struct event);
+ event->type = EVENT_TYPE_USER;
+ event->action = EVENT_ACTION_CONF;
+
+ if (url[strlen(url) - 1] == '/') {
+ event->params = talloc_array(event, struct param, 3);
+ param = &event->params[0];
+ param->name = talloc_strdup(event, "pxepathprefix");
+ param->value = talloc_strdup(event, url);
+ param = &event->params[1];
+ param->name = talloc_strdup(event, "mac");
+ param->value = talloc_strdup(event, mac);
+ param = &event->params[2];
+ param->name = talloc_strdup(event, "ip");
+ param->value = talloc_strdup(event, ip);
+ event->n_params = 3;
+ } else {
+ event->params = talloc_array(event, struct param, 1);
+ param = &event->params[0];
+ param->name = talloc_strdup(event, "pxeconffile");
+ param->value = talloc_strdup(event, url);
+ event->n_params = 1;
+ }
+
+ pb_url = pb_url_parse(event, event->params->value);
+ if (!pb_url || !pb_url->host) {
+ status->message = talloc_asprintf(handler,
+ _("Invalid config URL!"));
+ goto msg;
+ }
+
+ event->device = device_from_addr(event, pb_url);
+ if (!event->device) {
+ status->message = talloc_asprintf(status,
+ _("Unable to route to host %s"),
+ pb_url->host);
+ goto msg;
+ }
+
+ dev = discover_device_create(handler, event->device);
+ ctx = device_handler_discover_context_create(handler, dev);
+ ctx->event = event;
+
+ iterate_parsers(ctx);
+
+ device_handler_discover_context_commit(handler, ctx);
+
+ talloc_free(ctx);
+
+ status->type = BOOT_STATUS_INFO;
+ status->message = talloc_asprintf(status, _("Config file %s parsed"),
+ pb_url->file);
+msg:
+ boot_status(handler, status);
+ talloc_free(status);
+}
+
+#ifndef PETITBOOT_TEST
+
+static void device_handler_update_lang(const char *lang)
+{
+ const char *cur_lang;
+
+ if (!lang)
+ return;
+
+ cur_lang = setlocale(LC_ALL, NULL);
+ if (cur_lang && !strcmp(cur_lang, lang))
+ return;
+
+ setlocale(LC_ALL, lang);
+}
+
+static int device_handler_init_sources(struct device_handler *handler)
+{
+ /* init our device sources: udev, network and user events */
+ handler->udev = udev_init(handler, handler->waitset);
+ if (!handler->udev)
+ return -1;
+
+ handler->network = network_init(handler, handler->waitset,
+ handler->dry_run);
+ if (!handler->network)
+ return -1;
+
+ handler->user_event = user_event_init(handler, handler->waitset);
+ if (!handler->user_event)
+ return -1;
+
+ return 0;
+}
+
+static void device_handler_reinit_sources(struct device_handler *handler)
+{
+ /* if we haven't initialised sources previously (becuase we started in
+ * safe mode), then init once here. */
+ if (!(handler->udev || handler->network || handler->user_event)) {
+ device_handler_init_sources(handler);
+ return;
+ }
+
+ udev_reinit(handler->udev);
+
+ network_shutdown(handler->network);
+ handler->network = network_init(handler, handler->waitset,
+ handler->dry_run);
+}
+
+static const char *fs_parameters(struct discover_device *dev,
+ unsigned int rw_flags)
+{
+ const char *fstype = discover_device_get_param(dev, "ID_FS_TYPE");
+
+ /* XFS journals are not cross-endian compatible; don't try recovery
+ * even if we have a snapshot */
+ if (!strncmp(fstype, "xfs", strlen("xfs")))
+ return "norecovery";
+
+ /* If we have a snapshot available allow touching the filesystem */
+ if (dev->ramdisk)
+ return "";
+
+ if ((rw_flags | MS_RDONLY) != MS_RDONLY)
+ return "";
+
+ /* Avoid writes due to journal replay if we don't have a snapshot */
+ if (!strncmp(fstype, "ext4", strlen("ext4")))
+ return "norecovery";
+
+ return "";
+}
+
+static inline const char *get_device_path(struct discover_device *dev)
+{
+ return dev->ramdisk ? dev->ramdisk->snapshot : dev->device_path;
+}
+
+static bool check_existing_mount(struct discover_device *dev)
+{
+ struct stat devstat, mntstat;
+ const char *device_path;
+ struct mntent *mnt;
+ FILE *fp;
+ int rc;
+
+ device_path = get_device_path(dev);
+
+ rc = stat(device_path, &devstat);
+ if (rc) {
+ pb_debug("%s: stat failed: %s\n", __func__, strerror(errno));
+ return false;
+ }
+
+ if (!S_ISBLK(devstat.st_mode)) {
+ pb_debug("%s: %s isn't a block device?\n", __func__,
+ dev->device_path);
+ return false;
+ }
+
+ fp = fopen("/proc/self/mounts", "r");
+
+ for (;;) {
+ mnt = getmntent(fp);
+ if (!mnt)
+ break;
+
+ if (!mnt->mnt_fsname || mnt->mnt_fsname[0] != '/')
+ continue;
+
+ rc = stat(mnt->mnt_fsname, &mntstat);
+ if (rc)
+ continue;
+
+ if (!S_ISBLK(mntstat.st_mode))
+ continue;
+
+ if (mntstat.st_rdev == devstat.st_rdev) {
+ dev->mount_path = talloc_strdup(dev, mnt->mnt_dir);
+ dev->mounted_rw = !!hasmntopt(mnt, "rw");
+ dev->mounted = true;
+ dev->unmount = false;
+
+ pb_debug("%s: %s is already mounted (r%c) at %s\n",
+ __func__, dev->device_path,
+ dev->mounted_rw ? 'w' : 'o',
+ mnt->mnt_dir);
+ break;
+ }
+ }
+
+ fclose(fp);
+
+ return mnt != NULL;
+}
+
+static int mount_device(struct discover_device *dev)
+{
+ const char *fstype, *device_path;
+ int rc;
+
+ if (!dev->device_path)
+ return -1;
+
+ if (dev->mounted)
+ return 0;
+
+ if (check_existing_mount(dev))
+ return 0;
+
+ fstype = discover_device_get_param(dev, "ID_FS_TYPE");
+ if (!fstype)
+ return 0;
+
+ /* ext3 treats the norecovery option as an error, so mount the device
+ * as an ext4 filesystem instead */
+ if (!strncmp(fstype, "ext3", strlen("ext3"))) {
+ pb_debug("Mounting ext3 filesystem as ext4\n");
+ fstype = talloc_asprintf(dev, "ext4");
+ }
+
+ dev->mount_path = join_paths(dev, mount_base(),
+ dev->device_path);
+
+ if (pb_mkdir_recursive(dev->mount_path)) {
+ pb_log("couldn't create mount directory %s: %s\n",
+ dev->mount_path, strerror(errno));
+ goto err_free;
+ }
+
+ device_path = get_device_path(dev);
+
+ pb_log("mounting device %s read-only\n", dev->device_path);
+ errno = 0;
+ rc = mount(device_path, dev->mount_path, fstype,
+ MS_RDONLY | MS_SILENT,
+ fs_parameters(dev, MS_RDONLY));
+ if (!rc) {
+ dev->mounted = true;
+ dev->mounted_rw = false;
+ dev->unmount = true;
+ return 0;
+ }
+
+ pb_log("couldn't mount device %s: mount failed: %s\n",
+ device_path, strerror(errno));
+
+ /* If mount fails clean up any snapshot */
+ devmapper_destroy_snapshot(dev);
+
+ pb_rmdir_recursive(mount_base(), dev->mount_path);
+err_free:
+ talloc_free(dev->mount_path);
+ dev->mount_path = NULL;
+ return -1;
+}
+
+static int umount_device(struct discover_device *dev)
+{
+ const char *device_path;
+ int rc;
+
+ if (!dev->mounted || !dev->unmount)
+ return 0;
+
+ device_path = get_device_path(dev);
+
+ pb_log("unmounting device %s\n", device_path);
+ rc = umount(dev->mount_path);
+ if (rc)
+ return -1;
+
+ dev->mounted = false;
+ devmapper_destroy_snapshot(dev);
+
+ pb_rmdir_recursive(mount_base(), dev->mount_path);
+
+ talloc_free(dev->mount_path);
+ dev->mount_path = NULL;
+
+ return 0;
+}
+
+int device_request_write(struct discover_device *dev, bool *release)
+{
+ const char *fstype, *device_path;
+ const struct config *config;
+ int rc;
+
+ *release = false;
+
+ config = config_get();
+ if (!config->allow_writes)
+ return -1;
+
+ if (!dev->mounted)
+ return -1;
+
+ if (dev->mounted_rw)
+ return 0;
+
+ fstype = discover_device_get_param(dev, "ID_FS_TYPE");
+
+ device_path = get_device_path(dev);
+
+ pb_log("remounting device %s read-write\n", device_path);
+
+ rc = umount(dev->mount_path);
+ if (rc) {
+ pb_log("Failed to unmount %s: %s\n",
+ dev->mount_path, strerror(errno));
+ return -1;
+ }
+
+ rc = mount(device_path, dev->mount_path, fstype,
+ MS_SILENT,
+ fs_parameters(dev, MS_REMOUNT));
+ if (rc)
+ goto mount_ro;
+
+ dev->mounted_rw = true;
+ *release = true;
+ return 0;
+
+mount_ro:
+ pb_log("Unable to remount device %s read-write: %s\n",
+ device_path, strerror(errno));
+ if (mount(device_path, dev->mount_path, fstype,
+ MS_RDONLY | MS_SILENT,
+ fs_parameters(dev, MS_RDONLY)))
+ pb_log("Unable to recover mount for %s: %s\n",
+ device_path, strerror(errno));
+ return -1;
+}
+
+void device_release_write(struct discover_device *dev, bool release)
+{
+ const char *fstype, *device_path;
+
+ if (!release)
+ return;
+
+ device_path = get_device_path(dev);
+
+ fstype = discover_device_get_param(dev, "ID_FS_TYPE");
+
+ pb_log("remounting device %s read-only\n", device_path);
+
+ if (umount(dev->mount_path)) {
+ pb_log("Failed to unmount %s\n", dev->mount_path);
+ return;
+ }
+ dev->mounted_rw = dev->mounted = false;
+
+ if (dev->ramdisk) {
+ devmapper_merge_snapshot(dev);
+ /* device_path becomes stale after merge */
+ device_path = get_device_path(dev);
+ }
+
+ if (mount(device_path, dev->mount_path, fstype,
+ MS_RDONLY | MS_SILENT,
+ fs_parameters(dev, MS_RDONLY)))
+ pb_log("Failed to remount %s read-only: %s\n",
+ device_path, strerror(errno));
+ else
+ dev->mounted = true;
+}
+
+#else
+
+static void device_handler_update_lang(const char *lang __attribute__((unused)))
+{
+}
+
+static int device_handler_init_sources(
+ struct device_handler *handler __attribute__((unused)))
+{
+ return 0;
+}
+
+static void device_handler_reinit_sources(
+ struct device_handler *handler __attribute__((unused)))
+{
+}
+
+static int umount_device(struct discover_device *dev __attribute__((unused)))
+{
+ return 0;
+}
+
+static int __attribute__((unused)) mount_device(
+ struct discover_device *dev __attribute__((unused)))
+{
+ return 0;
+}
+
+int device_request_write(struct discover_device *dev __attribute__((unused)),
+ bool *release)
+{
+ *release = true;
+ return 0;
+}
+
+void device_release_write(struct discover_device *dev __attribute__((unused)),
+ bool release __attribute__((unused)))
+{
+}
+
+#endif
+
projects / petitboot / blobdiff