fix readed bytes per line bigger than max length

diff --git a/src/kds_s2000w_net.c b/src/kds_s2000w_net.c
index f6ffb8e08432be72c3a43ae5f4df9bbbfccec9ba..cd7ea9bce93873eb55f5df93194fb96c9cb94f8f 100644 (file)
--- a/src/kds_s2000w_net.c
+++ b/src/kds_s2000w_net.c
@@ -35,6 +35,11 @@ int* get_readed_lines()
        return &readed_lines;
 }
 
+int* get_readed_bytes_per_line()
+{
+       return &readed_bytes_per_line;
+}
+
 int _sane_kds_s2000w_net_find_first_data_byte(const char* data)
 {
        const int header_spaces = 3;
@@ -284,21 +289,18 @@ SANE_Status _sane_kds_s2000w_net_read(SANE_Handle handle, SANE_Byte* data,
                return SANE_STATUS_EOF;
        }
 
-       int maxlen = 0;
-       if (current_metadata.bytes_per_line < max_length) {
+       int maxlen = max_length;
+       if (current_metadata.bytes_per_line - readed_bytes_per_line < max_length)
                maxlen = current_metadata.bytes_per_line - readed_bytes_per_line;
-       } else {
-               maxlen = max_length - readed_bytes_per_line;
-       }
 
        *length = maxlen;
        memcpy(data, current_metadata.image + read_size, *length);
 
        readed_bytes_per_line += *length;
        read_size += *length;
+       printf("read size %i\n", read_size);
 
        if (readed_bytes_per_line >= current_metadata.bytes_per_line) {
-               readed_bytes_per_line = 0;
                readed_lines++;
        }
 

diff --git a/tests/kds_s2000w_net_tests.c b/tests/kds_s2000w_net_tests.c
index abcc1467c647f997e5c4096accafc15ee2d8f67c..051eee72bab9469f57319becb198974724b80e3a 100644 (file)
--- a/tests/kds_s2000w_net_tests.c
+++ b/tests/kds_s2000w_net_tests.c
@@ -28,6 +28,51 @@ START_TEST(sane_kds_s2000w_net_find_first_data_byte_test)
 }
 END_TEST
 
+START_TEST(sane_kds_s2000w_net_read_cancel_test)
+{
+       int* length = malloc(sizeof(int));
+       *length = 0;
+       int* cancel = get_cancel();
+       *cancel = 1;
+
+       SANE_Status status = _sane_kds_s2000w_net_read(NULL, NULL, 0, length);
+
+       ck_assert_int_eq(status, SANE_STATUS_CANCELLED);
+
+       free(length);
+       length = NULL;
+}
+END_TEST
+
+START_TEST(sane_kds_s2000w_net_read_all_lines_test)
+{
+       int* cancel = get_cancel();
+       *cancel = 0;
+       metadata* current_metadata_ptr = get_current_metadata();
+       char* image = malloc(sizeof(char) * 4);
+       for (int i = 0; i < 3; i++) {
+               image[i] = 0x0a;
+       }
+       image[4] = 0xff;
+       current_metadata.image = image;
+       current_metadata_ptr->lines = 1;
+       int* readed_lines = get_readed_lines();
+       *readed_lines = 0;
+       int* length = malloc(sizeof(int));
+       *length = 0;
+
+       _sane_kds_s2000w_net_read(NULL, NULL, 0, length);
+       SANE_Status status = _sane_kds_s2000w_net_read(NULL, NULL, 0, length);
+
+       ck_assert_int_eq(status, SANE_STATUS_EOF);
+
+       free(length);
+       length = NULL;
+       free(image);
+       image = NULL;
+}
+END_TEST
+
 START_TEST(sane_kds_s2000w_net_read_test)
 {
        int* read_size_ptr = get_read_size();
@@ -35,7 +80,6 @@ START_TEST(sane_kds_s2000w_net_read_test)
        metadata* current_metadata_ptr = get_current_metadata();
        int* read_size = get_read_size();
        *read_size = 0;
-       current_metadata_ptr->scanned_all_complete = 1;
        current_metadata_ptr->lines = 1;
        current_metadata_ptr->bytes_per_line = 65536;
        char* image = malloc(sizeof(char) * 65539);
@@ -64,44 +108,36 @@ START_TEST(sane_kds_s2000w_net_read_test)
 }
 END_TEST
 
-START_TEST(sane_kds_s2000w_net_read_cancel_test)
-{
-       int* length = malloc(sizeof(int));
-       *length = 0;
-       int* cancel = get_cancel();
-       *cancel = 1;
-
-       SANE_Status status = _sane_kds_s2000w_net_read(NULL, NULL, 0, length);
-
-       ck_assert_int_eq(status, SANE_STATUS_CANCELLED);
-
-       free(length);
-       length = NULL;
-}
-END_TEST
 
-START_TEST(sane_kds_s2000w_net_read_all_lines_test)
+START_TEST(sane_kds_s2000w_net_read_bytes_per_line_bigger_test)
 {
-       int* cancel = get_cancel();
-       *cancel = 0;
+       int* read_size_ptr = get_read_size();
+       *read_size_ptr = 0;
        metadata* current_metadata_ptr = get_current_metadata();
-       char* image = malloc(sizeof(char) * 4);
+       int* read_size = get_read_size();
+       *read_size = 0;
+       int* readed_bytes_per_line = get_readed_bytes_per_line();
+       readed_bytes_per_line = 0;
+       current_metadata_ptr->lines = 1;
+       current_metadata_ptr->bytes_per_line = 95000;
+       char* image = malloc(sizeof(char) * 95003);
        for (int i = 0; i < 3; i++) {
                image[i] = 0x0a;
        }
        image[4] = 0xff;
-       current_metadata.image = image;
-       current_metadata_ptr->lines = 1;
-       int* readed_lines = get_readed_lines();
-       *readed_lines = 0;
-       int* length = malloc(sizeof(int));
-       *length = 0;
+       current_metadata_ptr->image = image;
 
-       _sane_kds_s2000w_net_read(NULL, NULL, 0, length);
-       SANE_Status status = _sane_kds_s2000w_net_read(NULL, NULL, 0, length);
+       SANE_Int maxlen = 65536;
+       char* dataptr = malloc(sizeof(char) * maxlen);
+       SANE_Int* length = malloc(sizeof(SANE_Int));
 
-       ck_assert_int_eq(status, SANE_STATUS_EOF);
+       _sane_kds_s2000w_net_read(NULL, (void*) dataptr, maxlen, length);
+       _sane_kds_s2000w_net_read(NULL, (void*) dataptr, maxlen, length);
+
+       ck_assert_int_eq(*read_size_ptr, 95003);        
 
+       free(dataptr);
+       dataptr = NULL;
        free(length);
        length = NULL;
        free(image);

diff --git a/tests/runtests.c b/tests/runtests.c
index 0e71ff1a5c4b40cd5f239072bee61918b08c3f05..ca24e290dd582b8833bb5bb398583e7d19051b67 100644 (file)
--- a/tests/runtests.c
+++ b/tests/runtests.c
@@ -10,9 +10,10 @@ Suite* first_tests()
 
        tc_core = tcase_create("core");
        tcase_add_test(tc_core, sane_kds_s2000w_net_find_first_data_byte_test);
-       tcase_add_test(tc_core, sane_kds_s2000w_net_read_test);
        tcase_add_test(tc_core, sane_kds_s2000w_net_read_cancel_test);
        tcase_add_test(tc_core, sane_kds_s2000w_net_read_all_lines_test);
+       tcase_add_test(tc_core, sane_kds_s2000w_net_read_test);
+       tcase_add_test(tc_core, sane_kds_s2000w_net_read_bytes_per_line_bigger_test);
 
        suite_add_tcase(suite, tc_core);