basex/basex.c

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