?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated PCI IDs to latest snapshot.
[tangerine.git] / workbench / c / Version.c
blob256b655e5728bd75441735fac3714cc1ba79997d
1 /*
2 Copyright © 1995-2007, The AROS Development Team. All rights reserved.
3 $Id$
4
5 Desc: Version CLI command
6 Lang: english
7 */
8
9 /******************************************************************************
10
11 NAME
12
13 Version [<library|device|file>] [<version #>] [<revision #>] [FILE] [FULL] [RES]
14
15 SYNOPSIS
16
17 NAME/M,MD5SUM/S,VERSION/N,REVISION/N,FILE/S,FULL/S,RES/S
18
19 LOCATION
20
21 Sys:C
22
23 FUNCTION
24
25 Prints or checks the version and revision information of a file, library or device.
26
27 INPUTS
28
29 NAME -- name of file, library or device to check. If not given it
30 prints version and revision of Kickstart.
31 MD5SUM -- #FIXME what is that?
32 VERSION -- checks for version and returns error code 5 (warn) if the
33 version of the file is lower.
34 REVISION -- checks for revision and returns error code 5 (warn) if the
35 revision of the file is lower.
36 FILE -- reads from file and ignores currently loaded libraries and devices
37 FULL -- prints additional information
38 RES -- gets version of resident commands
39
40 RESULT
41
42 NOTES
43
44 EXAMPLE
45
46 BUGS
47
48 SEE ALSO
49
50 INTERNALS
51
52 HISTORY
53
54 ******************************************************************************/
55
56 #include <aros/arosbase.h>
57 #include <aros/config.h>
58 #include <aros/inquire.h>
59 #include <proto/aros.h>
60
61 #define ENABLE_RT 1
62 #include <aros/rt.h>
63
64 #include <stdlib.h>
65 #include <string.h>
66 #include <stdio.h>
67 #include <ctype.h>
68 #include <proto/exec.h>
69 #include <exec/execbase.h>
70 #include <exec/libraries.h>
71 #include <exec/memory.h>
72 #include <exec/types.h>
73 #include <exec/resident.h>
74 #include <proto/dos.h>
75 #include <proto/utility.h>
76 #include <dos/datetime.h>
77 #include <dos/dos.h>
78 #include <dos/dosextens.h>
79
80 /*===[md5.h]==============================================================*/
81
82 /* Data structure for MD5 (Message-Digest) computation */
83 typedef struct {
84 ULONG buf[4]; /* scratch buffer */
85 ULONG i[2]; /* number of _bits_ handled mod 2^64 */
86 unsigned char in[64]; /* input buffer */
87 } MD5_CTX;
88
89 void MD5Init(MD5_CTX *mdContext);
90 void MD5Update(MD5_CTX *mdContext, unsigned char *inBuf, unsigned int inLen);
91 void MD5Final(unsigned char digest[16], MD5_CTX *mdContext);
92
93 /*==[md5.c]===============================================================*/
94
95 /*
96 * Used in 'version' as is, just removed the #include "ambient.h"
97 *
98 * Harry Sintonen <sintonen@iki.fi>
99 */
100
101 /*
102 * Ambient - the ultimate desktop
103 * ------------------------------
104 * (c) 2001-2003 by David Gerber <zapek@meanmachine.ch>
105 * All Rights Reserved
106 *
107 * $Id$
108 */
109
110 //#include "ambient.h"
111 //#include <exec/types.h>
112
113 /*
114 ***********************************************************************
115 ** md5.c -- the source code for MD5 routines **
116 ** RSA Data Security, Inc. MD5 Message-Digest Algorithm **
117 ** Created: 2/17/90 RLR **
118 ** Revised: 1/91 SRD,AJ,BSK,JT Reference C Version **
119 ***********************************************************************
120 */
121
122 /*
123 * Edited 7 May 93 by CP to change the interface to match that
124 * of the MD5 routines in RSAREF. Due to this alteration, this
125 * code is "derived from the RSA Data Security, Inc. MD5 Message-
126 * Digest Algorithm". (See below.)
127 */
128
129 /*
130 ***********************************************************************
131 ** Copyright (C) 1990, RSA Data Security, Inc. All rights reserved. **
132 ** **
133 ** License to copy and use this software is granted provided that **
134 ** it is identified as the "RSA Data Security, Inc. MD5 Message- **
135 ** Digest Algorithm" in all material mentioning or referencing this **
136 ** software or this function. **
137 ** **
138 ** License is also granted to make and use derivative works **
139 ** provided that such works are identified as "derived from the RSA **
140 ** Data Security, Inc. MD5 Message-Digest Algorithm" in all **
141 ** material mentioning or referencing the derived work. **
142 ** **
143 ** RSA Data Security, Inc. makes no representations concerning **
144 ** either the merchantability of this software or the suitability **
145 ** of this software for any particular purpose. It is provided "as **
146 ** is" without express or implied warranty of any kind. **
147 ** **
148 ** These notices must be retained in any copies of any part of this **
149 ** documentation and/or software. **
150 ***********************************************************************
151 */
152
153 //#include "md5.h"
154
155 /*
156 ***********************************************************************
157 ** Message-digest routines: **
158 ** To form the message digest for a message M **
159 ** (1) Initialize a context buffer mdContext using MD5Init **
160 ** (2) Call MD5Update on mdContext and M **
161 ** (3) Call MD5Final on mdContext **
162 ** The message digest is now in the bugffer passed to MD5Final **
163 ***********************************************************************
164 */
165
166 static unsigned char PADDING[64] = {
167 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
168 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
169 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
170 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
171 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
172 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
173 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
174 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
175 };
176
177 /* F, G, H and I are basic MD5 functions */
178 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
179 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
180 #define H(x, y, z) ((x) ^ (y) ^ (z))
181 #define I(x, y, z) ((y) ^ ((x) | (~z)))
182
183 /* ROTATE_LEFT rotates x left n bits */
184 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
185
186 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4 */
187 /* Rotation is separate from addition to prevent recomputation */
188 #define FF(a, b, c, d, x, s, ac) \
189 {(a) += F ((b), (c), (d)) + (x) + (ULONG)(ac); \
190 (a) = ROTATE_LEFT ((a), (s)); \
191 (a) += (b); \
192 }
193 #define GG(a, b, c, d, x, s, ac) \
194 {(a) += G ((b), (c), (d)) + (x) + (ULONG)(ac); \
195 (a) = ROTATE_LEFT ((a), (s)); \
196 (a) += (b); \
197 }
198 #define HH(a, b, c, d, x, s, ac) \
199 {(a) += H ((b), (c), (d)) + (x) + (ULONG)(ac); \
200 (a) = ROTATE_LEFT ((a), (s)); \
201 (a) += (b); \
202 }
203 #define II(a, b, c, d, x, s, ac) \
204 {(a) += I ((b), (c), (d)) + (x) + (ULONG)(ac); \
205 (a) = ROTATE_LEFT ((a), (s)); \
206 (a) += (b); \
207 }
208
209 static void Transform(register ULONG *buf,register ULONG *in);
210
211 /* The routine MD5Init initializes the message-digest context
212 mdContext. All fields are set to zero.
213 */
214 void MD5Init ( MD5_CTX *mdContext)
215 {
216 mdContext->i[0] = mdContext->i[1] = (ULONG)0;
217
218 /* Load magic initialization constants.
219 */
220 mdContext->buf[0] = (ULONG)0x67452301L;
221 mdContext->buf[1] = (ULONG)0xefcdab89L;
222 mdContext->buf[2] = (ULONG)0x98badcfeL;
223 mdContext->buf[3] = (ULONG)0x10325476L;
224 }
225
226 /* The routine MD5Update updates the message-digest context to
227 account for the presence of each of the characters inBuf[0..inLen-1]
228 in the message whose digest is being computed.
229 */
230 void MD5Update (MD5_CTX *mdContext, unsigned char *inBuf,
231 unsigned int inLen)
232 {
233 register int i, ii;
234 int mdi;
235 ULONG in[16];
236
237 /* compute number of bytes mod 64 */
238 mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
239
240 /* update number of bits */
241 if ((mdContext->i[0] + ((ULONG)inLen << 3)) < mdContext->i[0])
242 mdContext->i[1]++;
243 mdContext->i[0] += ((ULONG)inLen << 3);
244 mdContext->i[1] += ((ULONG)inLen >> 29);
245
246 while (inLen--)
247 {
248 /* add new character to buffer, increment mdi */
249 mdContext->in[mdi++] = *inBuf++;
250
251 /* transform if necessary */
252 if (mdi == 0x40)
253 {
254 for (i = 0, ii = 0; i < 16; i++, ii += 4)
255 in[i] = (((ULONG)mdContext->in[ii+3]) << 24) |
256 (((ULONG)mdContext->in[ii+2]) << 16) |
257 (((ULONG)mdContext->in[ii+1]) << 8) |
258 ((ULONG)mdContext->in[ii]);
259 Transform (mdContext->buf, in);
260 mdi = 0;
261 }
262 }
263 }
264
265 /* The routine MD5Final terminates the message-digest computation and
266 ends with the desired message digest in mdContext->digest[0...15].
267 */
268 void MD5Final (unsigned char digest[16], MD5_CTX *mdContext)
269 {
270 ULONG in[16];
271 int mdi;
272 unsigned int i, ii;
273 unsigned int padLen;
274
275 /* save number of bits */
276 in[14] = mdContext->i[0];
277 in[15] = mdContext->i[1];
278
279 /* compute number of bytes mod 64 */
280 mdi = (int)((mdContext->i[0] >> 3) & 0x3F);
281
282 /* pad out to 56 mod 64 */
283 padLen = (mdi < 56) ? (56 - mdi) : (120 - mdi);
284 MD5Update (mdContext, PADDING, padLen);
285
286 /* append length in bits and transform */
287 for (i = 0, ii = 0; i < 14; i++, ii += 4)
288 in[i] = (((ULONG)mdContext->in[ii+3]) << 24) |
289 (((ULONG)mdContext->in[ii+2]) << 16) |
290 (((ULONG)mdContext->in[ii+1]) << 8) |
291 ((ULONG)mdContext->in[ii]);
292 Transform (mdContext->buf, in);
293
294 /* store buffer in digest */
295 for (i = 0, ii = 0; i < 4; i++, ii += 4)
296 {
297 digest[ii] = (unsigned char) (mdContext->buf[i] & 0xFF);
298 digest[ii+1] = (unsigned char)((mdContext->buf[i] >> 8) & 0xFF);
299 digest[ii+2] = (unsigned char)((mdContext->buf[i] >> 16) & 0xFF);
300 digest[ii+3] = (unsigned char)((mdContext->buf[i] >> 24) & 0xFF);
301 }
302 }
303
304 /* Basic MD5 step. Transforms buf based on in. Note that if the Mysterious
305 Constants are arranged backwards in little-endian order and decrypted with
306 the DES they produce OCCULT MESSAGES!
307 */
308 void Transform(register ULONG *buf,register ULONG *in)
309 {
310 register ULONG a = buf[0], b = buf[1], c = buf[2], d = buf[3];
311
312 /* Round 1 */
313 #define S11 7
314 #define S12 12
315 #define S13 17
316 #define S14 22
317 FF ( a, b, c, d, in[ 0], S11, 0xD76AA478L); /* 1 */
318 FF ( d, a, b, c, in[ 1], S12, 0xE8C7B756L); /* 2 */
319 FF ( c, d, a, b, in[ 2], S13, 0x242070DBL); /* 3 */
320 FF ( b, c, d, a, in[ 3], S14, 0xC1BDCEEEL); /* 4 */
321 FF ( a, b, c, d, in[ 4], S11, 0xF57C0FAFL); /* 5 */
322 FF ( d, a, b, c, in[ 5], S12, 0x4787C62AL); /* 6 */
323 FF ( c, d, a, b, in[ 6], S13, 0xA8304613L); /* 7 */
324 FF ( b, c, d, a, in[ 7], S14, 0xFD469501L); /* 8 */
325 FF ( a, b, c, d, in[ 8], S11, 0x698098D8L); /* 9 */
326 FF ( d, a, b, c, in[ 9], S12, 0x8B44F7AFL); /* 10 */
327 FF ( c, d, a, b, in[10], S13, 0xFFFF5BB1L); /* 11 */
328 FF ( b, c, d, a, in[11], S14, 0x895CD7BEL); /* 12 */
329 FF ( a, b, c, d, in[12], S11, 0x6B901122L); /* 13 */
330 FF ( d, a, b, c, in[13], S12, 0xFD987193L); /* 14 */
331 FF ( c, d, a, b, in[14], S13, 0xA679438EL); /* 15 */
332 FF ( b, c, d, a, in[15], S14, 0x49B40821L); /* 16 */
333
334 /* Round 2 */
335 #define S21 5
336 #define S22 9
337 #define S23 14
338 #define S24 20
339 GG ( a, b, c, d, in[ 1], S21, 0xF61E2562L); /* 17 */
340 GG ( d, a, b, c, in[ 6], S22, 0xC040B340L); /* 18 */
341 GG ( c, d, a, b, in[11], S23, 0x265E5A51L); /* 19 */
342 GG ( b, c, d, a, in[ 0], S24, 0xE9B6C7AAL); /* 20 */
343 GG ( a, b, c, d, in[ 5], S21, 0xD62F105DL); /* 21 */
344 GG ( d, a, b, c, in[10], S22, 0x02441453L); /* 22 */
345 GG ( c, d, a, b, in[15], S23, 0xD8A1E681L); /* 23 */
346 GG ( b, c, d, a, in[ 4], S24, 0xE7D3FBC8L); /* 24 */
347 GG ( a, b, c, d, in[ 9], S21, 0x21E1CDE6L); /* 25 */
348 GG ( d, a, b, c, in[14], S22, 0xC33707D6L); /* 26 */
349 GG ( c, d, a, b, in[ 3], S23, 0xF4D50D87L); /* 27 */
350 GG ( b, c, d, a, in[ 8], S24, 0x455A14EDL); /* 28 */
351 GG ( a, b, c, d, in[13], S21, 0xA9E3E905L); /* 29 */
352 GG ( d, a, b, c, in[ 2], S22, 0xFCEFA3F8L); /* 30 */
353 GG ( c, d, a, b, in[ 7], S23, 0x676F02D9L); /* 31 */
354 GG ( b, c, d, a, in[12], S24, 0x8D2A4C8AL); /* 32 */
355
356 /* Round 3 */
357 #define S31 4
358 #define S32 11
359 #define S33 16
360 #define S34 23
361 HH ( a, b, c, d, in[ 5], S31, 0xFFFA3942L); /* 33 */
362 HH ( d, a, b, c, in[ 8], S32, 0x8771F681L); /* 34 */
363 HH ( c, d, a, b, in[11], S33, 0x6D9D6122L); /* 35 */
364 HH ( b, c, d, a, in[14], S34, 0xFDE5380CL); /* 36 */
365 HH ( a, b, c, d, in[ 1], S31, 0xA4BEEA44L); /* 37 */
366 HH ( d, a, b, c, in[ 4], S32, 0x4BDECFA9L); /* 38 */
367 HH ( c, d, a, b, in[ 7], S33, 0xF6BB4B60L); /* 39 */
368 HH ( b, c, d, a, in[10], S34, 0xBEBFBC70L); /* 40 */
369 HH ( a, b, c, d, in[13], S31, 0x289B7EC6L); /* 41 */
370 HH ( d, a, b, c, in[ 0], S32, 0xEAA127FAL); /* 42 */
371 HH ( c, d, a, b, in[ 3], S33, 0xD4EF3085L); /* 43 */
372 HH ( b, c, d, a, in[ 6], S34, 0x04881D05L); /* 44 */
373 HH ( a, b, c, d, in[ 9], S31, 0xD9D4D039L); /* 45 */
374 HH ( d, a, b, c, in[12], S32, 0xE6DB99E5L); /* 46 */
375 HH ( c, d, a, b, in[15], S33, 0x1FA27CF8L); /* 47 */
376 HH ( b, c, d, a, in[ 2], S34, 0xC4AC5665L); /* 48 */
377
378 /* Round 4 */
379 #define S41 6
380 #define S42 10
381 #define S43 15
382 #define S44 21
383 II ( a, b, c, d, in[ 0], S41, 0xF4292244L); /* 49 */
384 II ( d, a, b, c, in[ 7], S42, 0x432AFF97L); /* 50 */
385 II ( c, d, a, b, in[14], S43, 0xAB9423A7L); /* 51 */
386 II ( b, c, d, a, in[ 5], S44, 0xFC93A039L); /* 52 */
387 II ( a, b, c, d, in[12], S41, 0x655B59C3L); /* 53 */
388 II ( d, a, b, c, in[ 3], S42, 0x8F0CCC92L); /* 54 */
389 II ( c, d, a, b, in[10], S43, 0xFFEFF47DL); /* 55 */
390 II ( b, c, d, a, in[ 1], S44, 0x85845DD1L); /* 56 */
391 II ( a, b, c, d, in[ 8], S41, 0x6FA87E4FL); /* 57 */
392 II ( d, a, b, c, in[15], S42, 0xFE2CE6E0L); /* 58 */
393 II ( c, d, a, b, in[ 6], S43, 0xA3014314L); /* 59 */
394 II ( b, c, d, a, in[13], S44, 0x4E0811A1L); /* 60 */
395 II ( a, b, c, d, in[ 4], S41, 0xF7537E82L); /* 61 */
396 II ( d, a, b, c, in[11], S42, 0xBD3AF235L); /* 62 */
397 II ( c, d, a, b, in[ 2], S43, 0x2AD7D2BBL); /* 63 */
398 II ( b, c, d, a, in[ 9], S44, 0xEB86D391L); /* 64 */
399
400 buf[0] += a;
401 buf[1] += b;
402 buf[2] += c;
403 buf[3] += d;
404 }
405
406 /*==[end md5.c]============================================================*/
407
408
409 const TEXT version[] = "$VER: Version 42.1 (12.11.2006)\n";
410
411 static const char ERROR_HEADER[] = "Version";
412
413 #define TEMPLATE "NAME/M,MD5SUM/S,VERSION/N,REVISION/N,FILE/S,FULL/S,RES/S"
414 struct
415 {
416 CONST_STRPTR *arg_name;
417 IPTR arg_md5sum;
418 LONG *arg_version;
419 LONG *arg_revision;
420 IPTR arg_file;
421 IPTR arg_full;
422 IPTR arg_res;
423 }
424 args;
425
426 LONG mversion, mrevision;
427
428 struct
429 {
430 STRPTR pv_name;
431 ULONG pv_flags;
432 LONG pv_version;
433 LONG pv_revision;
434 //LONG pv_days;
435 STRPTR pv_vername;
436 STRPTR pv_revname;
437 STRPTR pv_datestr;
438 STRPTR pv_extralf;
439 STRPTR pv_extrastr;
440 UBYTE pv_md5sum[16];
441 }
442 parsedver = { NULL, 0, 0, 0, NULL, NULL, NULL, NULL, NULL, {0}};
443
444 #define PVF_MD5SUM (1 << 0)
445 #define PVF_NOVERSION (1 << 1)
446
447 static
448 int makeverstring(CONST_STRPTR name);
449 static
450 void printverstring(void);
451 static
452 void freeverstring(void);
453 static
454 int makesysver(void);
455 static
456 int cmpargsparsed(void);
457
458
459 /**************************** support functions ************************/
460
461 /* Duplicate string, by given length or -1 for full length
462 */
463 static
464 STRPTR dupstr(CONST_STRPTR buffer, LONG len)
465 {
466 STRPTR ret = NULL;
467
468 if (buffer)
469 {
470 if (len == -1)
471 len = strlen(buffer);
472
473 ret = AllocVec(len + 1, MEMF_ANY);
474 if (ret)
475 {
476 CopyMem((STRPTR) buffer, ret, len);
477 ret[len] = '\0';
478 }
479 }
480
481 return ret;
482 }
483
484
485 static
486 inline int myisspace(int c)
487 {
488 return (c == ' ' || c == '\t');
489 }
490
491
492 /* Return a pointer to a string, stripped by all leading whitespace characters
493 * (SPACE, TAB).
494 */
495 static
496 STRPTR skipwhites(CONST_STRPTR buffer)
497 {
498 for (;; buffer++)
499 {
500 if (buffer[0] == '\0' || !isspace(buffer[0]))
501 {
502 return (STRPTR) buffer;
503 }
504 }
505 }
506
507
508 /* Return a pointer to a string, stripped by all leading space characters
509 * (SPACE).
510 */
511 static
512 STRPTR skipspaces(CONST_STRPTR buffer)
513 {
514 for (;; buffer++)
515 {
516 if (buffer[0] == '\0' || buffer[0] != ' ')
517 {
518 return (STRPTR) buffer;
519 }
520 }
521 }
522
523
524 /* Strip all whitespace-characters from the end of a string. Note that the
525 * buffer passed in will be modified!
526 */
527 static
528 void stripwhites(STRPTR buffer)
529 {
530 int len = strlen(buffer);
531
532 while (len > 0)
533 {
534 if (!isspace(buffer[len-1]))
535 {
536 buffer[len] = '\0';
537 return;
538 }
539 len--;
540 }
541 buffer[len] = '\0';
542 }
543
544
545 /* Searches for a given string in a file and stores up to *lenptr characters
546 * into the buffer beginning with the first character after the given string.
547 */
548 static
549 int findinfile(BPTR file, CONST_STRPTR string, STRPTR buffer, int *lenptr, unsigned char digest[16])
550 {
551 int error = RETURN_OK;
552 int buflen = *lenptr, len = 0, pos, stringlen;
553 BOOL ready = FALSE;
554 MD5_CTX md5ctx;
555 STRPTR bufpos;
556 STRPTR tmp;
557
558 tmp = AllocMem(buflen, MEMF_PUBLIC);
559 if (!tmp)
560 {
561 return RETURN_FAIL;
562 }
563
564 stringlen = strlen(string);
565 *lenptr = -1;
566
567 if (args.arg_md5sum)
568 {
569 MD5Init(&md5ctx);
570 }
571
572 bufpos = tmp;
573 while ((len = Read(file, &tmp[len], buflen - len)) > 0)
574 {
575 pos = 0;
576
577 if (args.arg_md5sum)
578 {
579 MD5Update(&md5ctx, bufpos, len);
580 }
581
582 if (ready)
583 {
584 /* If we get here we're scanning the rest of the file for md5sum. - Piru */
585 len = 0;
586 }
587 else
588 {
589 while ((len - pos) >= stringlen)
590 {
591 /* Compare the current buffer position with the supplied string. */
592 if (strncmp(&tmp[pos], string, stringlen) == 0)
593 {
594 /* It is equal! Now move the rest of the buffer to the top of
595 * the buffer and fill it up.
596 */
597 int findstrlen = len - pos;
598
599 memcpy(buffer, &tmp[pos + stringlen], findstrlen);
600
601 len = Read(file, &buffer[findstrlen], buflen - findstrlen);
602 if (len >= 0)
603 {
604 if (args.arg_md5sum)
605 {
606 MD5Update(&md5ctx, &buffer[findstrlen], len);
607 }
608
609 *lenptr = findstrlen + len;
610 }
611 else
612 {
613 error = RETURN_FAIL;
614 }
615 ready = TRUE;
616 break;
617 }
618 pos++;
619 }
620 /* Move the rest of the buffer that could not be compared (because it
621 * is smaller than the string to compare) to the top of the buffer.
622 */
623 if (!ready)
624 {
625 memmove(tmp, &tmp[len - stringlen], stringlen);
626 }
627 else
628 {
629 /* If we're not md5summing, stop file scanning now. - Piru */
630 if (!args.arg_md5sum)
631 {
632 break;
633 }
634 }
635 len = stringlen;
636 }
637
638 bufpos = &tmp[len];
639 }
640
641 FreeMem(tmp, buflen);
642
643 if (len == -1)
644 {
645 error = RETURN_FAIL;
646 }
647
648 if (args.arg_md5sum)
649 {
650 memset(digest, 0, 16);
651 MD5Final(digest, &md5ctx);
652 }
653
654 return error;
655 }
656
657
658 /*************************** parsing functions *************************/
659
660 /* Convert a date in the form DD.MM.YY or DD.MM.YYYY into a numerical
661 * value. Return FALSE, if buffer doesn't contain a valid date.
662 */
663 static
664 BOOL makedatefromstring(CONST_STRPTR *bufptr)
665 {
666 CONST_STRPTR buffer = *bufptr;
667 struct DateTime dt;
668 CONST_STRPTR headerstart, end;
669 STRPTR newbuf;
670 LONG res;
671 int len, i;
672 UBYTE c;
673
674 //if (isspace(buffer[0]))
675 // buffer++;
676
677 headerstart = buffer;
678
679 buffer = strchr(buffer, '(');
680 if (!buffer)
681 {
682 return FALSE;
683 }
684 buffer++;
685 end = strchr(buffer, ')');
686 if (!end)
687 {
688 return FALSE;
689 }
690 len = (int)(end - buffer);
691 newbuf = dupstr(buffer, len);
692 if (!newbuf)
693 {
694 return FALSE;
695 }
696 for (i = 0; i < len; i++)
697 {
698 c = newbuf[i];
699
700 if (c == '.' || c == '/')
701 newbuf[i] = '-';
702 else if (!isalnum(c))
703 {
704 end = buffer + i;
705 newbuf[i] = '\0';
706 break;
707 }
708 }
709
710 //Printf("date: \"%s\"\n", (LONG) newbuf);
711
712 dt.dat_Format = FORMAT_CDN;
713 dt.dat_Flags = 0;
714 dt.dat_StrDay = NULL;
715 dt.dat_StrDate = newbuf;
716 dt.dat_StrTime = NULL;
717 res = StrToDate(&dt);
718 if (!res)
719 {
720 dt.dat_Format = FORMAT_DOS;
721 res = StrToDate(&dt);
722 if (!res)
723 {
724 //Printf("StrToDate failed!\n");
725 FreeVec(newbuf);
726 return FALSE;
727 }
728 }
729 FreeVec(newbuf);
730
731 //parsedver.pv_days = dt.dat_Stamp.ds_Days;
732
733 parsedver.pv_datestr = AllocVec(buffer - headerstart + LEN_DATSTRING + 2, MEMF_ANY);
734 if (!parsedver.pv_datestr)
735 {
736 return FALSE;
737 }
738
739 dt.dat_Stamp.ds_Minute = 0;
740 dt.dat_Stamp.ds_Tick = 0;
741
742 dt.dat_StrDate = parsedver.pv_datestr + (buffer - headerstart);
743 dt.dat_Format = FORMAT_DEF;
744 if (!DateToStr(&dt))
745 {
746 //Printf("DateToStr failed!\n");
747 return FALSE;
748 }
749
750 CopyMem((STRPTR) headerstart, parsedver.pv_datestr, buffer - headerstart);
751 res = strlen(parsedver.pv_datestr);
752 parsedver.pv_datestr[res++] = ')';
753 parsedver.pv_datestr[res] = '\0';
754
755 *bufptr = end + 1;
756
757 return TRUE;
758 }
759
760
761 /* Check whether the given string contains a version in the form
762 * <version>.<revision> . If not return FALSE, otherwise fill in parsedver and
763 * return TRUE.
764 */
765 static
766 BOOL makeversionfromstring(CONST_STRPTR *bufptr)
767 {
768 LONG pos, ver, rev;
769 CONST_STRPTR buffer = *bufptr;
770 CONST_STRPTR verstart, revstart;
771
772 //Printf("makeversionfromstring: buffer \"%s\"\n", (LONG) buffer);
773
774 /* Do version */
775
776 verstart = buffer;
777 pos = StrToLong((STRPTR) buffer, &ver);
778 if (pos == -1)
779 {
780 return FALSE;
781 }
782 parsedver.pv_version = ver;
783 parsedver.pv_revision = -1;
784
785 parsedver.pv_vername = dupstr(verstart, pos);
786 if (!parsedver.pv_vername)
787 {
788 return FALSE;
789 }
790
791 /* Do revision */
792
793 buffer += pos;
794 revstart = buffer;
795 buffer = skipspaces(buffer); /* NOTE: skipspaces, not skipwhites! */
796 if (*buffer != '.')
797 {
798 *bufptr = buffer;
799 return TRUE;
800 }
801
802 buffer++;
803 pos = StrToLong((STRPTR) buffer, &rev);
804 if (pos == -1)
805 {
806 *bufptr = buffer;
807 return TRUE;
808 }
809
810 parsedver.pv_revision = rev;
811
812 /* calc the revision string len */
813 pos = buffer + pos - revstart;
814 parsedver.pv_revname = dupstr(revstart, pos);
815 if (!parsedver.pv_revname)
816 {
817 return FALSE;
818 }
819
820 *bufptr = revstart + pos;
821
822 return TRUE;
823 }
824
825
826 static
827 void printverstring(void)
828 {
829 if (args.arg_md5sum)
830 {
831 if (parsedver.pv_flags & PVF_MD5SUM)
832 {
833 #ifdef __AROS__
834 /* Endianess safe version */
835
836 Printf("%02lX%02lX%02lX%02lX"
837 "%02lX%02lX%02lX%02lX"
838 "%02lX%02lX%02lX%02lX"
839 "%02lX%02lX%02lX%02lX ",
840 parsedver.pv_md5sum[0],
841 parsedver.pv_md5sum[1],
842 parsedver.pv_md5sum[2],
843 parsedver.pv_md5sum[3],
844 parsedver.pv_md5sum[4],
845 parsedver.pv_md5sum[5],
846 parsedver.pv_md5sum[6],
847 parsedver.pv_md5sum[7],
848 parsedver.pv_md5sum[8],
849 parsedver.pv_md5sum[9],
850 parsedver.pv_md5sum[10],
851 parsedver.pv_md5sum[11],
852 parsedver.pv_md5sum[12],
853 parsedver.pv_md5sum[13],
854 parsedver.pv_md5sum[14],
855 parsedver.pv_md5sum[15]);
856
857 #else
858 VPrintf("%08lX%08lX%08lX%08lX ", parsedver.pv_md5sum);
859 #endif
860 }
861 else
862 {
863 /* "01234567012345670123456701234567: " */
864 PutStr("<no md5sum available> ");
865 }
866 }
867
868 if (parsedver.pv_flags & PVF_NOVERSION)
869 {
870 Printf("%s\n", (LONG) parsedver.pv_name);
871 }
872 else
873 {
874 if (args.arg_full)
875 {
876 /* If md5sum output was there, avoid linefeed to allow parsing the output - Piru */
877 if (args.arg_md5sum)
878 {
879 parsedver.pv_extralf = " ";
880 }
881
882 Printf("%s%s%s%s%s%s%s\n",
883 (LONG) parsedver.pv_name, (LONG) (*parsedver.pv_name ? " " : ""),
884 (LONG) parsedver.pv_vername, (LONG) parsedver.pv_revname,
885 (LONG) parsedver.pv_datestr,
886 parsedver.pv_extralf ? (LONG) parsedver.pv_extralf : (LONG) "\n",
887 parsedver.pv_extrastr ? (LONG) parsedver.pv_extrastr : (LONG) "");
888 }
889 else
890 {
891 Printf("%s%s%s%s\n",
892 (LONG) parsedver.pv_name, (LONG) (*parsedver.pv_name ? " " : ""),
893 (LONG) parsedver.pv_vername, (LONG) parsedver.pv_revname);
894 }
895 }
896 }
897
898
899 static
900 int makedata(CONST_STRPTR buffer, CONST_STRPTR ptr, int pos)
901 {
902 //Printf("makedata: buffer \"%s\" prt \"%s\"\n", (LONG) buffer, (LONG) ptr);
903
904 if (makeversionfromstring(&ptr))
905 {
906 CONST_STRPTR endp;
907 BOOL doskip;
908
909 /* It is! */
910 /* Copy the program-name into a buffer. */
911 parsedver.pv_name = dupstr(buffer, pos);
912 if (!parsedver.pv_name)
913 {
914 PrintFault(ERROR_NO_FREE_STORE, (STRPTR) ERROR_HEADER);
915 return RETURN_FAIL;
916 }
917
918 /* Now find the date */
919 //Printf("makedatafromstring: ptr #1: \"%s\"\n", (LONG) ptr);
920 doskip = strchr(ptr, '(') ? TRUE : FALSE;
921 (void) makedatefromstring(&ptr);
922
923 //Printf("makedatafromstring: ptr #2: \"%s\"\n", (LONG) ptr);
924 if (doskip)
925 ptr = skipspaces(ptr); /* NOTE: not skipwhites! */
926 for (endp = ptr; *endp != '\0' && *endp != '\r' && *endp != '\n'; endp++)
927 ;
928 pos = endp - ptr;
929 if (pos)
930 {
931 parsedver.pv_extrastr = dupstr(ptr, pos);
932 if (!parsedver.pv_extrastr)
933 {
934 PrintFault(ERROR_NO_FREE_STORE, (STRPTR) ERROR_HEADER);
935 return RETURN_FAIL;
936 }
937
938 if (doskip)
939 parsedver.pv_extralf = "\n";
940 }
941
942 return 1;
943 }
944
945 return 0;
946 }
947
948
949 /* Retrieves version information from string. The data is stored in the
950 * global struct parsedver.pv_
951 */
952
953 static
954 int makedatafromstring(CONST_STRPTR buffer)
955 {
956 int error = RETURN_OK;
957 int pos = 0;
958 LONG add, dummy;
959
960 while (buffer[pos] && buffer[pos] != '\r' && buffer[pos] != '\n')
961 {
962 /* NOTE: Not isspace()! - Piru */
963 if (myisspace(buffer[pos]) &&
964 (add = StrToLong((STRPTR) buffer + pos + 1, &dummy)) != -1)
965 {
966 CONST_STRPTR ptr;
967
968 /* Found something, which looks like a version. Now check, if it
969 * really is.
970 */
971
972 //Printf("makedatafromstring: buffer + %ld: \"%s\"\n", pos, (LONG) buffer + pos);
973
974 ptr = buffer + pos + 1;
975
976 if (makedata(buffer, ptr, pos))
977 {
978 break;
979 }
980 }
981 pos++;
982 }
983
984 if (!buffer[pos] || buffer[pos] == '\r' || buffer[pos] == '\n')
985 {
986 CONST_STRPTR endp;
987
988 /* use the whatever is after ver tag as name */
989 for (endp = buffer; *endp != '\0' && *endp != '\r' && *endp != '\n'; endp++)
990 ;
991 pos = endp - buffer;
992
993 parsedver.pv_name = dupstr(buffer, pos);
994 if (!parsedver.pv_name)
995 {
996 PrintFault(ERROR_NO_FREE_STORE, (STRPTR) ERROR_HEADER);
997 return RETURN_FAIL;
998 }
999 }
1000
1001 /* Strip any whitespaces from the tail of the program-name.
1002 */
1003 if (parsedver.pv_name)
1004 {
1005 stripwhites(parsedver.pv_name);
1006 }
1007
1008 return error;
1009 }
1010
1011
1012 /* Case-insensitive FindResident()
1013 */
1014 static
1015 struct Resident *findresident(CONST_STRPTR name)
1016 {
1017 struct Resident **rp;
1018 struct Resident *resident;
1019
1020 rp = (struct Resident **) SysBase->ResModules;
1021
1022 while ((resident = *rp++))
1023 {
1024 if (((LONG) resident) > 0)
1025 {
1026 if (!Stricmp(resident->rt_Name, (STRPTR) name))
1027 {
1028 break;
1029 }
1030 }
1031 else
1032 {
1033 rp = (struct Resident **) (((ULONG) resident) & (ULONG) ~(1 << 31));
1034 }
1035 }
1036
1037 return resident;
1038 }
1039
1040
1041 /* Case-insensitive FindName()
1042 */
1043 static
1044 struct Node *findname(struct List *list, CONST_STRPTR name)
1045 {
1046 struct Node *node;
1047
1048 ForeachNode(list, node)
1049 {
1050 if (!Stricmp(node->ln_Name, (STRPTR) name))
1051 {
1052 return node;
1053 }
1054 }
1055
1056 return NULL;
1057 }
1058
1059
1060 /* Retrieve information from resident modules. Returns 0 for success.
1061 */
1062 static
1063 int createresidentver(struct Resident *MyResident)
1064 {
1065 STRPTR buffer = NULL, tmpbuffer;
1066 int error, pos = 0, foundver = FALSE;
1067
1068 if (MyResident->rt_IdString)
1069 {
1070 buffer = skipwhites(MyResident->rt_IdString);
1071 //Printf("createresidentver: buffer \"%s\"\n", (LONG) buffer);
1072
1073 /* Locate version part */
1074 while (buffer[pos])
1075 {
1076 LONG dummy;
1077
1078 /* NOTE: Not isspace()! - Piru */
1079 if (myisspace(buffer[pos]) &&
1080 StrToLong(buffer + pos + 1, &dummy) != -1)
1081 {
1082 buffer += pos;
1083 foundver = TRUE;
1084 break;
1085 }
1086 pos++;
1087 }
1088 //Printf("createresidentver: buffer: \"%s\"\n", (LONG) buffer);
1089 }
1090
1091
1092 /* If could not find any version info, use the resident rt_Name */
1093 if (!foundver)
1094 buffer = "";
1095
1096 //Printf("createresidentver: buffer: \"%s\"\n", (LONG) buffer);
1097
1098 tmpbuffer = AllocVec(strlen(MyResident->rt_Name) + strlen(buffer) + 1, MEMF_ANY);
1099 if (!tmpbuffer)
1100 {
1101 PrintFault(ERROR_NO_FREE_STORE, (STRPTR) ERROR_HEADER);
1102 return RETURN_FAIL;
1103 }
1104
1105 strcpy(tmpbuffer, MyResident->rt_Name);
1106 strcat(tmpbuffer, buffer);
1107 //Printf("createresidentver: tmpbuffer: \"%s\"\n", (LONG) tmpbuffer);
1108 error = makedatafromstring(tmpbuffer);
1109
1110 FreeVec(tmpbuffer);
1111
1112 return error;
1113 }
1114
1115
1116 /* Retrieve version information from library. Returns 0 for success.
1117 */
1118 static
1119 int createlibraryver(struct Library *MyLibrary)
1120 {
1121 STRPTR buffer, tmpbuffer;
1122 int error, foundver = FALSE, pos;
1123
1124 if (MyLibrary->lib_IdString)
1125 {
1126 //Printf("createlibraryver: lib_IdString \"%s\"\n", (LONG) MyLibrary->lib_IdString);
1127 buffer = skipwhites(MyLibrary->lib_IdString);
1128
1129 //Printf("createlibraryver: buffer \"%s\"\n", (LONG) buffer);
1130
1131 /* Find full 'ver.rev' version info
1132 */
1133 pos = 0;
1134 while (buffer[pos])
1135 {
1136 LONG dummy, add;
1137
1138 /* NOTE: Not isspace()! - Piru */
1139 if (myisspace(buffer[pos]) &&
1140 (add = StrToLong(buffer + pos + 1, &dummy)) != -1 &&
1141 buffer[pos + 1 + add] == '.')
1142 {
1143 buffer += pos;
1144 pos = 0;
1145 foundver = TRUE;
1146 break;
1147 }
1148 pos++;
1149 }
1150
1151 /* If could not find 'ver.rev', find any numeric */
1152 if (!foundver)
1153 {
1154 pos = 0;
1155 while (buffer[pos])
1156 {
1157 LONG dummy;
1158
1159 /* NOTE: Not isspace()! - Piru */
1160 if (myisspace(buffer[pos]) &&
1161 StrToLong(buffer + pos + 1, &dummy) != -1)
1162 {
1163 buffer += pos;
1164 pos = 0;
1165 foundver = TRUE;
1166 break;
1167 }
1168 pos++;
1169 }
1170 }
1171 }
1172
1173 /* If could not find any version info, use the resident rt_Name */
1174 if (!foundver)
1175 {
1176 buffer = "";
1177 error = RETURN_WARN;
1178 }
1179
1180 tmpbuffer = AllocVec(strlen(MyLibrary->lib_Node.ln_Name) + strlen(buffer) + 1, MEMF_ANY);
1181 if (!tmpbuffer)
1182 {
1183 PrintFault(ERROR_NO_FREE_STORE, (STRPTR) ERROR_HEADER);
1184 return RETURN_FAIL;
1185 }
1186
1187 strcpy(tmpbuffer, MyLibrary->lib_Node.ln_Name);
1188 strcat(tmpbuffer, buffer);
1189 //Printf("createlibraryver: tmpbuffer: \"%s\"\n", (LONG) tmpbuffer);
1190 pos = makedatafromstring(tmpbuffer);
1191 if (pos > error)
1192 {
1193 error = pos;
1194 }
1195
1196 FreeVec(tmpbuffer);
1197
1198 return error;
1199 }
1200
1201
1202 /* Create default strings
1203 */
1204 static
1205 int createdefvers(CONST_STRPTR name)
1206 {
1207 FreeVec(parsedver.pv_revname);
1208 FreeVec(parsedver.pv_vername);
1209 FreeVec(parsedver.pv_name);
1210
1211 parsedver.pv_name = dupstr(name, -1);
1212 parsedver.pv_vername = AllocVec(14, MEMF_ANY);
1213 parsedver.pv_revname = AllocVec(15, MEMF_ANY);
1214
1215 if (parsedver.pv_name &&
1216 parsedver.pv_vername &&
1217 parsedver.pv_revname)
1218 {
1219 sprintf(parsedver.pv_vername, "%ld", parsedver.pv_version);
1220 sprintf(parsedver.pv_revname, ".%ld", parsedver.pv_revision);
1221
1222 return RETURN_OK;
1223 }
1224
1225 return RETURN_FAIL;
1226 }
1227
1228
1229 /* Create version info from named resident
1230 */
1231 static
1232 int makeresidentver(CONST_STRPTR name)
1233 {
1234 struct Resident *MyResident;
1235 int error = -1;
1236
1237 if ((MyResident = findresident(name)))
1238 {
1239 error = createresidentver(MyResident);
1240 if (error != RETURN_OK)
1241 {
1242 /* get values from residenttag */
1243 parsedver.pv_version = MyResident->rt_Version;
1244 parsedver.pv_revision = -1;
1245 error = createdefvers(MyResident->rt_Name);
1246 }
1247 }
1248
1249 return error;
1250 }
1251
1252
1253 /* Create version info from named list node
1254 */
1255 static
1256 int makeexeclistver(struct List *list, CONST_STRPTR name)
1257 {
1258 struct Library *MyLibrary;
1259 int error = -1;
1260
1261 Forbid();
1262
1263 MyLibrary = (struct Library *) findname(list, name);
1264 if (MyLibrary)
1265 {
1266 /* get values from library */
1267 ULONG ver = MyLibrary->lib_Version;
1268 ULONG rev = MyLibrary->lib_Revision;
1269
1270 error = createlibraryver(MyLibrary);
1271 if (error != RETURN_OK ||
1272 parsedver.pv_version != ver ||
1273 parsedver.pv_revision != rev)
1274 {
1275 /* special case where createlibraryrev was successful, but
1276 * version or revision don't match.
1277 */
1278 if (error == RETURN_OK)
1279 {
1280 /* If there is extrastr, make sure there's linefeed, too.
1281 */
1282 if (parsedver.pv_extrastr)
1283 {
1284 parsedver.pv_extralf = "\n";
1285 }
1286 }
1287
1288 /* get values from library */
1289 parsedver.pv_version = ver;
1290 parsedver.pv_revision = rev;
1291
1292 error = createdefvers(MyLibrary->lib_Node.ln_Name);
1293 }
1294 }
1295
1296 Permit();
1297
1298 return error;
1299 }
1300
1301
1302 /* Find resident from seglist, return NULL if none found
1303 */
1304 static
1305 struct Resident *FindLibResident(BPTR Segment)
1306 {
1307 while (Segment)
1308 {
1309 ULONG *MySegment;
1310 UWORD *MyBuffer;
1311 UWORD *EndBuffer;
1312
1313 MySegment = (ULONG*) BADDR(Segment);
1314 MyBuffer = (UWORD*) &MySegment[1];
1315 EndBuffer = (UWORD*) &MySegment[(MySegment[-1] - sizeof(ULONG) * 4) / sizeof(ULONG)];
1316
1317 while (MyBuffer < EndBuffer)
1318 {
1319 struct Resident *MyResident;
1320
1321 MyResident = (struct Resident*) MyBuffer;
1322 if (MyResident->rt_MatchWord == RTC_MATCHWORD &&
1323 MyResident->rt_MatchTag == MyResident)
1324 {
1325 return MyResident;
1326 }
1327
1328 MyBuffer++;
1329 }
1330
1331 Segment =(BPTR) MySegment[0];
1332 }
1333
1334 SetIoErr(ERROR_OBJECT_NOT_FOUND);
1335 return NULL;
1336 }
1337
1338
1339 /* Find $VER: tag from seglist, return NULL if none found
1340 Returns dupstr()d string or NULL.
1341 */
1342 static
1343 STRPTR FindSegmentVER(BPTR Segment)
1344 {
1345 while (Segment)
1346 {
1347 ULONG *MySegment;
1348 CONST_STRPTR MyBuffer;
1349 CONST_STRPTR EndBuffer;
1350 CONST_STRPTR SegmentEnd;
1351
1352 MySegment = (ULONG*) BADDR(Segment);
1353 MyBuffer = (CONST_STRPTR) &MySegment[1];
1354 SegmentEnd = ((CONST_STRPTR) MySegment) + MySegment[-1] - sizeof(ULONG) * 2;
1355 EndBuffer = SegmentEnd - 5;
1356
1357 while (MyBuffer < EndBuffer)
1358 {
1359 if (MyBuffer[0] == '$' &&
1360 MyBuffer[1] == 'V' &&
1361 MyBuffer[2] == 'E' &&
1362 MyBuffer[3] == 'R' &&
1363 MyBuffer[4] == ':')
1364 {
1365 CONST_STRPTR EndPtr;
1366
1367 MyBuffer += 5;
1368 /* Required because some smartass could end his $VER: tag
1369 * without '\0' in the segment to save space. - Piru
1370 */
1371 for (EndPtr = MyBuffer; EndPtr < SegmentEnd && *EndPtr; EndPtr++)
1372 ;
1373 if (EndPtr - MyBuffer)
1374 {
1375 return dupstr(MyBuffer, EndPtr - MyBuffer);
1376 }
1377 }
1378
1379 MyBuffer++;
1380 }
1381
1382 Segment =(BPTR) MySegment[0];
1383 }
1384
1385 SetIoErr(ERROR_OBJECT_NOT_FOUND);
1386 return NULL;
1387 }
1388
1389
1390 /* Create version info from named device
1391 */
1392 static
1393 int makedevicever(CONST_STRPTR name)
1394 {
1395 struct DevProc *MyDevProc;
1396 int error = -1;
1397
1398 MyDevProc = GetDeviceProc((STRPTR) name, NULL);
1399 if (MyDevProc)
1400 {
1401 if (MyDevProc->dvp_DevNode->dol_Type == DLT_DEVICE)
1402 {
1403 #ifdef __AROS__
1404 #warning "FIXME: AROS specific version info for devices"
1405 error = RETURN_FAIL;
1406 #else
1407 BPTR SegList;
1408
1409 SegList = MyDevProc->dvp_DevNode->dol_misc.dol_handler.dol_SegList;
1410 if (SegList)
1411 {
1412 struct Resident *MyResident;
1413
1414 MyResident = FindLibResident(SegList);
1415 if (MyResident)
1416 {
1417 error = createresidentver(MyResident);
1418 }
1419 else
1420 error = RETURN_FAIL;
1421 }
1422 #endif
1423 }
1424 FreeDeviceProc(MyDevProc);
1425 }
1426
1427 if (error != RETURN_OK && error != -1)
1428 {
1429 Printf("Could not find version information for '%s'\n", (LONG) name);
1430 }
1431
1432 return error;
1433 }
1434
1435
1436 /* Retrieve version information from file. Return 0 for success.
1437 */
1438 #define BUFFERSIZE (16384 + 1)
1439 static
1440 int makefilever(CONST_STRPTR name)
1441 {
1442 BPTR file;
1443 int error; // = RETURN_OK;
1444
1445 file = Open((STRPTR) name, MODE_OLDFILE);
1446 if (file)
1447 {
1448 UBYTE *buffer;
1449
1450 buffer = AllocMem(BUFFERSIZE, MEMF_PUBLIC);
1451 if (buffer)
1452 {
1453 int len = BUFFERSIZE - 1;
1454
1455 error = findinfile(file, "$VER:", buffer, &len, parsedver.pv_md5sum);
1456 if (error == RETURN_OK)
1457 {
1458 parsedver.pv_flags |= PVF_MD5SUM;
1459
1460 if (len >= 0)
1461 {
1462 STRPTR startbuffer;
1463
1464 buffer[len] = '\0';
1465 startbuffer = skipwhites(buffer);
1466
1467 //Printf("startbuffer \"%s\"\n", startbuffer);
1468 error = makedatafromstring(startbuffer);
1469 }
1470 else
1471 {
1472 /* Try LoadSeg
1473 */
1474 error = RETURN_ERROR;
1475
1476 Close(file);
1477
1478 file = LoadSeg((STRPTR) name);
1479 if (file)
1480 {
1481 struct Resident *MyResident;
1482
1483 MyResident = FindLibResident(file);
1484 if (MyResident /*&&
1485 (MyResident->rt_Type == NT_LIBRARY ||
1486 MyResident->rt_Type == NT_DEVICE)*/)
1487 {
1488 error = createresidentver(MyResident);
1489 }
1490
1491 UnLoadSeg(file);
1492 }
1493 file = NULL;
1494
1495 if (error != RETURN_OK)
1496 {
1497 /* If user didn't ask for md5sum or we could not calculate it.
1498 */
1499 if (!args.arg_md5sum || (!(parsedver.pv_flags & PVF_MD5SUM)))
1500 {
1501 Printf("Could not find version information for '%s'\n", (LONG) name);
1502 }
1503 }
1504 }
1505 }
1506 else
1507 {
1508 PrintFault(IoErr(), (STRPTR) ERROR_HEADER);
1509 }
1510
1511 FreeMem(buffer, BUFFERSIZE);
1512 }
1513 else
1514 {
1515 error = RETURN_FAIL;
1516 PrintFault(IoErr(), (STRPTR) ERROR_HEADER);
1517 }
1518
1519 if (file)
1520 Close(file);
1521 }
1522 else
1523 {
1524 LONG ioerr = IoErr();
1525
1526 if (ioerr == ERROR_OBJECT_NOT_FOUND ||
1527 ioerr == ERROR_OBJECT_WRONG_TYPE)
1528 {
1529 error = -1;
1530 }
1531 else
1532 {
1533 PrintFault(IoErr(), (STRPTR) ERROR_HEADER);
1534 error = RETURN_FAIL;
1535 }
1536 }
1537
1538 return error;
1539 }
1540
1541
1542 static
1543 int makerescmdver(CONST_STRPTR name)
1544 {
1545 int error = -1;
1546 struct Segment *segment;
1547
1548 Forbid();
1549
1550 segment = FindSegment((STRPTR) name, NULL, 0);
1551 if (!segment)
1552 {
1553 segment = FindSegment((STRPTR) name, NULL, 1);
1554 }
1555
1556 if (segment)
1557 {
1558 if (segment->seg_UC == CMD_INTERNAL ||
1559 segment->seg_UC == CMD_DISABLED)
1560 {
1561 Permit();
1562 error = makeresidentver("shell");
1563 Forbid();
1564 }
1565 else
1566 {
1567 STRPTR buffer = FindSegmentVER(segment->seg_Seg);
1568 if (buffer)
1569 {
1570 STRPTR startbuffer;
1571
1572 startbuffer = skipwhites(buffer);
1573
1574 //Printf("startbuffer \"%s\"\n", (LONG) startbuffer);
1575 error = makedatafromstring(startbuffer);
1576
1577 FreeVec(buffer);
1578 }
1579 }
1580 }
1581
1582 Permit();
1583
1584 return error;
1585 }
1586
1587 static
1588 int setvervar(CONST_STRPTR name, LONG ver, LONG rev)
1589 {
1590 UBYTE buf[32];
1591
1592 sprintf(buf, "%ld.%ld", (LONG) ver, (LONG) rev);
1593
1594 return SetVar((STRPTR) name, buf, -1, GVF_LOCAL_ONLY | LV_VAR) ? RETURN_OK : -1;
1595 }
1596
1597
1598 static
1599 int makekickversion(void)
1600 {
1601 parsedver.pv_version = SysBase->LibNode.lib_Version;
1602 parsedver.pv_revision = SysBase->SoftVer;
1603
1604 setvervar("Kickstart",
1605 parsedver.pv_version,
1606 parsedver.pv_revision);
1607
1608 Printf("Kickstart %ld.%ld",
1609 (LONG) parsedver.pv_version, (LONG) parsedver.pv_revision);
1610
1611 return RETURN_OK;
1612 }
1613
1614
1615 static
1616 int makewbversion(void)
1617 {
1618 int error = -1;
1619 struct Library *VersionBase;
1620
1621 VersionBase = OpenLibrary("version.library", 0);
1622 if (VersionBase)
1623 {
1624 error = makeexeclistver(&SysBase->LibList, "version.library");
1625
1626 if (error == RETURN_OK)
1627 {
1628 STRPTR newname = dupstr("Workbench", -1);
1629 if (newname)
1630 {
1631 FreeVec(parsedver.pv_name);
1632 parsedver.pv_name = newname;
1633 }
1634 setvervar("Workbench", parsedver.pv_version, parsedver.pv_revision);
1635 }
1636
1637 CloseLibrary(VersionBase);
1638 }
1639
1640 return error;
1641 }
1642
1643
1644 static
1645 int makesysver(void)
1646 {
1647 int error;
1648
1649 error = makekickversion();
1650 if (error == RETURN_OK)
1651 {
1652 error = makewbversion();
1653
1654 if (error == RETURN_OK)
1655 {
1656 PutStr(", ");
1657 }
1658 else
1659 {
1660 /* prevent silly errormsg if no version.library */
1661 PutStr("\n");
1662 error = RETURN_WARN;
1663 }
1664 }
1665
1666 return error;
1667 }
1668
1669
1670 /* Determine, by which means to get the version-string.
1671 */
1672 static
1673 int makeverstring(CONST_STRPTR name)
1674 {
1675 int error; // = RETURN_OK;
1676 BOOL volume = name[strlen(name) - 1] == ':';
1677 CONST_STRPTR filepart = FilePart(name);
1678
1679 error = -1;
1680
1681 if (!volume && !args.arg_file)
1682 {
1683 if (*filepart)
1684 {
1685 error = makeresidentver(filepart);
1686 if (error != RETURN_OK)
1687 {
1688
1689 /* Try libraries
1690 */
1691 error = makeexeclistver(&SysBase->LibList, filepart);
1692 if (error != RETURN_OK)
1693 {
1694 STRPTR namebuf;
1695 ULONG namelen = strlen(filepart);
1696
1697 /* 12 is "MOSSYS:LIBS/" */
1698 if ((namebuf = AllocVec(12 + namelen + 4 + 1, MEMF_PUBLIC)))
1699 {
1700 strcpy(namebuf, "LIBS:");
1701 strcat(namebuf, filepart);
1702 error = makefilever(namebuf);
1703
1704 /* Try devices
1705 */
1706 if (error != RETURN_OK)
1707 {
1708 error = makeexeclistver(&SysBase->DeviceList, filepart);
1709 if (error != RETURN_OK)
1710 {
1711 strcpy(namebuf, "DEVS:");
1712 strcat(namebuf, filepart);
1713 error = makefilever(namebuf);
1714 }
1715 }
1716 FreeVec(namebuf);
1717 }
1718 }
1719 }
1720 }
1721 }
1722
1723 if (!args.arg_res && error == -1)
1724 {
1725 if (volume)
1726 {
1727 error = makedevicever(name);
1728 }
1729 else
1730 {
1731 if (*filepart)
1732 {
1733 error = makefilever(name);
1734 }
1735 }
1736 }
1737
1738 if (!args.arg_file && error == -1)
1739 {
1740 error = makerescmdver(name);
1741 }
1742
1743 if (error)
1744 {
1745 /* If user asked for md5sum, and we could calculate it, don't print error
1746 * but the md5sum + file.
1747 */
1748 if (args.arg_md5sum && (parsedver.pv_flags & PVF_MD5SUM))
1749 {
1750 parsedver.pv_name = dupstr(name, -1);
1751 parsedver.pv_flags |= PVF_NOVERSION;
1752 error = RETURN_OK;
1753 }
1754 }
1755
1756 if (error == -1)
1757 {
1758 PrintFault(ERROR_OBJECT_NOT_FOUND, (STRPTR) ERROR_HEADER);
1759 error = RETURN_FAIL;
1760 }
1761
1762 return error;
1763 }
1764
1765
1766 static
1767 void freeverstring(void)
1768 {
1769 parsedver.pv_flags = 0;
1770 parsedver.pv_version = 0;
1771 parsedver.pv_revision = 0;
1772
1773 FreeVec(parsedver.pv_extrastr);
1774 parsedver.pv_extrastr = NULL;
1775 parsedver.pv_extralf = NULL;
1776 FreeVec(parsedver.pv_datestr);
1777 parsedver.pv_datestr = NULL;
1778 FreeVec(parsedver.pv_revname);
1779 parsedver.pv_revname = NULL;
1780 FreeVec(parsedver.pv_vername);
1781 parsedver.pv_vername = NULL;
1782 FreeVec(parsedver.pv_name);
1783 parsedver.pv_name = NULL;
1784 }
1785
1786 /* Compare the version given as argument with the version from the object.
1787 * Return RETURN_WARN, if args-v>object-v, otherwise return RETURN_OK.
1788 */
1789 static
1790 int cmpargsparsed(void)
1791 {
1792 if (args.arg_version)
1793 {
1794 if (*(args.arg_version) > parsedver.pv_version)
1795 {
1796 return RETURN_WARN;
1797 }
1798 else if (*(args.arg_version) == parsedver.pv_version && args.arg_revision)
1799 {
1800 if (*(args.arg_revision) > parsedver.pv_revision)
1801 {
1802 return RETURN_WARN;
1803 }
1804 }
1805 }
1806 else if (args.arg_revision)
1807 {
1808 if (*(args.arg_revision) > parsedver.pv_revision)
1809 {
1810 return RETURN_WARN;
1811 }
1812 }
1813 return RETURN_OK;
1814 }
1815
1816 /******************************* main program ****************************/
1817
1818 int __nocommandline;
1819
1820 int main (void)
1821 {
1822 LONG error = RETURN_FAIL;
1823
1824 struct RDArgs *rda;
1825
1826 rda = ReadArgs(TEMPLATE, (IPTR *) &args, NULL);
1827 if (rda)
1828 {
1829 if (!args.arg_name || !*args.arg_name)
1830 {
1831 /* No args, make system version */
1832 error = makesysver();
1833 if (error == RETURN_OK)
1834 {
1835 printverstring();
1836 if (parsedver.pv_flags & PVF_NOVERSION)
1837 {
1838 error = RETURN_FAIL;
1839 }
1840 if (error == RETURN_OK)
1841 {
1842 error = cmpargsparsed();
1843 }
1844 }
1845 freeverstring();
1846 }
1847 else
1848 {
1849 CONST_STRPTR *name;
1850 BOOL multifile;
1851 #if 1
1852 /* Workaround for:
1853 * version file ver
1854 * version file ver rev
1855 */
1856 if (!args.arg_version && !args.arg_revision)
1857 {
1858 LONG narg = 1;
1859 while (args.arg_name[narg]) { narg++; }
1860 if (narg == 2 || narg == 3)
1861 {
1862 if (StrToLong(args.arg_name[1], &mversion) > 0)
1863 {
1864 args.arg_version = &mversion;
1865 args.arg_name[1] = args.arg_name[2];
1866 if (narg == 3)
1867 {
1868 args.arg_name[2] = NULL;
1869 }
1870 if (narg == 3)
1871 {
1872 if (StrToLong(args.arg_name[1], &mrevision) > 0)
1873 {
1874 args.arg_revision = &mrevision;
1875 args.arg_name[1] = NULL;
1876 }
1877 }
1878 }
1879 }
1880 }
1881 #endif
1882 multifile = args.arg_name[1] != NULL;
1883
1884 for (name = args.arg_name; *name; name++)
1885 {
1886 error = makeverstring(*name);
1887 if (error == RETURN_OK)
1888 {
1889 printverstring();
1890
1891 if (!multifile)
1892 {
1893 /* Single args, do compare stuff also */
1894 if (parsedver.pv_flags & PVF_NOVERSION)
1895 {
1896 error = RETURN_FAIL;
1897 }
1898 if (error == RETURN_OK)
1899 {
1900 error = cmpargsparsed();
1901 }
1902 }
1903 }
1904 freeverstring();
1905
1906 }
1907 }
1908
1909 FreeArgs(rda);
1910 }
1911 else
1912 {
1913 PrintFault(IoErr(), (STRPTR) ERROR_HEADER);
1914 error = RETURN_FAIL;
1915 }
1916
1917 RT_Exit();
1918
1919 return(error);
1920 }
A totally sweet operating system