osta.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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(s, n)
  215         unsigned char *s;
  216         int n;
  217 {
  218         unsigned short crc=0;
  219 
  220         while (n-- > 0)
  221                 crc = crc_table[(crc>>8 ^ *s++) & 0xff] ^ (crc<<8);
  222         return crc;
  223 }
  224 
  225 /* UNICODE Checksum */
  226 unsigned short
  227 udf_unicode_cksum(s, n)
  228         unsigned short *s;
  229         int n;
  230 {
  231         unsigned short crc=0;
  232 
  233         while (n-- > 0) {
  234                 /* Take high order byte first--corresponds to a big endian
  235                  * byte stream.
  236                  */
  237                 crc = crc_table[(crc>>8 ^ (*s>>8)) & 0xff] ^ (crc<<8);
  238                 crc = crc_table[(crc>>8 ^ (*s++ & 0xff)) & 0xff] ^ (crc<<8);
  239         }
  240         return crc;
  241 }
  242 
  243 #ifdef MAIN
  244 unsigned char bytes[] = { 0x70, 0x6A, 0x77 };
  245 
  246 main()
  247 {
  248         unsigned short x;
  249         x = cksum(bytes, sizeof bytes);
  250         printf("checksum: calculated=%4.4x, correct=%4.4x\en", x, 0x3299);
  251         exit(0);
  252 }
  253 #endif
  254 
  255 /*****************************************************************************/
  256 #ifdef NEEDS_ISPRINT
  257 /*-
  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.
  265  */
  266 
  267 /***********************************************************************
  268  * To use these routines with different operating systems.
  269  *
  270  * OS/2
  271  * Define OS2
  272  * Define MAXLEN = 254
  273  *
  274  * Windows 95
  275  * Define WIN_95
  276  * Define MAXLEN = 255
  277  *
  278  * Windows NT
  279  * Define WIN_NT
  280  * Define MAXLEN = 255
  281  *
  282  * Macintosh:
  283  * Define MAC.
  284  * Define MAXLEN = 31.
  285  *
  286  * UNIX
  287  * Define UNIX.
  288  * Define MAXLEN as specified by unix version.
  289  */
  290 
  291 #define ILLEGAL_CHAR_MARK       0x005F
  292 #define CRC_MARK        0x0023
  293 #define EXT_SIZE        5
  294 #define TRUE    1
  295 #define FALSE   0
  296 #define PERIOD  0x002E
  297 #define SPACE   0x0020
  298 
  299 /*** PROTOTYPES ***/
  300 int IsIllegal(unicode_t ch);
  301 
  302 /* Define a function or macro which determines if a Unicode character is
  303  * printable under your implementation.
  304  */
  305 int UnicodeIsPrint(unicode_t);
  306 
  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.
  311  *
  312  * RETURN VALUE
  313  *
  314  * Number of unicode characters in translated name.
  315  */
  316 int UDFTransName(
  317         unicode_t *newName,     /* (Output)Translated name. Must be of length
  318                                  * MAXLEN */
  319         unicode_t *udfName,     /* (Input) Name from UDF volume.*/
  320         int udfLen)             /* (Input) Length of UDF Name. */
  321 {
  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
  325         int trailIndex = 0;
  326 #endif
  327         unsigned short valueCRC;
  328         unicode_t current;
  329         const char hexChar[] = "0123456789ABCDEF";
  330 
  331         for (index = 0; index < udfLen; index++) {
  332                 current = udfName[index];
  333 
  334                 if (IsIllegal(current) || !UnicodeIsPrint(current)) {
  335                         needsCRC = TRUE;
  336                         /* Replace Illegal and non-displayable chars with
  337                          * underscore.
  338                          */
  339                         current = ILLEGAL_CHAR_MARK;
  340                         /* Skip any other illegal or non-displayable
  341                          * characters.
  342                          */
  343                         while(index+1 < udfLen && (IsIllegal(udfName[index+1])
  344                             || !UnicodeIsPrint(udfName[index+1]))) {
  345                                 index++;
  346                         }
  347                 }
  348 
  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. */
  353                                 hasExt = FALSE;
  354                         } else {
  355                                 hasExt = TRUE;
  356                                 extIndex = index;
  357                                 newExtIndex = newIndex;
  358                         }
  359                 }
  360 
  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;
  365                 }
  366 #endif
  367 
  368                 if (newIndex < MAXLEN) {
  369                         newName[newIndex++] = current;
  370                 } else {
  371                         needsCRC = TRUE;
  372                 }
  373         }
  374 
  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;
  379                 needsCRC = TRUE;
  380                 hasExt = FALSE; /* Trailing period does not make an
  381                                  * extension. */
  382         }
  383 #endif
  384 
  385         if (needsCRC) {
  386                 unicode_t ext[EXT_SIZE];
  387                 int localExtIndex = 0;
  388                 if (hasExt) {
  389                         int maxFilenameLen;
  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)) {
  396                                         needsCRC = 1;
  397                                         /* Replace Illegal and non-displayable
  398                                          * chars with underscore.
  399                                          */
  400                                         current = ILLEGAL_CHAR_MARK;
  401                                         /* Skip any other illegal or
  402                                          * non-displayable characters.
  403                                          */
  404                                         while(index + 1 < EXT_SIZE
  405                                             && (IsIllegal(udfName[extIndex +
  406                                             index + 2]) ||
  407                                             !isprint(udfName[extIndex +
  408                                             index + 2]))) {
  409                                                 index++;
  410                                         }
  411                                 }
  412                                 ext[localExtIndex++] = current;
  413                         }
  414 
  415                         /* Truncate filename to leave room for extension and
  416                          * CRC.
  417                          */
  418                         maxFilenameLen = ((MAXLEN - 5) - localExtIndex - 1);
  419                         if (newIndex > maxFilenameLen) {
  420                                 newIndex = maxFilenameLen;
  421                         } else {
  422                                 newIndex = newExtIndex;
  423                         }
  424                 } else if (newIndex > MAXLEN - 5) {
  425                         /*If no extension, make sure to leave room for CRC. */
  426                         newIndex = MAXLEN - 5;
  427                 }
  428                 newName[newIndex++] = CRC_MARK; /* Add mark for CRC. */
  429 
  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)];
  437 
  438                 /* Place a translated extension at end, if found. */
  439                 if (hasExt) {
  440                         newName[newIndex++] = PERIOD;
  441                         for (index = 0;index < localExtIndex ;index++ ) {
  442                                 newName[newIndex++] = ext[index];
  443                         }
  444                 }
  445         }
  446         return(newIndex);
  447 }
  448 
  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().
  456  *
  457  * RETURN VALUE
  458  *
  459  * Non-zero if the Unicode character is in the given ASCII string.
  460  */
  461 int UnicodeInString(
  462         unsigned char *string,  /* (Input) String to search through. */
  463         unicode_t ch)           /* (Input) Unicode char to search for. */
  464 {
  465         int found = FALSE;
  466         while (*string != '\0' && found == FALSE) {
  467                 /* These types should compare, since both are unsigned
  468                  * numbers. */
  469                 if (*string == ch) {
  470                         found = TRUE;
  471                 }
  472                 string++;
  473         }
  474         return(found);
  475 }
  476 #endif /* OS2 */
  477 
  478 /***********************************************************************
  479  * Decides whether the given character is illegal for a given OS.
  480  *
  481  * RETURN VALUE
  482  *
  483  * Non-zero if char is illegal.
  484  */
  485 int IsIllegal(unicode_t ch)
  486 {
  487 #ifdef MAC
  488         /* Only illegal character on the MAC is the colon. */
  489         if (ch == 0x003A) {
  490                 return(1);
  491         } else {
  492                 return(0);
  493         }
  494 
  495 #elif defined UNIX
  496         /* Illegal UNIX characters are NULL and slash. */
  497         if (ch == 0x0000 || ch == 0x002F) {
  498                 return(1);
  499         } else {
  500                 return(0);
  501         }
  502 
  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)) {
  506                 return(1);
  507         } else {
  508                 return(0);
  509         }
  510 #endif
  511 }
  512 #endif
Cache object: 84774e690b7d5a4905929f53a603d5f6
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/udf/osta.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/udf/osta.c
