ascmagic.c 20 KB

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