3rdparty/libfort

@@ -1 +1 @@
-Subproject commit 5a8f9312bdbe05be484d2c07dd8c94a39e0ae196
+Subproject commit 41237162a9bd34a30a88069ee4e230584ae8d674

AUR/PKGBUILD

@@ -1,14 +1,14 @@
 # Maintainer: Mario Hüttel <mario (dot) huettel (!) gmx (dot) net>
 
 pkgname=patchelfcrc
-pkgver=v1.0.0_rc1
+pkgver=5e7f697
 pkgrel=1
 pkgdesc="Tool for patching CRC checksums of sections into ELF binaries"
 arch=('i686' 'x86_64')
 url="https://git.shimatta.de/mhu/patchelfcrc"
 licence=('GPLv2')
 depends=('libelf' 'libxml2')
-makedepends=('cmake' 'pandoc' 'git' 'gvim' 'bash')
+makedepends=('cmake' 'pandoc' 'git' 'gvim')
 provides=('patchelfcrc')
 source=("${pkgname}-git"::"git+https://git.shimatta.de/mhu/patchelfcrc" "git+https://git.shimatta.de/3rd-party/libfort.git" "git+https://git.shimatta.de/mhu/linklist-lib")
 sha1sums=('SKIP' 'SKIP' 'SKIP')

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.5...3.18)
+cmake_minimum_required(VERSION 3.5)
 
 project(patchelfcrc LANGUAGES C)
 

include/patchelfcrc/reporting.h

@@ -21,25 +21,14 @@
 
 #include <stdbool.h>
 
-/**
+#define print_err(fmt, ...) fprintf(stderr, "[ERR] " fmt, ## __VA_ARGS__)
- * @brief Setting for reporting to console.
- */
-enum reporting_color_mode {
-    COLOR_MODE_DETECT, /**< @brief Automatically detect if tty. If tty, color is used */
-    COLOR_MODE_COLOR, /**< @brief Force color mode on stderr */
-    COLOR_MODE_COLOR_OFF, /**< @brief Force no color on stderr */
-};
 
-void print_err(const char *fmt, ...);
+#define print_warn(fmt, ...) fprintf(stderr, "[WARN] " fmt, ## __VA_ARGS__)
-
-void print_warn(const char *fmt, ...);
 
 void print_debug(const char *fmt, ...);
 
-void reporting_enable_verbose(bool state);
+void reporting_enable_verbose(void);
 
 bool reporting_get_verbosity(void);
 
-void reporting_init(enum reporting_color_mode mode);
-
 #endif /* _REPORTING_H_ */

linklist-lib

@@ -1 +1 @@
-Subproject commit fdd99bad488bfd60cff152c0ec17bc927ed2e232
+Subproject commit c20b5c2528a46fe6a4aa74631ae3b628f73ac24f

man/CMakeLists.txt

@@ -10,10 +10,10 @@ add_custom_command(
 	OUTPUT
 		${CMAKE_CURRENT_BINARY_DIR}/${MAN_PAGE_NAME}
 	COMMAND
-		bash -c "cat \"${CMAKE_CURRENT_SOURCE_DIR}/patchelfcrc.1.md\" | sed \"s/!version!/`git describe --tags --always --dirty`/\" | pandoc  -s -t man | gzip > \"${CMAKE_CURRENT_BINARY_DIR}/${MAN_PAGE_NAME}\""
+		bash -c "pandoc \"${CMAKE_CURRENT_SOURCE_DIR}/patchelfcrc.1.md\" -s -t man | gzip > \"${CMAKE_CURRENT_BINARY_DIR}/${MAN_PAGE_NAME}\""
 	VERBATIM
 	WORKING_DIRECTORY
-		${CMAKE_CURRENT_SOURCE_DIR}
+		${CMAKE_CURRENT_BINARY_DIR}
 	MAIN_DEPENDENCY
 		${CMAKE_CURRENT_SOURCE_DIR}/patchelfcrc.1.md
 )

man/patchelfcrc.1.md

@@ -1,4 +1,4 @@
-% patchelfcrc(1) !version!
+% patchelfcrc(1) 0.0.2
 % Mario Huettel
 % October 2022
 
@@ -61,7 +61,7 @@
 : Export the calculated files to an XML file *XMLFILE*.
 
 **--import**=*XMLFILE*
-: Import the CRCs from an XML file *XMLFILE* and do not calculate anything in the given *ELF*
+: Import the CRCs from an XML file *XMLFILE* and do not caclulate anything in the given *ELF*
 
 **--help**, **-h**, **-?**
 : Print help.
@@ -84,9 +84,6 @@
 **--usage**
 : Print usage hints on command line options.
 
-**--no-color**
-: Force output on stdout and stderr to be pure text without color codes.
-
 # EXAMPLES
 
 **patchelfcrc** --list-crcs
@@ -134,9 +131,9 @@
 
 **patchelfcrc** -l -g word --start-magic=0x12345678 --end-magic=0x8754321 -p crc-32-mpeg -f bare -O .outputsection -S .text executable.elf
 : Calculate the CRC over *.text* section and place the result in the *.outputsection* section.
-The output sections start and end are checked for the given magic numbers in order to ensure correct memory layout.
+The output sections start and end are checked for the given magic numbers in order to assure correct memory layout.
-*CRC-32-MPEG* is used as CRC algorithm.
+*CRC-32-MPEG* is used as CRC algorothm.
 The memory is interpreted as *little endian* and the CRC calculation granularity is a 32 bit *word*.
 
 # BUGS
-None
+Currently, reversed CRC algorithms are not implemented.

src/crc.c

@@ -34,26 +34,13 @@ int crc_len_from_poly(uint64_t polynomial)
 	return pos;
 }
 
-static uint32_t reverse_short_poly(uint32_t poly, uint8_t len)
-{
-	uint8_t i;
-	uint32_t ret = 0ul;
-
-	for (i = 0; i < len; i++) {
-		ret <<= 1;
-		ret |= (poly & 1u);
-		poly >>= 1;
-	}
-
-	return ret;
-}
-
 static uint64_t shorten_polynomial(uint64_t poly)
 {
 	int i;
-	for (i = 32; i >= 0; i--) {
+
-		if (poly & ((uint64_t)1ull << i)) {
+	for (i = 31; i <= 0; i--) {
-			poly &= ~((uint64_t)1ull<<i);
+		if (poly & (1 << i)) {
+			poly &= ~(1<<i);
 			break;
 		}
 	}
@@ -68,22 +55,14 @@ static void internal_push_byte(struct crc_calc *crc, const uint8_t *data, size_t
 
 	crc_val = crc->crc_val;
 
-	if (crc->settings.rev) {
 	for (i = 0; i < len; i++, data++) {
-			crc_val = (crc_val >> 8) ^ crc->table[((crc_val & 0xFF) ^ *data)];
+		crc_val = ((crc_val << 8) & crc->crc_mask) ^ crc->table[((crc_val >> (crc->crc_length-8u)) & 0xff) ^ *data];
-		}
-	} else {
-		/* Non reversed algo */
-		for (i = 0; i < len; i++, data++) {
-			crc_val = ((crc_val << 8) & crc->crc_mask) ^
-				crc->table[((crc_val >> (crc->crc_length-8u)) & 0xff) ^ *data];
-		}
 	}
 
 	crc->crc_val = crc_val;
 }
 
-static void fill_crc_table_non_reversed(struct crc_calc *crc)
+static void fill_crc_table(struct crc_calc *crc)
 {
 	uint32_t input;
 	uint32_t crc_reg;
@@ -107,44 +86,10 @@ static void fill_crc_table_non_reversed(struct crc_calc *crc)
 				crc_reg <<= 1;
 			}
 		}
-		crc->table[input] = crc_reg & crc->crc_mask;
+		crc->table[input] = crc_reg;
 	}
 }
 
-static void fill_crc_table_reversed(struct crc_calc *crc)
-{
-	uint32_t input;
-	uint32_t crc_reg;
-	uint32_t short_poly;
-	int i;
-
-	short_poly = (uint32_t)shorten_polynomial(crc->settings.polynomial);
-	short_poly = reverse_short_poly(short_poly, crc->crc_length);
-
-	for (input = 0; input <= 255u; input++) {
-		crc_reg = (uint32_t)input;
-		for (i = 0; i < 8; i++) {
-			/* Check LSB for reversed CRC shifting */
-			if (crc_reg & 1u) {
-				crc_reg >>= 1;
-				crc_reg ^= short_poly;
-			} else {
-				crc_reg >>= 1;
-			}
-		}
-		crc->table[input] = crc_reg & crc->crc_mask;
-	}
-
-}
-
-static void fill_crc_table(struct crc_calc *crc)
-{
-	if (crc->settings.rev)
-		fill_crc_table_reversed(crc);
-	else
-		fill_crc_table_non_reversed(crc);
-}
-
 void crc_init(struct crc_calc *crc, const struct crc_settings *settings)
 {
 	uint32_t i;

src/elfpatch.c

@@ -30,19 +30,6 @@
 #include <fort.h>
 #include <inttypes.h>
 #include <patchelfcrc/crc-output-struct.h>
-#include <byteswap.h>
-
-static const union  {
-	uint8_t data[4];
-	uint32_t val;
-} _endianess_check_union = {{1u, 2u, 3u, 4u}};
-
-enum endianess {
-	END_LITTLE = 0x04030201ul,
-	END_BIG = 0x01020304ul,
-};
-
-#define HOST_ENDIANESS (_endianess_check_union.val)
 
 struct elf_section {
 	GElf_Shdr section_header;
@@ -71,13 +58,13 @@ struct elfpatch {
 	if (!is_elfpatch_struct((ep))) { \
 	return; \
 	} \
-	} while (0)
+	} while(0)
 
 #define ret_val_if_ep_err(ep, val) do { \
 	if (!is_elfpatch_struct((ep))) { \
-			return val; \
+	return (val); \
 	} \
-	} while (0)
+	} while(0)
 
 /**
  * @brief Convert a series of 4 bytes into a uint32_t dpending on endianess
@@ -90,15 +77,14 @@ static uint32_t get_uint32_from_byte_string(const uint8_t *data, bool little_end
 	uint32_t out = 0ul;
 	int i;
 
-	/* Always shift in in big endian format */
 	for (i = 0; i < 4; i++) {
-			out <<= 8u;
-		out |= (uint32_t)data[i];
-	}
-
-	/* Swap bytes if little endian */
 		if (little_endian)
-		out = bswap_32(out);
+			out >>= 8u;
+		else
+			out <<= 8u;
+
+		out |= (((uint32_t)data[i]) << (little_endian ? 24u : 0u));
+	}
 
 	return out;
 }
@@ -110,12 +96,14 @@ static void write_crc_to_byte_array(uint8_t *byte_array, uint32_t crc, uint8_t c
 	if (!byte_array)
 		return;
 
-	if (!little_endian)
-		crc = bswap_32(crc);
-
 	for (i = 0; i < crc_size_bytes; i++) {
+		if (little_endian) {
 			byte_array[i] = (uint8_t)(crc & 0xFFul);
 			crc >>= 8u;
+		} else {
+			byte_array[i] = (uint8_t)((crc & 0xFF000000ul) >> 24u);
+			crc <<= 8u;
+		}
 	}
 }
 
@@ -148,14 +136,6 @@ static const char *section_type_to_str(Elf64_Word type)
 		return "INIT_ARRAY";
 	case SHT_FINI_ARRAY:
 		return "FINI_ARRAY";
-	case SHT_PREINIT_ARRAY:
-		return "PREINIT_ARRAY";
-	case SHT_DYNAMIC:
-		return "DYNAMIC";
-	case SHT_ARM_ATTRIBUTES:
-		return "ARM_ATTRIBUTES";
-	case SHT_ARM_PREEMPTMAP:
-		return "ARM_PREEMPTMAP";
 	default:
 		break;
 	}
@@ -167,7 +147,6 @@ static void print_sections(elfpatch_handle_t *ep)
 	SlList *iter;
 	ft_table_t *table;
 	const struct elf_section *section;
-	bool alloc, write, exec;
 
 	ret_if_ep_err(ep);
 
@@ -183,23 +162,15 @@ static void print_sections(elfpatch_handle_t *ep)
 
 	/* Write header */
 	ft_set_cell_prop(table, 0, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE, FT_ROW_HEADER);
-	ft_write_ln(table, "Section", "Type", "ALLOC", "WRITE", "EXEC", "Size", "VMA", "LMA", "File Offset");
+	ft_write_ln(table, "Section", "Type", "Size", "VMA", "LMA", "File Offset");
 
 	for (iter = ep->sections; iter; iter = sl_list_next(iter)) {
 		section = (const struct elf_section *)iter->data;
 		if (!section)
 			continue;
-
+		ft_printf_ln(table, "%s|%s|%lu|%p|%p|%p",
-		alloc = !!(section->section_header.sh_flags & SHF_ALLOC);
-		write = !!(section->section_header.sh_flags & SHF_WRITE);
-		exec = !!(section->section_header.sh_flags & SHF_EXECINSTR);
-
-		ft_printf_ln(table, "%s|%s|%s|%s|%s|%lu|%p|%p|%p",
 			     section->name,
 			     section_type_to_str(section->section_header.sh_type),
-			     alloc ? "x" : "",
-			     write ? "x" : "",
-			     exec ? "x" : "",
 			     section->section_header.sh_size,
 			     (void *)section->section_header.sh_addr,
 			     (void *)section->lma,
@@ -226,7 +197,7 @@ static SlList *elf_patch_get_sections(elfpatch_handle_t *ep)
 		sl_list_free_full(ret, (void (*)(void *))free_elf_section_element);
 	ep->sections = NULL;
 
-	if (elf_getshdrstrndx(ep->elf, &shstrndx) != 0) {
+	if (elf_getshdrstrndx (ep->elf , &shstrndx) != 0) {
 		print_err("ELF error: %s\n", elf_errmsg(-1));
 		goto ret_free_section_list;
 	}
@@ -247,10 +218,9 @@ static SlList *elf_patch_get_sections(elfpatch_handle_t *ep)
 		sec->lma = (uint64_t)sec->section_header.sh_addr;
 
 		name = elf_strptr(ep->elf, shstrndx, sec->section_header.sh_name);
-
+		if (name) {
-		if (name)
 			sec->name = strdup(name);
-
+		}
 		ret = sl_list_append(ret, sec);
 	}
 
@@ -290,12 +260,6 @@ static int elf_patch_read_program_headers(elfpatch_handle_t *ep)
 		return -1;
 	}
 
-	if (header_count == 0) {
-		/* No program headers found. This ELF file is probably not linked */
-		ep->program_headers_count = 0;
-		return 0;
-	}
-
 	ep->program_headers = (GElf_Phdr *)malloc(header_count * sizeof(GElf_Phdr));
 	if (!ep->program_headers) {
 		/* Mem error. Abort. Program will crash eventually */
@@ -341,11 +305,9 @@ static void resolve_section_lmas(elfpatch_handle_t *ep)
 		if (!sec)
 			continue;
 
-		/* By default each sections LMA is assumed to be its LMA as well */
-		sec->lma = (uint64_t)sec->section_header.sh_addr;
-
 		if (sec->section_header.sh_type == SHT_NOBITS) {
 			/* Section does not contain data. It may be allocated but is not loaded. Therefore, LMA=VMA. */
+			sec->lma = (uint64_t)sec->section_header.sh_addr;
 			continue;
 		}
 
@@ -469,13 +431,15 @@ elfpatch_handle_t *elf_patch_open(const char *path, bool readonly, bool expect_l
 		switch (ident[5]) {
 		case 1:
 			print_debug("ELF Endianess: little\n");
-			if (!expect_little_endian)
+			if (!expect_little_endian) {
-				print_warn("Big endian format expected. File is little endian. Double check settings!\n");
+				print_err("Big endian format expected. File is little endian. Double check settings!\n");
+			}
 			break;
 		case 2:
 			print_debug("ELF Endianess: big\n");
-			if (expect_little_endian)
+			if (expect_little_endian) {
-				print_warn("Little endian format expected. File is big endian. Double check settings!\n");
+				print_err("Little endian format expected. File is big endian. Double check settings!\n");
+			}
 			break;
 		default:
 			print_err("Cannot determine endianess of ELF file. EI_DATA is: %d\n", ident[5]);
@@ -490,8 +454,9 @@ close_elf:
 		ep->elf = NULL;
 	}
 close_fd:
-	if (ep->fd > 0)
+	if (ep->fd > 0) {
 		close(ep->fd);
+	}
 free_struct:
 	free(ep);
 	ep = NULL;
@@ -526,14 +491,14 @@ int elf_patch_check_for_section(elfpatch_handle_t *ep, const char *section)
 	return ret;
 }
 
-static size_t translate_index(size_t index, enum granularity granularity, bool little_endian, bool reversed)
+static size_t translate_index(size_t index, enum granularity granularity, bool little_endian)
 {
 	size_t word_idx;
 	size_t part_idx;
 	size_t d_index;
 	size_t gran_in_bytes;
 
-	if ((!little_endian && !reversed) || (little_endian && reversed) || granularity == GRANULARITY_BYTE)
+	if (!little_endian || granularity == GRANULARITY_BYTE)
 		return index;
 
 	gran_in_bytes = (size_t)granularity / 8u;
@@ -561,30 +526,30 @@ int elf_patch_compute_crc_over_section(elfpatch_handle_t *ep, const char *sectio
 	/* Find section */
 	sec = find_section_in_list(ep->sections, section);
 	if (!sec) {
-		print_err("Cannot find section '%s'\n", section);
+		print_err("Cannot find section %s\n", section);
 		return -1;
 	}
 
 	data = elf_getdata(sec->scn, NULL);
 	if (!data) {
-		print_err("Error reading section data from '%s': %s\n", section, elf_errmsg(-1));
+		print_err("Error reading section data from %s: %s\n", section, elf_errmsg(-1));
 		return -1;
 	}
 
+	print_debug("Section data length: %lu\n", data->d_size);
 	if (!data->d_size) {
-		print_err("Section '%s' contains no data.\n", section);
+		print_err("Section %s contains no data.\n", section);
 		return -2;
 	}
 
 	/* NOBIT sections have a length but no data in the file. Abort in this case */
 	if (!data->d_buf) {
-		print_err("Section '%s' does not contain loadable data.\n", section);
+		print_err("Section %s does not contain loadable data.\n", section);
 		return -2;
 	}
 
-	/* If big endian for non reversed / little endian for reversed or granularity is byte, simply compute CRC. No reordering is necessary */
+	/* If big endian or granularity is byte, simply compute CRC. No reordering is necessary */
-	if ((!little_endian && !crc->settings.rev) || (little_endian && crc->settings.rev) ||
+	if (!little_endian || granularity == GRANULARITY_BYTE) {
-			granularity == GRANULARITY_BYTE) {
 		crc_push_bytes(crc, data->d_buf, data->d_size);
 	} else {
 		/* Little endian case with > byte sized chunks */
@@ -592,22 +557,19 @@ int elf_patch_compute_crc_over_section(elfpatch_handle_t *ep, const char *sectio
 		/* Check granularity vs size of section */
 		padding_count = (gran_in_bytes - data->d_size % gran_in_bytes) % gran_in_bytes;
 		if (padding_count) {
-			print_warn("Section '%s' is not a multiple size of the given granularity. %u zero padding bytes will be added.\n",
+			print_err("Section '%s' is not a multiple size of the given granularity. %u zero padding bytes will be added.\n",
 				  section, padding_count);
 		}
 
-		for (idx = 0; idx < data->d_size; idx++)
+		for (idx = 0; idx < data->d_size; idx++) {
-			crc_push_byte(crc,
+			crc_push_byte(crc, ((char *)data->d_buf)[translate_index(idx, granularity, little_endian)]);
-				      ((char *)data->d_buf)[
+		}
-					translate_index(idx, granularity,
-						little_endian,
-						crc->settings.rev)
-					]);
 
 		/* Pad with zeroes */
-		for (idx = 0; idx < padding_count; idx++)
+		for (idx = 0; idx < padding_count; idx++) {
 			crc_push_byte(crc, 0x00);
 		}
+	}
 
 	return 0;
 }
@@ -632,7 +594,7 @@ static size_t calculate_needed_space_for_crcs(enum crc_format format,
 		break;
 	default:
 		needed_space = 0;
-		print_err("Unsupported CRC output format.\n");
+		print_err("Unsupported CRC output format\n");
 	}
 	/* Add existing magic numbers to required space */
 	if (check_start_magic) {
@@ -687,7 +649,6 @@ int elf_patch_write_crcs_to_section(elfpatch_handle_t *ep, const char *output_se
 	struct crc_out_struct_32bit crc_32bit;
 	struct crc_out_struct_64bit crc_64bit;
 	uint64_t in_sec_addr, in_sec_len;
-	bool needs_byteswap;
 
 	ret_val_if_ep_err(ep, -1000);
 
@@ -750,8 +711,8 @@ int elf_patch_write_crcs_to_section(elfpatch_handle_t *ep, const char *output_se
 
 	print_debug("Single CRC requires %u bytes.\n", (unsigned int)crc_size_bytes);
 
-	needed_space = calculate_needed_space_for_crcs(format, crc_data->elf_bits, check_start_magic,
+	needed_space = calculate_needed_space_for_crcs(format, crc_data->elf_bits, check_start_magic, check_end_magic, crc_size_bytes,
-		check_end_magic, crc_size_bytes, crc_count);
+						       crc_count);
 
 	print_debug("Required space for %zu CRCs%s: %zu (available: %zu)\n",
 		    crc_count,
@@ -785,12 +746,6 @@ int elf_patch_write_crcs_to_section(elfpatch_handle_t *ep, const char *output_se
 		if (check_start_magic && crc_data->elf_bits == 64)
 			sec_bytes += 4u;
 
-		needs_byteswap = false;
-		if ((HOST_ENDIANESS != END_LITTLE && little_endian) ||
-				(HOST_ENDIANESS == END_LITTLE && !little_endian)) {
-			needs_byteswap = true;
-		}
-
 		for (iter = crc_data->crc_entries, idx = 0; iter; iter = sl_list_next(iter), idx++) {
 			crc_entry = (struct crc_entry *)iter->data;
 			in_sec_addr = use_vma ? crc_entry->vma : crc_entry->lma;
@@ -801,19 +756,18 @@ int elf_patch_write_crcs_to_section(elfpatch_handle_t *ep, const char *output_se
 			print_debug("Corresponding input section at 0x%"PRIx64", length: %"PRIu64"\n",
 				    in_sec_addr,
 				    in_sec_len);
-
 			if (crc_data->elf_bits == 32) {
-				crc_32bit.crc = needs_byteswap ? bswap_32(crc_entry->crc) : crc_entry->crc;
+				crc_32bit.crc = crc_entry->crc;
-				crc_32bit.length = needs_byteswap ? bswap_32((uint32_t)in_sec_len) : (uint32_t)in_sec_len;
+				crc_32bit.length = (uint32_t)in_sec_len;
-				crc_32bit.start_address = needs_byteswap ? bswap_32((uint32_t)in_sec_addr) : (uint32_t)in_sec_addr;
+				crc_32bit.start_address = (uint32_t)in_sec_addr;
 				memcpy(sec_bytes, &crc_32bit, sizeof(crc_32bit));
 				sec_bytes += sizeof(crc_32bit);
 			} else {
 				/* 64 bit case */
-				crc_64bit.crc = needs_byteswap ? bswap_32(crc_entry->crc) : crc_entry->crc;
+				crc_64bit.crc = crc_entry->crc;
 				crc_64bit._unused_dummy = 0ul;
-				crc_64bit.length = needs_byteswap ? bswap_64(in_sec_len) : in_sec_len;
+				crc_64bit.length = in_sec_len;
-				crc_64bit.start_address = needs_byteswap ? bswap_64(in_sec_addr) : in_sec_addr;
+				crc_64bit.start_address = in_sec_addr;
 				memcpy(sec_bytes, &crc_64bit, sizeof(crc_64bit));
 				sec_bytes += sizeof(crc_64bit);
 			}
@@ -828,11 +782,12 @@ int elf_patch_write_crcs_to_section(elfpatch_handle_t *ep, const char *output_se
 		crc_64bit.length = 0ull;
 		crc_64bit.start_address = 0ull;
 
-		if (crc_data->elf_bits == 32)
+		if (crc_data->elf_bits == 32) {
 			memcpy(sec_bytes, &crc_32bit, sizeof(crc_32bit));
-		else
+		} else {
 			memcpy(sec_bytes, &crc_64bit, sizeof(crc_64bit));
 		}
+	}
 
 	/* Flag section data as invalid to trigger rewrite.
 	 * This is needed due to the forced memory layout
@@ -853,10 +808,11 @@ void elf_patch_close_and_free(elfpatch_handle_t *ep)
 		if (ep->readonly) {
 			print_debug("DRY RUN: File will not be updated\n");
 		} else {
-			if (elf_update(ep->elf, ELF_C_WRITE) < 0)
+			if (elf_update(ep->elf, ELF_C_WRITE) < 0) {
 				print_err("Error writing ELF file: %s\n", elf_errmsg(-1));
 			}
 		}
+	}
 
 	if (ep->elf)
 		elf_end(ep->elf);

src/main.c

@@ -40,10 +40,8 @@ const char *argp_program_bug_address = "<mario [dot] huettel [at] linux [dot] co
 #define ARG_KEY_IMPORT (6)
 #define ARG_KEY_USE_VMA (7)
 #define ARG_KEY_XSD (8)
-#define ARG_KEY_FORCE_NO_COLOR (9)
 
 struct command_line_options {
-	bool force_nocolor;
 	bool little_endian;
 	bool dry_run;
 	bool verbose;
@@ -106,19 +104,16 @@ static error_t parse_opt(int key, char *arg, struct argp_state *state)
 	case ARG_KEY_USE_VMA:
 		args->use_vma = true;
 		break;
-	case ARG_KEY_FORCE_NO_COLOR:
-		args->force_nocolor = true;
-		break;
 	case 'p':
 		/* Polyniomial */
 		args->crc.polynomial = strtoull(arg, &endptr, 0);
 		if (endptr == arg) {
-			looked_up_crc = lookup_named_crc(arg);
+			if ((looked_up_crc = lookup_named_crc(arg))) {
-			if (looked_up_crc)
 				memcpy(&args->crc, &looked_up_crc->settings, sizeof(struct crc_settings));
-			else
+			} else {
 				argp_error(state, "Error parsing polynomial: %s\n", arg);
 			}
+		}
 		break;
 	case 'l':
 		args->little_endian = true;
@@ -200,7 +195,6 @@ static int parse_cmdline_options(int *argc, char ***argv, struct command_line_op
 		{"import", ARG_KEY_IMPORT, "XML", 0, "Do not caclulate CRCs but import them from file", 3},
 		{"xsd", ARG_KEY_XSD, 0, 0, "Print XSD to stdout", 0},
 		{"use-vma", ARG_KEY_USE_VMA, 0, 0, "Use the VMA instead of the LMA for struct output", 2},
-		{"no-color", ARG_KEY_FORCE_NO_COLOR, 0, 0, "Force the output to be text only without colors", 0},
 		/* Sentinel */
 		{NULL, 0, 0, 0, NULL, 0}
 	};
@@ -239,11 +233,12 @@ static void prepare_default_opts(struct command_line_options *opts)
 	opts->output_section = NULL;
 	opts->export_xml = NULL;
 	opts->import_xml = NULL;
-    opts->force_nocolor = false;
 }
 
 static void print_verbose_start_info(const struct command_line_options *cmd_opts)
 {
+	int i;
+	SlList *list_iter;
 	const struct named_crc *predef_crc;
 
 	print_debug("Start CRC patching\n");
@@ -266,17 +261,28 @@ static void print_verbose_start_info(const struct command_line_options *cmd_opts
 		print_debug("CRC length: %d\n", crc_len_from_poly(cmd_opts->crc.polynomial));
 	}
 
-	if (cmd_opts->elf_path)
+	if (cmd_opts->elf_path) {
 		print_debug("ELF file: %s\n", cmd_opts->elf_path);
+	}
 
-	if (cmd_opts->output_section)
+	if (cmd_opts->output_section) {
 		print_debug("Output section: %s\n", cmd_opts->output_section);
+	}
 
-	if (cmd_opts->export_xml)
+	if (cmd_opts->export_xml) {
 		print_debug("Export CRCs to '%s'\n", cmd_opts->export_xml);
+	}
 
-	if (cmd_opts->import_xml)
+	if (cmd_opts->import_xml) {
 		print_debug("Import CRCs from '%s'\n", cmd_opts->import_xml);
+	}
+
+	if (cmd_opts->section_list) {
+		for (list_iter = cmd_opts->section_list, i = 1; list_iter; list_iter = sl_list_next(list_iter), i++) {
+			print_debug("Input section [%d]: \"%s\"\n", i, (const char *)list_iter->data);
+		}
+	}
+
 }
 
 static void free_cmd_args(struct command_line_options *opts)
@@ -316,7 +322,6 @@ static int check_all_sections_present(elfpatch_handle_t *ep, SlList *list)
 		sec_name = (const char *)iter->data;
 		if (!sec_name)
 			continue;
-
 		if (elf_patch_check_for_section(ep, sec_name)) {
 			print_err("Cannot find section '%s'\n", sec_name);
 			ret = -2;
@@ -335,8 +340,7 @@ static int check_all_sections_present(elfpatch_handle_t *ep, SlList *list)
  * @param opts Command line options. Used for CRC generation
  * @return CRC data
  */
-static struct crc_import_data *compute_crcs(elfpatch_handle_t *ep, SlList *list,
+static struct crc_import_data *compute_crcs(elfpatch_handle_t *ep, SlList *list, const struct command_line_options *opts)
-	const struct command_line_options *opts)
 {
 	SlList *iter;
 	const char *sec_name;
@@ -419,18 +423,13 @@ int main(int argc, char **argv)
 
 	prepare_default_opts(&cmd_opts);
 	parse_cmdline_options(&argc, &argv, &cmd_opts);
-
 	if (cmd_opts.print_xsd) {
 		xml_print_xsd();
 		goto free_cmds;
 	}
 
-	/* Initialize console output */
-	reporting_init(cmd_opts.force_nocolor ? COLOR_MODE_COLOR_OFF : COLOR_MODE_DETECT);
-
 	if (cmd_opts.verbose || cmd_opts.dry_run)
-		reporting_enable_verbose(true);
+		reporting_enable_verbose();
-
 	print_verbose_start_info(&cmd_opts);
 
 	if (cmd_opts.list) {
@@ -449,11 +448,19 @@ int main(int argc, char **argv)
 		return -2;
 	}
 
-	if (cmd_opts.use_vma && cmd_opts.format != FORMAT_STRUCT)
+	if (cmd_opts.use_vma && cmd_opts.format != FORMAT_STRUCT) {
 		print_warn("--use-vma option only has an effect when exporting as struct output.\n");
+	}
 
-	if (!cmd_opts.output_section && cmd_opts.export_xml == NULL)
+	if (!cmd_opts.output_section && cmd_opts.export_xml == NULL) {
-		print_warn("No output section or XML export specified. Will continue but not create any output.\n");
+		print_err("No output section / XML export specified. Will continue but not create any output\n");
+	}
+
+	/* Do error printing if using a reversed polynomial. It is not implemented yet! */
+	if (cmd_opts.crc.rev) {
+		print_err("Reversed polynomials are not supported yet\nExiting...\n");
+		goto free_cmds;
+	}
 
 	/* Prepare libelf for use with the latest ELF version */
 	elf_version(EV_CURRENT);
@@ -474,11 +481,13 @@ int main(int argc, char **argv)
 
 		/* Compute CRCs over sections */
 		crc_data = compute_crcs(ep, cmd_opts.section_list, &cmd_opts);
-		if (!crc_data)
+		if (!crc_data) {
 			goto ret_close_elf;
+		}
 
-		if (reporting_get_verbosity())
+		if (reporting_get_verbosity()) {
 			print_crcs(crc_data);
+		}
 	} else {
 		crc_data = xml_import_from_file(cmd_opts.import_xml);
 	}
@@ -495,7 +504,7 @@ int main(int argc, char **argv)
 
 	if (cmd_opts.export_xml) {
 		if (xml_write_crcs_to_file(cmd_opts.export_xml, crc_data)) {
-			print_err("Error during XML generation.\n");
+			print_err("Error during XML generation\n");
 			ret = -3;
 		}
 	}

src/named_crcs.c

@@ -28,7 +28,7 @@
 		.xor = outxor, \
 		.start_value = init, \
 		.rev = reverse \
-} }
+}}
 
 const struct named_crc predefined_crc_table[] = {
 	NAMED_CRC("crc-8", 0x107, false, 0x00, 0x00),
@@ -70,7 +70,7 @@ const struct named_crc predefined_crc_table[] = {
 	NAMED_CRC("jamcrc", 0x104C11DB7, true, 0xFFFFFFFF, 0x00000000),
 	NAMED_CRC("xfer", 0x1000000AF, false, 0x00000000, 0x00000000),
 	/* SENTINEL */
-	{ .name = NULL, .settings = {0, 0, 0, false} },
+	{.name = NULL, .settings = {0, 0, 0, false}},
 };
 
 const struct named_crc *reverse_lookup_named_crc(const struct crc_settings *settings)
@@ -110,26 +110,19 @@ void list_predefined_crcs(void)
 {
 	ft_table_t *table;
 	const struct named_crc *iter;
-	struct crc_calc crc;
 
 	table = ft_create_table();
 
 	ft_set_cell_prop(table, 0, FT_ANY_COLUMN, FT_CPROP_ROW_TYPE, FT_ROW_HEADER);
-	ft_write_ln(table, "Name", "Polynomial", "Reversed", "Start Value", "Output XOR", "Test Value");
+	ft_write_ln(table, "Name", "Polynomial", "Reversed", "Start Value", "Output XOR");
 
 	for (iter = predefined_crc_table; iter->name; iter++) {
-		crc_init(&crc, &iter->settings);
+		ft_printf_ln(table, "%s|0x%lx|%s|0x%x|0x%x",
-		/* Calculate the test value */
-		crc_push_bytes(&crc, (const uint8_t *)"123456789", 9);
-		crc_finish_calc(&crc);
-		ft_printf_ln(table, "%s|0x%lx|%s|0x%x|0x%x|0x%x",
 			     iter->name,
 			     iter->settings.polynomial,
 			     iter->settings.rev ? "yes" : "no",
 			     iter->settings.start_value,
-			     iter->settings.xor,
+			     iter->settings.xor);
-			     crc_get_value(&crc));
-		crc_destroy(&crc);
 	}
 
 	printf("%s\n", ft_to_string(table));

src/reporting.c

@@ -19,66 +19,9 @@
 #include <patchelfcrc/reporting.h>
 #include <stdarg.h>
 #include <stdio.h>
-#include <stdlib.h>
 #include <stdbool.h>
-#include <string.h>
-#include <unistd.h>
 
 static bool global_verbosity_state = false;
-static bool reporting_use_color = false;
-
-#define COLOR_RESET "\e[0m"
-
-#define COLOR_BOLD_RED "\e[31;1m"
-#define COLOR_RED "\e[31m"
-
-#define COLOR_BOLD_YELLOW "\e[33;1m"
-#define COLOR_YELLOW "\e[33m"
-
-
-void print_err(const char *fmt, ...)
-{
-	va_list va;
-	va_start(va, fmt);
-
-	/* Set color */
-	if (reporting_use_color)
-		fprintf(stderr, COLOR_BOLD_RED "[ERR]" COLOR_RESET " " COLOR_RED);
-	else
-		fprintf(stderr, "[ERR] ");
-
-
-	vfprintf(stderr, fmt, va);
-
-	/* Reset color */
-	if (reporting_use_color) {
-		fprintf(stderr, COLOR_RESET);
-	}
-
-	va_end(va);
-}
-
-void print_warn(const char *fmt, ...)
-{
-	va_list va;
-	va_start(va, fmt);
-
-	/* Set color */
-	if (reporting_use_color)
-		fprintf(stderr, COLOR_BOLD_YELLOW "[WARN]" COLOR_RESET " " COLOR_YELLOW);
-	else
-		fprintf(stderr, "[WARN] ");
-
-
-	vfprintf(stderr, fmt, va);
-
-	/* Reset color */
-	if (reporting_use_color) {
-		fprintf(stderr, COLOR_RESET);
-	}
-
-	va_end(va);
-}
 
 void print_debug(const char *fmt, ...)
 {
@@ -91,52 +34,12 @@ void print_debug(const char *fmt, ...)
 	}
 }
 
-void reporting_enable_verbose(bool state)
+void reporting_enable_verbose(void)
 {
-	global_verbosity_state = state;
+	global_verbosity_state = true;
 }
 
 bool reporting_get_verbosity(void)
 {
 	return global_verbosity_state;
 }
-
-/**
- * @brief Check whether stderr supports colors.
- * @note This function checks for a tty and the TERM environment variable. It has to contain "xterm".
- * @return true if colors are supported
- * @return false if no colors should be used
- */
-static bool stderr_supports_colors(void)
-{
-	const char *env_var;
-	const char *tmp;
-
-	if (isatty(2) != 1)
-		return false;
-
-	env_var = getenv("TERM");
-	if (!env_var)
-		return false;
-
-	tmp = strstr(env_var, "xterm");
-	if (!tmp)
-		return false;
-
-	return true;
-}
-
-void reporting_init(enum reporting_color_mode mode)
-{
-	switch (mode) {
-	case COLOR_MODE_COLOR:
-		reporting_use_color = true;
-		break;
-	case COLOR_MODE_COLOR_OFF:
-		reporting_use_color = false;
-		break;
-	default: /* Auto detect case and invalid settings */
-		reporting_use_color = stderr_supports_colors();
-		break;
-	}
-}

src/xml.c

@@ -30,8 +30,9 @@ int xml_write_crcs_to_file(const char *path, const struct crc_import_data *crc_d
 	const struct crc_entry *entry;
 	size_t index;
 
-	if (!path || !crc_data)
+	if (!path || !crc_data) {
 		return -1000;
+	}
 
 	writer = xmlNewTextWriterFilename(path, 0);
 	if (!writer) {
@@ -66,9 +67,7 @@ int xml_write_crcs_to_file(const char *path, const struct crc_import_data *crc_d
 	xmlTextWriterStartElement(writer, BAD_CAST "sections");
 
 	/* Output all section CRCs */
-	for (entry_iter = crc_data->crc_entries, index = 0u;
+	for (entry_iter = crc_data->crc_entries, index = 0u; entry_iter; entry_iter = sl_list_next(entry_iter), index++) {
-	entry_iter;
-	entry_iter = sl_list_next(entry_iter), index++) {
 		entry = (const struct crc_entry *)entry_iter->data;
 		xmlTextWriterStartElement(writer, BAD_CAST "crc");
 		xmlTextWriterWriteFormatAttribute(writer, BAD_CAST "name", "%s", entry->name);
@@ -223,8 +222,7 @@ static int convert_number_string_to_uint(const char *data, uint64_t *output)
  * @return 0 if successful
  * @return negative in case of an error
  */
-static int get_uint64_from_xpath_content(const char *xpath, xmlXPathContextPtr xpath_ctx,
+static int get_uint64_from_xpath_content(const char *xpath, xmlXPathContextPtr xpath_ctx, uint64_t *output, bool required)
-						uint64_t *output, bool required)
 {
 	const char *data;
 	int ret = -1;
@@ -247,8 +245,7 @@ static int get_uint64_from_xpath_content(const char *xpath, xmlXPathContextPtr x
  * @return 0 if successful
  * @return negative in case of an error
  */
-static int get_uint32_from_xpath_content(const char *xpath, xmlXPathContextPtr xpath_ctx,
+static int get_uint32_from_xpath_content(const char *xpath, xmlXPathContextPtr xpath_ctx, uint32_t *output, bool required)
-						uint32_t *output, bool required)
 {
 	const char *data;
 	uint64_t tmp;
@@ -362,10 +359,10 @@ struct crc_import_data *xml_import_from_file(const char *path)
 		print_err("Error reading XML file: %s\n", path);
 		goto ret_none;
 	}
-
 	root_node = xmlDocGetRootElement(doc);
-	if (!root_node)
+	if (!root_node) {
 		goto ret_close_doc;
+	}
 
 	/* Validate the document */
 	if (!validate_xml_doc(doc)) {
@@ -375,8 +372,9 @@ struct crc_import_data *xml_import_from_file(const char *path)
 
 	/* Get xpath context */
 	xpath_ctx = xmlXPathNewContext(doc);
-	if (!xpath_ctx)
+	if (!xpath_ctx) {
 		goto ret_close_doc;
+	}
 
 	/* Get the version number and print error in case of incompatibility. Continue either way */
 	cptr = (char *)xmlGetProp(root_node, BAD_CAST "version");