Home | History | Annotate | Download | only in win 
      1 /* ----------------------------------------------------------------------- *
      2  *
      3  *   Copyright 2003 Lars Munch Christensen - All Rights Reserved
      4  *   Copyright 1998-2008 H. Peter Anvin - All Rights Reserved
      5  *
      6  *   Based on the Linux installer program for SYSLINUX by H. Peter Anvin
      7  *
      8  *   This program is free software; you can redistribute it and/or modify
      9  *   it under the terms of the GNU General Public License as published by
     10  *   the Free Software Foundation, Inc., 53 Temple Place Ste 330,
     11  *   Boston MA 02111-1307, USA; either version 2 of the License, or
     12  *   (at your option) any later version; incorporated herein by reference.
     13  *
     14  * ----------------------------------------------------------------------- */
     15 
     16 /*
     17  * syslinux-mingw.c - Win2k/WinXP installer program for SYSLINUX
     18  */
     19 
     20 #include <windows.h>
     21 #include <stdio.h>
     22 #include <ctype.h>
     23 #include <getopt.h>
     24 
     25 #include "syslinux.h"
     26 #include "libfat.h"
     27 #include "setadv.h"
     28 #include "sysexits.h"
     29 #include "syslxopt.h"
     30 #include "syslxfs.h"
     31 #include "ntfssect.h"
     32 
     33 #ifdef __GNUC__
     34 # define noreturn void __attribute__((noreturn))
     35 #else
     36 # define noreturn void
     37 #endif
     38 
     39 void error(char *msg);
     40 
     41 /* Begin stuff for MBR code */
     42 
     43 #include <winioctl.h>
     44 
     45 #define PART_TABLE  0x1be
     46 #define PART_SIZE   0x10
     47 #define PART_COUNT  4
     48 #define PART_ACTIVE 0x80
     49 
     50 // The following struct should be in the ntddstor.h file, but I didn't have it.
     51 // mingw32 has <ddk/ntddstor.h>, but including that file causes all kinds
     52 // of other failures.  mingw64 has it in <winioctl.h>.
     53 // Thus, instead of STORAGE_DEVICE_NUMBER, use a lower-case private
     54 // definition...
     55 struct storage_device_number {
     56     DEVICE_TYPE DeviceType;
     57     ULONG DeviceNumber;
     58     ULONG PartitionNumber;
     59 };
     60 
     61 BOOL GetStorageDeviceNumberByHandle(HANDLE handle,
     62 				    const struct storage_device_number *sdn)
     63 {
     64     BOOL result = FALSE;
     65     DWORD count;
     66 
     67     if (DeviceIoControl(handle, IOCTL_STORAGE_GET_DEVICE_NUMBER, NULL,
     68 			0, (LPVOID) sdn, sizeof(*sdn), &count, NULL)) {
     69 	result = TRUE;
     70     } else {
     71 	error("GetDriveNumber: DeviceIoControl failed");
     72     }
     73 
     74     return (result);
     75 }
     76 
     77 int GetBytesPerSector(HANDLE drive)
     78 {
     79     int result = 0;
     80     DISK_GEOMETRY g;
     81     DWORD count;
     82 
     83     if (DeviceIoControl(drive, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0,
     84 			&g, sizeof(g), &count, NULL)) {
     85 	result = g.BytesPerSector;
     86     }
     87 
     88     return (result);
     89 }
     90 
     91 BOOL FixMBR(int driveNum, int partitionNum, int write_mbr, int set_active)
     92 {
     93     BOOL result = TRUE;
     94     HANDLE drive;
     95 
     96     char driveName[128];
     97 
     98     sprintf(driveName, "\\\\.\\PHYSICALDRIVE%d", driveNum);
     99 
    100     drive = CreateFile(driveName,
    101 		       GENERIC_READ | GENERIC_WRITE,
    102 		       FILE_SHARE_WRITE | FILE_SHARE_READ,
    103 		       NULL, OPEN_EXISTING, 0, NULL);
    104 
    105     if (drive == INVALID_HANDLE_VALUE) {
    106 	error("Accessing physical drive");
    107 	result = FALSE;
    108     }
    109 
    110     if (result) {
    111 	unsigned char sector[SECTOR_SIZE];
    112 	DWORD howMany;
    113 
    114 	if (GetBytesPerSector(drive) != SECTOR_SIZE) {
    115 	    fprintf(stderr,
    116 		    "Error: Sector size of this drive is %d; must be %d\n",
    117 		    GetBytesPerSector(drive), SECTOR_SIZE);
    118 	    result = FALSE;
    119 	}
    120 
    121 	if (result) {
    122 	    if (ReadFile(drive, sector, sizeof(sector), &howMany, NULL) == 0) {
    123 		error("Reading raw drive");
    124 		result = FALSE;
    125 	    } else if (howMany != sizeof(sector)) {
    126 		fprintf(stderr,
    127 			"Error: ReadFile on drive only got %d of %d bytes\n",
    128 			(int)howMany, sizeof(sector));
    129 		result = FALSE;
    130 	    }
    131 	}
    132 	// Copy over the MBR code if specified (-m)
    133 	if (write_mbr) {
    134 	    if (result) {
    135 		if (syslinux_mbr_len >= PART_TABLE) {
    136 		    fprintf(stderr, "Error: MBR will not fit; not writing\n");
    137 		    result = FALSE;
    138 		} else {
    139 		    memcpy(sector, syslinux_mbr, syslinux_mbr_len);
    140 		}
    141 	    }
    142 	}
    143 	// Check that our partition is active if specified (-a)
    144 	if (set_active) {
    145 	    if (sector[PART_TABLE + (PART_SIZE * (partitionNum - 1))] != 0x80) {
    146 		int p;
    147 		for (p = 0; p < PART_COUNT; p++)
    148 		    sector[PART_TABLE + (PART_SIZE * p)] =
    149 			(p == partitionNum - 1 ? 0x80 : 0);
    150 	    }
    151 	}
    152 
    153 	if (result) {
    154 	    SetFilePointer(drive, 0, NULL, FILE_BEGIN);
    155 
    156 	    if (WriteFile(drive, sector, sizeof(sector), &howMany, NULL) == 0) {
    157 		error("Writing MBR");
    158 		result = FALSE;
    159 	    } else if (howMany != sizeof(sector)) {
    160 		fprintf(stderr,
    161 			"Error: WriteFile on drive only wrote %d of %d bytes\n",
    162 			(int)howMany, sizeof(sector));
    163 		result = FALSE;
    164 	    }
    165 	}
    166 
    167 	if (!CloseHandle(drive)) {
    168 	    error("CloseFile on drive");
    169 	    result = FALSE;
    170 	}
    171     }
    172 
    173     return (result);
    174 }
    175 
    176 /* End stuff for MBR code */
    177 
    178 const char *program;		/* Name of program */
    179 
    180 /*
    181  * Check Windows version.
    182  *
    183  * On Windows Me/98/95 you cannot open a directory, physical disk, or
    184  * volume using CreateFile.
    185  */
    186 int checkver(void)
    187 {
    188     OSVERSIONINFO osvi;
    189 
    190     osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
    191     GetVersionEx(&osvi);
    192 
    193     return (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) &&
    194 	((osvi.dwMajorVersion > 4) ||
    195 	 ((osvi.dwMajorVersion == 4) && (osvi.dwMinorVersion == 0)));
    196 }
    197 
    198 /*
    199  * Windows error function
    200  */
    201 void error(char *msg)
    202 {
    203     LPVOID lpMsgBuf;
    204 
    205     /* Format the Windows error message */
    206     FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),	// Default language
    207 		  (LPTSTR) & lpMsgBuf, 0, NULL);
    208 
    209     /* Print it */
    210     fprintf(stderr, "%s: %s", msg, (char *)lpMsgBuf);
    211 
    212     /* Free the buffer */
    213     LocalFree(lpMsgBuf);
    214 }
    215 
    216 /*
    217  * Wrapper for ReadFile suitable for libfat
    218  */
    219 int libfat_readfile(intptr_t pp, void *buf, size_t secsize,
    220 		    libfat_sector_t sector)
    221 {
    222     uint64_t offset = (uint64_t) sector * secsize;
    223     LONG loword = (LONG) offset;
    224     LONG hiword = (LONG) (offset >> 32);
    225     LONG hiwordx = hiword;
    226     DWORD bytes_read;
    227 
    228     if (SetFilePointer((HANDLE) pp, loword, &hiwordx, FILE_BEGIN) != loword ||
    229 	hiword != hiwordx ||
    230 	!ReadFile((HANDLE) pp, buf, secsize, &bytes_read, NULL) ||
    231 	bytes_read != secsize) {
    232 	fprintf(stderr, "Cannot read sector %u\n", sector);
    233 	exit(1);
    234     }
    235 
    236     return secsize;
    237 }
    238 
    239 static void move_file(char *pathname, char *filename)
    240 {
    241     char new_name[strlen(opt.directory) + 16];
    242     char *cp = new_name + 3;
    243     const char *sd;
    244     int slash = 1;
    245 
    246     new_name[0] = opt.device[0];
    247     new_name[1] = ':';
    248     new_name[2] = '\\';
    249 
    250     for (sd = opt.directory; *sd; sd++) {
    251 	char c = *sd;
    252 
    253 	if (c == '/' || c == '\\') {
    254 	    if (slash)
    255 		continue;
    256 	    c = '\\';
    257 	    slash = 1;
    258 	} else {
    259 	    slash = 0;
    260 	}
    261 
    262 	*cp++ = c;
    263     }
    264 
    265     /* Skip if subdirectory == root */
    266     if (cp > new_name + 3) {
    267 	if (!slash)
    268 	    *cp++ = '\\';
    269 
    270 	memcpy(cp, filename, 12);
    271 
    272 	/* Delete any previous file */
    273 	SetFileAttributes(new_name, FILE_ATTRIBUTE_NORMAL);
    274 	DeleteFile(new_name);
    275 	if (!MoveFile(pathname, new_name)) {
    276 	    fprintf(stderr,
    277 		    "Failed to move %s to destination directory: %s\n",
    278 		    filename, opt.directory);
    279 
    280 	    SetFileAttributes(pathname, FILE_ATTRIBUTE_READONLY |
    281 			      FILE_ATTRIBUTE_SYSTEM |
    282 			      FILE_ATTRIBUTE_HIDDEN);
    283 	} else
    284 	    SetFileAttributes(new_name, FILE_ATTRIBUTE_READONLY |
    285 			      FILE_ATTRIBUTE_SYSTEM |
    286 			      FILE_ATTRIBUTE_HIDDEN);
    287     }
    288 }
    289 
    290 int main(int argc, char *argv[])
    291 {
    292     HANDLE f_handle, d_handle;
    293     DWORD bytes_read;
    294     DWORD bytes_written;
    295     DWORD drives;
    296     UINT drive_type;
    297 
    298     static unsigned char sectbuf[SECTOR_SIZE];
    299     char **argp;
    300     static char drive_name[] = "\\\\.\\?:";
    301     static char drive_root[] = "?:\\";
    302     static char ldlinux_name[] = "?:\\ldlinux.sys";
    303     static char ldlinuxc32_name[] = "?:\\ldlinux.c32";
    304     const char *errmsg;
    305     struct libfat_filesystem *fs;
    306     libfat_sector_t s, *secp;
    307     libfat_sector_t *sectors;
    308     int ldlinux_sectors;
    309     uint32_t ldlinux_cluster;
    310     int nsectors;
    311     int fs_type;
    312 
    313     if (!checkver()) {
    314 	fprintf(stderr,
    315 		"You need to be running at least Windows NT; use syslinux.com instead.\n");
    316 	exit(1);
    317     }
    318 
    319     program = argv[0];
    320 
    321     parse_options(argc, argv, MODE_SYSLINUX_DOSWIN);
    322 
    323     if (!opt.device || !isalpha(opt.device[0]) || opt.device[1] != ':'
    324 	|| opt.device[2])
    325 	usage(EX_USAGE, MODE_SYSLINUX_DOSWIN);
    326 
    327     if (opt.sectors || opt.heads || opt.reset_adv || opt.set_once
    328 	|| (opt.update_only > 0) || opt.menu_save || opt.offset) {
    329 	fprintf(stderr,
    330 		"At least one specified option not yet implemented"
    331 		" for this installer.\n");
    332 	exit(1);
    333     }
    334 
    335     /* Test if drive exists */
    336     drives = GetLogicalDrives();
    337     if (!(drives & (1 << (tolower(opt.device[0]) - 'a')))) {
    338 	fprintf(stderr, "No such drive %c:\n", opt.device[0]);
    339 	exit(1);
    340     }
    341 
    342     /* Determines the drive type */
    343     drive_name[4] = opt.device[0];
    344     ldlinux_name[0] = opt.device[0];
    345     ldlinuxc32_name[0] = opt.device[0];
    346     drive_root[0] = opt.device[0];
    347     drive_type = GetDriveType(drive_root);
    348 
    349     /* Test for removeable media */
    350     if ((drive_type == DRIVE_FIXED) && (opt.force == 0)) {
    351 	fprintf(stderr, "Not a removable drive (use -f to override) \n");
    352 	exit(1);
    353     }
    354 
    355     /* Test for unsupported media */
    356     if ((drive_type != DRIVE_FIXED) && (drive_type != DRIVE_REMOVABLE)) {
    357 	fprintf(stderr, "Unsupported media\n");
    358 	exit(1);
    359     }
    360 
    361     /*
    362      * First open the drive
    363      */
    364     d_handle = CreateFile(drive_name, GENERIC_READ | GENERIC_WRITE,
    365 			  FILE_SHARE_READ | FILE_SHARE_WRITE,
    366 			  NULL, OPEN_EXISTING, 0, NULL);
    367 
    368     if (d_handle == INVALID_HANDLE_VALUE) {
    369 	error("Could not open drive");
    370 	exit(1);
    371     }
    372 
    373     /*
    374      * Make sure we can read the boot sector
    375      */
    376     if (!ReadFile(d_handle, sectbuf, SECTOR_SIZE, &bytes_read, NULL)) {
    377 	error("Reading boot sector");
    378 	exit(1);
    379     }
    380     if (bytes_read != SECTOR_SIZE) {
    381 	fprintf(stderr, "Could not read the whole boot sector\n");
    382 	exit(1);
    383     }
    384 
    385     /* Check to see that what we got was indeed an FAT/NTFS
    386      * boot sector/superblock
    387      */
    388     if ((errmsg = syslinux_check_bootsect(sectbuf, &fs_type))) {
    389 	fprintf(stderr, "%s\n", errmsg);
    390 	exit(1);
    391     }
    392 
    393     /* Change to normal attributes to enable deletion */
    394     /* Just ignore error if the file do not exists */
    395     SetFileAttributes(ldlinux_name, FILE_ATTRIBUTE_NORMAL);
    396     SetFileAttributes(ldlinuxc32_name, FILE_ATTRIBUTE_NORMAL);
    397 
    398     /* Delete the file */
    399     /* Just ignore error if the file do not exists */
    400     DeleteFile(ldlinux_name);
    401     DeleteFile(ldlinuxc32_name);
    402 
    403     /* Initialize the ADV -- this should be smarter */
    404     syslinux_reset_adv(syslinux_adv);
    405 
    406     /* Create ldlinux.sys file */
    407     f_handle = CreateFile(ldlinux_name, GENERIC_READ | GENERIC_WRITE,
    408 			  FILE_SHARE_READ | FILE_SHARE_WRITE,
    409 			  NULL, CREATE_ALWAYS,
    410 			  FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM |
    411 			  FILE_ATTRIBUTE_HIDDEN, NULL);
    412 
    413     if (f_handle == INVALID_HANDLE_VALUE) {
    414 	error("Unable to create ldlinux.sys");
    415 	exit(1);
    416     }
    417 
    418     /* Write ldlinux.sys file */
    419     if (!WriteFile(f_handle, (const char _force *)syslinux_ldlinux,
    420 		   syslinux_ldlinux_len, &bytes_written, NULL) ||
    421 	bytes_written != syslinux_ldlinux_len) {
    422 	error("Could not write ldlinux.sys");
    423 	exit(1);
    424     }
    425     if (!WriteFile(f_handle, syslinux_adv, 2 * ADV_SIZE,
    426 		   &bytes_written, NULL) ||
    427 	bytes_written != 2 * ADV_SIZE) {
    428 	error("Could not write ADV to ldlinux.sys");
    429 	exit(1);
    430     }
    431 
    432     /* Now flush the media */
    433     if (!FlushFileBuffers(f_handle)) {
    434 	error("FlushFileBuffers failed");
    435 	exit(1);
    436     }
    437 
    438     /* Map the file (is there a better way to do this?) */
    439     ldlinux_sectors = (syslinux_ldlinux_len + 2 * ADV_SIZE + SECTOR_SIZE - 1)
    440 	>> SECTOR_SHIFT;
    441     sectors = calloc(ldlinux_sectors, sizeof *sectors);
    442     if (fs_type == NTFS) {
    443 	DWORD err;
    444 	S_NTFSSECT_VOLINFO vol_info;
    445 	LARGE_INTEGER vcn, lba, len;
    446 	S_NTFSSECT_EXTENT extent;
    447 
    448 	err = NtfsSectGetVolumeInfo(drive_name + 4, &vol_info);
    449 	if (err != ERROR_SUCCESS) {
    450 	    error("Could not fetch NTFS volume info");
    451 	    exit(1);
    452 	}
    453 	secp = sectors;
    454 	nsectors = 0;
    455 	for (vcn.QuadPart = 0;
    456 	     NtfsSectGetFileVcnExtent(f_handle, &vcn, &extent) == ERROR_SUCCESS;
    457 	     vcn = extent.NextVcn) {
    458 	    err = NtfsSectLcnToLba(&vol_info, &extent.FirstLcn, &lba);
    459 	    if (err != ERROR_SUCCESS) {
    460 		error("Could not translate LDLINUX.SYS LCN to disk LBA");
    461 		exit(1);
    462 	    }
    463 	    lba.QuadPart -= vol_info.PartitionLba.QuadPart;
    464 	    len.QuadPart = ((extent.NextVcn.QuadPart -
    465 			     extent.FirstVcn.QuadPart) *
    466 			    vol_info.SectorsPerCluster);
    467 	    while (len.QuadPart-- && nsectors < ldlinux_sectors) {
    468 		*secp++ = lba.QuadPart++;
    469 		nsectors++;
    470 	    }
    471 	}
    472 	goto map_done;
    473     }
    474     fs = libfat_open(libfat_readfile, (intptr_t) d_handle);
    475     ldlinux_cluster = libfat_searchdir(fs, 0, "LDLINUX SYS", NULL);
    476     secp = sectors;
    477     nsectors = 0;
    478     s = libfat_clustertosector(fs, ldlinux_cluster);
    479     while (s && nsectors < ldlinux_sectors) {
    480 	*secp++ = s;
    481 	nsectors++;
    482 	s = libfat_nextsector(fs, s);
    483     }
    484     libfat_close(fs);
    485 map_done:
    486 
    487     /*
    488      * Patch ldlinux.sys and the boot sector
    489      */
    490     syslinux_patch(sectors, nsectors, opt.stupid_mode, opt.raid_mode, opt.directory, NULL);
    491 
    492     /*
    493      * Rewrite the file
    494      */
    495     if (SetFilePointer(f_handle, 0, NULL, FILE_BEGIN) != 0 ||
    496 	!WriteFile(f_handle, syslinux_ldlinux, syslinux_ldlinux_len,
    497 		   &bytes_written, NULL)
    498 	|| bytes_written != syslinux_ldlinux_len) {
    499 	error("Could not write ldlinux.sys");
    500 	exit(1);
    501     }
    502 
    503     /* If desired, fix the MBR */
    504     if (opt.install_mbr || opt.activate_partition) {
    505 	struct storage_device_number sdn;
    506 	if (GetStorageDeviceNumberByHandle(d_handle, &sdn)) {
    507 	    if (!FixMBR(sdn.DeviceNumber, sdn.PartitionNumber, opt.install_mbr, opt.activate_partition)) {
    508 		fprintf(stderr,
    509 			"Did not successfully update the MBR; continuing...\n");
    510 	    }
    511 	} else {
    512 	    fprintf(stderr,
    513 		    "Could not find device number for updating MBR; continuing...\n");
    514 	}
    515     }
    516 
    517     /* Close file */
    518     CloseHandle(f_handle);
    519 
    520     /* Move the file to the desired location */
    521     if (opt.directory)
    522 	move_file(ldlinux_name, "ldlinux.sys");
    523 
    524     f_handle = CreateFile(ldlinuxc32_name, GENERIC_READ | GENERIC_WRITE,
    525 			  FILE_SHARE_READ | FILE_SHARE_WRITE,
    526 			  NULL, CREATE_ALWAYS,
    527 			  FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_SYSTEM |
    528 			  FILE_ATTRIBUTE_HIDDEN, NULL);
    529 
    530     if (f_handle == INVALID_HANDLE_VALUE) {
    531 	error("Unable to create ldlinux.c32");
    532 	exit(1);
    533     }
    534 
    535     /* Write ldlinux.c32 file */
    536     if (!WriteFile(f_handle, (const char _force *)syslinux_ldlinuxc32,
    537 		   syslinux_ldlinuxc32_len, &bytes_written, NULL) ||
    538 	bytes_written != syslinux_ldlinuxc32_len) {
    539 	error("Could not write ldlinux.c32");
    540 	exit(1);
    541     }
    542 
    543     /* Now flush the media */
    544     if (!FlushFileBuffers(f_handle)) {
    545 	error("FlushFileBuffers failed");
    546 	exit(1);
    547     }
    548 
    549     CloseHandle(f_handle);
    550 
    551     /* Move the file to the desired location */
    552     if (opt.directory)
    553 	move_file(ldlinuxc32_name, "ldlinux.c32");
    554 
    555     /* Make the syslinux boot sector */
    556     syslinux_make_bootsect(sectbuf, fs_type);
    557 
    558     /* Write the syslinux boot sector into the boot sector */
    559     if (opt.bootsecfile) {
    560 	f_handle = CreateFile(opt.bootsecfile, GENERIC_READ | GENERIC_WRITE,
    561 			      FILE_SHARE_READ | FILE_SHARE_WRITE,
    562 			      NULL, CREATE_ALWAYS,
    563 			      FILE_ATTRIBUTE_ARCHIVE, NULL);
    564 	if (f_handle == INVALID_HANDLE_VALUE) {
    565 	    error("Unable to create bootsector file");
    566 	    exit(1);
    567 	}
    568 	if (!WriteFile(f_handle, sectbuf, SECTOR_SIZE, &bytes_written, NULL)) {
    569 	    error("Could not write boot sector file");
    570 	    exit(1);
    571 	}
    572 	CloseHandle(f_handle);
    573     } else {
    574 	SetFilePointer(d_handle, 0, NULL, FILE_BEGIN);
    575 	WriteFile(d_handle, sectbuf, SECTOR_SIZE, &bytes_written, NULL);
    576     }
    577 
    578     if (bytes_written != SECTOR_SIZE) {
    579 	fprintf(stderr, "Could not write the whole boot sector\n");
    580 	exit(1);
    581     }
    582 
    583     /* Close file */
    584     CloseHandle(d_handle);
    585 
    586     /* Done! */
    587     return 0;
    588 }
    589