int GptBootProgramList(HGPT hGPT) { int iErr; // Buffer for the 1st sector of programs in the chain char *pSect = (char *)NULL; EFI_MBR_HEADER *pMbr; EFI_BOOT_PROGRAM_HEADER *pOldProgram; // QWORD qwLBA; // Allocate buffers to access drive data. pSect = (char *)malloc(hGPT->iSectorSize); if (!pSect) GptBootProgramListFail(1); pMbr = (EFI_MBR_HEADER *)pSect; pOldProgram = (EFI_BOOT_PROGRAM_HEADER *)pSect; // Scan the chain printf("Boot program chain: "); iErr = GptBlockRead(hGPT, qwZero, 1, pSect); if (iErr) GptBootProgramListFail(2); if ( (memcmp(((char *)&(pMbr->Header.Signature))+3, "MBR32", 5)) // Unknown signature || (!CheckCrc(128, &(pMbr->Header))) // invalid CRC ) GptBootProgramListFail(3); // Invalid boot program chain qwLBA = pMbr->NextBootProg.StartingLBA; if (!qwLBA) // The chain is empty so far { printf("Empty."); } else for (;;) // Else scan the chain until the current boot menu or the end { printfx("LBA=0x%s ", qwLBA); iErr = GptBlockRead(hGPT, qwLBA, 1, pSect); if (iErr) GptBootProgramListFail(2); if (!CheckCrc(hGPT->iSectorSize, &(pOldProgram->Header))) GptBootProgramListFail(4); if (!pOldProgram->NextBootProg.StartingLBA) // Reached the end of the chain! { printf("\n"); break; } qwLBA = pOldProgram->NextBootProg.StartingLBA; } bplist_return: free(pSect); return iErr; }
// fast method to just read the UID of a tag (collission detection not supported) // *buf should be large enough to fit the 64bit uid // returns 1 if suceeded int getUID(uint8_t *buf) { UsbCommand resp; UsbCommand c = {CMD_ISO_15693_COMMAND, {0, 1, 1}}; // len,speed,recv? c.d.asBytes[0] = ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH | ISO15_REQ_INVENTORY | ISO15_REQINV_SLOT1; c.d.asBytes[1] = ISO15_CMD_INVENTORY; c.d.asBytes[2] = 0; // mask length AddCrc(c.d.asBytes, 3); c.arg[0] = 5; // len uint8_t retry; // don't give up the at the first try for (retry = 0; retry < 3; retry++) { clearCommandBuffer(); SendCommand(&c); if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) { uint8_t resplen = resp.arg[0]; if (resplen >= 12 && CheckCrc(resp.d.asBytes, 12)) { memcpy(buf, resp.d.asBytes + 2, 8); return 1; } } } // retry if ( retry >= 3 ) PrintAndLogEx(WARNING, "timeout while waiting for reply."); return 0; }
void ArchExecutor::CheckFileIntagrity(Options* options) { int filesCount = options->Files->GetCount(); for(int i = 0; i < filesCount; i++) { char* path = options->Files->GetElement(i); FILE* file = fopen(path, "rb"); if (IsCompressedFile(file) && !CheckCrc(file)) { printf("arch: %s: invalid compressed data--crc error\n", GetName(path)); } fclose(file); } }
/** * efi_main - The entry point for the OS loader image. * @image: firmware-allocated handle that identifies the image * @sys_table: EFI system table */ EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *_table) { WCHAR *error_buf; EFI_STATUS err; EFI_LOADED_IMAGE *info; CHAR16 *name, *options; UINT32 options_size; char *cmdline; InitializeLib(image, _table); sys_table = _table; boot = sys_table->BootServices; runtime = sys_table->RuntimeServices; if (CheckCrc(sys_table->Hdr.HeaderSize, &sys_table->Hdr) != TRUE) return EFI_LOAD_ERROR; Print(banner, EFILINUX_VERSION_MAJOR, EFILINUX_VERSION_MINOR); err = fs_init(); if (err != EFI_SUCCESS) goto failed; err = handle_protocol(image, &LoadedImageProtocol, (void **)&info); if (err != EFI_SUCCESS) goto fs_deinit; if (!read_config_file(info, &options, &options_size)) { int i; options = info->LoadOptions; options_size = info->LoadOptionsSize; /* * Skip the first word, that's probably our name. Stop * when we hit a word delimiter (' ') or the start of an * efilinux argument ('-'). */ i = 0; while (i < options_size) { if (options[i] == ' ' || options[i] == '-') break; i++; } options = &options[i]; options_size -= i; } if (options && options_size != 0) { err = parse_args(options, options_size, &name, &cmdline); /* We print the usage message in case of invalid args */ if (err == EFI_INVALID_PARAMETER) { fs_exit(); return EFI_SUCCESS; } if (err != EFI_SUCCESS) goto fs_deinit; } err = load_image(image, name, cmdline); if (err != EFI_SUCCESS) goto free_args; return EFI_SUCCESS; free_args: free(cmdline); free(name); fs_deinit: fs_exit(); failed: /* * We need to be careful not to trash 'err' here. If we fail * to allocate enough memory to hold the error string fallback * to returning 'err'. */ if (allocate_pool(EfiLoaderData, ERROR_STRING_LENGTH, (void **)&error_buf) != EFI_SUCCESS) { Print(L"Couldn't allocate pages for error string\n"); return err; } StatusToString(error_buf, err); Print(L": %s\n", error_buf); return exit(image, err, ERROR_STRING_LENGTH, error_buf); }
// Reads all memory pages // need to write to file int CmdHF15Dump(const char*Cmd) { uint8_t fileNameLen = 0; char filename[FILE_PATH_SIZE] = {0}; char * fptr = filename; bool errors = false; uint8_t cmdp = 0; uint8_t uid[8] = {0,0,0,0,0,0,0,0}; while(param_getchar(Cmd, cmdp) != 0x00 && !errors) { switch(param_getchar(Cmd, cmdp)) { case 'h': case 'H': return usage_15_dump(); case 'f': case 'F': fileNameLen = param_getstr(Cmd, cmdp+1, filename, FILE_PATH_SIZE); cmdp += 2; break; default: PrintAndLogEx(WARNING, "Unknown parameter '%c'\n", param_getchar(Cmd, cmdp)); errors = true; break; } } //Validations if (errors) return usage_15_dump(); if (fileNameLen < 1) { PrintAndLogEx(INFO, "Using UID as filename"); if (!getUID(uid)) { PrintAndLogEx(WARNING, "No tag found."); return 1; } fptr += sprintf(fptr, "hf-15-"); FillFileNameByUID(fptr,uid,"-dump",sizeof(uid)); } // detect blocksize from card :) PrintAndLogEx(NORMAL, "Reading memory from tag UID %s", sprintUID(NULL, uid)); int blocknum = 0; uint8_t *recv = NULL; // memory. t15memory mem[256]; uint8_t data[256*4] = {0}; memset(data, 0, sizeof(data)); UsbCommand resp; UsbCommand c = {CMD_ISO_15693_COMMAND, {0, 1, 1}}; // len,speed,recv? uint8_t *req = c.d.asBytes; req[0] = ISO15_REQ_SUBCARRIER_SINGLE | ISO15_REQ_DATARATE_HIGH | ISO15_REQ_NONINVENTORY | ISO15_REQ_ADDRESS; req[1] = ISO15_CMD_READ; // copy uid to read command memcpy(req+2, uid, sizeof(uid)); for (int retry = 0; retry < 5; retry++) { req[10] = blocknum; AddCrc(req, 11); c.arg[0] = 13; clearCommandBuffer(); SendCommand(&c); if (WaitForResponseTimeout(CMD_ACK, &resp, 2000)) { uint8_t len = resp.arg[0]; if ( len < 2 ) { PrintAndLogEx(FAILED, "iso15693 card select failed"); continue; } recv = resp.d.asBytes; if ( !CheckCrc(recv, len) ) { PrintAndLogEx(FAILED, "crc fail"); continue; } if (recv[0] & ISO15_RES_ERROR) { PrintAndLogEx(FAILED, "Tag returned Error %i: %s", recv[1], TagErrorStr(recv[1]) ); break; } mem[blocknum].lock = resp.d.asBytes[0]; memcpy(mem[blocknum].block, resp.d.asBytes + 1, 4); memcpy(data + (blocknum * 4), resp.d.asBytes + 1, 4); retry = 0; blocknum++; printf("."); fflush(stdout); } } PrintAndLogEx(NORMAL, "\n"); PrintAndLogEx(NORMAL, "block# | data |lck| ascii"); PrintAndLogEx(NORMAL, "---------+--------------+---+----------"); for (int i = 0; i < blocknum; i++) { PrintAndLogEx(NORMAL, "%3d/0x%02X | %s | %d | %s", i, i, sprint_hex(mem[i].block, 4 ), mem[i].lock, sprint_ascii(mem[i].block, 4) ); } PrintAndLogEx(NORMAL, "\n"); size_t datalen = blocknum * 4; saveFileEML(filename, "eml", data, datalen, 4); saveFile(filename, "bin", data, datalen); return 0; }
int main( int argc, char **argv ) { FILE *fp; char *game_file; int level = 0; int old_level = 0; (void) printf(&title_msg[WHAT_OFFSET]); /*lint -e506 Ignore constat boolean */ assert(sizeof(SAVED_GAME) == SAVED_GAME_SIZE); /*lint +e506 Ignore constat boolean */ if (argc != 3) { (void) printf("Usage: SetLevel (saved game) (level)\n"); (void) printf(" 1 - Rookie\n"); (void) printf(" 2 - Amateur\n"); (void) printf(" 3 - Semi-Pro\n"); (void) printf(" 4 - Pro\n"); (void) printf(" 5 - Ace\n"); return -1; } game_file = argv[1]; level = atoi(argv[2]); if (level < 1 || level > 5) { (void) printf("SetLevel: The level value should be between 1 and 5.\n"); return -1; } --level; if ((fp = fopen(game_file, "rb+")) == NULL) { (void) printf("SetLevel: Unable to open saved game file called '%s'\n", game_file); return -1; } if (fread(&game, sizeof(game), 1, fp) != 1) { (void) printf("SetLevel: Unable to read from saved game file called '%s'\n", game_file); return -1; } if (!CheckCrc(&game, sizeof(game), game.crc1, game.crc2)) { (void) printf("SetLevel: '%s' doesn't appear to be a valid saved game file.\n", game_file); return -1; } /* ** Update level and recalculate CRC. */ old_level = game.data[LEVEL_OFFSET]; game.data[LEVEL_OFFSET] = (unsigned char) level; CalcCrc(&game, sizeof(game), &game.crc1, &game.crc2); (void) fseek(fp, 0L, SEEK_SET); if (fwrite(&game, sizeof(game), 1, fp) != 1) { (void) printf("SetLevel: Unable to write to saved game file called '%s'\n", game_file); return -1; } (void) printf("Updated saved game '%s' from '%s' to '%s'\n", game_file, level_txt[old_level], level_txt[level]); (void) fclose(fp); return 0; }
int GptBootProgramAdd(HGPT hGPT, char *pNewSect) { int iErr; // Buffer for the 1st sector of the new boot program EFI_BOOT_PROGRAM_HEADER *pNewProgram = (EFI_BOOT_PROGRAM_HEADER *)pNewSect; // Buffer for the 1st sector of other programs in the chain char *pSect = (char *)NULL; EFI_MBR_HEADER *pMbr; EFI_BOOT_PROGRAM_HEADER *pOldProgram; // QWORD qwLBA, qwLastLBA; #ifdef _DEBUG char szQwordBuf[20]; #endif QWORD qwNewLBA = pNewProgram->Partition.StartingLBA; EFI_GUID guidNew = pNewProgram->Partition.PartitionTypeGUID; #ifdef _DEBUG if (iDebug) printf("GptBootProgramAdd(hBlockDev=%p, lba=%s)\n", hGPT->hBlockDev, qwtox(qwNewLBA, szQwordBuf)); #endif // Allocate buffers to access drive data. pSect = (char *)malloc(hGPT->iSectorSize); if (!pSect) GptBootProgramAddFail(1); pMbr = (EFI_MBR_HEADER *)pSect; pOldProgram = (EFI_BOOT_PROGRAM_HEADER *)pSect; // Update the boot program chain iErr = GptBlockRead(hGPT, qwZero, 1, pSect); if (iErr) GptBootProgramAddFail(2); if ( (memcmp(((char *)&(pMbr->Header.Signature))+3, "MBR32", 5)) // Unknown signature || (!CheckCrc(128, &(pMbr->Header))) // invalid CRC ) GptBootProgramAddFail(3); // Invalid boot program chain qwLBA = pMbr->NextBootProg.StartingLBA; qwLastLBA = 0; if (!qwLBA) // The chain is empty so far { pMbr->NextBootProg.StartingLBA = qwNewLBA; // Start the chain with this boot program. } else if (GUIDCMP(guidNew, guidBootMenu)) // It's not empty, but Anything else than boot menus is inserted ahead of the chain. { pMbr->NextBootProg.StartingLBA = qwNewLBA; // Start the chain with this new boot program. pNewProgram->NextBootProg.StartingLBA = qwLBA; // And link this new boot program to the previous chain. } else for (;;) // Else scan the chain until the current boot menu or the end { iErr = GptBlockRead(hGPT, qwLBA, 1, pSect); if (iErr) GptBootProgramAddFail(2); if (!CheckCrc(hGPT->iSectorSize, &(pOldProgram->Header))) GptBootProgramAddFail(3); if (!GUIDCMP(pOldProgram->Partition.PartitionTypeGUID, guidBootMenu)) { // There's already one boot menu in the chain! // Back-up to the previous boot program. qwLBA = qwLastLBA; iErr = GptBlockRead(hGPT, qwLBA, 1, pSect); if (iErr) GptBootProgramAddFail(2); if (!qwLBA) pMbr->NextBootProg.StartingLBA = qwNewLBA; // Start the chain with this boot menu. else pOldProgram->NextBootProg.StartingLBA = qwNewLBA;// Append this boot menu to the chain break; } qwLastLBA = qwLBA; if (!pOldProgram->NextBootProg.StartingLBA) // Reached the end of the chain! { pOldProgram->NextBootProg.StartingLBA = qwNewLBA; // Append this boot menu to the chain break; } qwLBA = pOldProgram->NextBootProg.StartingLBA; } SetCrc(&pNewProgram->Header); // Update the CRC. iErr = GptBlockWrite(hGPT, qwNewLBA, 1, pNewSect); if (iErr) GptBootProgramAddFail(2); SetCrc(&pOldProgram->Header); // Update the CRC. iErr = GptBlockWrite(hGPT, qwLastLBA, 1, pSect); if (iErr) GptBootProgramAddFail(2); bpadd_return: free(pSect); return iErr; }
int GptAllocFileCopy(HGPT hGPT, char *pszFileName, EFI_PARTITION_ENTRY *pNewEntry) { int i; int iPartition; QWORD qwLBA; int iErr; // To be cleaned up before return char *pSect = (char *)NULL; // End of clean-up zone int nSect; FILE *hf = NULL; // Compute the number of partition entries per sector. // int iEntryPerSect = hGPT->iSectorSize / sizeof(EFI_PARTITION_ENTRY); // Allocate a buffer to access drive data. pSect = (char *)malloc(hGPT->iSectorSize); if (!pSect) GptAllocFileCopyFail(-4); // Open the partition image file hf = fopen(pszFileName, "rb"); if (!hf) GptAllocFileCopyFail(-10); // Compute the number of sectors necessary. nSect = (int)((_filelength(_fileno(hf)) + hGPT->iSectorSize - 1) / hGPT->iSectorSize); // Search the smallest contiguous block of free sectors large enough. pNewEntry->EndingLBA = nSect; iPartition = GptAllocSectors(hGPT, pNewEntry); // Side effect: pNewEntry->PartitionTypeGUID = 0; if (iPartition < 0) GptAllocFileCopyFail(iPartition); #ifdef _DEBUG if (iVerbose) { printf("Allocating partition entry #%d for copying from file %s\n", iPartition, pszFileName); } #endif // Write the partition contents for (i=0, qwLBA=pNewEntry->StartingLBA; i<nSect; i++, qwLBA++) { size_t stRead; stRead = fread(pSect, 1, hGPT->iSectorSize, hf); if (stRead < (size_t)(hGPT->iSectorSize)) memset(pSect+stRead, 0, hGPT->iSectorSize-stRead); // ~~jfl 2001/12/19 Use the partition type GUID specified in the file, if any. if (i==0) { EFI_BOOT_PROGRAM_HEADER *pHdr = (EFI_BOOT_PROGRAM_HEADER *)pSect; if (CheckCrc(hGPT->iSectorSize, &(pHdr->Header))) { if (!memcmp(((char *)&(pHdr->Header.Signature))+3, "MBR32", 5)) { pNewEntry->PartitionTypeGUID = guidMbrBackup; // If it's inside the GPT, then it's the backup! } else // Assume it's a relay or a boot program (Including the boot menu). { // Both have a partition entry behind the header. pNewEntry->PartitionTypeGUID = pHdr->Partition.PartitionTypeGUID; } } else if ( (!memcmp(((char *)&(pHdr->Header.Signature))+3, "Relay", 5)) && (!uuidcmp(&(pHdr->Partition.PartitionTypeGUID), &guidRelay)) ) // It's a relay, but with the header incomplete (CRC not set yet). { pNewEntry->PartitionTypeGUID = guidRelay; // ~~jfl 2002/01/03 Update the partition header while we have it. uuid_create((uuid_t *)&(pHdr->Partition.UniquePartitionGUID)); // Generate a new GUID SetCrc(&(pHdr->Header)); } else if (IsMBR(pSect)) // Master Boot Record. Assume it's a hard disk. { pNewEntry->PartitionTypeGUID = guidHardDiskImage; } if (IsNullUuid((uuid_t*)&(pNewEntry->PartitionTypeGUID))) // Assume anything else is a floppy. { pNewEntry->PartitionTypeGUID = guidFloppyImage; } } iErr = GptBlockWrite(hGPT, qwLBA, 1, pSect); if (iErr) GptAllocFileCopyFail(-3); } copy_return: // Cleanup fclose(hf); free(pSect); return iPartition; }
HGPT GptOpen(HANDLE hBlockDev) { int iErr; // To be cleaned up eventually GPTREF *hGPT; // End of clean-up zone #ifdef _DEBUG if (iDebug) printf("GptOpen(hBlockDev=%p)\n", hBlockDev); #endif // Create a new GPTREF object hGPT = NEW(GPTREF); if (!hGPT) return 0; memset(hGPT, 0, sizeof(GPTREF)); // Clear everything hGPT->hBlockDev = hBlockDev; // Manage logical sectors that may be different from physical sectors in the case of image files. hGPT->iSectorSize = BlockSize(hGPT->hBlockDev); // Sector size. 1 for files; 512 for disks. hGPT->iSectPerSect = 1; // Number of logical sectors per physical sector if (BlockType(hBlockDev) == 0) // If it's a file image of a GPT... { // ... Force all file accesses per 512-byte blocks hGPT->iSectPerSect = 512 / hGPT->iSectorSize; // Logical sectors per physical sector hGPT->iSectorSize = 512; // New logical sector size } // Allocate buffers to access drive data. hGPT->pGptHdr = (EFI_PARTITION_TABLE_HEADER *)malloc(hGPT->iSectorSize); if (!hGPT->pGptHdr) GptOpenFail(); // Get the GPT header. iErr = GptBlockRead(hGPT, qwOne, 1, hGPT->pGptHdr); if (iErr) GptOpenFail(); // Debug. TO BE REMOVED. CheckCrc(hGPT->iSectorSize, &(hGPT->pGptHdr->Header)); CheckCrcAltSize(hGPT->iSectorSize, 0x5C, &(hGPT->pGptHdr->Header)); CheckCrcAltSize(hGPT->iSectorSize, 0x58, &(hGPT->pGptHdr->Header)); if (!strncmp((char *)&(hGPT->pGptHdr->Header.Signature), "TRAP IFE", 8)) { strncpy((char *)&(hGPT->pGptHdr->Header.Signature), EFI_PTAB_HEADER_ID, 8); } // DumpBuf(&(hGPT->pGptHdr->Header), 0, hGPT->pGptHdr->Header.HeaderSize); CheckCrc(hGPT->iSectorSize, &(hGPT->pGptHdr->Header)); CheckCrcAltSize(hGPT->iSectorSize, 0x5C, &(hGPT->pGptHdr->Header)); CheckCrcAltSize(hGPT->iSectorSize, 0x58, &(hGPT->pGptHdr->Header)); hGPT->pGptHdr->PartitionEntryArrayCRC32 = 0; CheckCrc(hGPT->iSectorSize, &(hGPT->pGptHdr->Header)); CheckCrcAltSize(hGPT->iSectorSize, 0x5C, &(hGPT->pGptHdr->Header)); CheckCrcAltSize(hGPT->iSectorSize, 0x58, &(hGPT->pGptHdr->Header)); // Check if the header is valid if (( strncmp((char *)&(hGPT->pGptHdr->Header.Signature), EFI_PTAB_HEADER_ID, 8) && strncmp((char *)&(hGPT->pGptHdr->Header.Signature), "TRAP IFE", 8)) // || (!CheckCrc(hGPT->iSectorSize, &(hGPT->pGptHdr->Header))) ) GptOpenFail(); // Success return hGPT; // HGPT is same type as GPTREF* open_return: GptClose(hGPT); return (HGPT)NULL; }
int GptBootProgramDelete(HGPT hGPT, QWORD qwFirst) { int iErr; // Buffer for the 1st sector of other programs in the chain char *pSect = (char *)NULL; EFI_MBR_HEADER *pMbr; EFI_BOOT_PROGRAM_HEADER *pBootProgram; // Buffer for the 2nd sector of other programs in the chain char *pSect2 = (char *)NULL; EFI_BOOT_PROGRAM_HEADER *pDeletedProgram; // QWORD qwLBA, qwLastLBA; #ifdef _DEBUG char szQwordBuf[20]; #endif #ifdef _DEBUG if (iDebug) printf("GptBootProgramDelete(hBlockDev=%p, lba=%s)\n", hGPT->hBlockDev, qwtox(qwFirst, szQwordBuf)); #endif if (!qwFirst) return 0; // Prevent problems // Allocate buffers to access drive data. pSect = (char *)malloc(hGPT->iSectorSize); if (!pSect) GptBootProgramDeleteFail(1); pMbr = (EFI_MBR_HEADER *)pSect; pBootProgram = (EFI_BOOT_PROGRAM_HEADER *)pSect; pSect2 = (char *)malloc(hGPT->iSectorSize); if (!pSect2) GptBootProgramDeleteFail(1); pDeletedProgram = (EFI_BOOT_PROGRAM_HEADER *)pSect2; // Update the boot program chain iErr = GptBlockRead(hGPT, qwZero, 1, pSect); if (iErr) GptBootProgramDeleteFail(2); if ( (memcmp(((char *)&(pMbr->Header.Signature))+3, "MBR32", 5)) // Unknown signature || (!CheckCrc(128, &(pMbr->Header))) // invalid CRC ) GptBootProgramDeleteFail(3); // Invalid boot program chain qwLBA = pMbr->NextBootProg.StartingLBA; qwLastLBA = 0; if (!qwLBA) // The chain is empty so far { goto bpdel_return; // Requested boot program NOT in the chain! } else while (qwLBA != qwFirst) // Else scan the chain until the end { iErr = GptBlockRead(hGPT, qwLBA, 1, pSect); if (iErr) GptBootProgramDeleteFail(2); if (!CheckCrc(hGPT->iSectorSize, &(pBootProgram->Header))) GptBootProgramDeleteFail(3); qwLastLBA = qwLBA; if (!pBootProgram->NextBootProg.StartingLBA) // Reached the end of the chain! { goto bpdel_return; // Requested boot program NOT in the chain!Done. } qwLBA = pBootProgram->NextBootProg.StartingLBA; } iErr = GptBlockRead(hGPT, qwFirst, 1, pSect2); if (iErr) GptBootProgramDeleteFail(2); if (!CheckCrc(hGPT->iSectorSize, &(pDeletedProgram->Header))) GptBootProgramDeleteFail(3); qwLBA = pDeletedProgram->NextBootProg.StartingLBA; // The boot program that was to follow de deleted one if (!qwLastLBA) pMbr->NextBootProg.StartingLBA = qwLBA; else pBootProgram->NextBootProg.StartingLBA = qwLBA; // And link this new boot program to the previous chain. SetCrc(&pBootProgram->Header); // Update the CRC. iErr = GptBlockWrite(hGPT, qwLastLBA, 1, pSect); if (iErr) GptBootProgramDeleteFail(2); bpdel_return: free(pSect); free(pSect2); return iErr; }
int main( int argc, char **argv ) { FILE *ifp; FILE *ofp; char *name_file; char *game_file; (void) printf(&title_msg[WHAT_OFFSET]); /*lint -e506 Ignore constat boolean */ assert(sizeof(SAVED_GAME) == SAVED_GAME_SIZE); /*lint +e506 Ignore constat boolean */ if (argc != 3) { (void) printf("Usage: SetNames (name file) (saved game)\n"); return -1; } name_file = argv[1]; game_file = argv[2]; if ((ifp = fopen(name_file, "rb")) == NULL) { (void) printf("SetNames: Unable to open names file called '%s'\n", name_file); return -1; } if ((ofp = fopen(game_file, "rb+")) == NULL) { (void) printf("SetNames: Unable to open saved game file called '%s'\n", game_file); return -1; } if (fread(&names, sizeof(names), 1, ifp) != 1) { (void) printf("SetNames: Unable to read from names file called '%s'\n", name_file); return -1; } if (!CheckCrc(&names, sizeof(names), names.crc1, names.crc2)) { (void) printf("SetNames: '%s' doesn't appear to be a valid names file.\n", name_file); return -1; } if (fread(&game, sizeof(game), 1, ofp) != 1) { (void) printf("SetNames: Unable to read from saved game file called '%s'\n", game_file); return -1; } if (!CheckCrc(&game, sizeof(game), game.crc1, game.crc2)) { (void) printf("SetNames: '%s' doesn't appear to be a valid saved game file.\n", name_file); return -1; } /* ** Copy names and recalculate CRC. */ (void) memcpy(&game.names, &names, sizeof(game.names) - CRC_SIZE); CalcCrc(&game, sizeof(game), &game.crc1, &game.crc2); (void) fseek(ofp, 0L, SEEK_SET); if (fwrite(&game, sizeof(game), 1, ofp) != 1) { (void) printf("SetNames: Unable to write to saved game file called '%s'\n", name_file); return -1; } (void) printf("Updated saved game '%s' with names from '%s'\n", game_file, name_file); (void) fclose(ifp); (void) fclose(ofp); return 0; }
/** * efi_main - The entry point for the OS loader image. * @image: firmware-allocated handle that identifies the image * @sys_table: EFI system table */ EFI_STATUS efi_main(EFI_HANDLE image, EFI_SYSTEM_TABLE *_table) { WCHAR *error_buf; EFI_STATUS err; EFI_LOADED_IMAGE *info; CHAR16 *name = NULL; CHAR16 *options; BOOLEAN options_from_conf_file = FALSE; UINT32 options_size; CHAR8 *cmdline = NULL; struct bootimg_hooks hooks; main_image_handle = image; InitializeLib(image, _table); sys_table = _table; boot = sys_table->BootServices; runtime = sys_table->RuntimeServices; if (CheckCrc(ST->Hdr.HeaderSize, &ST->Hdr) != TRUE) return EFI_LOAD_ERROR; log_init(); info(banner, EFILINUX_VERSION_MAJOR, EFILINUX_VERSION_MINOR, EFILINUX_BUILD_STRING, EFILINUX_VERSION_STRING, EFILINUX_VERSION_DATE); store_osloader_version(EFILINUX_BUILD_STRING); err = fs_init(); if (err != EFI_SUCCESS) error(L"fs_init failed, DnX mode ?\n"); err = handle_protocol(image, &LoadedImageProtocol, (void **)&info); if (err != EFI_SUCCESS) goto fs_deinit; efilinux_image_base = info->ImageBase; efilinux_image = info->DeviceHandle; if (!read_config_file(info, &options, &options_size)) { int i; options = info->LoadOptions; options_size = info->LoadOptionsSize; /* Skip the first word, that's our name. */ for (i = 0; i < options_size && options[i] != ' '; i++) ; options = &options[i]; options_size -= i; } else options_from_conf_file = TRUE; err = init_platform_functions(); if (EFI_ERROR(err)) { error(L"Failed to initialize platform: %r\n", err); goto fs_deinit; } CHAR16 type = '\0'; if (options && options_size != 0) { err = parse_args(options, options_size, &type, &name, &cmdline); if (options_from_conf_file) free(options); /* We print the usage message in case of invalid args */ if (err == EFI_INVALID_PARAMETER) { fs_exit(); return EFI_SUCCESS; } if (err != EFI_SUCCESS) goto fs_deinit; } hooks.before_exit = loader_ops.hook_before_exit; hooks.before_jump = loader_ops.hook_before_jump; hooks.watchdog = tco_start_watchdog; debug(L"shell cmdline=%a\n", cmdline); switch(type) { case 'f': if (!name) { error(L"No file name specified or name is empty\n"); goto free_args; } info(L"Starting file %s\n", name); err = android_image_start_file(info->DeviceHandle, name, cmdline, &hooks); break; case 't': { enum targets target; if ((err = name_to_target(name, &target)) != EFI_SUCCESS) { error(L"Unknown target name %s\n", name); goto free_args; } info(L"Starting target %s\n", name); loader_ops.load_target(target, cmdline); break; } case 'p': { EFI_GUID part_guid; if ((err = name_to_guid(name, &part_guid)) != EFI_SUCCESS) { error(L"Unknown target name %s\n", name); goto free_args; } info(L"Starting partition %s\n", name); err = android_image_start_partition(&part_guid, cmdline, &hooks); break; } case 'c': { int i; for (i = 0 ; i < sizeof(commands) / sizeof(*commands); i++) if (!StrCmp(commands[i].name, name)) commands[i].func(); err = EFI_SUCCESS; } break; case 'a': { CHAR16 *endptr; VOID * addr = (VOID *)strtoul16(name, &endptr, 0); if ((name[0] == '\0' || *endptr != '\0')) { error(L"Failed to convert %s into address\n", name); goto free_args; } debug(L"Loading android image at 0x%x\n", addr); err = android_image_start_buffer(addr, cmdline, &hooks); break; } default: debug(L"type=0x%x, starting bootlogic\n", type); err = start_boot_logic(cmdline); if (EFI_ERROR(err)) { error(L"Boot logic failed: %r\n", err); goto free_args; } } free_args: if (cmdline) free(cmdline); if (name) free(name); fs_deinit: fs_exit(); /* * We need to be careful not to trash 'err' here. If we fail * to allocate enough memory to hold the error string fallback * to returning 'err'. */ error_buf = AllocatePool(ERROR_STRING_LENGTH); if (!error_buf) { error(L"Couldn't allocate pages for error string\n"); return EFI_OUT_OF_RESOURCES; } StatusToString(error_buf, err); error(L": %s\n", error_buf); loader_ops.hook_before_exit(); return exit(image, err, ERROR_STRING_LENGTH, error_buf); }