lib/util.c

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