1 /* 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. 5 * 6 * $FreeBSD$ 7 */ 8 9 #include <fs/udf/osta.h> 10 11 /*****************************************************************************/ 12 /*- 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. 19 */ 20 21 /*********************************************************************** 22 * Takes an OSTA CS0 compressed unicode name, and converts 23 * it to Unicode. 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. 29 * 30 * RETURN VALUE 31 * 32 * The number of unicode characters which were uncompressed. 33 * A -1 is returned if the compression ID is invalid. 34 */ 35 int 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. */ 40 { 41 unsigned int compID; 42 int returnValue, unicodeIndex, byteIndex; 43 44 /* Use UDFCompressed to store current byte being read. */ 45 compID = UDFCompressed[0]; 46 47 /* First check for valid compID. */ 48 if (compID != 8 && compID != 16) { 49 returnValue = -1; 50 } else { 51 unicodeIndex = 0; 52 byteIndex = 1; 53 54 /* Loop through all the bytes. */ 55 while (byteIndex < numberOfBytes) { 56 if (compID == 16) { 57 /* Move the first byte to the high bits of the 58 * unicode char. 59 */ 60 unicode[unicodeIndex] = 61 UDFCompressed[byteIndex++] << 8; 62 } else { 63 unicode[unicodeIndex] = 0; 64 } 65 if (byteIndex < numberOfBytes) { 66 /*Then the next byte to the low bits. */ 67 unicode[unicodeIndex] |= 68 UDFCompressed[byteIndex++]; 69 } 70 unicodeIndex++; 71 } 72 returnValue = unicodeIndex; 73 } 74 return(returnValue); 75 } 76 77 /* 78 * Almost same as udf_UncompressUnicode(). The difference is that 79 * it keeps byte order of unicode string. 80 */ 81 int 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. */ 86 { 87 unsigned int compID; 88 int returnValue, unicodeIndex, byteIndex; 89 90 /* Use UDFCompressed to store current byte being read. */ 91 compID = UDFCompressed[0]; 92 93 /* First check for valid compID. */ 94 if (compID != 8 && compID != 16) { 95 returnValue = -1; 96 } else { 97 unicodeIndex = 0; 98 byteIndex = 1; 99 100 /* Loop through all the bytes. */ 101 while (byteIndex < numberOfBytes) { 102 if (compID == 16) { 103 /* Move the first byte to the high bits of the 104 * unicode char. 105 */ 106 unicode[unicodeIndex++] = 107 UDFCompressed[byteIndex++]; 108 } else { 109 unicode[unicodeIndex++] = 0; 110 } 111 if (byteIndex < numberOfBytes) { 112 /*Then the next byte to the low bits. */ 113 unicode[unicodeIndex++] = 114 UDFCompressed[byteIndex++]; 115 } 116 } 117 returnValue = unicodeIndex; 118 } 119 return(returnValue); 120 } 121 122 /*********************************************************************** 123 * DESCRIPTION: 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. 128 * 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. 133 * 134 * RETURN VALUE 135 * 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. 139 */ 140 int 141 udf_CompressUnicode( 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. */ 146 { 147 int byteIndex, unicodeIndex; 148 149 if (compID != 8 && compID != 16) { 150 byteIndex = -1; /* Unsupported compression ID ! */ 151 } else { 152 /* Place compression code in first byte. */ 153 UDFCompressed[0] = compID; 154 155 byteIndex = 1; 156 unicodeIndex = 0; 157 while (unicodeIndex < numberOfChars) { 158 if (compID == 16) { 159 /* First, place the high bits of the char 160 * into the byte stream. 161 */ 162 UDFCompressed[byteIndex++] = 163 (unicode[unicodeIndex] & 0xFF00) >> 8; 164 } 165 /*Then place the low bits into the stream. */ 166 UDFCompressed[byteIndex++] = 167 unicode[unicodeIndex] & 0x00FF; 168 unicodeIndex++; 169 } 170 } 171 return(byteIndex); 172 } 173 174 /*****************************************************************************/ 175 /* 176 * CRC 010041 177 */ 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 211 }; 212 213 unsigned short 214 udf_cksum(unsigned char *s, int n) 215 { 216 unsigned short crc=0; 217 218 while (n-- > 0) 219 crc = crc_table[(crc>>8 ^ *s++) & 0xff] ^ (crc<<8); 220 return crc; 221 } 222 223 /* UNICODE Checksum */ 224 unsigned short 225 udf_unicode_cksum(unsigned short *s, int n) 226 { 227 unsigned short crc=0; 228 229 while (n-- > 0) { 230 /* Take high order byte first--corresponds to a big endian 231 * byte stream. 232 */ 233 crc = crc_table[(crc>>8 ^ (*s>>8)) & 0xff] ^ (crc<<8); 234 crc = crc_table[(crc>>8 ^ (*s++ & 0xff)) & 0xff] ^ (crc<<8); 235 } 236 return crc; 237 } 238 239 #ifdef MAIN 240 unsigned char bytes[] = { 0x70, 0x6A, 0x77 }; 241 242 main() 243 { 244 unsigned short x; 245 x = cksum(bytes, sizeof bytes); 246 printf("checksum: calculated=%4.4x, correct=%4.4x\en", x, 0x3299); 247 exit(0); 248 } 249 #endif 250 251 /*****************************************************************************/ 252 #ifdef NEEDS_ISPRINT 253 /*- 254 ********************************************************************** 255 * OSTA UDF compliant file name translation routine for OS/2, 256 * Windows 95, Windows NT, Macintosh and UNIX. 257 * Copyright 1995 Micro Design International, Inc. 258 * Written by Jason M. Rinn. 259 * Micro Design International gives permission for the free use of the 260 * following source code. 261 */ 262 263 /*********************************************************************** 264 * To use these routines with different operating systems. 265 * 266 * OS/2 267 * Define OS2 268 * Define MAXLEN = 254 269 * 270 * Windows 95 271 * Define WIN_95 272 * Define MAXLEN = 255 273 * 274 * Windows NT 275 * Define WIN_NT 276 * Define MAXLEN = 255 277 * 278 * Macintosh: 279 * Define APPLE_MAC. 280 * Define MAXLEN = 31. 281 * 282 * UNIX 283 * Define UNIX. 284 * Define MAXLEN as specified by unix version. 285 */ 286 287 #define ILLEGAL_CHAR_MARK 0x005F 288 #define CRC_MARK 0x0023 289 #define EXT_SIZE 5 290 #define TRUE 1 291 #define FALSE 0 292 #define PERIOD 0x002E 293 #define SPACE 0x0020 294 295 /*** PROTOTYPES ***/ 296 int IsIllegal(unicode_t ch); 297 298 /* Define a function or macro which determines if a Unicode character is 299 * printable under your implementation. 300 */ 301 int UnicodeIsPrint(unicode_t); 302 303 /*********************************************************************** 304 * Translates a long file name to one using a MAXLEN and an illegal 305 * char set in accord with the OSTA requirements. Assumes the name has 306 * already been translated to Unicode. 307 * 308 * RETURN VALUE 309 * 310 * Number of unicode characters in translated name. 311 */ 312 int UDFTransName( 313 unicode_t *newName, /* (Output)Translated name. Must be of length 314 * MAXLEN */ 315 unicode_t *udfName, /* (Input) Name from UDF volume.*/ 316 int udfLen) /* (Input) Length of UDF Name. */ 317 { 318 int index, newIndex = 0, needsCRC = FALSE; 319 int extIndex = 0, newExtIndex = 0, hasExt = FALSE; 320 #if defined OS2 || defined WIN_95 || defined WIN_NT 321 int trailIndex = 0; 322 #endif 323 unsigned short valueCRC; 324 unicode_t current; 325 const char hexChar[] = "0123456789ABCDEF"; 326 327 for (index = 0; index < udfLen; index++) { 328 current = udfName[index]; 329 330 if (IsIllegal(current) || !UnicodeIsPrint(current)) { 331 needsCRC = TRUE; 332 /* Replace Illegal and non-displayable chars with 333 * underscore. 334 */ 335 current = ILLEGAL_CHAR_MARK; 336 /* Skip any other illegal or non-displayable 337 * characters. 338 */ 339 while(index+1 < udfLen && (IsIllegal(udfName[index+1]) 340 || !UnicodeIsPrint(udfName[index+1]))) { 341 index++; 342 } 343 } 344 345 /* Record position of extension, if one is found. */ 346 if (current == PERIOD && (udfLen - index -1) <= EXT_SIZE) { 347 if (udfLen == index + 1) { 348 /* A trailing period is NOT an extension. */ 349 hasExt = FALSE; 350 } else { 351 hasExt = TRUE; 352 extIndex = index; 353 newExtIndex = newIndex; 354 } 355 } 356 357 #if defined OS2 || defined WIN_95 || defined WIN_NT 358 /* Record position of last char which is NOT period or space. */ 359 else if (current != PERIOD && current != SPACE) { 360 trailIndex = newIndex; 361 } 362 #endif 363 364 if (newIndex < MAXLEN) { 365 newName[newIndex++] = current; 366 } else { 367 needsCRC = TRUE; 368 } 369 } 370 371 #if defined OS2 || defined WIN_95 || defined WIN_NT 372 /* For OS2, 95 & NT, truncate any trailing periods and\or spaces. */ 373 if (trailIndex != newIndex - 1) { 374 newIndex = trailIndex + 1; 375 needsCRC = TRUE; 376 hasExt = FALSE; /* Trailing period does not make an 377 * extension. */ 378 } 379 #endif 380 381 if (needsCRC) { 382 unicode_t ext[EXT_SIZE]; 383 int localExtIndex = 0; 384 if (hasExt) { 385 int maxFilenameLen; 386 /* Translate extension, and store it in ext. */ 387 for(index = 0; index<EXT_SIZE && 388 extIndex + index +1 < udfLen; index++ ) { 389 current = udfName[extIndex + index + 1]; 390 if (IsIllegal(current) || 391 !UnicodeIsPrint(current)) { 392 needsCRC = 1; 393 /* Replace Illegal and non-displayable 394 * chars with underscore. 395 */ 396 current = ILLEGAL_CHAR_MARK; 397 /* Skip any other illegal or 398 * non-displayable characters. 399 */ 400 while(index + 1 < EXT_SIZE 401 && (IsIllegal(udfName[extIndex + 402 index + 2]) || 403 !isprint(udfName[extIndex + 404 index + 2]))) { 405 index++; 406 } 407 } 408 ext[localExtIndex++] = current; 409 } 410 411 /* Truncate filename to leave room for extension and 412 * CRC. 413 */ 414 maxFilenameLen = ((MAXLEN - 5) - localExtIndex - 1); 415 if (newIndex > maxFilenameLen) { 416 newIndex = maxFilenameLen; 417 } else { 418 newIndex = newExtIndex; 419 } 420 } else if (newIndex > MAXLEN - 5) { 421 /*If no extension, make sure to leave room for CRC. */ 422 newIndex = MAXLEN - 5; 423 } 424 newName[newIndex++] = CRC_MARK; /* Add mark for CRC. */ 425 426 /*Calculate CRC from original filename from FileIdentifier. */ 427 valueCRC = udf_unicode_cksum(udfName, udfLen); 428 /* Convert 16-bits of CRC to hex characters. */ 429 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12]; 430 newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8]; 431 newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4]; 432 newName[newIndex++] = hexChar[(valueCRC & 0x000f)]; 433 434 /* Place a translated extension at end, if found. */ 435 if (hasExt) { 436 newName[newIndex++] = PERIOD; 437 for (index = 0;index < localExtIndex ;index++ ) { 438 newName[newIndex++] = ext[index]; 439 } 440 } 441 } 442 return(newIndex); 443 } 444 445 #if defined OS2 || defined WIN_95 || defined WIN_NT 446 /*********************************************************************** 447 * Decides if a Unicode character matches one of a list 448 * of ASCII characters. 449 * Used by OS2 version of IsIllegal for readability, since all of the 450 * illegal characters above 0x0020 are in the ASCII subset of Unicode. 451 * Works very similarly to the standard C function strchr(). 452 * 453 * RETURN VALUE 454 * 455 * Non-zero if the Unicode character is in the given ASCII string. 456 */ 457 int UnicodeInString( 458 unsigned char *string, /* (Input) String to search through. */ 459 unicode_t ch) /* (Input) Unicode char to search for. */ 460 { 461 int found = FALSE; 462 while (*string != '\0' && found == FALSE) { 463 /* These types should compare, since both are unsigned 464 * numbers. */ 465 if (*string == ch) { 466 found = TRUE; 467 } 468 string++; 469 } 470 return(found); 471 } 472 #endif /* OS2 */ 473 474 /*********************************************************************** 475 * Decides whether the given character is illegal for a given OS. 476 * 477 * RETURN VALUE 478 * 479 * Non-zero if char is illegal. 480 */ 481 int IsIllegal(unicode_t ch) 482 { 483 #ifdef APPLE_MAC 484 /* Only illegal character on the MAC is the colon. */ 485 if (ch == 0x003A) { 486 return(1); 487 } else { 488 return(0); 489 } 490 491 #elif defined UNIX 492 /* Illegal UNIX characters are NULL and slash. */ 493 if (ch == 0x0000 || ch == 0x002F) { 494 return(1); 495 } else { 496 return(0); 497 } 498 499 #elif defined OS2 || defined WIN_95 || defined WIN_NT 500 /* Illegal char's for OS/2 according to WARP toolkit. */ 501 if (ch < 0x0020 || UnicodeInString("\\/:*?\"<>|", ch)) { 502 return(1); 503 } else { 504 return(0); 505 } 506 #endif 507 } 508 #endif 509