File: /usr/src/linux/fs/umsdos/mangle.c
1 /*
2 * linux/fs/umsdos/mangle.c
3 *
4 * Written 1993 by Jacques Gelinas
5 *
6 * Control the mangling of file name to fit msdos name space.
7 * Many optimisations by GLU == dglaude@is1.vub.ac.be (Glaude David)
8 */
9
10 #include <linux/errno.h>
11 #include <linux/string.h>
12 #include <linux/kernel.h>
13 #include <linux/umsdos_fs.h>
14
15 /* (This file is used outside of the kernel) */
16 #ifndef __KERNEL__
17 #define KERN_WARNING
18 #endif
19
20 /*
21 * Complete the mangling of the MSDOS fake name
22 * based on the position of the entry in the EMD file.
23 *
24 * Simply complete the job of umsdos_parse; fill the extension.
25 *
26 * Beware that info->f_pos must be set.
27 */
28 void umsdos_manglename (struct umsdos_info *info)
29 {
30 if (info->msdos_reject) {
31 /* #Specification: file name / non MSDOS conforming / mangling
32 * Each non MSDOS conforming file has a special extension
33 * build from the entry position in the EMD file.
34 *
35 * This number is then transform in a base 32 number, where
36 * each digit is expressed like hexadecimal number, using
37 * digit and letter, except it uses 22 letters from 'a' to 'v'.
38 * The number 32 comes from 2**5. It is faster to split a binary
39 * number using a base which is a power of two. And I was 32
40 * when I started this project. Pick your answer :-) .
41 *
42 * If the result is '0', it is replace with '_', simply
43 * to make it odd.
44 *
45 * This is true for the first two character of the extension.
46 * The last one is taken from a list of odd character, which
47 * are:
48 *
49 * { } ( ) ! ` ^ & @
50 *
51 * With this scheme, we can produce 9216 ( 9* 32 * 32)
52 * different extensions which should not clash with any useful
53 * extension already popular or meaningful. Since most directory
54 * have much less than 32 * 32 files in it, the first character
55 * of the extension of any mangled name will be {.
56 *
57 * Here are the reason to do this (this kind of mangling).
58 *
59 * -The mangling is deterministic. Just by the extension, we
60 * are able to locate the entry in the EMD file.
61 *
62 * -By keeping to beginning of the file name almost unchanged,
63 * we are helping the MSDOS user.
64 *
65 * -The mangling produces names not too ugly, so an msdos user
66 * may live with it (remember it, type it, etc...).
67 *
68 * -The mangling produces names ugly enough so no one will
69 * ever think of using such a name in real life. This is not
70 * fool proof. I don't think there is a total solution to this.
71 */
72 int entry_num;
73 char *pt = info->fake.fname + info->fake.len;
74 /* lookup for encoding the last character of the extension
75 * It contains valid character after the ugly one to make sure
76 * even if someone overflows the 32 * 32 * 9 limit, it still
77 * does something
78 */
79 #define SPECIAL_MANGLING '{','}','(',')','!','`','^','&','@'
80 static char lookup3[] =
81 {
82 SPECIAL_MANGLING,
83 /* This is the start of lookup12 */
84 '_', '1', '2', '3', '4', '5', '6', '7', '8', '9',
85 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
86 'p', 'q', 'r', 's', 't', 'u', 'v'
87 };
88
89 #define lookup12 (lookup3+9)
90 entry_num = info->f_pos / UMSDOS_REC_SIZE;
91 if (entry_num > (9* 32 * 32)){
92 printk (KERN_WARNING "UMSDOS: more than 9216 files in a directory.\n"
93 "This may break the mangling strategy.\n"
94 "Not a killer problem. See doc.\n");
95 }
96 *pt++ = '.';
97 *pt++ = lookup3 [(entry_num >> 10) & 31];
98 *pt++ = lookup12[(entry_num >> 5) & 31];
99 *pt++ = lookup12[entry_num & 31];
100 *pt = '\0'; /* help doing printk */
101 info->fake.len += 4;
102 info->msdos_reject = 0; /* Avoid mangling twice */
103 }
104 }
105
106 /*
107 * Evaluate the record size needed to store of name of len character.
108 * The value returned is a multiple of UMSDOS_REC_SIZE.
109 */
110 int umsdos_evalrecsize (int len)
111 {
112 struct umsdos_dirent dirent;
113 int nbrec = 1 + ((len - 1 + (dirent.name - (char *) &dirent))
114 / UMSDOS_REC_SIZE);
115
116 return nbrec * UMSDOS_REC_SIZE;
117 /*
118 * GLU This should be inlined or something to speed it up to the max.
119 * GLU nbrec is absolutely not needed to return the value.
120 */
121 }
122 #ifdef TEST
123 int umsdos_evalrecsize_old (int len)
124 {
125 struct umsdos_dirent dirent;
126 int size = len + (dirent.name - (char *) &dirent);
127 int nbrec = size / UMSDOS_REC_SIZE;
128 int extra = size % UMSDOS_REC_SIZE;
129
130 if (extra > 0)
131 nbrec++;
132 return nbrec * UMSDOS_REC_SIZE;
133 }
134 #endif
135
136
137 /*
138 * Fill the struct info with the full and msdos name of a file
139 * Return 0 if all is OK, a negative error code otherwise.
140 */
141 int umsdos_parse (
142 const char *fname,
143 int len,
144 struct umsdos_info *info)
145 {
146 int ret = -ENAMETOOLONG;
147
148 /* #Specification: file name / too long
149 * If a file name exceed UMSDOS maxima, the file name is silently
150 * truncated. This makes it conformant with the other file system
151 * of Linux (minix and ext2 at least).
152 */
153 if (len > UMSDOS_MAXNAME)
154 len = UMSDOS_MAXNAME;
155 {
156 const char *firstpt = NULL; /* First place we saw a "." in fname */
157
158 /* #Specification: file name / non MSDOS conforming / base length 0
159 * file names beginning with a period '.' are invalid for MS-DOS.
160 * It needs absolutely a base name. So the file name is mangled
161 */
162 int ivldchar = fname[0] == '.'; /* At least one invalid character */
163 int msdos_len = len;
164 int base_len;
165
166 /*
167 * cardinal_per_size tells if there exists at least one
168 * DOS pseudo device on length n. See the test below.
169 */
170 static const char cardinal_per_size[9] =
171 {
172 0, 0, 0, 1, 1, 0, 1, 0, 1
173 };
174
175 /*
176 * lkp translate all character to acceptable character (for DOS).
177 * When lkp[n] == n, it means also it is an acceptable one.
178 * So it serves both as a flag and as a translator.
179 */
180 static char lkp[256];
181 static char is_init = 0;
182
183 if (!is_init) {
184 /*
185 * Initialisation of the array is easier and less error
186 * prone like this.
187 */
188 int i;
189 static const char *spc = "\"*+,/:;<=>?[\\]|~";
190
191 is_init = 1;
192 for (i = 0; i <= 32; i++)
193 lkp[i] = '#';
194 for (i = 33; i < 'A'; i++)
195 lkp[i] = (char) i;
196 for (i = 'A'; i <= 'Z'; i++)
197 lkp[i] = (char) (i + ('a' - 'A'));
198 for (i = 'Z' + 1; i < 127; i++)
199 lkp[i] = (char) i;
200 for (i = 128; i < 256; i++)
201 lkp[i] = '#';
202
203 lkp['.'] = '_';
204 while (*spc != '\0')
205 lkp[(unsigned char) (*spc++)] = '#';
206 }
207 /* GLU
208 * File names longer than 8+'.'+3 are invalid for MS-DOS,
209 * so the file name is to be mangled--no further test is needed.
210 * This speeds up handling of long names.
211 * The position of the last point is no more necessary anyway.
212 */
213 if (len <= (8 + 1 + 3)) {
214 const char *pt = fname;
215 const char *endpt = fname + len;
216
217 while (pt < endpt) {
218 if (*pt == '.') {
219 if (firstpt != NULL) {
220 /* 2 . in a file name. Reject */
221 ivldchar = 1;
222 break;
223 } else {
224 int extlen = (int) (endpt - pt);
225
226 firstpt = pt;
227 if (firstpt - fname > 8) {
228 /* base name longer than 8: reject */
229 ivldchar = 1;
230 break;
231 } else if (extlen > 4) {
232 /* Extension longer than 4 (including .): reject */
233 ivldchar = 1;
234 break;
235 } else if (extlen == 1) {
236 /* #Specification: file name / non MSDOS conforming / last char == .
237 * If the last character of a file name is
238 * a period, mangling is applied. MS-DOS does
239 * not support those file names.
240 */
241 ivldchar = 1;
242 break;
243 } else if (extlen == 4) {
244 /* #Specification: file name / non MSDOS conforming / mangling clash
245 * To avoid clash with the umsdos mangling, any file
246 * with a special character as the first character
247 * of the extension will be mangled. This solves the
248 * following problem:
249 *
250 * #
251 * touch FILE
252 * # FILE is invalid for DOS, so mangling is applied
253 * # file.{_1 is created in the DOS directory
254 * touch file.{_1
255 * # To UMSDOS file point to a single DOS entry.
256 * # So file.{_1 has to be mangled.
257 * #
258 */
259 static char special[] =
260 {
261 SPECIAL_MANGLING, '\0'
262 };
263
264 if (strchr (special, firstpt[1]) != NULL) {
265 ivldchar = 1;
266 break;
267 }
268 }
269 }
270 } else if (lkp[(unsigned char) (*pt)] != *pt) {
271 ivldchar = 1;
272 break;
273 }
274 pt++;
275 }
276 } else {
277 ivldchar = 1;
278 }
279 if (ivldchar
280 || (firstpt == NULL && len > 8)
281 || (len == UMSDOS_EMD_NAMELEN
282 && memcmp (fname, UMSDOS_EMD_FILE, UMSDOS_EMD_NAMELEN) == 0)) {
283 /* #Specification: file name / --linux-.---
284 * The name of the EMD file --linux-.--- is map to a mangled
285 * name. So UMSDOS does not restrict its use.
286 */
287 /* #Specification: file name / non MSDOS conforming / mangling
288 * Non MSDOS conforming file names must use some alias to fit
289 * in the MSDOS name space.
290 *
291 * The strategy is simple. The name is simply truncated to
292 * 8 char. points are replace with underscore and a
293 * number is given as an extension. This number correspond
294 * to the entry number in the EMD file. The EMD file
295 * only need to carry the real name.
296 *
297 * Upper case is also converted to lower case.
298 * Control character are converted to #.
299 * Spaces are converted to #.
300 * The following characters are also converted to #.
301 * #
302 * " * + , / : ; < = > ? [ \ ] | ~
303 * #
304 *
305 * Sometimes the problem is not in MS-DOS itself but in
306 * command.com.
307 */
308 int i;
309 char *pt = info->fake.fname;
310
311 base_len = msdos_len = (msdos_len > 8) ? 8 : msdos_len;
312 /*
313 * There is no '.' any more so we know for a fact that
314 * the base length is the length.
315 */
316 memcpy (info->fake.fname, fname, msdos_len);
317 for (i = 0; i < msdos_len; i++, pt++)
318 *pt = lkp[(unsigned char) (*pt)];
319 *pt = '\0'; /* GLU We force null termination. */
320 info->msdos_reject = 1;
321 /*
322 * The numeric extension is added only when we know
323 * the position in the EMD file, in umsdos_newentry(),
324 * umsdos_delentry(), and umsdos_findentry().
325 * See umsdos_manglename().
326 */
327 } else {
328 /* Conforming MSDOS file name */
329 strncpy (info->fake.fname, fname, len);
330 info->msdos_reject = 0;
331 base_len = firstpt != NULL ? (int) (firstpt - fname) : len;
332 }
333 if (cardinal_per_size[base_len]) {
334 /* #Specification: file name / MSDOS devices / mangling
335 * To avoid unreachable file from MS-DOS, any MS-DOS conforming
336 * file with a basename equal to one of the MS-DOS pseudo
337 * devices will be mangled.
338 *
339 * If a file such as "prn" was created, it would be unreachable
340 * under MS-DOS because "prn" is assumed to be the printer, even
341 * if the file does have an extension.
342 *
343 * Since the extension is unimportant to MS-DOS, we must patch
344 * the basename also. We simply insert a minus '-'. To avoid
345 * conflict with valid file with a minus in front (such as
346 * "-prn"), we add an mangled extension like any other
347 * mangled file name.
348 *
349 * Here is the list of DOS pseudo devices:
350 *
351 * #
352 * "prn","con","aux","nul",
353 * "lpt1","lpt2","lpt3","lpt4",
354 * "com1","com2","com3","com4",
355 * "clock$"
356 * #
357 *
358 * and some standard ones for common DOS programs
359 *
360 * "emmxxxx0","xmsxxxx0","setverxx"
361 *
362 * (Thanks to Chris Hall <cah17@phoenix.cambridge.ac.uk>
363 * for pointing these out to me).
364 *
365 * Is there one missing?
366 */
367 /* This table must be ordered by length */
368 static const char *tbdev[] =
369 {
370 "prn", "con", "aux", "nul",
371 "lpt1", "lpt2", "lpt3", "lpt4",
372 "com1", "com2", "com3", "com4",
373 "clock$",
374 "emmxxxx0", "xmsxxxx0", "setverxx"
375 };
376
377 /* Tell where to find in tbdev[], the first name of */
378 /* a certain length */
379 static const char start_ind_dev[9] =
380 {
381 0, 0, 0, 4, 12, 12, 13, 13, 16
382 };
383 char basen[9];
384 int i;
385
386 for (i = start_ind_dev[base_len - 1]; i < start_ind_dev[base_len]; i++) {
387 if (memcmp (info->fake.fname, tbdev[i], base_len) == 0) {
388 memcpy (basen, info->fake.fname, base_len);
389 basen[base_len] = '\0'; /* GLU We force null termination. */
390 /*
391 * GLU We do that only if necessary; we try to do the
392 * GLU simple thing in the usual circumstance.
393 */
394 info->fake.fname[0] = '-';
395 strcpy (info->fake.fname + 1, basen); /* GLU We already guaranteed a null would be at the end. */
396 msdos_len = (base_len == 8) ? 8 : base_len + 1;
397 info->msdos_reject = 1;
398 break;
399 }
400 }
401 }
402 info->fake.fname[msdos_len] = '\0'; /* Help doing printk */
403 /* GLU This zero should (always?) be there already. */
404 info->fake.len = msdos_len;
405 /* Why not use info->fake.len everywhere? Is it longer?
406 */
407 memcpy (info->entry.name, fname, len);
408 info->entry.name[len] = '\0'; /* for printk */
409 info->entry.name_len = len;
410 ret = 0;
411 }
412 /*
413 * Evaluate how many records are needed to store this entry.
414 */
415 info->recsize = umsdos_evalrecsize (len);
416 return ret;
417 }
418
419 #ifdef TEST
420
421 struct MANG_TEST {
422 char *fname; /* Name to validate */
423 int msdos_reject; /* Expected msdos_reject flag */
424 char *msname; /* Expected msdos name */
425 };
426
427 struct MANG_TEST tb[] =
428 {
429 "hello", 0, "hello",
430 "hello.1", 0, "hello.1",
431 "hello.1_", 0, "hello.1_",
432 "prm", 0, "prm",
433
434 #ifdef PROPOSITION
435 "HELLO", 1, "hello",
436 "Hello.1", 1, "hello.1",
437 "Hello.c", 1, "hello.c",
438 #else
439 /*
440 * I find the three examples below very unfortunate. I propose to
441 * convert them to lower case in a quick preliminary pass, then test
442 * whether there are other troublesome characters. I have not made
443 * this change, because it is not easy, but I wanted to mention the
444 * principle. Obviously something like that would increase the chance
445 * of collisions, for example between "HELLO" and "Hello", but these
446 * can be treated elsewhere along with the other collisions.
447 */
448
449 "HELLO", 1, "hello",
450 "Hello.1", 1, "hello_1",
451 "Hello.c", 1, "hello_c",
452 #endif
453
454 "hello.{_1", 1, "hello_{_",
455 "hello\t", 1, "hello#",
456 "hello.1.1", 1, "hello_1_",
457 "hel,lo", 1, "hel#lo",
458 "Salut.Tu.vas.bien?", 1, "salut_tu",
459 ".profile", 1, "_profile",
460 ".xv", 1, "_xv",
461 "toto.", 1, "toto_",
462 "clock$.x", 1, "-clock$",
463 "emmxxxx0", 1, "-emmxxxx",
464 "emmxxxx0.abcd", 1, "-emmxxxx",
465 "aux", 1, "-aux",
466 "prn", 1, "-prn",
467 "prn.abc", 1, "-prn",
468 "PRN", 1, "-prn",
469 /*
470 * GLU WARNING: the results of these are different with my version
471 * GLU of mangling compared to the original one.
472 * GLU CAUSE: the manner of calculating the baselen variable.
473 * GLU For you they are always 3.
474 * GLU For me they are respectively 7, 8, and 8.
475
476 */
477 "PRN.abc", 1, "prn_abc",
478 "Prn.abcd", 1, "prn_abcd",
479 "prn.abcd", 1, "prn_abcd",
480 "Prn.abcdefghij", 1, "prn_abcd"
481 };
482
483 int main (int argc, char *argv[])
484 {
485 int i, rold, rnew;
486
487 printf ("Testing the umsdos_parse.\n");
488 for (i = 0; i < sizeof (tb) / sizeof (tb[0]); i++) {
489 struct MANG_TEST *pttb = tb + i;
490 struct umsdos_info info;
491 int ok = umsdos_parse (pttb->fname, strlen (pttb->fname), &info);
492
493 if (strcmp (info.fake.fname, pttb->msname) != 0) {
494 printf ("**** %s -> ", pttb->fname);
495 printf ("%s <> %s\n", info.fake.fname, pttb->msname);
496 } else if (info.msdos_reject != pttb->msdos_reject) {
497 printf ("**** %s -> %s ", pttb->fname, pttb->msname);
498 printf ("%d <> %d\n", info.msdos_reject, pttb->msdos_reject);
499 } else {
500 printf (" %s -> %s %d\n", pttb->fname, pttb->msname
501 ,pttb->msdos_reject);
502 }
503 }
504 printf ("Testing the new umsdos_evalrecsize.");
505 for (i = 0; i < UMSDOS_MAXNAME; i++) {
506 rnew = umsdos_evalrecsize (i);
507 rold = umsdos_evalrecsize_old (i);
508 if (!(i % UMSDOS_REC_SIZE)) {
509 printf ("\n%d:\t", i);
510 }
511 if (rnew != rold) {
512 printf ("**** %d newres: %d != %d \n", i, rnew, rold);
513 } else {
514 printf (".");
515 }
516 }
517 printf ("\nEnd of Testing.\n");
518
519 return 0;
520 }
521
522 #endif
523