fs/hfs/trans.c

   1 /*
   2  * linux/fs/hfs/trans.c
   3  *
   4  * Copyright (C) 1995-1997  Paul H. Hargrove
   5  * This file may be distributed under the terms of the GNU Public License.
   6  *
   7  * This file contains routines for converting between the Macintosh
   8  * character set and various other encodings.  This includes dealing
   9  * with ':' vs. '/' as the path-element separator.
  10  *
  11  * Latin-1 translation based on code contributed by Holger Schemel
  12  * (aeglos@valinor.owl.de).
  13  *
  14  * The '8-bit', '7-bit ASCII' and '7-bit alphanumeric' encodings are
  15  * implementations of the three encodings recommended by Apple in the
  16  * document "AppleSingle/AppleDouble Formats: Developer's Note
  17  * (9/94)".  This document is available from Apple's Technical
  18  * Information Library from the World Wide Web server
  19  * www.info.apple.com.
  20  *
  21  * The 'CAP' encoding is an implementation of the naming scheme used
  22  * by the Columbia AppleTalk Package, available for anonymous FTP from
  23  * ????.
  24  *
  25  * "XXX" in a comment is a note to myself to consider changing something.
  26  *
  27  * In function preconditions the term "valid" applied to a pointer to
  28  * a structure means that the pointer is non-NULL and the structure it
  29  * points to has all fields initialized to consistent values.
  30  */
  31
  32 #include "hfs.h"
  33 #include <linux/hfs_fs_sb.h>
  34 #include <linux/hfs_fs_i.h>
  35 #include <linux/hfs_fs.h>
  36
  37 /*================ File-local variables ================*/
  38
  39 /* int->ASCII map for a single hex digit */
  40 static char hex[16] = {'0','1','2','3','4','5','6','7',
  41                        '8','9','a','b','c','d','e','f'};
  42 /*
  43  * Latin-1 to Mac character set map
  44  *
  45  * For the sake of consistency this map is generated from the Mac to
  46  * Latin-1 map the first time it is needed.  This means there is just
  47  * one map to maintain.
  48  */
  49 static unsigned char latin2mac_map[128]; /* initially all zero */
  50
  51 /*
  52  * Mac to Latin-1 map for the upper 128 characters (both have ASCII in
  53  * the lower 128 positions)
  54  */
  55 static unsigned char mac2latin_map[128] = {
  56         0xC4, 0xC5, 0xC7, 0xC9, 0xD1, 0xD6, 0xDC, 0xE1,
  57         0xE0, 0xE2, 0xE4, 0xE3, 0xE5, 0xE7, 0xE9, 0xE8,
  58         0xEA, 0xEB, 0xED, 0xEC, 0xEE, 0xEF, 0xF1, 0xF3,
  59         0xF2, 0xF4, 0xF6, 0xF5, 0xFA, 0xF9, 0xFB, 0xFC,
  60         0x00, 0xB0, 0xA2, 0xA3, 0xA7, 0xB7, 0xB6, 0xDF,
  61         0xAE, 0xA9, 0x00, 0xB4, 0xA8, 0x00, 0xC6, 0xD8,
  62         0x00, 0xB1, 0x00, 0x00, 0xA5, 0xB5, 0xF0, 0x00,
  63         0x00, 0x00, 0x00, 0xAA, 0xBA, 0x00, 0xE6, 0xF8,
  64         0xBF, 0xA1, 0xAC, 0x00, 0x00, 0x00, 0x00, 0xAB,
  65         0xBB, 0x00, 0xA0, 0xC0, 0xC3, 0xD5, 0x00, 0x00,
  66         0xAD, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF7, 0x00,
  67         0xFF, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0x00,
  68         0x00, 0x00, 0xB8, 0x00, 0x00, 0xC2, 0xCA, 0xC1,
  69         0xCB, 0xC8, 0xCD, 0xCE, 0xCF, 0xCC, 0xD3, 0xD4,
  70         0x00, 0xD2, 0xDA, 0xDB, 0xD9, 0x00, 0x00, 0x00,
  71         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
  72 };
  73
  74 /*================ File-local functions ================*/
  75
  76 /*
  77  * dehex()
  78  *
  79  * Given a hexadecimal digit in ASCII, return the integer representation.
  80  */
  81 static inline const unsigned char dehex(char c) {
  82         if ((c>='0')&&(c<='9')) {
  83                 return c-'0';
  84         }
  85         if ((c>='a')&&(c<='f')) {
  86                 return c-'a'+10;
  87         }
  88         if ((c>='A')&&(c<='F')) {
  89                 return c-'A'+10;
  90         }
  91         return 0xff;
  92 }
  93
  94 /*================ Global functions ================*/
  95
  96 /*
  97  * hfs_mac2nat()
  98  *
  99  * Given a 'Pascal String' (a string preceded by a length byte) in
 100  * the Macintosh character set produce the corresponding filename using
 101  * the Netatalk name-mangling scheme, returning the length of the
 102  * mangled filename.  Note that the output string is not NULL terminated.
 103  *
 104  * The name-mangling works as follows:
 105  * Characters 32-126 (' '-'~') except '/' and any initial '.' are passed
 106  * unchanged from input to output.  The remaining characters are replaced
 107  * by three characters: ':xx' where xx is the hexadecimal representation
 108  * of the character, using lowercase 'a' through 'f'.
 109  */
 110 int hfs_mac2nat(char *out, const struct hfs_name *in) {
 111         unsigned char c;
 112         const unsigned char *p = in->Name;
 113         int len = in->Len;
 114         int count = 0;
 115
 116         /* Special case for .AppleDesktop which in the
 117            distant future may be a pseudodirectory. */
 118         if (strncmp(".AppleDesktop", p, len) == 0) {
 119                 strncpy(out, p, 13);
 120                 return 13;
 121         }
 122
 123         while (len--) {
 124                 c = *p++;
 125                 if ((c<32) || (c=='/') || (c>126) || (!count && (c=='.'))) {
 126                         *out++ = ':';
 127                         *out++ = hex[(c>>4) & 0xf];
 128                         *out++ = hex[c & 0xf];
 129                         count += 3;
 130                 } else {
 131                         *out++ = c;
 132                         count++;
 133                 }
 134         }
 135         return count;
 136 }
 137
 138 /*
 139  * hfs_mac2cap()
 140  *
 141  * Given a 'Pascal String' (a string preceded by a length byte) in
 142  * the Macintosh character set produce the corresponding filename using
 143  * the CAP name-mangling scheme, returning the length of the mangled
 144  * filename.  Note that the output string is not NULL terminated.
 145  *
 146  * The name-mangling works as follows:
 147  * Characters 32-126 (' '-'~') except '/' are passed unchanged from
 148  * input to output.  The remaining characters are replaced by three
 149  * characters: ':xx' where xx is the hexadecimal representation of the
 150  * character, using lowercase 'a' through 'f'.
 151  */
 152 int hfs_mac2cap(char *out, const struct hfs_name *in) {
 153         unsigned char c;
 154         const unsigned char *p = in->Name;
 155         int len = in->Len;
 156         int count = 0;
 157
 158         while (len--) {
 159                 c = *p++;
 160                 if ((c<32) || (c=='/') || (c>126)) {
 161                         *out++ = ':';
 162                         *out++ = hex[(c>>4) & 0xf];
 163                         *out++ = hex[c & 0xf];
 164                         count += 3;
 165                 } else {
 166                         *out++ = c;
 167                         count++;
 168                 }
 169         }
 170         return count;
 171 }
 172
 173 /*
 174  * hfs_mac2eight()
 175  *
 176  * Given a 'Pascal String' (a string preceded by a length byte) in
 177  * the Macintosh character set produce the corresponding filename using
 178  * the '8-bit' name-mangling scheme, returning the length of the
 179  * mangled filename.  Note that the output string is not NULL
 180  * terminated.
 181  *
 182  * This is one of the three recommended naming conventions described
 183  * in Apple's document "AppleSingle/AppleDouble Formats: Developer's
 184  * Note (9/94)"
 185  *
 186  * The name-mangling works as follows:
 187  * Characters 0, '%' and '/' are replaced by three characters: '%xx'
 188  * where xx is the hexadecimal representation of the character, using
 189  * lowercase 'a' through 'f'.  All other characters are passed
 190  * unchanged from input to output.  Note that this format is mainly
 191  * implemented for completeness and is rather hard to read.
 192  */
 193 int hfs_mac2eight(char *out, const struct hfs_name *in) {
 194         unsigned char c;
 195         const unsigned char *p = in->Name;
 196         int len = in->Len;
 197         int count = 0;
 198
 199         while (len--) {
 200                 c = *p++;
 201                 if (!c || (c=='/') || (c=='%')) {
 202                         *out++ = '%';
 203                         *out++ = hex[(c>>4) & 0xf];
 204                         *out++ = hex[c & 0xf];
 205                         count += 3;
 206                 } else {
 207                         *out++ = c;
 208                         count++;
 209                 }
 210         }
 211         return count;
 212 }
 213
 214 /*
 215  * hfs_mac2seven()
 216  *
 217  * Given a 'Pascal String' (a string preceded by a length byte) in
 218  * the Macintosh character set produce the corresponding filename using
 219  * the '7-bit ASCII' name-mangling scheme, returning the length of the
 220  * mangled filename.  Note that the output string is not NULL
 221  * terminated.
 222  *
 223  * This is one of the three recommended naming conventions described
 224  * in Apple's document "AppleSingle/AppleDouble Formats: Developer's
 225  * Note (9/94)"
 226  *
 227  * The name-mangling works as follows:
 228  * Characters 0, '%', '/' and 128-255 are replaced by three
 229  * characters: '%xx' where xx is the hexadecimal representation of the
 230  * character, using lowercase 'a' through 'f'.  All other characters
 231  * are passed unchanged from input to output.  Note that control
 232  * characters (including newline) and space are unchanged make reading
 233  * these filenames difficult.
 234  */
 235 int hfs_mac2seven(char *out, const struct hfs_name *in) {
 236         unsigned char c;
 237         const unsigned char *p = in->Name;
 238         int len = in->Len;
 239         int count = 0;
 240
 241         while (len--) {
 242                 c = *p++;
 243                 if (!c || (c=='/') || (c=='%') || (c&0x80)) {
 244                         *out++ = '%';
 245                         *out++ = hex[(c>>4) & 0xf];
 246                         *out++ = hex[c & 0xf];
 247                         count += 3;
 248                 } else {
 249                         *out++ = c;
 250                         count++;
 251                 }
 252         }
 253         return count;
 254 }
 255
 256 /*
 257  * hfs_mac2alpha()
 258  *
 259  * Given a 'Pascal String' (a string preceded by a length byte) in
 260  * the Macintosh character set produce the corresponding filename using
 261  * the '7-bit alphanumeric' name-mangling scheme, returning the length
 262  * of the mangled filename.  Note that the output string is not NULL
 263  * terminated.
 264  *
 265  * This is one of the three recommended naming conventions described
 266  * in Apple's document "AppleSingle/AppleDouble Formats: Developer's
 267  * Note (9/94)"
 268  *
 269  * The name-mangling works as follows:
 270  * The characters 'a'-'z', 'A'-'Z', '0'-'9', '_' and the last '.' in
 271  * the filename are passed unchanged from input to output.  All
 272  * remaining characters (including any '.'s other than the last) are
 273  * replaced by three characters: '%xx' where xx is the hexadecimal
 274  * representation of the character, using lowercase 'a' through 'f'.
 275  */
 276 int hfs_mac2alpha(char *out, const struct hfs_name *in) {
 277         unsigned char c;
 278         const unsigned char *p = in->Name;
 279         int len = in->Len;
 280         int count = 0;
 281         const unsigned char *lp;        /* last period */
 282
 283         /* strrchr() would be good here, but 'in' is not null-terminated */
 284         for (lp=p+len-1; (lp>=p)&&(*lp!='.'); --lp) {}
 285         ++lp;
 286
 287         while (len--) {
 288                 c = *p++;
 289                 if ((p==lp) || ((c>='0')&&(c<='9')) || ((c>='A')&&(c<='Z')) ||
 290                                 ((c>='a')&&(c<='z')) || (c=='_')) {
 291                         *out++ = c;
 292                         count++;
 293                 } else {
 294                         *out++ = '%';
 295                         *out++ = hex[(c>>4) & 0xf];
 296                         *out++ = hex[c & 0xf];
 297                         count += 3;
 298                 }
 299         }
 300         return count;
 301 }
 302
 303 /*
 304  * hfs_mac2triv()
 305  *
 306  * Given a 'Pascal String' (a string preceded by a length byte) in
 307  * the Macintosh character set produce the corresponding filename using
 308  * the 'trivial' name-mangling scheme, returning the length of the
 309  * mangled filename.  Note that the output string is not NULL
 310  * terminated.
 311  *
 312  * The name-mangling works as follows:
 313  * The character '/', which is illegal in Linux filenames is replaced
 314  * by ':' which never appears in HFS filenames.  All other characters
 315  * are passed unchanged from input to output.
 316  */
 317 int hfs_mac2triv(char *out, const struct hfs_name *in) {
 318         unsigned char c;
 319         const unsigned char *p = in->Name;
 320         int len = in->Len;
 321         int count = 0;
 322
 323         while (len--) {
 324                 c = *p++;
 325                 if (c=='/') {
 326                         *out++ = ':';
 327                 } else {
 328                         *out++ = c;
 329                 }
 330                 count++;
 331         }
 332         return count;
 333 }
 334
 335 /*
 336  * hfs_mac2latin()
 337  *
 338  * Given a 'Pascal String' (a string preceded by a length byte) in
 339  * the Macintosh character set produce the corresponding filename using
 340  * the 'Latin-1' name-mangling scheme, returning the length of the
 341  * mangled filename.  Note that the output string is not NULL
 342  * terminated.
 343  *
 344  * The Macintosh character set and Latin-1 are both extensions of the
 345  * ASCII character set.  Some, but certainly not all, of the characters
 346  * in the Macintosh character set are also in Latin-1 but not with the
 347  * same encoding.  This name-mangling scheme replaces the characters in
 348  * the Macintosh character set that have Latin-1 equivalents by those
 349  * equivalents; the characters 32-126, excluding '/' and '%', are
 350  * passed unchanged from input to output.  The remaining characters
 351  * are replaced by three characters: '%xx' where xx is the hexadecimal
 352  * representation of the character, using lowercase 'a' through 'f'.
 353  *
 354  * The array mac2latin_map[] indicates the correspondence between the
 355  * two character sets.  The byte in element x-128 gives the Latin-1
 356  * encoding of the character with encoding x in the Macintosh
 357  * character set.  A value of zero indicates Latin-1 has no
 358  * corresponding character.
 359  */
 360 int hfs_mac2latin(char *out, const struct hfs_name *in) {
 361         unsigned char c;
 362         const unsigned char *p = in->Name;
 363         int len = in->Len;
 364         int count = 0;
 365
 366         while (len--) {
 367                 c = *p++;
 368
 369                 if ((c & 0x80) && mac2latin_map[c & 0x7f]) {
 370                         *out++ = mac2latin_map[c & 0x7f];
 371                         count++;
 372                 } else if ((c>=32) && (c<=126) && (c!='/') && (c!='%')) {
 373                         *out++ =  c;
 374                         count++;
 375                 } else {
 376                         *out++ = '%';
 377                         *out++ = hex[(c>>4) & 0xf];
 378                         *out++ = hex[c & 0xf];
 379                         count += 3;
 380                 }
 381         }
 382         return count;
 383 }
 384
 385 /*
 386  * hfs_colon2mac()
 387  *
 388  * Given an ASCII string (not null-terminated) and its length,
 389  * generate the corresponding filename in the Macintosh character set
 390  * using the 'CAP' name-mangling scheme, returning the length of the
 391  * mangled filename.  Note that the output string is not NULL
 392  * terminated.
 393  *
 394  * This routine is a inverse to hfs_mac2cap() and hfs_mac2nat().
 395  * A ':' not followed by a 2-digit hexadecimal number (or followed
 396  * by the codes for NULL or ':') is replaced by a '|'.
 397  */
 398 void hfs_colon2mac(struct hfs_name *out, const char *in, int len) {
 399         int hi, lo;
 400         unsigned char code, c, *count;
 401         unsigned char *p = out->Name;
 402
 403         out->Len = 0;
 404         count = &out->Len;
 405         while (len-- && (*count < HFS_NAMELEN)) {
 406                 c = *in++;
 407                 (*count)++;
 408                 if (c!=':') {
 409                         *p++ = c;
 410                 } else if ((len<2) ||
 411                            ((hi=dehex(in[0])) & 0xf0) ||
 412                            ((lo=dehex(in[1])) & 0xf0) ||
 413                            !(code = (hi << 4) | lo) ||
 414                            (code == ':')) {
 415                         *p++ = '|';
 416                 } else {
 417                         *p++ = code;
 418                         len -= 2;
 419                         in += 2;
 420                 }
 421         }
 422 }
 423
 424 /*
 425  * hfs_prcnt2mac()
 426  *
 427  * Given an ASCII string (not null-terminated) and its length,
 428  * generate the corresponding filename in the Macintosh character set
 429  * using Apple's three recommended name-mangling schemes, returning
 430  * the length of the mangled filename.  Note that the output string is
 431  * not NULL terminated.
 432  *
 433  * This routine is a inverse to hfs_mac2alpha(), hfs_mac2seven() and
 434  * hfs_mac2eight().
 435  * A '%' not followed by a 2-digit hexadecimal number (or followed
 436  * by the code for NULL or ':') is unchanged.
 437  * A ':' is replaced by a '|'.
 438  */
 439 void hfs_prcnt2mac(struct hfs_name *out, const char *in, int len) {
 440         int hi, lo;
 441         unsigned char code, c, *count;
 442         unsigned char *p = out->Name;
 443
 444         out->Len = 0;
 445         count = &out->Len;
 446         while (len-- && (*count < HFS_NAMELEN)) {
 447                 c = *in++;
 448                 (*count)++;
 449                 if (c==':') {
 450                         *p++ = '|';
 451                 } else if (c!='%') {
 452                         *p++ = c;
 453                 } else if ((len<2) ||
 454                            ((hi=dehex(in[0])) & 0xf0) ||
 455                            ((lo=dehex(in[1])) & 0xf0) ||
 456                            !(code = (hi << 4) | lo) ||
 457                            (code == ':')) {
 458                         *p++ = '%';
 459                 } else {
 460                         *p++ = code;
 461                         len -= 2;
 462                         in += 2;
 463                 }
 464         }
 465 }
 466
 467 /*
 468  * hfs_triv2mac()
 469  *
 470  * Given an ASCII string (not null-terminated) and its length,
 471  * generate the corresponding filename in the Macintosh character set
 472  * using the 'trivial' name-mangling scheme, returning the length of
 473  * the mangled filename.  Note that the output string is not NULL
 474  * terminated.
 475  *
 476  * This routine is a inverse to hfs_mac2triv().
 477  * A ':' is replaced by a '/'.
 478  */
 479 void hfs_triv2mac(struct hfs_name *out, const char *in, int len) {
 480         unsigned char c, *count;
 481         unsigned char *p = out->Name;
 482
 483         out->Len = 0;
 484         count = &out->Len;
 485         while (len-- && (*count < HFS_NAMELEN)) {
 486                 c = *in++;
 487                 (*count)++;
 488                 if (c==':') {
 489                         *p++ = '/';
 490                 } else {
 491                         *p++ = c;
 492                 }
 493         }
 494 }
 495
 496 /*
 497  * hfs_latin2mac()
 498  *
 499  * Given an Latin-1 string (not null-terminated) and its length,
 500  * generate the corresponding filename in the Macintosh character set
 501  * using the 'Latin-1' name-mangling scheme, returning the length of
 502  * the mangled filename.  Note that the output string is not NULL
 503  * terminated.
 504  *
 505  * This routine is a inverse to hfs_latin2cap().
 506  * A '%' not followed by a 2-digit hexadecimal number (or followed
 507  * by the code for NULL or ':') is unchanged.
 508  * A ':' is replaced by a '|'.
 509  *
 510  * Note that the character map is built the first time it is needed.
 511  */
 512 void hfs_latin2mac(struct hfs_name *out, const char *in, int len)
 513 {
 514         int hi, lo;
 515         unsigned char code, c, *count;
 516         unsigned char *p = out->Name;
 517         static int map_initialized = 0;
 518
 519         if (!map_initialized) {
 520                 int i;
 521
 522                 /* build the inverse mapping at run time */
 523                 for (i = 0; i < 128; i++) {
 524                         if ((c = mac2latin_map[i])) {
 525                                 latin2mac_map[(int)c - 128] = i + 128;
 526                         }
 527                 }
 528                 map_initialized = 1;
 529         }
 530
 531         out->Len = 0;
 532         count = &out->Len;
 533         while (len-- && (*count < HFS_NAMELEN)) {
 534                 c = *in++;
 535                 (*count)++;
 536
 537                 if (c==':') {
 538                         *p++ = '|';
 539                 } else if (c!='%') {
 540                         if (c<128 || !(*p = latin2mac_map[c-128])) {
 541                                 *p = c;
 542                         }
 543                         p++;
 544                 } else if ((len<2) ||
 545                            ((hi=dehex(in[0])) & 0xf0) ||
 546                            ((lo=dehex(in[1])) & 0xf0) ||
 547                            !(code = (hi << 4) | lo) ||
 548                            (code == ':')) {
 549                         *p++ = '%';
 550                 } else {
 551                         *p++ = code;
 552                         len -= 2;
 553                         in += 2;
 554                 }
 555         }
 556 }