2 Unix SMB/CIFS implementation.
3 Name mangling with persistent tdb
4 Copyright (C) Simo Sorce 2001
5 Copyright (C) Andrew Bartlett 2002
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 /****************************************************************************
23 Rewritten from scrach in 2001 by Simo Sorce <idra@samba.org>
24 ****************************************************************************/
29 /* -------------------------------------------------------------------------- **
30 * External Variables...
33 extern int case_default; /* Are conforming 8.3 names all upper or lower? */
34 extern BOOL case_mangle; /* If true, all chars in 8.3 should be same case. */
36 char magic_char = '~';
38 /* -------------------------------------------------------------------- */
40 #define MANGLE_TDB_VERSION "20010927"
41 #define MANGLE_TDB_FILE_NAME "mangle.tdb"
42 #define MANGLED_PREFIX "MANGLED_"
43 #define LONG_PREFIX "LONG_"
44 #define COUNTER_PREFIX "COUNTER_"
45 #define MANGLE_COUNTER_MAX 99
46 #define MANGLE_SUFFIX_SIZE 3 /* "~XX" */
49 static TDB_CONTEXT *mangle_tdb;
51 BOOL init_mangle_tdb(void)
55 tdbfile = lock_path(MANGLE_TDB_FILE_NAME); /* this return a static pstring do not try to free it */
58 if (!(mangle_tdb = tdb_open_log(tdbfile, 0, TDB_DEFAULT, O_RDWR | O_CREAT, 0600)))
60 DEBUG(0, ("Unable to open Mangle TDB\n"));
67 /* trasform a unicode string into a dos charset string */
68 static int ucs2_to_dos(char *dest, const smb_ucs2_t *src, int dest_len)
73 dest_len = sizeof(pstring);
76 src_len = strlen_w(src)* sizeof(smb_ucs2_t);
78 ret = convert_string(CH_UCS2, CH_DOS, src, src_len, dest, dest_len);
79 if (dest_len) dest[MIN(ret, dest_len-1)] = 0;
84 /* trasform in a string that contain only valid chars for win filenames,
85 not including a '.' */
86 static void strvalid(smb_ucs2_t *src)
88 if (!src || !*src) return;
91 if (!isvalid83_w(*src) || *src == UCS2_CHAR('.')) *src = UCS2_CHAR('_');
97 /* return False if something fail and
98 * return 2 alloced unicode strings that contain prefix and extension
100 static NTSTATUS mangle_get_prefix(const smb_ucs2_t *ucs2_string, smb_ucs2_t **prefix, smb_ucs2_t **extension)
106 *prefix = strdup_w(ucs2_string);
109 DEBUG(0,("mangle_get_prefix: out of memory!\n"));
110 return NT_STATUS_NO_MEMORY;
112 if ((p = strrchr_w(*prefix, UCS2_CHAR('.'))))
114 ext_len = strlen_w(p+1);
115 if ((ext_len > 0) && (ext_len < 4) && (p != *prefix) &&
116 (NT_STATUS_IS_OK(has_valid_chars(p+1)))) /* check extension */
119 *extension = strdup_w(p+1);
122 DEBUG(0,("mangle_get_prefix: out of memory!\n"));
124 return NT_STATUS_NO_MEMORY;
132 /* mangled must contain only the file name, not a path.
133 and MUST be ZERO terminated */
134 smb_ucs2_t *unmangle(const smb_ucs2_t *mangled)
139 smb_ucs2_t *pref, *ext, *retstr;
140 size_t long_len, ext_len, muf_len;
142 if (strlen_w(mangled) > 12) return NULL;
143 if (!strchr_w(mangled, UCS2_CHAR('~'))) return NULL;
145 /* if it is a path refuse to proceed */
146 if (strchr_w(mangled, UCS2_CHAR('/'))) {
147 DEBUG(10, ("unmangle: cannot unmangle a path\n"));
151 if (NT_STATUS_IS_ERR(mangle_get_prefix(mangled, &pref, &ext)))
154 /* mangled names are stored lowercase only */
157 muf_len = ucs2_to_dos(mufname, pref, sizeof(mufname));
159 if (!muf_len) return NULL;
161 slprintf(keystr, sizeof(keystr) - 1, "%s%s", MANGLED_PREFIX, mufname);
163 key.dsize = strlen (keystr) + 1;
166 data = tdb_fetch(mangle_tdb, key);
168 if (!data.dptr) /* not found */
170 DEBUG(5,("unmangle: failed retrieve from db %s\n", tdb_errorstr(mangle_tdb)));
177 long_len = (data.dsize / 2) - 1;
178 ext_len = strlen_w(ext);
179 retstr = (smb_ucs2_t *)malloc((long_len + ext_len + 2)*sizeof(smb_ucs2_t));
182 DEBUG(0, ("unamngle: out of memory!\n"));
185 strncpy_w(retstr, (smb_ucs2_t *)data.dptr, long_len);
186 retstr[long_len] = UCS2_CHAR('.');
187 retstr[long_len + 1] = 0;
188 strncat_w(retstr, ext, ext_len);
192 retstr = strdup_w((smb_ucs2_t *)data.dptr);
195 DEBUG(0, ("unamngle: out of memory!\n"));
202 SAFE_FREE(data.dptr);
209 /* unmangled must contain only the file name, not a path.
210 and MUST be ZERO terminated.
211 return a new allocated string if the name is yet valid 8.3
212 or is mangled successfully.
213 return null on error.
216 smb_ucs2_t *mangle(const smb_ucs2_t *unmangled)
218 TDB_DATA data, key, klock;
226 smb_ucs2_t *mangled = NULL;
227 smb_ucs2_t *umpref, *ext, *p = NULL;
228 size_t pref_len, ext_len, ud83_len;
230 /* if it is a path refuse to proceed */
231 if (strchr_w(unmangled, UCS2_CHAR('/'))) {
232 DEBUG(10, ("mangle: cannot mangle a path\n"));
236 /* if it is a valid 8_3 do not mangle again */
237 if (NT_STATUS_IS_OK(is_8_3_w(unmangled)))
240 if (NT_STATUS_IS_ERR(mangle_get_prefix(unmangled, &umpref, &ext)))
243 /* test if the same is yet mangled */
246 pull_ucs2(NULL, longname, umpref, sizeof(longname), 0, STR_TERMINATE);
247 slprintf(keystr, sizeof(keystr)-1, "%s%s", LONG_PREFIX, longname);
249 key.dsize = strlen(keystr) + 1;
252 data = tdb_fetch (mangle_tdb, key);
253 if (!data.dptr) /* not found */
258 if (tdb_error(mangle_tdb) != TDB_ERR_NOEXIST)
260 DEBUG(0, ("mangle: database retrieval error: %s\n",
261 tdb_errorstr(mangle_tdb)));
265 /* if not find the first free possibile mangled name */
267 pos = strlen_w(umpref);
268 if ((8 - MANGLE_SUFFIX_SIZE) < pos)
269 pos = 8 - MANGLE_SUFFIX_SIZE;
276 char *unmangled_unix = acnv_u2ux(unmangled);
278 DEBUG(0, ("mangle: unable to mangle file name (%s)!\n",unmangled_unix));
279 SAFE_FREE(unmangled_unix);
282 strncpy_w(temp, umpref, pos);
286 /* convert any invalid char into '_' */
288 ud83_len = ucs2_to_dos(prefix, temp, sizeof(prefix));
289 if (!ud83_len) goto done;
291 while (ud83_len > 8 - MANGLE_SUFFIX_SIZE);
293 slprintf(keylock, sizeof(keylock)-1, "%s%s", COUNTER_PREFIX, prefix);
294 klock.dptr = keylock;
295 klock.dsize = strlen(keylock) + 1;
298 data.dptr = (char *)&c;
299 data.dsize = sizeof(uint32);
300 /* try to insert a new counter prefix, if it exist the call will
301 fail (correct) otherwise it will create a new entry with counter set
304 if(tdb_store(mangle_tdb, klock, data, TDB_INSERT) != TDB_SUCCESS)
306 if (tdb_error(mangle_tdb) != TDB_ERR_EXISTS)
308 char *unmangled_unix = acnv_u2ux(unmangled);
309 DEBUG(0, ("mangle: database store error: %s for filename: %s\n",
310 tdb_errorstr(mangle_tdb), unmangled_unix));
311 SAFE_FREE(unmangled_unix);
316 /* lock the mangle counter for this prefix */
317 if (tdb_chainlock(mangle_tdb, klock))
319 char *unmangled_unix = acnv_u2ux(unmangled);
321 DEBUG(0,("mangle: failed to lock database for filename %s\n!", unmangled_unix));
322 SAFE_FREE(unmangled_unix);
327 data = tdb_fetch(mangle_tdb, klock);
330 char *unmangled_unix = acnv_u2ux(unmangled);
332 DEBUG(0, ("mangle: database retrieval error: %s for filename: %s\n",
333 tdb_errorstr(mangle_tdb), unmangled_unix));
334 SAFE_FREE(unmangled_unix);
337 c = *((uint32 *)data.dptr);
340 if (c > MANGLE_COUNTER_MAX)
342 char *unmangled_unix = acnv_u2ux(unmangled);
344 DEBUG(0, ("mangle: error, counter overflow (max=%d, counter=%d) for file: [%s] prefix (dos charset): [%s]!\n", MANGLE_COUNTER_MAX, c, unmangled_unix, prefix));
345 SAFE_FREE(unmangled_unix);
349 temp[pos] = UCS2_CHAR('~');
351 snprintf(suffix, 7, "%.6d", c);
352 strncat_wa(temp, &suffix[7 - MANGLE_SUFFIX_SIZE], MANGLE_SUFFIX_SIZE);
354 ud83_len = ucs2_to_dos(mufname, temp, sizeof(mufname));
355 if (!ud83_len) goto done;
358 char *unmangled_unix = acnv_u2ux(unmangled);
360 DEBUG(0, ("mangle: darn, logic error aborting! Filename was %s\n", unmangled_unix));
361 SAFE_FREE(unmangled_unix);
365 /* store the long entry with mangled key */
366 slprintf(keystr, sizeof(keystr)-1, "%s%s", MANGLED_PREFIX, mufname);
368 key.dsize = strlen (keystr) + 1;
369 data.dsize = (strlen_w(umpref) + 1) * sizeof (smb_ucs2_t);
370 data.dptr = (void *)umpref;
372 if (tdb_store(mangle_tdb, key, data, TDB_INSERT) != TDB_SUCCESS)
374 char *unmangled_unix = acnv_u2ux(unmangled);
376 DEBUG(0, ("mangle: database store error: %s for filename: %s\n",
377 tdb_errorstr(mangle_tdb), unmangled_unix));
378 SAFE_FREE(unmangled_unix);
382 /* store the mangled entry with long key*/
383 pull_ucs2(NULL, longname, umpref, sizeof(longname), 0, STR_TERMINATE);
384 slprintf(keystr, sizeof(keystr)-1, "%s%s", LONG_PREFIX, longname);
386 key.dsize = strlen (keystr) + 1;
387 data.dsize = strlen(mufname) + 1;
389 if (tdb_store(mangle_tdb, key, data, TDB_INSERT) != TDB_SUCCESS)
391 char *unmangled_unix = acnv_u2ux(unmangled);
392 DEBUG(0, ("mangle: database store failed: %s for filename: %s\n",
393 tdb_errorstr(mangle_tdb), unmangled_unix));
394 SAFE_FREE(unmangled_unix);
396 /* try to delete the mangled key entry to avoid later inconsistency */
397 slprintf(keystr, sizeof(keystr)-1, "%s%s", MANGLED_PREFIX, mufname);
399 key.dsize = strlen (keystr) + 1;
400 if (!tdb_delete(mangle_tdb, key))
402 DEBUG(0, ("mangle: severe error, mangled tdb may be inconsistent!\n"));
410 DEBUG(0,("mangle: out of memory!\n"));
414 data.dptr = (char *)&c;
415 data.dsize = sizeof(uint32);
416 /* store the counter */
417 if(tdb_store(mangle_tdb, klock, data, TDB_REPLACE) != TDB_SUCCESS)
419 char *unmangled_unix = acnv_u2ux(unmangled);
420 DEBUG(0, ("mangle: database store failed: %s for filename: %s\n",
421 tdb_errorstr(mangle_tdb), unmangled_unix));
422 SAFE_FREE(unmangled_unix);
423 /* try to delete the mangled and long key entry to avoid later inconsistency */
424 slprintf(keystr, sizeof(keystr)-1, "%s%s", MANGLED_PREFIX, mufname);
426 key.dsize = strlen (keystr) + 1;
427 if (!tdb_delete(mangle_tdb, key))
429 DEBUG(0, ("mangle: severe error, mangled tdb may be inconsistent!\n"));
431 slprintf(keystr, sizeof(keystr)-1, "%s%s", LONG_PREFIX, longname);
433 key.dsize = strlen (keystr) + 1;
434 if (!tdb_delete(mangle_tdb, key))
436 DEBUG(0, ("mangle: severe error, mangled tdb may be inconsistent!\n"));
442 tdb_chainunlock(mangle_tdb, klock);
446 p = acnv_dosu2(data.dptr);
449 DEBUG(0,("mangle: internal error acnv_dosu2() failed!\n"));
456 pref_len = strlen_w(p);
457 ext_len = strlen_w(ext);
458 mangled = (smb_ucs2_t *)malloc((pref_len + ext_len + 2)*sizeof(smb_ucs2_t));
461 DEBUG(0,("mangle: out of memory!\n"));
464 strncpy_w (mangled, p, pref_len);
465 mangled[pref_len] = UCS2_CHAR('.');
466 mangled[pref_len + 1] = 0;
467 strncat_w (mangled, ext, ext_len);
471 mangled = strdup_w(p);
474 DEBUG(0,("mangle: out of memory!\n"));
479 /* mangled name are returned in upper or lower case depending on
480 case_default value */
484 if (tclock) tdb_chainunlock(mangle_tdb, klock);
493 /* non unicode compatibility functions */
495 char *dos_mangle(const char *dos_unmangled)
497 smb_ucs2_t *in, *out;
500 if (!dos_unmangled || !*dos_unmangled) return NULL;
502 in = acnv_dosu2(dos_unmangled);
505 DEBUG(0,("dos_mangle: internal error acnv_dosu2() failed!\n"));
516 dos_mangled = acnv_u2dos(out);
519 DEBUG(0,("dos_mangle: internal error acnv_u2dos() failed!\n"));
529 char *dos_unmangle(const char *dos_mangled)
531 smb_ucs2_t *in, *out;
534 if (!dos_mangled || !*dos_mangled) return NULL;
536 in = acnv_dosu2(dos_mangled);
539 DEBUG(0,("dos_unmangle: internal error acnv_dosu2() failed!\n"));
550 dos_unmangled = acnv_u2dos(out);
553 DEBUG(0,("dos_unmangle: internal error acnv_u2dos failed!\n"));
560 return dos_unmangled;
563 BOOL is_8_3(const char *fname, BOOL check_case)
566 smb_ucs2_t *ucs2name;
567 NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
569 if (!fname || !*fname) return False;
570 if ((f = strrchr(fname, '/')) == NULL) f = fname;
573 DEBUG(10,("is_8_3: testing [%s]\n", f));
575 if (strlen(f) > 12) return False;
577 ucs2name = acnv_uxu2(f);
580 DEBUG(0,("is_8_3: internal error acnv_uxu2() failed!\n"));
584 ret = is_8_3_w(ucs2name);
589 DEBUG(10,("is_8_3: returning -> %s\n", NT_STATUS_IS_OK(ret)?"True":"False"));
591 if (NT_STATUS_IS_ERR(ret)) return False;
595 NTSTATUS is_8_3_w(const smb_ucs2_t *fname)
597 smb_ucs2_t *pref = 0, *ext = 0;
599 NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
601 if (!fname || !*fname) return NT_STATUS_INVALID_PARAMETER;
603 DEBUG(10,("is_8_3_w: testing\n")); /* [%s]\n", fname)); */
605 if (strlen_w(fname) > 12) return NT_STATUS_UNSUCCESSFUL;
607 if (strcmp_wa(fname, ".") == 0 || strcmp_wa(fname, "..") == 0)
610 if (NT_STATUS_IS_ERR(is_valid_name(fname))) goto done;
612 if (NT_STATUS_IS_ERR(mangle_get_prefix(fname, &pref, &ext))) goto done;
613 plen = strlen_w(pref);
615 if (strchr_wa(pref, '.')) goto done;
616 if (plen < 1 || plen > 8) goto done;
617 if (ext) if (strlen_w(ext) > 3) goto done;
627 NTSTATUS has_valid_chars(const smb_ucs2_t *s)
629 NTSTATUS ret = NT_STATUS_OK;
631 if (!s || !*s) return NT_STATUS_INVALID_PARAMETER;
633 DEBUG(10,("has_valid_chars: testing\n")); /* [%s]\n", s)); */
635 /* CHECK: this should not be necessary if the ms wild chars
636 are not valid in valid.dat --- simo */
637 if (ms_has_wild_w(s)) return NT_STATUS_UNSUCCESSFUL;
640 if(!isvalid83_w(*s)) return NT_STATUS_UNSUCCESSFUL;
647 NTSTATUS is_valid_name(const smb_ucs2_t *fname)
650 NTSTATUS ret = NT_STATUS_OK;
652 if (!fname || !*fname) return NT_STATUS_INVALID_PARAMETER;
654 DEBUG(10,("is_valid_name: testing\n")); /* [%s]\n", s)); */
656 if (*fname == UCS2_CHAR('.')) return NT_STATUS_UNSUCCESSFUL;
658 ret = has_valid_chars(fname);
659 if (NT_STATUS_IS_ERR(ret)) return ret;
661 str = strdup_w(fname);
662 p = strchr_w(str, UCS2_CHAR('.'));
670 if(strcmp_wa(p, "UX") == 0)
671 ret = NT_STATUS_UNSUCCESSFUL;
674 if((strcmp_wa(p, "LOCK$") == 0)
675 || (strcmp_wa(p, "ON") == 0)
676 || (strcmp_wa(p, "OM1") == 0)
677 || (strcmp_wa(p, "OM2") == 0)
678 || (strcmp_wa(p, "OM3") == 0)
679 || (strcmp_wa(p, "OM4") == 0)
681 ret = NT_STATUS_UNSUCCESSFUL;
684 if((strcmp_wa(p, "PT1") == 0)
685 || (strcmp_wa(p, "PT2") == 0)
686 || (strcmp_wa(p, "PT3") == 0)
688 ret = NT_STATUS_UNSUCCESSFUL;
691 if(strcmp_wa(p, "UL") == 0)
692 ret = NT_STATUS_UNSUCCESSFUL;
695 if(strcmp_wa(p, "RN") == 0)
696 ret = NT_STATUS_UNSUCCESSFUL;
706 BOOL is_mangled(const char *s)
708 smb_ucs2_t *u2, *res;
711 DEBUG(10,("is_mangled: testing [%s]\n", s));
713 if (!s || !*s) return False;
714 if ((strlen(s) > 12) || (!strchr(s, '~'))) return False;
719 DEBUG(0,("is_mangled: internal error acnv_dosu2() failed!!\n"));
727 DEBUG(10,("is_mangled: returning [%s]\n", ret?"True":"False"));
731 NTSTATUS is_mangled_w(const smb_ucs2_t *s)
734 NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
737 if (res) ret = NT_STATUS_OK;
742 NTSTATUS path_has_mangled(const smb_ucs2_t *s)
744 smb_ucs2_t *p, *f, *b;
745 NTSTATUS ret = NT_STATUS_UNSUCCESSFUL;
747 if (!s || !*s) return NT_STATUS_INVALID_PARAMETER;
750 if (!p) return NT_STATUS_NO_MEMORY;
751 trim_string_wa(p, "/", "/");
754 b = strchr_w(f, UCS2_CHAR('/'));
756 if (NT_STATUS_IS_OK(is_mangled_w(f))) {
767 /* backward compatibility functions */
769 void reset_mangled_cache(void)
771 DEBUG(10,("reset_mangled_cache: compatibility function, remove me!\n"));
774 BOOL check_mangled_cache(char *s)
776 smb_ucs2_t *u2, *res;
779 DEBUG(10,("check_mangled_cache: I'm so ugly, please remove me!\n"));
780 DEBUG(10,("check_mangled_cache: testing -> [%s]\n", s));
782 if (!s || !*s) return False;
787 DEBUG(0,("check_mangled_cache: out of memory!\n"));
795 ucs2_to_dos (s, res, PSTRING_LEN);
796 /* We MUST change this brainded interface,
797 we do not know how many chars will be used
798 in dos so i guess they will be no more than
799 double the size of the unicode string
801 DEBUG(10,("check_mangled_cache: returning -> [%s]\n", s));
806 DEBUG(10,("check_mangled_cache: returning -> %s\n", ret?"True":"False"));
810 void mangle_name_83(char *s)
812 smb_ucs2_t *u2, *res;
814 DEBUG(10,("mangle_name_83: I'm so ugly, please remove me!\n"));
815 DEBUG(10,("mangle_name_83: testing -> [%s]\n", s));
817 if (!s || !*s) return;
822 DEBUG(0,("mangle_name_83: internal error acnv_dosu2() failed!\n"));
827 if (res) ucs2_to_dos (s, res, 13); /* ugly, but must be done this way */
828 DEBUG(10,("mangle_name_83: returning -> [%s]\n", s));
833 BOOL name_map_mangle(char *OutName, BOOL need83, BOOL cache83, int snum)
835 DEBUG(10,("name_map_mangle: I'm so ugly, please remove me!\n"));
837 if (!need83) return True;
838 /* if (is_8_3(OutName, True)) return True; */
839 /* Warning: we should check for invalid chars in file name and mangle
840 if invalid chars found --simo*/
842 mangle_name_83(OutName);
848 #if 0 /* TEST_MANGLE_CODE */
850 #define LONG "this_is_a_long_file_name"
851 #define LONGM "this_~01"
852 #define SHORT "short"
853 #define SHORTM "short~01"
857 #define EXTFAIL "longext"
860 static void unmangle_test (char *name, char *ext)
862 smb_ucs2_t ucs2_name[2048];
866 push_ucs2(NULL, ucs2_name, name, sizeof(ucs2_name), STR_TERMINATE);
869 strncat_wa(ucs2_name, ".", 1);
870 strncat_wa(ucs2_name, ext, strlen(ext) + 1);
872 retstr = unmangle(ucs2_name);
873 if(retstr) pull_ucs2(NULL, unix_name, retstr, sizeof(unix_name), 0, STR_TERMINATE);
874 else unix_name[0] = 0;
875 if (ext) printf ("[%s.%s] ---> [%s]\n", name, ext, unix_name);
876 else printf ("[%s] ---> [%s]\n", name, unix_name);
880 static void mangle_test (char *name, char *ext)
882 smb_ucs2_t ucs2_name[2048];
886 push_ucs2(NULL, ucs2_name, name, sizeof(ucs2_name), STR_TERMINATE);
889 strncat_wa(ucs2_name, ".", 1);
890 strncat_wa(ucs2_name, ext, strlen(ext) + 1);
892 retstr = mangle(ucs2_name);
893 if(retstr) pull_ucs2(NULL, unix_name, retstr, sizeof(unix_name), 0, STR_TERMINATE);
894 else unix_name[0] = 0;
895 if (ext) printf ("[%s.%s] ---> [%s]\n", name, ext, unix_name);
896 else printf ("[%s] ---> [%s]\n", name, unix_name);
900 void mangle_test_code(void)
905 printf("Unmangle test 1:\n");
907 unmangle_test (LONG, NULL);
908 unmangle_test (LONG, EXT1);
909 unmangle_test (LONG, EXT2);
910 unmangle_test (LONG, EXT3);
911 unmangle_test (LONG, EXTFAIL);
912 unmangle_test (LONG, EXTNULL);
914 unmangle_test (LONGM, NULL);
915 unmangle_test (LONGM, EXT1);
916 unmangle_test (LONGM, EXT2);
917 unmangle_test (LONGM, EXT3);
918 unmangle_test (LONGM, EXTFAIL);
919 unmangle_test (LONGM, EXTNULL);
921 unmangle_test (SHORT, NULL);
922 unmangle_test (SHORT, EXT1);
923 unmangle_test (SHORT, EXT2);
924 unmangle_test (SHORT, EXT3);
925 unmangle_test (SHORT, EXTFAIL);
926 unmangle_test (SHORT, EXTNULL);
928 unmangle_test (SHORTM, NULL);
929 unmangle_test (SHORTM, EXT1);
930 unmangle_test (SHORTM, EXT2);
931 unmangle_test (SHORTM, EXT3);
932 unmangle_test (SHORTM, EXTFAIL);
933 unmangle_test (SHORTM, EXTNULL);
936 printf("Mangle test\n");
938 mangle_test (LONG, NULL);
939 mangle_test (LONG, EXT1);
940 mangle_test (LONG, EXT2);
941 mangle_test (LONG, EXT3);
942 mangle_test (LONG, EXTFAIL);
943 mangle_test (LONG, EXTNULL);
945 mangle_test (LONGM, NULL);
946 mangle_test (LONGM, EXT1);
947 mangle_test (LONGM, EXT2);
948 mangle_test (LONGM, EXT3);
949 mangle_test (LONGM, EXTFAIL);
950 mangle_test (LONGM, EXTNULL);
952 mangle_test (SHORT, NULL);
953 mangle_test (SHORT, EXT1);
954 mangle_test (SHORT, EXT2);
955 mangle_test (SHORT, EXT3);
956 mangle_test (SHORT, EXTFAIL);
957 mangle_test (SHORT, EXTNULL);
959 mangle_test (SHORTM, NULL);
960 mangle_test (SHORTM, EXT1);
961 mangle_test (SHORTM, EXT2);
962 mangle_test (SHORTM, EXT3);
963 mangle_test (SHORTM, EXTFAIL);
964 mangle_test (SHORTM, EXTNULL);
966 /* unmangle again every */
967 printf("Unmangle test 2:\n");
969 unmangle_test (LONG, NULL);
970 unmangle_test (LONG, EXT1);
971 unmangle_test (LONG, EXT2);
972 unmangle_test (LONG, EXT3);
973 unmangle_test (LONG, EXTFAIL);
974 unmangle_test (LONG, EXTNULL);
976 unmangle_test (LONGM, NULL);
977 unmangle_test (LONGM, EXT1);
978 unmangle_test (LONGM, EXT2);
979 unmangle_test (LONGM, EXT3);
980 unmangle_test (LONGM, EXTFAIL);
981 unmangle_test (LONGM, EXTNULL);
983 unmangle_test (SHORT, NULL);
984 unmangle_test (SHORT, EXT1);
985 unmangle_test (SHORT, EXT2);
986 unmangle_test (SHORT, EXT3);
987 unmangle_test (SHORT, EXTFAIL);
988 unmangle_test (SHORT, EXTNULL);
990 unmangle_test (SHORTM, NULL);
991 unmangle_test (SHORTM, EXT1);
992 unmangle_test (SHORTM, EXT2);
993 unmangle_test (SHORTM, EXT3);
994 unmangle_test (SHORTM, EXTFAIL);
995 unmangle_test (SHORTM, EXTNULL);
998 #endif /* TEST_MANGLE_CODE */