basex/basex.c

/*
 * version 1.5  2001-06-26
 *   slightly more robust
 *   "compression" levels
 *   '-I' for decode
 *   '-n' option
 *   ident strings can not contain whitespace
 * version 1.4  2001-06-24
 * version 1.3  1999-09-12
 * version 1.2  1995-03-01
 * version 1.1  1995-05-30
 * version 1.0  1994-12-13
 *
 * remember to transfer files with
 * Content-Encoding: 8bit
 * Content-Transfer-Encoding: 8bit
 *
 * this is written in ISO-C89
 * + getopt (e.g. -D_POSIX_C_SOURCE=2)
 *
 * basex -v -i "id" <input >output
 * basex -d -I -v <input >output
 *
 * -V           show version
 * -d           decode
 * -v           verbose
 * -i <id>      use identifier id
 * -I           print id to stderr on decryption
 * -n           do NOT create output
 * -1           VERY conservative
 * -5           rather conservative (almost rfc2822)
 * -7           non-rfc2822, but should work (default)
 * -9           maximum level (not that much better)
 *
 * ESCAPE -> ESCAPE 'A'
 * 0x00   -> ESCAPE 'B'
 * 0x0a   -> ESCAPE 'C'
 * 0x0d   -> ESCAPE 'D'
 * ESCAPE x, x != A-D unchanged
 *
 * uses adler32 checksum
 */

/* next include is for getopt only */
#include <unistd.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXLINE (60000+3)
#define ESCAPE  0xff
#define MAXBLK  5000000L                /* max. blksize on decode */
#define ID1     "BASEX ENCODED DATA"    /* file header */
#define ID2     "X"                     /* control header */
#define ID3     '|'                     /* data header */

char version[] = "basex version 1.5 - 2001-06-26";

typedef unsigned long u32;              /* 4 byte unsigned int */
typedef unsigned char u8;               /* 1 byte unsigned int */

int verbose   = 0;
int showident = 0;
int complevel = 7;
int nooutput  = 0;

int linelen;
int blklen;

extern char *optarg;
/*extern int optind, opterr, optopt; */

u32
adler32 (u8 * data, int len)
{
  u32 s1 = 1;
  u32 s2 = 0;
  u32 modulo = 65521;

  while (--len)
    {
      s1 += *data++;
      if (s1 >= modulo)
        s1 -= modulo;
        
      s2 += s1;
      if (s2 >= modulo)
        s2 -= modulo;
      
    };
  return (s2 << 16) + s1;
}

void
out_char (FILE * o, int code)
{
  static char line[MAXLINE + 1];
  static int llen = 0;

  if (code == -2)
    {
      if (llen)
        {
          line[llen] = 0;
          if (!nooutput)
            fprintf (o, "%c%s\n", ID3, line);
        }
    }
  else if (code == -1)
    {
      llen = 0;
    }
  else
    {
      line[llen++] = code;
      if (llen >= linelen)
        {
          llen = 0;
          line[linelen] = 0;
          if (!nooutput)
            fprintf (o, "%c%s\n", ID3, line);
        }
    }
}

int
encode (FILE * i, FILE * o, char *id)
{
  u8 *block;
  long blklen;
  int len;

  if (complevel <= 1)
    {
      linelen = 120;
      blklen  = 50000;
    }
  else if (complevel <= 5)
    {
      linelen = 996;
      blklen  = 50000;
    }
  else if (complevel <= 7)
    {
      linelen = 7996;
      blklen  = 50000;
    }
  else
    {
      linelen = 60000;
      blklen  = 5000000;
    }

  block = malloc (blklen);

  if (!block)
    {
      fprintf (stderr, "unable to allocate %ld bytes", blklen * 2);
      return 11;
    }

  if (!nooutput)
    {
      fprintf (o, "%s\n", ID1);
      fprintf (o, "%s VERSION 2\n", ID2);
      if (id)
        fprintf (o, "%s IDENT %s\n", ID2, id);
    }
  
  /*fprintf (o, "%s CODEC AFE0C0DE\n", ID2);*/ /* default */
  while ((len = fread (block, 1, blklen, i)) > 0)
    {
      u32 sum = adler32 (block, len);
      u8 *p = block;

      if (!nooutput)
        fprintf (o, "%s BLOCK %d %08lx\n", ID2, len, sum);

      out_char (o, -1);
      while (len--)
        {
          int c = *p++ ^ (u8) sum++;

          if (c == ESCAPE)
            {
              out_char (o, ESCAPE);
              if (len)
                {
                  switch (*p ^ (u8) sum)
                    {
                      case 'A':
                      case 'B':
                      case 'C':
                      case 'D':
                        out_char (o, 'A');
                        break;
                      default:
                        /* nothing */;
                    }
                }
              else
                out_char (o, 'A');
            }
          else if (c == 0x00)
            {
              out_char (o, ESCAPE);
              out_char (o, 'B');
            }
          else if (c == 0x0a)
            {
              out_char (o, ESCAPE);
              out_char (o, 'C');
            }
          else if (c == 0x0d)
            {
              out_char (o, ESCAPE);
              out_char (o, 'D');
            }
          else
            {
              out_char (o, c);
            }
        }
      
      out_char (o, -2);
    }
  
  if (!nooutput)
    fprintf (o, "%s END\n", ID2);

  free (block);

  return 0;
}

int
in_char (FILE * i, int code)
{
  static int llen;
  static char line[MAXLINE + 3];

  if (code == -1)
    {
      llen = MAXLINE + 1;
      return 0;
    }
  else
    {
      if (llen > MAXLINE
          || line[llen] == 0
          || line[llen] == '\r'
          || line[llen] == '\n')
        {
          do {
            if (!fgets (line, sizeof (line), i))
              {
                perror ("error on block read (file truncated?)");
                return -1;
              }
          } while (line[0] != ID3);

          llen = 1;
        }
      
      return (unsigned char) line[llen++];
    }
}

int
decodeblock (FILE * i, u8 * data, int len, int sum)
{
  int ch;

  (void) in_char (i, -1);

  while (len--)
    {
      ch = in_char (i, 0);
      if (ch < 0)
        return 8;
      
retry:
      if (ch == ESCAPE)
        {
          switch ((ch = in_char (i, 0)))
            {
              case 'A': ch = ESCAPE; break;
              case 'B': ch = 0x00;   break;
              case 'C': ch = 0x0a;   break;
              case 'D': ch = 0x0d;   break;
              
              default:
                *data++ = (u8) ESCAPE ^ (u8) sum++; len--;
                goto retry;
            }
        }
      
      *data++ = (u8) ch ^ (u8) sum++;
    }

  return 0;
}

int
decode (FILE * i, FILE * o)
{
  char input[255];
  char *opt = input + sizeof (ID2) - 1 + 1;
  long blklen;
  int err;
  u32 sum, sum2;

  u32 codec = 0xafe1c0de;
  int version = 0;
  char ident[255];

  ident[0] = 0;

  do
    {
      if (!fgets (input, sizeof (input), i))
        {
          perror ("unable to find start of encoded data");
          return 1;
        }
    }
  while (strncmp (input, ID1, sizeof (ID1) - 1));

  if (verbose)
    fprintf (stderr, "basex header found, processing options\n");

  for (;;)
    {
      if (!fgets (input, sizeof (input), i))
        {
          perror ("error while processing options");
          return 2;
        }
      
      if (strncmp (input, ID2, sizeof (ID2) - 1) || *(opt - 1) != ' ')
        {
          fprintf (stderr, "garbage instead of option, ignored\n");
        }
      else
        {
          if (sscanf (opt, "VERSION %d\n", &version) == 1)
            {
              if (verbose)
                fprintf (stderr, "option version %d\n", version);
              
              if (version != 2)
                {
                  fprintf (stderr, "unsupported version %d\n", version);
                  return 5;
                }
            }
          else if (sscanf (opt, "CODEC %8lx\n", &codec) == 1)
            {
              if (verbose)
                fprintf (stderr, "option codec %lx\n", codec);
            }
          else if (sscanf (opt, "IDENT %[^\n]\n", ident) == 1)
            {
              if (verbose || showident)
                fprintf (stderr, "option ident %s\n", ident);
            }
          else if (strcmp (opt, "END\n") == 0)
            {
              if (verbose)
                fprintf (stderr, "option end\n");
              
              return 0;
            }
          else if (sscanf (opt, "BLOCK %ld %08lx\n", &blklen, &sum) == 2)
            {
              u8 *block;

              if (verbose)
                fprintf (stderr, "option block len %ld, checksum %08lx\n", blklen, sum);
              
              if (blklen > MAXBLK)
                {
                  fprintf (stderr, "block length too large (%ld>%ld)\n", blklen, MAXBLK);
                  return 4;
                }

              switch (codec)
                {
                  case 0xafe1c0de:

                    block = malloc (blklen);

                    if (!block)
                      {
                        fprintf (stderr, "unable to allocate %ld bytes", blklen);
                        return 11;
                      }
                
                    err = decodeblock (i, block, blklen, sum);
                    if (err)
                      return err;
                    
                    sum2 = adler32 (block, blklen);
                    if (sum != sum2)
                      {
                        fprintf (stderr, "checksumming error %08lx != %08lx\n", sum, sum2);
                        return 9;
                      }
                    
                    if (!nooutput && fwrite (block, blklen, 1, o) <= 0)
                      {
                        perror ("write error");
                        return 10;
                      }

                    free (block);
                    break;
                  
                  default:
                    fprintf (stderr, "unknown codec %08lx\n", codec);
                    return 3;
                }
            }
          else
            {
              fprintf (stderr, "unknown or unrecognized option %s\n", opt);
              return 2;
            }
        }
    }
}

int
main (int argc, char *argv[])
{
  int dec = 0;
  char *id = 0;

  for (;;)
    {
      int c = getopt (argc, argv, "Vvdi:In123456789");

      if (c == EOF)
        break;

      switch (c)
        {
          case 'V':
            puts (version);
            exit (EXIT_SUCCESS);
            break;

          case 'v':
            verbose = 1;
            break;
          
          case 'd':
            dec = 1;
            break;
          
          case 'i':
            id = optarg;
            break;

          case 'I':
            showident = 1;
            break;

          case 'n':
            nooutput = 1;
            break;

          case '1':
          case '2':
          case '3':
          case '4':
            complevel = 1;
            break;
          case '5':
          case '6':
            complevel = 5;
            break;
          case '7':
          case '8':
            complevel = 7;
            break;
          case '9':
            complevel = 9;
            break;
          
          case '?':
            fprintf (stderr, "encode: basex [-v] [-n] [-i id] [-1 | -5 | -7 | -9]\n");
            fprintf (stderr, "decode: basex [-d] [-v] [-n] [-I]\n");
            break;
        }
    }

  if (verbose)
    fprintf (stderr, "mode %s\n", dec ? "decoding" : "encoding");

  if (dec)
    return decode (stdin, stdout);
  else
    return encode (stdin, stdout, id);
}

Revision:	1.2
Committed:	Sun Sep 23 21:18:52 2001 UTC (23 years ago) by root
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+7 -6 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/*
2			* version 1.5 2001-06-26
3	root	1.2	* slightly more robust
4			* "compression" levels
5			* '-I' for decode
6			* '-n' option
7			* ident strings can not contain whitespace
8	root	1.1	* version 1.4 2001-06-24
9			* version 1.3 1999-09-12
10			* version 1.2 1995-03-01
11			* version 1.1 1995-05-30
12			* version 1.0 1994-12-13
13			*
14			* remember to transfer files with
15			* Content-Encoding: 8bit
16			* Content-Transfer-Encoding: 8bit
17			*
18			* this is written in ISO-C89
19			* + getopt (e.g. -D_POSIX_C_SOURCE=2)
20			*
21			* basex -v -i "id" <input >output
22			* basex -d -I -v <input >output
23			*
24			* -V show version
25			* -d decode
26			* -v verbose
27			* -i <id> use identifier id
28			* -I print id to stderr on decryption
29			* -n do NOT create output
30			* -1 VERY conservative
31			* -5 rather conservative (almost rfc2822)
32			* -7 non-rfc2822, but should work (default)
33			* -9 maximum level (not that much better)
34			*
35			* ESCAPE -> ESCAPE 'A'
36			* 0x00 -> ESCAPE 'B'
37			* 0x0a -> ESCAPE 'C'
38			* 0x0d -> ESCAPE 'D'
39			* ESCAPE x, x != A-D unchanged
40			*
41			* uses adler32 checksum
42			*/
43
44			/* next include is for getopt only */
45			#include <unistd.h>
46
47			#include <stdio.h>
48			#include <stdlib.h>
49			#include <string.h>
50
51			#define MAXLINE (60000+3)
52			#define ESCAPE 0xff
53			#define MAXBLK 5000000L /* max. blksize on decode */
54			#define ID1 "BASEX ENCODED DATA" /* file header */
55			#define ID2 "X" /* control header */
56			#define ID3 '\|' /* data header */
57
58			char version[] = "basex version 1.5 - 2001-06-26";
59
60			typedef unsigned long u32; /* 4 byte unsigned int */
61			typedef unsigned char u8; /* 1 byte unsigned int */
62
63			int verbose = 0;
64			int showident = 0;
65			int complevel = 7;
66			int nooutput = 0;
67
68			int linelen;
69			int blklen;
70
71			extern char *optarg;
72			/extern int optind, opterr, optopt; /
73
74			u32
75			adler32 (u8 * data, int len)
76			{
77			u32 s1 = 1;
78			u32 s2 = 0;
79			u32 modulo = 65521;
80
81			while (--len)
82			{
83			s1 += *data++;
84			if (s1 >= modulo)
85			s1 -= modulo;
86
87			s2 += s1;
88			if (s2 >= modulo)
89			s2 -= modulo;
90
91			};
92			return (s2 << 16) + s1;
93			}
94
95			void
96			out_char (FILE * o, int code)
97			{
98			static char line[MAXLINE + 1];
99			static int llen = 0;
100
101			if (code == -2)
102			{
103			if (llen)
104			{
105			line[llen] = 0;
106			if (!nooutput)
107			fprintf (o, "%c%s\n", ID3, line);
108			}
109			}
110			else if (code == -1)
111			{
112			llen = 0;
113			}
114			else
115			{
116			line[llen++] = code;
117			if (llen >= linelen)
118			{
119			llen = 0;
120			line[linelen] = 0;
121			if (!nooutput)
122			fprintf (o, "%c%s\n", ID3, line);
123			}
124			}
125			}
126
127			int
128			encode (FILE * i, FILE * o, char *id)
129			{
130			u8 *block;
131			long blklen;
132			int len;
133
134			if (complevel <= 1)
135			{
136			linelen = 120;
137			blklen = 50000;
138			}
139			else if (complevel <= 5)
140			{
141			linelen = 996;
142			blklen = 50000;
143			}
144			else if (complevel <= 7)
145			{
146			linelen = 7996;
147			blklen = 50000;
148			}
149			else
150			{
151			linelen = 60000;
152			blklen = 5000000;
153			}
154
155			block = malloc (blklen);
156
157			if (!block)
158			{
159			fprintf (stderr, "unable to allocate %ld bytes", blklen * 2);
160			return 11;
161			}
162
163			if (!nooutput)
164			{
165			fprintf (o, "%s\n", ID1);
166			fprintf (o, "%s VERSION 2\n", ID2);
167			if (id)
168			fprintf (o, "%s IDENT %s\n", ID2, id);
169			}
170
171			/fprintf (o, "%s CODEC AFE0C0DE\n", ID2);/ /* default */
172			while ((len = fread (block, 1, blklen, i)) > 0)
173			{
174			u32 sum = adler32 (block, len);
175			u8 *p = block;
176
177			if (!nooutput)
178			fprintf (o, "%s BLOCK %d %08lx\n", ID2, len, sum);
179
180			out_char (o, -1);
181			while (len--)
182			{
183			int c = *p++ ^ (u8) sum++;
184
185			if (c == ESCAPE)
186			{
187			out_char (o, ESCAPE);
188			if (len)
189			{
190			switch (*p ^ (u8) sum)
191			{
192			case 'A':
193			case 'B':
194			case 'C':
195			case 'D':
196			out_char (o, 'A');
197			break;
198			default:
199			/* nothing */;
200			}
201			}
202			else
203			out_char (o, 'A');
204			}
205			else if (c == 0x00)
206			{
207			out_char (o, ESCAPE);
208			out_char (o, 'B');
209			}
210			else if (c == 0x0a)
211			{
212			out_char (o, ESCAPE);
213			out_char (o, 'C');
214			}
215			else if (c == 0x0d)
216			{
217			out_char (o, ESCAPE);
218			out_char (o, 'D');
219			}
220			else
221			{
222			out_char (o, c);
223			}
224			}
225
226			out_char (o, -2);
227			}
228
229			if (!nooutput)
230			fprintf (o, "%s END\n", ID2);
231
232			free (block);
233
234			return 0;
235			}
236
237			int
238			in_char (FILE * i, int code)
239			{
240			static int llen;
241			static char line[MAXLINE + 3];
242
243			if (code == -1)
244			{
245			llen = MAXLINE + 1;
246			return 0;
247			}
248			else
249			{
250			if (llen > MAXLINE
251			\|\| line[llen] == 0
252			\|\| line[llen] == '\r'
253			\|\| line[llen] == '\n')
254			{
255			do {
256			if (!fgets (line, sizeof (line), i))
257			{
258			perror ("error on block read (file truncated?)");
259			return -1;
260			}
261			} while (line[0] != ID3);
262
263			llen = 1;
264			}
265
266			return (unsigned char) line[llen++];
267			}
268			}
269
270			int
271			decodeblock (FILE * i, u8 * data, int len, int sum)
272			{
273			int ch;
274
275			(void) in_char (i, -1);
276
277			while (len--)
278			{
279			ch = in_char (i, 0);
280			if (ch < 0)
281			return 8;
282
283			retry:
284			if (ch == ESCAPE)
285			{
286			switch ((ch = in_char (i, 0)))
287			{
288			case 'A': ch = ESCAPE; break;
289			case 'B': ch = 0x00; break;
290			case 'C': ch = 0x0a; break;
291			case 'D': ch = 0x0d; break;
292
293			default:
294			*data++ = (u8) ESCAPE ^ (u8) sum++; len--;
295			goto retry;
296			}
297			}
298
299			*data++ = (u8) ch ^ (u8) sum++;
300			}
301
302			return 0;
303			}
304
305			int
306			decode (FILE * i, FILE * o)
307			{
308			char input[255];
309			char *opt = input + sizeof (ID2) - 1 + 1;
310			long blklen;
311			int err;
312			u32 sum, sum2;
313
314			u32 codec = 0xafe1c0de;
315			int version = 0;
316			char ident[255];
317
318			ident[0] = 0;
319
320			do
321			{
322			if (!fgets (input, sizeof (input), i))
323			{
324			perror ("unable to find start of encoded data");
325			return 1;
326			}
327			}
328			while (strncmp (input, ID1, sizeof (ID1) - 1));
329
330			if (verbose)
331			fprintf (stderr, "basex header found, processing options\n");
332
333			for (;;)
334			{
335			if (!fgets (input, sizeof (input), i))
336			{
337			perror ("error while processing options");
338			return 2;
339			}
340
341			if (strncmp (input, ID2, sizeof (ID2) - 1) \|\| *(opt - 1) != ' ')
342			{
343			fprintf (stderr, "garbage instead of option, ignored\n");
344			}
345			else
346			{
347			if (sscanf (opt, "VERSION %d\n", &version) == 1)
348			{
349			if (verbose)
350			fprintf (stderr, "option version %d\n", version);
351
352			if (version != 2)
353			{
354			fprintf (stderr, "unsupported version %d\n", version);
355			return 5;
356			}
357			}
358			else if (sscanf (opt, "CODEC %8lx\n", &codec) == 1)
359			{
360			if (verbose)
361			fprintf (stderr, "option codec %lx\n", codec);
362			}
363	root	1.2	else if (sscanf (opt, "IDENT %[^\n]\n", ident) == 1)
364	root	1.1	{
365			if (verbose \|\| showident)
366			fprintf (stderr, "option ident %s\n", ident);
367			}
368			else if (strcmp (opt, "END\n") == 0)
369			{
370			if (verbose)
371			fprintf (stderr, "option end\n");
372
373			return 0;
374			}
375			else if (sscanf (opt, "BLOCK %ld %08lx\n", &blklen, &sum) == 2)
376			{
377			u8 *block;
378
379			if (verbose)
380			fprintf (stderr, "option block len %ld, checksum %08lx\n", blklen, sum);
381
382			if (blklen > MAXBLK)
383			{
384			fprintf (stderr, "block length too large (%ld>%ld)\n", blklen, MAXBLK);
385			return 4;
386			}
387
388			switch (codec)
389			{
390			case 0xafe1c0de:
391
392			block = malloc (blklen);
393
394			if (!block)
395			{
396			fprintf (stderr, "unable to allocate %ld bytes", blklen);
397			return 11;
398			}
399
400			err = decodeblock (i, block, blklen, sum);
401			if (err)
402			return err;
403
404			sum2 = adler32 (block, blklen);
405			if (sum != sum2)
406			{
407			fprintf (stderr, "checksumming error %08lx != %08lx\n", sum, sum2);
408			return 9;
409			}
410
411			if (!nooutput && fwrite (block, blklen, 1, o) <= 0)
412			{
413			perror ("write error");
414			return 10;
415			}
416
417			free (block);
418			break;
419
420			default:
421			fprintf (stderr, "unknown codec %08lx\n", codec);
422			return 3;
423			}
424			}
425			else
426			{
427			fprintf (stderr, "unknown or unrecognized option %s\n", opt);
428			return 2;
429			}
430			}
431			}
432			}
433
434			int
435			main (int argc, char *argv[])
436			{
437			int dec = 0;
438			char *id = 0;
439
440			for (;;)
441			{
442			int c = getopt (argc, argv, "Vvdi:In123456789");
443
444			if (c == EOF)
445			break;
446
447			switch (c)
448			{
449			case 'V':
450			puts (version);
451			exit (EXIT_SUCCESS);
452			break;
453
454			case 'v':
455			verbose = 1;
456			break;
457
458			case 'd':
459			dec = 1;
460			break;
461
462			case 'i':
463			id = optarg;
464			break;
465
466			case 'I':
467			showident = 1;
468			break;
469
470			case 'n':
471			nooutput = 1;
472			break;
473
474			case '1':
475			case '2':
476			case '3':
477			case '4':
478			complevel = 1;
479			break;
480			case '5':
481			case '6':
482			complevel = 5;
483			break;
484			case '7':
485			case '8':
486			complevel = 7;
487			break;
488			case '9':
489			complevel = 9;
490			break;
491
492			case '?':
493	root	1.2	fprintf (stderr, "encode: basex [-v] [-n] [-i id] [-1 \| -5 \| -7 \| -9]\n");
494	root	1.1	fprintf (stderr, "decode: basex [-d] [-v] [-n] [-I]\n");
495			break;
496			}
497			}
498
499			if (verbose)
500			fprintf (stderr, "mode %s\n", dec ? "decoding" : "encoding");
501
502			if (dec)
503			return decode (stdin, stdout);
504			else
505			return encode (stdin, stdout, id);
506			}
507