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/10.3/sys/fs/udf/osta.c 193571 2009-06-06 07:13:57Z rwatson $
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 */
35int
36udf_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 */
81int
82udf_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 */
140int
141udf_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 */
178static 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
213unsigned short
214udf_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 */
226unsigned short
227udf_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
244unsigned char bytes[] = { 0x70, 0x6A, 0x77 };
245
246main()
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 APPLE_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 ***/
300int IsIllegal(unicode_t ch);
301
302/* Define a function or macro which determines if a Unicode character is
303 * printable under your implementation.
304 */
305int 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 */
316int 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 */
461int 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 */
485int IsIllegal(unicode_t ch)
486{
487#ifdef APPLE_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
513