contrib/xz/src/xz/suffix.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       suffix.c
   4 /// \brief      Checks filename suffix and creates the destination filename
   5 //
   6 //  Author:     Lasse Collin
   7 //
   8 //  This file has been put into the public domain.
   9 //  You can do whatever you want with this file.
  10 //
  11 ///////////////////////////////////////////////////////////////////////////////
  12
  13 #include "private.h"
  14
  15 #ifdef __DJGPP__
  16 #       include <fcntl.h>
  17 #endif
  18
  19 // For case-insensitive filename suffix on case-insensitive systems
  20 #if defined(TUKLIB_DOSLIKE) || defined(__VMS)
  21 #       ifdef HAVE_STRINGS_H
  22 #               include <strings.h>
  23 #       endif
  24 #       define strcmp strcasecmp
  25 #endif
  26
  27
  28 static char *custom_suffix = NULL;
  29
  30
  31 /// \brief      Test if the char is a directory separator
  32 static bool
  33 is_dir_sep(char c)
  34 {
  35 #ifdef TUKLIB_DOSLIKE
  36         return c == '/' || c == '\\' || c == ':';
  37 #else
  38         return c == '/';
  39 #endif
  40 }
  41
  42
  43 /// \brief      Test if the string contains a directory separator
  44 static bool
  45 has_dir_sep(const char *str)
  46 {
  47 #ifdef TUKLIB_DOSLIKE
  48         return strpbrk(str, "/\\:") != NULL;
  49 #else
  50         return strchr(str, '/') != NULL;
  51 #endif
  52 }
  53
  54
  55 #ifdef __DJGPP__
  56 /// \brief      Test for special suffix used for 8.3 short filenames (SFN)
  57 ///
  58 /// \return     If str matches *.?- or *.??-, true is returned. Otherwise
  59 ///             false is returned.
  60 static bool
  61 has_sfn_suffix(const char *str, size_t len)
  62 {
  63         if (len >= 4 && str[len - 1] == '-' && str[len - 2] != '.'
  64                         && !is_dir_sep(str[len - 2])) {
  65                 // *.?-
  66                 if (str[len - 3] == '.')
  67                         return !is_dir_sep(str[len - 4]);
  68
  69                 // *.??-
  70                 if (len >= 5 && !is_dir_sep(str[len - 3])
  71                                 && str[len - 4] == '.')
  72                         return !is_dir_sep(str[len - 5]);
  73         }
  74
  75         return false;
  76 }
  77 #endif
  78
  79
  80 /// \brief      Checks if src_name has given compressed_suffix
  81 ///
  82 /// \param      suffix      Filename suffix to look for
  83 /// \param      src_name    Input filename
  84 /// \param      src_len     strlen(src_name)
  85 ///
  86 /// \return     If src_name has the suffix, src_len - strlen(suffix) is
  87 ///             returned. It's always a positive integer. Otherwise zero
  88 ///             is returned.
  89 static size_t
  90 test_suffix(const char *suffix, const char *src_name, size_t src_len)
  91 {
  92         const size_t suffix_len = strlen(suffix);
  93
  94         // The filename must have at least one character in addition to
  95         // the suffix. src_name may contain path to the filename, so we
  96         // need to check for directory separator too.
  97         if (src_len <= suffix_len
  98                         || is_dir_sep(src_name[src_len - suffix_len - 1]))
  99                 return 0;
 100
 101         if (strcmp(suffix, src_name + src_len - suffix_len) == 0)
 102                 return src_len - suffix_len;
 103
 104         return 0;
 105 }
 106
 107
 108 /// \brief      Removes the filename suffix of the compressed file
 109 ///
 110 /// \return     Name of the uncompressed file, or NULL if file has unknown
 111 ///             suffix.
 112 static char *
 113 uncompressed_name(const char *src_name, const size_t src_len)
 114 {
 115         static const struct {
 116                 const char *compressed;
 117                 const char *uncompressed;
 118         } suffixes[] = {
 119                 { ".xz",    "" },
 120                 { ".txz",   ".tar" }, // .txz abbreviation for .txt.gz is rare.
 121                 { ".lzma",  "" },
 122 #ifdef __DJGPP__
 123                 { ".lzm",   "" },
 124 #endif
 125                 { ".tlz",   ".tar" }, // Both .tar.lzma and .tar.lz
 126 #ifdef HAVE_LZIP_DECODER
 127                 { ".lz",    "" },
 128 #endif
 129         };
 130
 131         const char *new_suffix = "";
 132         size_t new_len = 0;
 133
 134         if (opt_format != FORMAT_RAW) {
 135                 for (size_t i = 0; i < ARRAY_SIZE(suffixes); ++i) {
 136                         new_len = test_suffix(suffixes[i].compressed,
 137                                         src_name, src_len);
 138                         if (new_len != 0) {
 139                                 new_suffix = suffixes[i].uncompressed;
 140                                 break;
 141                         }
 142                 }
 143
 144 #ifdef __DJGPP__
 145                 // Support also *.?- -> *.? and *.??- -> *.?? on DOS.
 146                 // This is done also when long filenames are available
 147                 // to keep it easy to decompress files created when
 148                 // long filename support wasn't available.
 149                 if (new_len == 0 && has_sfn_suffix(src_name, src_len)) {
 150                         new_suffix = "";
 151                         new_len = src_len - 1;
 152                 }
 153 #endif
 154         }
 155
 156         if (new_len == 0 && custom_suffix != NULL)
 157                 new_len = test_suffix(custom_suffix, src_name, src_len);
 158
 159         if (new_len == 0) {
 160                 message_warning(_("%s: Filename has an unknown suffix, "
 161                                 "skipping"), src_name);
 162                 return NULL;
 163         }
 164
 165         const size_t new_suffix_len = strlen(new_suffix);
 166         char *dest_name = xmalloc(new_len + new_suffix_len + 1);
 167
 168         memcpy(dest_name, src_name, new_len);
 169         memcpy(dest_name + new_len, new_suffix, new_suffix_len);
 170         dest_name[new_len + new_suffix_len] = '\0';
 171
 172         return dest_name;
 173 }
 174
 175
 176 /// This message is needed in multiple places in compressed_name(),
 177 /// so the message has been put into its own function.
 178 static void
 179 msg_suffix(const char *src_name, const char *suffix)
 180 {
 181         message_warning(_("%s: File already has `%s' suffix, skipping"),
 182                         src_name, suffix);
 183         return;
 184 }
 185
 186
 187 /// \brief      Appends suffix to src_name
 188 ///
 189 /// In contrast to uncompressed_name(), we check only suffixes that are valid
 190 /// for the specified file format.
 191 static char *
 192 compressed_name(const char *src_name, size_t src_len)
 193 {
 194         // The order of these must match the order in args.h.
 195         static const char *const all_suffixes[][4] = {
 196                 {
 197                         ".xz",
 198                         ".txz",
 199                         NULL
 200                 }, {
 201                         ".lzma",
 202 #ifdef __DJGPP__
 203                         ".lzm",
 204 #endif
 205                         ".tlz",
 206                         NULL
 207 #ifdef HAVE_LZIP_DECODER
 208                 // This is needed to keep the table indexing in sync with
 209                 // enum format_type from coder.h.
 210                 }, {
 211 /*
 212                         ".lz",
 213 */
 214                         NULL
 215 #endif
 216                 }, {
 217                         // --format=raw requires specifying the suffix
 218                         // manually or using stdout.
 219                         NULL
 220                 }
 221         };
 222
 223         // args.c ensures these.
 224         assert(opt_format != FORMAT_AUTO);
 225 #ifdef HAVE_LZIP_DECODER
 226         assert(opt_format != FORMAT_LZIP);
 227 #endif
 228
 229         const size_t format = opt_format - 1;
 230         const char *const *suffixes = all_suffixes[format];
 231
 232         // Look for known filename suffixes and refuse to compress them.
 233         for (size_t i = 0; suffixes[i] != NULL; ++i) {
 234                 if (test_suffix(suffixes[i], src_name, src_len) != 0) {
 235                         msg_suffix(src_name, suffixes[i]);
 236                         return NULL;
 237                 }
 238         }
 239
 240 #ifdef __DJGPP__
 241         // Recognize also the special suffix that is used when long
 242         // filename (LFN) support isn't available. This suffix is
 243         // recognized on LFN systems too.
 244         if (opt_format == FORMAT_XZ && has_sfn_suffix(src_name, src_len)) {
 245                 msg_suffix(src_name, "-");
 246                 return NULL;
 247         }
 248 #endif
 249
 250         if (custom_suffix != NULL) {
 251                 if (test_suffix(custom_suffix, src_name, src_len) != 0) {
 252                         msg_suffix(src_name, custom_suffix);
 253                         return NULL;
 254                 }
 255         }
 256
 257         const char *suffix = custom_suffix != NULL
 258                         ? custom_suffix : suffixes[0];
 259         size_t suffix_len = strlen(suffix);
 260
 261 #ifdef __DJGPP__
 262         if (!_use_lfn(src_name)) {
 263                 // Long filename (LFN) support isn't available and we are
 264                 // limited to 8.3 short filenames (SFN).
 265                 //
 266                 // Look for suffix separator from the filename, and make sure
 267                 // that it is in the filename, not in a directory name.
 268                 const char *sufsep = strrchr(src_name, '.');
 269                 if (sufsep == NULL || sufsep[1] == '\0'
 270                                 || has_dir_sep(sufsep)) {
 271                         // src_name has no filename extension.
 272                         //
 273                         // Examples:
 274                         // xz foo         -> foo.xz
 275                         // xz -F lzma foo -> foo.lzm
 276                         // xz -S x foo    -> foox
 277                         // xz -S x foo.   -> foo.x
 278                         // xz -S x.y foo  -> foox.y
 279                         // xz -S .x foo   -> foo.x
 280                         // xz -S .x foo.  -> foo.x
 281                         //
 282                         // Avoid double dots:
 283                         if (sufsep != NULL && sufsep[1] == '\0'
 284                                         && suffix[0] == '.')
 285                                 --src_len;
 286
 287                 } else if (custom_suffix == NULL
 288                                 && strcasecmp(sufsep, ".tar") == 0) {
 289                         // ".tar" is handled specially.
 290                         //
 291                         // Examples:
 292                         // xz foo.tar          -> foo.txz
 293                         // xz -F lzma foo.tar  -> foo.tlz
 294                         static const char *const tar_suffixes[] = {
 295                                 ".txz", // .tar.xz
 296                                 ".tlz", // .tar.lzma
 297 /*
 298                                 ".tlz", // .tar.lz
 299 */
 300                         };
 301                         suffix = tar_suffixes[format];
 302                         suffix_len = 4;
 303                         src_len -= 4;
 304
 305                 } else {
 306                         if (custom_suffix == NULL && opt_format == FORMAT_XZ) {
 307                                 // Instead of the .xz suffix, use a single
 308                                 // character at the end of the filename
 309                                 // extension. This is to minimize name
 310                                 // conflicts when compressing multiple files
 311                                 // with the same basename. E.g. foo.txt and
 312                                 // foo.exe become foo.tx- and foo.ex-. Dash
 313                                 // is rare as the last character of the
 314                                 // filename extension, so it seems to be
 315                                 // quite safe choice and it stands out better
 316                                 // in directory listings than e.g. x. For
 317                                 // comparison, gzip uses z.
 318                                 suffix = "-";
 319                                 suffix_len = 1;
 320                         }
 321
 322                         if (suffix[0] == '.') {
 323                                 // The first character of the suffix is a dot.
 324                                 // Throw away the original filename extension
 325                                 // and replace it with the new suffix.
 326                                 //
 327                                 // Examples:
 328                                 // xz -F lzma foo.txt  -> foo.lzm
 329                                 // xz -S .x  foo.txt   -> foo.x
 330                                 src_len = sufsep - src_name;
 331
 332                         } else {
 333                                 // The first character of the suffix is not
 334                                 // a dot. Preserve the first 0-2 characters
 335                                 // of the original filename extension.
 336                                 //
 337                                 // Examples:
 338                                 // xz foo.txt         -> foo.tx-
 339                                 // xz -S x  foo.c     -> foo.cx
 340                                 // xz -S ab foo.c     -> foo.cab
 341                                 // xz -S ab foo.txt   -> foo.tab
 342                                 // xz -S abc foo.txt  -> foo.abc
 343                                 //
 344                                 // Truncate the suffix to three chars:
 345                                 if (suffix_len > 3)
 346                                         suffix_len = 3;
 347
 348                                 // If needed, overwrite 1-3 characters.
 349                                 if (strlen(sufsep) > 4 - suffix_len)
 350                                         src_len = sufsep - src_name
 351                                                         + 4 - suffix_len;
 352                         }
 353                 }
 354         }
 355 #endif
 356
 357         char *dest_name = xmalloc(src_len + suffix_len + 1);
 358
 359         memcpy(dest_name, src_name, src_len);
 360         memcpy(dest_name + src_len, suffix, suffix_len);
 361         dest_name[src_len + suffix_len] = '\0';
 362
 363         return dest_name;
 364 }
 365
 366
 367 extern char *
 368 suffix_get_dest_name(const char *src_name)
 369 {
 370         assert(src_name != NULL);
 371
 372         // Length of the name is needed in all cases to locate the end of
 373         // the string to compare the suffix, so calculate the length here.
 374         const size_t src_len = strlen(src_name);
 375
 376         return opt_mode == MODE_COMPRESS
 377                         ? compressed_name(src_name, src_len)
 378                         : uncompressed_name(src_name, src_len);
 379 }
 380
 381
 382 extern void
 383 suffix_set(const char *suffix)
 384 {
 385         // Empty suffix and suffixes having a directory separator are
 386         // rejected. Such suffixes would break things later.
 387         if (suffix[0] == '\0' || has_dir_sep(suffix))
 388                 message_fatal(_("%s: Invalid filename suffix"), suffix);
 389
 390         // Replace the old custom_suffix (if any) with the new suffix.
 391         free(custom_suffix);
 392         custom_suffix = xstrdup(suffix);
 393         return;
 394 }
 395
 396
 397 extern bool
 398 suffix_is_set(void)
 399 {
 400         return custom_suffix != NULL;
 401 }