lib/util.c

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