/*
* linux/fs/hfs/trans.c
*
* Copyright (C) 1995-1997 Paul H. Hargrove
* This file may be distributed under the terms of the GNU General Public License.
*
* This file contains routines for converting between the Macintosh
* character set and various other encodings. This includes dealing
* with ':' vs. '/' as the path-element separator.
*
* Latin-1 translation based on code contributed by Holger Schemel
* (aeglos@valinor.owl.de).
*
* The '8-bit', '7-bit ASCII' and '7-bit alphanumeric' encodings are
* implementations of the three encodings recommended by Apple in the
* document "AppleSingle/AppleDouble Formats: Developer's Note
* (9/94)". This document is available from Apple's Technical
* Information Library from the World Wide Web server
* www.info.apple.com.
*
* The 'CAP' encoding is an implementation of the naming scheme used
* by the Columbia AppleTalk Package, available for anonymous FTP from
* ????.
*
* "XXX" in a comment is a note to myself to consider changing something.
*
* In function preconditions the term "valid" applied to a pointer to
* a structure means that the pointer is non-NULL and the structure it
* points to has all fields initialized to consistent values.
*/
#include "hfs.h"
#include <linux/hfs_fs_sb.h>
#include <linux/hfs_fs_i.h>
#include <linux/hfs_fs.h>
/*================ File-local variables ================*/
/* int->ASCII map for a single hex digit */
static char hex[16] = {'0','1','2','3','4','5','6','7',
'8','9','a','b','c','d','e','f'};
/*
* Latin-1 to Mac character set map
*
* For the sake of consistency this map is generated from the Mac to
* Latin-1 map the first time it is needed. This means there is just
* one map to maintain.
*/
static unsigned char latin2mac_map[128]; /* initially all zero */
/*
* Mac to Latin-1 map for the upper 128 characters (both have ASCII in
* the lower 128 positions)
*/
static unsigned char mac2latin_map[128] = {
0xC4, 0xC5, 0xC7, 0xC9, 0xD1, 0xD6, 0xDC, 0xE1,
0xE0, 0xE2, 0xE4, 0xE3, 0xE5, 0xE7, 0xE9, 0xE8,
0xEA, 0xEB, 0xED, 0xEC, 0xEE, 0xEF, 0xF1, 0xF3,
0xF2, 0xF4, 0xF6, 0xF5, 0xFA, 0xF9, 0xFB, 0xFC,
0x00, 0xB0, 0xA2, 0xA3, 0xA7, 0xB7, 0xB6, 0xDF,
0xAE, 0xA9, 0x00, 0xB4, 0xA8, 0x00, 0xC6, 0xD8,
0x00, 0xB1, 0x00, 0x00, 0xA5, 0xB5, 0xF0, 0x00,
0x00, 0x00, 0x00, 0xAA, 0xBA, 0x00, 0xE6, 0xF8,
0xBF, 0xA1, 0xAC, 0x00, 0x00, 0x00, 0x00, 0xAB,
0xBB, 0x00, 0xA0, 0xC0, 0xC3, 0xD5, 0x00, 0x00,
0xAD, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF7, 0x00,
0xFF, 0x00, 0x00, 0xA4, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0xB8, 0x00, 0x00, 0xC2, 0xCA, 0xC1,
0xCB, 0xC8, 0xCD, 0xCE, 0xCF, 0xCC, 0xD3, 0xD4,
0x00, 0xD2, 0xDA, 0xDB, 0xD9, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};
/*================ File-local functions ================*/
/*
* dehex()
*
* Given a hexadecimal digit in ASCII, return the integer representation.
*/
static inline const unsigned char dehex(char c) {
if ((c>='0')&&(c<='9')) {
return c-'0';
}
if ((c>='a')&&(c<='f')) {
return c-'a'+10;
}
if ((c>='A')&&(c<='F')) {
return c-'A'+10;
}
return 0xff;
}
/*================ Global functions ================*/
/*
* hfs_mac2nat()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the Netatalk name-mangling scheme, returning the length of the
* mangled filename. Note that the output string is not NULL terminated.
*
* The name-mangling works as follows:
* Characters 32-126 (' '-'~') except '/' and any initial '.' are passed
* unchanged from input to output. The remaining characters are replaced
* by three characters: ':xx' where xx is the hexadecimal representation
* of the character, using lowercase 'a' through 'f'.
*/
int hfs_mac2nat(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
/* Special case for .AppleDesktop which in the
distant future may be a pseudodirectory. */
if (strncmp(".AppleDesktop", p, len) == 0) {
strncpy(out, p, 13);
return 13;
}
while (len--) {
c = *p++;
if ((c<32) || (c=='/') || (c>126) || (!count && (c=='.'))) {
*out++ = ':';
*out++ = hex[(c>>4) & 0xf];
*out++ = hex[c & 0xf];
count += 3;
} else {
*out++ = c;
count++;
}
}
return count;
}
/*
* hfs_mac2cap()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the CAP name-mangling scheme, returning the length of the mangled
* filename. Note that the output string is not NULL terminated.
*
* The name-mangling works as follows:
* Characters 32-126 (' '-'~') except '/' are passed unchanged from
* input to output. The remaining characters are replaced by three
* characters: ':xx' where xx is the hexadecimal representation of the
* character, using lowercase 'a' through 'f'.
*/
int hfs_mac2cap(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
while (len--) {
c = *p++;
if ((c<32) || (c=='/') || (c>126)) {
*out++ = ':';
*out++ = hex[(c>>4) & 0xf];
*out++ = hex[c & 0xf];
count += 3;
} else {
*out++ = c;
count++;
}
}
return count;
}
/*
* hfs_mac2eight()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the '8-bit' name-mangling scheme, returning the length of the
* mangled filename. Note that the output string is not NULL
* terminated.
*
* This is one of the three recommended naming conventions described
* in Apple's document "AppleSingle/AppleDouble Formats: Developer's
* Note (9/94)"
*
* The name-mangling works as follows:
* Characters 0, '%' and '/' are replaced by three characters: '%xx'
* where xx is the hexadecimal representation of the character, using
* lowercase 'a' through 'f'. All other characters are passed
* unchanged from input to output. Note that this format is mainly
* implemented for completeness and is rather hard to read.
*/
int hfs_mac2eight(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
while (len--) {
c = *p++;
if (!c || (c=='/') || (c=='%')) {
*out++ = '%';
*out++ = hex[(c>>4) & 0xf];
*out++ = hex[c & 0xf];
count += 3;
} else {
*out++ = c;
count++;
}
}
return count;
}
/*
* hfs_mac2seven()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the '7-bit ASCII' name-mangling scheme, returning the length of the
* mangled filename. Note that the output string is not NULL
* terminated.
*
* This is one of the three recommended naming conventions described
* in Apple's document "AppleSingle/AppleDouble Formats: Developer's
* Note (9/94)"
*
* The name-mangling works as follows:
* Characters 0, '%', '/' and 128-255 are replaced by three
* characters: '%xx' where xx is the hexadecimal representation of the
* character, using lowercase 'a' through 'f'. All other characters
* are passed unchanged from input to output. Note that control
* characters (including newline) and space are unchanged make reading
* these filenames difficult.
*/
int hfs_mac2seven(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
while (len--) {
c = *p++;
if (!c || (c=='/') || (c=='%') || (c&0x80)) {
*out++ = '%';
*out++ = hex[(c>>4) & 0xf];
*out++ = hex[c & 0xf];
count += 3;
} else {
*out++ = c;
count++;
}
}
return count;
}
/*
* hfs_mac2alpha()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the '7-bit alphanumeric' name-mangling scheme, returning the length
* of the mangled filename. Note that the output string is not NULL
* terminated.
*
* This is one of the three recommended naming conventions described
* in Apple's document "AppleSingle/AppleDouble Formats: Developer's
* Note (9/94)"
*
* The name-mangling works as follows:
* The characters 'a'-'z', 'A'-'Z', '0'-'9', '_' and the last '.' in
* the filename are passed unchanged from input to output. All
* remaining characters (including any '.'s other than the last) are
* replaced by three characters: '%xx' where xx is the hexadecimal
* representation of the character, using lowercase 'a' through 'f'.
*/
int hfs_mac2alpha(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
const unsigned char *lp; /* last period */
/* strrchr() would be good here, but 'in' is not null-terminated */
for (lp=p+len-1; (lp>=p)&&(*lp!='.'); --lp) {}
++lp;
while (len--) {
c = *p++;
if ((p==lp) || ((c>='0')&&(c<='9')) || ((c>='A')&&(c<='Z')) ||
((c>='a')&&(c<='z')) || (c=='_')) {
*out++ = c;
count++;
} else {
*out++ = '%';
*out++ = hex[(c>>4) & 0xf];
*out++ = hex[c & 0xf];
count += 3;
}
}
return count;
}
/*
* hfs_mac2triv()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the 'trivial' name-mangling scheme, returning the length of the
* mangled filename. Note that the output string is not NULL
* terminated.
*
* The name-mangling works as follows:
* The character '/', which is illegal in Linux filenames is replaced
* by ':' which never appears in HFS filenames. All other characters
* are passed unchanged from input to output.
*/
int hfs_mac2triv(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
while (len--) {
c = *p++;
if (c=='/') {
*out++ = ':';
} else {
*out++ = c;
}
count++;
}
return count;
}
/*
* hfs_mac2latin()
*
* Given a 'Pascal String' (a string preceded by a length byte) in
* the Macintosh character set produce the corresponding filename using
* the 'Latin-1' name-mangling scheme, returning the length of the
* mangled filename. Note that the output string is not NULL
* terminated.
*
* The Macintosh character set and Latin-1 are both extensions of the
* ASCII character set. Some, but certainly not all, of the characters
* in the Macintosh character set are also in Latin-1 but not with the
* same encoding. This name-mangling scheme replaces the characters in
* the Macintosh character set that have Latin-1 equivalents by those
* equivalents; the characters 32-126, excluding '/' and '%', are
* passed unchanged from input to output. The remaining characters
* are replaced by three characters: '%xx' where xx is the hexadecimal
* representation of the character, using lowercase 'a' through 'f'.
*
* The array mac2latin_map[] indicates the correspondence between the
* two character sets. The byte in element x-128 gives the Latin-1
* encoding of the character with encoding x in the Macintosh
* character set. A value of zero indicates Latin-1 has no
* corresponding character.
*/
int hfs_mac2latin(char *out, const struct hfs_name *in) {
unsigned char c;
const unsigned char *p = in->Name;
int len = in->Len;
int count = 0;
while (len--) {
c = *p++;
if ((c & 0x80) && mac2latin_map[c & 0x7f]) {
*out++ = mac2latin_map[c & 0x7f];
count++;
} else if ((c>=32) && (c<=126) && (c!='/') && (c!='%')) {
*out++ = c;
count++;
} else {
*out++ = '%';
*out++ = hex[(c>>4) & 0xf];
*out++ = hex[c & 0xf];
count += 3;
}
}
return count;
}
/*
* hfs_colon2mac()
*
* Given an ASCII string (not null-terminated) and its length,
* generate the corresponding filename in the Macintosh character set
* using the 'CAP' name-mangling scheme, returning the length of the
* mangled filename. Note that the output string is not NULL
* terminated.
*
* This routine is a inverse to hfs_mac2cap() and hfs_mac2nat().
* A ':' not followed by a 2-digit hexadecimal number (or followed
* by the codes for NULL or ':') is replaced by a '|'.
*/
void hfs_colon2mac(struct hfs_name *out, const char *in, int len) {
int hi, lo;
unsigned char code, c, *count;
unsigned char *p = out->Name;
out->Len = 0;
count = &out->Len;
while (len-- && (*count < HFS_NAMELEN)) {
c = *in++;
(*count)++;
if (c!=':') {
*p++ = c;
} else if ((len<2) ||
((hi=dehex(in[0])) & 0xf0) ||
((lo=dehex(in[1])) & 0xf0) ||
!(code = (hi << 4) | lo) ||
(code == ':')) {
*p++ = '|';
} else {
*p++ = code;
len -= 2;
in += 2;
}
}
}
/*
* hfs_prcnt2mac()
*
* Given an ASCII string (not null-terminated) and its length,
* generate the corresponding filename in the Macintosh character set
* using Apple's three recommended name-mangling schemes, returning
* the length of the mangled filename. Note that the output string is
* not NULL terminated.
*
* This routine is a inverse to hfs_mac2alpha(), hfs_mac2seven() and
* hfs_mac2eight().
* A '%' not followed by a 2-digit hexadecimal number (or followed
* by the code for NULL or ':') is unchanged.
* A ':' is replaced by a '|'.
*/
void hfs_prcnt2mac(struct hfs_name *out, const char *in, int len) {
int hi, lo;
unsigned char code, c, *count;
unsigned char *p = out->Name;
out->Len = 0;
count = &out->Len;
while (len-- && (*count < HFS_NAMELEN)) {
c = *in++;
(*count)++;
if (c==':') {
*p++ = '|';
} else if (c!='%') {
*p++ = c;
} else if ((len<2) ||
((hi=dehex(in[0])) & 0xf0) ||
((lo=dehex(in[1])) & 0xf0) ||
!(code = (hi << 4) | lo) ||
(code == ':')) {
*p++ = '%';
} else {
*p++ = code;
len -= 2;
in += 2;
}
}
}
/*
* hfs_triv2mac()
*
* Given an ASCII string (not null-terminated) and its length,
* generate the corresponding filename in the Macintosh character set
* using the 'trivial' name-mangling scheme, returning the length of
* the mangled filename. Note that the output string is not NULL
* terminated.
*
* This routine is a inverse to hfs_mac2triv().
* A ':' is replaced by a '/'.
*/
void hfs_triv2mac(struct hfs_name *out, const char *in, int len) {
unsigned char c, *count;
unsigned char *p = out->Name;
out->Len = 0;
count = &out->Len;
while (len-- && (*count < HFS_NAMELEN)) {
c = *in++;
(*count)++;
if (c==':') {
*p++ = '/';
} else {
*p++ = c;
}
}
}
/*
* hfs_latin2mac()
*
* Given an Latin-1 string (not null-terminated) and its length,
* generate the corresponding filename in the Macintosh character set
* using the 'Latin-1' name-mangling scheme, returning the length of
* the mangled filename. Note that the output string is not NULL
* terminated.
*
* This routine is a inverse to hfs_latin2cap().
* A '%' not followed by a 2-digit hexadecimal number (or followed
* by the code for NULL or ':') is unchanged.
* A ':' is replaced by a '|'.
*
* Note that the character map is built the first time it is needed.
*/
void hfs_latin2mac(struct hfs_name *out, const char *in, int len)
{
int hi, lo;
unsigned char code, c, *count;
unsigned char *p = out->Name;
static int map_initialized;
if (!map_initialized) {
int i;
/* build the inverse mapping at run time */
for (i = 0; i < 128; i++) {
if ((c = mac2latin_map[i])) {
latin2mac_map[(int)c - 128] = i + 128;
}
}
map_initialized = 1;
}
out->Len = 0;
count = &out->Len;
while (len-- && (*count < HFS_NAMELEN)) {
c = *in++;
(*count)++;
if (c==':') {
*p++ = '|';
} else if (c!='%') {
if (c<128 || !(*p = latin2mac_map[c-128])) {
*p = c;
}
p++;
} else if ((len<2) ||
((hi=dehex(in[0])) & 0xf0) ||
((lo=dehex(in[1])) & 0xf0) ||
!(code = (hi << 4) | lo) ||
(code == ':')) {
*p++ = '%';
} else {
*p++ = code;
len -= 2;
in += 2;
}
}
}
![[BACK]](/icons/back.gif){kind=icon}
Return to trans.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [Development] / linux-2.6-xfs / fs / hfs