lib/util.c

   1 /*
   2    Various utilities
   3
   4    Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
   5    2004, 2005, 2007, 2009, 2011
   6    The Free Software Foundation, Inc.
   7
   8    Written by:
   9    Miguel de Icaza, 1994, 1995, 1996
  10    Janne Kukonlehto, 1994, 1995, 1996
  11    Dugan Porter, 1994, 1995, 1996
  12    Jakub Jelinek, 1994, 1995, 1996
  13    Mauricio Plaza, 1994, 1995, 1996
  14
  15    The file_date routine is mostly from GNU's fileutils package,
  16    written by Richard Stallman and David MacKenzie.
  17
  18    This file is part of the Midnight Commander.
  19
  20    The Midnight Commander is free software: you can redistribute it
  21    and/or modify it under the terms of the GNU General Public License as
  22    published by the Free Software Foundation, either version 3 of the License,
  23    or (at your option) any later version.
  24
  25    The Midnight Commander is distributed in the hope that it will be useful,
  26    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  28    GNU General Public License for more details.
  29
  30    You should have received a copy of the GNU General Public License
  31    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  32  */
  33
  34 /** \file lib/util.c
  35  *  \brief Source: various utilities
  36  */
  37
  38 #include <config.h>
  39
  40 #include <ctype.h>
  41 #include <limits.h>
  42 #include <stdarg.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <fcntl.h>
  47 #include <sys/time.h>
  48 #include <sys/types.h>
  49 #include <sys/stat.h>
  50 #include <unistd.h>
  51
  52 #include "lib/global.h"
  53 #include "lib/mcconfig.h"
  54 #include "lib/fileloc.h"
  55 #include "lib/vfs/vfs.h"
  56 #include "lib/strutil.h"
  57 #include "lib/util.h"
  58
  59 /*** global variables ****************************************************************************/
  60
  61 /*** file scope macro definitions ****************************************************************/
  62
  63 #define ismode(n,m) ((n & m) == m)
  64
  65 /* Number of attempts to create a temporary file */
  66 #ifndef TMP_MAX
  67 #define TMP_MAX 16384
  68 #endif /* !TMP_MAX */
  69
  70 #define TMP_SUFFIX ".tmp"
  71
  72 #define ASCII_A (0x40 + 1)
  73 #define ASCII_Z (0x40 + 26)
  74 #define ASCII_a (0x60 + 1)
  75 #define ASCII_z (0x60 + 26)
  76
  77 /*** file scope type declarations ****************************************************************/
  78
  79 /*** file scope variables ************************************************************************/
  80
  81 /*** file scope functions ************************************************************************/
  82 /* --------------------------------------------------------------------------------------------- */
  83
  84 static inline int
  85 is_7bit_printable (unsigned char c)
  86 {
  87     return (c > 31 && c < 127);
  88 }
  89
  90 /* --------------------------------------------------------------------------------------------- */
  91
  92 static inline int
  93 is_iso_printable (unsigned char c)
  94 {
  95     return ((c > 31 && c < 127) || c >= 160);
  96 }
  97
  98 /* --------------------------------------------------------------------------------------------- */
  99
 100 static inline int
 101 is_8bit_printable (unsigned char c)
 102 {
 103     /* "Full 8 bits output" doesn't work on xterm */
 104     if (mc_global.tty.xterm_flag)
 105         return is_iso_printable (c);
 106
 107     return (c > 31 && c != 127 && c != 155);
 108 }
 109
 110 /* --------------------------------------------------------------------------------------------- */
 111
 112 static char *
 113 resolve_symlinks (const vfs_path_t * vpath)
 114 {
 115     char *p, *p2;
 116     char *buf, *buf2, *q, *r, c;
 117     struct stat mybuf;
 118
 119     if (vpath->relative)
 120         return NULL;
 121
 122     p = p2 = vfs_path_to_str (vpath);
 123     r = buf = g_malloc (MC_MAXPATHLEN);
 124     buf2 = g_malloc (MC_MAXPATHLEN);
 125     *r++ = PATH_SEP;
 126     *r = 0;
 127
 128     do
 129     {
 130         q = strchr (p + 1, PATH_SEP);
 131         if (!q)
 132         {
 133             q = strchr (p + 1, 0);
 134             if (q == p + 1)
 135                 break;
 136         }
 137         c = *q;
 138         *q = 0;
 139         if (mc_lstat (vpath, &mybuf) < 0)
 140         {
 141             g_free (buf);
 142             buf = NULL;
 143             goto ret;
 144         }
 145         if (!S_ISLNK (mybuf.st_mode))
 146             strcpy (r, p + 1);
 147         else
 148         {
 149             int len;
 150
 151             len = mc_readlink (vpath, buf2, MC_MAXPATHLEN - 1);
 152             if (len < 0)
 153             {
 154                 g_free (buf);
 155                 buf = NULL;
 156                 goto ret;
 157             }
 158             buf2[len] = 0;
 159             if (*buf2 == PATH_SEP)
 160                 strcpy (buf, buf2);
 161             else
 162                 strcpy (r, buf2);
 163         }
 164         canonicalize_pathname (buf);
 165         r = strchr (buf, 0);
 166         if (!*r || *(r - 1) != PATH_SEP)
 167             /* FIXME: this condition is always true because r points to the EOL */
 168         {
 169             *r++ = PATH_SEP;
 170             *r = 0;
 171         }
 172         *q = c;
 173         p = q;
 174     }
 175     while (c != '\0');
 176
 177     if (!*buf)
 178         strcpy (buf, PATH_SEP_STR);
 179     else if (*(r - 1) == PATH_SEP && r != buf + 1)
 180         *(r - 1) = 0;
 181
 182   ret:
 183     g_free (buf2);
 184     g_free (p2);
 185     return buf;
 186 }
 187
 188 /* --------------------------------------------------------------------------------------------- */
 189
 190 static gboolean
 191 mc_util_write_backup_content (const char *from_file_name, const char *to_file_name)
 192 {
 193     FILE *backup_fd;
 194     char *contents;
 195     gsize length;
 196     gboolean ret1 = TRUE;
 197
 198     if (!g_file_get_contents (from_file_name, &contents, &length, NULL))
 199         return FALSE;
 200
 201     backup_fd = fopen (to_file_name, "w");
 202     if (backup_fd == NULL)
 203     {
 204         g_free (contents);
 205         return FALSE;
 206     }
 207
 208     if (fwrite ((const void *) contents, 1, length, backup_fd) != length)
 209         ret1 = FALSE;
 210     {
 211         int ret2;
 212         ret2 = fflush (backup_fd);
 213         ret2 = fclose (backup_fd);
 214     }
 215     g_free (contents);
 216     return ret1;
 217 }
 218
 219 /* --------------------------------------------------------------------------------------------- */
 220 /*** public functions ****************************************************************************/
 221 /* --------------------------------------------------------------------------------------------- */
 222
 223 int
 224 is_printable (int c)
 225 {
 226     c &= 0xff;
 227
 228 #ifdef HAVE_CHARSET
 229     /* "Display bits" is ignored, since the user controls the output
 230        by setting the output codepage */
 231     return is_8bit_printable (c);
 232 #else
 233     if (!mc_global.eight_bit_clean)
 234         return is_7bit_printable (c);
 235
 236     if (mc_global.full_eight_bits)
 237     {
 238         return is_8bit_printable (c);
 239     }
 240     else
 241         return is_iso_printable (c);
 242 #endif /* !HAVE_CHARSET */
 243 }
 244
 245 /* --------------------------------------------------------------------------------------------- */
 246 /**
 247  * Quote the filename for the purpose of inserting it into the command
 248  * line.  If quote_percent is 1, replace "%" with "%%" - the percent is
 249  * processed by the mc command line.
 250  */
 251 char *
 252 name_quote (const char *s, int quote_percent)
 253 {
 254     char *ret, *d;
 255
 256     d = ret = g_malloc (strlen (s) * 2 + 2 + 1);
 257     if (*s == '-')
 258     {
 259         *d++ = '.';
 260         *d++ = '/';
 261     }
 262
 263     for (; *s; s++, d++)
 264     {
 265         switch (*s)
 266         {
 267         case '%':
 268             if (quote_percent)
 269                 *d++ = '%';
 270             break;
 271         case '\'':
 272         case '\\':
 273         case '\r':
 274         case '\n':
 275         case '\t':
 276         case '"':
 277         case ';':
 278         case ' ':
 279         case '?':
 280         case '|':
 281         case '[':
 282         case ']':
 283         case '{':
 284         case '}':
 285         case '<':
 286         case '>':
 287         case '`':
 288         case '!':
 289         case '$':
 290         case '&':
 291         case '*':
 292         case '(':
 293         case ')':
 294             *d++ = '\\';
 295             break;
 296         case '~':
 297         case '#':
 298             if (d == ret)
 299                 *d++ = '\\';
 300             break;
 301         }
 302         *d = *s;
 303     }
 304     *d = '\0';
 305     return ret;
 306 }
 307
 308 /* --------------------------------------------------------------------------------------------- */
 309
 310 char *
 311 fake_name_quote (const char *s, int quote_percent)
 312 {
 313     (void) quote_percent;
 314     return g_strdup (s);
 315 }
 316
 317 /* --------------------------------------------------------------------------------------------- */
 318 /**
 319  * path_trunc() is the same as str_trunc() but
 320  * it deletes possible password from path for security
 321  * reasons.
 322  */
 323
 324 const char *
 325 path_trunc (const char *path, size_t trunc_len)
 326 {
 327     vfs_path_t *vpath;
 328     char *secure_path;
 329     const char *ret;
 330
 331     vpath = vfs_path_from_str (path);
 332     secure_path = vfs_path_to_str_flags (vpath, 0, VPF_STRIP_PASSWORD);
 333     vfs_path_free (vpath);
 334
 335     ret = str_trunc (secure_path, trunc_len);
 336     g_free (secure_path);
 337
 338     return ret;
 339 }
 340
 341 /* --------------------------------------------------------------------------------------------- */
 342
 343 const char *
 344 size_trunc (uintmax_t size, gboolean use_si)
 345 {
 346     static char x[BUF_TINY];
 347     uintmax_t divisor = 1;
 348     const char *xtra = "";
 349
 350     if (size > 999999999UL)
 351     {
 352         divisor = use_si ? 1000 : 1024;
 353         xtra = use_si ? "k" : "K";
 354
 355         if (size / divisor > 999999999UL)
 356         {
 357             divisor = use_si ? (1000 * 1000) : (1024 * 1024);
 358             xtra = use_si ? "m" : "M";
 359
 360             if (size / divisor > 999999999UL)
 361             {
 362                 divisor = use_si ? (1000 * 1000 * 1000) : (1024 * 1024 * 1024);
 363                 xtra = use_si ? "g" : "G";
 364             }
 365         }
 366     }
 367     g_snprintf (x, sizeof (x), "%.0f%s", 1.0 * size / divisor, xtra);
 368     return x;
 369 }
 370
 371 /* --------------------------------------------------------------------------------------------- */
 372
 373 const char *
 374 size_trunc_sep (uintmax_t size, gboolean use_si)
 375 {
 376     static char x[60];
 377     int count;
 378     const char *p, *y;
 379     char *d;
 380
 381     p = y = size_trunc (size, use_si);
 382     p += strlen (p) - 1;
 383     d = x + sizeof (x) - 1;
 384     *d-- = '\0';
 385     while (p >= y && isalpha ((unsigned char) *p))
 386         *d-- = *p--;
 387     for (count = 0; p >= y; count++)
 388     {
 389         if (count == 3)
 390         {
 391             *d-- = ',';
 392             count = 0;
 393         }
 394         *d-- = *p--;
 395     }
 396     d++;
 397     if (*d == ',')
 398         d++;
 399     return d;
 400 }
 401
 402 /* --------------------------------------------------------------------------------------------- */
 403 /**
 404  * Print file SIZE to BUFFER, but don't exceed LEN characters,
 405  * not including trailing 0. BUFFER should be at least LEN+1 long.
 406  * This function is called for every file on panels, so avoid
 407  * floating point by any means.
 408  *
 409  * Units: size units (filesystem sizes are 1K blocks)
 410  *    0=bytes, 1=Kbytes, 2=Mbytes, etc.
 411  */
 412
 413 void
 414 size_trunc_len (char *buffer, unsigned int len, uintmax_t size, int units, gboolean use_si)
 415 {
 416     /* Avoid taking power for every file.  */
 417     /* *INDENT-OFF* */
 418     static const uintmax_t power10[] = {
 419     /* we hope that size of uintmax_t is 4 bytes at least */
 420         1ULL,
 421         10ULL,
 422         100ULL,
 423         1000ULL,
 424         10000ULL,
 425         100000ULL,
 426         1000000ULL,
 427         10000000ULL,
 428         100000000ULL,
 429         1000000000ULL
 430     /* maximmum value of uintmax_t (in case of 4 bytes) is
 431         4294967295
 432      */
 433 #if SIZEOF_UINTMAX_T == 8
 434                      ,
 435         10000000000ULL,
 436         100000000000ULL,
 437         1000000000000ULL,
 438         10000000000000ULL,
 439         100000000000000ULL,
 440         1000000000000000ULL,
 441         10000000000000000ULL,
 442         100000000000000000ULL,
 443         1000000000000000000ULL,
 444         10000000000000000000ULL
 445     /* maximmum value of uintmax_t (in case of 8 bytes) is
 446         18447644073710439615
 447      */
 448 #endif
 449     };
 450     /* *INDENT-ON* */
 451     static const char *const suffix[] = { "", "K", "M", "G", "T", "P", "E", "Z", "Y", NULL };
 452     static const char *const suffix_lc[] = { "", "k", "m", "g", "t", "p", "e", "z", "y", NULL };
 453     int j = 0;
 454
 455     if (len == 0)
 456         len = 9;
 457 #if SIZEOF_UINTMAX_T == 8
 458     /* 20 decimal digits are required to represent 8 bytes */
 459     else if (len > 19)
 460         len = 19;
 461 #else
 462     /* 10 decimal digits are required to represent 4 bytes */
 463     else if (len > 9)
 464         len = 9;
 465 #endif
 466
 467     /*
 468      * recalculate from 1024 base to 1000 base if units>0
 469      * We can't just multiply by 1024 - that might cause overflow
 470      * if off_t type is too small
 471      */
 472     if (use_si)
 473         for (j = 0; j < units; j++)
 474         {
 475             uintmax_t size_remain;
 476
 477             size_remain = ((size % 125) * 1024) / 1000; /* size mod 125, recalculated */
 478             size = size / 125;  /* 128/125 = 1024/1000 */
 479             size = size * 128;  /* This will convert size from multiple of 1024 to multiple of 1000 */
 480             size += size_remain;        /* Re-add remainder lost by division/multiplication */
 481         }
 482
 483     for (j = units; suffix[j] != NULL; j++)
 484     {
 485         if (size == 0)
 486         {
 487             if (j == units)
 488             {
 489                 /* Empty files will print "0" even with minimal width.  */
 490                 g_snprintf (buffer, len + 1, "0");
 491                 break;
 492             }
 493
 494             /* Use "~K" or just "K" if len is 1.  Use "B" for bytes.  */
 495             g_snprintf (buffer, len + 1, (len > 1) ? "~%s" : "%s",
 496                         (j > 1) ? (use_si ? suffix_lc[j - 1] : suffix[j - 1]) : "B");
 497             break;
 498         }
 499
 500         if (size < power10[len - (j > 0 ? 1 : 0)])
 501         {
 502             g_snprintf (buffer, len + 1, "%" PRIuMAX "%s", size, use_si ? suffix_lc[j] : suffix[j]);
 503             break;
 504         }
 505
 506         /* Powers of 1000 or 1024, with rounding.  */
 507         if (use_si)
 508             size = (size + 500) / 1000;
 509         else
 510             size = (size + 512) >> 10;
 511     }
 512 }
 513
 514 /* --------------------------------------------------------------------------------------------- */
 515
 516 const char *
 517 string_perm (mode_t mode_bits)
 518 {
 519     static char mode[11];
 520
 521     strcpy (mode, "----------");
 522     if (S_ISDIR (mode_bits))
 523         mode[0] = 'd';
 524     if (S_ISCHR (mode_bits))
 525         mode[0] = 'c';
 526     if (S_ISBLK (mode_bits))
 527         mode[0] = 'b';
 528     if (S_ISLNK (mode_bits))
 529         mode[0] = 'l';
 530     if (S_ISFIFO (mode_bits))
 531         mode[0] = 'p';
 532     if (S_ISNAM (mode_bits))
 533         mode[0] = 'n';
 534     if (S_ISSOCK (mode_bits))
 535         mode[0] = 's';
 536     if (S_ISDOOR (mode_bits))
 537         mode[0] = 'D';
 538     if (ismode (mode_bits, S_IXOTH))
 539         mode[9] = 'x';
 540     if (ismode (mode_bits, S_IWOTH))
 541         mode[8] = 'w';
 542     if (ismode (mode_bits, S_IROTH))
 543         mode[7] = 'r';
 544     if (ismode (mode_bits, S_IXGRP))
 545         mode[6] = 'x';
 546     if (ismode (mode_bits, S_IWGRP))
 547         mode[5] = 'w';
 548     if (ismode (mode_bits, S_IRGRP))
 549         mode[4] = 'r';
 550     if (ismode (mode_bits, S_IXUSR))
 551         mode[3] = 'x';
 552     if (ismode (mode_bits, S_IWUSR))
 553         mode[2] = 'w';
 554     if (ismode (mode_bits, S_IRUSR))
 555         mode[1] = 'r';
 556 #ifdef S_ISUID
 557     if (ismode (mode_bits, S_ISUID))
 558         mode[3] = (mode[3] == 'x') ? 's' : 'S';
 559 #endif /* S_ISUID */
 560 #ifdef S_ISGID
 561     if (ismode (mode_bits, S_ISGID))
 562         mode[6] = (mode[6] == 'x') ? 's' : 'S';
 563 #endif /* S_ISGID */
 564 #ifdef S_ISVTX
 565     if (ismode (mode_bits, S_ISVTX))
 566         mode[9] = (mode[9] == 'x') ? 't' : 'T';
 567 #endif /* S_ISVTX */
 568     return mode;
 569 }
 570
 571 /* --------------------------------------------------------------------------------------------- */
 572
 573 const char *
 574 extension (const char *filename)
 575 {
 576     const char *d = strrchr (filename, '.');
 577     return (d != NULL) ? d + 1 : "";
 578 }
 579
 580 /* --------------------------------------------------------------------------------------------- */
 581
 582 char *
 583 load_mc_home_file (const char *from, const char *filename, char **allocated_filename)
 584 {
 585     char *hintfile_base, *hintfile;
 586     char *lang;
 587     char *data;
 588
 589     hintfile_base = g_build_filename (from, filename, (char *) NULL);
 590     lang = guess_message_value ();
 591
 592     hintfile = g_strconcat (hintfile_base, ".", lang, (char *) NULL);
 593     if (!g_file_get_contents (hintfile, &data, NULL, NULL))
 594     {
 595         /* Fall back to the two-letter language code */
 596         if (lang[0] != '\0' && lang[1] != '\0')
 597             lang[2] = '\0';
 598         g_free (hintfile);
 599         hintfile = g_strconcat (hintfile_base, ".", lang, (char *) NULL);
 600         if (!g_file_get_contents (hintfile, &data, NULL, NULL))
 601         {
 602             g_free (hintfile);
 603             hintfile = hintfile_base;
 604             g_file_get_contents (hintfile_base, &data, NULL, NULL);
 605         }
 606     }
 607
 608     g_free (lang);
 609
 610     if (hintfile != hintfile_base)
 611         g_free (hintfile_base);
 612
 613     if (allocated_filename != NULL)
 614         *allocated_filename = hintfile;
 615     else
 616         g_free (hintfile);
 617
 618     return data;
 619 }
 620
 621 /* --------------------------------------------------------------------------------------------- */
 622
 623 const char *
 624 extract_line (const char *s, const char *top)
 625 {
 626     static char tmp_line[BUF_MEDIUM];
 627     char *t = tmp_line;
 628
 629     while (*s && *s != '\n' && (size_t) (t - tmp_line) < sizeof (tmp_line) - 1 && s < top)
 630         *t++ = *s++;
 631     *t = 0;
 632     return tmp_line;
 633 }
 634
 635 /* --------------------------------------------------------------------------------------------- */
 636 /**
 637  * The basename routine
 638  */
 639
 640 const char *
 641 x_basename (const char *s)
 642 {
 643     const char *url_delim, *path_sep;
 644
 645     url_delim = g_strrstr (s, VFS_PATH_URL_DELIMITER);
 646     path_sep = strrchr (s, PATH_SEP);
 647
 648     if (url_delim == NULL
 649         || url_delim < path_sep - strlen (VFS_PATH_URL_DELIMITER)
 650         || url_delim - s + strlen (VFS_PATH_URL_DELIMITER) < strlen (s))
 651     {
 652         /* avoid trailing PATH_SEP, if present */
 653         if (s[strlen (s) - 1] == PATH_SEP)
 654         {
 655             while (--path_sep > s && *path_sep != PATH_SEP);
 656             return (path_sep != s) ? path_sep + 1 : s;
 657         }
 658         else
 659             return (path_sep != NULL) ? path_sep + 1 : s;
 660     }
 661
 662     while (--url_delim > s && *url_delim != PATH_SEP);
 663     while (--url_delim > s && *url_delim != PATH_SEP);
 664
 665     return (url_delim == s) ? s : url_delim + 1;
 666 }
 667
 668 /* --------------------------------------------------------------------------------------------- */
 669
 670 const char *
 671 unix_error_string (int error_num)
 672 {
 673     static char buffer[BUF_LARGE];
 674     gchar *strerror_currentlocale;
 675
 676     strerror_currentlocale = g_locale_from_utf8 (g_strerror (error_num), -1, NULL, NULL, NULL);
 677     g_snprintf (buffer, sizeof (buffer), "%s (%d)", strerror_currentlocale, error_num);
 678     g_free (strerror_currentlocale);
 679
 680     return buffer;
 681 }
 682
 683 /* --------------------------------------------------------------------------------------------- */
 684
 685 const char *
 686 skip_separators (const char *s)
 687 {
 688     const char *su = s;
 689
 690     for (; *su; str_cnext_char (&su))
 691         if (*su != ' ' && *su != '\t' && *su != ',')
 692             break;
 693
 694     return su;
 695 }
 696
 697 /* --------------------------------------------------------------------------------------------- */
 698
 699 const char *
 700 skip_numbers (const char *s)
 701 {
 702     const char *su = s;
 703
 704     for (; *su; str_cnext_char (&su))
 705         if (!str_isdigit (su))
 706             break;
 707
 708     return su;
 709 }
 710
 711 /* --------------------------------------------------------------------------------------------- */
 712 /**
 713  * Remove all control sequences from the argument string.  We define
 714  * "control sequence", in a sort of pidgin BNF, as follows:
 715  *
 716  * control-seq = Esc non-'['
 717  *             | Esc '[' (0 or more digits or ';' or '?') (any other char)
 718  *
 719  * This scheme works for all the terminals described in my termcap /
 720  * terminfo databases, except the Hewlett-Packard 70092 and some Wyse
 721  * terminals.  If I hear from a single person who uses such a terminal
 722  * with MC, I'll be glad to add support for it.  (Dugan)
 723  * Non-printable characters are also removed.
 724  */
 725
 726 char *
 727 strip_ctrl_codes (char *s)
 728 {
 729     char *w;                    /* Current position where the stripped data is written */
 730     char *r;                    /* Current position where the original data is read */
 731     char *n;
 732
 733     if (!s)
 734         return 0;
 735
 736     for (w = s, r = s; *r;)
 737     {
 738         if (*r == ESC_CHAR)
 739         {
 740             /* Skip the control sequence's arguments */ ;
 741             /* '(' need to avoid strange 'B' letter in *Suse (if mc runs under root user) */
 742             if (*(++r) == '[' || *r == '(')
 743             {
 744                 /* strchr() matches trailing binary 0 */
 745                 while (*(++r) && strchr ("0123456789;?", *r));
 746             }
 747             else if (*r == ']')
 748             {
 749                 /*
 750                  * Skip xterm's OSC (Operating System Command)
 751                  * http://www.xfree86.org/current/ctlseqs.html
 752                  * OSC P s ; P t ST
 753                  * OSC P s ; P t BEL
 754                  */
 755                 char *new_r = r;
 756
 757                 for (; *new_r; ++new_r)
 758                 {
 759                     switch (*new_r)
 760                     {
 761                         /* BEL */
 762                     case '\a':
 763                         r = new_r;
 764                         goto osc_out;
 765                     case ESC_CHAR:
 766                         /* ST */
 767                         if (*(new_r + 1) == '\\')
 768                         {
 769                             r = new_r + 1;
 770                             goto osc_out;
 771                         }
 772                     }
 773                 }
 774               osc_out:;
 775             }
 776
 777             /*
 778              * Now we are at the last character of the sequence.
 779              * Skip it unless it's binary 0.
 780              */
 781             if (*r)
 782                 r++;
 783             continue;
 784         }
 785
 786         n = str_get_next_char (r);
 787         if (str_isprint (r))
 788         {
 789             memmove (w, r, n - r);
 790             w += n - r;
 791         }
 792         r = n;
 793     }
 794     *w = 0;
 795     return s;
 796 }
 797
 798 /* --------------------------------------------------------------------------------------------- */
 799
 800 enum compression_type
 801 get_compression_type (int fd, const char *name)
 802 {
 803     unsigned char magic[16];
 804     size_t str_len;
 805
 806     /* Read the magic signature */
 807     if (mc_read (fd, (char *) magic, 4) != 4)
 808         return COMPRESSION_NONE;
 809
 810     /* GZIP_MAGIC and OLD_GZIP_MAGIC */
 811     if (magic[0] == 037 && (magic[1] == 0213 || magic[1] == 0236))
 812     {
 813         return COMPRESSION_GZIP;
 814     }
 815
 816     /* PKZIP_MAGIC */
 817     if (magic[0] == 0120 && magic[1] == 0113 && magic[2] == 003 && magic[3] == 004)
 818     {
 819         /* Read compression type */
 820         mc_lseek (fd, 8, SEEK_SET);
 821         if (mc_read (fd, (char *) magic, 2) != 2)
 822             return COMPRESSION_NONE;
 823
 824         /* Gzip can handle only deflated (8) or stored (0) files */
 825         if ((magic[0] != 8 && magic[0] != 0) || magic[1] != 0)
 826             return COMPRESSION_NONE;
 827
 828         /* Compatible with gzip */
 829         return COMPRESSION_GZIP;
 830     }
 831
 832     /* PACK_MAGIC and LZH_MAGIC and compress magic */
 833     if (magic[0] == 037 && (magic[1] == 036 || magic[1] == 0240 || magic[1] == 0235))
 834     {
 835         /* Compatible with gzip */
 836         return COMPRESSION_GZIP;
 837     }
 838
 839     /* BZIP and BZIP2 files */
 840     if ((magic[0] == 'B') && (magic[1] == 'Z') && (magic[3] >= '1') && (magic[3] <= '9'))
 841     {
 842         switch (magic[2])
 843         {
 844         case '0':
 845             return COMPRESSION_BZIP;
 846         case 'h':
 847             return COMPRESSION_BZIP2;
 848         }
 849     }
 850
 851     /* Support for LZMA (only utils format with magic in header).
 852      * This is the default format of LZMA utils 4.32.1 and later. */
 853
 854     if (mc_read (fd, (char *) magic + 4, 2) != 2)
 855         return COMPRESSION_NONE;
 856
 857     /* LZMA utils format */
 858     if (magic[0] == 0xFF
 859         && magic[1] == 'L'
 860         && magic[2] == 'Z' && magic[3] == 'M' && magic[4] == 'A' && magic[5] == 0x00)
 861         return COMPRESSION_LZMA;
 862
 863     /* XZ compression magic */
 864     if (magic[0] == 0xFD
 865         && magic[1] == 0x37
 866         && magic[2] == 0x7A && magic[3] == 0x58 && magic[4] == 0x5A && magic[5] == 0x00)
 867         return COMPRESSION_XZ;
 868
 869     str_len = strlen (name);
 870     /* HACK: we must belive to extention of LZMA file :) ... */
 871     if ((str_len > 5 && strcmp (&name[str_len - 5], ".lzma") == 0) ||
 872         (str_len > 4 && strcmp (&name[str_len - 4], ".tlz") == 0))
 873         return COMPRESSION_LZMA;
 874
 875     return COMPRESSION_NONE;
 876 }
 877
 878 /* --------------------------------------------------------------------------------------------- */
 879
 880 const char *
 881 decompress_extension (int type)
 882 {
 883     switch (type)
 884     {
 885     case COMPRESSION_GZIP:
 886         return "/ugz" VFS_PATH_URL_DELIMITER;
 887     case COMPRESSION_BZIP:
 888         return "/ubz" VFS_PATH_URL_DELIMITER;
 889     case COMPRESSION_BZIP2:
 890         return "/ubz2" VFS_PATH_URL_DELIMITER;
 891     case COMPRESSION_LZMA:
 892         return "/ulzma" VFS_PATH_URL_DELIMITER;
 893     case COMPRESSION_XZ:
 894         return "/uxz" VFS_PATH_URL_DELIMITER;
 895     }
 896     /* Should never reach this place */
 897     fprintf (stderr, "Fatal: decompress_extension called with an unknown argument\n");
 898     return 0;
 899 }
 900
 901 /* --------------------------------------------------------------------------------------------- */
 902
 903 void
 904 wipe_password (char *passwd)
 905 {
 906     char *p = passwd;
 907
 908     if (!p)
 909         return;
 910     for (; *p; p++)
 911         *p = 0;
 912     g_free (passwd);
 913 }
 914
 915 /* --------------------------------------------------------------------------------------------- */
 916 /**
 917  * Convert "\E" -> esc character and ^x to control-x key and ^^ to ^ key
 918  *
 919  * @param p pointer to string
 920  *
 921  * @return newly allocated string
 922  */
 923
 924 char *
 925 convert_controls (const char *p)
 926 {
 927     char *valcopy = g_strdup (p);
 928     char *q;
 929
 930     /* Parse the escape special character */
 931     for (q = valcopy; *p;)
 932     {
 933         if (*p == '\\')
 934         {
 935             p++;
 936             if ((*p == 'e') || (*p == 'E'))
 937             {
 938                 p++;
 939                 *q++ = ESC_CHAR;
 940             }
 941         }
 942         else
 943         {
 944             if (*p == '^')
 945             {
 946                 p++;
 947                 if (*p == '^')
 948                     *q++ = *p++;
 949                 else
 950                 {
 951                     char c = (*p | 0x20);
 952                     if (c >= 'a' && c <= 'z')
 953                     {
 954                         *q++ = c - 'a' + 1;
 955                         p++;
 956                     }
 957                     else if (*p)
 958                         p++;
 959                 }
 960             }
 961             else
 962                 *q++ = *p++;
 963         }
 964     }
 965     *q = 0;
 966     return valcopy;
 967 }
 968
 969 /* --------------------------------------------------------------------------------------------- */
 970 /**
 971  * Finds out a relative path from first to second, i.e. goes as many ..
 972  * as needed up in first and then goes down using second
 973  */
 974
 975 char *
 976 diff_two_paths (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
 977 {
 978     char *p, *q, *r, *s, *buf = NULL;
 979     int i, j, prevlen = -1, currlen;
 980     char *my_first = NULL, *my_second = NULL;
 981
 982     my_first = resolve_symlinks (vpath1);
 983     if (my_first == NULL)
 984         goto ret;
 985
 986     my_second = resolve_symlinks (vpath2);
 987     if (my_second == NULL)
 988         goto ret;
 989
 990     for (j = 0; j < 2; j++)
 991     {
 992         p = my_first;
 993         q = my_second;
 994         while (TRUE)
 995         {
 996             r = strchr (p, PATH_SEP);
 997             s = strchr (q, PATH_SEP);
 998             if (r == NULL || s == NULL)
 999                 break;
1000             *r = '\0';
1001             *s = '\0';
1002             if (strcmp (p, q) != 0)
1003             {
1004                 *r = PATH_SEP;
1005                 *s = PATH_SEP;
1006                 break;
1007             }
1008
1009             *r = PATH_SEP;
1010             *s = PATH_SEP;
1011
1012             p = r + 1;
1013             q = s + 1;
1014         }
1015         p--;
1016         for (i = 0; (p = strchr (p + 1, PATH_SEP)) != NULL; i++)
1017             ;
1018         currlen = (i + 1) * 3 + strlen (q) + 1;
1019         if (j != 0)
1020         {
1021             if (currlen < prevlen)
1022                 g_free (buf);
1023             else
1024                 goto ret;
1025         }
1026         p = buf = g_malloc (currlen);
1027         prevlen = currlen;
1028         for (; i >= 0; i--, p += 3)
1029             strcpy (p, "../");
1030         strcpy (p, q);
1031     }
1032
1033   ret:
1034     g_free (my_first);
1035     g_free (my_second);
1036     return buf;
1037 }
1038
1039 /* --------------------------------------------------------------------------------------------- */
1040 /**
1041  * Append text to GList, remove all entries with the same text
1042  */
1043
1044 GList *
1045 list_append_unique (GList * list, char *text)
1046 {
1047     GList *lc_link;
1048
1049     /*
1050      * Go to the last position and traverse the list backwards
1051      * starting from the second last entry to make sure that we
1052      * are not removing the current link.
1053      */
1054     list = g_list_append (list, text);
1055     list = g_list_last (list);
1056     lc_link = g_list_previous (list);
1057
1058     while (lc_link != NULL)
1059     {
1060         GList *newlink;
1061
1062         newlink = g_list_previous (lc_link);
1063         if (strcmp ((char *) lc_link->data, text) == 0)
1064         {
1065             GList *tmp;
1066
1067             g_free (lc_link->data);
1068             tmp = g_list_remove_link (list, lc_link);
1069             g_list_free_1 (lc_link);
1070         }
1071         lc_link = newlink;
1072     }
1073
1074     return list;
1075 }
1076
1077 /* --------------------------------------------------------------------------------------------- */
1078 /**
1079  * Read and restore position for the given filename.
1080  * If there is no stored data, return line 1 and col 0.
1081  */
1082
1083 void
1084 load_file_position (const vfs_path_t * filename_vpath, long *line, long *column, off_t * offset,
1085                     GArray ** bookmarks)
1086 {
1087     char *fn;
1088     FILE *f;
1089     char buf[MC_MAXPATHLEN + 100];
1090     const size_t len = vfs_path_len (filename_vpath);
1091     char *filename;
1092
1093     /* defaults */
1094     *line = 1;
1095     *column = 0;
1096     *offset = 0;
1097
1098     /* open file with positions */
1099     fn = mc_config_get_full_path (MC_FILEPOS_FILE);
1100     f = fopen (fn, "r");
1101     g_free (fn);
1102     if (f == NULL)
1103         return;
1104
1105     /* prepare array for serialized bookmarks */
1106     *bookmarks = g_array_sized_new (FALSE, FALSE, sizeof (size_t), MAX_SAVED_BOOKMARKS);
1107     filename = vfs_path_to_str (filename_vpath);
1108
1109     while (fgets (buf, sizeof (buf), f) != NULL)
1110     {
1111         const char *p;
1112         gchar **pos_tokens;
1113
1114         /* check if the filename matches the beginning of string */
1115         if (strncmp (buf, filename, len) != 0)
1116             continue;
1117
1118         /* followed by single space */
1119         if (buf[len] != ' ')
1120             continue;
1121
1122         /* and string without spaces */
1123         p = &buf[len + 1];
1124         if (strchr (p, ' ') != NULL)
1125             continue;
1126
1127         pos_tokens = g_strsplit (p, ";", 3 + MAX_SAVED_BOOKMARKS);
1128         if (pos_tokens[0] == NULL)
1129         {
1130             *line = 1;
1131             *column = 0;
1132             *offset = 0;
1133         }
1134         else
1135         {
1136             *line = strtol (pos_tokens[0], NULL, 10);
1137             if (pos_tokens[1] == NULL)
1138             {
1139                 *column = 0;
1140                 *offset = 0;
1141             }
1142             else
1143             {
1144                 *column = strtol (pos_tokens[1], NULL, 10);
1145                 if (pos_tokens[2] == NULL)
1146                     *offset = 0;
1147                 else
1148                 {
1149                     size_t i;
1150
1151                     *offset = (off_t) g_ascii_strtoll (pos_tokens[2], NULL, 10);
1152
1153                     for (i = 0; i < MAX_SAVED_BOOKMARKS && pos_tokens[3 + i] != NULL; i++)
1154                     {
1155                         size_t val;
1156
1157                         val = strtoul (pos_tokens[3 + i], NULL, 10);
1158                         g_array_append_val (*bookmarks, val);
1159                     }
1160                 }
1161             }
1162         }
1163
1164         g_strfreev (pos_tokens);
1165     }
1166
1167     g_free (filename);
1168     fclose (f);
1169 }
1170
1171 /* --------------------------------------------------------------------------------------------- */
1172 /**
1173  * Save position for the given file
1174  */
1175
1176 void
1177 save_file_position (const vfs_path_t * filename_vpath, long line, long column, off_t offset,
1178                     GArray * bookmarks)
1179 {
1180     static size_t filepos_max_saved_entries = 0;
1181     char *fn, *tmp_fn;
1182     FILE *f, *tmp_f;
1183     char buf[MC_MAXPATHLEN + 100];
1184     size_t i;
1185     const size_t len = vfs_path_len (filename_vpath);
1186     gboolean src_error = FALSE;
1187     char *filename;
1188
1189     if (filepos_max_saved_entries == 0)
1190         filepos_max_saved_entries = mc_config_get_int (mc_main_config, CONFIG_APP_SECTION,
1191                                                        "filepos_max_saved_entries", 1024);
1192
1193     fn = mc_config_get_full_path (MC_FILEPOS_FILE);
1194     if (fn == NULL)
1195         goto early_error;
1196
1197     mc_util_make_backup_if_possible (fn, TMP_SUFFIX);
1198
1199     /* open file */
1200     f = fopen (fn, "w");
1201     if (f == NULL)
1202         goto open_target_error;
1203
1204     tmp_fn = g_strdup_printf ("%s" TMP_SUFFIX, fn);
1205     tmp_f = fopen (tmp_fn, "r");
1206     if (tmp_f == NULL)
1207     {
1208         src_error = TRUE;
1209         goto open_source_error;
1210     }
1211
1212     filename = vfs_path_to_str (filename_vpath);
1213     /* put the new record */
1214     if (line != 1 || column != 0 || bookmarks != NULL)
1215     {
1216         if (fprintf (f, "%s %ld;%ld;%" PRIuMAX, filename, line, column, (uintmax_t) offset) < 0)
1217             goto write_position_error;
1218         if (bookmarks != NULL)
1219             for (i = 0; i < bookmarks->len && i < MAX_SAVED_BOOKMARKS; i++)
1220                 if (fprintf (f, ";%zu", g_array_index (bookmarks, size_t, i)) < 0)
1221                     goto write_position_error;
1222
1223         if (fprintf (f, "\n") < 0)
1224             goto write_position_error;
1225     }
1226
1227     i = 1;
1228     while (fgets (buf, sizeof (buf), tmp_f) != NULL)
1229     {
1230         if (buf[len] == ' ' && strncmp (buf, filename, len) == 0
1231             && strchr (&buf[len + 1], ' ') == NULL)
1232             continue;
1233
1234         fprintf (f, "%s", buf);
1235         if (++i > filepos_max_saved_entries)
1236             break;
1237     }
1238
1239   write_position_error:
1240     g_free (filename);
1241     fclose (tmp_f);
1242   open_source_error:
1243     g_free (tmp_fn);
1244     fclose (f);
1245     if (src_error)
1246         mc_util_restore_from_backup_if_possible (fn, TMP_SUFFIX);
1247     else
1248         mc_util_unlink_backup_if_possible (fn, TMP_SUFFIX);
1249   open_target_error:
1250     g_free (fn);
1251   early_error:
1252     if (bookmarks != NULL)
1253         g_array_free (bookmarks, TRUE);
1254 }
1255
1256 /* --------------------------------------------------------------------------------------------- */
1257
1258 extern int
1259 ascii_alpha_to_cntrl (int ch)
1260 {
1261     if ((ch >= ASCII_A && ch <= ASCII_Z) || (ch >= ASCII_a && ch <= ASCII_z))
1262     {
1263         ch &= 0x1f;
1264     }
1265     return ch;
1266 }
1267
1268 /* --------------------------------------------------------------------------------------------- */
1269
1270 const char *
1271 Q_ (const char *s)
1272 {
1273     const char *result, *sep;
1274
1275     result = _(s);
1276     sep = strchr (result, '|');
1277     return (sep != NULL) ? sep + 1 : result;
1278 }
1279
1280 /* --------------------------------------------------------------------------------------------- */
1281
1282 gboolean
1283 mc_util_make_backup_if_possible (const char *file_name, const char *backup_suffix)
1284 {
1285     struct stat stat_buf;
1286     char *backup_path;
1287     gboolean ret;
1288     if (!exist_file (file_name))
1289         return FALSE;
1290
1291     backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1292
1293     if (backup_path == NULL)
1294         return FALSE;
1295
1296     ret = mc_util_write_backup_content (file_name, backup_path);
1297
1298     if (ret)
1299     {
1300         /* Backup file will have same ownership with main file. */
1301         if (stat (file_name, &stat_buf) == 0)
1302             chmod (backup_path, stat_buf.st_mode);
1303         else
1304             chmod (backup_path, S_IRUSR | S_IWUSR);
1305     }
1306
1307     g_free (backup_path);
1308
1309     return ret;
1310 }
1311
1312 /* --------------------------------------------------------------------------------------------- */
1313
1314 gboolean
1315 mc_util_restore_from_backup_if_possible (const char *file_name, const char *backup_suffix)
1316 {
1317     gboolean ret;
1318     char *backup_path;
1319
1320     backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1321     if (backup_path == NULL)
1322         return FALSE;
1323
1324     ret = mc_util_write_backup_content (backup_path, file_name);
1325     g_free (backup_path);
1326
1327     return ret;
1328 }
1329
1330 /* --------------------------------------------------------------------------------------------- */
1331
1332 gboolean
1333 mc_util_unlink_backup_if_possible (const char *file_name, const char *backup_suffix)
1334 {
1335     char *backup_path;
1336
1337     backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1338     if (backup_path == NULL)
1339         return FALSE;
1340
1341     if (exist_file (backup_path))
1342     {
1343         vfs_path_t *vpath;
1344
1345         vpath = vfs_path_from_str (backup_path);
1346         mc_unlink (vpath);
1347         vfs_path_free (vpath);
1348     }
1349
1350     g_free (backup_path);
1351     return TRUE;
1352 }
1353
1354 /* --------------------------------------------------------------------------------------------- */
1355 /**
1356  * partly taken from dcigettext.c, returns "" for default locale
1357  * value should be freed by calling function g_free()
1358  */
1359
1360 char *
1361 guess_message_value (void)
1362 {
1363     static const char *const var[] = {
1364         /* Setting of LC_ALL overwrites all other.  */
1365         /* Do not use LANGUAGE for check user locale and drowing hints */
1366         "LC_ALL",
1367         /* Next comes the name of the desired category.  */
1368         "LC_MESSAGES",
1369         /* Last possibility is the LANG environment variable.  */
1370         "LANG",
1371         /* NULL exit loops */
1372         NULL
1373     };
1374
1375     unsigned i = 0;
1376     const char *locale = NULL;
1377
1378     while (var[i] != NULL)
1379     {
1380         locale = getenv (var[i]);
1381         if (locale != NULL && locale[0] != '\0')
1382             break;
1383         i++;
1384     }
1385
1386     if (locale == NULL)
1387         locale = "";
1388
1389     return g_strdup (locale);
1390 }
1391
1392 /* --------------------------------------------------------------------------------------------- */