contrib/file-4/src/ascmagic.c

   1 /*
   2  * Copyright (c) Ian F. Darwin 1986-1995.
   3  * Software written by Ian F. Darwin and others;
   4  * maintained 1995-present by Christos Zoulas and others.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice immediately at the beginning of the file, without modification,
  11  *    this list of conditions, and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  20  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28 /*
  29  * ASCII magic -- file types that we know based on keywords
  30  * that can appear anywhere in the file.
  31  *
  32  * Extensively modified by Eric Fischer <enf@pobox.com> in July, 2000,
  33  * to handle character codes other than ASCII on a unified basis.
  34  *
  35  * Joerg Wunsch <joerg@freebsd.org> wrote the original support for 8-bit
  36  * international characters, now subsumed into this file.
  37  */
  38
  39 #include "file.h"
  40 #include "magic.h"
  41 #include <stdio.h>
  42 #include <string.h>
  43 #include <memory.h>
  44 #include <ctype.h>
  45 #include <stdlib.h>
  46 #ifdef HAVE_UNISTD_H
  47 #include <unistd.h>
  48 #endif
  49 #include "names.h"
  50
  51 #ifndef lint
  52 FILE_RCSID("@(#)$Id: ascmagic.c,v 1.43 2005/06/25 15:52:14 christos Exp $")
  53 #endif  /* lint */
  54
  55 typedef unsigned long unichar;
  56
  57 #define MAXLINELEN 300  /* longest sane line length */
  58 #define ISSPC(x) ((x) == ' ' || (x) == '\t' || (x) == '\r' || (x) == '\n' \
  59                   || (x) == 0x85 || (x) == '\f')
  60
  61 private int looks_ascii(const unsigned char *, size_t, unichar *, size_t *);
  62 private int looks_utf8(const unsigned char *, size_t, unichar *, size_t *);
  63 private int looks_unicode(const unsigned char *, size_t, unichar *, size_t *);
  64 private int looks_latin1(const unsigned char *, size_t, unichar *, size_t *);
  65 private int looks_extended(const unsigned char *, size_t, unichar *, size_t *);
  66 private void from_ebcdic(const unsigned char *, size_t, unsigned char *);
  67 private int ascmatch(const unsigned char *, const unichar *, size_t);
  68
  69
  70 protected int
  71 file_ascmagic(struct magic_set *ms, const unsigned char *buf, size_t nbytes)
  72 {
  73         size_t i;
  74         unsigned char *nbuf = NULL;
  75         unichar *ubuf = NULL;
  76         size_t ulen;
  77         struct names *p;
  78         int rv = -1;
  79
  80         const char *code = NULL;
  81         const char *code_mime = NULL;
  82         const char *type = NULL;
  83         const char *subtype = NULL;
  84         const char *subtype_mime = NULL;
  85
  86         int has_escapes = 0;
  87         int has_backspace = 0;
  88         int seen_cr = 0;
  89
  90         int n_crlf = 0;
  91         int n_lf = 0;
  92         int n_cr = 0;
  93         int n_nel = 0;
  94
  95         int last_line_end = -1;
  96         int has_long_lines = 0;
  97
  98         /*
  99          * Undo the NUL-termination kindly provided by process()
 100          * but leave at least one byte to look at
 101          */
 102         while (nbytes > 1 && buf[nbytes - 1] == '\0')
 103                 nbytes--;
 104
 105         if ((nbuf = malloc((nbytes + 1) * sizeof(nbuf[0]))) == NULL)
 106                 goto done;
 107         if ((ubuf = malloc((nbytes + 1) * sizeof(ubuf[0]))) == NULL)
 108                 goto done;
 109
 110         /*
 111          * Then try to determine whether it's any character code we can
 112          * identify.  Each of these tests, if it succeeds, will leave
 113          * the text converted into one-unichar-per-character Unicode in
 114          * ubuf, and the number of characters converted in ulen.
 115          */
 116         if (looks_ascii(buf, nbytes, ubuf, &ulen)) {
 117                 code = "ASCII";
 118                 code_mime = "us-ascii";
 119                 type = "text";
 120         } else if (looks_utf8(buf, nbytes, ubuf, &ulen)) {
 121                 code = "UTF-8 Unicode";
 122                 code_mime = "utf-8";
 123                 type = "text";
 124         } else if ((i = looks_unicode(buf, nbytes, ubuf, &ulen)) != 0) {
 125                 if (i == 1)
 126                         code = "Little-endian UTF-16 Unicode";
 127                 else
 128                         code = "Big-endian UTF-16 Unicode";
 129
 130                 type = "character data";
 131                 code_mime = "utf-16";    /* is this defined? */
 132         } else if (looks_latin1(buf, nbytes, ubuf, &ulen)) {
 133                 code = "ISO-8859";
 134                 type = "text";
 135                 code_mime = "iso-8859-1";
 136         } else if (looks_extended(buf, nbytes, ubuf, &ulen)) {
 137                 code = "Non-ISO extended-ASCII";
 138                 type = "text";
 139                 code_mime = "unknown";
 140         } else {
 141                 from_ebcdic(buf, nbytes, nbuf);
 142
 143                 if (looks_ascii(nbuf, nbytes, ubuf, &ulen)) {
 144                         code = "EBCDIC";
 145                         type = "character data";
 146                         code_mime = "ebcdic";
 147                 } else if (looks_latin1(nbuf, nbytes, ubuf, &ulen)) {
 148                         code = "International EBCDIC";
 149                         type = "character data";
 150                         code_mime = "ebcdic";
 151                 } else {
 152                         rv = 0;
 153                         goto done;  /* doesn't look like text at all */
 154                 }
 155         }
 156
 157         /*
 158          * for troff, look for . + letter + letter or .\";
 159          * this must be done to disambiguate tar archives' ./file
 160          * and other trash from real troff input.
 161          *
 162          * I believe Plan 9 troff allows non-ASCII characters in the names
 163          * of macros, so this test might possibly fail on such a file.
 164          */
 165         if (*ubuf == '.') {
 166                 unichar *tp = ubuf + 1;
 167
 168                 while (ISSPC(*tp))
 169                         ++tp;   /* skip leading whitespace */
 170                 if ((tp[0] == '\\' && tp[1] == '\"') ||
 171                     (isascii((unsigned char)tp[0]) &&
 172                      isalnum((unsigned char)tp[0]) &&
 173                      isascii((unsigned char)tp[1]) &&
 174                      isalnum((unsigned char)tp[1]) &&
 175                      ISSPC(tp[2]))) {
 176                         subtype_mime = "text/troff";
 177                         subtype = "troff or preprocessor input";
 178                         goto subtype_identified;
 179                 }
 180         }
 181
 182         if ((*buf == 'c' || *buf == 'C') && ISSPC(buf[1])) {
 183                 subtype_mime = "text/fortran";
 184                 subtype = "fortran program";
 185                 goto subtype_identified;
 186         }
 187
 188         /* look for tokens from names.h - this is expensive! */
 189
 190         i = 0;
 191         while (i < ulen) {
 192                 size_t end;
 193
 194                 /*
 195                  * skip past any leading space
 196                  */
 197                 while (i < ulen && ISSPC(ubuf[i]))
 198                         i++;
 199                 if (i >= ulen)
 200                         break;
 201
 202                 /*
 203                  * find the next whitespace
 204                  */
 205                 for (end = i + 1; end < nbytes; end++)
 206                         if (ISSPC(ubuf[end]))
 207                                 break;
 208
 209                 /*
 210                  * compare the word thus isolated against the token list
 211                  */
 212                 for (p = names; p < names + NNAMES; p++) {
 213                         if (ascmatch((const unsigned char *)p->name, ubuf + i,
 214                             end - i)) {
 215                                 subtype = types[p->type].human;
 216                                 subtype_mime = types[p->type].mime;
 217                                 goto subtype_identified;
 218                         }
 219                 }
 220
 221                 i = end;
 222         }
 223
 224 subtype_identified:
 225
 226         /*
 227          * Now try to discover other details about the file.
 228          */
 229         for (i = 0; i < ulen; i++) {
 230                 if (ubuf[i] == '\n') {
 231                         if (seen_cr)
 232                                 n_crlf++;
 233                         else
 234                                 n_lf++;
 235                         last_line_end = i;
 236                 } else if (seen_cr)
 237                         n_cr++;
 238
 239                 seen_cr = (ubuf[i] == '\r');
 240                 if (seen_cr)
 241                         last_line_end = i;
 242
 243                 if (ubuf[i] == 0x85) { /* X3.64/ECMA-43 "next line" character */
 244                         n_nel++;
 245                         last_line_end = i;
 246                 }
 247
 248                 /* If this line is _longer_ than MAXLINELEN, remember it. */
 249                 if (i > last_line_end + MAXLINELEN)
 250                         has_long_lines = 1;
 251
 252                 if (ubuf[i] == '\033')
 253                         has_escapes = 1;
 254                 if (ubuf[i] == '\b')
 255                         has_backspace = 1;
 256         }
 257
 258         /* Beware, if the data has been truncated, the final CR could have
 259            been followed by a LF.  If we have HOWMANY bytes, it indicates
 260            that the data might have been truncated, probably even before
 261            this function was called. */
 262         if (seen_cr && nbytes < HOWMANY)
 263                 n_cr++;
 264
 265         if ((ms->flags & MAGIC_MIME)) {
 266                 if (subtype_mime) {
 267                         if (file_printf(ms, subtype_mime) == -1)
 268                                 goto done;
 269                 } else {
 270                         if (file_printf(ms, "text/plain") == -1)
 271                                 goto done;
 272                 }
 273
 274                 if (code_mime) {
 275                         if (file_printf(ms, "; charset=") == -1)
 276                                 goto done;
 277                         if (file_printf(ms, code_mime) == -1)
 278                                 goto done;
 279                 }
 280         } else {
 281                 if (file_printf(ms, code) == -1)
 282                         goto done;
 283
 284                 if (subtype) {
 285                         if (file_printf(ms, " ") == -1)
 286                                 goto done;
 287                         if (file_printf(ms, subtype) == -1)
 288                                 goto done;
 289                 }
 290
 291                 if (file_printf(ms, " ") == -1)
 292                         goto done;
 293                 if (file_printf(ms, type) == -1)
 294                         goto done;
 295
 296                 if (has_long_lines)
 297                         if (file_printf(ms, ", with very long lines") == -1)
 298                                 goto done;
 299
 300                 /*
 301                  * Only report line terminators if we find one other than LF,
 302                  * or if we find none at all.
 303                  */
 304                 if ((n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0) ||
 305                     (n_crlf != 0 || n_cr != 0 || n_nel != 0)) {
 306                         if (file_printf(ms, ", with") == -1)
 307                                 goto done;
 308
 309                         if (n_crlf == 0 && n_cr == 0 && n_nel == 0 && n_lf == 0)                        {
 310                                 if (file_printf(ms, " no") == -1)
 311                                         goto done;
 312                         } else {
 313                                 if (n_crlf) {
 314                                         if (file_printf(ms, " CRLF") == -1)
 315                                                 goto done;
 316                                         if (n_cr || n_lf || n_nel)
 317                                                 if (file_printf(ms, ",") == -1)
 318                                                         goto done;
 319                                 }
 320                                 if (n_cr) {
 321                                         if (file_printf(ms, " CR") == -1)
 322                                                 goto done;
 323                                         if (n_lf || n_nel)
 324                                                 if (file_printf(ms, ",") == -1)
 325                                                         goto done;
 326                                 }
 327                                 if (n_lf) {
 328                                         if (file_printf(ms, " LF") == -1)
 329                                                 goto done;
 330                                         if (n_nel)
 331                                                 if (file_printf(ms, ",") == -1)
 332                                                         goto done;
 333                                 }
 334                                 if (n_nel)
 335                                         if (file_printf(ms, " NEL") == -1)
 336                                                 goto done;
 337                         }
 338
 339                         if (file_printf(ms, " line terminators") == -1)
 340                                 goto done;
 341                 }
 342
 343                 if (has_escapes)
 344                         if (file_printf(ms, ", with escape sequences") == -1)
 345                                 goto done;
 346                 if (has_backspace)
 347                         if (file_printf(ms, ", with overstriking") == -1)
 348                                 goto done;
 349         }
 350         rv = 1;
 351 done:
 352         if (nbuf)
 353                 free(nbuf);
 354         if (ubuf)
 355                 free(ubuf);
 356
 357         return rv;
 358 }
 359
 360 private int
 361 ascmatch(const unsigned char *s, const unichar *us, size_t ulen)
 362 {
 363         size_t i;
 364
 365         for (i = 0; i < ulen; i++) {
 366                 if (s[i] != us[i])
 367                         return 0;
 368         }
 369
 370         if (s[i])
 371                 return 0;
 372         else
 373                 return 1;
 374 }
 375
 376 /*
 377  * This table reflects a particular philosophy about what constitutes
 378  * "text," and there is room for disagreement about it.
 379  *
 380  * Version 3.31 of the file command considered a file to be ASCII if
 381  * each of its characters was approved by either the isascii() or
 382  * isalpha() function.  On most systems, this would mean that any
 383  * file consisting only of characters in the range 0x00 ... 0x7F
 384  * would be called ASCII text, but many systems might reasonably
 385  * consider some characters outside this range to be alphabetic,
 386  * so the file command would call such characters ASCII.  It might
 387  * have been more accurate to call this "considered textual on the
 388  * local system" than "ASCII."
 389  *
 390  * It considered a file to be "International language text" if each
 391  * of its characters was either an ASCII printing character (according
 392  * to the real ASCII standard, not the above test), a character in
 393  * the range 0x80 ... 0xFF, or one of the following control characters:
 394  * backspace, tab, line feed, vertical tab, form feed, carriage return,
 395  * escape.  No attempt was made to determine the language in which files
 396  * of this type were written.
 397  *
 398  *
 399  * The table below considers a file to be ASCII if all of its characters
 400  * are either ASCII printing characters (again, according to the X3.4
 401  * standard, not isascii()) or any of the following controls: bell,
 402  * backspace, tab, line feed, form feed, carriage return, esc, nextline.
 403  *
 404  * I include bell because some programs (particularly shell scripts)
 405  * use it literally, even though it is rare in normal text.  I exclude
 406  * vertical tab because it never seems to be used in real text.  I also
 407  * include, with hesitation, the X3.64/ECMA-43 control nextline (0x85),
 408  * because that's what the dd EBCDIC->ASCII table maps the EBCDIC newline
 409  * character to.  It might be more appropriate to include it in the 8859
 410  * set instead of the ASCII set, but it's got to be included in *something*
 411  * we recognize or EBCDIC files aren't going to be considered textual.
 412  * Some old Unix source files use SO/SI (^N/^O) to shift between Greek
 413  * and Latin characters, so these should possibly be allowed.  But they
 414  * make a real mess on VT100-style displays if they're not paired properly,
 415  * so we are probably better off not calling them text.
 416  *
 417  * A file is considered to be ISO-8859 text if its characters are all
 418  * either ASCII, according to the above definition, or printing characters
 419  * from the ISO-8859 8-bit extension, characters 0xA0 ... 0xFF.
 420  *
 421  * Finally, a file is considered to be international text from some other
 422  * character code if its characters are all either ISO-8859 (according to
 423  * the above definition) or characters in the range 0x80 ... 0x9F, which
 424  * ISO-8859 considers to be control characters but the IBM PC and Macintosh
 425  * consider to be printing characters.
 426  */
 427
 428 #define F 0   /* character never appears in text */
 429 #define T 1   /* character appears in plain ASCII text */
 430 #define I 2   /* character appears in ISO-8859 text */
 431 #define X 3   /* character appears in non-ISO extended ASCII (Mac, IBM PC) */
 432
 433 private char text_chars[256] = {
 434         /*                  BEL BS HT LF    FF CR    */
 435         F, F, F, F, F, F, F, T, T, T, T, F, T, T, F, F,  /* 0x0X */
 436         /*                              ESC          */
 437         F, F, F, F, F, F, F, F, F, F, F, T, F, F, F, F,  /* 0x1X */
 438         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x2X */
 439         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x3X */
 440         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x4X */
 441         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x5X */
 442         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,  /* 0x6X */
 443         T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, F,  /* 0x7X */
 444         /*            NEL                            */
 445         X, X, X, X, X, T, X, X, X, X, X, X, X, X, X, X,  /* 0x8X */
 446         X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X,  /* 0x9X */
 447         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xaX */
 448         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xbX */
 449         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xcX */
 450         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xdX */
 451         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I,  /* 0xeX */
 452         I, I, I, I, I, I, I, I, I, I, I, I, I, I, I, I   /* 0xfX */
 453 };
 454
 455 private int
 456 looks_ascii(const unsigned char *buf, size_t nbytes, unichar *ubuf,
 457     size_t *ulen)
 458 {
 459         int i;
 460
 461         *ulen = 0;
 462
 463         for (i = 0; i < nbytes; i++) {
 464                 int t = text_chars[buf[i]];
 465
 466                 if (t != T)
 467                         return 0;
 468
 469                 ubuf[(*ulen)++] = buf[i];
 470         }
 471
 472         return 1;
 473 }
 474
 475 private int
 476 looks_latin1(const unsigned char *buf, size_t nbytes, unichar *ubuf, size_t *ulen)
 477 {
 478         int i;
 479
 480         *ulen = 0;
 481
 482         for (i = 0; i < nbytes; i++) {
 483                 int t = text_chars[buf[i]];
 484
 485                 if (t != T && t != I)
 486                         return 0;
 487
 488                 ubuf[(*ulen)++] = buf[i];
 489         }
 490
 491         return 1;
 492 }
 493
 494 private int
 495 looks_extended(const unsigned char *buf, size_t nbytes, unichar *ubuf,
 496     size_t *ulen)
 497 {
 498         int i;
 499
 500         *ulen = 0;
 501
 502         for (i = 0; i < nbytes; i++) {
 503                 int t = text_chars[buf[i]];
 504
 505                 if (t != T && t != I && t != X)
 506                         return 0;
 507
 508                 ubuf[(*ulen)++] = buf[i];
 509         }
 510
 511         return 1;
 512 }
 513
 514 private int
 515 looks_utf8(const unsigned char *buf, size_t nbytes, unichar *ubuf, size_t *ulen)
 516 {
 517         int i, n;
 518         unichar c;
 519         int gotone = 0;
 520
 521         *ulen = 0;
 522
 523         for (i = 0; i < nbytes; i++) {
 524                 if ((buf[i] & 0x80) == 0) {        /* 0xxxxxxx is plain ASCII */
 525                         /*
 526                          * Even if the whole file is valid UTF-8 sequences,
 527                          * still reject it if it uses weird control characters.
 528                          */
 529
 530                         if (text_chars[buf[i]] != T)
 531                                 return 0;
 532
 533                         ubuf[(*ulen)++] = buf[i];
 534                 } else if ((buf[i] & 0x40) == 0) { /* 10xxxxxx never 1st byte */
 535                         return 0;
 536                 } else {                           /* 11xxxxxx begins UTF-8 */
 537                         int following;
 538
 539                         if ((buf[i] & 0x20) == 0) {             /* 110xxxxx */
 540                                 c = buf[i] & 0x1f;
 541                                 following = 1;
 542                         } else if ((buf[i] & 0x10) == 0) {      /* 1110xxxx */
 543                                 c = buf[i] & 0x0f;
 544                                 following = 2;
 545                         } else if ((buf[i] & 0x08) == 0) {      /* 11110xxx */
 546                                 c = buf[i] & 0x07;
 547                                 following = 3;
 548                         } else if ((buf[i] & 0x04) == 0) {      /* 111110xx */
 549                                 c = buf[i] & 0x03;
 550                                 following = 4;
 551                         } else if ((buf[i] & 0x02) == 0) {      /* 1111110x */
 552                                 c = buf[i] & 0x01;
 553                                 following = 5;
 554                         } else
 555                                 return 0;
 556
 557                         for (n = 0; n < following; n++) {
 558                                 i++;
 559                                 if (i >= nbytes)
 560                                         goto done;
 561
 562                                 if ((buf[i] & 0x80) == 0 || (buf[i] & 0x40))
 563                                         return 0;
 564
 565                                 c = (c << 6) + (buf[i] & 0x3f);
 566                         }
 567
 568                         ubuf[(*ulen)++] = c;
 569                         gotone = 1;
 570                 }
 571         }
 572 done:
 573         return gotone;   /* don't claim it's UTF-8 if it's all 7-bit */
 574 }
 575
 576 private int
 577 looks_unicode(const unsigned char *buf, size_t nbytes, unichar *ubuf,
 578     size_t *ulen)
 579 {
 580         int bigend;
 581         int i;
 582
 583         if (nbytes < 2)
 584                 return 0;
 585
 586         if (buf[0] == 0xff && buf[1] == 0xfe)
 587                 bigend = 0;
 588         else if (buf[0] == 0xfe && buf[1] == 0xff)
 589                 bigend = 1;
 590         else
 591                 return 0;
 592
 593         *ulen = 0;
 594
 595         for (i = 2; i + 1 < nbytes; i += 2) {
 596                 /* XXX fix to properly handle chars > 65536 */
 597
 598                 if (bigend)
 599                         ubuf[(*ulen)++] = buf[i + 1] + 256 * buf[i];
 600                 else
 601                         ubuf[(*ulen)++] = buf[i] + 256 * buf[i + 1];
 602
 603                 if (ubuf[*ulen - 1] == 0xfffe)
 604                         return 0;
 605                 if (ubuf[*ulen - 1] < 128 &&
 606                     text_chars[(size_t)ubuf[*ulen - 1]] != T)
 607                         return 0;
 608         }
 609
 610         return 1 + bigend;
 611 }
 612
 613 #undef F
 614 #undef T
 615 #undef I
 616 #undef X
 617
 618 /*
 619  * This table maps each EBCDIC character to an (8-bit extended) ASCII
 620  * character, as specified in the rationale for the dd(1) command in
 621  * draft 11.2 (September, 1991) of the POSIX P1003.2 standard.
 622  *
 623  * Unfortunately it does not seem to correspond exactly to any of the
 624  * five variants of EBCDIC documented in IBM's _Enterprise Systems
 625  * Architecture/390: Principles of Operation_, SA22-7201-06, Seventh
 626  * Edition, July, 1999, pp. I-1 - I-4.
 627  *
 628  * Fortunately, though, all versions of EBCDIC, including this one, agree
 629  * on most of the printing characters that also appear in (7-bit) ASCII.
 630  * Of these, only '|', '!', '~', '^', '[', and ']' are in question at all.
 631  *
 632  * Fortunately too, there is general agreement that codes 0x00 through
 633  * 0x3F represent control characters, 0x41 a nonbreaking space, and the
 634  * remainder printing characters.
 635  *
 636  * This is sufficient to allow us to identify EBCDIC text and to distinguish
 637  * between old-style and internationalized examples of text.
 638  */
 639
 640 private unsigned char ebcdic_to_ascii[] = {
 641   0,   1,   2,   3, 156,   9, 134, 127, 151, 141, 142,  11,  12,  13,  14,  15,
 642  16,  17,  18,  19, 157, 133,   8, 135,  24,  25, 146, 143,  28,  29,  30,  31,
 643 128, 129, 130, 131, 132,  10,  23,  27, 136, 137, 138, 139, 140,   5,   6,   7,
 644 144, 145,  22, 147, 148, 149, 150,   4, 152, 153, 154, 155,  20,  21, 158,  26,
 645 ' ', 160, 161, 162, 163, 164, 165, 166, 167, 168, 213, '.', '<', '(', '+', '|',
 646 '&', 169, 170, 171, 172, 173, 174, 175, 176, 177, '!', '$', '*', ')', ';', '~',
 647 '-', '/', 178, 179, 180, 181, 182, 183, 184, 185, 203, ',', '%', '_', '>', '?',
 648 186, 187, 188, 189, 190, 191, 192, 193, 194, '`', ':', '#', '@', '\'','=', '"',
 649 195, 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 196, 197, 198, 199, 200, 201,
 650 202, 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', '^', 204, 205, 206, 207, 208,
 651 209, 229, 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 210, 211, 212, '[', 214, 215,
 652 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, ']', 230, 231,
 653 '{', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 232, 233, 234, 235, 236, 237,
 654 '}', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 238, 239, 240, 241, 242, 243,
 655 '\\',159, 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 244, 245, 246, 247, 248, 249,
 656 '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 250, 251, 252, 253, 254, 255
 657 };
 658
 659 #ifdef notdef
 660 /*
 661  * The following EBCDIC-to-ASCII table may relate more closely to reality,
 662  * or at least to modern reality.  It comes from
 663  *
 664  *   http://ftp.s390.ibm.com/products/oe/bpxqp9.html
 665  *
 666  * and maps the characters of EBCDIC code page 1047 (the code used for
 667  * Unix-derived software on IBM's 390 systems) to the corresponding
 668  * characters from ISO 8859-1.
 669  *
 670  * If this table is used instead of the above one, some of the special
 671  * cases for the NEL character can be taken out of the code.
 672  */
 673
 674 private unsigned char ebcdic_1047_to_8859[] = {
 675 0x00,0x01,0x02,0x03,0x9C,0x09,0x86,0x7F,0x97,0x8D,0x8E,0x0B,0x0C,0x0D,0x0E,0x0F,
 676 0x10,0x11,0x12,0x13,0x9D,0x0A,0x08,0x87,0x18,0x19,0x92,0x8F,0x1C,0x1D,0x1E,0x1F,
 677 0x80,0x81,0x82,0x83,0x84,0x85,0x17,0x1B,0x88,0x89,0x8A,0x8B,0x8C,0x05,0x06,0x07,
 678 0x90,0x91,0x16,0x93,0x94,0x95,0x96,0x04,0x98,0x99,0x9A,0x9B,0x14,0x15,0x9E,0x1A,
 679 0x20,0xA0,0xE2,0xE4,0xE0,0xE1,0xE3,0xE5,0xE7,0xF1,0xA2,0x2E,0x3C,0x28,0x2B,0x7C,
 680 0x26,0xE9,0xEA,0xEB,0xE8,0xED,0xEE,0xEF,0xEC,0xDF,0x21,0x24,0x2A,0x29,0x3B,0x5E,
 681 0x2D,0x2F,0xC2,0xC4,0xC0,0xC1,0xC3,0xC5,0xC7,0xD1,0xA6,0x2C,0x25,0x5F,0x3E,0x3F,
 682 0xF8,0xC9,0xCA,0xCB,0xC8,0xCD,0xCE,0xCF,0xCC,0x60,0x3A,0x23,0x40,0x27,0x3D,0x22,
 683 0xD8,0x61,0x62,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0xAB,0xBB,0xF0,0xFD,0xFE,0xB1,
 684 0xB0,0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x70,0x71,0x72,0xAA,0xBA,0xE6,0xB8,0xC6,0xA4,
 685 0xB5,0x7E,0x73,0x74,0x75,0x76,0x77,0x78,0x79,0x7A,0xA1,0xBF,0xD0,0x5B,0xDE,0xAE,
 686 0xAC,0xA3,0xA5,0xB7,0xA9,0xA7,0xB6,0xBC,0xBD,0xBE,0xDD,0xA8,0xAF,0x5D,0xB4,0xD7,
 687 0x7B,0x41,0x42,0x43,0x44,0x45,0x46,0x47,0x48,0x49,0xAD,0xF4,0xF6,0xF2,0xF3,0xF5,
 688 0x7D,0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x50,0x51,0x52,0xB9,0xFB,0xFC,0xF9,0xFA,0xFF,
 689 0x5C,0xF7,0x53,0x54,0x55,0x56,0x57,0x58,0x59,0x5A,0xB2,0xD4,0xD6,0xD2,0xD3,0xD5,
 690 0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0xB3,0xDB,0xDC,0xD9,0xDA,0x9F
 691 };
 692 #endif
 693
 694 /*
 695  * Copy buf[0 ... nbytes-1] into out[], translating EBCDIC to ASCII.
 696  */
 697 private void
 698 from_ebcdic(const unsigned char *buf, size_t nbytes, unsigned char *out)
 699 {
 700         int i;
 701
 702         for (i = 0; i < nbytes; i++) {
 703                 out[i] = ebcdic_to_ascii[buf[i]];
 704         }
 705 }