BaseTools/Source/C/GnuGenBootSector/GnuGenBootSector.c

   1 /** @file
   2
   3 Copyright (c) 2006 - 2010, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14   GnuGenBootSector.c
  15
  16 Abstract:
  17   Reading/writing MBR/DBR.
  18   NOTE:
  19     If we write MBR to disk, we just update the MBR code and the partition table wouldn't be over written.
  20     If we process DBR, we will patch MBR to set first partition active if no active partition exists.
  21
  22 **/
  23
  24 #include "CommonLib.h"
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <Common/UefiBaseTypes.h>
  29
  30 #include "ParseInf.h"
  31 #include "EfiUtilityMsgs.h"
  32
  33 //
  34 // Utility Name
  35 //
  36 #define UTILITY_NAME  "GnuGenBootSector"
  37
  38 //
  39 // Utility version information
  40 //
  41 #define UTILITY_MAJOR_VERSION 0
  42 #define UTILITY_MINOR_VERSION 1
  43
  44 #define MAX_DRIVE                             26
  45 #define PARTITION_TABLE_OFFSET                0x1BE
  46
  47 #define SIZE_OF_PARTITION_ENTRY               0x10
  48
  49 #define PARTITION_ENTRY_STARTLBA_OFFSET       8
  50
  51 #define PARTITION_ENTRY_NUM                   4
  52
  53 #define DRIVE_UNKNOWN     0
  54 #define DRIVE_NO_ROOT_DIR 1
  55 #define DRIVE_REMOVABLE   2
  56 #define DRIVE_FIXED       3
  57 #define DRIVE_REMOTE      4
  58 #define DRIVE_CDROM       5
  59 #define DRIVE_RAMDISK     6
  60
  61 typedef struct _DRIVE_TYPE_DESC {
  62   UINTN  Type;
  63   CHAR8  *Description;
  64 } DRIVE_TYPE_DESC;
  65
  66 #define DRIVE_TYPE_ITEM(x) {x, #x}
  67
  68 DRIVE_TYPE_DESC DriveTypeDesc[] = {
  69   DRIVE_TYPE_ITEM (DRIVE_UNKNOWN),
  70   DRIVE_TYPE_ITEM (DRIVE_NO_ROOT_DIR),
  71   DRIVE_TYPE_ITEM (DRIVE_REMOVABLE),
  72   DRIVE_TYPE_ITEM (DRIVE_FIXED),
  73   DRIVE_TYPE_ITEM (DRIVE_REMOTE),
  74   DRIVE_TYPE_ITEM (DRIVE_CDROM),
  75   DRIVE_TYPE_ITEM (DRIVE_RAMDISK),
  76   {(UINTN) -1, NULL}
  77 };
  78
  79 typedef struct _DRIVE_INFO {
  80   CHAR8             VolumeLetter;
  81   DRIVE_TYPE_DESC   *DriveType;
  82   UINTN             DiskNumber;
  83 } DRIVE_INFO;
  84
  85 typedef enum {
  86   PathUnknown,
  87   PathFile,
  88   PathFloppy,
  89   PathUsb,
  90   PathIde
  91 } PATH_TYPE;
  92
  93 typedef struct _PATH_INFO {
  94   CHAR8            *Path;
  95   CHAR8            PhysicalPath[260];
  96   PATH_TYPE        Type;
  97   BOOLEAN          Input;
  98 } PATH_INFO;
  99
 100 typedef enum {
 101   ErrorSuccess,
 102   ErrorFileCreate,
 103   ErrorFileReadWrite,
 104   ErrorNoMbr,
 105   ErrorFatType,
 106   ErrorPath,
 107 } ERROR_STATUS;
 108
 109 CHAR8 *ErrorStatusDesc[] = {
 110   "Success",
 111   "Failed to create files",
 112   "Failed to read/write files",
 113   "No MBR exists",
 114   "Failed to detect Fat type",
 115   "Inavlid path"
 116 };
 117
 118
 119 //UnSupported Windows API functions.
 120 UINTN GetLogicalDrives(void) { return 1; }
 121
 122
 123
 124 /**
 125   Get path information, including physical path for Linux platform.
 126
 127   @param PathInfo   Point to PATH_INFO structure.
 128
 129   @return whether path is valid.
 130 **/
 131 ERROR_STATUS
 132 GetPathInfo (
 133   PATH_INFO   *PathInfo
 134   )
 135 {
 136   FILE        *f;
 137
 138   if (strncmp(PathInfo->Path, "/dev/", 5) == 0) {
 139     //
 140     // Process disk path here.
 141     //
 142
 143     // Process floppy disk
 144     if (PathInfo->Path[5] == 'f' && PathInfo->Path[6] == 'd' && PathInfo->Path[8] == '\0') {
 145       PathInfo->Type = PathFloppy;
 146       strcpy (PathInfo->PhysicalPath, PathInfo->Path);
 147
 148       return ErrorSuccess;
 149     } else {
 150     // Other disk types is not supported yet.
 151     fprintf (stderr, "ERROR: It's not a floppy disk!\n");
 152     return ErrorPath;
 153     }
 154
 155     // Try to open the device.
 156     f = fopen(PathInfo->Path,"r");
 157     if (f == NULL) {
 158       printf ("error :open device failed!\n");
 159       return ErrorPath;
 160     }
 161     fclose (f);
 162     return ErrorSuccess;
 163   }
 164
 165   // Process file path here.
 166   PathInfo->Type = PathFile;
 167   if (PathInfo->Input) {
 168     // If path is file path, check whether file is valid.
 169     printf("Path = %s\n",PathInfo->Path);
 170     f = fopen (PathInfo->Path, "r");
 171     if (f == NULL) {
 172       fprintf (stderr, "Test error E2003: File was not provided!\n");
 173       return ErrorPath;
 174     }
 175     fclose (f);
 176   }
 177
 178   strcpy(PathInfo->PhysicalPath, PathInfo->Path);
 179   return ErrorSuccess;
 180
 181 }
 182
 183 VOID
 184 ListDrive (
 185   VOID
 186   )
 187 {
 188   printf("-l or -list not supported!\n");
 189 }
 190
 191 /**
 192   Writing or reading boot sector or MBR according to the argument.
 193
 194   @param InputInfo PATH_INFO instance for input path
 195   @param OutputInfo PATH_INFO instance for output path
 196   @param ProcessMbr TRUE is to process MBR, otherwise, processing boot sector
 197
 198   @return ERROR_STATUS
 199  **/
 200 ERROR_STATUS
 201 ProcessBsOrMbr (
 202   PATH_INFO     *InputInfo,
 203   PATH_INFO     *OutputInfo,
 204   BOOLEAN       ProcessMbr
 205   )
 206 {
 207   CHAR8 FirstSector[0x200] = {0};
 208   CHAR8 FirstSectorBackup[0x200] = {0};
 209
 210   FILE *InputFile;
 211   FILE *OutputFile;
 212
 213
 214   InputFile = fopen(InputInfo->PhysicalPath, "r");
 215   if (InputFile == NULL) {
 216     return ErrorFileReadWrite;
 217   }
 218
 219   if (0x200 != fread(FirstSector, 1, 0x200, InputFile)) {
 220     fclose(InputFile);
 221     return ErrorFileReadWrite;
 222   }
 223
 224   fclose(InputFile);
 225
 226   //Not support USB and IDE.
 227   if (InputInfo->Type == PathUsb) {
 228     printf("USB has not been supported yet!");
 229     return ErrorSuccess;
 230   }
 231
 232   if (InputInfo->Type == PathIde) {
 233     printf("IDE has not been supported yet!");
 234     return ErrorSuccess;
 235   }
 236
 237   //Process Floppy Disk
 238   OutputFile = fopen(OutputInfo->PhysicalPath, "w");
 239   if (OutputFile == NULL) {
 240     return ErrorFileReadWrite;
 241   }
 242
 243   if (OutputInfo->Type != PathFile) {
 244     if (ProcessMbr) {
 245       //
 246       // Use original partition table
 247       //
 248       if (0x200 != fread (FirstSectorBackup, 1, 0x200, OutputFile)) {
 249         fclose(OutputFile);
 250         return ErrorFileReadWrite;
 251         }
 252       memcpy (FirstSector + 0x1BE, FirstSectorBackup + 0x1BE, 0x40);
 253     }
 254   }
 255   if(0x200 != fwrite(FirstSector, 1, 0x200, OutputFile)) {
 256     fclose(OutputFile);
 257     return ErrorFileReadWrite;
 258   }
 259
 260   fclose(OutputFile);
 261   return ErrorSuccess;
 262 }
 263
 264
 265 /**
 266
 267   Displays the standard utility information to SDTOUT
 268
 269 **/
 270 VOID
 271 Version (
 272   VOID
 273   )
 274 {
 275   printf ("%s v%d.%d -Utility to retrieve and update the boot sector or MBR.\n", UTILITY_NAME, UTILITY_MAJOR_VERSION, UTILITY_MINOR_VERSION);
 276   printf ("Copyright (c) 2007-2010 Intel Corporation. All rights reserved.\n");
 277 }
 278
 279
 280 VOID
 281 PrintUsage (
 282   VOID
 283     )
 284 {
 285   Version();
 286   printf ("\nUsage: \n\
 287    GenBootSector\n\
 288      [-l, --list list disks]\n\
 289      [-i, --input Filename]\n\
 290      [-o, --output Filename]\n\
 291      [-m, --mbr process the MBR also]\n\
 292      [-v, --verbose]\n\
 293      [--version]\n\
 294      [-q, --quiet disable all messages except fatal errors]\n\
 295      [-d, --debug[#]\n\
 296      [-h, --help]\n");
 297 }
 298
 299 int
 300 main (
 301   int  argc,
 302   char *argv[]
 303   )
 304 {
 305   CHAR8          *AppName;
 306   INTN           Index;
 307   BOOLEAN        ProcessMbr;
 308   ERROR_STATUS   Status;
 309   EFI_STATUS     EfiStatus;
 310   PATH_INFO      InputPathInfo;
 311   PATH_INFO      OutputPathInfo;
 312   UINT64         LogLevel;
 313
 314   SetUtilityName (UTILITY_NAME);
 315
 316   ZeroMem(&InputPathInfo, sizeof(PATH_INFO));
 317   ZeroMem(&OutputPathInfo, sizeof(PATH_INFO));
 318
 319   AppName = *argv;
 320   argv ++;
 321   argc --;
 322
 323   ProcessMbr    = FALSE;
 324
 325   if (argc == 0) {
 326     PrintUsage();
 327     return 0;
 328   }
 329
 330   //
 331   // Parse command line
 332   //
 333   for (Index = 0; Index < argc; Index ++) {
 334     if ((stricmp (argv[Index], "-l") == 0) || (stricmp (argv[Index], "--list") == 0)) {
 335       ListDrive ();
 336       return 0;
 337     }
 338
 339     if ((stricmp (argv[Index], "-m") == 0) || (stricmp (argv[Index], "--mbr") == 0)) {
 340       ProcessMbr = TRUE;
 341       continue;
 342     }
 343
 344     if ((stricmp (argv[Index], "-i") == 0) || (stricmp (argv[Index], "--input") == 0)) {
 345       InputPathInfo.Path  = argv[Index + 1];
 346       InputPathInfo.Input = TRUE;
 347       if (InputPathInfo.Path == NULL) {
 348         Error (NULL, 0, 1003, "Invalid option value", "Input file name can't be NULL");
 349         return 1;
 350       }
 351       if (InputPathInfo.Path[0] == '-') {
 352         Error (NULL, 0, 1003, "Invalid option value", "Input file is missing");
 353         return 1;
 354       }
 355       ++Index;
 356       continue;
 357     }
 358
 359     if ((stricmp (argv[Index], "-o") == 0) || (stricmp (argv[Index], "--output") == 0)) {
 360       OutputPathInfo.Path  = argv[Index + 1];
 361       OutputPathInfo.Input = FALSE;
 362       if (OutputPathInfo.Path == NULL) {
 363         Error (NULL, 0, 1003, "Invalid option value", "Output file name can't be NULL");
 364         return 1;
 365       }
 366       if (OutputPathInfo.Path[0] == '-') {
 367         Error (NULL, 0, 1003, "Invalid option value", "Output file is missing");
 368         return 1;
 369       }
 370       ++Index;
 371       continue;
 372     }
 373
 374     if ((stricmp (argv[Index], "-h") == 0) || (stricmp (argv[Index], "--help") == 0)) {
 375       PrintUsage ();
 376       return 0;
 377     }
 378
 379     if (stricmp (argv[Index], "--version") == 0) {
 380       Version ();
 381       return 0;
 382     }
 383
 384     if ((stricmp (argv[Index], "-v") == 0) || (stricmp (argv[Index], "--verbose") == 0)) {
 385       continue;
 386     }
 387
 388     if ((stricmp (argv[Index], "-q") == 0) || (stricmp (argv[Index], "--quiet") == 0)) {
 389       continue;
 390     }
 391
 392     if ((stricmp (argv[Index], "-d") == 0) || (stricmp (argv[Index], "--debug") == 0)) {
 393       EfiStatus = AsciiStringToUint64 (argv[Index + 1], FALSE, &LogLevel);
 394       if (EFI_ERROR (EfiStatus)) {
 395         Error (NULL, 0, 1003, "Invalid option value", "%s = %s", argv[Index], argv[Index + 1]);
 396         return 1;
 397       }
 398       if (LogLevel > 9) {
 399         Error (NULL, 0, 1003, "Invalid option value", "Debug Level range is 0-9, currnt input level is %d", (int) LogLevel);
 400         return 1;
 401       }
 402       SetPrintLevel (LogLevel);
 403       DebugMsg (NULL, 0, 9, "Debug Mode Set", "Debug Output Mode Level %s is set!", argv[Index + 1]);
 404       ++Index;
 405       continue;
 406     }
 407
 408     //
 409     // Don't recognize the parameter.
 410     //
 411     Error (NULL, 0, 1000, "Unknown option", "%s", argv[Index]);
 412     return 1;
 413   }
 414
 415   if (InputPathInfo.Path == NULL) {
 416     Error (NULL, 0, 1001, "Missing options", "Input file is missing");
 417     return 1;
 418   }
 419
 420   if (OutputPathInfo.Path == NULL) {
 421     Error (NULL, 0, 1001, "Missing options", "Output file is missing");
 422     return 1;
 423   }
 424
 425   if (GetPathInfo(&InputPathInfo) != ErrorSuccess) {
 426     Error (NULL, 0, 1003, "Invalid option value", "Input file can't be found.");
 427     return 1;
 428   }
 429
 430   if (GetPathInfo(&OutputPathInfo) != ErrorSuccess) {
 431     Error (NULL, 0, 1003, "Invalid option value", "Output file can't be found.");
 432     return 1;
 433   }
 434
 435   //
 436   // Process DBR (Patch or Read)
 437   //
 438   Status = ProcessBsOrMbr (&InputPathInfo, &OutputPathInfo, ProcessMbr);
 439
 440   if (Status == ErrorSuccess) {
 441     fprintf (
 442       stdout,
 443       "%s %s: successful!\n",
 444       (OutputPathInfo.Type != PathFile) ? "Write" : "Read",
 445       ProcessMbr ? "MBR" : "DBR"
 446       );
 447     return 0;
 448   } else {
 449     fprintf (
 450       stderr,
 451       "%s: %s %s: failed - %s (LastError: 0x%x)!\n",
 452       (Status == ErrorNoMbr) ? "WARNING" : "ERROR",
 453       (OutputPathInfo.Type != PathFile) ? "Write" : "Read",
 454       ProcessMbr ? "MBR" : "DBR",
 455       ErrorStatusDesc[Status],
 456       errno
 457       );
 458     return 1;
 459   }
 460 }