stand/common/install.c

   1 /*-
   2  * Copyright (c) 2008-2014, Juniper Networks, Inc.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  19  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  21  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/socket.h>
  32 #include <net/if.h>
  33 #include <netinet/in.h>
  34 #include <netinet/in_systm.h>
  35
  36 #include <stand.h>
  37 #include <net.h>
  38 #include <string.h>
  39
  40 #include "bootstrap.h"
  41
  42 extern struct in_addr servip;
  43
  44 extern int pkgfs_init(const char *, struct fs_ops *);
  45 extern void pkgfs_cleanup(void);
  46
  47 COMMAND_SET(install, "install", "install software package", command_install);
  48
  49 static char *inst_kernel;
  50 static char **inst_modules;
  51 static char *inst_rootfs;
  52 static char *inst_loader_rc;
  53
  54 static int
  55 setpath(char **what, char *val)
  56 {
  57         char *path;
  58         size_t len;
  59         int rel;
  60
  61         len = strlen(val) + 1;
  62         rel = (val[0] != '/') ? 1 : 0;
  63         path = malloc(len + rel);
  64         if (path == NULL)
  65                 return (ENOMEM);
  66         path[0] = '/';
  67         strcpy(path + rel, val);
  68
  69         *what = path;
  70         return (0);
  71 }
  72
  73 static int
  74 setmultipath(char ***what, char *val)
  75 {
  76         char *s, *v;
  77         int count, error, idx;
  78
  79         count = 0;
  80         v = val;
  81         do {
  82                 count++;
  83                 s = strchr(v, ',');
  84                 v = (s == NULL) ? NULL : s + 1;
  85         } while (v != NULL);
  86
  87         *what = calloc(count + 1, sizeof(char *));
  88         if (*what == NULL)
  89                 return (ENOMEM);
  90
  91         for (idx = 0; idx < count; idx++) {
  92                 s = strchr(val, ',');
  93                 if (s != NULL)
  94                         *s++ = '\0';
  95                 error = setpath(*what + idx, val);
  96                 if (error)
  97                         return (error);
  98                 val = s;
  99         }
 100
 101         return (0);
 102 }
 103
 104 static int
 105 read_metatags(int fd)
 106 {
 107         char buf[1024];
 108         char *p, *tag, *val;
 109         ssize_t fsize;
 110         int error;
 111
 112         fsize = read(fd, buf, sizeof(buf));
 113         if (fsize == -1)
 114                 return (errno);
 115
 116         /*
 117          * Assume that if we read a whole buffer worth of data, we
 118          * haven't read the entire file. In other words, the buffer
 119          * size must always be larger than the file size. That way
 120          * we can append a '\0' and use standard string operations.
 121          * Return an error if this is not possible.
 122          */
 123         if (fsize == sizeof(buf))
 124                 return (ENOMEM);
 125
 126         buf[fsize] = '\0';
 127         error = 0;
 128         tag = buf;
 129         while (!error && *tag != '\0') {
 130                 val = strchr(tag, '=');
 131                 if (val == NULL) {
 132                         error = EINVAL;
 133                         break;
 134                 }
 135                 *val++ = '\0';
 136                 p = strchr(val, '\n');
 137                 if (p == NULL) {
 138                         error = EINVAL;
 139                         break;
 140                 }
 141                 *p++ = '\0';
 142
 143                 if (strcmp(tag, "KERNEL") == 0)
 144                         error = setpath(&inst_kernel, val);
 145                 else if (strcmp(tag, "MODULES") == 0)
 146                         error = setmultipath(&inst_modules, val);
 147                 else if (strcmp(tag, "ROOTFS") == 0)
 148                         error = setpath(&inst_rootfs, val);
 149                 else if (strcmp(tag, "LOADER_RC") == 0)
 150                         error = setpath(&inst_loader_rc, val);
 151
 152                 tag = p;
 153         }
 154
 155         return (error);
 156 }
 157
 158 static void
 159 cleanup(void)
 160 {
 161         u_int i;
 162
 163         if (inst_kernel != NULL) {
 164                 free(inst_kernel);
 165                 inst_kernel = NULL;
 166         }
 167         if (inst_modules != NULL) {
 168                 i = 0;
 169                 while (inst_modules[i] != NULL)
 170                         free(inst_modules[i++]);
 171                 free(inst_modules);
 172                 inst_modules = NULL;
 173         }
 174         if (inst_rootfs != NULL) {
 175                 free(inst_rootfs);
 176                 inst_rootfs = NULL;
 177         }
 178         if (inst_loader_rc != NULL) {
 179                 free(inst_loader_rc);
 180                 inst_loader_rc = NULL;
 181         }
 182         pkgfs_cleanup();
 183 }
 184
 185 /*
 186  * usage: install URL
 187  * where: URL = (tftp|file)://[host]/<package>
 188  */
 189 static int
 190 install(char *pkgname)
 191 {
 192         static char buf[256];
 193         struct fs_ops *proto;
 194         struct preloaded_file *fp;
 195         char *s, *currdev;
 196         const char *devname;
 197         int error, fd, i, local;
 198
 199         s = strstr(pkgname, "://");
 200         if (s == NULL)
 201                 goto invalid_url;
 202
 203         i = s - pkgname;
 204         if (i == 4 && !strncasecmp(pkgname, "tftp", i)) {
 205                 devname = "net0";
 206                 proto = &tftp_fsops;
 207                 local = 0;
 208         } else if (i == 4 && !strncasecmp(pkgname, "file", i)) {
 209                 currdev = getenv("currdev");
 210                 if (currdev != NULL && strcmp(currdev, "pxe0:") == 0) {
 211                         devname = "pxe0";
 212                         proto = NULL;
 213                 } else {
 214                         devname = "disk1";
 215                         proto = &dosfs_fsops;
 216                 }
 217                 local = 1;
 218         } else
 219                 goto invalid_url;
 220
 221         s += 3;
 222         if (*s == '\0')
 223                 goto invalid_url;
 224
 225         if (*s != '/' ) {
 226                 if (local)
 227                         goto invalid_url;
 228
 229                 pkgname = strchr(s, '/');
 230                 if (pkgname == NULL)
 231                         goto invalid_url;
 232
 233                 *pkgname = '\0';
 234                 servip.s_addr = inet_addr(s);
 235                 if (servip.s_addr == htonl(INADDR_NONE))
 236                         goto invalid_url;
 237
 238                 setenv("serverip", inet_ntoa(servip), 1);
 239
 240                 *pkgname = '/';
 241         } else
 242                 pkgname = s;
 243
 244         if (strlen(devname) + strlen(pkgname) + 2 > sizeof(buf)) {
 245                 command_errmsg = "package name too long";
 246                 return (CMD_ERROR);
 247         }
 248         sprintf(buf, "%s:%s", devname, pkgname);
 249         setenv("install_package", buf, 1);
 250
 251         error = pkgfs_init(buf, proto);
 252         if (error) {
 253                 command_errmsg = "cannot open package";
 254                 goto fail;
 255         }
 256
 257         /*
 258          * Point of no return: unload anything that may have been
 259          * loaded and prune the environment from harmful variables.
 260          */
 261         unload();
 262         unsetenv("vfs.root.mountfrom");
 263
 264         /*
 265          * read the metatags file.
 266          */
 267         fd = open("/metatags", O_RDONLY);
 268         if (fd != -1) {
 269                 error = read_metatags(fd);
 270                 close(fd);
 271                 if (error) {
 272                         command_errmsg = "cannot load metatags";
 273                         goto fail;
 274                 }
 275         }
 276
 277         s = (inst_kernel == NULL) ? "/kernel" : inst_kernel;
 278         error = mod_loadkld(s, 0, NULL);
 279         if (error) {
 280                 command_errmsg = "cannot load kernel from package";
 281                 goto fail;
 282         }
 283
 284         /* If there is a loader.rc in the package, execute it */
 285         s = (inst_loader_rc == NULL) ? "/loader.rc" : inst_loader_rc;
 286         fd = open(s, O_RDONLY);
 287         if (fd != -1) {
 288                 close(fd);
 289                 error = inter_include(s);
 290                 if (error == CMD_ERROR)
 291                         goto fail;
 292         }
 293
 294         i = 0;
 295         while (inst_modules != NULL && inst_modules[i] != NULL) {
 296                 error = mod_loadkld(inst_modules[i], 0, NULL);
 297                 if (error) {
 298                         command_errmsg = "cannot load module(s) from package";
 299                         goto fail;
 300                 }
 301                 i++;
 302         }
 303
 304         s = (inst_rootfs == NULL) ? "/install.iso" : inst_rootfs;
 305         if (file_loadraw(s, "mfs_root", 1) == NULL) {
 306                 error = errno;
 307                 command_errmsg = "cannot load root file system";
 308                 goto fail;
 309         }
 310
 311         cleanup();
 312
 313         fp = file_findfile(NULL, NULL);
 314         if (fp != NULL)
 315                 file_formats[fp->f_loader]->l_exec(fp);
 316         error = CMD_ERROR;
 317         command_errmsg = "unable to start installation";
 318
 319  fail:
 320         sprintf(buf, "%s (error %d)", command_errmsg, error);
 321         cleanup();
 322         unload();
 323         exclusive_file_system = NULL;
 324         command_errmsg = buf;   /* buf is static. */
 325         return (CMD_ERROR);
 326
 327  invalid_url:
 328         command_errmsg = "invalid URL";
 329         return (CMD_ERROR);
 330 }
 331
 332 static int
 333 command_install(int argc, char *argv[])
 334 {
 335         int argidx;
 336
 337         unsetenv("install_format");
 338
 339         argidx = 1;
 340         while (1) {
 341                 if (argc == argidx) {
 342                         command_errmsg =
 343                             "usage: install [--format] <URL>";
 344                         return (CMD_ERROR);
 345                 }
 346                 if (!strcmp(argv[argidx], "--format")) {
 347                         setenv("install_format", "yes", 1);
 348                         argidx++;
 349                         continue;
 350                 }
 351                 break;
 352         }
 353
 354         return (install(argv[argidx]));
 355 }