com32/elflink/ldlinux/ldlinux.c

   1 #include <linux/list.h>
   2 #include <sys/times.h>
   3 #include <fcntl.h>
   4 #include <stdbool.h>
   5 #include <string.h>
   6 #include <core.h>
   7 #include <fs.h>
   8 #include "cli.h"
   9 #include "console.h"
  10 #include "com32.h"
  11 #include "menu.h"
  12 #include "config.h"
  13 #include "syslinux/adv.h"
  14 #include "syslinux/boot.h"
  15
  16 #include <sys/module.h>
  17
  18 struct file_ext {
  19         const char *name;
  20         enum kernel_type type;
  21 };
  22
  23 static const struct file_ext file_extensions[] = {
  24         { ".com", IMAGE_TYPE_COMBOOT },
  25         { ".cbt", IMAGE_TYPE_COMBOOT },
  26         { ".c32", IMAGE_TYPE_COM32 },
  27         { ".img", IMAGE_TYPE_FDIMAGE },
  28         { ".bss", IMAGE_TYPE_BSS },
  29         { ".bin", IMAGE_TYPE_BOOT },
  30         { ".bs", IMAGE_TYPE_BOOT },
  31         { ".0", IMAGE_TYPE_PXE },
  32         { NULL, 0 },
  33 };
  34
  35 /*
  36  * Return a pointer to one byte after the last character of the
  37  * command.
  38  */
  39 static inline const char *find_command(const char *str)
  40 {
  41         const char *p;
  42
  43         p = str;
  44         while (*p && !my_isspace(*p))
  45                 p++;
  46         return p;
  47 }
  48
  49 uint32_t parse_image_type(const char *kernel)
  50 {
  51         const struct file_ext *ext;
  52         const char *p;
  53         int len;
  54
  55         /* Find the end of the command */
  56         p = find_command(kernel);
  57         len = p - kernel;
  58
  59         for (ext = file_extensions; ext->name; ext++) {
  60                 int elen = strlen(ext->name);
  61
  62                 if (!strncmp(kernel + len - elen, ext->name, elen))
  63                         return ext->type;
  64         }
  65
  66         /* use IMAGE_TYPE_KERNEL as default */
  67         return IMAGE_TYPE_KERNEL;
  68 }
  69
  70 /*
  71  * Returns the kernel name with file extension if one wasn't present.
  72  */
  73 static const char *get_extension(const char *kernel)
  74 {
  75         const struct file_ext *ext;
  76         const char *p;
  77         int len;
  78
  79         /* Find the end of the command */
  80         p = find_command(kernel);
  81         len = p - kernel;
  82
  83         for (ext = file_extensions; ext->name; ext++) {
  84                 char *str;
  85                 int elen = strlen(ext->name);
  86                 int fd;
  87
  88                 str = malloc(len + elen + 1);
  89
  90                 strncpy(str, kernel, len);
  91                 strncpy(str + len, ext->name, elen);
  92                 str[len + elen] = '\0';
  93
  94                 fd = searchdir(str);
  95                 free(str);
  96
  97                 if (fd >= 0)
  98                         return ext->name;
  99         }
 100
 101         return NULL;
 102 }
 103
 104 static const char *apply_extension(const char *kernel, const char *ext)
 105 {
 106         const char *p;
 107         char *k;
 108         int len = strlen(kernel);
 109         int elen = strlen(ext);
 110
 111         k = malloc(len + elen + 1);
 112         if (!k)
 113                 return NULL;
 114
 115         p = find_command(kernel);
 116
 117         len = p - kernel;
 118
 119         /* Copy just the kernel name */
 120         memcpy(k, kernel, len);
 121
 122         /* Append the extension */
 123         memcpy(k + len, ext, elen);
 124
 125         /* Copy the rest of the command line */
 126         strcpy(k + len + elen, p);
 127
 128         k[len + elen + strlen(p)] = '\0';
 129
 130         return k;
 131 }
 132
 133 /*
 134  * Attempt to load a kernel after deciding what type of image it is.
 135  *
 136  * We only return from this function if something went wrong loading
 137  * the the kernel. If we return the caller should call enter_cmdline()
 138  * so that the user can help us out.
 139  */
 140 void load_kernel(const char *command_line)
 141 {
 142         struct menu_entry *me;
 143         const char *cmdline;
 144         const char *kernel;
 145         uint32_t type;
 146
 147         kernel = strdup(command_line);
 148         if (!kernel)
 149                 goto bad_kernel;
 150
 151         /* Virtual kernel? */
 152         me = find_label(kernel);
 153         if (me) {
 154                 type = parse_image_type(me->cmdline);
 155
 156                 execute(me->cmdline, type);
 157                 /* We shouldn't return */
 158                 goto bad_kernel;
 159         }
 160
 161         if (!allowimplicit)
 162                 goto bad_implicit;
 163
 164         /* Insert a null character to ignore any user-specified options */
 165         if (!allowoptions) {
 166                 char *p = (char *)find_command(kernel);
 167                 *p = '\0';
 168         }
 169
 170         type = parse_image_type(kernel);
 171         if (type == IMAGE_TYPE_KERNEL) {
 172                 const char *ext;
 173
 174                 /*
 175                  * Automatically lookup the extension if one wasn't
 176                  * supplied by the user.
 177                  */
 178                 ext = get_extension(kernel);
 179                 if (ext) {
 180                         const char *k;
 181
 182                         k = apply_extension(kernel, ext);
 183                         if (!k)
 184                                 goto bad_kernel;
 185
 186                         free((void *)kernel);
 187                         kernel = k;
 188
 189                         type = parse_image_type(kernel);
 190                 }
 191         }
 192
 193         execute(kernel, type);
 194         free((void *)kernel);
 195
 196 bad_implicit:
 197 bad_kernel:
 198         /*
 199          * If we fail to boot the kernel execute the "onerror" command
 200          * line.
 201          */
 202         if (onerrorlen) {
 203                 rsprintf(&cmdline, "%s %s", onerror, default_cmd);
 204                 execute(cmdline, IMAGE_TYPE_COM32);
 205         }
 206 }
 207
 208 static void enter_cmdline(void)
 209 {
 210         const char *cmdline;
 211
 212         /* Enter endless command line prompt, should support "exit" */
 213         while (1) {
 214                 cmdline = edit_cmdline("boot:", 1, NULL, cat_help_file);
 215                 printf("\n");
 216
 217                 /* return if user only press enter or we timed out */
 218                 if (!cmdline || cmdline[0] == '\0')
 219                         return;
 220
 221                 load_kernel(cmdline);
 222         }
 223 }
 224
 225 int main(int argc __unused, char **argv __unused)
 226 {
 227         const void *adv;
 228         const char *cmdline;
 229         size_t count = 0;
 230         char *config_argv[2] = { NULL, NULL };
 231
 232         openconsole(&dev_rawcon_r, &dev_ansiserial_w);
 233
 234         if (ConfigName[0])
 235                 config_argv[0] = ConfigName;
 236
 237         parse_configs(config_argv);
 238
 239         adv = syslinux_getadv(ADV_BOOTONCE, &count);
 240         if (adv && count) {
 241                 /*
 242                  * We apparently have a boot-once set; clear it and
 243                  * then execute the boot-once.
 244                  */
 245                 char *src, *dst;
 246                 size_t i;
 247
 248                 src = (char *)adv;
 249                 cmdline = dst = malloc(count + 1);
 250                 if (!dst) {
 251                         printf("Failed to allocate memory for ADV\n");
 252                         goto cmdline;
 253                 }
 254
 255                 for (i = 0; i < count; i++)
 256                         *dst++ = *src++;
 257                 *dst = '\0';    /* Null-terminate */
 258
 259                 /* Clear the boot-once data from the ADV */
 260                 if (!syslinux_setadv(ADV_BOOTONCE, 0, NULL))
 261                         syslinux_adv_write();
 262
 263                 load_kernel(cmdline); /* Shouldn't return */
 264                 goto cmdline;
 265         }
 266
 267         /* TODO: Check KbdFlags? */
 268
 269         if (forceprompt)
 270                 goto cmdline;
 271
 272         cmdline = default_cmd;
 273 auto_boot:
 274         /*
 275          * Auto boot
 276          */
 277         if (defaultlevel || noescape) {
 278                 if (defaultlevel) {
 279                         load_kernel(cmdline); /* Shouldn't return */
 280                 } else {
 281                         printf("No DEFAULT or UI configuration directive found!\n");
 282
 283                         if (noescape)
 284                                 kaboom();
 285                 }
 286         }
 287
 288 cmdline:
 289         /* Only returns if the user pressed enter or input timed out */
 290         enter_cmdline();
 291
 292         cmdline = ontimeoutlen ? ontimeout : default_cmd;
 293
 294         goto auto_boot;
 295
 296         return 0;
 297 }