]> git.gag.com Git - debian/tar/blob - lib/paxnames.c
mark 1.29b-2 as not yet uploaded
[debian/tar] / lib / paxnames.c
1 /* This file is part of GNU paxutils
2    Copyright (C) 2005, 2007, 2010 Free Software Foundation, Inc.
3
4    This program is free software; you can redistribute it and/or modify it
5    under the terms of the GNU General Public License as published by the
6    Free Software Foundation; either version 3, or (at your option) any later
7    version.
8
9    This program is distributed in the hope that it will be useful, but
10    WITHOUT ANY WARRANTY; without even the implied warranty of
11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
12    Public License for more details.
13
14    You should have received a copy of the GNU General Public License along
15    with this program; if not, write to the Free Software Foundation, Inc.,
16    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
17
18 #include <system.h>
19 #include <hash.h>
20 #include <paxlib.h>
21
22 \f
23 /* Hash tables of strings.  */
24
25 /* Calculate the hash of a string.  */
26 static size_t
27 hash_string_hasher (void const *name, size_t n_buckets)
28 {
29   return hash_string (name, n_buckets);
30 }
31
32 /* Compare two strings for equality.  */
33 static bool
34 hash_string_compare (void const *name1, void const *name2)
35 {
36   return strcmp (name1, name2) == 0;
37 }
38
39 /* Return zero if TABLE contains a LEN-character long prefix of STRING,
40    otherwise, insert a newly allocated copy of this prefix to TABLE and
41    return 1.  If RETURN_PREFIX is not NULL, point it to the allocated
42    copy. */
43 static bool
44 hash_string_insert_prefix (Hash_table **table, char const *string, size_t len,
45                            const char **return_prefix)
46 {
47   Hash_table *t = *table;
48   char *s;
49   char *e;
50
51   if (len)
52     {
53       s = xmalloc (len + 1);
54       memcpy (s, string, len);
55       s[len] = 0;
56     }
57   else
58     s = xstrdup (string);
59
60   if (! ((t
61           || (*table = t = hash_initialize (0, 0, hash_string_hasher,
62                                             hash_string_compare, 0)))
63          && (e = hash_insert (t, s))))
64     xalloc_die ();
65
66   if (e == s)
67     {
68       if (return_prefix)
69         *return_prefix = s;
70       return 1;
71     }
72   else
73     {
74       free (s);
75       return 0;
76     }
77 }
78
79 \f
80 static Hash_table *prefix_table[2];
81
82 /* Return true if file names of some members in the archive were stripped off
83    their leading components. We could have used
84         return prefix_table[0] || prefix_table[1]
85    but the following seems to be safer: */
86 bool
87 removed_prefixes_p (void)
88 {
89   return (prefix_table[0] && hash_get_n_entries (prefix_table[0]) != 0)
90          || (prefix_table[1] && hash_get_n_entries (prefix_table[1]) != 0);
91 }
92
93 /* Return a safer suffix of FILE_NAME, or "." if it has no safer
94    suffix.  Check for fully specified file names and other atrocities.
95    Warn the user if we do not return NAME.  If LINK_TARGET is 1,
96    FILE_NAME is the target of a hard link, not a member name.
97    If ABSOLUTE_NAMES is 0, strip filesystem prefix from the file name. */
98
99 char *
100 safer_name_suffix (char const *file_name, bool link_target,
101                    bool absolute_names)
102 {
103   char const *p;
104
105   if (absolute_names)
106     p = file_name;
107   else
108     {
109       /* Skip file system prefixes, leading file name components that contain
110          "..", and leading slashes.  */
111
112       size_t prefix_len = FILE_SYSTEM_PREFIX_LEN (file_name);
113
114       for (p = file_name + prefix_len; *p; )
115         {
116           if (p[0] == '.' && p[1] == '.' && (ISSLASH (p[2]) || !p[2]))
117             prefix_len = p + 2 - file_name;
118
119           do
120             {
121               char c = *p++;
122               if (ISSLASH (c))
123                 break;
124             }
125           while (*p);
126         }
127
128       for (p = file_name + prefix_len; ISSLASH (*p); p++)
129         continue;
130       prefix_len = p - file_name;
131
132       if (prefix_len)
133         {
134           const char *prefix;
135           if (hash_string_insert_prefix (&prefix_table[link_target], file_name,
136                                          prefix_len, &prefix))
137             {
138               static char const *const diagnostic[] =
139               {
140                 N_("Removing leading `%s' from member names"),
141                 N_("Removing leading `%s' from hard link targets")
142               };
143               WARN ((0, 0, _(diagnostic[link_target]), prefix));
144             }
145         }
146     }
147
148   if (! *p)
149     {
150       if (p == file_name)
151         {
152           static char const *const diagnostic[] =
153           {
154             N_("Substituting `.' for empty member name"),
155             N_("Substituting `.' for empty hard link target")
156           };
157           WARN ((0, 0, "%s", _(diagnostic[link_target])));
158         }
159
160       p = ".";
161     }
162
163   return (char *) p;
164 }