Пример #1
0
// ----------------------------------------------------------------------------
// Load
// ----------------------------------------------------------------------------
static bool _cartridge_Load(const byte* data, uint size) {
  uint index;
  if(size <= 128) {
    fprintf(stderr,"Cartridge data is invalid.");
    //logger_LogError("Cartridge data is invalid.", CARTRIDGE_SOURCE);
    return false;
  }

  cartridge_Release( );
  
  byte header[128] = {0};
  for(index = 0; index < 128; index++) {
    header[index] = data[index];
  }

  uint offset = 0;
  if(cartridge_HasHeader(header)) {
    cartridge_ReadHeader(header);
    size -= 128;
    offset = 128;
  }
  else {
    cartridge_size = size;
  }
  
  cartridge_buffer = (char *) malloc(cartridge_size);
  for(index = 0; index < cartridge_size; index++) {
    cartridge_buffer[index] = data[index + offset];
  }
  
//strcpy(cartridge_digest,hash_Compute(cartridge_buffer, cartridge_size));
  hash_Compute(cartridge_buffer, cartridge_size,cartridge_digest);
  return true;
}
Пример #2
0
bool cartridge_Load_buffer(char* rom_buffer, int rom_size) {
  cartridge_Release();
  byte* data = (byte *)rom_buffer;
  uint size = rom_size;

  if(!_cartridge_Load(data, size)) {
    return false;
  }
  strcpy(cartridge_filename ,"");
  return true;
}
Пример #3
0
// ----------------------------------------------------------------------------
// Load
// ----------------------------------------------------------------------------
bool cartridge_Load(const uint8_t* data, uint32_t size)
{
   int index;
   uint32_t offset     = 0;
   uint8_t header[128] = {0};

   /* Cartridge data is invalid. */
   if(size <= 128)
      return false;

   cartridge_Release( );

   for(index = 0; index < 128; index++)
      header[index] = data[index];

   /* Prosystem doesn't support CC2 hacks. */
   if (cartridge_CC2(header))
      return false;

   if(cartridge_HasHeader(header))
   {
      cartridge_ReadHeader(header);
      size -= 128;
      offset = 128;
   }

   cartridge_size   = size;
   cartridge_buffer = (uint8_t*)malloc(cartridge_size * sizeof(uint8_t));

   for(index = 0; index < cartridge_size; index++)
      cartridge_buffer[index] = data[index + offset];

   hash_Compute(cartridge_digest, cartridge_buffer, cartridge_size);

   return true;
}
Пример #4
0
// ----------------------------------------------------------------------------
// Load
// ----------------------------------------------------------------------------
bool cartridge_Load(char *filename) {
  if(strlen(filename) == 0) {
	fprintf(stderr,"Cartridge filename is invalid.");
    //logger_LogError("Cartridge filename is invalid.", CARTRIDGE_SOURCE);
    return false;
  }
  
  cartridge_Release();
  //logger_LogInfo("Opening cartridge file " + filename + ".");
  
  byte* data = NULL;
  uint size = archive_GetUncompressedFileSize(filename);
  if(size == 0) {
    int file = open(filename, O_RDONLY | O_BINARY);
    if (file < 0) {
      fprintf(stderr,"Failed to open the cartridge file %s for reading", filename);
      //logger_LogError("Failed to open the cartridge file " + filename + " for reading.", CARTRIDGE_SOURCE);
      return false;  
    }

#if 0
    if(lseek(file, 0L, SEEK_END) <0) {
      close(file);
      //logger_LogError("Failed to find the end of the cartridge file.", CARTRIDGE_SOURCE);
      return false;
    }
    size = ftell(file);
    if(lseek(file, 0L, SEEK_SET)<0) {
      close(file);
      //logger_LogError("Failed to find the size of the cartridge file.", CARTRIDGE_SOURCE);
      return false;
    }
#endif

	struct stat fileStat;
    if (stat(filename,&fileStat) < 0)  {
      fprintf(stderr,"Failed to find the size of the cartridge file.");
      //logger_LogError("Failed to find the size of the cartridge file.", CARTRIDGE_SOURCE);
      return false;
    }
	
	size = fileStat.st_size;
    data = (char *) malloc(size);
    if( (read(file, (char *) data, size) < 0) /*&& ferror(file)*/) {
      close(file);
	  fprintf(stderr,"Failed to read the cartridge data.");
      //logger_LogError("Failed to read the cartridge data.", CARTRIDGE_SOURCE);
      cartridge_Release( );
      free(data);
      return false;
    }    

    close(file);    
  }
  else {
    data = (char *) malloc(size);
    archive_Uncompress(filename, data, size);
  }

  if(!_cartridge_Load(data, size)) {
	  fprintf(stderr,"Failed to load the cartridge data into memory.\n");
    //logger_LogError("Failed to load the cartridge data into memory.", CARTRIDGE_SOURCE);
    free(data);
    return false;
  }
  if(data != NULL) {
	gameCRC = crc32(0, data, size);
	free(data);
  }
  strcpy(cartridge_filename, filename);
  return true;
}