2 * Various routines from the OSTA 2.01 specs. Copyrights are included with
3 * each code segment. Slight whitespace modifications have been made for
4 * formatting purposes. Typos/bugs have been fixed.
9 #include <fs/udf/osta.h>
11 /*****************************************************************************/
13 **********************************************************************
14 * OSTA compliant Unicode compression, uncompression routines.
15 * Copyright 1995 Micro Design International, Inc.
16 * Written by Jason M. Rinn.
17 * Micro Design International gives permission for the free use of the
18 * following source code.
21 /***********************************************************************
22 * Takes an OSTA CS0 compressed unicode name, and converts
24 * The Unicode output will be in the byte order
25 * that the local compiler uses for 16-bit values.
26 * NOTE: This routine only performs error checking on the compID.
27 * It is up to the user to ensure that the unicode buffer is large
28 * enough, and that the compressed unicode name is correct.
32 * The number of unicode characters which were uncompressed.
33 * A -1 is returned if the compression ID is invalid.
36 udf_UncompressUnicode(
37 int numberOfBytes, /* (Input) number of bytes read from media. */
38 byte *UDFCompressed, /* (Input) bytes read from media. */
39 unicode_t *unicode) /* (Output) uncompressed unicode characters. */
42 int returnValue, unicodeIndex, byteIndex;
44 /* Use UDFCompressed to store current byte being read. */
45 compID = UDFCompressed[0];
47 /* First check for valid compID. */
48 if (compID != 8 && compID != 16) {
54 /* Loop through all the bytes. */
55 while (byteIndex < numberOfBytes) {
57 /* Move the first byte to the high bits of the
60 unicode[unicodeIndex] =
61 UDFCompressed[byteIndex++] << 8;
63 unicode[unicodeIndex] = 0;
65 if (byteIndex < numberOfBytes) {
66 /*Then the next byte to the low bits. */
67 unicode[unicodeIndex] |=
68 UDFCompressed[byteIndex++];
72 returnValue = unicodeIndex;
78 * Almost same as udf_UncompressUnicode(). The difference is that
79 * it keeps byte order of unicode string.
82 udf_UncompressUnicodeByte(
83 int numberOfBytes, /* (Input) number of bytes read from media. */
84 byte *UDFCompressed, /* (Input) bytes read from media. */
85 byte *unicode) /* (Output) uncompressed unicode characters. */
88 int returnValue, unicodeIndex, byteIndex;
90 /* Use UDFCompressed to store current byte being read. */
91 compID = UDFCompressed[0];
93 /* First check for valid compID. */
94 if (compID != 8 && compID != 16) {
100 /* Loop through all the bytes. */
101 while (byteIndex < numberOfBytes) {
103 /* Move the first byte to the high bits of the
106 unicode[unicodeIndex++] =
107 UDFCompressed[byteIndex++];
109 unicode[unicodeIndex++] = 0;
111 if (byteIndex < numberOfBytes) {
112 /*Then the next byte to the low bits. */
113 unicode[unicodeIndex++] =
114 UDFCompressed[byteIndex++];
117 returnValue = unicodeIndex;
122 /***********************************************************************
124 * Takes a string of unicode wide characters and returns an OSTA CS0
125 * compressed unicode string. The unicode MUST be in the byte order of
126 * the compiler in order to obtain correct results. Returns an error
127 * if the compression ID is invalid.
129 * NOTE: This routine assumes the implementation already knows, by
130 * the local environment, how many bits are appropriate and
131 * therefore does no checking to test if the input characters fit
132 * into that number of bits or not.
136 * The total number of bytes in the compressed OSTA CS0 string,
137 * including the compression ID.
138 * A -1 is returned if the compression ID is invalid.
142 int numberOfChars, /* (Input) number of unicode characters. */
143 int compID, /* (Input) compression ID to be used. */
144 unicode_t *unicode, /* (Input) unicode characters to compress. */
145 byte *UDFCompressed) /* (Output) compressed string, as bytes. */
147 int byteIndex, unicodeIndex;
149 if (compID != 8 && compID != 16) {
150 byteIndex = -1; /* Unsupported compression ID ! */
152 /* Place compression code in first byte. */
153 UDFCompressed[0] = compID;
157 while (unicodeIndex < numberOfChars) {
159 /* First, place the high bits of the char
160 * into the byte stream.
162 UDFCompressed[byteIndex++] =
163 (unicode[unicodeIndex] & 0xFF00) >> 8;
165 /*Then place the low bits into the stream. */
166 UDFCompressed[byteIndex++] =
167 unicode[unicodeIndex] & 0x00FF;
174 /*****************************************************************************/
178 static unsigned short crc_table[256] = {
179 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7,
180 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF,
181 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6,
182 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE,
183 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485,
184 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D,
185 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4,
186 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC,
187 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823,
188 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B,
189 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12,
190 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A,
191 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41,
192 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49,
193 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70,
194 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78,
195 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F,
196 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067,
197 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E,
198 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256,
199 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D,
200 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
201 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C,
202 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634,
203 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB,
204 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3,
205 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A,
206 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92,
207 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9,
208 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1,
209 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8,
210 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0
218 unsigned short crc=0;
221 crc = crc_table[(crc>>8 ^ *s++) & 0xff] ^ (crc<<8);
225 /* UNICODE Checksum */
227 udf_unicode_cksum(s, n)
231 unsigned short crc=0;
234 /* Take high order byte first--corresponds to a big endian
237 crc = crc_table[(crc>>8 ^ (*s>>8)) & 0xff] ^ (crc<<8);
238 crc = crc_table[(crc>>8 ^ (*s++ & 0xff)) & 0xff] ^ (crc<<8);
244 unsigned char bytes[] = { 0x70, 0x6A, 0x77 };
249 x = cksum(bytes, sizeof bytes);
250 printf("checksum: calculated=%4.4x, correct=%4.4x\en", x, 0x3299);
255 /*****************************************************************************/
258 **********************************************************************
259 * OSTA UDF compliant file name translation routine for OS/2,
260 * Windows 95, Windows NT, Macintosh and UNIX.
261 * Copyright 1995 Micro Design International, Inc.
262 * Written by Jason M. Rinn.
263 * Micro Design International gives permission for the free use of the
264 * following source code.
267 /***********************************************************************
268 * To use these routines with different operating systems.
272 * Define MAXLEN = 254
276 * Define MAXLEN = 255
280 * Define MAXLEN = 255
284 * Define MAXLEN = 31.
288 * Define MAXLEN as specified by unix version.
291 #define ILLEGAL_CHAR_MARK 0x005F
292 #define CRC_MARK 0x0023
296 #define PERIOD 0x002E
300 int IsIllegal(unicode_t ch);
302 /* Define a function or macro which determines if a Unicode character is
303 * printable under your implementation.
305 int UnicodeIsPrint(unicode_t);
307 /***********************************************************************
308 * Translates a long file name to one using a MAXLEN and an illegal
309 * char set in accord with the OSTA requirements. Assumes the name has
310 * already been translated to Unicode.
314 * Number of unicode characters in translated name.
317 unicode_t *newName, /* (Output)Translated name. Must be of length
319 unicode_t *udfName, /* (Input) Name from UDF volume.*/
320 int udfLen) /* (Input) Length of UDF Name. */
322 int index, newIndex = 0, needsCRC = FALSE;
323 int extIndex = 0, newExtIndex = 0, hasExt = FALSE;
324 #if defined OS2 || defined WIN_95 || defined WIN_NT
327 unsigned short valueCRC;
329 const char hexChar[] = "0123456789ABCDEF";
331 for (index = 0; index < udfLen; index++) {
332 current = udfName[index];
334 if (IsIllegal(current) || !UnicodeIsPrint(current)) {
336 /* Replace Illegal and non-displayable chars with
339 current = ILLEGAL_CHAR_MARK;
340 /* Skip any other illegal or non-displayable
343 while(index+1 < udfLen && (IsIllegal(udfName[index+1])
344 || !UnicodeIsPrint(udfName[index+1]))) {
349 /* Record position of extension, if one is found. */
350 if (current == PERIOD && (udfLen - index -1) <= EXT_SIZE) {
351 if (udfLen == index + 1) {
352 /* A trailing period is NOT an extension. */
357 newExtIndex = newIndex;
361 #if defined OS2 || defined WIN_95 || defined WIN_NT
362 /* Record position of last char which is NOT period or space. */
363 else if (current != PERIOD && current != SPACE) {
364 trailIndex = newIndex;
368 if (newIndex < MAXLEN) {
369 newName[newIndex++] = current;
375 #if defined OS2 || defined WIN_95 || defined WIN_NT
376 /* For OS2, 95 & NT, truncate any trailing periods and\or spaces. */
377 if (trailIndex != newIndex - 1) {
378 newIndex = trailIndex + 1;
380 hasExt = FALSE; /* Trailing period does not make an
386 unicode_t ext[EXT_SIZE];
387 int localExtIndex = 0;
390 /* Translate extension, and store it in ext. */
391 for(index = 0; index<EXT_SIZE &&
392 extIndex + index +1 < udfLen; index++ ) {
393 current = udfName[extIndex + index + 1];
394 if (IsIllegal(current) ||
395 !UnicodeIsPrint(current)) {
397 /* Replace Illegal and non-displayable
398 * chars with underscore.
400 current = ILLEGAL_CHAR_MARK;
401 /* Skip any other illegal or
402 * non-displayable characters.
404 while(index + 1 < EXT_SIZE
405 && (IsIllegal(udfName[extIndex +
407 !isprint(udfName[extIndex +
412 ext[localExtIndex++] = current;
415 /* Truncate filename to leave room for extension and
418 maxFilenameLen = ((MAXLEN - 5) - localExtIndex - 1);
419 if (newIndex > maxFilenameLen) {
420 newIndex = maxFilenameLen;
422 newIndex = newExtIndex;
424 } else if (newIndex > MAXLEN - 5) {
425 /*If no extension, make sure to leave room for CRC. */
426 newIndex = MAXLEN - 5;
428 newName[newIndex++] = CRC_MARK; /* Add mark for CRC. */
430 /*Calculate CRC from original filename from FileIdentifier. */
431 valueCRC = udf_unicode_cksum(udfName, udfLen);
432 /* Convert 16-bits of CRC to hex characters. */
433 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12];
434 newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8];
435 newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4];
436 newName[newIndex++] = hexChar[(valueCRC & 0x000f)];
438 /* Place a translated extension at end, if found. */
440 newName[newIndex++] = PERIOD;
441 for (index = 0;index < localExtIndex ;index++ ) {
442 newName[newIndex++] = ext[index];
449 #if defined OS2 || defined WIN_95 || defined WIN_NT
450 /***********************************************************************
451 * Decides if a Unicode character matches one of a list
452 * of ASCII characters.
453 * Used by OS2 version of IsIllegal for readability, since all of the
454 * illegal characters above 0x0020 are in the ASCII subset of Unicode.
455 * Works very similarly to the standard C function strchr().
459 * Non-zero if the Unicode character is in the given ASCII string.
462 unsigned char *string, /* (Input) String to search through. */
463 unicode_t ch) /* (Input) Unicode char to search for. */
466 while (*string != '\0' && found == FALSE) {
467 /* These types should compare, since both are unsigned
478 /***********************************************************************
479 * Decides whether the given character is illegal for a given OS.
483 * Non-zero if char is illegal.
485 int IsIllegal(unicode_t ch)
488 /* Only illegal character on the MAC is the colon. */
496 /* Illegal UNIX characters are NULL and slash. */
497 if (ch == 0x0000 || ch == 0x002F) {
503 #elif defined OS2 || defined WIN_95 || defined WIN_NT
504 /* Illegal char's for OS/2 according to WARP toolkit. */
505 if (ch < 0x0020 || UnicodeInString("\\/:*?\"<>|", ch)) {