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