Debian Codegraph @

src/lib/helper/check_helper.c

raw
1 /* 'checkit_tiff' is a conformance checker for baseline TIFFs
2 *
3 * author: Andreas Romeyke, 2015-2022
4 * licensed under conditions of libtiff
5 * (see http://libtiff.maptools.org/misc.html)
6 *
7 */
8
9 #include <stdarg.h>
10 #include "check.h"
11 #include "check_helper.h"
12 #include "ctstring.h"
13 #include <sys/stat.h>
14 #include <assert.h>
15 #include <stdio.h>
16 #ifdef __WIN32__
17 #define bswap_16 _byteswap_ushort
18 #define bswap_32 _byteswap_ulong
19 #else
20 #include <byteswap.h>
21 #endif
22 /*
23 #define DEBUG
24 */
25
26 void free_value_if_set(ret_t * pointer) {
27 if (
28 (!pointer->value_found.is_const)
29 && (pointer->value_found.len > 0)
30 && (pointer->value_found.string != NULL)
31 ) {
32 clean_str(&pointer->value_found);
33 }
34 }
35
36 void free_expected_if_set(ret_t * pointer) {
37 if (
38 (!pointer->expected_value.is_const)
39 && (pointer->expected_value.len > 0)
40 && (pointer->expected_value.string != NULL)
41 ) {
42 clean_str(&pointer->expected_value);
43 }
44 }
45
46
47 string_t float2str(float v) {
48 char array[VALUESTRLEN]={0};
49 snprintf(array, VALUESTRLEN-1, "%f", v);
50 return str(array);
51 }
52
53 string_t uint2str(unsigned int v) {
54 char array[VALUESTRLEN]={0};
55 snprintf(array, VALUESTRLEN-1, "%u", v);
56 return str(array);
57 }
58
59 string_t int2str(int v) {
60 char array[VALUESTRLEN]={0};
61 snprintf(array, VALUESTRLEN-1, "%i", v);
62 return str(array);
63 }
64
65 string_t frac2str(int d, int n) {
66 char array[VALUESTRLEN]={0};
67 snprintf(array, VALUESTRLEN-1, "%i/%i", d, n);
68 return str(array);
69 }
70
71 uint16 TIFFSwabShort(uint16 a) {
72 return bswap_16( a );
73 }
74
75 uint32 TIFFSwabLong(uint32 a) {
76 return bswap_32( a );
77 }
78
79 long long fsize(int fd) {
80 struct stat st;
81 fstat(fd, &st);
82 return st.st_size;
83 }
84
85 ret_t set_value_found_ret (ret_t * rp, const string_t msg) {
86 assert( NULL != rp);
87 free_value_if_set(rp);
88 rp->value_found=msg;
89 return *rp;
90 }
91
92 ret_t set_value_found_ret_with_returncode(ret_t *rp, const string_t msg, returncode_t rc) {
93 assert(NULL != rp);
94 ret_t r = set_value_found_ret(rp, msg);
95 r.returncode = rc;
96 return r;
97 }
98
99 ret_t set_value_found_ret_u32_value (ret_t *rp, uint32 value) {
100 assert(NULL != rp);
101 ret_t ret = set_value_found_ret(rp, uint2str(value));
102 return ret;
103 }
104
105 ret_t set_value_found_ret_u16_value (ret_t *rp, uint16 value) {
106 assert(NULL != rp);
107 ret_t ret = set_value_found_ret(rp, uint2str(value));
108 return ret;
109
110 }
111
112 ret_t set_value_found_ret_float_value (ret_t *rp, float value) {
113 assert(NULL != rp);
114 ret_t ret = set_value_found_ret(rp, float2str(value));
115 return ret;
116 }
117
118
119
120 ret_t set_value_found_ret_formatted (ret_t * rp, const char * fmt, ...) {
121 assert(NULL != rp);
122 char msg[VALUESTRLEN]={0};
123 va_list argptr;
124 va_start(argptr, fmt);
125 vsnprintf(msg, VALUESTRLEN-1, fmt, argptr);
126 va_end(argptr);
127 ret_t ret = set_value_found_ret(rp, str(msg));
128 clean_ret(*rp);
129 return ret;
130 }
131
132 ret_t set_value_found_ret_formatted_with_returncode(ret_t * rp, returncode_t rc, const char * fmt, ...) {
133 assert(NULL != rp);
134 char msg[VALUESTRLEN]={0};
135 va_list argptr;
136 va_start(argptr, fmt);
137 vsnprintf(msg, VALUESTRLEN-1, fmt, argptr);
138 va_end(argptr);
139 ret_t ret = set_value_found_ret(rp, str(msg));
140 clean_ret(*rp);
141 ret.returncode = rc;
142 return ret;
143
144 }
145
146 ret_t set_expected_value_formatted (ret_t * rp, const char * fmt, ...) {
147 char msg[VALUESTRLEN]={0};
148 va_list argptr;
149 va_start(argptr, fmt);
150 vsnprintf(msg, VALUESTRLEN, fmt, argptr);
151 va_end(argptr);
152 free_expected_if_set(rp);
153 rp->expected_value = str(msg);
154 return *rp;
155 }
156
157 uint32 get_streamlen_at_offset(const ifd_entry_t *ifd_entry) {
158 uint32 streamlen;
159 switch (ifd_entry->datatype) {
160 case TIFF_ASCII:
161 case TIFF_BYTE:
162 case TIFF_SBYTE:
163 case TIFF_UNDEFINED:
164 streamlen = ifd_entry->count;
165 break;
166 case TIFF_SHORT:
167 case TIFF_SSHORT:
168 streamlen = ifd_entry->count * 2;
169 break;
170 case TIFF_LONG:
171 case TIFF_SLONG:
172 case TIFF_IFD:
173 case TIFF_FLOAT:
174 streamlen = ifd_entry->count * 4;
175 break;
176 case TIFF_LONG8:
177 case TIFF_DOUBLE:
178 case TIFF_SLONG8:
179 case TIFF_RATIONAL:
180 case TIFF_SRATIONAL:
181 streamlen = ifd_entry->count * 8;
182 break;
183 default:
184 streamlen = ifd_entry->count;
185 }
186 return streamlen;
187 }
188
189 bool tag_is_an_IFD(const ifd_entry_t *ifd_entry) {
190 return (ifd_entry->datatype == TIFF_IFD) || (ifd_entry->datatype == TIFF_IFD8);
191 }
192
193 void clean_ret(ret_t ret) {
194 clean_str(&ret.expected_value);
195 clean_str(&ret.value_found);
196 }
197
198
199
200 /* vim: set tabstop=2 softtabstop=2 shiftwidth=2 smarttab expandtab :*/