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; }