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