Ros-diffs January 2017

ros-diffs@reactos.org

15 participants
160 discussions

[akhaldi] 73603: [0.4.4] Update the version number.

by akhaldi＠svn.reactos.org

Author: akhaldi Date: Fri Jan 27 09:54:34 2017 New Revision: 73603 URL: http://svn.reactos.org/svn/reactos?rev=73603&view=rev Log: [0.4.4] Update the version number. Modified: branches/ros-branch-0_4_4/reactos/sdk/include/reactos/version.cmake Modified: branches/ros-branch-0_4_4/reactos/sdk/include/reactos/version.cmake URL: http://svn.reactos.org/svn/reactos/branches/ros-branch-0_4_4/reactos/sdk/in… ============================================================================== --- branches/ros-branch-0_4_4/reactos/sdk/include/reactos/version.cmake [iso-8859-1] (original) +++ branches/ros-branch-0_4_4/reactos/sdk/include/reactos/version.cmake [iso-8859-1] Fri Jan 27 09:54:34 2017 @@ -17,15 +17,15 @@ string(TIMESTAMP KERNEL_VERSION_BUILD %Y%m%d UTC) set(KERNEL_VERSION_MAJOR "0") -set(KERNEL_VERSION_MINOR "5") -set(KERNEL_VERSION_PATCH_LEVEL "0") +set(KERNEL_VERSION_MINOR "4") +set(KERNEL_VERSION_PATCH_LEVEL "4") set(COPYRIGHT_YEAR "2017") # KERNEL_VERSION_BUILD_TYPE is "SVN" or "" (for the release) -set(KERNEL_VERSION_BUILD_TYPE "SVN") +set(KERNEL_VERSION_BUILD_TYPE "") # KERNEL_VERSION_RELEASE_TYPE is "RC1", "RC2" or "" (for the final one) -set(KERNEL_VERSION_RELEASE_TYPE "") +set(KERNEL_VERSION_RELEASE_TYPE "RC1") set(KERNEL_VERSION "${KERNEL_VERSION_MAJOR}.${KERNEL_VERSION_MINOR}") if(KERNEL_VERSION_PATCH_LEVEL)

7 years, 8 months

[akhaldi] 73602: [0.4.4] Branch for the release.

by akhaldi＠svn.reactos.org

Author: akhaldi Date: Fri Jan 27 09:47:24 2017 New Revision: 73602 URL: http://svn.reactos.org/svn/reactos?rev=73602&view=rev Log: [0.4.4] Branch for the release. Added: branches/ros-branch-0_4_4/ (props changed) - copied from r73601, trunk/ Propchange: branches/ros-branch-0_4_4/ ------------------------------------------------------------------------------ --- svn:mergeinfo (added) +++ svn:mergeinfo Fri Jan 27 09:47:24 2017 @@ -0,0 +1 @@ +/branches/colins-printing-for-freedom:67543-68405,68407-68414,68417-70595

7 years, 8 months

[hbelusca] 73601: [SHELL32]: Replace some animations with RLE-8 compressed ones; courtesy Jared Smudde. Thanks! CORE-11643

by hbelusca＠svn.reactos.org

Author: hbelusca Date: Fri Jan 27 01:07:47 2017 New Revision: 73601 URL: http://svn.reactos.org/svn/reactos?rev=73601&view=rev Log: [SHELL32]: Replace some animations with RLE-8 compressed ones; courtesy Jared Smudde. Thanks! CORE-11643 Modified: trunk/reactos/dll/win32/shell32/res/avis/160+161+167+168.avi trunk/reactos/dll/win32/shell32/res/avis/162.avi trunk/reactos/dll/win32/shell32/res/avis/163.avi trunk/reactos/dll/win32/shell32/res/avis/164+169.avi trunk/reactos/dll/win32/shell32/res/avis/170.avi Modified: trunk/reactos/dll/win32/shell32/res/avis/160+161+167+168.avi URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/res/avis… ============================================================================== Binary files - no diff available. Modified: trunk/reactos/dll/win32/shell32/res/avis/162.avi URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/res/avis… ============================================================================== Binary files - no diff available. Modified: trunk/reactos/dll/win32/shell32/res/avis/163.avi URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/res/avis… ============================================================================== Binary files - no diff available. Modified: trunk/reactos/dll/win32/shell32/res/avis/164+169.avi URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/res/avis… ============================================================================== Binary files - no diff available. Modified: trunk/reactos/dll/win32/shell32/res/avis/170.avi URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/res/avis… ============================================================================== Binary files - no diff available.

7 years, 8 months

[gadamopoulos] 73600: [SDK] -rosctrls.h: Add GetItemPosition and SetItemPosition methods in CListView.

by gadamopoulos＠svn.reactos.org

Author: gadamopoulos Date: Thu Jan 26 17:03:35 2017 New Revision: 73600 URL: http://svn.reactos.org/svn/reactos?rev=73600&view=rev Log: [SDK] -rosctrls.h: Add GetItemPosition and SetItemPosition methods in CListView. Modified: trunk/reactos/sdk/include/reactos/rosctrls.h Modified: trunk/reactos/sdk/include/reactos/rosctrls.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/include/reactos/rosctr… ============================================================================== --- trunk/reactos/sdk/include/reactos/rosctrls.h [iso-8859-1] (original) +++ trunk/reactos/sdk/include/reactos/rosctrls.h [iso-8859-1] Thu Jan 26 17:03:35 2017 @@ -214,6 +214,16 @@ SendMessage(LVM_GETITEMTEXT, iItem, (LPARAM) &itemInfo); } + + BOOL GetItemPosition(int nItem, POINT* pPoint) + { + return (BOOL)SendMessage(LVM_GETITEMPOSITION, nItem, (LPARAM)pPoint); + } + + BOOL SetItemPosition(int nItem, POINT* pPoint) + { + return (BOOL)SendMessage(LVM_SETITEMPOSITION, nItem, MAKELPARAM(pPoint->x, pPoint->y)); + } }; template<typename TItemData = DWORD_PTR>

7 years, 8 months

[gadamopoulos] 73599: [SHELL32] -CDefView: Implement moving icons around. Note that the positions are never stored so a refresh returns them to their initial position.

by gadamopoulos＠svn.reactos.org

Author: gadamopoulos Date: Thu Jan 26 16:48:52 2017 New Revision: 73599 URL: http://svn.reactos.org/svn/reactos?rev=73599&view=rev Log: [SHELL32] -CDefView: Implement moving icons around. Note that the positions are never stored so a refresh returns them to their initial position. Modified: trunk/reactos/dll/win32/shell32/CDefView.cpp Modified: trunk/reactos/dll/win32/shell32/CDefView.cpp URL: http://svn.reactos.org/svn/reactos/trunk/reactos/dll/win32/shell32/CDefView… ============================================================================== --- trunk/reactos/dll/win32/shell32/CDefView.cpp [iso-8859-1] (original) +++ trunk/reactos/dll/win32/shell32/CDefView.cpp [iso-8859-1] Thu Jan 26 16:48:52 2017 @@ -96,6 +96,7 @@ LONG m_iDragOverItem; /* Dragged over item's index, iff m_pCurDropTarget != NULL */ UINT m_cScrollDelay; /* Send a WM_*SCROLL msg every 250 ms during drag-scroll */ POINT m_ptLastMousePos; /* Mouse position at last DragOver call */ + POINT m_ptFirstMousePos; /* Mouse position when the drag operation started */ // CComPtr<IContextMenu> m_pCM; @@ -1756,6 +1757,8 @@ DWORD dwEffect2; m_pSourceDataObject = pda; + m_ptFirstMousePos = ((LPNMLISTVIEW)lParam)->ptAction; + ClientToScreen(&m_ptFirstMousePos); DoDragDrop(pda, this, dwEffect, &dwEffect2); @@ -2902,7 +2905,6 @@ { /* Get a hold on the data object for later calls to DragEnter on the sub-folders */ m_pCurDataObject = pDataObject; - pDataObject->AddRef(); return drag_notify_subitem(grfKeyState, pt, pdwEffect); } @@ -2936,11 +2938,22 @@ if ((m_iDragOverItem == -1) && (*pdwEffect & DROPEFFECT_MOVE) && - (GetKeyState(VK_LBUTTON) != 0) && + /*(GetKeyState(VK_LBUTTON) != 0) &&*/ (m_pSourceDataObject.p) && (SHIsSameObject(pDataObject, m_pSourceDataObject))) { - ERR("Should implement moving items here!\n"); + /* Reposition the items */ + int lvIndex = -1; + while ((lvIndex = m_ListView.GetNextItem(lvIndex, LVNI_SELECTED)) > -1) + { + POINT ptItem; + if (m_ListView.GetItemPosition(lvIndex, &ptItem)) + { + ptItem.x += pt.x - m_ptFirstMousePos.x; + ptItem.y += pt.y - m_ptFirstMousePos.y; + m_ListView.SetItemPosition(lvIndex, &ptItem); + } + } if (m_pCurDropTarget) {

7 years, 8 months

[hbelusca] 73598: [EXPLORER]: Update the Start Menu banner for FOSDEM 2017, thanks to Jared Smudde!

by hbelusca＠svn.reactos.org

Author: hbelusca Date: Thu Jan 26 00:09:25 2017 New Revision: 73598 URL: http://svn.reactos.org/svn/reactos?rev=73598&view=rev Log: [EXPLORER]: Update the Start Menu banner for FOSDEM 2017, thanks to Jared Smudde! Modified: branches/ReactOS-0.4.4-FOSDEM2017/reactos/base/shell/explorer/res/bmp/158.bmp branches/ReactOS-0.4.4-FOSDEM2017/reactos/base/shell/explorer/res/src/logov.psd Modified: branches/ReactOS-0.4.4-FOSDEM2017/reactos/base/shell/explorer/res/bmp/158.bmp URL: http://svn.reactos.org/svn/reactos/branches/ReactOS-0.4.4-FOSDEM2017/reacto… ============================================================================== Binary files - no diff available. Modified: branches/ReactOS-0.4.4-FOSDEM2017/reactos/base/shell/explorer/res/src/logov.psd URL: http://svn.reactos.org/svn/reactos/branches/ReactOS-0.4.4-FOSDEM2017/reacto… ============================================================================== Binary files - no diff available.

7 years, 8 months

[hbelusca] 73597: [FREELDR]: Fix GCCLin compilation (#if'd 0 an unused static function; I keep it there still in case it can become useful later).

by hbelusca＠svn.reactos.org

Author: hbelusca Date: Wed Jan 25 22:50:46 2017 New Revision: 73597 URL: http://svn.reactos.org/svn/reactos?rev=73597&view=rev Log: [FREELDR]: Fix GCCLin compilation (#if'd 0 an unused static function; I keep it there still in case it can become useful later). Modified: trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c Modified: trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/arch/… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c [iso-8859-1] (original) +++ trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c [iso-8859-1] Wed Jan 25 22:50:46 2017 @@ -35,11 +35,13 @@ #define SCREEN_ATTR 0x1F // Bright white on blue background +#if 0 static void i386PrintChar(char chr, ULONG x, ULONG y) { MachVideoPutChar(chr, SCREEN_ATTR, x, y); } +#endif /* Used to store the current X and Y position on the screen */ ULONG i386_ScreenPosX = 0;

7 years, 8 months

[hbelusca] 73596: [XDK]: Do not always redefine the ASSERT(MSG) macros with the NT_xxx ones, especially for the FreeLdr/... bootloader (where we don't use WinDbg for debugging, yet), because in thi...

by hbelusca＠svn.reactos.org

Author: hbelusca Date: Wed Jan 25 22:43:04 2017 New Revision: 73596 URL: http://svn.reactos.org/svn/reactos?rev=73596&view=rev Log: [XDK]: Do not always redefine the ASSERT(MSG) macros with the NT_xxx ones, especially for the FreeLdr/... bootloader (where we don't use WinDbg for debugging, yet), because in this case the int 0x2c is hardly informative. We fall back to the good old RtlAssert which displays an assertion failure string in the default debug output port (e.g. serial), and then does an int 0x03. [FREELDR] - "static"-ify some printing helper functions; - hide the textmode cursor before blue-screening; - disable interrupts before hanging forever. Modified: trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c trunk/reactos/sdk/include/xdk/rtlfuncs.h Modified: trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/freeldr/arch/… ============================================================================== --- trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c [iso-8859-1] (original) +++ trunk/reactos/boot/freeldr/freeldr/arch/i386/i386bug.c [iso-8859-1] Wed Jan 25 22:43:04 2017 @@ -35,7 +35,7 @@ #define SCREEN_ATTR 0x1F // Bright white on blue background -void +static void i386PrintChar(char chr, ULONG x, ULONG y) { MachVideoPutChar(chr, SCREEN_ATTR, x, y); @@ -45,7 +45,7 @@ ULONG i386_ScreenPosX = 0; ULONG i386_ScreenPosY = 0; -void +static void i386PrintText(char *pszText) { char chr; @@ -66,7 +66,7 @@ } } -void +static void PrintText(const char *format, ...) { va_list argptr; @@ -79,7 +79,7 @@ i386PrintText(buffer); } -void +static void i386PrintFrames(PKTRAP_FRAME TrapFrame) { FRAME *Frame; @@ -105,6 +105,7 @@ { PUCHAR InstructionPointer; + MachVideoHideShowTextCursor(FALSE); MachVideoClearScreen(SCREEN_ATTR); i386_ScreenPosX = 0; i386_ScreenPosY = 0; @@ -182,7 +183,7 @@ CHAR Buffer[1024]; va_list argptr; - /* Blue screen for the win */ + MachVideoHideShowTextCursor(FALSE); MachVideoClearScreen(SCREEN_ATTR); i386_ScreenPosX = 0; i386_ScreenPosY = 0; @@ -215,6 +216,7 @@ PCHAR File, ULONG Line) { + MachVideoHideShowTextCursor(FALSE); MachVideoClearScreen(SCREEN_ATTR); i386_ScreenPosX = 0; i386_ScreenPosY = 0; @@ -231,6 +233,8 @@ PrintText("Bug Information:\n %p\n %p\n %p\n %p\n %p\n\n", BugCheckInfo[0], BugCheckInfo[1], BugCheckInfo[2], BugCheckInfo[3], BugCheckInfo[4]); + _disable(); + __halt(); for (;;); } Modified: trunk/reactos/sdk/include/xdk/rtlfuncs.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/include/xdk/rtlfuncs.h… ============================================================================== --- trunk/reactos/sdk/include/xdk/rtlfuncs.h [iso-8859-1] (original) +++ trunk/reactos/sdk/include/xdk/rtlfuncs.h [iso-8859-1] Wed Jan 25 22:43:04 2017 @@ -3314,7 +3314,7 @@ # define NT_ASSERTMSGW NT_ASSERTMSGW_NOASSUME #endif /* NT_ASSERT_ALWAYS_ASSUMES */ -#if defined(_MSC_VER) && (defined(__REACTOS__) || defined(ASSERT_ALWAYS_NT_ASSERT)) +#if defined(_MSC_VER) && (defined(__REACTOS__) || defined(ASSERT_ALWAYS_NT_ASSERT)) && !defined(_BLDR_) #undef ASSERT #define ASSERT NT_ASSERT #undef ASSERTMSG

7 years, 8 months

[cfinck] 73595: [ISOHYBRID] Import the isohybrid tool from http://repo.or.cz/syslinux.git/tree/138e850fab106b5235178848b3e0d33e25f4d3a2:/utils I had to add a lot of glue code (getopt, err/errx/warn...

by cfinck＠svn.reactos.org

Author: cfinck Date: Tue Jan 24 22:53:20 2017 New Revision: 73595 URL: http://svn.reactos.org/svn/reactos?rev=73595&view=rev Log: [ISOHYBRID] Import the isohybrid tool from http://repo.or.cz/syslinux.git/tree/138e850fab106b5235178848b3e0d33e25f4d3a… I had to add a lot of glue code (getopt, err/errx/warn/warnx) to get it to compile under all our build platforms Windows, Linux and macOS. GPT/Mac partition support is disabled at the moment (look for REACTOS_ISOHYBRID_EFI_MAC_SUPPORT), that would need a portable libuuid. A fix for correctly opening ISOs as binary and not text-mode has been implemented and already sent upstream. ISOs are not being patched automatically yet due to CORE-12692 CORE-12648 Added: trunk/reactos/sdk/tools/isohybrid/ trunk/reactos/sdk/tools/isohybrid/CMakeLists.txt (with props) trunk/reactos/sdk/tools/isohybrid/isohybrid.c (with props) trunk/reactos/sdk/tools/isohybrid/isohybrid.h (with props) trunk/reactos/sdk/tools/isohybrid/reactos_support_code.c (with props) trunk/reactos/sdk/tools/isohybrid/reactos_support_code.h (with props) Modified: trunk/reactos/CMakeLists.txt trunk/reactos/sdk/tools/CMakeLists.txt Modified: trunk/reactos/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/reactos/CMakeLists.txt?rev=73595&r… ============================================================================== --- trunk/reactos/CMakeLists.txt [iso-8859-1] (original) +++ trunk/reactos/CMakeLists.txt [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -110,9 +110,9 @@ if(NOT NEW_STYLE_BUILD) if(NOT MSVC) - export(TARGETS bin2c widl gendib cabman fatten hpp mkhive mkisofs obj2bin spec2def geninc rsym mkshelllink utf16le xml2sdb FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake NAMESPACE native- ) + export(TARGETS bin2c widl gendib cabman fatten hpp isohybrid mkhive mkisofs obj2bin spec2def geninc rsym mkshelllink utf16le xml2sdb FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake NAMESPACE native- ) else() - export(TARGETS bin2c widl gendib cabman fatten hpp mkhive mkisofs obj2bin spec2def geninc mkshelllink utf16le xml2sdb FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake NAMESPACE native- ) + export(TARGETS bin2c widl gendib cabman fatten hpp isohybrid mkhive mkisofs obj2bin spec2def geninc mkshelllink utf16le xml2sdb FILE ${CMAKE_BINARY_DIR}/ImportExecutables.cmake NAMESPACE native- ) endif() endif() Modified: trunk/reactos/sdk/tools/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/tools/CMakeLists.txt?r… ============================================================================== --- trunk/reactos/sdk/tools/CMakeLists.txt [iso-8859-1] (original) +++ trunk/reactos/sdk/tools/CMakeLists.txt [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -27,6 +27,7 @@ add_subdirectory(cabman) add_subdirectory(hhpcomp) add_subdirectory(hpp) +add_subdirectory(isohybrid) add_subdirectory(kbdtool) add_subdirectory(mkhive) add_subdirectory(mkisofs) @@ -40,4 +41,4 @@ add_subdirectory(rsym) endif() -add_subdirectory(fatten) +add_subdirectory(fatten) Added: trunk/reactos/sdk/tools/isohybrid/CMakeLists.txt URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/tools/isohybrid/CMakeL… ============================================================================== --- trunk/reactos/sdk/tools/isohybrid/CMakeLists.txt (added) +++ trunk/reactos/sdk/tools/isohybrid/CMakeLists.txt [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -0,0 +1,7 @@ + +add_definitions( + -DISOHYBRID_C_STANDALONE) + +add_host_tool(isohybrid + isohybrid.c + reactos_support_code.c) Propchange: trunk/reactos/sdk/tools/isohybrid/CMakeLists.txt ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/sdk/tools/isohybrid/isohybrid.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/tools/isohybrid/isohyb… ============================================================================== --- trunk/reactos/sdk/tools/isohybrid/isohybrid.c (added) +++ trunk/reactos/sdk/tools/isohybrid/isohybrid.c [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -0,0 +1,1237 @@ +/* + * isohybrid.c: Post process an ISO 9660 image generated with mkisofs or + * genisoimage to allow - hybrid booting - as a CD-ROM or as a hard + * disk. + * + * This is based on the original Perl script written by H. Peter Anvin. The + * rewrite in C is to avoid dependency on Perl on a system under installation. + * + * Copyright (C) 2010 P J P <pj.pandit(a)yahoo.co.in> + * + * isohybrid is a free software; you can redistribute it and/or modify it + * under the terms of GNU General Public License as published by Free Software + * Foundation; either version 2 of the license, or (at your option) any later + * version. + * + * isohybrid is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with isohybrid; if not, see: <http://www.gnu.org/licenses>. + * + */ + +#define _FILE_OFFSET_BITS 64 +//#include <err.h> +#include <time.h> +#include <ctype.h> +#include <fcntl.h> +#include <stdio.h> +//#include <alloca.h> +//#include <getopt.h> +#include <signal.h> +#include <stdlib.h> +#include <string.h> +//#include <unistd.h> +#include <sys/stat.h> +#include <inttypes.h> +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +#include <uuid/uuid.h> +#endif + +#include "isohybrid.h" +#include "reactos_support_code.h" + +char *prog = NULL; +extern int opterr, optind; +struct stat isostat; +unsigned int padding = 0; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +uuid_t disk_uuid, part_uuid, iso_uuid; +#endif + +uint8_t mode = 0; +enum { VERBOSE = 1 , EFI = 2 , MAC = 4}; + +/* user options */ +uint16_t head = 64; /* 1 <= head <= 256 */ +uint8_t sector = 32; /* 1 <= sector <= 63 */ + +uint8_t entry = 0; /* partition number: 1 <= entry <= 4 */ +uint8_t offset = 0; /* partition offset: 0 <= offset <= 64 */ +uint16_t type = 0x17; /* partition type: 0 <= type <= 255 */ +uint32_t id = 0; /* MBR: 0 <= id <= 0xFFFFFFFF(4294967296) */ + +uint8_t hd0 = 0; /* 0 <= hd0 <= 2 */ +uint8_t partok = 0; /* 0 <= partok <= 1 */ + +char mbr_template_path[1024] = {0}; /* Path to MBR template */ + +uint16_t ve[16]; +uint32_t catoffset = 0; +uint32_t c = 0, cc = 0, cs = 0; + +uint32_t psize = 0, isosize = 0; + +/* boot catalogue parameters */ +uint32_t de_lba = 0; +uint16_t de_seg = 0, de_count = 0, de_mbz2 = 0; +uint8_t de_boot = 0, de_media = 0, de_sys = 0, de_mbz1 = 0; +uint32_t efi_lba = 0, mac_lba = 0; +uint16_t efi_count = 0, mac_count = 0; +uint8_t efi_boot = 0, efi_media = 0, efi_sys = 0; + +int apm_parts = 3; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +uint8_t afp_header[] = { 0x45, 0x52, 0x08, 0x00, 0x00, 0x00, 0x90, 0x90, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; + +uuid_t efi_system_partition = {0xC1, 0x2A, 0x73, 0x28, 0xF8, 0x1F, 0x11, 0xD2, 0xBA, 0x4B, 0x00, 0xA0, 0xC9, 0x3E, 0xC9, 0x3B}; +uuid_t basic_partition = {0xEB,0xD0,0xA0,0xA2,0xB9,0xE5,0x44,0x33,0x87,0xC0,0x68,0xB6,0xB7,0x26,0x99,0xC7}; +uuid_t hfs_partition = {0x48, 0x46, 0x53, 0x00, 0x00, 0x00, 0x11, 0xAA, 0xAA, 0x11, 0x00, 0x30, 0x65, 0x43, 0xEC, 0xAC}; +#endif + +uint32_t crc_tab[256] = +{ + 0, 0x77073096, 0xEE0E612C, 0x990951BA, + 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3, + 0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, + 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91, + 0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, + 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7, + 0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, + 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5, + 0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, + 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B, + 0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, + 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59, + 0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, + 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F, + 0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, + 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D, + 0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, + 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433, + 0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, + 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01, + 0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, + 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457, + 0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, + 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65, + 0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, + 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB, + 0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, + 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9, + 0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, + 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F, + 0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, + 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD, + 0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, + 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683, + 0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, + 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1, + 0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, + 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7, + 0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, + 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5, + 0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, + 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B, + 0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, + 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79, + 0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, + 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F, + 0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, + 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D, + 0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, + 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713, + 0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, + 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21, + 0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, + 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777, + 0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, + 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45, + 0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, + 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB, + 0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, + 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9, + 0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, + 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF, + 0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, + 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D +}; + +struct iso_primary_descriptor { + uint8_t ignore [80]; + uint32_t size; + uint8_t ignore2 [44]; + uint16_t block_size; +}; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +struct gpt_header { + uint64_t signature; + uint32_t revision; + uint32_t headerSize; + uint32_t headerCRC; + uint32_t reserved; + uint64_t currentLBA; + uint64_t backupLBA; + uint64_t firstUsableLBA; + uint64_t lastUsableLBA; + uuid_t diskGUID; + uint64_t partitionEntriesLBA; + uint32_t numParts; + uint32_t sizeOfPartitionEntries; + uint32_t partitionEntriesCRC; + uint8_t reserved2[420]; +}; + +struct gpt_part_header { + uuid_t partTypeGUID; + uuid_t partGUID; + uint64_t firstLBA; + uint64_t lastLBA; + uint64_t attributes; + uint16_t name[36]; +}; + +#define APM_OFFSET 2048 + +struct apple_part_header { + uint16_t signature; /* expected to be MAC_PARTITION_MAGIC */ + uint16_t res1; + uint32_t map_count; /* # blocks in partition map */ + uint32_t start_block; /* absolute starting block # of partition */ + uint32_t block_count; /* number of blocks in partition */ + char name[32]; /* partition name */ + char type[32]; /* string type description */ + uint32_t data_start; /* rel block # of first data block */ + uint32_t data_count; /* number of data blocks */ + uint32_t status; /* partition status bits */ + uint32_t boot_start; + uint32_t boot_count; + uint32_t boot_load; + uint32_t boot_load2; + uint32_t boot_entry; + uint32_t boot_entry2; + uint32_t boot_cksum; + char processor[16]; /* Contains 680x0, x=0,2,3,4; or empty */ + uint32_t driver_sig; + char _padding[372]; +}; +#endif + + +void +usage(void) +{ + printf("Usage: %s [OPTIONS] <boot.iso>\n", prog); +} + + +void +printh(void) +{ +#define FMT "%-20s %s\n" + + usage(); + + printf("\n"); + printf("Options:\n"); + printf(FMT, " -h <X>", "Number of geometry heads (default 64)"); + printf(FMT, " -s <X>", "Number of geometry sectors (default 32)"); + printf(FMT, " -e --entry", "Specify partition entry number (1-4)"); + printf(FMT, " -o --offset", "Specify partition offset (default 0)"); + printf(FMT, " -t --type", "Specify partition type (default 0x17)"); + printf(FMT, " -i --id", "Specify MBR ID (default random)"); +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + printf(FMT, " -u --uefi", "Build EFI bootable image"); + printf(FMT, " -m --mac", "Add AFP table support"); +#endif + printf(FMT, " -b --mbr <PATH>", "Load MBR from PATH"); + + printf("\n"); + printf(FMT, " --forcehd0", "Assume we are loaded as disk ID 0"); + printf(FMT, " --ctrlhd0", "Assume disk ID 0 if the Ctrl key is pressed"); + printf(FMT, " --partok", "Allow booting from within a partition"); + + printf("\n"); + printf(FMT, " -? --help", "Display this help"); + printf(FMT, " -v --verbose", "Display verbose output"); + printf(FMT, " -V --version", "Display version information"); + + printf("\n"); + printf("Report bugs to <pj.pandit(a)yahoo.co.in>\n"); +} + + +int +check_option(int argc, char *argv[]) +{ + char *err = NULL; + int n = 0, ind = 0; + + const char optstr[] = ":h:s:e:o:t:i:b:umfcp?vV"; + struct option lopt[] = \ + { + { "entry", required_argument, NULL, 'e' }, + { "offset", required_argument, NULL, 'o' }, + { "type", required_argument, NULL, 't' }, + { "id", required_argument, NULL, 'i' }, + + { "forcehd0", no_argument, NULL, 'f' }, + { "ctrlhd0", no_argument, NULL, 'c' }, + { "partok", no_argument, NULL, 'p'}, +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + { "uefi", no_argument, NULL, 'u'}, + { "mac", no_argument, NULL, 'm'}, +#endif + { "mbr", required_argument, NULL, 'b' }, + + { "help", no_argument, NULL, '?' }, + { "verbose", no_argument, NULL, 'v' }, + { "version", no_argument, NULL, 'V' }, + + { 0, 0, 0, 0 } + }; + + opterr = mode = 0; + while ((n = getopt_long_only(argc, argv, optstr, lopt, &ind)) != -1) + { + switch (n) + { + case 'h': + head = strtoul(optarg, &err, 0); + if (head < 1 || head > 256) + errx(1, "invalid head: `%s', 1 <= head <= 256", optarg); + break; + + case 's': + sector = strtoul(optarg, &err, 0); + if (sector < 1 || sector > 63) + errx(1, "invalid sector: `%s', 1 <= sector <= 63", optarg); + break; + + case 'e': + entry = strtoul(optarg, &err, 0); + if (entry < 1 || entry > 4) + errx(1, "invalid entry: `%s', 1 <= entry <= 4", optarg); + if (mode & MAC || mode & EFI) + errx(1, "setting an entry is unsupported with EFI or Mac"); + break; + + case 'o': + offset = strtoul(optarg, &err, 0); + if (*err || offset > 64) + errx(1, "invalid offset: `%s', 0 <= offset <= 64", optarg); + break; + + case 't': + type = strtoul(optarg, &err, 0); + if (*err || type > 255) + errx(1, "invalid type: `%s', 0 <= type <= 255", optarg); + break; + + case 'i': + id = strtoul(optarg, &err, 0); + if (*err) + errx(1, "invalid id: `%s'", optarg); + break; + + case 'f': + hd0 = 1; + break; + + case 'c': + hd0 = 2; + break; + + case 'p': + partok = 1; + break; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + case 'u': + mode |= EFI; + if (entry) + errx(1, "setting an entry is unsupported with EFI or Mac"); + break; + + case 'm': + mode |= MAC; + if (entry) + errx(1, "setting an entry is unsupported with EFI or Mac"); + break; +#endif + + case 'b': + if (strlen(optarg) >= sizeof(mbr_template_path)) + errx(1, "--mbr : Path too long"); + strcpy(mbr_template_path, optarg); + break; + + case 'v': + mode |= VERBOSE; + break; + + case 'V': + printf("%s version %s\n", prog, VERSION); + exit(0); + + case ':': + errx(1, "option `-%c' takes an argument", optopt); + + default: + case '?': + if (optopt) + errx(1, "invalid option `-%c', see --help", optopt); + + printh(); + exit(0); + } + } + + return optind; +} + +uint16_t +bendian_short(const uint16_t s) +{ + uint16_t r = 1; + + if (!*(uint8_t *)&r) + return s; + + r = (s & 0x00FF) << 8 | (s & 0xFF00) >> 8; + + return r; +} + + +uint32_t +bendian_int(const uint32_t s) +{ + uint32_t r = 1; + + if (!*(uint8_t *)&r) + return s; + + r = (s & 0x000000FF) << 24 | (s & 0xFF000000) >> 24 + | (s & 0x0000FF00) << 8 | (s & 0x00FF0000) >> 8; + + return r; +} + +uint16_t +lendian_short(const uint16_t s) +{ + uint16_t r = 1; + + if (*(uint8_t *)&r) + return s; + + r = (s & 0x00FF) << 8 | (s & 0xFF00) >> 8; + + return r; +} + + +uint32_t +lendian_int(const uint32_t s) +{ + uint32_t r = 1; + + if (*(uint8_t *)&r) + return s; + + r = (s & 0x000000FF) << 24 | (s & 0xFF000000) >> 24 + | (s & 0x0000FF00) << 8 | (s & 0x00FF0000) >> 8; + + return r; +} + +uint64_t +lendian_64(const uint64_t s) +{ + uint64_t r = 1; + + if (*(uint8_t *)&r) + return s; + + r = (s & 0x00000000000000FFull) << 56 | (s & 0xFF00000000000000ull) >> 56 + | (s & 0x000000000000FF00ull) << 40 | (s & 0x00FF000000000000ull) >> 40 + | (s & 0x0000000000FF0000ull) << 24 | (s & 0x0000FF0000000000ull) >> 24 + | (s & 0x00000000FF000000ull) << 8 | (s & 0x000000FF00000000ull) >> 8; + + return r; +} + + +int +check_banner(const uint8_t *buf) +{ + static const char banner[] = "\0CD001\1EL TORITO SPECIFICATION\0\0\0\0" \ + "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" \ + "\0\0\0\0\0"; + + if (!buf || memcmp(buf, banner, sizeof(banner) - 1)) + return 1; + + buf += sizeof(banner) - 1; + memcpy(&catoffset, buf, sizeof(catoffset)); + + catoffset = lendian_int(catoffset); + + return 0; +} + + +int +check_catalogue(const uint8_t *buf) +{ + int i = 0; + + for (i = 0, cs = 0; i < 16; i++) + { + ve[i] = 0; + memcpy(&ve[i], buf, sizeof(ve[i])); + + ve[i] = lendian_short(ve[i]); + + buf += 2; + cs += ve[i]; + + if (mode & VERBOSE) + printf("ve[%d]: %d, cs: %d\n", i, ve[i], cs); + } + if ((ve[0] != 0x0001) || (ve[15] != 0xAA55) || (cs & 0xFFFF)) + return 1; + + return 0; +} + + +int +read_catalogue(const uint8_t *buf) +{ + memcpy(&de_boot, buf++, 1); + memcpy(&de_media, buf++, 1); + + memcpy(&de_seg, buf, 2); + de_seg = lendian_short(de_seg); + buf += 2; + + memcpy(&de_sys, buf++, 1); + memcpy(&de_mbz1, buf++, 1); + + memcpy(&de_count, buf, 2); + de_count = lendian_short(de_count); + buf += 2; + + memcpy(&de_lba, buf, 4); + de_lba = lendian_int(de_lba); + buf += 4; + + memcpy(&de_mbz2, buf, 2); + de_mbz2 = lendian_short(de_mbz2); + buf += 2; + + if (de_boot != 0x88 || de_media != 0 + || (de_seg != 0 && de_seg != 0x7C0) || de_count != 4) + return 1; + + return 0; +} + + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +int +read_efi_section(const uint8_t *buf) +{ + unsigned char header_indicator; + unsigned char platform_id; + short count; + + memcpy(&header_indicator, buf++, 1); + memcpy(&platform_id, buf++, 1); + + memcpy(&count, buf, 2); + count = lendian_short(count); + buf += 2; + + if (platform_id == 0xef) + return 0; + + return 1; +} + +int +read_efi_catalogue(const uint8_t *buf, uint16_t *count, uint32_t *lba) +{ + buf += 6; + + memcpy(count, buf, 2); + *count = lendian_short(*count); + buf += 2; + + memcpy(lba, buf, 4); + *lba = lendian_int(*lba); + buf += 6; + + return 0; +} +#endif + + +void +display_catalogue(void) +{ + printf("de_boot: %hhu\n", de_boot); + printf("de_media: %hhu\n", de_media); + printf("de_seg: %hu\n", de_seg); + printf("de_sys: %hhu\n", de_sys); + printf("de_mbz1: %hhu\n", de_mbz1); + printf("de_count: %hu\n", de_count); + printf("de_lba: %u\n", de_lba); + printf("de_mbz2: %hu\n", de_mbz2); +} + + +void +read_mbr_template(char *path, uint8_t *mbr) +{ + FILE *fp; + int ret; + + fp = fopen(path, "rb"); + if (fp == NULL) + err(1, "could not open MBR template file `%s'", path); + clearerr(fp); + ret = fread(mbr, 1, MBRSIZE, fp); + if (ferror(fp) || ret != MBRSIZE) + err(1, "error while reading MBR template file `%s'", path); + fclose(fp); +} + + +int +initialise_mbr(uint8_t *mbr) +{ + int i = 0; + uint32_t tmp = 0; + uint8_t ptype = 0, *rbm = mbr; + uint8_t bhead = 0, bsect = 0, bcyle = 0; + uint8_t ehead = 0, esect = 0, ecyle = 0; + +#ifndef ISOHYBRID_C_STANDALONE + extern unsigned char isohdpfx[][MBRSIZE]; +#endif + + if (mbr_template_path[0]) { + read_mbr_template(mbr_template_path, mbr); + } else { + +#ifdef ISOHYBRID_C_STANDALONE + + err(1, "This is a standalone binary. You must specify --mbr. E.g with /usr/lib/syslinux/isohdpfx.bin"); + +#else + + memcpy(mbr, &isohdpfx[hd0 + 3 * partok], MBRSIZE); + +#endif /* ! ISOHYBRID_C_STANDALONE */ + + } + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (mode & MAC) { + memcpy(mbr, afp_header, sizeof(afp_header)); + } +#endif + + if (!entry) + entry = 1; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (mode & EFI) + type = 0; +#endif + + mbr += MBRSIZE; /* offset 432 */ + + tmp = lendian_int(de_lba * 4); + memcpy(mbr, &tmp, sizeof(tmp)); + mbr += sizeof(tmp); /* offset 436 */ + + tmp = 0; + memcpy(mbr, &tmp, sizeof(tmp)); + mbr += sizeof(tmp); /* offset 440 */ + + tmp = lendian_int(id); + memcpy(mbr, &tmp, sizeof(tmp)); + mbr += sizeof(tmp); /* offset 444 */ + + mbr[0] = '\0'; + mbr[1] = '\0'; + mbr += 2; /* offset 446 */ + + ptype = type; + psize = c * head * sector - offset; + + bhead = (offset / sector) % head; + bsect = (offset % sector) + 1; + bcyle = offset / (head * sector); + + bsect += (bcyle & 0x300) >> 2; + bcyle &= 0xFF; + + ehead = head - 1; + esect = sector + (((cc - 1) & 0x300) >> 2); + ecyle = (cc - 1) & 0xFF; + + for (i = 1; i <= 4; i++) + { + memset(mbr, 0, 16); + if (i == entry) + { + mbr[0] = 0x80; + mbr[1] = bhead; + mbr[2] = bsect; + mbr[3] = bcyle; + mbr[4] = ptype; + mbr[5] = ehead; + mbr[6] = esect; + mbr[7] = ecyle; + + tmp = lendian_int(offset); + memcpy(&mbr[8], &tmp, sizeof(tmp)); + + tmp = lendian_int(psize); + memcpy(&mbr[12], &tmp, sizeof(tmp)); + } +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (i == 2 && (mode & EFI)) + { + mbr[0] = 0x0; + mbr[1] = 0xfe; + mbr[2] = 0xff; + mbr[3] = 0xff; + mbr[4] = 0xef; + mbr[5] = 0xfe; + mbr[6] = 0xff; + mbr[7] = 0xff; + + tmp = lendian_int(efi_lba * 4); + memcpy(&mbr[8], &tmp, sizeof(tmp)); + + tmp = lendian_int(efi_count); + memcpy(&mbr[12], &tmp, sizeof(tmp)); + } + if (i == 3 && (mode & MAC)) + { + mbr[0] = 0x0; + mbr[1] = 0xfe; + mbr[2] = 0xff; + mbr[3] = 0xff; + mbr[4] = 0x0; + mbr[5] = 0xfe; + mbr[6] = 0xff; + mbr[7] = 0xff; + + tmp = lendian_int(mac_lba * 4); + memcpy(&mbr[8], &tmp, sizeof(tmp)); + + tmp = lendian_int(mac_count); + memcpy(&mbr[12], &tmp, sizeof(tmp)); + } +#endif + mbr += 16; + } + mbr[0] = 0x55; + mbr[1] = 0xAA; + mbr += 2; + + return mbr - rbm; +} + +void +display_mbr(const uint8_t *mbr, size_t len) +{ + unsigned char c = 0; + unsigned int i = 0, j = 0; + + printf("sizeof(MBR): %zu bytes\n", len); + for (i = 0; i < len; i++) + { + if (!(i % 16)) + printf("%04d ", i); + + if (!(i % 8)) + printf(" "); + + c = mbr[i]; + printf("%02x ", c); + + if (!((i + 1) % 16)) + { + printf(" |"); + for (; j <= i; j++) + printf("%c", isprint(mbr[j]) ? mbr[j] : '.'); + printf("|\n"); + } + } +} + + +uint32_t chksum_crc32 (unsigned char *block, unsigned int length) +{ + register unsigned long crc; + unsigned long i; + + crc = 0xFFFFFFFF; + for (i = 0; i < length; i++) + { + crc = ((crc >> 8) & 0x00FFFFFF) ^ crc_tab[(crc ^ *block++) & 0xFF]; + } + return (crc ^ 0xFFFFFFFF); +} + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +void +reverse_uuid(uuid_t uuid) +{ + uint8_t t, *p = (uint8_t *)uuid; + + t = p[0]; p[0] = p[3]; p[3] = t; + t = p[1]; p[1] = p[2]; p[2] = t; + t = p[4]; p[4] = p[5]; p[5] = t; + t = p[6]; p[6] = p[7]; p[7] = t; +} +#endif + +static uint16_t * +ascii_to_utf16le(uint16_t *dst, const char *src) +{ + uint8_t *p = (uint8_t *)dst; + char c; + + do { + c = *src++; + *p++ = c; + *p++ = 0; + } while (c); + + return (uint16_t *)p; +} + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT +void +initialise_gpt(uint8_t *gpt, uint32_t current, uint32_t alternate, int primary) +{ + struct gpt_header *header = (struct gpt_header *)gpt; + struct gpt_part_header *part; + int hole = 0; + int gptsize = 128 / 4 + 2; + + if (mac_lba) { + /* 2048 bytes per partition, plus round to 2048 boundary */ + hole = (apm_parts * 4) + 2; + } + + if (primary) { + uuid_generate(disk_uuid); + reverse_uuid(disk_uuid); + } + + header->signature = lendian_64(0x5452415020494645ull); + header->revision = lendian_int(0x010000); + header->headerSize = lendian_int(0x5c); + header->currentLBA = lendian_64(current); + header->backupLBA = lendian_64(alternate); + header->firstUsableLBA = lendian_64(gptsize + hole); + header->lastUsableLBA = lendian_64((isostat.st_size + padding)/512 - + gptsize); + if (primary) + header->partitionEntriesLBA = lendian_64(0x02 + hole); + else + header->partitionEntriesLBA = lendian_64(current - (128 / 4)); + header->numParts = lendian_int(0x80); + header->sizeOfPartitionEntries = lendian_int(0x80); + memcpy(header->diskGUID, disk_uuid, sizeof(uuid_t)); + + if (primary) + gpt += sizeof(struct gpt_header) + hole * 512; + else + gpt -= header->sizeOfPartitionEntries * header->numParts; + + part = (struct gpt_part_header *)gpt; + if (primary) { + uuid_generate(part_uuid); + uuid_generate(iso_uuid); + reverse_uuid(part_uuid); + reverse_uuid(iso_uuid); + } + + memcpy(part->partGUID, iso_uuid, sizeof(uuid_t)); + memcpy(part->partTypeGUID, basic_partition, sizeof(uuid_t)); + part->firstLBA = lendian_64(0); + part->lastLBA = lendian_64(psize - 1); + ascii_to_utf16le(part->name, "ISOHybrid ISO"); + + gpt += sizeof(struct gpt_part_header); + part++; + + memcpy(part->partGUID, part_uuid, sizeof(uuid_t)); + memcpy(part->partTypeGUID, basic_partition, sizeof(uuid_t)); + part->firstLBA = lendian_64(efi_lba * 4); + part->lastLBA = lendian_64(part->firstLBA + efi_count - 1); + ascii_to_utf16le(part->name, "ISOHybrid"); + + gpt += sizeof(struct gpt_part_header); + + if (mac_lba) { + gpt += sizeof(struct gpt_part_header); + + part++; + + memcpy(part->partGUID, part_uuid, sizeof(uuid_t)); + memcpy(part->partTypeGUID, hfs_partition, sizeof(uuid_t)); + part->firstLBA = lendian_64(mac_lba * 4); + part->lastLBA = lendian_64(part->firstLBA + mac_count - 1); + ascii_to_utf16le(part->name, "ISOHybrid"); + + part--; + } + + part--; + + header->partitionEntriesCRC = lendian_int (chksum_crc32((uint8_t *)part, + header->numParts * header->sizeOfPartitionEntries)); + + header->headerCRC = lendian_int(chksum_crc32((uint8_t *)header, + header->headerSize)); +} + +void +initialise_apm(uint8_t *gpt, uint32_t start) +{ + struct apple_part_header *part = (struct apple_part_header *)gpt; + + part->signature = bendian_short(0x504d); + part->map_count = bendian_int(apm_parts); + part->start_block = bendian_int(1); + part->block_count = bendian_int(4); + strcpy(part->name, "Apple"); + strcpy(part->type, "Apple_partition_map"); + part->data_start = bendian_int(0); + part->data_count = bendian_int(10); + part->status = bendian_int(0x03); + + part = (struct apple_part_header *)(gpt + 2048); + + part->signature = bendian_short(0x504d); + part->map_count = bendian_int(3); + part->start_block = bendian_int(efi_lba); + part->block_count = bendian_int(efi_count / 4); + strcpy(part->name, "EFI"); + strcpy(part->type, "Apple_HFS"); + part->data_start = bendian_int(0); + part->data_count = bendian_int(efi_count / 4); + part->status = bendian_int(0x33); + + part = (struct apple_part_header *)(gpt + 4096); + + if (mac_lba) + { + part->signature = bendian_short(0x504d); + part->map_count = bendian_int(3); + part->start_block = bendian_int(mac_lba); + part->block_count = bendian_int(mac_count / 4); + strcpy(part->name, "EFI"); + strcpy(part->type, "Apple_HFS"); + part->data_start = bendian_int(0); + part->data_count = bendian_int(mac_count / 4); + part->status = bendian_int(0x33); + } else { + part->signature = bendian_short(0x504d); + part->map_count = bendian_int(3); + part->start_block = bendian_int((start/2048) + 10); + part->block_count = bendian_int(efi_lba - start/2048 - 10); + strcpy(part->name, "ISO"); + strcpy(part->type, "Apple_Free"); + part->data_start = bendian_int(0); + part->data_count = bendian_int(efi_lba - start/2048 - 10); + part->status = bendian_int(0x01); + } +} +#endif + +int +main(int argc, char *argv[]) +{ + int i = 0; + FILE *fp = NULL; + uint8_t *buf = NULL, *bufz = NULL; + int cylsize = 0, frac = 0; + size_t orig_gpt_size, free_space, gpt_size; + struct iso_primary_descriptor descriptor; + + prog = strcpy(alloca(strlen(argv[0]) + 1), argv[0]); + i = check_option(argc, argv); + argc -= i; + argv += i; + + if (!argc) + { + usage(); + return 1; + } + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if ((mode & EFI) && offset) + errx(1, "%s: --offset is invalid with UEFI images\n", argv[0]); +#endif + + srand(time(NULL) << (getppid() << getpid())); + + if (!(fp = fopen(argv[0], "rb+"))) + err(1, "could not open file `%s'", argv[0]); + + if (fseeko(fp, (off_t) (16 << 11), SEEK_SET)) + err(1, "%s: seek error - 0", argv[0]); + + if (fread(&descriptor, sizeof(char), sizeof(descriptor), fp) != sizeof(descriptor)) + err(1, "%s: read error - 0", argv[0]); + + if (fseeko(fp, (off_t) 17 * 2048, SEEK_SET)) + err(1, "%s: seek error - 1", argv[0]); + + bufz = buf = calloc(BUFSIZE, sizeof(char)); + if (fread(buf, sizeof(char), BUFSIZE, fp) != BUFSIZE) + err(1, "%s", argv[0]); + + if (check_banner(buf)) + errx(1, "%s: could not find boot record", argv[0]); + + if (mode & VERBOSE) + printf("catalogue offset: %d\n", catoffset); + + if (fseeko(fp, ((off_t) catoffset) * 2048, SEEK_SET)) + err(1, "%s: seek error - 2", argv[0]); + + buf = bufz; + memset(buf, 0, BUFSIZE); + if (fread(buf, sizeof(char), BUFSIZE, fp) != BUFSIZE) + err(1, "%s", argv[0]); + + if (check_catalogue(buf)) + errx(1, "%s: invalid boot catalogue", argv[0]); + + buf += sizeof(ve); + if (read_catalogue(buf)) + errx(1, "%s: unexpected boot catalogue parameters", argv[0]); + + if (mode & VERBOSE) + display_catalogue(); + + buf += 32; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (mode & EFI) + { + if (!read_efi_section(buf)) { + buf += 32; + if (!read_efi_catalogue(buf, &efi_count, &efi_lba) && efi_lba) { + offset = 0; + } else { + errx(1, "%s: invalid efi catalogue", argv[0]); + } + } else { + errx(1, "%s: unable to find efi image", argv[0]); + } + } +#endif + + buf += 32; + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (mode & MAC) + { + if (!read_efi_section(buf)) { + buf += 32; + if (!read_efi_catalogue(buf, &mac_count, &mac_lba) && mac_lba) { + offset = 0; + } else { + errx(1, "%s: invalid efi catalogue", argv[0]); + } + } else { + errx(1, "%s: unable to find mac efi image", argv[0]); + } + } +#endif + + if (fseeko(fp, (((off_t) de_lba) * 2048 + 0x40), SEEK_SET)) + err(1, "%s: seek error - 3", argv[0]); + + buf = bufz; + memset(buf, 0, BUFSIZE); + if (fread(buf, sizeof(char), 4, fp) != 4) + err(1, "%s", argv[0]); + + if (memcmp(buf, "\xFB\xC0\x78\x70", 4)) + errx(1, "%s: boot loader does not have an isolinux.bin hybrid " \ + "signature. Note that isolinux-debug.bin does not support " \ + "hybrid booting", argv[0]); + + if (stat(argv[0], &isostat)) + err(1, "%s", argv[0]); + + isosize = lendian_int(descriptor.size) * lendian_short(descriptor.block_size); + free_space = isostat.st_size - isosize; + + cylsize = head * sector * 512; + frac = isostat.st_size % cylsize; + padding = (frac > 0) ? cylsize - frac : 0; + + if (mode & VERBOSE) + printf("imgsize: %zu, padding: %d\n", (size_t)isostat.st_size, padding); + + cc = c = ( isostat.st_size + padding) / cylsize; + if (c > 1024) + { + warnx("Warning: more than 1024 cylinders: %d", c); + warnx("Not all BIOSes will be able to boot this device"); + cc = 1024; + } + + if (!id) + { + if (fseeko(fp, (off_t) 440, SEEK_SET)) + err(1, "%s: seek error - 4", argv[0]); + + if (fread(&id, 1, 4, fp) != 4) + err(1, "%s: read error", argv[0]); + + id = lendian_int(id); + if (!id) + { + if (mode & VERBOSE) + printf("random "); + id = rand(); + } + } + if (mode & VERBOSE) + printf("id: %u\n", id); + + buf = bufz; + memset(buf, 0, BUFSIZE); + i = initialise_mbr(buf); + + if (mode & VERBOSE) + display_mbr(buf, i); + + if (fseeko(fp, (off_t) 0, SEEK_SET)) + err(1, "%s: seek error - 5", argv[0]); + + if (fwrite(buf, sizeof(char), i, fp) != (size_t)i) + err(1, "%s: write error - 1", argv[0]); + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (efi_lba) { + reverse_uuid(basic_partition); + reverse_uuid(hfs_partition); + + /* 512 byte header, 128 entries of 128 bytes */ + orig_gpt_size = gpt_size = 512 + (128 * 128); + + /* Leave space for the APM if necessary */ + if (mac_lba) + gpt_size += (4 * 2048); + + buf = calloc(gpt_size, sizeof(char)); + memset(buf, 0, gpt_size); + + /* + * We need to ensure that we have enough space for the secondary GPT. + * Unlike the primary, this doesn't need a hole for the APM. We still + * want to be 1MB aligned so just bump the padding by a megabyte. + */ + if (free_space < orig_gpt_size && padding < orig_gpt_size) { + padding += 1024 * 1024; + } + + /* + * Determine the size of the ISO filesystem. This will define the size + * of the partition that covers it. + */ + psize = isosize / 512; + + /* + * Primary GPT starts at sector 1, secondary GPT starts at 1 sector + * before the end of the image + */ + initialise_gpt(buf, 1, (isostat.st_size + padding - 512) / 512, 1); + + if (fseeko(fp, (off_t) 512, SEEK_SET)) + err(1, "%s: seek error - 6", argv[0]); + + if (fwrite(buf, sizeof(char), gpt_size, fp) != (size_t)gpt_size) + err(1, "%s: write error - 2", argv[0]); + } + + if (mac_lba) + { + /* Apple partition entries filling 2048 bytes each */ + int apm_size = apm_parts * 2048; + + buf = realloc(buf, apm_size); + memset(buf, 0, apm_size); + + initialise_apm(buf, APM_OFFSET); + + fseeko(fp, (off_t) APM_OFFSET, SEEK_SET); + fwrite(buf, sizeof(char), apm_size, fp); + } +#endif + + if (padding) + { + if (fsync(fileno(fp))) + err(1, "%s: could not synchronise", argv[0]); + + if (ftruncate(fileno(fp), isostat.st_size + padding)) + err(1, "%s: could not add padding bytes", argv[0]); + } + +#ifdef REACTOS_ISOHYBRID_EFI_MAC_SUPPORT + if (efi_lba) { + buf = realloc(buf, orig_gpt_size); + memset(buf, 0, orig_gpt_size); + + buf += orig_gpt_size - sizeof(struct gpt_header); + + initialise_gpt(buf, (isostat.st_size + padding - 512) / 512, 1, 0); + + /* Shift back far enough to write the 128 GPT entries */ + buf -= 128 * sizeof(struct gpt_part_header); + + /* + * Seek far enough back that the gpt header is 512 bytes before the + * end of the image + */ + + if (fseeko(fp, (isostat.st_size + padding) - orig_gpt_size, SEEK_SET)) + err(1, "%s: seek error - 8", argv[0]); + + if (fwrite(buf, sizeof(char), orig_gpt_size, fp) != orig_gpt_size) + err(1, "%s: write error - 4", argv[0]); + } +#endif + + free(buf); + fclose(fp); + + return 0; +} Propchange: trunk/reactos/sdk/tools/isohybrid/isohybrid.c ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/sdk/tools/isohybrid/isohybrid.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/tools/isohybrid/isohyb… ============================================================================== --- trunk/reactos/sdk/tools/isohybrid/isohybrid.h (added) +++ trunk/reactos/sdk/tools/isohybrid/isohybrid.h [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -0,0 +1,27 @@ +/* + * isohybrid.h: header file for isohybrid.c: Post process an ISO 9660 image + * generated with mkisofs or genisoimage to allow - hybrid booting - as a + * CD-ROM or as a hard disk. + * + * Copyright (C) 2010 Geert Stappers <stappers(a)stappers.nl> + * + * isohybrid is a free software; you can redistribute it and/or modify it + * under the terms of GNU General Public License as published by Free Software + * Foundation; either version 2 of the license, or (at your option) any later + * version. + * + * isohybrid is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or + * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for + * more details. + * + * You should have received a copy of the GNU General Public License along + * with isohybrid; if not, see: <http://www.gnu.org/licenses>. + * + */ + +#define VERSION "0.12" +#define BUFSIZE 2048 +#define MBRSIZE 432 + +/* End of header file */ Propchange: trunk/reactos/sdk/tools/isohybrid/isohybrid.h ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/sdk/tools/isohybrid/reactos_support_code.c URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/tools/isohybrid/reacto… ============================================================================== --- trunk/reactos/sdk/tools/isohybrid/reactos_support_code.c (added) +++ trunk/reactos/sdk/tools/isohybrid/reactos_support_code.c [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -0,0 +1,534 @@ +#include "reactos_support_code.h" + +void +isohybrid_error(int eval, const char* fmt, ...) +{ + fprintf(stderr, "isohybrid: "); + + va_list ap; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); + exit(eval); +} + +void +isohybrid_warning(const char *fmt, ...) +{ + fprintf(stderr, "isohybrid: "); + + va_list ap; + va_start(ap, fmt); + vfprintf(stderr, fmt, ap); + va_end(ap); +} + +///////////////////////////////////////////////////////////////////////////// +// getopt code from mingw-w64 +///////////////////////////////////////////////////////////////////////////// +/* $OpenBSD: getopt_long.c,v 1.23 2007/10/31 12:34:57 chl Exp $ */ +/* $NetBSD: getopt_long.c,v 1.15 2002/01/31 22:43:40 tv Exp $ */ + +/* + * Copyright (c) 2002 Todd C. Miller <Todd.Miller(a)courtesan.com> + * + * Permission to use, copy, modify, and distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Sponsored in part by the Defense Advanced Research Projects + * Agency (DARPA) and Air Force Research Laboratory, Air Force + * Materiel Command, USAF, under agreement number F39502-99-1-0512. + */ +/*- + * Copyright (c) 2000 The NetBSD Foundation, Inc. + * All rights reserved. + * + * This code is derived from software contributed to The NetBSD Foundation + * by Dieter Baron and Thomas Klausner. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + */ +int opterr = 1; /* if error message should be printed */ +int optind = 1; /* index into parent argv vector */ + +///// REACTOS ONLY: optopt set to 0 by default, because isohybrid needs this +int optopt = 0; /* character checked for validity */ + +int optreset; /* reset getopt */ +char *optarg; /* argument associated with option */ + +#define PRINT_ERROR ((opterr) && (*options != ':')) + +#define FLAG_PERMUTE 0x01 /* permute non-options to the end of argv */ +#define FLAG_ALLARGS 0x02 /* treat non-options as args to option "-1" */ +#define FLAG_LONGONLY 0x04 /* operate as getopt_long_only */ + +/* return values */ +#define BADCH (int)'?' +#define BADARG ((*options == ':') ? (int)':' : (int)'?') +#define INORDER (int)1 + +#define EMSG "" + +static char *place = EMSG; /* option letter processing */ + +/* XXX: set optreset to 1 rather than these two */ +static int nonopt_start = -1; /* first non option argument (for permute) */ +static int nonopt_end = -1; /* first option after non options (for permute) */ + +/* Error messages */ +static const char recargchar[] = "option requires an argument -- %c"; +static const char recargstring[] = "option requires an argument -- %s"; +static const char ambig[] = "ambiguous option -- %.*s"; +static const char noarg[] = "option doesn't take an argument -- %.*s"; +static const char illoptchar[] = "unknown option -- %c"; +static const char illoptstring[] = "unknown option -- %s"; + +/* +* Compute the greatest common divisor of a and b. +*/ +static int +gcd(int a, int b) +{ + int c; + + c = a % b; + while (c != 0) { + a = b; + b = c; + c = a % b; + } + + return (b); +} + +/* +* Exchange the block from nonopt_start to nonopt_end with the block +* from nonopt_end to opt_end (keeping the same order of arguments +* in each block). +*/ +static void +permute_args(int panonopt_start, int panonopt_end, int opt_end, +char * const *nargv) +{ + int cstart, cyclelen, i, j, ncycle, nnonopts, nopts, pos; + char *swap; + + /* + * compute lengths of blocks and number and size of cycles + */ + nnonopts = panonopt_end - panonopt_start; + nopts = opt_end - panonopt_end; + ncycle = gcd(nnonopts, nopts); + cyclelen = (opt_end - panonopt_start) / ncycle; + + for (i = 0; i < ncycle; i++) { + cstart = panonopt_end + i; + pos = cstart; + for (j = 0; j < cyclelen; j++) { + if (pos >= panonopt_end) + pos -= nnonopts; + else + pos += nopts; + swap = nargv[pos]; + /* LINTED const cast */ + ((char **)nargv)[pos] = nargv[cstart]; + /* LINTED const cast */ + ((char **)nargv)[cstart] = swap; + } + } +} + +/* +* parse_long_options -- +* Parse long options in argc/argv argument vector. +* Returns -1 if short_too is set and the option does not match long_options. +*/ +static int +parse_long_options(char * const *nargv, const char *options, +const struct option *long_options, int *idx, int short_too) +{ + char *current_argv, *has_equal; + size_t current_argv_len; + int i, ambiguous, match; + +#define IDENTICAL_INTERPRETATION(_x, _y) \ + (long_options[(_x)].has_arg == long_options[(_y)].has_arg && \ + long_options[(_x)].flag == long_options[(_y)].flag && \ + long_options[(_x)].val == long_options[(_y)].val) + + current_argv = place; + match = -1; + ambiguous = 0; + + optind++; + + if ((has_equal = strchr(current_argv, '=')) != NULL) { + /* argument found (--option=arg) */ + current_argv_len = has_equal - current_argv; + has_equal++; + } + else + current_argv_len = strlen(current_argv); + + for (i = 0; long_options[i].name; i++) { + /* find matching long option */ + if (strncmp(current_argv, long_options[i].name, + current_argv_len)) + continue; + + if (strlen(long_options[i].name) == current_argv_len) { + /* exact match */ + match = i; + ambiguous = 0; + break; + } + /* + * If this is a known short option, don't allow + * a partial match of a single character. + */ + if (short_too && current_argv_len == 1) + continue; + + if (match == -1) /* partial match */ + match = i; + else if (!IDENTICAL_INTERPRETATION(i, match)) + ambiguous = 1; + } + if (ambiguous) { + /* ambiguous abbreviation */ + if (PRINT_ERROR) + warnx(ambig, (int)current_argv_len, + current_argv); + optopt = 0; + return (BADCH); + } + if (match != -1) { /* option found */ + if (long_options[match].has_arg == no_argument + && has_equal) { + if (PRINT_ERROR) + warnx(noarg, (int)current_argv_len, + current_argv); + /* + * XXX: GNU sets optopt to val regardless of flag + */ + if (long_options[match].flag == NULL) + optopt = long_options[match].val; + else + optopt = 0; + return (BADARG); + } + if (long_options[match].has_arg == required_argument || + long_options[match].has_arg == optional_argument) { + if (has_equal) + optarg = has_equal; + else if (long_options[match].has_arg == + required_argument) { + /* + * optional argument doesn't use next nargv + */ + optarg = nargv[optind++]; + } + } + if ((long_options[match].has_arg == required_argument) + && (optarg == NULL)) { + /* + * Missing argument; leading ':' indicates no error + * should be generated. + */ + if (PRINT_ERROR) + warnx(recargstring, + current_argv); + /* + * XXX: GNU sets optopt to val regardless of flag + */ + if (long_options[match].flag == NULL) + optopt = long_options[match].val; + else + optopt = 0; + --optind; + return (BADARG); + } + } + else { /* unknown option */ + if (short_too) { + --optind; + return (-1); + } + if (PRINT_ERROR) + warnx(illoptstring, current_argv); + optopt = 0; + return (BADCH); + } + if (idx) + *idx = match; + if (long_options[match].flag) { + *long_options[match].flag = long_options[match].val; + return (0); + } + else + return (long_options[match].val); +#undef IDENTICAL_INTERPRETATION +} + +/* +* getopt_internal -- +* Parse argc/argv argument vector. Called by user level routines. +*/ +static int +getopt_internal(int nargc, char * const *nargv, const char *options, +const struct option *long_options, int *idx, int flags) +{ + char *oli; /* option letter list index */ + int optchar, short_too; + static int posixly_correct = -1; + + if (options == NULL) + return (-1); + + /* + * XXX Some GNU programs (like cvs) set optind to 0 instead of + * XXX using optreset. Work around this braindamage. + */ + if (optind == 0) + optind = optreset = 1; + + /* + * Disable GNU extensions if POSIXLY_CORRECT is set or options + * string begins with a '+'. + * + * CV, 2009-12-14: Check POSIXLY_CORRECT anew if optind == 0 or + * optreset != 0 for GNU compatibility. + */ + if (posixly_correct == -1 || optreset != 0) + posixly_correct = (getenv("POSIXLY_CORRECT") != NULL); + if (*options == '-') + flags |= FLAG_ALLARGS; + else if (posixly_correct || *options == '+') + flags &= ~FLAG_PERMUTE; + if (*options == '+' || *options == '-') + options++; + + optarg = NULL; + if (optreset) + nonopt_start = nonopt_end = -1; +start: + if (optreset || !*place) { /* update scanning pointer */ + optreset = 0; + if (optind >= nargc) { /* end of argument vector */ + place = EMSG; + if (nonopt_end != -1) { + /* do permutation, if we have to */ + permute_args(nonopt_start, nonopt_end, + optind, nargv); + optind -= nonopt_end - nonopt_start; + } + else if (nonopt_start != -1) { + /* + * If we skipped non-options, set optind + * to the first of them. + */ + optind = nonopt_start; + } + nonopt_start = nonopt_end = -1; + return (-1); + } + if (*(place = nargv[optind]) != '-' || + (place[1] == '\0' && strchr(options, '-') == NULL)) { + place = EMSG; /* found non-option */ + if (flags & FLAG_ALLARGS) { + /* + * GNU extension: + * return non-option as argument to option 1 + */ + optarg = nargv[optind++]; + return (INORDER); + } + if (!(flags & FLAG_PERMUTE)) { + /* + * If no permutation wanted, stop parsing + * at first non-option. + */ + return (-1); + } + /* do permutation */ + if (nonopt_start == -1) + nonopt_start = optind; + else if (nonopt_end != -1) { + permute_args(nonopt_start, nonopt_end, + optind, nargv); + nonopt_start = optind - + (nonopt_end - nonopt_start); + nonopt_end = -1; + } + optind++; + /* process next argument */ + goto start; + } + if (nonopt_start != -1 && nonopt_end == -1) + nonopt_end = optind; + + /* + * If we have "-" do nothing, if "--" we are done. + */ + if (place[1] != '\0' && *++place == '-' && place[1] == '\0') { + optind++; + place = EMSG; + /* + * We found an option (--), so if we skipped + * non-options, we have to permute. + */ + if (nonopt_end != -1) { + permute_args(nonopt_start, nonopt_end, + optind, nargv); + optind -= nonopt_end - nonopt_start; + } + nonopt_start = nonopt_end = -1; + return (-1); + } + } + + /* + * Check long options if: + * 1) we were passed some + * 2) the arg is not just "-" + * 3) either the arg starts with -- we are getopt_long_only() + */ + if (long_options != NULL && place != nargv[optind] && + (*place == '-' || (flags & FLAG_LONGONLY))) { + short_too = 0; + if (*place == '-') + place++; /* --foo long option */ + else if (*place != ':' && strchr(options, *place) != NULL) + short_too = 1; /* could be short option too */ + + optchar = parse_long_options(nargv, options, long_options, + idx, short_too); + if (optchar != -1) { + place = EMSG; + return (optchar); + } + } + + if ((optchar = (int)*place++) == (int)':' || + (optchar == (int)'-' && *place != '\0') || + (oli = strchr(options, optchar)) == NULL) { + /* + * If the user specified "-" and '-' isn't listed in + * options, return -1 (non-option) as per POSIX. + * Otherwise, it is an unknown option character (or ':'). + */ + if (optchar == (int)'-' && *place == '\0') + return (-1); + if (!*place) + ++optind; + if (PRINT_ERROR) + warnx(illoptchar, optchar); + optopt = optchar; + return (BADCH); + } + if (long_options != NULL && optchar == 'W' && oli[1] == ';') { + /* -W long-option */ + if (*place) /* no space */ + /* NOTHING */; + else if (++optind >= nargc) { /* no arg */ + place = EMSG; + if (PRINT_ERROR) + warnx(recargchar, optchar); + optopt = optchar; + return (BADARG); + } + else /* white space */ + place = nargv[optind]; + optchar = parse_long_options(nargv, options, long_options, + idx, 0); + place = EMSG; + return (optchar); + } + if (*++oli != ':') { /* doesn't take argument */ + if (!*place) + ++optind; + } + else { /* takes (optional) argument */ + optarg = NULL; + if (*place) /* no white space */ + optarg = place; + else if (oli[1] != ':') { /* arg not optional */ + if (++optind >= nargc) { /* no arg */ + place = EMSG; + if (PRINT_ERROR) + warnx(recargchar, optchar); + optopt = optchar; + return (BADARG); + } + else + optarg = nargv[optind]; + } + place = EMSG; + ++optind; + } + /* dump back option letter */ + return (optchar); +} + +/* +* getopt_long_only -- +* Parse argc/argv argument vector. +*/ +int +getopt_long_only(int nargc, char * const *nargv, const char *options, +const struct option *long_options, int *idx) +{ + + return (getopt_internal(nargc, nargv, options, long_options, idx, + FLAG_PERMUTE | FLAG_LONGONLY)); +} +///////////////////////////////////////////////////////////////////////////// + +#ifdef _WIN32 +int +fsync(int fd) +{ + HANDLE hFile = (HANDLE)_get_osfhandle(fd); + if (hFile == INVALID_HANDLE_VALUE) + return 1; + + return !FlushFileBuffers(hFile); +} + +int +getppid(void) +{ + // Just return any nonzero value under Windows to enable isohybrid's usage + // as a part of srand initialization. + return 1; +} +#endif Propchange: trunk/reactos/sdk/tools/isohybrid/reactos_support_code.c ------------------------------------------------------------------------------ svn:eol-style = native Added: trunk/reactos/sdk/tools/isohybrid/reactos_support_code.h URL: http://svn.reactos.org/svn/reactos/trunk/reactos/sdk/tools/isohybrid/reacto… ============================================================================== --- trunk/reactos/sdk/tools/isohybrid/reactos_support_code.h (added) +++ trunk/reactos/sdk/tools/isohybrid/reactos_support_code.h [iso-8859-1] Tue Jan 24 22:53:20 2017 @@ -0,0 +1,60 @@ +#ifndef _REACTOS_SUPPORT_CODE_H +#define _REACTOS_SUPPORT_CODE_H + +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#ifdef _WIN32 +#include <malloc.h> +#include <windows.h> +#else +#include <alloca.h> +#include <unistd.h> +#endif + +void isohybrid_error(int eval, const char* fmt, ...); +void isohybrid_warning(const char* fmt, ...); + +#define err(...) isohybrid_error(__VA_ARGS__) +#define errx(...) isohybrid_error(__VA_ARGS__) +#define warn(...) isohybrid_warning(__VA_ARGS__) +#define warnx(...) isohybrid_warning(__VA_ARGS__) + + +///////////////////////////////////////////////////////////////////////////// +// getopt code from mingw-w64 +///////////////////////////////////////////////////////////////////////////// +extern int optopt; /* single option character, as parsed */ +extern char *optarg; /* pointer to argument of current option */ + +struct option /* specification for a long form option... */ +{ + const char *name; /* option name, without leading hyphens */ + int has_arg; /* does it take an argument? */ + int *flag; /* where to save its status, or NULL */ + int val; /* its associated status value */ +}; + +enum /* permitted values for its `has_arg' field... */ +{ + no_argument = 0, /* option never takes an argument */ + required_argument, /* option always requires an argument */ + optional_argument /* option may take an argument */ +}; + +int getopt_long_only(int nargc, char * const *nargv, const char *options, const struct option *long_options, int *idx); +///////////////////////////////////////////////////////////////////////////// + +#ifdef _WIN32 +int fsync(int fd); +int getppid(void); +#endif + +#ifdef _MSC_VER +#define fseeko _fseeki64 +#define ftruncate _chsize +#endif + +#endif Propchange: trunk/reactos/sdk/tools/isohybrid/reactos_support_code.h ------------------------------------------------------------------------------ svn:eol-style = native

7 years, 8 months

[cfinck] 73594: [BOOTSECT] Overhaul our ISO boot sector: - Add another entry point for hybrid booting (called by isombr) and the hybrid signature needed for isohybrid. - Import latest isolinux.asm ...

by cfinck＠svn.reactos.org

Author: cfinck Date: Tue Jan 24 22:45:37 2017 New Revision: 73594 URL: http://svn.reactos.org/svn/reactos?rev=73594&view=rev Log: [BOOTSECT] Overhaul our ISO boot sector: - Add another entry point for hybrid booting (called by isombr) and the hybrid signature needed for isohybrid. - Import latest isolinux.asm "API" from http://repo.or.cz/syslinux.git/blob/8bbb10b70905339b7ca6b58d6833b6a95ab03da… (latest version to date) and http://repo.or.cz/syslinux.git/blob/9141c603930ef23da1e08e487a0c26750fbb4fb… (latest version that came with all functions in ASM). Among other things, this brings us getlinsec_ebios (for reading setupldr.sys in hybrid/MBR mode) and BrokenAwardHack (for working around broken Award BIOSes) - Fix upstream getlinsec_ebios to load files >64K. - Load the HDD boot sector directly to 0x7C00 instead of trackbuf. This way, we don't have to load it again when the user decides to boot from HDD. - Check for the 0xAA55 signature to decide if the HDD contains a valid MBR. This was done differently and inconsistently for isoboot and isobtrt. - Adapt the file and comment style to ReactOS guidelines. Add meaningful comments to our main code. Remove stuff that was just taken from isolinux.asm, but makes no sense for our version. - Remove DEBUG_MESSAGES ifdef. There is no chance they can ever fit into the 2K sector with all the added features. Debugging can still happen using Bochs or adding specific messages. Tested with Bochs, QEMU, VMware, VirtualBox and four real computers. Many thanks to Hermès for all the helpful suggestions and additional investigations! :) CORE-12648 Modified: trunk/reactos/boot/freeldr/bootsect/isoboot.S Modified: trunk/reactos/boot/freeldr/bootsect/isoboot.S URL: http://svn.reactos.org/svn/reactos/trunk/reactos/boot/freeldr/bootsect/isob… ============================================================================== --- trunk/reactos/boot/freeldr/bootsect/isoboot.S [iso-8859-1] (original) +++ trunk/reactos/boot/freeldr/bootsect/isoboot.S [iso-8859-1] Tue Jan 24 22:45:37 2017 @@ -1,63 +1,47 @@ /* - * COPYRIGHT: See COPYING in the top level directory - * PROJECT: ReactOS Bootsector for ISO file system - * FILE: boot/freeldr/bootsect/isoboot.S - * PURPOSE: - * PROGRAMMERS: ? - */ + * PROJECT: ReactOS Boot Sector for ISO file system (based on ISOLINUX) + * LICENSE: GNU GPLv2 or any later version as published by the Free Software Foundation + * PROGRAMMERS: H. Peter Anvin + * Michael K. Ter Louw + * Eric Kohl + * Timo Kreuzer <timo.kreuzer(a)reactos.org> + * Colin Finck <colin(a)reactos.org> + * + ***************************************************************************** + * + * isolinux.asm + * + * A program to boot Linux kernels off a CD-ROM using the El Torito + * boot standard in "no emulation" mode, making the entire filesystem + * available. It is based on the SYSLINUX boot loader for MS-DOS + * floppies. + * + * Copyright 1994-2009 H. Peter Anvin - All Rights Reserved + * Copyright 2009 Intel Corporation *author: H. Peter Anvin + * + * This program is free software *you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, Inc., 53 Temple Place Ste 330, + * Boston MA 02111-1307, USA *either version 2 of the License, or + * (at your option) any later version *incorporated herein by reference. + * + *****************************************************************************/ /* INCLUDES ******************************************************************/ - #include <asm.inc> #include <freeldr/include/arch/pc/x86common.h> -.code16 - -// **************************************************************************** -// -// isolinux.asm -// -// A program to boot Linux kernels off a CD-ROM using the El Torito -// boot standard in "no emulation" mode, making the entire filesystem -// available. It is based on the SYSLINUX boot loader for MS-DOS -// floppies. -// -// Copyright (C) 1994-2001 H. Peter Anvin -// -// This program is free software; you can redistribute it and/or modify -// it under the terms of the GNU General Public License as published by -// the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, -// USA; either version 2 of the License, or (at your option) any later -// version; incorporated herein by reference. -// -// **************************************************************************** -// -// THIS FILE IS A MODIFIED VERSION OF ISOLINUX.ASM -// MODIFICATION DONE BY MICHAEL K TER LOUW -// LAST UPDATED 3-9-2002 -// SEE "COPYING" FOR INFORMATION ABOUT THE LICENSE THAT APPLIES TO THIS RELEASE -// -// **************************************************************************** -// -// This file is a modified version of ISOLINUX.ASM. -// Modification done by Eric Kohl -// Last update 04-25-2002 -// -// **************************************************************************** - -//#define DEBUG_MESSAGES /* Uncomment to get debugging messages */ #ifndef ROS_REGTEST #define WAIT_FOR_KEY #endif -// **************************************************************************** -// BEGIN THE BIOS/CODE/DATA SEGMENT -// **************************************************************************** -serial_base = HEX(0400) // Base addresses for 4 serial ports (4 words) -BIOS_fbm = HEX(0413) // Free Base Memory (kilobytes) (1 word) + +.code16 +ASSUME CS:.text, DS:.text, ES:.text + +/* CONSTANTS ******************************************************************/ BIOS_timer = HEX(046C) // Timer ticks (1 word) BIOS_magic = HEX(0472) // BIOS reset magic (1 word) -BIOS_vidrows = HEX(0484) // Number of screen rows (1 byte) // Memory below this point is reserved for the BIOS and the MBR trackbuf = HEX(1000) // Track buffer goes here (8192 bytes) @@ -65,132 +49,150 @@ // struct open_file_t file_sector = 0 // Sector pointer (0 = structure free) -file_left = 4 // Number of sectors left - -//struct dir_t +file_bytesleft = 4 // Number of bytes left +file_left = 8 // Number of sectors left +// Another unused DWORD follows here in ISOLINUX +#define open_file_t_size 16 + +// struct dir_t dir_lba = 0 // Directory start (LBA) dir_len = 4 // Length in bytes dir_clust = 8 // Length in clusters - #define dir_t_size 12 -#define open_file_t_size 8 MAX_OPEN_LG2 = 2 // log2(Max number of open files) MAX_OPEN = 4 -SECTORSIZE_LG2 = 11 // 2048 bytes/sector (El Torito requirement) -SECTORSIZE = 2048 -retry_count = 6 // How patient are we with the BIOS? - -/******************************************************************************/ +SECTOR_SHIFT = 11 // 2048 bytes/sector (El Torito requirement) +SECTOR_SIZE = 2048 +retry_count = 6 // How patient are we with the BIOS? + +/* UNINITIALIZED VARIABLES ****************************************************/ absolute HEX(5000) // Here we keep our BSS stuff -resb DriveNo, 1 // CD-ROM BIOS drive number (BYTE) -resb DiskError, 1 // Error code for disk I/O (BYTE) -resb RetryCount, 1 // Used for disk access retries (BYTE) -resb TimeoutCount, 1 // Timeout counter (BYTE) -resb ISOFlags, 1 // Flags for ISO directory search (BYTE) -resb RootDir, dir_t_size // Root directory (dir_t_size BYTES) -resb CurDir, dir_t_size // Current directory (dir_t_size BYTES) resb ISOFileName, 64 // ISO filename canonicalization buffer resb ISOFileNameEnd, 1 +resb CurrentDir, dir_t_size // Current directory +resb RootDir, dir_t_size // Root directory +resb DiskSys, 2 // Last INT 13h call +resb GetlinsecPtr, 2 // The sector-read pointer +resb DiskError, 1 // Error code for disk I/O +resb DriveNumber, 1 // CD-ROM BIOS drive number +resb ISOFlags, 1 // Flags for ISO directory search +resb RetryCount, 1 // Used for disk access retries //align open_file_t_size -absolute HEX(5060) +absolute HEX(5070) resb Files, (MAX_OPEN * open_file_t_size) -/******************************************************************************/ - - +/* ENTRY POINTS ***************************************************************/ + +// Entry point when booted from CD (El Torito standard) start: - cli // Disable interrupts - xor ax, ax // ax = segment zero - mov ss, ax // Initialize stack segment - mov sp, offset start // Set up stack - mov ds, ax // Initialize other segment registers + mov bx, offset getlinsec_cdrom + // Fall through + +start_common: + // Set up our stack and a flat addressing model. + cli + xor ax, ax + mov ss, ax + mov sp, offset start + mov ds, ax mov es, ax mov fs, ax mov gs, ax - sti // Enable interrupts - cld // Increment pointers - - mov cx, 2048 / 4 // Copy the bootsector - mov si, HEX(7C00) // from 0000:7C00 - mov di, HEX(7000) // to 0000:7000 - rep movsd // copy the program - - ljmp16 0, relocate // jump into relocated code - -relocate: -#ifdef DEBUG_MESSAGES - // Display the banner and copyright - mov si, offset isolinux_banner // si points to hello message - call writestr // display the message - mov si, offset copyright_str - call writestr -#endif + sti + + // Our boot sector has been loaded to address 0x7C00. + // Relocate our 2048 bytes boot sector to the given base address (should be 0x7000). + cld + mov cx, 2048 / 4 + mov si, HEX(7C00) + mov di, offset start + rep movsd + + ljmp16 0, relocated // jump into relocated code + +.org 64 +hybrid_signature: + .long HEX(7078c0fb) + +// Entry point when booted through ISOMBR from a drive (isohybrid mode) +start_hybrid: + mov bx, offset getlinsec_ebios + jmp start_common + +relocated: + // Save our passed variables (BX from the entry point, DL from the BIOS) before anybody clobbers the registers. + mov word ptr ds:[GetlinsecPtr], bx + mov byte ptr ds:[DriveNumber], dl // Make sure the keyboard buffer is empty call pollchar_and_empty - // Check for MBR on harddisk - pusha - mov ax, HEX(0201) - mov dx, HEX(0080) - mov cx, HEX(0001) - mov bx, trackbuf - int HEX(13) - popa - jc .boot_cdrom // could not read hdd - - push ax -#ifdef ROS_REGTEST // this change is taken from the original isobtrt.asm - mov ax, word ptr ds:[trackbuf+510] -#else - mov ax, word ptr ds:[trackbuf] -#endif - cmp ax, 0 - je .boot_cdrom // no boot sector found (hopefully there are no weird bootsectors which begin with 0) - pop ax - -#ifdef WAIT_FOR_KEY - // Display the 'Press key' message and wait for a maximum of 5 seconds - call crlf - mov si, offset presskey_msg // si points to 'Press key' message - call writestr // display the message - - mov byte ptr ds:[TimeoutCount], 5 -.next_second: - mov eax, ds:[BIOS_timer] // load current tick counter - add eax, 19 - -.poll_again: - call pollchar_and_empty - jnz .boot_cdrom - - mov ebx, ds:[BIOS_timer] - cmp eax, ebx - jnz .poll_again - - mov si, offset dot_msg // print '.' - call writestr - dec byte ptr ds:[TimeoutCount] // decrement timeout counter - jz .boot_harddisk - jmp .next_second -#endif - -.boot_harddisk: - call crlf - - // Boot first harddisk (drive 0x80) + // If we're booting in hybrid mode and our boot drive is the first HDD (drive 80h), + // we have no other option than booting into SETUPLDR. + cmp word ptr ds:[GetlinsecPtr], offset getlinsec_ebios + jne .read_mbr + cmp byte ptr ds:[DriveNumber], HEX(80) + je .boot_setupldr + +.read_mbr: + // Read the first sector (MBR) from the first hard disk (drive 80h) to 7C00h. + // If we then decide to boot from HDD, we already have it at the right place. + // In case of an error (indicated by the Carry Flag), just boot SETUPLDR from our ReactOS Medium. mov ax, HEX(0201) mov dx, HEX(0080) mov cx, HEX(0001) mov bx, HEX(7C00) - int HEX(13) - jnc .go_hd - jmp kaboom -.go_hd: + call int13 + jc .boot_setupldr + + // Verify the signature of the read MBR. + // If it's invalid, there is probably no OS installed and we just boot SETUPLDR from our ReactOS Medium. + mov ax, word ptr ds:[HEX(7C00)+510] + cmp ax, HEX(AA55) + jne .boot_setupldr + +#ifdef WAIT_FOR_KEY + // We could either boot from the ReactOS Medium or from hard disk. Let the user decide! + // Display the 'Press key' message. + call crlf_early + mov si, offset presskey_msg + call writestr_early + + // Count down 5 seconds. + mov cx, 5 + +.next_second: + // Count in seconds using the BIOS Timer, which runs roughly at 19 ticks per second. + // Load its value plus one second into EAX for comparison later. + mov eax, ds:[BIOS_timer] + add eax, 19 + +.poll_again: + // Check for a keypress, boot SETUPLDR from our ReactOS Medium if a key was pressed. + call pollchar_and_empty + jnz .boot_setupldr + + // Check if another second has passed (in BIOS Timer ticks). + mov ebx, ds:[BIOS_timer] + cmp eax, ebx + jnz .poll_again + + // Another second has passed, so print the dot and decrement the second counter. + // If the user hasn't pressed a key after the entire 5 seconds have elapsed, just boot from the first hard disk. + mov si, offset dot_msg + call writestr_early + dec cx + jz .boot_harddisk + jmp .next_second +#endif + +.boot_harddisk: + // Restore a clean context for the hard disk MBR and boot the already loaded MBR. + call crlf_early mov ax, cs mov ds, ax mov es, ax @@ -200,336 +202,425 @@ ljmp16 0, HEX(7C00) -.boot_cdrom: +.boot_setupldr: #ifdef WAIT_FOR_KEY - call crlf - call crlf + call crlf_early + call crlf_early #endif - // Save and display the boot drive number - mov byte ptr ds:[DriveNo], dl -#ifdef DEBUG_MESSAGES - mov si, offset startup_msg + // The BIOS gave us a boot drive number, so in a perfect world we could just use that one now. + // Unfortunately, there are many broken BIOSes around, which is why ISOLINUX verifies it and applies some hacks if the number is wrong. + // Let's do exactly the same here to achieve maximum compatibility. + + // Don't do this if we are running in hybrid mode. + cmp word ptr ds:[GetlinsecPtr], offset getlinsec_ebios + je found_drive + + // Use the INT 13 function 4B01h (Get Disk Emulation Status) to fetch the El Torito Spec Packet. + // We can use this information to verify that our passed boot drive number really belongs to our CD. + mov ax, HEX(4B01) + mov dl, byte ptr ds:[DriveNumber] + mov si, offset spec_packet + call int13 + + // If this INT 13 function yields an error, we may be on a broken AWARD BIOS. + // Check this and patch if possible. + jc award_hack + + // Check that our passed boot drive number and the number in the Spec Packet match. + // If not, try some workarounds to find our drive anyway. + mov dl, byte ptr ds:[DriveNumber] + cmp byte ptr ds:[sp_drive], dl + jne spec_query_failed + +found_drive: + // Clear Files structures + mov di, Files + mov cx, (MAX_OPEN*open_file_t_size)/4 + xor eax, eax + rep stosd + + // Read the entire 2K-sized ISO9660 Primary Volume Descriptor at sector 16 (32K). + // This calculation only holds for single-session ISOs, but we should never encounter anything else. + mov eax, 16 + mov bx, trackbuf + call getonesec + + // Read the LBA address (offset 2 in the Directory Record) of the root directory (offset 156 in the Primary Volume Descriptor). + mov eax, dword ptr ds:[trackbuf+156+2] + mov dword ptr ds:[RootDir+dir_lba], eax + mov dword ptr ds:[CurrentDir+dir_lba], eax + + // Read the data length (offset 10 in the Directory Record) of the root directory (offset 156 in the Primary Volume Descriptor). + mov eax, dword ptr ds:[trackbuf+156+10] + mov dword ptr ds:[RootDir+dir_len], eax + mov dword ptr ds:[CurrentDir+dir_len], eax + + // Calculate the number of clusters and write that to our RootDir and CurrentDir structures. + add eax, SECTOR_SIZE-1 + shr eax, SECTOR_SHIFT + mov dword ptr ds:[RootDir+dir_clust],eax + mov dword ptr ds:[CurrentDir+dir_clust],eax + + // Look for the "LOADER" directory (directory is indicated by AL = 2 when using searchdir_iso). + mov di, offset loader_dir + mov al, 2 + call searchdir_iso + jnz .dir_found + + // No directory was found, so bail out with an error message. + mov si, offset no_dir_msg + call writemsg + jmp kaboom + +.dir_found: + // The directory was found, so update the information in our CurrentDir structure. + // Free the file pointer entry at SI in the process. + mov dword ptr ds:[CurrentDir+dir_len], eax + mov eax, dword ptr ds:[si+file_left] + mov dword ptr ds:[CurrentDir+dir_clust], eax + xor eax, eax + xchg eax, dword ptr ds:[si+file_sector] + mov dword ptr ds:[CurrentDir+dir_lba], eax + + // Look for the "SETUPLDR.SYS" file. + mov di, offset setupldr_sys + call searchdir + jnz .setupldr_found + + // The SETUPLDR file was not found, so bail out with an error message. + mov si, offset no_setupldr_msg + call writemsg + jmp kaboom + +.setupldr_found: + // Calculate the rounded up number of 2K sectors that need to be read. + mov ecx, eax + shr ecx, SECTOR_SHIFT + test eax, HEX(7FF) + jz .load_setupldr + inc ecx + +.load_setupldr: + // Load the entire SETUPLDR.SYS (parameter CX = FFFFh) to its designated base address FREELDR_BASE. + // Using a high segment address with offset 0 instead of segment 0 with offset FREELDR_BASE apparently increases compatibility with some BIOSes. + mov bx, FREELDR_BASE / 16 + mov es, bx + xor ebx, ebx + mov cx, HEX(FFFF) + call getfssec + + // Fetch our stored drive number to DL and set the boot partition to 0 in DH. + mov dl, byte ptr ds:[DriveNumber] + mov dh, 0 + + // Transfer execution to the bootloader. + ljmp16 0, FREELDR_BASE + + +/* FUNCTIONS *****************************************************************/ + +/////////////////////////////////////////////////////////////////////////////// +// Start of BrokenAwardHack --- 10-nov-2002 Knut_Petersen(a)t-online.de +/////////////////////////////////////////////////////////////////////////////// +// +// There is a problem with certain versions of the AWARD BIOS ... +// the boot sector will be loaded and executed correctly, but, because the +// int 13 vector points to the wrong code in the BIOS, every attempt to +// load the spec packet will fail. We scan for the equivalent of +// +// mov ax,0201h +// mov bx,7c00h +// mov cx,0006h +// mov dx,0180h +// pushf +// call <direct far> +// +// and use <direct far> as the new vector for int 13. The code above is +// used to load the boot code into ram, and there should be no reason +// for anybody to change it now or in the future. There are no opcodes +// that use encodings relativ to IP, so scanning is easy. If we find the +// code above in the BIOS code we can be pretty sure to run on a machine +// with an broken AWARD BIOS ... +// +/////////////////////////////////////////////////////////////////////////////// +award_oldint13: + .long 0 +award_string: + .byte HEX(0b8),1,2,HEX(0bb),0,HEX(7c),HEX(0b9),6,0,HEX(0ba),HEX(80),1,HEX(09c),HEX(09a) + +award_hack: + mov si, offset spec_err_msg // Moved to this place from + call writemsg // spec_query_failed + + mov eax, dword ptr ds:[HEX(13)*4] + mov dword ptr ds:[award_oldint13], eax + + push es + mov ax, HEX(F000) // ES = BIOS Seg + mov es, ax + cld + xor di, di // start at ES:DI = f000:0 +award_loop: + push di // save DI + mov si, offset award_string // scan for award_string + mov cx, 7 // length of award_string = 7dw + repz cmpsw // compare + pop di // restore DI + jcxz award_found // jmp if found + inc di // not found, inc di + jno award_loop + +award_failed: + pop es // No, not this way :-(( +award_fail2: + mov eax, dword ptr ds:[award_oldint13] // restore the original int + or eax, eax // 13 vector if there is one + jz spec_query_failed // and try other workarounds + mov dword ptr ds:[HEX(13)*4], eax + jmp spec_query_failed + +award_found: + mov eax, dword ptr es:[di+HEX(0e)] // load possible int 13 addr + pop es // restore ES + + cmp eax, dword ptr ds:[award_oldint13] // give up if this is the + jz award_failed // active int 13 vector, + mov dword ptr ds:[HEX(13)*4], eax // otherwise change 0:13h*4 + + mov ax, HEX(4B01) // try to read the spec packet + mov dl, byte ptr ds:[DriveNumber] // now ... it should not fail + mov si, offset spec_packet // any longer + int HEX(13) + jc award_fail2 + + jmp found_drive // and leave error recovery code +/////////////////////////////////////////////////////////////////////////////// +// End of BrokenAwardHack ---- 10-nov-2002 Knut_Petersen(a)t-online.de +/////////////////////////////////////////////////////////////////////////////// + + +// INT 13h, AX=4B01h, DL=<passed in value> failed. +// Try to scan the entire 80h-FFh from the end. +spec_query_failed: + // some code moved to BrokenAwardHack + + mov dl, HEX(FF) + +.test_loop: + pusha + mov ax, HEX(4B01) + mov si, offset spec_packet + mov byte ptr ds:[si], HEX(13) // Size of buffer + call int13 + popa + jc .still_broken + + mov si, offset maybe_msg call writemsg mov al, dl call writehex2 - call crlf -#endif - - // Now figure out what we're actually doing - // Note: use passed-in DL value rather than 7Fh because - // at least some BIOSes will get the wrong value otherwise - mov ax, HEX(4B01) // Get disk emulation status - mov dl, byte ptr ds:[DriveNo] - mov si, offset spec_packet - int HEX(13) - jc spec_query_failed // Shouldn't happen (BIOS bug) - mov dl, byte ptr ds:[DriveNo] - cmp byte ptr ds:[sp_drive], dl // Should contain the drive number - jne spec_query_failed - -#ifdef DEBUG_MESSAGES - mov si, offset spec_ok_msg + call crlf_early + + cmp byte ptr ds:[sp_drive], dl + jne .maybe_broken + + // Okay, good enough... + mov si, offset alright_msg call writemsg - mov al, byte ptr ds:[sp_drive] +.found_drive0: + mov byte ptr ds:[DriveNumber], dl +.found_drive: + jmp found_drive + + // Award BIOS 4.51 apparently passes garbage in sp_drive, + // but if this was the drive number originally passed in + // DL then consider it "good enough" +.maybe_broken: + mov al, byte ptr ds:[DriveNumber] + cmp al, dl + je .found_drive + + // Intel Classic R+ computer with Adaptec 1542CP BIOS 1.02 + // passes garbage in sp_drive, and the drive number originally + // passed in DL does not have 80h bit set. + or al, HEX(80) + cmp al, dl + je .found_drive0 + +.still_broken: + dec dx + cmp dl, HEX(80) + jnb .test_loop + + // No spec packet anywhere. Some particularly pathetic + // BIOSes apparently don't even implement function + // 4B01h, so we can't query a spec packet no matter + // what. If we got a drive number in DL, then try to + // use it, and if it works, then well... + mov dl, byte ptr ds:[DriveNumber] + cmp dl, HEX(81) // Should be 81-FF at least + jb fatal_error // If not, it's hopeless + + // Write a warning to indicate we're on *very* thin ice now + mov si, offset nospec_msg + call writemsg + mov al, dl call writehex2 - call crlf -#endif - -found_drive: - // Get drive information - mov ah, HEX(48) - mov dl, byte ptr ds:[DriveNo] - mov si, offset drive_params - int HEX(13) - jnc params_ok - - // mov si, nosecsize_msg No use in reporting this - // call writemsg - -params_ok: - // Check for the sector size (should be 2048, but - // some BIOSes apparently think we're 512-byte media) - // - // FIX: We need to check what the proper behaviour - // is for getlinsec when the BIOS thinks the sector - // size is 512!!! For that, we need such a BIOS, though... -#ifdef DEBUG_MESSAGES - mov si, offset secsize_msg + call crlf_early + jmp .found_drive // Pray that this works... + +fatal_error: + mov si, offset nothing_msg call writemsg - mov ax, word ptr ds:[dp_secsize] - call writehex4 - call crlf -#endif - - - // - // Clear Files structures - // - mov di, Files - mov cx, (MAX_OPEN*open_file_t_size)/4 - xor eax, eax - rep stosd - - // - // Now, we need to sniff out the actual filesystem data structures. - // mkisofs gave us a pointer to the primary volume descriptor - // (which will be at 16 only for a single-session disk!); from the PVD - // we should be able to find the rest of what we need to know. - // -get_fs_structures: - mov eax, 16 // Primary Volume Descriptor (sector 16) - mov bx, trackbuf - call getonesec - - mov eax, dword ptr ds:[trackbuf+156+2] - mov dword ptr ds:[RootDir+dir_lba],eax - mov dword ptr ds:[CurDir+dir_lba],eax -#ifdef DEBUG_MESSAGES - mov si, offset rootloc_msg - call writemsg - call writehex8 - call crlf -#endif - - mov eax, dword ptr ds:[trackbuf+156+10] - mov dword ptr ds:[RootDir+dir_len],eax - mov dword ptr ds:[CurDir+dir_len],eax -#ifdef DEBUG_MESSAGES - mov si, offset rootlen_msg - call writemsg - call writehex8 - call crlf -#endif - add eax,SECTORSIZE-1 - shr eax,SECTORSIZE_LG2 - mov dword ptr ds:[RootDir+dir_clust],eax - mov dword ptr ds:[CurDir+dir_clust],eax -#ifdef DEBUG_MESSAGES - mov si, offset rootsect_msg - call writemsg - call writehex8 - call crlf -#endif - - // Look for the "REACTOS" directory, and if found, - // make it the current directory instead of the root - // directory. - mov di, offset isolinux_dir - mov al, 2 // Search for a directory - call searchdir_iso - jnz .dir_found - mov si, offset no_dir_msg - call writemsg - jmp kaboom - -.dir_found: - mov dword ptr ds:[CurDir+dir_len],eax - mov eax, dword ptr ds:[si+file_left] - mov dword ptr ds:[CurDir+dir_clust],eax - xor eax,eax // Free this file pointer entry - xchg eax,dword ptr ds:[si+file_sector] - mov dword ptr ds:[CurDir+dir_lba],eax - - - mov di, offset isolinux_bin // di points to Isolinux filename - call searchdir // look for the file - jnz .isolinux_opened // got the file - mov si, offset no_isolinux_msg // si points to error message - call writemsg // display the message - jmp kaboom // fail boot - -.isolinux_opened: - mov di, si // save file pointer - -#ifdef DEBUG_MESSAGES - mov si, offset filelen_msg - call writemsg - call writehex8 - call crlf -#endif - - mov ecx, eax // calculate sector count - shr ecx, 11 - test eax, HEX(7FF) - jz .full_sector - inc ecx -.full_sector: - -#ifdef DEBUG_MESSAGES - mov eax, ecx - mov si, offset filesect_msg - call writemsg - call writehex8 - call crlf -#endif - -// use high segment, as some bios can fail, when offset is too big - mov bx, FREELDR_BASE / 16 // es = load segment - mov es, bx - xor ebx, ebx // bx = load offset - mov si, di // restore file pointer - mov cx, HEX(0FFFF) // load the whole file - call getfssec // get the whole file - -#ifdef DEBUG_MESSAGES - mov si, offset startldr_msg - call writemsg - call crlf -#endif - - mov dl, byte ptr ds:[DriveNo] // dl = boot drive - mov dh, 0 // dh = boot partition - - /* Transfer execution to the bootloader */ - ljmp16 0, FREELDR_BASE + +.norge: + jmp short .norge // // searchdir: // -// Open a file -// -// On entry: -// DS:DI = filename -// If successful: -// ZF clear -// SI = file pointer -// DX:AX or EAX = file length in bytes -// If unsuccessful -// ZF set -// - +// Open a file +// +// On entry: +// DS:DI = filename +// If successful: +// ZF clear +// SI = file pointer +// EAX = file length in bytes +// If unsuccessful +// ZF set +// +// Assumes CS == DS == ES, and trashes BX and CX. // // searchdir_iso is a special entry point for ISOLINUX only. In addition // to the above, searchdir_iso passes a file flag mask in AL. This is useful // for searching for directories. // alloc_failure: - xor ax,ax // ZF <- 1 + xor ax, ax // ZF <- 1 ret searchdir: - xor al, al + xor al, al searchdir_iso: - mov byte ptr ds:[ISOFlags],al - call allocate_file // Temporary file structure for directory + mov byte ptr ds:[ISOFlags], al + call allocate_file // Temporary file structure for directory jnz alloc_failure - push es - push ds - pop es // ES = DS - mov si, offset CurDir - cmp byte ptr ds:[di], 92 //'\' // If filename begins with slash - jne .not_rooted - inc di // Skip leading slash - mov si, offset RootDir // Reference root directory instead + push es + push ds + pop es // ES = DS + mov si, offset CurrentDir + cmp byte ptr ds:[di], '/' // If filename begins with slash + jne .not_rooted + inc di // Skip leading slash + mov si, offset RootDir // Reference root directory instead .not_rooted: mov eax, dword ptr ds:[si+dir_clust] - mov dword ptr ds:[bx+file_left],eax - mov eax,dword ptr ds:[si+dir_lba] - mov dword ptr ds:[bx+file_sector],eax - mov edx,dword ptr ds:[si+dir_len] + mov dword ptr ds:[bx+file_left], eax + shl eax, SECTOR_SHIFT + mov dword ptr ds:[bx+file_bytesleft], eax + mov eax, dword ptr ds:[si+dir_lba] + mov dword ptr ds:[bx+file_sector], eax + mov edx, dword ptr ds:[si+dir_len] .look_for_slash: - mov ax,di + mov ax, di .scan: mov cl, byte ptr ds:[di] - inc di - and cl,cl - jz .isfile - cmp cl, 92 // '\' - jne .scan - mov byte ptr ds:[di-1], 0 // Terminate at directory name - mov cl,2 // Search for directory - xchg cl, byte ptr ds:[ISOFlags] - push di - push cx - push offset .resume // Where to "return" to - push es + inc di + and cl, cl + jz .isfile + cmp cl, '/' + jne .scan + mov byte ptr ds:[di-1], 0 // Terminate at directory name + mov cl, 2 // Search for directory + xchg cl, byte ptr ds:[ISOFlags] + + push di // Save these... + push cx + + // Create recursion stack frame... + push offset .resume // Where to "return" to + push es .isfile: - xchg ax,di + xchg ax, di .getsome: // Get a chunk of the directory - mov si,trackbuf + // This relies on the fact that ISOLINUX doesn't change SI + mov si, trackbuf pushad - xchg bx,si - mov cx,1 // load one sector + xchg bx, si + mov cx, word ptr ds:[BufSafe] call getfssec popad .compare: - movzx eax, byte ptr ds:[si] // Length of directory entry + movzx eax, byte ptr ds:[si] // Length of directory entry cmp al, 33 - jb .next_sector + jb .next_sector mov cl, byte ptr ds:[si+25] - xor cl, byte ptr ds:[ISOFlags] - test cl, HEX(8E) // Unwanted file attributes! + xor cl, byte ptr ds:[ISOFlags] + test cl, HEX(8E) // Unwanted file attributes! jnz .not_file pusha - movzx cx, byte ptr ds:[si+32] // File identifier length - add si, 33 // File identifier offset + movzx cx, byte ptr ds:[si+32] // File identifier length + add si, 33 // File identifier offset call iso_compare_names popa - je .success + je .success .not_file: - sub edx, eax // Decrease bytes left - jbe .failure - add si, ax // Advance pointer + sub edx, eax // Decrease bytes left + jbe .failure + add si, ax // Advance pointer .check_overrun: // Did we finish the buffer? cmp si, trackbuf+trackbufsize - jb .compare // No, keep going - - jmp .getsome // Get some more directory + jb .compare // No, keep going + + jmp short .getsome // Get some more directory .next_sector: // Advance to the beginning of next sector - lea ax, [si+SECTORSIZE-1] - and ax, not (SECTORSIZE-1) - sub ax, si - jmp .not_file // We still need to do length checks + lea ax, [si+SECTOR_SIZE-1] + and ax, not (SECTOR_SIZE-1) + sub ax, si + jmp short .not_file // We still need to do length checks .failure: -#ifdef DEBUG_MESSAGES - mov si, offset findfail_msg - call writemsg - call crlf -#endif - xor eax, eax // ZF = 1 + xor eax, eax // ZF = 1 mov dword ptr ds:[bx+file_sector], eax - pop es + pop es ret .success: - mov eax, dword ptr ds:[si+2] // Location of extent + mov eax, dword ptr ds:[si+2] // Location of extent mov dword ptr ds:[bx+file_sector], eax - mov eax, dword ptr ds:[si+10] // Data length - push eax - add eax, SECTORSIZE-1 - shr eax, SECTORSIZE_LG2 + mov eax, dword ptr ds:[si+10] // Data length + mov dword ptr ds:[bx+file_bytesleft], eax + push eax + add eax, SECTOR_SIZE-1 + shr eax, SECTOR_SHIFT mov dword ptr ds:[bx+file_left], eax - pop eax - mov edx, eax - shr edx, 16 - and bx, bx // ZF = 0 + pop eax + jz .failure // Empty file? + // ZF = 0 mov si, bx - pop es + pop es ret .resume: // We get here if we were only doing part of a lookup // This relies on the fact that .success returns bx == si - xchg edx, eax // Directory length in edx - pop cx // Old ISOFlags - pop di // Next filename pointer - - // restore the backslash in the filename - mov byte ptr ds:[di-1], 92 // '\' - - mov byte ptr ds:[ISOFlags], cl // Restore the flags - jz .failure // Did we fail? If so fail for real! - jmp .look_for_slash // Otherwise, next level + xchg edx, eax // Directory length in edx + pop cx // Old ISOFlags + pop di // Next filename pointer + mov byte ptr ds:[di-1], '/' // Restore slash + mov byte ptr ds:[ISOFlags], cl // Restore the flags + jz .failure // Did we fail? If so fail for real! + jmp .look_for_slash // Otherwise, next level // // allocate_file: Allocate a file structure @@ -546,12 +637,12 @@ mov cx, MAX_OPEN .check: cmp dword ptr ds:[bx], 0 - je .found - add bx, open_file_t_size // ZF = 0 - loop .check + je .found + add bx, open_file_t_size // ZF = 0 + loop .check // ZF = 0 if we fell out of the loop .found: - pop cx + pop cx ret // @@ -565,236 +656,170 @@ // iso_compare_names: // First, terminate and canonicalize input filename - push di + push di mov di, offset ISOFileName .canon_loop: - jcxz .canon_end + jcxz .canon_end lodsb - dec cx + dec cx cmp al, ';' - je .canon_end - and al, al - je .canon_end + je .canon_end + and al, al + je .canon_end stosb - cmp di, offset ISOFileNameEnd-1 // Guard against buffer overrun - jb .canon_loop + cmp di, offset ISOFileNameEnd-1 // Guard against buffer overrun + jb .canon_loop .canon_end: cmp di, ISOFileName - jbe .canon_done - cmp byte ptr ds:[di-1], '.' // Remove terminal dots - jne .canon_done - dec di - jmp short .canon_end + jbe .canon_done + cmp byte ptr ds:[di-1], '.' // Remove terminal dots + jne .canon_done + dec di + jmp short .canon_end .canon_done: - mov byte ptr ds:[di], 0 // Null-terminate string - pop di + mov byte ptr ds:[di], 0 // Null-terminate string + pop di mov si, ISOFileName .compare2: lodsb mov ah, byte ptr ds:[di] - inc di - and ax, ax - jz .success2 // End of string for both - and al, al // Is either one end of string? - jz .failure2 // If so, failure - and ah, ah - jz .failure2 - or ax, HEX(2020) // Convert to lower case + inc di + and ax, ax + jz .success2 // End of string for both + and al, al // Is either one end of string? + jz .failure2 // If so, failure + and ah, ah + jz .failure2 + or ax, HEX(2020) // Convert to lower case cmp al, ah - je .compare2 + je .compare2 .failure2: - and ax, ax // ZF = 0 (at least one will be nonzero) + and ax, ax // ZF = 0 (at least one will be nonzero) .success2: ret - - - - - - // // getfssec: Get multiple clusters from a file, given the file pointer. // // On entry: -// ES:BX -> Buffer -// SI -> File pointer -// CX -> Cluster count; 0FFFFh = until end of file +// ES:BX -> Buffer +// SI -> File pointer +// CX -> Cluster count // On exit: -// SI -> File pointer (or 0 on EOF) -// CF = 1 -> Hit EOF +// SI -> File pointer (or 0 on EOF) +// CF = 1 -> Hit EOF +// ECX -> Bytes actually read // getfssec: - cmp cx, word ptr ds:[si+file_left] - jna .ok_size - mov cx, word ptr ds:[si+file_left] - + push ds + push cs + pop ds // DS <- CS + + movzx ecx, cx + cmp ecx, dword ptr ds:[si+file_left] + jna .ok_size + mov ecx, dword ptr ds:[si+file_left] .ok_size: + pushad + mov eax, dword ptr ds:[si+file_sector] mov bp, cx - push cx - push si - mov eax, dword ptr ds:[si+file_sector] call getlinsec - xor ecx, ecx - pop si - pop cx - - add dword ptr ds:[si+file_sector], ecx - sub dword ptr ds:[si+file_left], ecx - ja .not_eof // CF = 0 - - xor ecx, ecx - mov dword ptr ds:[si+file_sector], ecx // Mark as unused - xor si,si + popad + + // ECX[31:16] == 0 here... + add dword ptr ds:[si+file_sector], ecx + sub dword ptr ds:[si+file_left], ecx + shl ecx, SECTOR_SHIFT // Convert to bytes + cmp ecx, dword ptr ds:[si+file_bytesleft] + jb .not_all + mov ecx, dword ptr ds:[si+file_bytesleft] +.not_all: + sub dword ptr ds:[si+file_bytesleft], ecx + jnz .ret // CF = 0 in this case... + push eax + xor eax, eax + mov dword ptr ds:[si+file_sector], eax // Unused + mov si, ax + pop eax stc - -.not_eof: - ret - - -// INT 13h, AX=4B01h, DL=<passed in value> failed. -// Try to scan the entire 80h-FFh from the end. -spec_query_failed: - mov si, offset spec_err_msg - call writemsg - - mov dl, HEX(0FF) -.test_loop: - pusha - mov ax, HEX(4B01) - mov si, offset spec_packet - mov byte ptr ds:[si], 13 // Size of buffer - int HEX(13) - popa - jc .still_broken - - mov si, offset maybe_msg - call writemsg - mov al, dl - call writehex2 - call crlf - - cmp byte ptr ds:[sp_drive], dl - jne .maybe_broken - - // Okay, good enough... - mov si, offset alright_msg - call writemsg - mov byte ptr ds:[DriveNo], dl -.found_drive: - jmp found_drive - - // Award BIOS 4.51 apparently passes garbage in sp_drive, - // but if this was the drive number originally passed in - // DL then consider it "good enough" -.maybe_broken: - cmp byte ptr ds:[DriveNo], dl - je .found_drive - -.still_broken: - dec dx - cmp dl, HEX(80) - jnb .test_loop - -fatal_error: - mov si, offset nothing_msg - call writemsg - -.norge: - jmp .norge - - - +.ret: + pop ds + ret + +// // Information message (DS:SI) output -// Prefix with "isolinux: " +// Prefix with "ISOBOOT: " +// writemsg: - push ax - push si - mov si, offset isolinux_str - call writestr - pop si - call writestr - pop ax - ret - -// -// crlf: Print a newline -crlf: - mov si, offset crlf_msg - // Fall through - -// -// writestr: write a null-terminated string to the console, saving -// registers on entry. -// -writestr: + push ax + push si + mov si, offset isoboot_str + call writestr_early + pop si + call writestr_early + pop ax + ret + +writestr_early: pushfd pushad -writestr_top: +.top: lodsb - and al, al - jz writestr_end + and al, al + jz .end_writestr call writechr - jmp short writestr_top -writestr_end: + jmp short .top +.end_writestr: popad popfd ret -// -// writehex[248]: Write a hex number in (AL, AX, EAX) to the console -// -writehex2: - pushfd - pushad - shl eax, 24 - mov cx, 2 - jmp short writehex_common -writehex4: - pushfd - pushad - shl eax, 16 - mov cx, 4 - jmp short writehex_common -writehex8: - pushfd - pushad - mov cx, 8 -writehex_common: -.loop: - rol eax, 4 - push eax - and al, HEX(0F) - cmp al, 10 - jae .high -.low: - add al, '0' - jmp short .ischar -.high: - add al, 'A'-10 -.ischar: +crlf_early: + push ax + mov al, 13 call writechr - pop eax - loop .loop - popad - popfd - ret - -// -// writechr: Write a character to the screen. There is a more "sophisticated" -// version of this in the subsequent code, so we patch the pointer -// when appropriate. + mov al, 10 + call writechr + pop ax + ret + +// +// writechr: Write a character to the screen. +// writechr: pushfd pushad mov ah, HEX(0E) - xor bx, bx + xor bx, bx int HEX(10) popad popfd ret // +// int13: save all the segment registers and call INT 13h. +// Some CD-ROM BIOSes have been found to corrupt segment registers +// and/or disable interrupts. +// +int13: + pushf + push bp + push ds + push es + push fs + push gs + int HEX(13) + mov bp, sp + setc byte ptr ds:[bp+10] // Propagate CF to the caller + pop gs + pop fs + pop es + pop ds + pop bp + popf + ret + +// // Get one sector. Convenience entry point. // getonesec: @@ -804,48 +829,113 @@ // // Get linear sectors - EBIOS LBA addressing, 2048-byte sectors. // -// Note that we can't always do this as a single request, because at least -// Phoenix BIOSes has a 127-sector limit. To be on the safe side, stick -// to 32 sectors (64K) per request. -// -// Input: -// EAX - Linear sector number -// ES:BX - Target buffer -// BP - Sector count -// getlinsec: - push es // save es, we reset it later to 0 - - mov si, offset dapa // Load up the DAPA + jmp word ptr cs:[GetlinsecPtr] + +// +// getlinsec_ebios: +// +// getlinsec implementation for floppy/HDD EBIOS (EDD) +// +getlinsec_ebios: + xor edx, edx + shld edx, eax, 2 + shl eax, 2 // Convert to HDD sectors + shl bp, 2 + +.loop_ebios: + push bp // Sectors left +.retry2: + call maxtrans // Enforce maximum transfer size + movzx edi, bp // Sectors we are about to read + mov cx, retry_count +.retry: + // Form DAPA on stack + push edx + push eax + push es + push bx + push di + push 16 + mov si, sp + pushad + mov dl, byte ptr ds:[DriveNumber] + push ds + push ss + pop ds // DS <- SS + mov ah, HEX(42) // Extended Read + call int13 + pop ds + popad + lea sp, [si+16] // Remove DAPA + jc .error_ebios + pop bp + add eax, edi // Advance sector pointer + adc edx, 0 + sub bp, di // Sectors left + shl di, 9 // 512-byte sectors + add bx, di // Advance buffer pointer + jnc .no_overflow // Check if we have read more than 64K and need to adjust ES + mov di, es + add di, HEX(1000) // Adjust segment by 64K (1000h * 16 = 10000h = 64K + 1) + mov es, di +.no_overflow: + and bp, bp + jnz .loop_ebios + + ret + +.error_ebios: + pushad // Try resetting the device + xor ax, ax + mov dl, byte ptr ds:[DriveNumber] + call int13 + popad + loop .retry // CX-- and jump if not zero + + // Total failure. + jmp kaboom + +// +// Truncate BP to MaxTransfer +// +maxtrans: + cmp bp, word ptr ds:[MaxTransfer] + jna .ok + mov bp, word ptr ds:[MaxTransfer] +.ok: + ret + +// +// This is the variant we use for real CD-ROMs: +// LBA, 2K sectors, some special error handling. +// +getlinsec_cdrom: + mov si, offset dapa // Load up the DAPA mov word ptr ds:[si+4], bx - mov bx, es - mov word ptr ds:[si+6], bx - xor bx, bx // reset es to 0, some bioses (KVM) require that - mov es, bx + mov word ptr ds:[si+6], es mov dword ptr ds:[si+8], eax -.loop2: - push bp // Sectors left - cmp bp, word ptr ds:[MaxTransfer] +.loop_cdrom: + push bp // Sectors left + cmp bp, word ptr ds:[MaxTransferCD] jbe .bp_ok - mov bp, word ptr ds:[MaxTransfer] + mov bp, word ptr ds:[MaxTransferCD] .bp_ok: mov word ptr ds:[si+2], bp push si - mov dl, byte ptr ds:[DriveNo] - mov ah, HEX(42) // Extended Read + mov dl, byte ptr ds:[DriveNumber] + mov ah, HEX(42) // Extended Read call xint13 pop si pop bp - movzx eax,word ptr ds:[si+2] // Sectors we read - add dword ptr ds:[si+8], eax // Advance sector pointer - sub bp, ax // Sectors left - shl ax, SECTORSIZE_LG2-4 // 2048-byte sectors -> segment - add word ptr ds:[si+6], ax // Advance buffer pointer + movzx eax, word ptr ds:[si+2] // Sectors we read + add dword ptr ds:[si+8], eax // Advance sector pointer + sub bp, ax // Sectors left + shl ax, SECTOR_SHIFT-4 // 2048-byte sectors -> segment + add word ptr ds:[si+6], ax // Advance buffer pointer and bp, bp - jnz .loop2 - mov eax, dword ptr ds:[si+8] // Next sector - - pop es + jnz .loop_cdrom + mov eax, dword ptr ds:[si+8] // Next sector ret // INT 13h with retry @@ -853,30 +943,31 @@ mov byte ptr ds:[RetryCount], retry_count .try: pushad - int HEX(13) - jc .error - add sp, 8*4 // Clean up stack - ret -.error: - mov byte ptr ds:[DiskError], ah // Save error code + call int13 + jc .error_cdrom + add sp, 8*4 // Clean up stack + ret +.error_cdrom: + mov byte ptr ds:[DiskError], ah // Save error code popad + mov word ptr ds:[DiskSys], ax // Save system call number dec byte ptr ds:[RetryCount] jz .real_error push ax mov al, byte ptr ds:[RetryCount] - mov ah, byte ptr ds:[dapa+2] // Sector transfer count - cmp al,2 // Only 2 attempts left + mov ah, byte ptr ds:[dapa+2] // Sector transfer count + cmp al, 2 // Only 2 attempts left ja .nodanger - mov ah,1 // Drop transfer size to 1 + mov ah, 1 // Drop transfer size to 1 jmp short .setsize .nodanger: cmp al, retry_count-2 - ja .again // First time, just try again - shr ah,1 // Otherwise, try to reduce - adc ah,0 // the max transfer size, but not to 0 + ja .again // First time, just try again + shr ah, 1 // Otherwise, try to reduce + adc ah, 0 // the max transfer size, but not to 0 .setsize: - mov byte ptr ds:[MaxTransfer],ah - mov byte ptr ds:[dapa+2],ah + mov byte ptr ds:[MaxTransferCD], ah + mov byte ptr ds:[dapa+2], ah .again: pop ax jmp .try @@ -886,11 +977,15 @@ call writemsg mov al, byte ptr ds:[DiskError] call writehex2 + mov si, offset oncall_str + call writestr_early + mov ax, word ptr ds:[DiskSys] + call writehex4 mov si, offset ondrive_str - call writestr + call writestr_early mov al, dl call writehex2 - call crlf + call crlf_early // Fall through to kaboom // @@ -898,187 +993,174 @@ // then do a hard reboot. // kaboom: + // Restore a clean context. mov ax, cs mov ds, ax mov es, ax mov fs, ax mov gs, ax sti + + // Display the failure message. mov si, offset err_bootfailed - call writestr - xor ax, ax // Wait for keypress + call writestr_early + + // Wait for a keypress. + xor ax, ax int HEX(16) + + // Disable interrupts and reset the system through a magic BIOS call. cli - mov word ptr ds:[BIOS_magic], 0 // Cold reboot - ljmp16 HEX(0F000), HEX(0FFF0) // Reset vector address - - -// -// pollchar_and_empty: check if we have an input character pending (ZF = 0) and empty the input buffer afterwards + mov word ptr ds:[BIOS_magic], 0 + ljmp16 HEX(0F000), HEX(0FFF0) + +// +// writehex[248]: Write a hex number in (AL, AX, EAX) to the console +// +writehex2: + pushfd + pushad + rol eax, 24 + mov cx,2 + jmp short writehex_common +writehex4: + pushfd + pushad + rol eax, 16 + mov cx, 4 + jmp short writehex_common +writehex8: + pushfd + pushad + mov cx, 8 +writehex_common: +.loop_writehex: + rol eax, 4 + push eax + and al, HEX(0F) + cmp al, 10 + jae .high +.low: + add al, '0' + jmp short .ischar +.high: + add al, 'A'-10 +.ischar: + call writechr + pop eax + loop .loop_writehex + popad + popfd + ret + +// +// pollchar_and_empty: Check if we have an input character pending (ZF = 0) +// and empty the input buffer afterwards. // pollchar_and_empty: pushad - mov ah, 1 // Did the user press a key? + mov ah, 1 // Did the user press a key? int HEX(16) - jz .end // No, then we're done - mov ah, 0 // Otherwise empty the buffer by reading it + jz .end_pollchar // No, then we're done + mov ah, 0 // Otherwise empty the buffer by reading it int HEX(16) -.end: +.end_pollchar: popad ret -isolinux_banner: - .ascii CR, LF, "Loading IsoBoot...", CR, LF, NUL -copyright_str: - .ascii " (C) 1994-2002 H. Peter Anvin", CR, LF, NUL +/* INITIALIZED VARIABLES *****************************************************/ presskey_msg: - .ascii "Press any key to boot from CD", NUL + .ascii "Press any key to boot from the ReactOS Medium", NUL dot_msg: .ascii ".", NUL - -#ifdef DEBUG_MESSAGES -startup_msg: - .ascii "Startup, DL = '", NUL -spec_ok_msg: - .ascii "packet OK, drive = ", NUL -secsize_msg: - .ascii "size appears to be ", NUL -rootloc_msg: - .ascii "Root dir loc: ", NUL -rootlen_msg: - .ascii "Root dir len: ", NUL -rootsect_msg: - .ascii "Root dir len(sect): ", NUL -fileloc_msg: - .ascii "SETUPLDR loc: ", NUL -filelen_msg: - .ascii "SETUPLDR len: ", NUL -filesect_msg: - .ascii "SETUPLDR len(sect): ", NUL -findfail_msg: - .ascii "Failed to find file!", NUL -startldr_msg: - .ascii "Starting SETUPLDR.SYS", NUL -#endif - +isoboot_str: + .ascii "ISOBOOT: ", NUL spec_err_msg: - .ascii "Load spec failed, trying wing ...", CR, LF, NUL + .ascii "Loading spec packet failed, trying to wing it...", CR, LF, NUL maybe_msg: - .ascii "Found smth at drive = ", NUL + .ascii "Found something at drive = ", NUL alright_msg: - .ascii "might be ok, continuing...", CR, LF, NUL + .ascii "Looks reasonable, continuing...", CR, LF, NUL +nospec_msg: + .ascii "Extremely broken BIOS detected, last attempt with drive = ", NUL nothing_msg: - .ascii "Failed locate CD-ROM; boot failed.", CR, LF, NUL - -isolinux_str: - .ascii "IsoBoot: ", NUL -crlf_msg: - .ascii CR, LF, NUL + .ascii "Failed to locate CD-ROM device; boot failed.", CR, LF, NUL diskerr_msg: .ascii "Disk error ", NUL +oncall_str: + .ascii ", AX = ", NUL ondrive_str: .ascii ", drive ", NUL - err_bootfailed: - .ascii CR, LF, "failed..", NUL -isolinux_dir: - .ascii "\\LOADER", NUL + .ascii CR, LF, "Boot failed: press a key to retry...", NUL +loader_dir: + .ascii "/LOADER", NUL no_dir_msg: .ascii "LOADER dir not found.", CR, LF, NUL -isolinux_bin: +setupldr_sys: .ascii "SETUPLDR.SYS", NUL -no_isolinux_msg: - .ascii "SETUPLDR not found.", CR, LF, NUL - +no_setupldr_msg: + .ascii "SETUPLDR.SYS not found.", CR, LF, NUL + +.align 4 +BufSafe: + .word trackbufsize/SECTOR_SIZE // Clusters we can load into trackbuf + +// Maximum transfer size +.align 4 +MaxTransfer: + .word 127 // Hard disk modes +MaxTransferCD: + .word 32 // CD mode // // El Torito spec packet // .align 8 spec_packet: - .byte HEX(13) // Size of packet + .byte HEX(13) // Size of packet sp_media: - .byte 0 // Media type + .byte 0 // Media type sp_drive: - .byte 0 // Drive number + .byte 0 // Drive number sp_controller: - .byte 0 // Controller index + .byte 0 // Controller index sp_lba: - .long 0 // LBA for emulated disk image + .long 0 // LBA for emulated disk image sp_devspec: - .word 0 // IDE/SCSI information + .word 0 // IDE/SCSI information sp_buffer: - .word 0 // User-provided buffer + .word 0 // User-provided buffer sp_loadseg: - .word 0 // Load segment + .word 0 // Load segment sp_sectors: - .word 0 // Sector count + .word 0 // Sector count sp_chs: - .byte 0,0,0 // Simulated CHS geometry + .byte 0,0,0 // Simulated CHS geometry sp_dummy: - .byte 0 // Scratch, safe to overwrite - -// -// EBIOS drive parameter packet -// -.align 8 -drive_params: - .word 30 // Buffer size -dp_flags: - .word 0 // Information flags -dp_cyl: - .long 0 // Physical cylinders -dp_head: - .long 0 // Physical heads -dp_sec: - .long 0 // Physical sectors/track -dp_totalsec: - .long 0,0 // Total sectors -dp_secsize: - .word 0 // Bytes per sector -dp_dpte: - .long 0 // Device Parameter Table -dp_dpi_key: - .word 0 // 0BEDDh if rest valid -dp_dpi_len: - .byte 0 // DPI len - .byte 0 - .word 0 -dp_bus: - .byte 0,0,0,0 // Host bus type -dp_interface: - .byte 0,0,0,0,0,0,0,0 // Interface type -db_i_path: - .long 0,0 // Interface path -db_d_path: - .long 0,0 // Device path - .byte 0 -db_dpi_csum: - .byte 0 // Checksum for DPI info + .byte 0 // Scratch, safe to overwrite // // EBIOS disk address packet // .align 8 dapa: - .word 16 // Packet size + .word 16 // Packet size .count: - .word 0 // Block count + .word 0 // Block count .off: - .word 0 // Offset of buffer + .word 0 // Offset of buffer .seg: - .word 0 // Segment of buffer + .word 0 // Segment of buffer .lba: - .long 0 // LBA (LSW) - .long 0 // LBA (MSW) - -.align 4 -MaxTransfer: - .word 2 //32 // Max sectors per transfer - -.org 2046 // Pad to file offset 2046 -.word HEX(0aa55) // BootSector signature + .long 0 // LBA (LSW) + .long 0 // LBA (MSW) + + +// Extend the size to cover one 2K-sized sector +.org 2047 + .byte 0 .endcode16

7 years, 8 months

← Newer
1
2
3
4
5
6
7
8
9
...
16
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

2009

2008

2007

2006

2005

2004

Ros-diffs January 2017