1 /* $NetBSD: udf_osta.c,v 1.4 2007/02/22 06:37:01 thorpej Exp $ */ 2 3 /* 4 * Various routines from the OSTA 2.01 specs. Copyrights are included with 5 * each code segment. Slight whitespace modifications have been made for 6 * formatting purposes. Typos/bugs have been fixed. 7 * 8 */ 9 10 #include "udf_osta.h" 11 12 13 /*****************************************************************************/ 14 /*********************************************************************** 15 * OSTA compliant Unicode compression, uncompression routines. 16 * Copyright 1995 Micro Design International, Inc. 17 * Written by Jason M. Rinn. 18 * Micro Design International gives permission for the free use of the 19 * following source code. 20 */ 21 22 /*********************************************************************** 23 * Takes an OSTA CS0 compressed unicode name, and converts 24 * it to Unicode. 25 * The Unicode output will be in the byte order 26 * that the local compiler uses for 16-bit values. 27 * NOTE: This routine only performs error checking on the compID. 28 * It is up to the user to ensure that the unicode buffer is large 29 * enough, and that the compressed unicode name is correct. 30 * 31 * RETURN VALUE 32 * 33 * The number of unicode characters which were uncompressed. 34 * A -1 is returned if the compression ID is invalid. 35 */ 36 int 37 udf_UncompressUnicode( 38 int numberOfBytes, /* (Input) number of bytes read from media. */ 39 byte *UDFCompressed, /* (Input) bytes read from media. */ 40 unicode_t *unicode) /* (Output) uncompressed unicode characters. */ 41 { 42 unsigned int compID; 43 int returnValue, unicodeIndex, byteIndex; 44 45 /* Use UDFCompressed to store current byte being read. */ 46 compID = UDFCompressed[0]; 47 48 /* First check for valid compID. */ 49 if (compID != 8 && compID != 16) { 50 returnValue = -1; 51 } else { 52 unicodeIndex = 0; 53 byteIndex = 1; 54 55 /* Loop through all the bytes. */ 56 while (byteIndex < numberOfBytes) { 57 if (compID == 16) { 58 /* Move the first byte to the high bits of the 59 * unicode char. 60 */ 61 unicode[unicodeIndex] = 62 UDFCompressed[byteIndex++] << 8; 63 } else { 64 unicode[unicodeIndex] = 0; 65 } 66 if (byteIndex < numberOfBytes) { 67 /*Then the next byte to the low bits. */ 68 unicode[unicodeIndex] |= 69 UDFCompressed[byteIndex++]; 70 } 71 unicodeIndex++; 72 } 73 returnValue = unicodeIndex; 74 } 75 return(returnValue); 76 } 77 78 /*********************************************************************** 79 * DESCRIPTION: 80 * Takes a string of unicode wide characters and returns an OSTA CS0 81 * compressed unicode string. The unicode MUST be in the byte order of 82 * the compiler in order to obtain correct results. Returns an error 83 * if the compression ID is invalid. 84 * 85 * NOTE: This routine assumes the implementation already knows, by 86 * the local environment, how many bits are appropriate and 87 * therefore does no checking to test if the input characters fit 88 * into that number of bits or not. 89 * 90 * RETURN VALUE 91 * 92 * The total number of bytes in the compressed OSTA CS0 string, 93 * including the compression ID. 94 * A -1 is returned if the compression ID is invalid. 95 */ 96 int 97 udf_CompressUnicode( 98 int numberOfChars, /* (Input) number of unicode characters. */ 99 int compID, /* (Input) compression ID to be used. */ 100 unicode_t *unicode, /* (Input) unicode characters to compress. */ 101 byte *UDFCompressed) /* (Output) compressed string, as bytes. */ 102 { 103 int byteIndex, unicodeIndex; 104 105 if (compID != 8 && compID != 16) { 106 byteIndex = -1; /* Unsupported compression ID ! */ 107 } else { 108 /* Place compression code in first byte. */ 109 UDFCompressed[0] = compID; 110 111 byteIndex = 1; 112 unicodeIndex = 0; 113 while (unicodeIndex < numberOfChars) { 114 if (compID == 16) { 115 /* First, place the high bits of the char 116 * into the byte stream. 117 */ 118 UDFCompressed[byteIndex++] = 119 (unicode[unicodeIndex] & 0xFF00) >> 8; 120 } 121 /*Then place the low bits into the stream. */ 122 UDFCompressed[byteIndex++] = 123 unicode[unicodeIndex] & 0x00FF; 124 unicodeIndex++; 125 } 126 } 127 return(byteIndex); 128 } 129 130 /*****************************************************************************/ 131 /* 132 * CRC 010041 133 */ 134 static unsigned short crc_table[256] = { 135 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50A5, 0x60C6, 0x70E7, 136 0x8108, 0x9129, 0xA14A, 0xB16B, 0xC18C, 0xD1AD, 0xE1CE, 0xF1EF, 137 0x1231, 0x0210, 0x3273, 0x2252, 0x52B5, 0x4294, 0x72F7, 0x62D6, 138 0x9339, 0x8318, 0xB37B, 0xA35A, 0xD3BD, 0xC39C, 0xF3FF, 0xE3DE, 139 0x2462, 0x3443, 0x0420, 0x1401, 0x64E6, 0x74C7, 0x44A4, 0x5485, 140 0xA56A, 0xB54B, 0x8528, 0x9509, 0xE5EE, 0xF5CF, 0xC5AC, 0xD58D, 141 0x3653, 0x2672, 0x1611, 0x0630, 0x76D7, 0x66F6, 0x5695, 0x46B4, 142 0xB75B, 0xA77A, 0x9719, 0x8738, 0xF7DF, 0xE7FE, 0xD79D, 0xC7BC, 143 0x48C4, 0x58E5, 0x6886, 0x78A7, 0x0840, 0x1861, 0x2802, 0x3823, 144 0xC9CC, 0xD9ED, 0xE98E, 0xF9AF, 0x8948, 0x9969, 0xA90A, 0xB92B, 145 0x5AF5, 0x4AD4, 0x7AB7, 0x6A96, 0x1A71, 0x0A50, 0x3A33, 0x2A12, 146 0xDBFD, 0xCBDC, 0xFBBF, 0xEB9E, 0x9B79, 0x8B58, 0xBB3B, 0xAB1A, 147 0x6CA6, 0x7C87, 0x4CE4, 0x5CC5, 0x2C22, 0x3C03, 0x0C60, 0x1C41, 148 0xEDAE, 0xFD8F, 0xCDEC, 0xDDCD, 0xAD2A, 0xBD0B, 0x8D68, 0x9D49, 149 0x7E97, 0x6EB6, 0x5ED5, 0x4EF4, 0x3E13, 0x2E32, 0x1E51, 0x0E70, 150 0xFF9F, 0xEFBE, 0xDFDD, 0xCFFC, 0xBF1B, 0xAF3A, 0x9F59, 0x8F78, 151 0x9188, 0x81A9, 0xB1CA, 0xA1EB, 0xD10C, 0xC12D, 0xF14E, 0xE16F, 152 0x1080, 0x00A1, 0x30C2, 0x20E3, 0x5004, 0x4025, 0x7046, 0x6067, 153 0x83B9, 0x9398, 0xA3FB, 0xB3DA, 0xC33D, 0xD31C, 0xE37F, 0xF35E, 154 0x02B1, 0x1290, 0x22F3, 0x32D2, 0x4235, 0x5214, 0x6277, 0x7256, 155 0xB5EA, 0xA5CB, 0x95A8, 0x8589, 0xF56E, 0xE54F, 0xD52C, 0xC50D, 156 0x34E2, 0x24C3, 0x14A0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405, 157 0xA7DB, 0xB7FA, 0x8799, 0x97B8, 0xE75F, 0xF77E, 0xC71D, 0xD73C, 158 0x26D3, 0x36F2, 0x0691, 0x16B0, 0x6657, 0x7676, 0x4615, 0x5634, 159 0xD94C, 0xC96D, 0xF90E, 0xE92F, 0x99C8, 0x89E9, 0xB98A, 0xA9AB, 160 0x5844, 0x4865, 0x7806, 0x6827, 0x18C0, 0x08E1, 0x3882, 0x28A3, 161 0xCB7D, 0xDB5C, 0xEB3F, 0xFB1E, 0x8BF9, 0x9BD8, 0xABBB, 0xBB9A, 162 0x4A75, 0x5A54, 0x6A37, 0x7A16, 0x0AF1, 0x1AD0, 0x2AB3, 0x3A92, 163 0xFD2E, 0xED0F, 0xDD6C, 0xCD4D, 0xBDAA, 0xAD8B, 0x9DE8, 0x8DC9, 164 0x7C26, 0x6C07, 0x5C64, 0x4C45, 0x3CA2, 0x2C83, 0x1CE0, 0x0CC1, 165 0xEF1F, 0xFF3E, 0xCF5D, 0xDF7C, 0xAF9B, 0xBFBA, 0x8FD9, 0x9FF8, 166 0x6E17, 0x7E36, 0x4E55, 0x5E74, 0x2E93, 0x3EB2, 0x0ED1, 0x1EF0 167 }; 168 169 unsigned short 170 udf_cksum(s, n) 171 unsigned char *s; 172 int n; 173 { 174 unsigned short crc=0; 175 176 while (n-- > 0) 177 crc = crc_table[(crc>>8 ^ *s++) & 0xff] ^ (crc<<8); 178 return crc; 179 } 180 181 /* UNICODE Checksum */ 182 unsigned short 183 udf_unicode_cksum(s, n) 184 unsigned short *s; 185 int n; 186 { 187 unsigned short crc=0; 188 189 while (n-- > 0) { 190 /* Take high order byte first--corresponds to a big endian 191 * byte stream. 192 */ 193 crc = crc_table[(crc>>8 ^ (*s>>8)) & 0xff] ^ (crc<<8); 194 crc = crc_table[(crc>>8 ^ (*s++ & 0xff)) & 0xff] ^ (crc<<8); 195 } 196 return crc; 197 } 198 199 #ifdef MAIN 200 unsigned char bytes[] = { 0x70, 0x6A, 0x77 }; 201 202 main() 203 { 204 unsigned short x; 205 x = cksum(bytes, sizeof bytes); 206 printf("checksum: calculated=%4.4x, correct=%4.4x\en", x, 0x3299); 207 exit(0); 208 } 209 #endif 210 211 /*****************************************************************************/ 212 /* #ifdef NEEDS_ISPRINT */ 213 /*********************************************************************** 214 * OSTA UDF compliant file name translation routine for OS/2, 215 * Windows 95, Windows NT, Macintosh and UNIX. 216 * Copyright 1995 Micro Design International, Inc. 217 * Written by Jason M. Rinn. 218 * Micro Design International gives permission for the free use of the 219 * following source code. 220 */ 221 222 /*********************************************************************** 223 * To use these routines with different operating systems. 224 * 225 * OS/2 226 * Define OS2 227 * Define MAXLEN = 254 228 * 229 * Windows 95 230 * Define WIN_95 231 * Define MAXLEN = 255 232 * 233 * Windows NT 234 * Define WIN_NT 235 * Define MAXLEN = 255 236 * 237 * Macintosh: 238 * Define MAC. 239 * Define MAXLEN = 31. 240 * 241 * UNIX 242 * Define UNIX. 243 * Define MAXLEN as specified by unix version. 244 */ 245 246 #define ILLEGAL_CHAR_MARK 0x005F 247 #define CRC_MARK 0x0023 248 #define EXT_SIZE 5 249 #define PERIOD 0x002E 250 #define SPACE 0x0020 251 252 /*** PROTOTYPES ***/ 253 int IsIllegal(unicode_t ch); 254 255 /* Define a function or macro which determines if a Unicode character is 256 * printable under your implementation. 257 */ 258 259 260 /* #include <stdio.h> */ 261 static int UnicodeIsPrint(unicode_t ch) { 262 return (ch >=' ') && (ch < 127); 263 } 264 265 266 int UnicodeLength(unicode_t *string) { 267 int length; 268 length = 0; 269 while (*string++) length++; 270 271 return length; 272 } 273 274 275 static int isprint(unsigned char c) { 276 return (c >= ' ') && (c != 127); 277 } 278 279 280 /*********************************************************************** 281 * Translates a long file name to one using a MAXLEN and an illegal 282 * char set in accord with the OSTA requirements. Assumes the name has 283 * already been translated to Unicode. 284 * 285 * RETURN VALUE 286 * 287 * Number of unicode characters in translated name. 288 */ 289 int UDFTransName( 290 unicode_t *newName, /* (Output)Translated name. Must be of length 291 * MAXLEN */ 292 unicode_t *udfName, /* (Input) Name from UDF volume.*/ 293 int udfLen) /* (Input) Length of UDF Name. */ 294 { 295 int Index, newIndex = 0, needsCRC = false; /* index is shadowed */ 296 int extIndex = 0, newExtIndex = 0, hasExt = false; 297 #if defined OS2 || defined WIN_95 || defined WIN_NT 298 int trailIndex = 0; 299 #endif 300 unsigned short valueCRC; 301 unicode_t current; 302 const char hexChar[] = "0123456789ABCDEF"; 303 304 for (Index = 0; Index < udfLen; Index++) { 305 current = udfName[Index]; 306 307 if (IsIllegal(current) || !UnicodeIsPrint(current)) { 308 needsCRC = true; 309 /* Replace Illegal and non-displayable chars with 310 * underscore. 311 */ 312 current = ILLEGAL_CHAR_MARK; 313 /* Skip any other illegal or non-displayable 314 * characters. 315 */ 316 while(Index+1 < udfLen && (IsIllegal(udfName[Index+1]) 317 || !UnicodeIsPrint(udfName[Index+1]))) { 318 Index++; 319 } 320 } 321 322 /* Record position of extension, if one is found. */ 323 if (current == PERIOD && (udfLen - Index -1) <= EXT_SIZE) { 324 if (udfLen == Index + 1) { 325 /* A trailing period is NOT an extension. */ 326 hasExt = false; 327 } else { 328 hasExt = true; 329 extIndex = Index; 330 newExtIndex = newIndex; 331 } 332 } 333 334 #if defined OS2 || defined WIN_95 || defined WIN_NT 335 /* Record position of last char which is NOT period or space. */ 336 else if (current != PERIOD && current != SPACE) { 337 trailIndex = newIndex; 338 } 339 #endif 340 341 if (newIndex < MAXLEN) { 342 newName[newIndex++] = current; 343 } else { 344 needsCRC = true; 345 } 346 } 347 348 #if defined OS2 || defined WIN_95 || defined WIN_NT 349 /* For OS2, 95 & NT, truncate any trailing periods and\or spaces. */ 350 if (trailIndex != newIndex - 1) { 351 newIndex = trailIndex + 1; 352 needsCRC = true; 353 hasExt = false; /* Trailing period does not make an 354 * extension. */ 355 } 356 #endif 357 358 if (needsCRC) { 359 unicode_t ext[EXT_SIZE]; 360 int localExtIndex = 0; 361 if (hasExt) { 362 int maxFilenameLen; 363 /* Translate extension, and store it in ext. */ 364 for(Index = 0; Index<EXT_SIZE && 365 extIndex + Index +1 < udfLen; Index++ ) { 366 current = udfName[extIndex + Index + 1]; 367 if (IsIllegal(current) || 368 !UnicodeIsPrint(current)) { 369 needsCRC = 1; 370 /* Replace Illegal and non-displayable 371 * chars with underscore. 372 */ 373 current = ILLEGAL_CHAR_MARK; 374 /* Skip any other illegal or 375 * non-displayable characters. 376 */ 377 while(Index + 1 < EXT_SIZE 378 && (IsIllegal(udfName[extIndex + 379 Index + 2]) || 380 !isprint(udfName[extIndex + 381 Index + 2]))) { 382 Index++; 383 } 384 } 385 ext[localExtIndex++] = current; 386 } 387 388 /* Truncate filename to leave room for extension and 389 * CRC. 390 */ 391 maxFilenameLen = ((MAXLEN - 5) - localExtIndex - 1); 392 if (newIndex > maxFilenameLen) { 393 newIndex = maxFilenameLen; 394 } else { 395 newIndex = newExtIndex; 396 } 397 } else if (newIndex > MAXLEN - 5) { 398 /*If no extension, make sure to leave room for CRC. */ 399 newIndex = MAXLEN - 5; 400 } 401 newName[newIndex++] = CRC_MARK; /* Add mark for CRC. */ 402 403 /*Calculate CRC from original filename from FileIdentifier. */ 404 valueCRC = udf_unicode_cksum(udfName, udfLen); 405 /* Convert 16-bits of CRC to hex characters. */ 406 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12]; 407 newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8]; 408 newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4]; 409 newName[newIndex++] = hexChar[(valueCRC & 0x000f)]; 410 411 /* Place a translated extension at end, if found. */ 412 if (hasExt) { 413 newName[newIndex++] = PERIOD; 414 for (Index = 0;Index < localExtIndex ;Index++ ) { 415 newName[newIndex++] = ext[Index]; 416 } 417 } 418 } 419 return(newIndex); 420 } 421 422 #if defined OS2 || defined WIN_95 || defined WIN_NT 423 /*********************************************************************** 424 * Decides if a Unicode character matches one of a list 425 * of ASCII characters. 426 * Used by OS2 version of IsIllegal for readability, since all of the 427 * illegal characters above 0x0020 are in the ASCII subset of Unicode. 428 * Works very similarly to the standard C function strchr(). 429 * 430 * RETURN VALUE 431 * 432 * Non-zero if the Unicode character is in the given ASCII string. 433 */ 434 int UnicodeInString( 435 unsigned char *string, /* (Input) String to search through. */ 436 unicode_t ch) /* (Input) Unicode char to search for. */ 437 { 438 int found = false; 439 while (*string != '\0' && found == false) { 440 /* These types should compare, since both are unsigned 441 * numbers. */ 442 if (*string == ch) { 443 found = true; 444 } 445 string++; 446 } 447 return(found); 448 } 449 #endif /* OS2 */ 450 451 /*********************************************************************** 452 * Decides whether the given character is illegal for a given OS. 453 * 454 * RETURN VALUE 455 * 456 * Non-zero if char is illegal. 457 */ 458 int IsIllegal(unicode_t ch) 459 { 460 #ifdef MAC 461 /* Only illegal character on the MAC is the colon. */ 462 if (ch == 0x003A) { 463 return(1); 464 } else { 465 return(0); 466 } 467 468 #elif defined UNIX 469 /* Illegal UNIX characters are NULL and slash. */ 470 if (ch == 0x0000 || ch == 0x002F) { 471 return(1); 472 } else { 473 return(0); 474 } 475 476 #elif defined OS2 || defined WIN_95 || defined WIN_NT 477 /* Illegal char's for OS/2 according to WARP toolkit. */ 478 if (ch < 0x0020 || UnicodeInString("\\/:*?\"<>|", ch)) { 479 return(1); 480 } else { 481 return(0); 482 } 483 #endif 484 } 485 /* #endif*/ /* NEEDS_ISPRINT */ 486 487