com32/lua/src/syslinux.c

   1 /* ----------------------------------------------------------------------- *
   2  *
   3  *   Copyright 2007-2008 H. Peter Anvin - All Rights Reserved
   4  *
   5  *   Permission is hereby granted, free of charge, to any person
   6  *   obtaining a copy of this software and associated documentation
   7  *   files (the "Software"), to deal in the Software without
   8  *   restriction, including without limitation the rights to use,
   9  *   copy, modify, merge, publish, distribute, sublicense, and/or
  10  *   sell copies of the Software, and to permit persons to whom
  11  *   the Software is furnished to do so, subject to the following
  12  *   conditions:
  13  *
  14  *   The above copyright notice and this permission notice shall
  15  *   be included in all copies or substantial portions of the Software.
  16  *
  17  *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  18  *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
  19  *   OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  20  *   NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  21  *   HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  22  *   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  23  *   FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  24  *   OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  * ----------------------------------------------------------------------- */
  27
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <unistd.h>
  31 #include <syslinux/boot.h>
  32
  33 #define lnetlib_c               /* Define the library */
  34
  35 #include "lua.h"
  36 #include "lauxlib.h"
  37 #include "lualib.h"
  38 #include "syslinux/boot.h"
  39 #include "syslinux/loadfile.h"
  40 #include "syslinux/linux.h"
  41 #include "syslinux/config.h"
  42 #include "syslinux/reboot.h"
  43
  44 int __parse_argv(char ***argv, const char *str);
  45
  46 #define SYSLINUX_FILE "syslinux_file"
  47
  48 typedef struct syslinux_file {
  49     char *data;
  50     char *name;
  51     size_t size;
  52 } syslinux_file;
  53
  54 /*
  55  * Most code taken from:
  56  *      com32/modules/linux.c
  57  */
  58
  59 /* Find the last instance of a particular command line argument
  60    (which should include the final =; do not use for boolean arguments) */
  61 static char *find_argument(char **argv, const char *argument)
  62 {
  63     int la = strlen(argument);
  64     char **arg;
  65     char *ptr = NULL;
  66
  67     for (arg = argv; *arg; arg++) {
  68         if (!memcmp(*arg, argument, la))
  69             ptr = *arg + la;
  70     }
  71
  72     return ptr;
  73 }
  74
  75 /* Get a value with a potential suffix (k/m/g/t/p/e) */
  76 static unsigned long long suffix_number(const char *str)
  77 {
  78     char *ep;
  79     unsigned long long v;
  80     int shift;
  81
  82     v = strtoull(str, &ep, 0);
  83     switch (*ep | 0x20) {
  84     case 'k':
  85         shift = 10;
  86         break;
  87     case 'm':
  88         shift = 20;
  89         break;
  90     case 'g':
  91         shift = 30;
  92         break;
  93     case 't':
  94         shift = 40;
  95         break;
  96     case 'p':
  97         shift = 50;
  98         break;
  99     case 'e':
 100         shift = 60;
 101         break;
 102     default:
 103         shift = 0;
 104         break;
 105     }
 106     v <<= shift;
 107
 108     return v;
 109 }
 110
 111 /* Truncate to 32 bits, with saturate */
 112 static inline uint32_t saturate32(unsigned long long v)
 113 {
 114     return (v > 0xffffffff) ? 0xffffffff : (uint32_t) v;
 115 }
 116
 117 /* Stitch together the command line from a set of argv's */
 118 static char *make_cmdline(char **argv)
 119 {
 120     char **arg;
 121     size_t bytes;
 122     char *cmdline, *p;
 123
 124     bytes = 1;                  /* Just in case we have a zero-entry cmdline */
 125     for (arg = argv; *arg; arg++) {
 126         bytes += strlen(*arg) + 1;
 127     }
 128
 129     p = cmdline = malloc(bytes);
 130     if (!cmdline)
 131         return NULL;
 132
 133     for (arg = argv; *arg; arg++) {
 134         int len = strlen(*arg);
 135         memcpy(p, *arg, len);
 136         p[len] = ' ';
 137         p += len + 1;
 138     }
 139
 140     if (p > cmdline)
 141         p--;                    /* Remove the last space */
 142     *p = '\0';
 143
 144     return cmdline;
 145 }
 146
 147 static int sl_run_command(lua_State * L)
 148 {
 149     const char *cmd = luaL_checkstring(L, 1);   /* Reads the string parameter */
 150     syslinux_run_command(cmd);
 151     return 0;
 152 }
 153
 154 /* do default boot */
 155 static int sl_run_default(lua_State * L)
 156 {
 157     /* Preventing GCC to complain against unused L */
 158     L=L;
 159     syslinux_run_default();
 160     return 0;
 161 }
 162
 163 /* do local boot */
 164 static int sl_local_boot(lua_State * L)
 165 {
 166     uint16_t flags = luaL_checkint(L, 1);
 167     syslinux_local_boot(flags);
 168     return 0;
 169 }
 170
 171 static int sl_final_cleanup(lua_State * L)
 172 {
 173     uint16_t flags = luaL_checkint(L, 1);
 174     syslinux_local_boot(flags);
 175     return 0;
 176 }
 177
 178 /* boot linux kernel and initrd */
 179 static int sl_boot_linux(lua_State * L)
 180 {
 181     const char *kernel = luaL_checkstring(L, 1);
 182     const char *cmdline = luaL_optstring(L, 2, "");
 183     char *initrd;
 184     void *kernel_data, *file_data;
 185     size_t kernel_len, file_len;
 186     struct initramfs *initramfs;
 187     char *newcmdline;
 188     uint32_t mem_limit = luaL_optint(L, 3, 0);
 189     uint16_t video_mode = luaL_optint(L, 4, 0);
 190 //  int ret, i;
 191     int ret;
 192     char **argv, **argp, *arg, *p;
 193
 194     (void)mem_limit;
 195     (void)video_mode;
 196
 197     ret = __parse_argv(&argv, cmdline);
 198
 199     newcmdline = malloc(strlen(kernel) + 12);
 200     if (!newcmdline)
 201         printf("Mem alloc failed: cmdline\n");
 202
 203     strcpy(newcmdline, "BOOT_IMAGE=");
 204     strcpy(newcmdline + strlen(newcmdline), kernel);
 205     argv[0] = newcmdline;
 206     argp = argv;
 207
 208     /* DEBUG
 209        for (i=0; i<ret; i++)
 210        printf("%d: %s\n", i, argv[i]);
 211      */
 212
 213     newcmdline = make_cmdline(argp);
 214     if (!newcmdline)
 215         printf("Creating command line failed!\n");
 216
 217     /* DEBUG
 218        printf("Command line: %s\n", newcmdline);
 219        msleep(1000);
 220      */
 221
 222     /* Look for specific command-line arguments we care about */
 223     if ((arg = find_argument(argp, "mem=")))
 224         mem_limit = saturate32(suffix_number(arg));
 225
 226     if ((arg = find_argument(argp, "vga="))) {
 227         switch (arg[0] | 0x20) {
 228         case 'a':               /* "ask" */
 229             video_mode = 0xfffd;
 230             break;
 231         case 'e':               /* "ext" */
 232             video_mode = 0xfffe;
 233             break;
 234         case 'n':               /* "normal" */
 235             video_mode = 0xffff;
 236             break;
 237         default:
 238             video_mode = strtoul(arg, NULL, 0);
 239             break;
 240         }
 241     }
 242
 243     printf("Loading kernel %s...\n", kernel);
 244     if (loadfile(kernel, &kernel_data, &kernel_len))
 245         printf("failed!\n");
 246     else
 247         printf("ok\n");
 248
 249     initramfs = initramfs_init();
 250     if (!initramfs)
 251         printf("Initializing initrd failed!\n");
 252
 253     if ((arg = find_argument(argp, "initrd="))) {
 254         do {
 255             p = strchr(arg, ',');
 256             if (p)
 257                 *p = '\0';
 258
 259             initrd = arg;
 260             printf("Loading initrd %s... ", initrd);
 261             if (initramfs_load_archive(initramfs, initrd)) {
 262                 printf("failed!\n");
 263             }
 264             printf("ok\n");
 265
 266             if (p)
 267                 *p++ = ',';
 268         } while ((arg = p));
 269     }
 270
 271     if (!loadfile("/testfile1", &file_data, &file_len)) {
 272         if (initramfs_add_file(initramfs, file_data, file_len, file_len,
 273                                "/testfile1", 0, 0755))
 274             printf("Adding extra file failed\n");
 275     } else
 276         printf("Loading extra file failed\n");
 277
 278     /* DEBUG
 279        msleep(10000);
 280      */
 281
 282     ret = syslinux_boot_linux(kernel_data, kernel_len, initramfs, NULL, newcmdline);
 283
 284     printf("syslinux_boot_linux returned %d\n", ret);
 285
 286     return 0;
 287 }
 288
 289 /* sleep for sec seconds */
 290 static int sl_sleep(lua_State * L)
 291 {
 292     unsigned int sec = luaL_checkint(L, 1);
 293     sleep(sec);
 294     return 0;
 295 }
 296
 297 /* sleep for msec milliseconds */
 298 static int sl_msleep(lua_State * L)
 299 {
 300     unsigned int msec = luaL_checkint(L, 1);
 301     msleep(msec);
 302     return 0;
 303 }
 304
 305 static int sl_run_kernel_image(lua_State * L)
 306 {
 307     const char *filename = luaL_checkstring(L, 1);
 308     const char *cmdline = luaL_checkstring(L, 2);
 309     uint32_t ipappend_flags = luaL_checkint(L, 3);
 310     uint32_t type = luaL_checkint(L, 4);
 311
 312     syslinux_run_kernel_image(filename, cmdline, ipappend_flags, type);
 313     return 0;
 314 }
 315
 316 static int sl_loadfile(lua_State * L)
 317 {
 318     const char *filename = luaL_checkstring(L, 1);
 319     syslinux_file *file;
 320
 321     void *file_data;
 322     size_t file_len;
 323
 324     if (loadfile(filename, &file_data, &file_len)) {
 325         lua_pushstring(L, "Could not load file");
 326         lua_error(L);
 327     }
 328
 329     file = malloc(sizeof(syslinux_file));
 330     strlcpy(file->name,filename,sizeof(syslinux_file));
 331     file->size = file_len;
 332     file->data = file_data;
 333
 334     lua_pushlightuserdata(L, file);
 335     luaL_getmetatable(L, SYSLINUX_FILE);
 336     lua_setmetatable(L, -2);
 337
 338     return 1;
 339 }
 340
 341 static int sl_filesize(lua_State * L)
 342 {
 343     const syslinux_file *file = luaL_checkudata(L, 1, SYSLINUX_FILE);
 344
 345     lua_pushinteger(L, file->size);
 346
 347     return 1;
 348 }
 349
 350 static int sl_filename(lua_State * L)
 351 {
 352     const syslinux_file *file = luaL_checkudata(L, 1, SYSLINUX_FILE);
 353
 354     lua_pushstring(L, file->name);
 355
 356     return 1;
 357 }
 358
 359 static int sl_initramfs_init(lua_State * L)
 360 {
 361     struct initramfs *initramfs;
 362
 363     initramfs = initramfs_init();
 364     if (!initramfs)
 365         printf("Initializing initrd failed!\n");
 366
 367     lua_pushlightuserdata(L, initramfs);
 368     luaL_getmetatable(L, SYSLINUX_FILE);
 369     lua_setmetatable(L, -2);
 370
 371     return 1;
 372 }
 373
 374 static int sl_initramfs_load_archive(lua_State * L)
 375 {
 376     struct initramfs *initramfs = luaL_checkudata(L, 1, SYSLINUX_FILE);
 377     const char *filename = luaL_checkstring(L, 2);
 378
 379     if (initramfs_load_archive(initramfs, filename)) {
 380         printf("failed!\n");
 381     }
 382
 383     return 0;
 384 }
 385
 386 static int sl_initramfs_add_file(lua_State * L)
 387 {
 388     struct initramfs *initramfs = luaL_checkudata(L, 1, SYSLINUX_FILE);
 389     /* FIXME: This code is doing nothing */
 390     //const char *filename = luaL_checkstring(L, 2);
 391     void *file_data = NULL;
 392     size_t file_len = 0;
 393
 394     return initramfs_add_file(initramfs, file_data, file_len, file_len, "/testfile1", 0, 0755);
 395 }
 396
 397 static int sl_boot_it(lua_State * L)
 398 {
 399     const syslinux_file *kernel = luaL_checkudata(L, 1, SYSLINUX_FILE);
 400     struct initramfs *initramfs = luaL_checkudata(L, 2, SYSLINUX_FILE);
 401     const char *cmdline = luaL_optstring(L, 3, "");
 402     uint32_t mem_limit = luaL_optint(L, 4, 0);
 403     uint16_t video_mode = luaL_optint(L, 5, 0);
 404     /* Preventing gcc to complain about unused variables */
 405     (void)video_mode;
 406     (void)mem_limit;
 407
 408     return syslinux_boot_linux(kernel->data, kernel->size,
 409                                initramfs, NULL, (char *)cmdline);
 410 }
 411
 412 static int sl_config_file(lua_State * L)
 413 {
 414     const char *config_file = syslinux_config_file();
 415     lua_pushstring(L, config_file);
 416     return 1;
 417 }
 418
 419 static int sl_reboot(lua_State * L)
 420 {
 421     int warm_boot = luaL_optint(L, 1, 0);
 422     /* explicitly convert it to 1 or 0 */
 423     warm_boot = warm_boot? 1 : 0;
 424     syslinux_reboot(warm_boot);
 425     return 0;
 426 }
 427
 428 static int sl_ipappend_strs(lua_State * L)
 429 {
 430     int i;
 431     const struct syslinux_ipappend_strings *ip_strs = syslinux_ipappend_strings();
 432     lua_newtable(L);
 433     for (i = 0; i < ip_strs->count; i++) {
 434         lua_pushinteger(L, i + 1);
 435         lua_pushstring(L, ip_strs->ptr[i]);
 436         lua_settable(L,-3);
 437     }
 438     return 1;
 439 }
 440
 441 static int sl_derivative(lua_State * L)
 442 {
 443     const struct syslinux_version *sv;
 444
 445     sv = syslinux_version();
 446
 447     switch (sv->filesystem) {
 448     case SYSLINUX_FS_SYSLINUX:
 449         lua_pushstring(L, "SYSLINUX");
 450         break;
 451     case SYSLINUX_FS_PXELINUX:
 452         lua_pushstring(L, "PXELINUX");
 453         break;
 454     case SYSLINUX_FS_ISOLINUX:
 455         lua_pushstring(L, "ISOLINUX");
 456         break;
 457     case SYSLINUX_FS_UNKNOWN:
 458     default:
 459         lua_pushstring(L, "Unknown Syslinux derivative");
 460         break;
 461     }
 462
 463     return 1;
 464 }
 465
 466 static int sl_version(lua_State * L)
 467 {
 468     const struct syslinux_version *sv;
 469
 470     sv = syslinux_version();
 471     lua_pushstring(L, sv->version_string);
 472
 473     return 1;
 474 }
 475
 476 static const luaL_reg syslinuxlib[] = {
 477     {"run_command", sl_run_command},
 478     {"run_default", sl_run_default},
 479     {"local_boot", sl_local_boot},
 480     {"final_cleanup", sl_final_cleanup},
 481     {"boot_linux", sl_boot_linux},
 482     {"run_kernel_image", sl_run_kernel_image},
 483     {"sleep", sl_sleep},
 484     {"msleep", sl_msleep},
 485     {"loadfile", sl_loadfile},
 486     {"filesize", sl_filesize},
 487     {"filename", sl_filename},
 488     {"initramfs_init", sl_initramfs_init},
 489     {"initramfs_load_archive", sl_initramfs_load_archive},
 490     {"initramfs_add_file", sl_initramfs_add_file},
 491     {"boot_it", sl_boot_it},
 492     {"config_file", sl_config_file},
 493     {"ipappend_strs", sl_ipappend_strs},
 494     {"reboot", sl_reboot},
 495     {"derivative", sl_derivative},
 496     {"version", sl_version},
 497     {NULL, NULL}
 498 };
 499
 500 /* This defines a function that opens up your library. */
 501
 502 LUALIB_API int luaopen_syslinux(lua_State * L)
 503 {
 504
 505     luaL_newmetatable(L, SYSLINUX_FILE);
 506
 507     luaL_openlib(L, LUA_SYSLINUXLIBNAME, syslinuxlib, 0);
 508     return 1;
 509 }