sys/vfs/udf/osta.c

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