{

typedef Elf32_Ehdr Ehdr;

typedef Elf32_Shdr Shdr;

typedef Elf32_Phdr Phdr;

inline static uint32_t round(uint32_t x)

{

return (x + 3) & ~3;

}

{

typedef Elf64_Ehdr Ehdr;

typedef Elf64_Shdr Shdr;

typedef Elf64_Phdr Phdr;

inline static uint32_t round(uint32_t x)

{

return (x + 7) & ~7;

}

{

// Read the header

if (!MCDeployFileRead(p_file, &r_header, sizeof(typename T::Ehdr)))

return MCDeployThrow(kMCDeployErrorLinuxNoHeader);

// Validate the ident field to make sure the exe is what we expect.

if (r_header . e_ident[EI_MAG0] != ELFMAG0 ||

r_header . e_ident[EI_MAG1] != ELFMAG1 ||

r_header . e_ident[EI_MAG2] != ELFMAG2 ||

r_header . e_ident[EI_MAG3] != ELFMAG3)

return MCDeployThrow(kMCDeployErrorLinuxBadHeaderMagic);

// MW-2013-05-03: [[ Linux64 ]] Class could be 32 or 64-bit.

if ((r_header . e_ident[EI_CLASS] != ELFCLASS32 && r_header . e_ident[EI_CLASS] != ELFCLASS64) ||

r_header . e_ident[EI_DATA] != ELFDATA2LSB ||

r_header . e_ident[EI_VERSION] != EV_CURRENT)

return MCDeployThrow(kMCDeployErrorLinuxBadHeaderType);

// Swap the fields as appropriate

swap_ElfX_Ehdr(r_header);

// Now check the header fields that aren't part of the ident

if (!p_is_android)

{

// MW-2013-04-29: [[ Linux64 ]] Allow any type of machine architecture.

// (in particular, ARM and x64 in addition to x386).

if (r_header . e_type != ET_EXEC ||

r_header . e_version != EV_CURRENT)

return MCDeployThrow(kMCDeployErrorLinuxBadImage);

}

else

{

if (r_header . e_type != ET_DYN ||

r_header . e_machine != EM_ARM ||

r_header . e_version != EV_CURRENT)

return MCDeployThrow(kMCDeployErrorLinuxBadImage);

}

return true;

{

// First check that we can read the section headers - they must be the size

// we think they should be.

if (p_header . e_shentsize != sizeof(typename T::Shdr))

return MCDeployThrow(kMCDeployErrorLinuxBadSectionSize);

// Allocate the array of the entries

r_table = new typename T::Shdr[p_header . e_shnum];

if (r_table == NULL)

return MCDeployThrow(kMCDeployErrorNoMemory);

// Next read each entry in from the file

for(uint32_t i = 0; i < p_header . e_shnum; i++)

{

if (!MCDeployFileReadAt(p_file, &r_table[i], sizeof(typename T::Shdr), p_header . e_shoff + i * p_header . e_shentsize))

return MCDeployThrow(kMCDeployErrorLinuxBadSectionTable);

swap_ElfX_Shdr(r_table[i]);

}

return true;

{

// First check that we can read the program headers - they must be the size

// we think they should be.

if (p_header . e_phentsize != sizeof(typename T::Phdr))

return MCDeployThrow(kMCDeployErrorLinuxBadSegmentSize);

// Allocate the array of the entries

r_table = new typename T::Phdr[p_header . e_phnum];

if (r_table == NULL)

return MCDeployThrow(kMCDeployErrorNoMemory);

// Next read each entry in from the file

for(uint32_t i = 0; i < p_header . e_phnum; i++)

{

if (!MCDeployFileReadAt(p_file, &r_table[i], sizeof(typename T::Phdr), p_header . e_phoff + i * p_header . e_phentsize))

return MCDeployThrow(kMCDeployErrorLinuxBadProgramTable);

swap_ElfX_Phdr(r_table[i]);

}

return true;

{

bool t_success;

t_success = true;

// First check that the index is valid

if (p_index >= p_string_header . sh_size)

return MCDeployThrow(kMCDeployErrorLinuxBadStringIndex);

// As the string table does not contain any string lengths and they are

// just NUL terminated, we must gradually load portions until a NUL is

// reached.

char *t_buffer;

uint32_t t_length;

t_buffer = NULL;

t_length = 0;

while(t_success)

{

// Compute how much data to read - this is either the fixed chunk

// size of 32, or the rest of the data in the section; whichever is

// smaller.

uint32_t t_request;

t_request = MCU_min(32U, p_string_header . sh_size - (p_index + t_length));

// If we are about to request 0 bytes, then this is a malformed

// string.

if (t_request == 0)

t_success = MCDeployThrow(kMCDeployErrorLinuxBadString);

// Try to read the chunk of data

char t_piece[32];

if (t_success)

t_success = MCDeployFileReadAt(p_file, t_piece, t_request, p_string_header . sh_offset + p_index + t_length);

// Adjust the size of request, by whether there is NUL in the piece

uint32_t t_piece_size;

t_piece_size = 0;

if (t_success)

{

if (memchr(t_piece, '\0', t_request) == NULL)

t_piece_size = t_request;

else

t_piece_size = strlen(t_piece);

// If the resulting length is less than request, it means it

// contains a NUL, thus increase length by one to include it.

if (t_piece_size < t_request)

t_piece_size += 1;

}

// Resize the output buffer and copy in the new data

if (t_success)

{

char *t_new_buffer;

t_new_buffer = (char *)realloc(t_buffer, t_length + t_piece_size);

if (t_new_buffer != NULL)

{

t_buffer = t_new_buffer;

memcpy(t_buffer + t_length, t_piece, t_piece_size);

t_length += t_piece_size;

}

else

t_success = MCDeployThrow(kMCDeployErrorNoMemory);

}

// Next check to see if we are done, by looking at the last

// (new) byte in the buffer.

if (t_success && t_buffer[t_length - 1] == '\0')

break;

}

if (t_success)

r_string = t_buffer;

else

free(t_buffer);

return t_success;

{

bool t_success;

t_success = true;

// First thing we do is open the files.

MCDeployFileRef t_engine, t_output;

t_engine = t_output = NULL;

if (t_success && !MCDeployFileOpen(p_params . engine, kMCOpenFileModeRead, t_engine))

t_success = MCDeployThrow(kMCDeployErrorNoEngine);

if (t_success && !MCDeployFileOpen(p_params . output, kMCOpenFileModeCreate, t_output))

t_success = MCDeployThrow(kMCDeployErrorNoOutput);

// Now read in the main ELF header

typename T::Ehdr t_header;

if (t_success)

t_success = MCDeployToLinuxReadHeader<T>(t_engine, p_is_android, t_header);

// Next read in the section header table

typename T::Shdr *t_section_headers;

t_section_headers = NULL;

if (t_success)

t_success = MCDeployToLinuxReadSectionHeaders<T>(t_engine, t_header, t_section_headers);

// Next read in the program header table

typename T::Phdr *t_program_headers;

t_program_headers = NULL;

if (t_success)

t_success = MCDeployToLinuxReadProgramHeaders<T>(t_engine, t_header, t_program_headers);

// Now we have the section header, we search for the 'project' and

// 'payload' sections.

typename T::Shdr *t_project_section, *t_payload_section;

t_project_section = NULL;

t_payload_section = NULL;

for(uint32_t i = 0; t_success && i < t_header . e_shnum && t_project_section == NULL; i++)

{

char *t_section_name;

t_success = MCDeployToLinuxReadString<T>(t_engine, t_section_headers[t_header . e_shstrndx], t_section_headers[i] . sh_name, t_section_name);

// Notice that we compare 9 bytes, this is to ensure we match .project

// only and not .project<otherchar> (i.e. we match the NUL char).

if (t_success && memcmp(t_section_name, ".project", 9) == 0)

t_project_section = &t_section_headers[i];

if (t_success && memcmp(t_section_name, ".payload", 9) == 0)

t_payload_section = &t_section_headers[i];

delete t_section_name;

}

if (t_success && t_project_section == NULL)

t_success = MCDeployThrow(kMCDeployErrorLinuxNoProjectSection);

if (t_success && (!MCStringIsEmpty(p_params . payload)) && t_payload_section == NULL)

t_success = MCDeployThrow(kMCDeployErrorLinuxNoPayloadSection);

// Next check that there are no sections after the project section.

// (This check implies there are no segments after the project section

// since the section table is ordered by vaddr and segments can only

// contain stuff in sections).

if (t_success)

for(typename T::Shdr *t_section = t_project_section + 1; t_section < t_section_headers + t_header . e_shnum; t_section += 1)

if (t_section -> sh_addr > t_project_section -> sh_addr)

{

t_success = MCDeployThrow(kMCDeployErrorLinuxBadSectionOrder);

break;

}

// Now we must search for the segment containing the payload/project sections.

// At present, we required that these sections sit in their own segment and

// that segment must be the last.

typename T::Phdr *t_project_segment;

t_project_segment = NULL;

for(uint32_t i = 0; t_success && i < t_header . e_phnum; i++)

if (t_project_section -> sh_addr >= t_program_headers[i] . p_vaddr &&

t_project_section -> sh_addr + t_project_section -> sh_size <= t_program_headers[i] . p_vaddr + t_program_headers[i] . p_memsz)

{

t_project_segment = &t_program_headers[i];

break;

}

if (t_success && t_project_segment == NULL)

t_success = MCDeployThrow(kMCDeployErrorLinuxNoProjectSegment);

// Make sure the payload section is in the project segment.

if (t_success && t_payload_section != NULL &&

(t_payload_section -> sh_addr > t_project_segment -> p_vaddr + t_project_segment -> p_memsz ||

t_payload_section -> sh_addr + t_payload_section -> sh_size < t_project_segment -> p_vaddr))

t_success = MCDeployThrow(kMCDeployErrorLinuxPayloadNotInProjectSegment);

// Next we write out everything before we get to project (or payload)

// section and then write out our sections themselves. After this we have

// enough info to rewrite the headers.

uint32_t t_output_offset;

t_output_offset = 0;

if (t_success)

{

if (t_payload_section != NULL)

t_output_offset = t_payload_section -> sh_offset;

else

t_output_offset = t_project_section -> sh_offset;

}

// Write out the original data up to the beginning of the project section or

// payload sections.

if (t_success)

t_success = MCDeployFileCopy(t_output, 0, t_engine, 0, t_output_offset);

// Write out the payload section (if any)

uint32_t t_payload_size;

t_payload_size = 0;

if (t_success && t_payload_section != NULL)

{

t_success = MCDeployWritePayload(p_params, false, t_output, t_output_offset, t_payload_size);

if (t_success)

{

t_payload_size = T::round(t_payload_size);

t_output_offset += t_payload_size;

}

}

// Write out the project info struct

uint32_t t_project_size, t_project_offset;

t_project_size = 0;

t_project_offset = 0;

if (t_success)

{

t_project_offset = t_output_offset;

t_success = MCDeployWriteProject(p_params, false, t_output, t_output_offset, t_project_size);

if (t_success)

{

t_project_size = T::round(t_project_size);

t_output_offset += t_project_size;

}

}

// Next use the project size to compute the updated header values we need.

uint32_t t_section_table_size, t_segment_table_size;

uint32_t t_section_table_offset, t_segment_table_offset;

uint32_t t_end_offset, t_end_size;

if (t_success)

{

// Compute the shift that will have occured to any post-project sections

int32_t t_project_delta, t_payload_delta;

t_project_delta = t_project_size - t_project_section -> sh_size;

if (t_payload_section != NULL)

t_payload_delta = t_payload_size - t_payload_section -> sh_size;

else

t_payload_delta = 0;

// If the project section is not the last one, then work out the

// subsequent section data size/offset.

if (t_project_section - t_section_headers + 1 < t_header . e_shnum)

{

t_end_offset = (t_project_section + 1) -> sh_offset;

t_end_size = (t_section_headers[t_header . e_shnum - 1] . sh_offset + t_section_headers[t_header . e_shnum - 1] . sh_size) - t_end_offset;

}

else

t_end_offset = t_end_size = 0;

//

if (t_payload_section != nil)

t_payload_section -> sh_size = t_payload_size;

t_project_section -> sh_offset = t_project_offset;

t_project_section -> sh_addr += t_payload_delta;

t_project_section -> sh_size = t_project_size;

t_project_segment -> p_filesz = t_payload_size + t_project_size;

t_project_segment -> p_memsz = t_payload_size + t_project_size;

for(typename T::Shdr *t_section = t_project_section + 1; t_section < t_section_headers + t_header . e_shnum; t_section += 1)

if (t_section -> sh_offset >= t_end_offset)

t_section -> sh_offset += t_project_delta + t_payload_delta;

t_header . e_shoff += t_project_delta + t_payload_delta;

//

t_section_table_size = t_header . e_shnum * sizeof(typename T::Shdr);

t_section_table_offset = t_header . e_shoff;

t_segment_table_size = t_header . e_phnum * sizeof(typename T::Phdr);

t_segment_table_offset = t_header . e_phoff;

//

for(uint32_t i = 0; i < t_header . e_shnum; i++)

swap_ElfX_Shdr(t_section_headers[i]);

for(uint32_t i = 0; i < t_header . e_phnum; i++)

swap_ElfX_Phdr(t_program_headers[i]);

swap_ElfX_Ehdr(t_header);

}

// Overwrite the updated header and program headers

if (t_success)

t_success = MCDeployFileWriteAt(t_output, &t_header, sizeof(typename T::Ehdr), 0);

if (t_success)

t_success = MCDeployFileWriteAt(t_output, t_program_headers, t_segment_table_size, t_segment_table_offset);

// Write out the remaining original data

if (t_success)

t_success = MCDeployFileCopy(t_output, t_output_offset, t_engine, t_end_offset, t_end_size);

// Finally write out the new section table

if (t_success)

t_success = MCDeployFileWriteAt(t_output, t_section_headers, t_section_table_size, t_section_table_offset);

delete[] t_program_headers;

delete[] t_section_headers;

MCDeployFileClose(t_engine);

MCDeployFileClose(t_output);

// OK-2010-02-22: [[Bug 8624]] - Standalones not being made executable if they contain accented chars in path.

MCStringRef t_path;

t_path = p_params.output;

// If on Mac OS X or Linux, make the file executable

#if defined(_MACOSX) || defined(_LINUX)

if (t_success)

{

MCAutoStringRefAsUTF8String t_utf8_path;

/* UNCHECKED */ t_utf8_path . Lock(t_path);

chmod(*t_utf8_path, 0755);

}

#endif

return t_success ? ES_NORMAL : ES_ERROR;

{

bool t_success;

t_success = true;

// MW-2013-05-03: [[ Linux64 ]] Snoop the engine type from the ident field.

MCDeployFileRef t_engine;

t_engine = NULL;

if (t_success && !MCDeployFileOpen(p_params . engine, kMCOpenFileModeRead, t_engine))

t_success = MCDeployThrow(kMCDeployErrorNoEngine);

char t_ident[EI_NIDENT];

if (t_success && !MCDeployFileRead(t_engine, t_ident, EI_NIDENT))

t_success = MCDeployThrow(kMCDeployErrorLinuxNoHeader);

if (t_success)

{

if (t_ident[EI_CLASS] == ELFCLASS32)

return MCDeployToELF<MCLinuxELF32Traits>(p_params, false);

else if (t_ident[EI_CLASS] == ELFCLASS64)

return MCDeployToELF<MCLinuxELF64Traits>(p_params, false);

t_success = MCDeployThrow(kMCDeployErrorLinuxBadHeaderType);

}

return t_success ? ES_NORMAL : ES_ERROR;