void dump_fat_header(FILE *obj_file, int is_swap) {
int header_size = sizeof(struct fat_header);
int arch_size = sizeof(struct fat_arch);
struct fat_header *header = load_bytes(obj_file, 0, header_size);
if (is_swap) {
swap_fat_header(header, 0);
}
int arch_offset = header_size;
for (int i = 0; i < header->nfat_arch; i++) {
struct fat_arch *arch = load_bytes(obj_file, arch_offset, arch_size);
if (is_swap) {
swap_fat_arch(arch, 1, 0);
}
int mach_header_offset = arch->offset;
free(arch);
arch_offset += arch_size;
uint32_t magic = read_magic(obj_file, mach_header_offset);
int is_64 = is_magic_64(magic);
int is_swap_mach = should_swap_bytes(magic);
dump_mach_header(obj_file, mach_header_offset, is_64, is_swap_mach);
}
free(header);
}
int main(int argc, char** argv)
{
if (argc != 2)
{
fprintf(stderr, "Usage: %s <object file or executable>\n", argv[0]);
return 1;
}
FILE* stream = fopen(argv[1], "r");
if (stream == NULL)
{
fprintf(stderr, "%s: invalid file\n", argv[1]);
return 1;
}
uint32_t signature = read_magic(stream);
rewind(stream);
switch (signature)
{
case MH_MAGIC_64:
parse_64bit_mach(stream);
break;
default:
fprintf(stderr, "%s: unsupported or unrecognized format 0x%08x\n", argv[1], signature);
break;
}
fclose(stream);
return 0;
}
int main(int argc, char** argv)
{
if (argc != 3)
{
fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
return 1;
}
FILE* stream;
if ((stream = fopen(argv[1], "r")) == NULL)
{
fprintf(stderr, "%s: invalid file\n", argv[1]);
return 1;
}
uint32_t magic = read_magic(stream);
if (magic != MH_MAGIC_64)
{
fprintf(stderr, "%s: unsupported or unrecognized format 0x%08x\n", argv[1], magic);
fclose(stream);
return 1;
}
rewind(stream);
if (!is_object_file(stream))
{
fprintf(stderr, "%s: is not an object file\n", argv[1]);
fclose(stream);
return 1;
}
uint8_t* byte_code = NULL;
size_t length = 0;
rewind(stream);
extract_byte_code(stream, byte_code, length);
fclose(stream);
if (byte_code == NULL)
{
fprintf(stderr, "%s: couldn't find text section in file\n", argv[1]);
return 2;
}
if ((stream = fopen(argv[2], "w")) == NULL)
{
fprintf(stderr, "%s: couldn't open file for writing\n", argv[2]);
fclose(stream);
return 1;
}
create_executable(stream, byte_code, length);
fclose(stream);
free(byte_code);
fprintf(stderr, "DONE\n");
return 0;
}
/* Interface functions */
void decompress(void)
{
int finish;
unsigned blocksize;
blocksize = read_magic() * 100000;
lc_recallocp(&block, blocksize * sizeof(*block));
lc_recallocp(&ll, blocksize * sizeof(*ll));
lc_recallocp(&zptr, blocksize * sizeof(*zptr));
initBogusModel();
arithCodeStartDecoding();
do
{
finish = getAndMoveToFrontDecode(blocksize);
undoReversibleTransformation();
spotBlock();
unRLEandDump(finish);
} while (!finish);
if (~getUInt32() != output_bs.crc)
invalid_input("CRC error");
} /* decompress */
PNGLoader::PNGLoader(IODevice iodevice, bool force_srgb)
: file(iodevice), force_srgb(force_srgb), scanline(nullptr), prev_scanline(nullptr), scanline_4ub(nullptr), scanline_4us(nullptr), palette(nullptr)
{
read_magic();
read_chunks();
decode_header();
decode_palette();
decode_colorkey();
decode_image();
}
void dump_segments(FILE *obj_file) {
uint32_t magic = read_magic(obj_file, 0);
int is_64 = is_magic_64(magic);
int is_swap = should_swap_bytes(magic);
int fat = is_fat(magic);
if (fat) {
dump_fat_header(obj_file, is_swap);
} else {
dump_mach_header(obj_file, 0, is_64, is_swap);
}
}
FileReader::FileReader( const std::string & filename ):
m_record_size(0)
{
m_file.open(filename,
std::ios_base::in | std::ios_base::binary);
if (!read_magic()) {
std::cerr << "Marsyas::Debug::FileReader: Wrong file type!" << std::endl;
m_file.close();
return;
}
if (!read_header()) {
std::cerr << "Marsyas::Debug::FileReader: Error reading header!" << std::endl;
m_file.close();
return;
}
}
long read_header(FILE *f, int *pndim, int *dim)
{
int i;
long magic;
magic = read_magic(f);
*pndim = read4(f, magic);
if (*pndim<1 || *pndim>=MAX_DIMS)
abort("number of dimensions out of range");
for (i=0;i<*pndim;i++)
dim[i] = read4(f, magic);
while(i<3) { /* for SN1 compatibility reasons */
if(magic != ASCII_MATRIX)
read4(f, magic); /* dummy */
i++;
}
return magic;
}
struct namedb *
namedb_open (const char *filename, nsd_options_t* opt, size_t num_children)
{
namedb_type *db;
/*
* Temporary region used while loading domain names from the
* database. The region is freed after each time a dname is
* read from the database.
*/
region_type *dname_region;
/*
* Temporary region used to store array of domains and zones
* while loading the database. The region is freed before
* returning.
*/
region_type *temp_region;
uint32_t dname_count;
domain_type **domains; /* Indexed by domain number. */
uint32_t zone_count;
zone_type **zones; /* Indexed by zone number. */
uint32_t i;
uint32_t rrset_count = 0;
uint32_t rr_count = 0;
rrset_type *rrset;
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(namedb_type) = %lu\n", (unsigned long) sizeof(namedb_type)));
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(zone_type) = %lu\n", (unsigned long) sizeof(zone_type)));
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(domain_type) = %lu\n", (unsigned long) sizeof(domain_type)));
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(rrset_type) = %lu\n", (unsigned long) sizeof(rrset_type)));
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(rr_type) = %lu\n", (unsigned long) sizeof(rr_type)));
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(rdata_atom_type) = %lu\n", (unsigned long) sizeof(rdata_atom_type)));
DEBUG(DEBUG_DBACCESS, 2,
(LOG_INFO, "sizeof(rbnode_t) = %lu\n", (unsigned long) sizeof(rbnode_t)));
if ((db = namedb_create()) == NULL) {
log_msg(LOG_ERR,
"insufficient memory to create database");
return NULL;
}
db->filename = region_strdup(db->region, filename);
if (gettimeofday(&(db->diff_timestamp), NULL) != 0) {
log_msg(LOG_ERR, "unable to load %s: cannot initialize"
"timestamp", db->filename);
namedb_destroy(db);
return NULL;
}
/* Open it... */
db->fd = fopen(db->filename, "r");
if (db->fd == NULL) {
log_msg(LOG_ERR, "unable to load %s: %s",
db->filename, strerror(errno));
namedb_destroy(db);
return NULL;
}
if (!read_magic(db)) {
log_msg(LOG_ERR, "corrupted database (read magic): %s", db->filename);
log_msg(LOG_ERR, "cannot load database, incompatible version "
"number. Please rebuild database and "
"start again.");
namedb_close(db);
return NULL;
}
if (!read_size(db, &zone_count)) {
log_msg(LOG_ERR, "corrupted database (read size): %s", db->filename);
namedb_close(db);
return NULL;
}
DEBUG(DEBUG_DBACCESS, 1,
(LOG_INFO, "Retrieving %lu zones\n", (unsigned long) zone_count));
temp_region = region_create(xalloc, free);
dname_region = region_create(xalloc, free);
db->zone_count = zone_count;
zones = (zone_type **) region_alloc(temp_region,
zone_count * sizeof(zone_type *));
for (i = 0; i < zone_count; ++i) {
const dname_type *dname = read_dname(db->fd, dname_region);
if (!dname) {
log_msg(LOG_ERR, "corrupted database (read dname): %s", db->filename);
region_destroy(dname_region);
region_destroy(temp_region);
namedb_close(db);
return NULL;
}
zones[i] = (zone_type *) region_alloc(db->region,
sizeof(zone_type));
zones[i]->next = db->zones;
db->zones = zones[i];
zones[i]->apex = domain_table_insert(db->domains, dname);
zones[i]->soa_rrset = NULL;
zones[i]->soa_nx_rrset = NULL;
zones[i]->ns_rrset = NULL;
#ifdef NSEC3
zones[i]->nsec3_soa_rr = NULL;
zones[i]->nsec3_last = NULL;
#endif
zones[i]->opts = zone_options_find(opt, domain_dname(zones[i]->apex));
zones[i]->number = i + 1;
zones[i]->is_secure = 0;
zones[i]->updated = 1;
zones[i]->is_ok = 0;
zones[i]->dirty = region_alloc(db->region, sizeof(uint8_t)*num_children);
memset(zones[i]->dirty, 0, sizeof(uint8_t)*num_children);
if(!zones[i]->opts) {
log_msg(LOG_ERR, "cannot load database. Zone %s in db "
"%s, but not in config file (might "
"happen if you edited the config "
"file). Please rebuild database and "
"start again.",
dname_to_string(dname, NULL), db->filename);
region_destroy(dname_region);
region_destroy(temp_region);
namedb_close(db);
return NULL;
}
#ifdef NSEC3
#ifndef FULL_PREHASH
zones[i]->nsec3_domains = NULL;
if (0 != zone_nsec3_domains_create(db, zones[i])) {
log_msg(LOG_ERR,
"insufficient memory for NSEC3 tree, "
"unable to read database");
region_destroy(dname_region);
region_destroy(temp_region);
namedb_close(db);
return NULL;
}
#endif /* !FULL_PREHASH */
#endif /* NSEC3 */
region_free_all(dname_region);
}
if (!read_size(db, &dname_count)) {
log_msg(LOG_ERR, "corrupted database (read size): %s", db->filename);
region_destroy(dname_region);
region_destroy(temp_region);
namedb_close(db);
return NULL;
}
DEBUG(DEBUG_DBACCESS, 1,
(LOG_INFO, "Retrieving %lu domain names\n", (unsigned long) dname_count));
domains = (domain_type **) region_alloc(
temp_region, dname_count * sizeof(domain_type *));
for (i = 0; i < dname_count; ++i) {
const dname_type *dname = read_dname(db->fd, dname_region);
if (!dname) {
log_msg(LOG_ERR, "corrupted database (read dname): %s", db->filename);
region_destroy(dname_region);
region_destroy(temp_region);
namedb_close(db);
return NULL;
}
domains[i] = domain_table_insert(db->domains, dname);
region_free_all(dname_region);
}
region_destroy(dname_region);
#ifndef NDEBUG
fprintf(stderr, "database region after loading domain names: ");
region_dump_stats(db->region, stderr);
fprintf(stderr, "\n");
#endif
while ((rrset = read_rrset(db, dname_count, domains, zone_count, zones))) {
++rrset_count;
rr_count += rrset->rr_count;
}
DEBUG(DEBUG_DBACCESS, 1,
(LOG_INFO, "Retrieved %lu RRs in %lu RRsets\n",
(unsigned long) rr_count, (unsigned long) rrset_count));
region_destroy(temp_region);
if ((db->crc_pos = ftello(db->fd)) == -1) {
log_msg(LOG_ERR, "ftello %s failed: %s",
db->filename, strerror(errno));
namedb_close(db);
return NULL;
}
if (!read_size(db, &db->crc)) {
log_msg(LOG_ERR, "corrupted database (read size): %s", db->filename);
namedb_close(db);
return NULL;
}
if (!read_magic(db)) {
log_msg(LOG_ERR, "corrupted database (read magic): %s", db->filename);
log_msg(LOG_ERR, "cannot load database, incompatible version "
"number. Please rebuild database and "
"start again.");
namedb_close(db);
return NULL;
}
fclose(db->fd);
db->fd = NULL;
#ifndef NDEBUG
fprintf(stderr, "database region after loading database: ");
region_dump_stats(db->region, stderr);
fprintf(stderr, "\n");
#endif
return db;
}
