int main(int argc, char *argv[])
{
FILE *f;
int ch;
int i;
openconsole(&dev_stdcon_r, &dev_stdcon_w);
printf("argv = %p\n", argv);
for (i = 0; i <= argc; i++)
printf("argv[%d] = %p = \"%s\"\n", i, argv[i], argv[i]);
if (argc < 2) {
fprintf(stderr, "Missing file name!\n");
exit(1);
}
printf("File = %s\n", argv[1]);
f = fopen(argv[1], "r");
while ((ch = getc(f)) != EOF)
putchar(ch);
fclose(f);
return 0;
}
int main(void)
{
const union syslinux_derivative_info *di;
const struct stack_frame *sf;
openconsole(&dev_null_r, &dev_stdcon_w);
di = syslinux_derivative_info();
if (di->c.filesystem != SYSLINUX_FS_PXELINUX) {
printf("Not running under PXELINUX (fs = %02x)\n", di->c.filesystem);
return 1;
}
sf = (const struct stack_frame *)di->pxe.stack;
printf("EAX: %08x EBX: %08x ECX: %08x EDX: %08x\n"
"ESP: %08x EBP: %08x ESI: %08x EDI: %08x\n"
"SS: %04x DS: %04x ES: %04x FS: %04x GS: %04x\n"
"EFLAGS: %08x RET: %04x:%04x PXE: %04x:%04x\n",
sf->eax, sf->ebx, sf->ecx, sf->edx,
sf->esp+4, sf->ebp, sf->esi, sf->edi,
di->rr.r.fs, sf->ds, sf->es, sf->fs, sf->gs,
sf->eflags, sf->ret_cs, sf->ret_ip, sf->pxe_cs, sf->pxe_ip);
return 0;
}
int main(int argc, char *argv[])
{
const struct syslinux_keyboard_map * const kmap = syslinux_keyboard_map();
size_t map_size;
void *kbdmap;
openconsole(&dev_null_r, &dev_stdcon_w);
if (argc != 2) {
error("Usage: kbdmap mapfile\n");
return 1;
}
if (kmap->version != 1) {
error("Syslinux core version mismatch\n");
return 1;
}
if (loadfile(argv[1], &kbdmap, &map_size)) {
error("Keyboard map file load error\n");
return 1;
}
if (map_size != kmap->length) {
error("Keyboard map file format error\n");
return 1;
}
memcpy(kmap->map, kbdmap, map_size);
return 0;
}
static void openconsole (void)
{
if (realconsole) {
if (debugger_type == 2) {
open_debug_window ();
consoleopen = 1;
} else {
close_debug_window ();
consoleopen = -1;
}
return;
}
if (debugger_active && (debugger_type < 0 || debugger_type == 2)) {
if (consoleopen > 0 || debuggerinitializing)
return;
if (debugger_type < 0) {
regqueryint (NULL, _T("DebuggerType"), &debugger_type);
if (debugger_type <= 0)
debugger_type = 2;
openconsole();
return;
}
close_console ();
if (open_debug_window ()) {
consoleopen = 1;
return;
}
open_console_window ();
} else {
if (consoleopen < 0)
return;
close_console ();
open_console_window ();
}
}
int main(int argc, char *argv[])
{
uint32_t leaf, counter;
uint32_t eax, ebx, ecx, edx;
openconsole(&dev_null_r, &dev_stdcon_w);
if (argc < 2 || argc > 4) {
printf("Usage: %s leaf [counter]\n", argv[0]);
exit(1);
}
leaf = strtoul(argv[1], NULL, 0);
counter = (argv > 2) ? strtoul(argv[2], NULL, 0) : 0;
if (!cpu_has_eflag(EFLAGS_ID)) {
printf("The CPUID instruction is not supported\n");
exit(1);
}
cpuid_count(leaf, counter, &eax, &ebx, &ecx, &edx);
dump_reg("eax", eax);
dump_reg("ebx", ebx);
dump_reg("ecx", ecx);
dump_reg("edx", edx);
return 0;
}
OS::OS(void): ent(0), hostname(NULL)
{
/* Ensure console drains before opening */
lib::udelay(100000);
openconsole(&dev_rawcon_r, &dev_stdcon_w);
get_hostname();
}
static int vesa_setmode(lua_State *L)
{
/* Preventing GCC to complain about unused L*/
L=L;
openconsole(&dev_rawcon_r, &dev_vesaserial_w);
return 0;
}
int main(void)
{
openconsole(&dev_null_r, &dev_stdcon_w);
dump_legacy();
dump_e820();
return 0;
}
static void console_put (const TCHAR *buffer)
{
if (console_buffer) {
if (_tcslen (console_buffer) + _tcslen (buffer) < console_buffer_size)
_tcscat (console_buffer, buffer);
} else {
openconsole ();
writeconsole (buffer);
}
}
void debugger_change (int mode)
{
if (mode < 0)
debugger_type = debugger_type == 2 ? 1 : 2;
else
debugger_type = mode;
if (debugger_type != 1 && debugger_type != 2)
debugger_type = 2;
regsetint (NULL, _T("DebuggerType"), debugger_type);
openconsole ();
}
void console_out (const char *format,...)
{
va_list parms;
char buffer[WRITE_LOG_BUF_SIZE];
DWORD temp;
va_start (parms, format);
_vsnprintf (buffer, WRITE_LOG_BUF_SIZE - 1, format, parms);
va_end (parms);
openconsole ();
WriteConsole (stdoutput, buffer, strlen (buffer), &temp, 0);
}
void f_out (void *f, const TCHAR *format, ...)
{
int count;
TCHAR buffer[WRITE_LOG_BUF_SIZE];
va_list parms;
va_start (parms, format);
if (f == NULL)
return;
count = _vsntprintf (buffer, WRITE_LOG_BUF_SIZE - 1, format, parms);
openconsole ();
writeconsole (buffer);
va_end (parms);
}
int main(int argc, char *argv[])
{
openconsole(&dev_null_r, &dev_stdcon_w);
if (argc < 2 || argc > 3) {
fprintf(stderr, "Usage: config <filename> [<directory>]\n");
return 1;
}
syslinux_run_kernel_image(argv[1], argv[2] ? argv[2] : "",
0, IMAGE_TYPE_CONFIG);
fprintf(stderr, "config: %s: failed to load (missing file?)\n", argv[1]);
return 1;
}
int main(void)
{
uint8_t *p, *ep;
size_t s = syslinux_adv_size();
char buf[256];
#if 0
/* this hangs! */
openconsole(&dev_stdcon_r, &dev_stdcon_w);
#else
/* this works */
openconsole(&dev_rawcon_r, &dev_ansiserial_w);
#endif
p = syslinux_adv_ptr();
printf("ADV size: %zd bytes at %p\n", s, p);
ep = p + s; /* Need at least opcode+len */
while (p < ep - 1 && *p) {
int t = *p++;
int l = *p++;
if (p + l > ep)
break;
memcpy(buf, p, l);
buf[l] = '\0';
printf("ADV %3d: \"%s\"\n", t, buf);
p += l;
}
return 0;
}
static void writeconsole_2 (const TCHAR *buffer)
{
DWORD temp;
if (!consoleopen)
openconsole ();
if (consoleopen > 0) {
WriteOutput (buffer, _tcslen (buffer));
} else if (realconsole) {
fputws (buffer, stdout);
fflush (stdout);
} else if (consoleopen < 0) {
WriteConsole (stdoutput, buffer, _tcslen (buffer), &temp, 0);
}
}
void f_out (void *f, const char *format, ...)
{
int count;
DWORD numwritten;
char buffer[WRITE_LOG_BUF_SIZE];
va_list parms;
va_start (parms, format);
count = _vsnprintf (buffer, WRITE_LOG_BUF_SIZE - 1, format, parms);
if (f == 0)
write_log (buffer);
else {
openconsole ();
WriteConsole (stdoutput, buffer, strlen (buffer), &numwritten, 0);
va_end (parms);
}
}
void write_log (const char *format, ...)
{
int count;
DWORD numwritten;
char buffer[WRITE_LOG_BUF_SIZE];
va_list parms;
va_start (parms, format);
count = _vsnprintf (buffer, WRITE_LOG_BUF_SIZE - 1, format, parms);
if (SHOW_CONSOLE || console_logging) {
openconsole ();
WriteConsole (stdoutput, buffer, strlen(buffer), &numwritten, 0);
}
if (debugfile) {
fprintf (debugfile, buffer);
fflush (debugfile);
}
va_end (parms);
}
int main(void)
{
s_dmi dmi;
openconsole(&dev_stdcon_r, &dev_stdcon_w);
if (dmi_iterate(&dmi) == -ENODMITABLE) {
printf("No DMI Structure found\n");
return -1;
}
parse_dmitable(&dmi);
moreprintf("productname: %s\n", dmi.system.product_name);
if (strncmp(dmi.system.product_name, "ProLiant ", 8) == 0) {
syslinux_run_kernel_image("pxelinux.cfg/proliant", "", 0, IMAGE_TYPE_CONFIG);
} else {
syslinux_run_kernel_image("pxelinux.cfg/menu", "", 0, IMAGE_TYPE_CONFIG);
}
return 0;
}
int main(int argc, const char *argv[])
{
openconsole(&dev_null_r, &dev_stdcon_w);
if (argc < 2) {
printf("Usage: sanboot rootpath\n");
return 1;
}
if (!is_gpxe()) {
printf("sanboot: gPXE API not detected\n");
return 1;
}
sanboot(argv + 1);
/* sanboot() should not return... */
printf("SAN boot failed.\n");
return 1;
}
int main(int argc, char *argv[])
{
struct driveinfo drive;
struct driveinfo *d = &drive;
(void)argc;
(void)argv;
openconsole(&dev_null_r, &dev_stdcon_w);
for (int disk = 0x80; disk < 0xff; disk++) {
memset(d, 0, sizeof(struct driveinfo));
d->disk = disk;
get_drive_parameters(d);
/* Do not print output when drive does not exists */
if (errno_disk == -1 || !d->cbios)
continue;
if (errno_disk) {
get_error("reading disk");
continue;
}
printf("DISK 0x%X:\n", d->disk);
printf(" C/H/S: %d heads, %d cylinders\n",
d->legacy_max_head + 1, d->legacy_max_cylinder + 1);
printf(" %d sectors/track, %d drives\n",
d->legacy_sectors_per_track, d->legacy_max_drive);
printf(" EDD: ebios=%d, EDD version: %X\n",
d->ebios, d->edd_version);
printf(" %d heads, %d cylinders\n",
(int) d->edd_params.heads, (int) d->edd_params.cylinders);
printf(" %d sectors, %d bytes/sector, %d sectors/track\n",
(int) d->edd_params.sectors, (int) d->edd_params.bytes_per_sector,
(int) d->edd_params.sectors_per_track);
printf(" Host bus: %s, Interface type: %s\n\n",
d->edd_params.host_bus_type, d->edd_params.interface_type);
}
return 0;
}
int main(int argc, char *argv[])
{
void *data;
size_t data_len;
openconsole(&dev_null_r, &dev_stdcon_w);
if (argc < 2) {
error("Usage: elf.c32 elf_file arguments...\n");
return 1;
}
if (zloadfile(argv[1], &data, &data_len)) {
error("Unable to load file\n");
return 1;
}
boot_elf(data, data_len, &argv[1]);
error("Invalid ELF file or insufficient memory\n");
return 1;
}
int main(int argc, char *argv[])
{
struct match *list, *match;
struct pci_domain *pci_domain;
openconsole(&dev_null_r, &dev_stdcon_w);
pci_domain = pci_scan();
if (pci_domain) {
list = parse_config(argc < 2 ? NULL : argv[1]);
match = find_pci_device(pci_domain, list);
if (match)
syslinux_run_command(match->filename);
}
/* On error, return to the command line */
fputs("Error: no recognized network card found!\n", stderr);
return 1;
}
int main(int argc, char *argv[])
{
void *data;
size_t data_len;
addr_t where;
openconsole(&dev_null_r, &dev_stdcon_w);
if (argc < 3) {
error("Usage: pmload.c32 bin_file address arguments...\n");
return 1;
}
where = strtoul(argv[2], NULL, 0);
if (loadfile(argv[1], &data, &data_len)) {
error("Unable to load file\n");
return 1;
}
boot_raw(data, data_len, where, &argv[1]);
error("Failed to boot, probably insufficient memory\n");
return 1;
}
int main(int argc, char *argv[])
{
openconsole(&dev_rawcon_r, &dev_vesaserial_w);
return menu_main(argc, argv);
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int main(int argc, char **argv)
{
int menu_index;
const union syslinux_derivative_info *sdi;
openconsole(&dev_stdcon_r, &dev_stdcon_w);
lowmem_buf = __com32.cs_bounce;
lowmem_buf_size = __com32.cs_bounce_size;
sdi = syslinux_derivative_info();
gfx_config.sector_shift = sdi->disk.sector_shift;
gfx_config.boot_drive = sdi->disk.drive_number;
if(sdi->c.filesystem == SYSLINUX_FS_PXELINUX) {
gfx_config.sector_shift = 11;
gfx_config.boot_drive = 0;
}
gfx_config.media_type = gfx_config.boot_drive < 0x80 ? 1 : 0;
if(sdi->c.filesystem == SYSLINUX_FS_ISOLINUX) {
gfx_config.media_type = sdi->iso.cd_mode ? 0 : 2;
}
gfx_config.bootloader = 1;
gfx_config.sysconfig_size = sizeof gfx_config;
gfx_config.bootloader_seg = 0; // apparently not needed
save_buf_size = lowmem_buf_size;
save_buf = malloc(save_buf_size);
if(argc < 2) {
printf("Usage: gfxboot.c32 bootlogo_file [message_file]\n");
if(argc > 2) show_message(argv[2]);
return 0;
}
if(read_config_file()) {
printf("Error reading config file\n");
if(argc > 2) show_message(argv[2]);
return 0;
}
if(gfx_init(argv[1])) {
printf("Error setting up gfxboot\n");
if(argc > 2) show_message(argv[2]);
return 0;
}
gfx_menu_init();
for(;;) {
menu_index = gfx_input();
// abort gfx, return to text mode prompt
if(menu_index == -1) {
gfx_done();
break;
}
// does not return if it succeeds
boot(menu_index);
}
if(argc > 2) show_message(argv[2]);
return 0;
}
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
int main(int argc, char **argv)
{
int menu_index;
const union syslinux_derivative_info *sdi;
char working_dir[256];
openconsole(&dev_stdcon_r, &dev_stdcon_w);
lowmem_buf = lmalloc(LOWMEM_BUF_SIZE);
if (!lowmem_buf) {
printf("Could not allocate memory.\n");
return 1;
}
sdi = syslinux_derivative_info();
gfx_config.sector_shift = sdi->disk.sector_shift;
gfx_config.boot_drive = sdi->disk.drive_number;
if(sdi->c.filesystem == SYSLINUX_FS_PXELINUX) {
gfx_config.sector_shift = 11;
gfx_config.boot_drive = 0;
}
gfx_config.media_type = gfx_config.boot_drive < 0x80 ? 1 : 0;
if(sdi->c.filesystem == SYSLINUX_FS_ISOLINUX) {
gfx_config.media_type = sdi->iso.cd_mode ? 0 : 2;
}
gfx_config.bootloader = 1;
gfx_config.sysconfig_size = sizeof gfx_config;
gfx_config.bootloader_seg = 0; // apparently not needed
if(argc < 2) {
printf("Usage: gfxboot.c32 bootlogo_file [message_file]\n");
if(argc > 2) show_message(argv[2]);
return 0;
}
if(read_config_file("~")) {
printf("Error reading config file\n");
if(argc > 2) show_message(argv[2]);
return 0;
}
if(getcwd(working_dir, sizeof working_dir)) {
gfx_config.gfxboot_cwd = (uint32_t) working_dir;
}
if(gfx_init(argv[1])) {
printf("Error setting up gfxboot\n");
if(argc > 2) show_message(argv[2]);
return 0;
}
gfx_menu_init();
for(;;) {
menu_index = gfx_input();
// abort gfx, return to text mode prompt
if(menu_index == -1) {
gfx_done();
break;
}
// does not return if it succeeds
boot(menu_index);
}
if(argc > 2) show_message(argv[2]);
return 0;
}
int main(int argc, char *argv[])
{
struct driveinfo drive;
struct driveinfo *d = &drive;
char buffer[4096] = {0};
unsigned int index = 0;
int ret, progress, progress_old;
int rows, cols;
(void)argc;
(void)argv;
openconsole(&dev_stdcon_r, &dev_stdcon_w);
if (getscreensize(1, &rows, &cols)) {
/* Unknown screen size? */
rows = 24;
cols = 80;
}
memset(buffer, 'A', 4096);
memcpy(buffer, boot_code, sizeof(boot_code));
buffer[510] = 0x55;
buffer[511] = 0xaa;
printf("DWIPE version %s, by sTeeL <*****@*****.**>\n", __DWIPE_VERSION__);
printf("remove USB DISK and hit ENTER key\n");
get_key(stdin, 0);
for (int disk = 0x80; disk < 0xff; disk++) {
memset(d, 0, sizeof(struct driveinfo));
d->disk = disk;
get_drive_parameters(d);
/* Do not print output when drive does not exists */
if (errno_disk == -1 || !d->cbios)
continue;
if (errno_disk) {
get_error("reading disk");
continue;
}
printf("DISK 0x%X:\n", d->disk);
printf(" C/H/S: %d heads, %d cylinders\n",
d->legacy_max_head + 1, d->legacy_max_cylinder + 1);
printf(" %d sectors/track, %d drives\n",
d->legacy_sectors_per_track, d->legacy_max_drive);
printf(" EDD: ebios=%d, EDD version: %X\n",
d->ebios, d->edd_version);
printf(" %d heads, %d cylinders\n",
(int) d->edd_params.heads, (int) d->edd_params.cylinders);
printf(" %d sectors, %d bytes/sector, %d sectors/track\n",
(int) d->edd_params.sectors, (int) d->edd_params.bytes_per_sector,
(int) d->edd_params.sectors_per_track);
printf(" Host bus: %s, Interface type: %s\n\n",
d->edd_params.host_bus_type, d->edd_params.interface_type);
progress_old = 0;
print_progress(0, cols);
for(index = 0; index < d->edd_params.sectors ; index += 8 ) {
ret = dwipe_write_sectors(d, index, buffer, 8);
if(ret == -1) {
printf("ERROR!\n");
continue;
} else {
progress = index * 100 / d->edd_params.sectors;
if(progress != progress_old) {
progress_old = progress;
print_progress(progress, cols);
}
}
}
print_progress(100, cols);
printf("\nDONE\n\n");
}
syslinux_reboot(0);
return 0;
}
