1 /* $NetBSD: udf_osta.c,v 1.2 2006/06/12 00:20:21 christos 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 TRUE 1 250 #define FALSE 0 251 #define PERIOD 0x002E 252 #define SPACE 0x0020 253 254 /*** PROTOTYPES ***/ 255 int IsIllegal(unicode_t ch); 256 257 /* Define a function or macro which determines if a Unicode character is 258 * printable under your implementation. 259 */ 260 261 262 /* #include <stdio.h> */ 263 static int UnicodeIsPrint(unicode_t ch) { 264 return (ch >=' ') && (ch < 127); 265 } 266 267 268 int UnicodeLength(unicode_t *string) { 269 int length; 270 length = 0; 271 while (*string++) length++; 272 273 return length; 274 } 275 276 277 static int isprint(unsigned char c) { 278 return (c >= ' ') && (c != 127); 279 } 280 281 282 /*********************************************************************** 283 * Translates a long file name to one using a MAXLEN and an illegal 284 * char set in accord with the OSTA requirements. Assumes the name has 285 * already been translated to Unicode. 286 * 287 * RETURN VALUE 288 * 289 * Number of unicode characters in translated name. 290 */ 291 int UDFTransName( 292 unicode_t *newName, /* (Output)Translated name. Must be of length 293 * MAXLEN */ 294 unicode_t *udfName, /* (Input) Name from UDF volume.*/ 295 int udfLen) /* (Input) Length of UDF Name. */ 296 { 297 int index, newIndex = 0, needsCRC = FALSE; 298 int extIndex = 0, newExtIndex = 0, hasExt = FALSE; 299 #if defined OS2 || defined WIN_95 || defined WIN_NT 300 int trailIndex = 0; 301 #endif 302 unsigned short valueCRC; 303 unicode_t current; 304 const char hexChar[] = "0123456789ABCDEF"; 305 306 for (index = 0; index < udfLen; index++) { 307 current = udfName[index]; 308 309 if (IsIllegal(current) || !UnicodeIsPrint(current)) { 310 needsCRC = TRUE; 311 /* Replace Illegal and non-displayable chars with 312 * underscore. 313 */ 314 current = ILLEGAL_CHAR_MARK; 315 /* Skip any other illegal or non-displayable 316 * characters. 317 */ 318 while(index+1 < udfLen && (IsIllegal(udfName[index+1]) 319 || !UnicodeIsPrint(udfName[index+1]))) { 320 index++; 321 } 322 } 323 324 /* Record position of extension, if one is found. */ 325 if (current == PERIOD && (udfLen - index -1) <= EXT_SIZE) { 326 if (udfLen == index + 1) { 327 /* A trailing period is NOT an extension. */ 328 hasExt = FALSE; 329 } else { 330 hasExt = TRUE; 331 extIndex = index; 332 newExtIndex = newIndex; 333 } 334 } 335 336 #if defined OS2 || defined WIN_95 || defined WIN_NT 337 /* Record position of last char which is NOT period or space. */ 338 else if (current != PERIOD && current != SPACE) { 339 trailIndex = newIndex; 340 } 341 #endif 342 343 if (newIndex < MAXLEN) { 344 newName[newIndex++] = current; 345 } else { 346 needsCRC = TRUE; 347 } 348 } 349 350 #if defined OS2 || defined WIN_95 || defined WIN_NT 351 /* For OS2, 95 & NT, truncate any trailing periods and\or spaces. */ 352 if (trailIndex != newIndex - 1) { 353 newIndex = trailIndex + 1; 354 needsCRC = TRUE; 355 hasExt = FALSE; /* Trailing period does not make an 356 * extension. */ 357 } 358 #endif 359 360 if (needsCRC) { 361 unicode_t ext[EXT_SIZE]; 362 int localExtIndex = 0; 363 if (hasExt) { 364 int maxFilenameLen; 365 /* Translate extension, and store it in ext. */ 366 for(index = 0; index<EXT_SIZE && 367 extIndex + index +1 < udfLen; index++ ) { 368 current = udfName[extIndex + index + 1]; 369 if (IsIllegal(current) || 370 !UnicodeIsPrint(current)) { 371 needsCRC = 1; 372 /* Replace Illegal and non-displayable 373 * chars with underscore. 374 */ 375 current = ILLEGAL_CHAR_MARK; 376 /* Skip any other illegal or 377 * non-displayable characters. 378 */ 379 while(index + 1 < EXT_SIZE 380 && (IsIllegal(udfName[extIndex + 381 index + 2]) || 382 !isprint(udfName[extIndex + 383 index + 2]))) { 384 index++; 385 } 386 } 387 ext[localExtIndex++] = current; 388 } 389 390 /* Truncate filename to leave room for extension and 391 * CRC. 392 */ 393 maxFilenameLen = ((MAXLEN - 5) - localExtIndex - 1); 394 if (newIndex > maxFilenameLen) { 395 newIndex = maxFilenameLen; 396 } else { 397 newIndex = newExtIndex; 398 } 399 } else if (newIndex > MAXLEN - 5) { 400 /*If no extension, make sure to leave room for CRC. */ 401 newIndex = MAXLEN - 5; 402 } 403 newName[newIndex++] = CRC_MARK; /* Add mark for CRC. */ 404 405 /*Calculate CRC from original filename from FileIdentifier. */ 406 valueCRC = udf_unicode_cksum(udfName, udfLen); 407 /* Convert 16-bits of CRC to hex characters. */ 408 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12]; 409 newName[newIndex++] = hexChar[(valueCRC & 0x0f00) >> 8]; 410 newName[newIndex++] = hexChar[(valueCRC & 0x00f0) >> 4]; 411 newName[newIndex++] = hexChar[(valueCRC & 0x000f)]; 412 413 /* Place a translated extension at end, if found. */ 414 if (hasExt) { 415 newName[newIndex++] = PERIOD; 416 for (index = 0;index < localExtIndex ;index++ ) { 417 newName[newIndex++] = ext[index]; 418 } 419 } 420 } 421 return(newIndex); 422 } 423 424 #if defined OS2 || defined WIN_95 || defined WIN_NT 425 /*********************************************************************** 426 * Decides if a Unicode character matches one of a list 427 * of ASCII characters. 428 * Used by OS2 version of IsIllegal for readability, since all of the 429 * illegal characters above 0x0020 are in the ASCII subset of Unicode. 430 * Works very similarly to the standard C function strchr(). 431 * 432 * RETURN VALUE 433 * 434 * Non-zero if the Unicode character is in the given ASCII string. 435 */ 436 int UnicodeInString( 437 unsigned char *string, /* (Input) String to search through. */ 438 unicode_t ch) /* (Input) Unicode char to search for. */ 439 { 440 int found = FALSE; 441 while (*string != '\0' && found == FALSE) { 442 /* These types should compare, since both are unsigned 443 * numbers. */ 444 if (*string == ch) { 445 found = TRUE; 446 } 447 string++; 448 } 449 return(found); 450 } 451 #endif /* OS2 */ 452 453 /*********************************************************************** 454 * Decides whether the given character is illegal for a given OS. 455 * 456 * RETURN VALUE 457 * 458 * Non-zero if char is illegal. 459 */ 460 int IsIllegal(unicode_t ch) 461 { 462 #ifdef MAC 463 /* Only illegal character on the MAC is the colon. */ 464 if (ch == 0x003A) { 465 return(1); 466 } else { 467 return(0); 468 } 469 470 #elif defined UNIX 471 /* Illegal UNIX characters are NULL and slash. */ 472 if (ch == 0x0000 || ch == 0x002F) { 473 return(1); 474 } else { 475 return(0); 476 } 477 478 #elif defined OS2 || defined WIN_95 || defined WIN_NT 479 /* Illegal char's for OS/2 according to WARP toolkit. */ 480 if (ch < 0x0020 || UnicodeInString("\\/:*?\"<>|", ch)) { 481 return(1); 482 } else { 483 return(0); 484 } 485 #endif 486 } 487 /* #endif*/ /* NEEDS_ISPRINT */ 488 489