static void MakeMainAddr(void)
{
unsigned short iaddr = 0;
iaddr = MAKE_SHORT(ParaUni.addr_sn);
main_addr[0] = ((iaddr%100)/10 << 4) + iaddr%10;
iaddr /= 100;
main_addr[1] = ((iaddr%100)/10 << 4) + iaddr%10;
iaddr /= 100;
main_addr[2] = ((iaddr%100)/10 << 4) + iaddr%10;
}
void parseElf32(FILE* fp, long fileSize)
{
const int sizeOfElfHeader = 0x34;
struct ELF_Header_32 elfHeader32 = {{ 0 }};
unsigned char* buffer = (unsigned char*)malloc(sizeOfElfHeader);
fread(buffer, sizeof(unsigned char), sizeOfElfHeader, fp);
char mag_str[4] = { buffer[0], buffer[1], buffer[2], buffer[3] };
// 32-bit ELF Header
memcpy(elfHeader32.ei_mag, mag_str, 4);
elfHeader32.ei_class = buffer[0x04];
elfHeader32.ei_data = buffer[0x05];
elfHeader32.ei_version = buffer[0x06];
elfHeader32.ei_osabi = buffer[0x07];
elfHeader32.ei_abiversion = buffer[0x08];
elfHeader32.e_type = MAKE_SHORT(buffer[0x11], buffer[0x10]);
elfHeader32.e_machine = MAKE_SHORT(buffer[0x13], buffer[0x12]);
elfHeader32.e_version =
MAKE_LONG(buffer[0x17], buffer[0x16], buffer[0x15], buffer[0x14]);
elfHeader32.e_entry =
MAKE_LONG(buffer[0x1B], buffer[0x1A], buffer[0x19], buffer[0x18]);
elfHeader32.e_phoff =
MAKE_LONG(buffer[0x1F], buffer[0x1E], buffer[0x1D], buffer[0x1C]);
elfHeader32.e_shoff =
MAKE_LONG(buffer[0x23], buffer[0x22], buffer[0x21], buffer[0x20]);
elfHeader32.e_flags =
MAKE_LONG(buffer[0x27], buffer[0x26], buffer[0x25], buffer[0x24]);
elfHeader32.e_ehsize = MAKE_SHORT(buffer[0x29], buffer[0x28]);
elfHeader32.e_phentsize = MAKE_SHORT(buffer[0x2B], buffer[0x2A]);
elfHeader32.e_phnum = MAKE_SHORT(buffer[0x2D], buffer[0x2C]);
elfHeader32.e_shentsize = MAKE_SHORT(buffer[0x2F], buffer[0x2E]);
elfHeader32.e_shnum = MAKE_SHORT(buffer[0x31], buffer[0x30]);
elfHeader32.e_shstrndx = MAKE_SHORT(buffer[0x33], buffer[0x32]);
free(buffer);
// 32-bit Program Headers
// if not there already, seek to program header offset found in elfHeader
if (sizeOfElfHeader != elfHeader32.e_phoff) {
if (fseek(fp, elfHeader32.e_phoff, SEEK_SET) != 0) {
printf("[ELF] Error seeking to elfHeader32.e_phoff (parse).\n");
// TODO: Clean exit in cases like this.
exit(-1);
}
}
if (elfHeader32.e_phentsize !=
(unsigned short)sizeof(struct Program_Header_32)) {
printf("[ELF Fatal Error] elfHeader32.e_phentsize == ");
printf("sizeof(Program_Header_32)\n[Is file corrupt?]\n");
// TODO: Clean exit in cases like this.
exit(-1);
}
int i = 0;
int sizeOfProgramHeaders = elfHeader32.e_phnum * elfHeader32.e_phentsize;
buffer = (unsigned char*)malloc(sizeOfProgramHeaders);
fread(buffer, sizeof(unsigned char), sizeOfProgramHeaders, fp);
struct Program_Header_32* programHeaders =
(struct Program_Header_32*)malloc(sizeOfProgramHeaders);
for (i = 0; i < elfHeader32.e_phnum; i++) {
int cur_phoff = (i * elfHeader32.e_phentsize);
struct Program_Header_32 cur_programHeader = { 0 };
cur_programHeader.p_type =
MAKE_LONG(buffer[cur_phoff+0x03], buffer[cur_phoff+0x02],
buffer[cur_phoff+0x01], buffer[cur_phoff+0x00]);
cur_programHeader.p_offset =
MAKE_LONG(buffer[cur_phoff+0x07], buffer[cur_phoff+0x06],
buffer[cur_phoff+0x05], buffer[cur_phoff+0x04]);
cur_programHeader.p_vaddr =
MAKE_LONG(buffer[cur_phoff+0x0B], buffer[cur_phoff+0x0A],
buffer[cur_phoff+0x09], buffer[cur_phoff+0x08]);
cur_programHeader.p_paddr =
MAKE_LONG(buffer[cur_phoff+0x0F], buffer[cur_phoff+0x0E],
buffer[cur_phoff+0x0D], buffer[cur_phoff+0x0C]);
cur_programHeader.p_filesz =
MAKE_LONG(buffer[cur_phoff+0x13], buffer[cur_phoff+0x12],
buffer[cur_phoff+0x11], buffer[cur_phoff+0x10]);
cur_programHeader.p_memsz =
MAKE_LONG(buffer[cur_phoff+0x17], buffer[cur_phoff+0x16],
buffer[cur_phoff+0x15], buffer[cur_phoff+0x14]);
cur_programHeader.p_flags =
MAKE_LONG(buffer[cur_phoff+0x1B], buffer[cur_phoff+0x1A],
buffer[cur_phoff+0x19], buffer[cur_phoff+0x18]);
cur_programHeader.p_align =
MAKE_LONG(buffer[cur_phoff+0x1F], buffer[cur_phoff+0x1E],
buffer[cur_phoff+0x1D], buffer[cur_phoff+0x1C]);
memcpy(&programHeaders[i], &cur_programHeader,
elfHeader32.e_phentsize);
}
free(buffer);
// 32-bit Section Headers
if (fseek(fp, elfHeader32.e_shoff, SEEK_SET) != 0) {
printf("[ELF] Error seeking to elfHeader32.e_shoff (parse).\n");
// TODO: Clean exit in cases like this.
free(programHeaders);
exit(-1);
}
if (elfHeader32.e_shentsize !=
(unsigned short)sizeof(struct Section_Header_32)) {
printf("[ELF Fatal Error] elfHeader32.e_shentsize == ");
printf("sizeof(Section_Header_32)\n[Is file corrupt?]\n");
// TODO: Clean exit in cases like this.
free(programHeaders);
exit(-1);
}
int sizeOfSectionHeaders = elfHeader32.e_shnum * elfHeader32.e_shentsize;
buffer = (unsigned char*)malloc(sizeOfSectionHeaders);
fread(buffer, sizeof(unsigned char), sizeOfSectionHeaders, fp);
struct Section_Header_32* sectionHeaders =
(struct Section_Header_32*)malloc(sizeOfSectionHeaders);
for (i = 0; i < elfHeader32.e_shnum; i++) {
int cur_shoff = (i * elfHeader32.e_shentsize);
struct Section_Header_32 cur_sectionHeader = { 0 };
cur_sectionHeader.sh_name =
MAKE_LONG(buffer[cur_shoff+0x03], buffer[cur_shoff+0x02],
buffer[cur_shoff+0x01], buffer[cur_shoff+0x00]);
cur_sectionHeader.sh_type =
MAKE_LONG(buffer[cur_shoff+0x07], buffer[cur_shoff+0x06],
buffer[cur_shoff+0x05], buffer[cur_shoff+0x04]);
cur_sectionHeader.sh_flags =
MAKE_LONG(buffer[cur_shoff+0x0B], buffer[cur_shoff+0x0A],
buffer[cur_shoff+0x09], buffer[cur_shoff+0x08]);
cur_sectionHeader.sh_address =
MAKE_LONG(buffer[cur_shoff+0x0F], buffer[cur_shoff+0x0E],
buffer[cur_shoff+0x0D], buffer[cur_shoff+0x0C]);
cur_sectionHeader.sh_offset =
MAKE_LONG(buffer[cur_shoff+0x13], buffer[cur_shoff+0x12],
buffer[cur_shoff+0x11], buffer[cur_shoff+0x10]);
cur_sectionHeader.sh_size =
MAKE_LONG(buffer[cur_shoff+0x17], buffer[cur_shoff+0x16],
buffer[cur_shoff+0x15], buffer[cur_shoff+0x14]);
cur_sectionHeader.sh_link =
MAKE_LONG(buffer[cur_shoff+0x1B], buffer[cur_shoff+0x1A],
buffer[cur_shoff+0x19], buffer[cur_shoff+0x18]);
cur_sectionHeader.sh_info =
MAKE_LONG(buffer[cur_shoff+0x1F], buffer[cur_shoff+0x1E],
buffer[cur_shoff+0x1D], buffer[cur_shoff+0x1C]);
cur_sectionHeader.sh_addralign =
MAKE_LONG(buffer[cur_shoff+0x23], buffer[cur_shoff+0x22],
buffer[cur_shoff+0x21], buffer[cur_shoff+0x20]);
cur_sectionHeader.sh_entsize =
MAKE_LONG(buffer[cur_shoff+0x27], buffer[cur_shoff+0x26],
buffer[cur_shoff+0x25], buffer[cur_shoff+0x24]);
memcpy(§ionHeaders[i], &cur_sectionHeader,
elfHeader32.e_shentsize);
}
free(buffer);
// Now, store the shstrtab
int shstrtab_addr =
sectionHeaders[elfHeader32.e_shstrndx].sh_offset;
if (!shstrtab_addr || fseek(fp, shstrtab_addr, SEEK_SET) != 0) {
printf("[ELF] Error seeking to shstrtab_addr (parse).\n");
// TODO: Clean exit in cases like this.
free(programHeaders);
free(sectionHeaders);
exit(-1);
}
int shstrtab_size = sectionHeaders[elfHeader32.e_shstrndx].sh_size;
char* shstrtab = (char*)malloc(
sizeof(char)*shstrtab_size);
fread(shstrtab, sizeof(char), shstrtab_size, fp);
// Printing!
unsigned char* codeSection = malloc(sectionHeaders[1].sh_size);
fseek(fp, sectionHeaders[1].sh_offset, SEEK_SET); // TODO: Error checking
fread(codeSection, sizeof(unsigned char), sectionHeaders[1].sh_size, fp);
disassemble_x86(&shstrtab[sectionHeaders[1].sh_name],
sectionHeaders[1].sh_address,
codeSection,
sectionHeaders[1].sh_size);
free(codeSection);
/* arbitrary separator here */
codeSection = malloc(sectionHeaders[2].sh_size);
fseek(fp, sectionHeaders[2].sh_offset, SEEK_SET); // TODO: Error checking
fread(codeSection, sizeof(unsigned char), sectionHeaders[2].sh_size, fp);
disassemble_x86(&shstrtab[sectionHeaders[2].sh_name],
sectionHeaders[2].sh_address,
codeSection,
sectionHeaders[2].sh_size);
free(codeSection);
/* arbitrary separator here */
printSectionHeader32(sectionHeaders[3], shstrtab);
codeSection = malloc(sectionHeaders[3].sh_size);
fseek(fp, sectionHeaders[3].sh_offset, SEEK_SET); // TODO: Error checking
fread(codeSection, sizeof(unsigned char), sectionHeaders[3].sh_size, fp);
disassemble_x86(&shstrtab[sectionHeaders[3].sh_name],
sectionHeaders[3].sh_address,
codeSection,
sectionHeaders[3].sh_size);
free(codeSection);
// cleanup
free(programHeaders);
free(sectionHeaders);
free(shstrtab);
}
static int adjust_output(image_segment *image, scan_parameters *scanp,
scanner_parameters *scannerp)
/* Needing a good cleanup */
{
/* light and dark points for the CCD sensor in question
* (stored in file as 0-1024, scaled to 0-65536) */
unsigned long hi, lo;
/* The result of our calculations */
unsigned long result;
unsigned long temp;
/* The CCD sensor which read the current pixel - this is a tricky value
to get right. */
int ccd, scaled_xoff;
/* Loop variables */
unsigned int scanline, pixelnum, colour;
unsigned long int pixel_address;
unsigned int cols = scanp->mode ? 3 : 1;
for (scanline = 0; scanline < image->height; scanline++)
{
for (pixelnum = 0; pixelnum < image->width; pixelnum++)
{
/* Figure out CCD sensor number */
/* MAGIC FORMULA ALERT! */
ccd = (pixelnum << (scannerp->natural_xresolution -
scanp->xresolution)) + (1 <<
(scannerp->natural_xresolution
- scanp->xresolution)) - 1;
scaled_xoff = scanp->xoffset <<
(scannerp->natural_xresolution -
scanp->xresolution);
ccd += scaled_xoff;
for (colour = 0; colour < cols; colour++)
{
/* Address of pixel under scrutiny */
pixel_address =
(scanline * image->width * cols * 2) +
(pixelnum * cols * 2) + (colour * 2);
/* Dark value is easy
* Range of lo is 0-18k */
lo = (scannerp->blackweight[ccd]) * 3;
/* Light value depends on the colour,
* and is an average in greyscale mode. */
if (scanp->mode == 1) /* RGB */
{
switch (colour)
{
case 0: hi = scannerp->redweight[ccd] * 3;
break;
case 1: hi = scannerp->greenweight[ccd] * 3;
break;
default: hi = scannerp->blueweight[ccd] * 3;
break;
}
}
else /* Grey - scanned using green */
{
hi = scannerp->greenweight[ccd] * 3;
}
/* Check for bad calibration data as it
can cause a divide-by-0 error */
if (hi <= lo)
{
DBG(1, "adjust_output: Bad cal data!"
" hi: %ld lo: %ld\n"
"Recalibrate, that "
"should fix it.\n",
hi, lo);
return -1;
}
/* Start with the pixel value in result */
result = MAKE_SHORT(*(image->image_data +
pixel_address),
*(image->image_data +
pixel_address + 1));
result = result >> 6; /* Range now = 0-1023 */
/*
if (scanline == 10)
DBG(200, "adjust_output: Initial pixel"
" value: %ld\n",
result);
*/
result *= 54; /* Range now = 0-54k */
/* Clip to dark and light values */
if (result < lo) result = lo;
if (result > hi) result = hi;
/* result = (base-lo) * max_value / (hi-lo) */
temp = result - lo;
temp *= 65536;
temp /= (hi - lo);
/* Clip output result has been clipped to lo,
* and hi >= lo, so temp can't be < 0 */
if (temp > 65535)
temp = 65535;
/*
if (scanline == 10)
{
DBG(200, "adjust_output: %d: base = "
"%lu, result %lu (%lu "
"- %lu)\n", pixelnum,
result, temp, lo, hi);
}
*/
result = temp;
/* Store the value back where it came
* from (always bigendian) */
*(image->image_data + pixel_address)
= HIGH_BYTE(result);
*(image->image_data + pixel_address+1)
= LOW_BYTE(result);
}
}
}
/*DBG(100, "Finished adjusting output\n");*/
return 0;
}
