core/elflink/load_env32.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <unistd.h>
   4 #include <string.h>
   5 #include <console.h>
   6 #include <dprintf.h>
   7 #include <com32.h>
   8 #include <syslinux/adv.h>
   9 #include <syslinux/config.h>
  10 #include <setjmp.h>
  11 #include <linux/list.h>
  12 #include <netinet/in.h>
  13 #include <sys/cpu.h>
  14 #include <core.h>
  15 #include <fcntl.h>
  16 #include <sys/file.h>
  17 #include <fs.h>
  18 #include <ctype.h>
  19 #include <alloca.h>
  20
  21 #include <sys/exec.h>
  22 #include <sys/module.h>
  23 #include "common.h"
  24
  25 extern char __dynstr_start[];
  26 extern char __dynstr_end[], __dynsym_end[];
  27 extern char __dynsym_start[];
  28 extern char __got_start[];
  29 extern Elf_Dyn __dynamic_start[];
  30 extern Elf_Word __gnu_hash_start[];
  31 extern char __module_start[];
  32
  33 struct elf_module core_module = {
  34     .name               = "(core)",
  35     .shallow            = true,
  36     .required           = LIST_HEAD_INIT((core_module.required)),
  37     .dependants         = LIST_HEAD_INIT((core_module.dependants)),
  38     .list               = LIST_HEAD_INIT((core_module.list)),
  39     .module_addr        = (void *)0x0,
  40     .ghash_table        = __gnu_hash_start,
  41     .str_table          = __dynstr_start,
  42     .sym_table          = __dynsym_start,
  43     .got                = __got_start,
  44     .dyn_table          = __dynamic_start,
  45     .syment_size        = sizeof(Elf_Sym),
  46 };
  47
  48 /*
  49  * Initializes the module subsystem by taking the core module
  50  * (preinitialized shallow module) and placing it on top of the
  51  * modules_head_list.
  52  */
  53 void init_module_subsystem(struct elf_module *module)
  54 {
  55     list_add(&module->list, &modules_head);
  56 }
  57
  58 __export int start_ldlinux(int argc, char **argv)
  59 {
  60         int rv;
  61
  62 again:
  63         rv = spawn_load(LDLINUX, argc, argv);
  64         if (rv == EEXIST) {
  65                 /*
  66                  * If a COM32 module calls execute() we may need to
  67                  * unload all the modules loaded since ldlinux.*,
  68                  * and restart initialisation. This is especially
  69                  * important for config files.
  70                  *
  71                  * But before we do that, try our best to make sure
  72                  * that spawn_load() is gonna succeed, e.g. that we
  73                  * can find LDLINUX it in PATH.
  74                  */
  75                 struct elf_module *ldlinux;
  76                 FILE *f;
  77
  78                 f = findpath(LDLINUX);
  79                 if (!f)
  80                         return ENOENT;
  81
  82                 fclose(f);
  83                 ldlinux = unload_modules_since(LDLINUX);
  84
  85                 /*
  86                  * Finally unload LDLINUX.
  87                  *
  88                  * We'll reload it when we jump to 'again' which will
  89                  * cause all the initialsation steps to be executed
  90                  * again.
  91                  */
  92                 module_unload(ldlinux);
  93                 goto again;
  94         }
  95
  96         return rv;
  97 }
  98
  99 /* note to self: do _*NOT*_ use static key word on this function */
 100 void load_env32(com32sys_t * regs __unused)
 101 {
 102         struct file_info *fp;
 103         int fd;
 104         char *argv[] = { LDLINUX, NULL };
 105         char realname[FILENAME_MAX];
 106         size_t size;
 107
 108         static const char *search_directories[] = {
 109                 "/boot/isolinux",
 110                 "/isolinux",
 111                 "/boot/syslinux",
 112                 "/syslinux",
 113                 "/",
 114                 NULL
 115         };
 116
 117         static const char *filenames[] = {
 118                 LDLINUX,
 119                 NULL
 120         };
 121
 122         dprintf("Starting %s elf module subsystem...\n", ELF_MOD_SYS);
 123
 124         if (strlen(CurrentDirName) && !path_add(CurrentDirName)) {
 125                 printf("Couldn't allocate memory for PATH\n");
 126                 goto out;
 127         }
 128
 129         size = (size_t)__dynstr_end - (size_t)__dynstr_start;
 130         core_module.strtable_size = size;
 131         size = (size_t)__dynsym_end - (size_t)__dynsym_start;
 132         core_module.symtable_size = size;
 133         core_module.base_addr = (Elf_Addr)__module_start;
 134
 135         init_module_subsystem(&core_module);
 136
 137         start_ldlinux(1, argv);
 138
 139         /*
 140          * If we failed to load LDLINUX it could be because our
 141          * current working directory isn't the install directory. Try
 142          * a bit harder to find LDLINUX. If search_dirs() succeeds
 143          * in finding LDLINUX it will set the cwd.
 144          */
 145         fd = opendev(&__file_dev, NULL, O_RDONLY);
 146         if (fd < 0)
 147                 goto out;
 148
 149         fp = &__file_info[fd];
 150
 151         if (!search_dirs(&fp->i.fd, search_directories, filenames, realname)) {
 152                 char path[FILENAME_MAX];
 153
 154                 /*
 155                  * search_dirs() sets the current working directory if
 156                  * it successfully opens the file. Add the directory
 157                  * in which we found ldlinux.* to PATH.
 158                  */
 159                 if (!core_getcwd(path, sizeof(path)))
 160                         goto out;
 161
 162                 if (!path_add(path)) {
 163                         printf("Couldn't allocate memory for PATH\n");
 164                         goto out;
 165                 }
 166
 167                 start_ldlinux(1, argv);
 168         }
 169
 170 out:
 171         writestr("\nFailed to load ");
 172         writestr(LDLINUX);
 173 }
 174
 175 static const char *__cmdline;
 176 __export const char *com32_cmdline(void)
 177 {
 178         return __cmdline;
 179 }
 180
 181 __export int create_args_and_load(char *cmdline)
 182 {
 183         char *p, **argv;
 184         int argc;
 185         int i;
 186
 187         if (!cmdline)
 188                 return -1;
 189
 190         for (argc = 0, p = cmdline; *p; argc++) {
 191                 /* Find the end of this arg */
 192                 while(*p && !isspace(*p))
 193                         p++;
 194
 195                 /*
 196                  * Now skip all whitespace between arguments.
 197                  */
 198                 while (*p && isspace(*p))
 199                         p++;
 200         }
 201
 202         /*
 203          * Generate a copy of argv on the stack as this is
 204          * traditionally where process arguments go.
 205          *
 206          * argv[0] must be the command name. Remember to allocate
 207          * space for the sentinel NULL.
 208          */
 209         argv = alloca((argc + 1) * sizeof(char *));
 210
 211         for (i = 0, p = cmdline; i < argc; i++) {
 212                 char *start;
 213                 int len = 0;
 214
 215                 start = p;
 216
 217                 /* Find the end of this arg */
 218                 while(*p && !isspace(*p)) {
 219                         p++;
 220                         len++;
 221                 }
 222
 223                 argv[i] = malloc(len + 1);
 224                 strncpy(argv[i], start, len);
 225                 argv[i][len] = '\0';
 226
 227                 /*
 228                  * Now skip all whitespace between arguments.
 229                  */
 230                 while (*p && isspace(*p))
 231                         p++;
 232
 233                 /*
 234                  * Point __cmdline at "argv[1] ... argv[argc-1]"
 235                  */
 236                 if (i == 0)
 237                         __cmdline = p;
 238         }
 239
 240         /* NUL-terminate */
 241         argv[argc] = NULL;
 242
 243         return spawn_load(argv[0], argc, argv);
 244 }
 245
 246 void pm_env32_run(com32sys_t *regs)
 247 {
 248         char *cmdline;
 249
 250         cmdline = MK_PTR(regs->es, regs->ebx.w[0]);
 251         if (create_args_and_load(cmdline) < 0)
 252                 printf("Failed to run com32 module\n");
 253 }