aboutsummaryrefslogtreecommitdiff
path: root/src/plugins/old/pack.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/plugins/old/pack.c')
-rw-r--r--src/plugins/old/pack.c538
1 files changed, 268 insertions, 270 deletions
diff --git a/src/plugins/old/pack.c b/src/plugins/old/pack.c
index 968cf67..4f9e19d 100644
--- a/src/plugins/old/pack.c
+++ b/src/plugins/old/pack.c
@@ -27,7 +27,7 @@ MODIFICATIONS.
27#include "platform.h" 27#include "platform.h"
28#include "pack.h" 28#include "pack.h"
29 29
30#if !(defined(_WIN32) && defined(cbNDRContext)) 30#if ! (defined(_WIN32) && defined(cbNDRContext))
31typedef unsigned char byte; 31typedef unsigned char byte;
32#endif 32#endif
33typedef unsigned short half; 33typedef unsigned short half;
@@ -37,11 +37,10 @@ typedef signed short shalf;
37typedef signed int sword; 37typedef signed int sword;
38 38
39 39
40
41int 40int
42EXTRACTOR_common_cat_unpack (const void *buf, 41EXTRACTOR_common_cat_unpack (const void *buf,
43 const char *fmt, 42 const char *fmt,
44 ...) 43 ...)
45{ 44{
46 va_list ap; 45 va_list ap;
47 word maxlen, len, *wordp; 46 word maxlen, len, *wordp;
@@ -63,283 +62,282 @@ EXTRACTOR_common_cat_unpack (const void *buf,
63 va_start (ap, fmt); 62 va_start (ap, fmt);
64 63
65 while (*fmt) 64 while (*fmt)
65 {
66 nreps = 1;
67
68 if (isdigit ( (unsigned char) *fmt))
66 { 69 {
67 nreps = 1; 70 /* We use cp instead of format to keep the 'const' qualifier of fmt */
71 nreps = strtoul (fmt, &cp, 0);
72 fmt = cp;
73 if (*fmt == 'a')
74 isnonprefixed = 0;
75 }
68 76
69 if (isdigit ( (unsigned char) *fmt)) 77 switch (*fmt)
78 {
79 case 'B':
80 case 'b':
81 bytep = va_arg (ap, byte *);
82 for (i = 0; i < nreps; ++i)
83 {
84 *bytep = *bp++;
85 ++bytep;
86 npacked += 1;
87 }
88 break;
89
90
91 case 'h':
92 halfp = va_arg (ap, half *);
93 for (i = 0; i < nreps; ++i)
94 {
95 *halfp = *bp++;
96 *halfp |= *bp++ << 8;
97 ++halfp;
98 npacked += 2;
99 }
100 break;
101
102 case 'H':
103 halfp = va_arg (ap, half *);
104 for (i = 0; i < nreps; ++i)
105 {
106 *halfp = *bp++ << 8;
107 *halfp |= *bp++;
108 ++halfp;
109 npacked += 2;
110 }
111 break;
112
113
114 case 'w':
115 wordp = va_arg (ap, word *);
116 for (i = 0; i < nreps; ++i)
117 {
118 *wordp = *bp++;
119 *wordp |= *bp++ << 8;
120 *wordp |= *bp++ << 16;
121 *wordp |= *bp++ << 24;
122 ++wordp;
123 npacked += 4;
124 }
125 break;
126
127 case 'x':
128 ll = va_arg (ap, long long *);
129 for (i = 0; i < nreps; ++i)
130 {
131 *ll = ((long long) *bp++);
132 *ll |= ((long long) *bp++) << 8;
133 *ll |= ((long long) *bp++) << 16;
134 *ll |= ((long long) *bp++) << 24;
135 *ll |= ((long long) *bp++) << 32;
136 *ll |= ((long long) *bp++) << 40;
137 *ll |= ((long long) *bp++) << 48;
138 *ll |= ((long long) *bp++) << 56;
139 ++ll;
140 npacked += 8;
141 }
142 break;
143
144 case 'W':
145 wordp = va_arg (ap, word *);
146 for (i = 0; i < nreps; ++i)
147 {
148 *wordp = *bp++ << 24;
149 *wordp |= *bp++ << 16;
150 *wordp |= *bp++ << 8;
151 *wordp |= *bp++;
152 ++wordp;
153 npacked += 4;
154 }
155 break;
156
157 case 'X':
158 ll = va_arg (ap, long long *);
159 for (i = 0; i < nreps; ++i)
160 {
161 *ll = ((long long) *bp++) << 56;
162 *ll |= ((long long) *bp++) << 48;
163 *ll |= ((long long) *bp++) << 40;
164 *ll |= ((long long) *bp++) << 32;
165 *ll |= ((long long) *bp++) << 24;
166 *ll |= ((long long) *bp++) << 18;
167 *ll |= ((long long) *bp++) << 8;
168 *ll |= ((long long) *bp++);
169 ++ll;
170 npacked += 8;
171 }
172 break;
173
174
175 case 'A':
176 if (isnonprefixed)
177 {
178 maxlen = va_arg (ap, word);
179 arr = va_arg (ap, void *);
180
181 len = *bp++ << 24;
182 len |= *bp++ << 16;
183 len |= *bp++ << 8;
184 len |= *bp++;
185
186 if (len > maxlen)
70 { 187 {
71 /* We use cp instead of format to keep the 'const' qualifier of fmt */ 188 va_end (ap);
72 nreps = strtoul (fmt, &cp, 0); 189 return -1;
73 fmt = cp;
74 if (*fmt == 'a')
75 isnonprefixed = 0;
76 } 190 }
77 191
78 switch (*fmt) 192 memmove (arr, bp, len);
193 bp += len;
194
195 npacked += len;
196 }
197 else
198 {
199 cbvp = va_arg (ap, struct cat_bvec *);
200 for (i = 0; i < nreps; ++i)
201 {
202 maxlen = cbvp->len;
203 arr = cbvp->data;
204
205 len = *bp++ << 24;
206 len |= *bp++ << 16;
207 len |= *bp++ << 8;
208 len |= *bp++;
209
210 if (len > maxlen)
211 return -1;
212
213 memmove (arr, bp, len);
214 cbvp->len = len;
215 bp += len;
216
217 ++cbvp;
218 npacked += len;
219 }
220 isnonprefixed = 1;
221 }
222 break;
223
224 case 'C':
225 case 'c':
226 sbytep = va_arg (ap, sbyte *);
227 for (i = 0; i < nreps; ++i)
228 {
229 *sbytep = *bp++;
230
231 if ((sizeof (sbyte) > 1) && (*sbytep & 0x80))
232 *sbytep |= (~0) << ((sizeof (sbyte) - 1) * 8);
233
234 ++sbytep;
235 npacked += 1;
236 }
237 break;
238
239
240 case 's':
241 shalfp = va_arg (ap, shalf *);
242 for (i = 0; i < nreps; ++i)
243 {
244 *shalfp = *bp++;
245 *shalfp |= *bp++ << 8;
246
247 if ((sizeof (shalf) > 2) && (*shalfp & 0x8000))
248 *shalfp |= (~0) << ((sizeof (shalf) - 2) * 8);
249
250 ++shalfp;
251 npacked += 2;
252 }
253 break;
254
255 case 'S':
256 shalfp = va_arg (ap, shalf *);
257 for (i = 0; i < nreps; ++i)
258 {
259 *shalfp = *bp++ << 8;
260 *shalfp |= *bp++;
261
262 if ((sizeof (shalf) > 2) && (*shalfp & 0x8000))
263 *shalfp |= (~0) << ((sizeof (shalf) - 2) * 8);
264
265 ++shalfp;
266 npacked += 2;
267 }
268 break;
269
270 case 'l':
271 swordp = va_arg (ap, sword *);
272 for (i = 0; i < nreps; ++i)
273 {
274 *swordp = *bp++;
275 *swordp |= *bp++ << 8;
276 *swordp |= *bp++ << 16;
277 *swordp |= *bp++ << 24;
278
279 if ((sizeof (swordp) > 4) && (*swordp & 0x80000000))
280 *swordp |= (~0) << ((sizeof (sword) - 4) * 8);
281
282 ++swordp;
283 npacked += 4;
284 }
285 break;
286
287 case 'L':
288 swordp = va_arg (ap, sword *);
289 for (i = 0; i < nreps; ++i)
290 {
291 *swordp = *bp++ << 24;
292 *swordp |= *bp++ << 16;
293 *swordp |= *bp++ << 8;
294 *swordp |= *bp++;
295
296 if ((sizeof (swordp) > 4) && (*swordp & 0x80000000))
297 *swordp |= (~0) << ((sizeof (sword) - 4) * 8);
298
299 ++swordp;
300 npacked += 4;
301 }
302 break;
303
304 case 'P':
305 cbvp = va_arg (ap, struct cat_bvec *);
306 for (i = 0; i < nreps; ++i)
307 {
308 len = *bp++ << 24;
309 len |= *bp++ << 16;
310 len |= *bp++ << 8;
311 len |= *bp++;
312
313 newbuf = (byte *) malloc (len);
314
315 if (! newbuf)
79 { 316 {
80 case 'B': 317 int j;
81 case 'b': 318 for (j = 0; j < i; j++)
82 bytep = va_arg (ap, byte *); 319 free (cbvp[i].data);
83 for (i = 0; i < nreps; ++i)
84 {
85 *bytep = *bp++;
86 ++bytep;
87 npacked += 1;
88 }
89 break;
90
91
92
93 case 'h':
94 halfp = va_arg (ap, half *);
95 for (i = 0; i < nreps; ++i)
96 {
97 *halfp = *bp++;
98 *halfp |= *bp++ << 8;
99 ++halfp;
100 npacked += 2;
101 }
102 break;
103
104 case 'H':
105 halfp = va_arg (ap, half *);
106 for (i = 0; i < nreps; ++i)
107 {
108 *halfp = *bp++ << 8;
109 *halfp |= *bp++;
110 ++halfp;
111 npacked += 2;
112 }
113 break;
114
115
116 case 'w':
117 wordp = va_arg (ap, word *);
118 for (i = 0; i < nreps; ++i)
119 {
120 *wordp = *bp++;
121 *wordp |= *bp++ << 8;
122 *wordp |= *bp++ << 16;
123 *wordp |= *bp++ << 24;
124 ++wordp;
125 npacked += 4;
126 }
127 break;
128
129 case 'x':
130 ll = va_arg (ap, long long *);
131 for (i = 0; i < nreps; ++i)
132 {
133 *ll = ((long long) *bp++);
134 *ll |= ((long long) *bp++) << 8;
135 *ll |= ((long long) *bp++) << 16;
136 *ll |= ((long long) *bp++) << 24;
137 *ll |= ((long long) *bp++) << 32;
138 *ll |= ((long long) *bp++) << 40;
139 *ll |= ((long long) *bp++) << 48;
140 *ll |= ((long long) *bp++) << 56;
141 ++ll;
142 npacked += 8;
143 }
144 break;
145
146 case 'W':
147 wordp = va_arg (ap, word *);
148 for (i = 0; i < nreps; ++i)
149 {
150 *wordp = *bp++ << 24;
151 *wordp |= *bp++ << 16;
152 *wordp |= *bp++ << 8;
153 *wordp |= *bp++;
154 ++wordp;
155 npacked += 4;
156 }
157 break;
158
159 case 'X':
160 ll = va_arg (ap, long long *);
161 for (i = 0; i < nreps; ++i)
162 {
163 *ll = ((long long) *bp++) << 56;
164 *ll |= ((long long) *bp++) << 48;
165 *ll |= ((long long) *bp++) << 40;
166 *ll |= ((long long) *bp++) << 32;
167 *ll |= ((long long) *bp++) << 24;
168 *ll |= ((long long) *bp++) << 18;
169 *ll |= ((long long) *bp++) << 8;
170 *ll |= ((long long) *bp++);
171 ++ll;
172 npacked += 8;
173 }
174 break;
175
176
177 case 'A':
178 if (isnonprefixed)
179 {
180 maxlen = va_arg (ap, word);
181 arr = va_arg (ap, void *);
182
183 len = *bp++ << 24;
184 len |= *bp++ << 16;
185 len |= *bp++ << 8;
186 len |= *bp++;
187
188 if (len > maxlen)
189 {
190 va_end (ap);
191 return -1;
192 }
193
194 memmove (arr, bp, len);
195 bp += len;
196
197 npacked += len;
198 }
199 else
200 {
201 cbvp = va_arg (ap, struct cat_bvec *);
202 for (i = 0; i < nreps; ++i)
203 {
204 maxlen = cbvp->len;
205 arr = cbvp->data;
206
207 len = *bp++ << 24;
208 len |= *bp++ << 16;
209 len |= *bp++ << 8;
210 len |= *bp++;
211
212 if (len > maxlen)
213 return -1;
214
215 memmove (arr, bp, len);
216 cbvp->len = len;
217 bp += len;
218
219 ++cbvp;
220 npacked += len;
221 }
222 isnonprefixed = 1;
223 }
224 break;
225
226 case 'C':
227 case 'c':
228 sbytep = va_arg (ap, sbyte *);
229 for (i = 0; i < nreps; ++i)
230 {
231 *sbytep = *bp++;
232
233 if ((sizeof (sbyte) > 1) && (*sbytep & 0x80))
234 *sbytep |= (~0) << ((sizeof (sbyte) - 1) * 8);
235
236 ++sbytep;
237 npacked += 1;
238 }
239 break;
240
241
242 case 's':
243 shalfp = va_arg (ap, shalf *);
244 for (i = 0; i < nreps; ++i)
245 {
246 *shalfp = *bp++;
247 *shalfp |= *bp++ << 8;
248
249 if ((sizeof (shalf) > 2) && (*shalfp & 0x8000))
250 *shalfp |= (~0) << ((sizeof (shalf) - 2) * 8);
251
252 ++shalfp;
253 npacked += 2;
254 }
255 break;
256
257 case 'S':
258 shalfp = va_arg (ap, shalf *);
259 for (i = 0; i < nreps; ++i)
260 {
261 *shalfp = *bp++ << 8;
262 *shalfp |= *bp++;
263
264 if ((sizeof (shalf) > 2) && (*shalfp & 0x8000))
265 *shalfp |= (~0) << ((sizeof (shalf) - 2) * 8);
266
267 ++shalfp;
268 npacked += 2;
269 }
270 break;
271
272 case 'l':
273 swordp = va_arg (ap, sword *);
274 for (i = 0; i < nreps; ++i)
275 {
276 *swordp = *bp++;
277 *swordp |= *bp++ << 8;
278 *swordp |= *bp++ << 16;
279 *swordp |= *bp++ << 24;
280
281 if ((sizeof (swordp) > 4) && (*swordp & 0x80000000))
282 *swordp |= (~0) << ((sizeof (sword) - 4) * 8);
283
284 ++swordp;
285 npacked += 4;
286 }
287 break;
288
289 case 'L':
290 swordp = va_arg (ap, sword *);
291 for (i = 0; i < nreps; ++i)
292 {
293 *swordp = *bp++ << 24;
294 *swordp |= *bp++ << 16;
295 *swordp |= *bp++ << 8;
296 *swordp |= *bp++;
297
298 if ((sizeof (swordp) > 4) && (*swordp & 0x80000000))
299 *swordp |= (~0) << ((sizeof (sword) - 4) * 8);
300
301 ++swordp;
302 npacked += 4;
303 }
304 break;
305
306 case 'P':
307 cbvp = va_arg (ap, struct cat_bvec *);
308 for (i = 0; i < nreps; ++i)
309 {
310 len = *bp++ << 24;
311 len |= *bp++ << 16;
312 len |= *bp++ << 8;
313 len |= *bp++;
314
315 newbuf = (byte *) malloc (len);
316
317 if (!newbuf)
318 {
319 int j;
320 for (j = 0; j < i; j++)
321 free (cbvp[i].data);
322 va_end (ap);
323 return -1;
324 }
325
326 memmove (newbuf, bp, len);
327 cbvp[i].data = newbuf;
328 cbvp[i].len = len;
329
330 bp += len;
331 npacked += len;
332 }
333 break;
334
335 default:
336 va_end (ap); 320 va_end (ap);
337 return -1; 321 return -1;
338 } 322 }
339 323
340 ++fmt; 324 memmove (newbuf, bp, len);
325 cbvp[i].data = newbuf;
326 cbvp[i].len = len;
327
328 bp += len;
329 npacked += len;
330 }
331 break;
332
333 default:
334 va_end (ap);
335 return -1;
341 } 336 }
342 337
338 ++fmt;
339 }
340
343 va_end (ap); 341 va_end (ap);
344 return 0; 342 return 0;
345} 343}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-23 08:12:55 +0000