From b191e945afdb19fe652dcc02f1c78d2b3467907e Mon Sep 17 00:00:00 2001
From: Bastian Dehn <hhaalo@arcor.de>
Date: Sat, 11 Oct 2025 17:12:27 +0200
Subject: [PATCH] fix static analyse style

---
 src/kds_s2000w_client.c                 |  2 +-
 src/kds_s2000w_config.c                 |  4 +--
 src/kds_s2000w_debug.c                  |  2 +-
 src/kds_s2000w_handler.c                | 35 ++++++++++++-------------
 src/kds_s2000w_handler.h                |  4 +--
 src/kds_s2000w_handler_opts.c           | 24 ++++++++---------
 src/kds_s2000w_image_converter_netpbm.c | 19 +++++++-------
 src/kds_s2000w_image_type_check.c       | 14 +++++-----
 src/kds_s2000w_image_type_check.h       |  6 ++---
 src/kds_s2000w_net.c                    |  6 ++---
 tests/kds_s2000w_client_mock.c          |  4 +--
 tests/kds_s2000w_net_tests.c            |  8 +++---
 12 files changed, 62 insertions(+), 66 deletions(-)

diff --git a/src/kds_s2000w_client.c b/src/kds_s2000w_client.c
index 12b3786..6d0b415 100644
--- a/src/kds_s2000w_client.c
+++ b/src/kds_s2000w_client.c
@@ -57,7 +57,7 @@ void _kds_s2000w_client_set_verbose()
 	curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 }
 
-size_t _kds_s2000w_client_write_callback(char* ptr, size_t size, size_t nmemb, void* data)
+size_t _kds_s2000w_client_write_callback(const char* ptr, size_t size, size_t nmemb, void* data)
 {
 	response* resp = (response*) data;
 
diff --git a/src/kds_s2000w_config.c b/src/kds_s2000w_config.c
index f27f726..9042ba3 100644
--- a/src/kds_s2000w_config.c
+++ b/src/kds_s2000w_config.c
@@ -30,7 +30,7 @@ program_config* _kds_s2000w_config_init()
 
 char* _kds_s2000w_config_copy_config_string(cfg_t* cfg, const char* key)
 {
-	char* value_str = cfg_getstr(cfg, key);
+	const char* value_str = cfg_getstr(cfg, key);
 	size_t length = strlen(value_str) + 1;
 	char* new_str = malloc(sizeof(char) * length);
 	if (new_str == NULL)
@@ -74,7 +74,7 @@ program_config* kds_s2000w_config_load(char* config_string)
 	if (config_string == NULL)
 		return config;
 
-	if (strlen(config_string) <= 0)
+	if (strlen(config_string) == 0)
 		return config;
 
 	cfg_opt_t opts[] = {
diff --git a/src/kds_s2000w_debug.c b/src/kds_s2000w_debug.c
index d723902..e4cbad0 100644
--- a/src/kds_s2000w_debug.c
+++ b/src/kds_s2000w_debug.c
@@ -30,7 +30,7 @@ const char* _kds_s2000w_debug_string(uint8_t level)
 }
 
 uint8_t kds_s2000w_debug_get_log_level() {
-	char* log_level = getenv("KDS_S2000W_NET_DEBUG");
+	const char* log_level = getenv("KDS_S2000W_NET_DEBUG");
 
 	if (log_level == NULL)
 		return log_level_default;
diff --git a/src/kds_s2000w_handler.c b/src/kds_s2000w_handler.c
index 429e513..302c700 100644
--- a/src/kds_s2000w_handler.c
+++ b/src/kds_s2000w_handler.c
@@ -13,11 +13,11 @@
 #define DEVICE_NAME "kds_s2000w_net"
 #define ATTEMPT 30
 
-uint32_t _kds_s2000w_handler_find_first_data_byte(imagedata* image)
+uint32_t _kds_s2000w_handler_find_first_data_byte(const imagedata* image)
 {
 	kds_s2000w_debug_printf(ALL, "sane_kds_s2000w_net_find_first_data_byte");
 
-	char* data = (char*) image->data;
+	const char* data = (const char*) image->data;
 	uint8_t header_spaces = 3;
 
 	if (strncmp(data, "P4", 2) == 0)
@@ -62,6 +62,18 @@ void _kds_s2000w_handler_load_config(handler* h)
 	config = NULL;
 }
 
+uint32_t _kds_s2000w_handler_is_color(const handler* h)
+{
+	json_object* config = json_object_object_get(h->current_scanner_config, "Configuration");
+	json_object* color_mode = json_object_object_get(config, "ColorMode");
+	const char* color_value = json_object_get_string(color_mode);
+
+	if (strcmp(color_value, "Color") == 0)
+		return 1;
+
+	return 0;
+}
+
 handler* kds_s2000w_handler_init()
 {
 	kds_s2000w_debug_printf(ALL, "init handler");
@@ -258,14 +270,14 @@ void kds_s2000w_handler_recreate_session(handler* h)
 	resp = NULL;
 }
 
-void kds_s2000w_handler_start_scan(handler* h)
+void kds_s2000w_handler_start_scan(const handler* h)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_handler_start_scan");
 
 	kds_s2000w_client_start_scan(h->sessionid);
 }
 
-void kds_s2000w_handler_stop_scan(handler* h)
+void kds_s2000w_handler_stop_scan(const handler* h)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_handler_stop_scan");
 
@@ -284,19 +296,7 @@ void kds_s2000w_handler_get_current_metadata(handler* h, metadata* params)
 	params->pixels_per_line = 0;
 	params->lines = 0;
 	params->depth = 8;
-
-	json_object* config = json_object_object_get(h->current_scanner_config, "Configuration");
-	json_object* metadata = json_object_object_get(config, "ColorMode");
-	const char* color_value = json_object_get_string(metadata);
-
-	if (strcmp(color_value, "Color") == 0)
-		params->format = 1;
-
-	if (strcmp(color_value, "Gray") == 0)
-		params->format = 0;
-
-	if (strcmp(color_value, "BW") == 0)
-		params->format = 0;
+	params->format = _kds_s2000w_handler_is_color(h);
 
 	if (h->image->data == NULL)
 		return;
@@ -345,7 +345,6 @@ void kds_s2000w_handler_get_current_metadata(handler* h, metadata* params)
 	
 	h->read_info->read_size = _kds_s2000w_handler_find_first_data_byte(h->image);
 
-	metadata = NULL;
 	free(mdata);
 	mdata = NULL;
 	free(scanner_image->data);
diff --git a/src/kds_s2000w_handler.h b/src/kds_s2000w_handler.h
index 9bdeb2b..841787e 100644
--- a/src/kds_s2000w_handler.h
+++ b/src/kds_s2000w_handler.h
@@ -78,8 +78,8 @@ void kds_s2000w_handler_recreate_session(handler* h);
 void kds_s2000w_handler_opts_get_option(handler* handle, uint32_t option, void* value, int32_t* info);
 void kds_s2000w_handler_opts_set_option(handler* handle, uint32_t option, void* value, int32_t* info);
 
-void kds_s2000w_handler_start_scan(handler* h);
-void kds_s2000w_handler_stop_scan(handler* h);
+void kds_s2000w_handler_start_scan(const handler* h);
+void kds_s2000w_handler_stop_scan(const handler* h);
 
 void kds_s2000w_handler_get_current_metadata(handler* h, metadata* params);
 void kds_s2000w_handler_get_current_scan_status(handler* h);
diff --git a/src/kds_s2000w_handler_opts.c b/src/kds_s2000w_handler_opts.c
index 73b0934..8e2244b 100644
--- a/src/kds_s2000w_handler_opts.c
+++ b/src/kds_s2000w_handler_opts.c
@@ -59,7 +59,7 @@ void _kds_s2000w_handler_opts_load_options(handler* h)
 	resp = NULL;
 }
 
-void _kds_s2000w_handler_opts_set_scan_source(option_descriptor* descriptor, handler* h, char* value)
+void _kds_s2000w_handler_opts_set_scan_source(const option_descriptor* descriptor, handler* h, const char* value)
 {
 	if (strcmp(descriptor->config_name, SCAN_SOURCE) != 0)
 		return;
@@ -97,7 +97,7 @@ void _kds_s2000w_handler_opts_set_option_to_default(handler* h)
 	resp = NULL;
 }
 
-json_object* _kds_s2000w_handler_opts_reset(option_descriptor* descriptor, handler* h)
+json_object* _kds_s2000w_handler_opts_reset(const option_descriptor* descriptor, handler* h)
 {
 	if (strcmp(descriptor->config_name, RESET) != 0)
 		return json_object_object_get(h->current_scanner_config, CONFIGURATION);
@@ -336,51 +336,51 @@ void _kds_s2000w_handler_opts_set_enable_color_drop_out_aggressiveness(json_obje
 	color_drop_out_aggressiveness->cap &= ~SANE_CAP_SOFT_SELECT;
 }
 
-void _kds_s2000w_handler_opts_set_offset_x(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_offset_x(const option_descriptor* descriptor, handler* h, const void* value)
 {
 	if (strcmp(descriptor->config_name, IMAGE_OFFSET_X) != 0)
 		return;
 
-	int32_t* int_value = (int32_t*) value;
+	const int32_t* int_value = (const int32_t*) value;
 	uint32_t tenth_inch = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, *int_value);
 	h->coord->offset_x = tenth_inch;
 }
 
-void _kds_s2000w_handler_opts_set_offset_y(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_offset_y(const option_descriptor* descriptor, handler* h, const void* value)
 {
 	if (strcmp(descriptor->config_name, IMAGE_OFFSET_Y) != 0)
 		return;
 
-	int32_t* int_value = (int32_t*) value;
+	const int32_t* int_value = (const int32_t*) value;
 	uint32_t tenth_inch = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, *int_value);
 	h->coord->offset_y = tenth_inch;
 }
 
-void _kds_s2000w_handler_opts_set_width(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_width(const option_descriptor* descriptor, handler* h, const void* value)
 {
 	if (strcmp(descriptor->config_name, IMAGE_WIDTH) != 0)
 		return;
 
-	int32_t* int_value = (int32_t*) value;
+	const int32_t* int_value = (const int32_t*) value;
 	uint32_t offset_x_pixel = kds_s2000w_pixel_converter_tenth_inch_to_pixel(GUI_DPI, h->coord->offset_x);
 	uint32_t width_pixel = *int_value - offset_x_pixel;
 	uint32_t tenth_inch_width = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, width_pixel);
 	h->coord->width = tenth_inch_width;
 }
 
-void _kds_s2000w_handler_opts_set_height(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_height(const option_descriptor* descriptor, handler* h, const void* value)
 {
 	if (strcmp(descriptor->config_name, IMAGE_HEIGHT) != 0)
 		return;
 
-	int32_t* int_value = (int32_t*) value;
+	const int32_t* int_value = (const int32_t*) value;
 	uint32_t offset_y_pixel = kds_s2000w_pixel_converter_tenth_inch_to_pixel(GUI_DPI, h->coord->offset_y);
 	uint32_t height_pixel = *int_value - offset_y_pixel;
 	uint32_t tenth_inch_height = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, height_pixel);
 	h->coord->height = tenth_inch_height;
 }
 
-void _kds_s2000w_handler_opts_set_info_option(option_descriptor* descriptor, int32_t* info) {
+void _kds_s2000w_handler_opts_set_info_option(const option_descriptor* descriptor, int32_t* info) {
 	if (info == NULL)
 		return;
 
@@ -404,7 +404,7 @@ void _kds_s2000w_handler_opts_set_info_option(option_descriptor* descriptor, int
 		*info = RELOAD_OPTIONS | RELOAD_PARAMS;
 }
 
-void _kds_s2000w_handler_opts_set_depends_opts(handler* h,
+void _kds_s2000w_handler_opts_set_depends_opts(const handler* h,
 	const char* config_name,
 	json_object* config)
 {
diff --git a/src/kds_s2000w_image_converter_netpbm.c b/src/kds_s2000w_image_converter_netpbm.c
index 7ed1288..6518e9b 100644
--- a/src/kds_s2000w_image_converter_netpbm.c
+++ b/src/kds_s2000w_image_converter_netpbm.c
@@ -27,7 +27,7 @@ typedef struct {
 tsize_t _kds_s2000w_image_converter_tiff_read(thandle_t handler, tdata_t data, tsize_t size)
 {
 	tiff_reader* reader = (tiff_reader*) handler;
-	char* imagedata = (char*) reader->image->data;
+	const char* imagedata = (const char*) reader->image->data;
 	memcpy(data, &imagedata[reader->curr_offset], size);
 	reader->curr_offset += size;
 
@@ -78,16 +78,15 @@ int _kds_s2000w_image_converter_tiff_close(thandle_t handler)
 
 toff_t _kds_s2000w_image_converter_tiff_size(thandle_t handler)
 {
-	tiff_reader* reader = (tiff_reader*) handler;
-
+	const tiff_reader* reader = (const tiff_reader*) handler;
 	return reader->curr_offset;
 }
 
-uint32_t _kds_s2000w_image_converter_find_char(blobdata* image, uint32_t start, const char cfind)
+uint32_t _kds_s2000w_image_converter_find_char(const blobdata* image, uint32_t start, const char cfind)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_image_converter_find_char");
 
-	char* image_data = (char*) image->data;
+	const char* image_data = (const char*) image->data;
 
 	for (uint32_t i = start; i < image->size; i++) {
 		if (image_data[i] == cfind)
@@ -97,7 +96,7 @@ uint32_t _kds_s2000w_image_converter_find_char(blobdata* image, uint32_t start,
 	return 0;
 }
 
-uint32_t _kds_s2000w_image_converter_get_number_from_substring(char* data, uint32_t start, uint32_t end)
+uint32_t _kds_s2000w_image_converter_get_number_from_substring(const char* data, uint32_t start, uint32_t end)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_image_converter_get_number_from_substring");
 
@@ -137,11 +136,11 @@ void _kds_s2000w_image_converter_tiff_metadata(blobdata* image, image_metadata*
 	TIFFClose(tiff);
 }
 
-void _kds_s2000w_image_converter_pnm_metadata(blobdata* image, image_metadata* mdata)
+void _kds_s2000w_image_converter_pnm_metadata(const blobdata* image, image_metadata* mdata)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_image_converter_pnm_metadata");
 
-	char* image_data = (char*) image->data;
+	const char* image_data = (const char*) image->data;
 
 	mdata->depth = 8;
 	if (strncmp(image_data, "P4", 2) == 0)
@@ -183,7 +182,7 @@ void _kds_s2000w_image_converter_set_pixels(uint8_t data_byte, bit* pixels)
 	}
 }
 
-void _kds_s2000w_image_converter_write_bw_pnm(uint8_t* data,
+void _kds_s2000w_image_converter_write_bw_pnm(const uint8_t* data,
 	size_t size,
 	uint32_t width,
 	uint32_t height,
@@ -215,7 +214,7 @@ void _kds_s2000w_image_converter_write_bw_pnm(uint8_t* data,
 	pixels = NULL;
 }
 
-void _kds_s2000w_image_converter_write_pnm(uint8_t* data,
+void _kds_s2000w_image_converter_write_pnm(const uint8_t* data,
 	size_t size,
 	uint32_t width,
 	uint32_t height,
diff --git a/src/kds_s2000w_image_type_check.c b/src/kds_s2000w_image_type_check.c
index 4d56e56..5ed1f73 100644
--- a/src/kds_s2000w_image_type_check.c
+++ b/src/kds_s2000w_image_type_check.c
@@ -2,44 +2,42 @@
 #include "kds_s2000w_debug.h"
 #include "kds_s2000w_image_type_check.h"
 
-bool kds_s2000w_image_type_check_is_tiff(blobdata* image)
+bool kds_s2000w_image_type_check_is_tiff(const blobdata* image)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_image_type_check_is_tiff");
 
 	if (image->size < 4)
 		return 0;
 
-	char* image_data = (char*) image->data;
-
+	const char* image_data = (const char*) image->data;
 	bool result = image_data[0] == (char)0x49;
 	result = result && image_data[1] == (char)0x49;
 	result = result && image_data[2] == (char)0x2A;
 	return result && image_data[3] == (char)0x00;
 }
 
-bool kds_s2000w_image_type_check_is_pnm(blobdata* image)
+bool kds_s2000w_image_type_check_is_pnm(const blobdata* image)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_image_type_check_is_pnm");
 
 	if (image->size < 2)
 		return 0;
 
-	char* image_data = (char*) image->data;
+	const char* image_data = (const char*) image->data;
 	if (strncmp(image_data, "P6", 2) == 0)
 		return 1;
 
 	return strncmp(image_data, "P4", 2) == 0;
 }
 
-bool kds_s2000w_image_type_check_is_jpeg(blobdata* image)
+bool kds_s2000w_image_type_check_is_jpeg(const blobdata* image)
 {
 	kds_s2000w_debug_printf(ALL, "kds_s2000w_image_type_check_is_jpeg");
 
 	if (image->size < 2)
 		return 0;
 
-	char* image_data = (char*) image->data;
-
+	const char* image_data = (const char*) image->data;
 	uint8_t result = image_data[0] == (char)0xff;
 	return result && image_data[1] == (char)0xd8;
 }
\ No newline at end of file
diff --git a/src/kds_s2000w_image_type_check.h b/src/kds_s2000w_image_type_check.h
index ef46cc6..8cbee0b 100644
--- a/src/kds_s2000w_image_type_check.h
+++ b/src/kds_s2000w_image_type_check.h
@@ -3,8 +3,8 @@
 #include <stdbool.h>
 #include "kds_s2000w_image_converter.h"
 
-bool kds_s2000w_image_type_check_is_tiff(blobdata* image);
-bool kds_s2000w_image_type_check_is_pnm(blobdata* image);
-bool kds_s2000w_image_type_check_is_jpeg(blobdata* image);
+bool kds_s2000w_image_type_check_is_tiff(const blobdata* image);
+bool kds_s2000w_image_type_check_is_pnm(const blobdata* image);
+bool kds_s2000w_image_type_check_is_jpeg(const blobdata* image);
 
 #endif
\ No newline at end of file
diff --git a/src/kds_s2000w_net.c b/src/kds_s2000w_net.c
index 89c2204..6c09425 100644
--- a/src/kds_s2000w_net.c
+++ b/src/kds_s2000w_net.c
@@ -104,7 +104,7 @@ void sane_kds_s2000w_net_close(SANE_Handle handle)
 {
 	kds_s2000w_debug_printf(ALL, "sane_kds_s2000w_net_close");
 
-	handler* h = (handler*) handle;
+	const handler* h = (const handler*) handle;
 	if (h == NULL || h->state != OPENED)
 		return;
 
@@ -207,7 +207,7 @@ SANE_Status sane_kds_s2000w_net_read(SANE_Handle handle, SANE_Byte* data,
 		return SANE_STATUS_EOF;
 	}
 
-	char* image_data = (char*) h->image->data;
+	const char* image_data = (const char*) h->image->data;
 	memcpy(data, image_data + h->read_info->read_size, *length);
 	h->read_info->read_size += *length;
 	return SANE_STATUS_GOOD;
@@ -234,7 +234,7 @@ void sane_kds_s2000w_net_cancel(SANE_Handle handle)
 		return;
 	}
 
-	if (h->current_scan_status->available_images <= 0) {
+	if (h->current_scan_status->available_images == 0) {
 		kds_s2000w_debug_printf(DEBUG, "scan completed no availible images");
 		kds_s2000w_handler_reset(h);
 		kds_s2000w_handler_recreate_session(h);
diff --git a/tests/kds_s2000w_client_mock.c b/tests/kds_s2000w_client_mock.c
index 2ee325c..d922852 100644
--- a/tests/kds_s2000w_client_mock.c
+++ b/tests/kds_s2000w_client_mock.c
@@ -6,7 +6,7 @@
 
 void mock_response(response* resp)
 {
-	response* mock_resp = mock_type(response*);
+	const response* mock_resp = mock_type(response*);
 	if (mock_resp == NULL)
 		return;
 
@@ -102,7 +102,7 @@ void __wrap_kds_s2000w_image_converter_to_pnm(blobdata* in, blobdata* out)
 
 char* __wrap_sanei_config_get_paths(void)
 {
-	char* str = "config_dir_list";
+	const char* str = "config_dir_list";
 
 	size_t size = strlen(str) + 1;
 	char* cpystr = malloc(size);
diff --git a/tests/kds_s2000w_net_tests.c b/tests/kds_s2000w_net_tests.c
index 455d515..6866a63 100644
--- a/tests/kds_s2000w_net_tests.c
+++ b/tests/kds_s2000w_net_tests.c
@@ -23,7 +23,7 @@ int setup(void** state)
 	response_list[0] = kds_s2000w_client_response_init();
 	response_list[0]->code = 200;
 	response_list[1] = kds_s2000w_client_response_init();
-	const char* metadata = "{\
+	const char* metadata_json = "{\
 		\"Metadata\": {\
 			\"BitDepth\": 8, \
 			\"ImageSize\": 1, \
@@ -33,7 +33,7 @@ int setup(void** state)
 	}";
 	response_list[1]->size = 106;
 	response_list[1]->data = malloc(response_list[1]->size);
-	memcpy(response_list[1]->data, metadata, response_list[1]->size);
+	memcpy(response_list[1]->data, metadata_json, response_list[1]->size);
 	response_list[1]->code = 200;
 	response_list[2] = kds_s2000w_client_response_init();
 	response_list[2]->code = 200;
@@ -496,7 +496,7 @@ void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state)
 	const char* test_config = "{\"Configuration\": { \"ColorMode\": \"Color\" } }";
 	h->current_scanner_config = json_tokener_parse(test_config);
 
-	int result = sane_kds_s2000w_net_start(h);
+	sane_kds_s2000w_net_start(h);
 
 	const char* status2 = "{ \
 		\"Status\": { \
@@ -524,7 +524,7 @@ void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state)
 	expect_function_call(__wrap_kds_s2000w_client_get_image);
 	expect_function_call(__wrap_kds_s2000w_client_delete_image);
 	expect_function_call(__wrap_kds_s2000w_client_stop_scan);
-	result = sane_kds_s2000w_net_start(h);
+	int32_t result = sane_kds_s2000w_net_start(h);
 
 	assert_int_equal(result, SANE_STATUS_GOOD);
 	assert_true(h->current_scan_status->complete_scanned);
-- 
2.47.3