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"           /* 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         1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000
 397     };
 398     static const char *const suffix[] = { "", "K", "M", "G", "T", "P", "E", "Z", "Y", NULL };
 399     static const char *const suffix_lc[] = { "", "k", "m", "g", "t", "p", "e", "z", "y", NULL };
 400     int j = 0;
 401     int size_remain;
 402
 403     if (len == 0)
 404         len = 9;
 405
 406     /*
 407      * recalculate from 1024 base to 1000 base if units>0
 408      * We can't just multiply by 1024 - that might cause overflow
 409      * if off_t type is too small
 410      */
 411     if (use_si)
 412         for (j = 0; j < units; j++)
 413         {
 414             size_remain = ((size % 125) * 1024) / 1000; /* size mod 125, recalculated */
 415             size = size / 125;  /* 128/125 = 1024/1000 */
 416             size = size * 128;  /* This will convert size from multiple of 1024 to multiple of 1000 */
 417             size += size_remain;        /* Re-add remainder lost by division/multiplication */
 418         }
 419
 420     for (j = units; suffix[j] != NULL; j++)
 421     {
 422         if (size == 0)
 423         {
 424             if (j == units)
 425             {
 426                 /* Empty files will print "0" even with minimal width.  */
 427                 g_snprintf (buffer, len + 1, "0");
 428                 break;
 429             }
 430
 431             /* Use "~K" or just "K" if len is 1.  Use "B" for bytes.  */
 432             g_snprintf (buffer, len + 1, (len > 1) ? "~%s" : "%s",
 433                         (j > 1) ? (use_si ? suffix_lc[j - 1] : suffix[j - 1]) : "B");
 434             break;
 435         }
 436
 437         if (size < power10[len - (j > 0)])
 438         {
 439             g_snprintf (buffer, len + 1, "%" PRIuMAX "%s", size, use_si ? suffix_lc[j] : suffix[j]);
 440             break;
 441         }
 442
 443         /* Powers of 1000 or 1024, with rounding.  */
 444         if (use_si)
 445             size = (size + 500) / 1000;
 446         else
 447             size = (size + 512) >> 10;
 448     }
 449 }
 450
 451 /* --------------------------------------------------------------------------------------------- */
 452
 453 const char *
 454 string_perm (mode_t mode_bits)
 455 {
 456     static char mode[11];
 457
 458     strcpy (mode, "----------");
 459     if (S_ISDIR (mode_bits))
 460         mode[0] = 'd';
 461     if (S_ISCHR (mode_bits))
 462         mode[0] = 'c';
 463     if (S_ISBLK (mode_bits))
 464         mode[0] = 'b';
 465     if (S_ISLNK (mode_bits))
 466         mode[0] = 'l';
 467     if (S_ISFIFO (mode_bits))
 468         mode[0] = 'p';
 469     if (S_ISNAM (mode_bits))
 470         mode[0] = 'n';
 471     if (S_ISSOCK (mode_bits))
 472         mode[0] = 's';
 473     if (S_ISDOOR (mode_bits))
 474         mode[0] = 'D';
 475     if (ismode (mode_bits, S_IXOTH))
 476         mode[9] = 'x';
 477     if (ismode (mode_bits, S_IWOTH))
 478         mode[8] = 'w';
 479     if (ismode (mode_bits, S_IROTH))
 480         mode[7] = 'r';
 481     if (ismode (mode_bits, S_IXGRP))
 482         mode[6] = 'x';
 483     if (ismode (mode_bits, S_IWGRP))
 484         mode[5] = 'w';
 485     if (ismode (mode_bits, S_IRGRP))
 486         mode[4] = 'r';
 487     if (ismode (mode_bits, S_IXUSR))
 488         mode[3] = 'x';
 489     if (ismode (mode_bits, S_IWUSR))
 490         mode[2] = 'w';
 491     if (ismode (mode_bits, S_IRUSR))
 492         mode[1] = 'r';
 493 #ifdef S_ISUID
 494     if (ismode (mode_bits, S_ISUID))
 495         mode[3] = (mode[3] == 'x') ? 's' : 'S';
 496 #endif /* S_ISUID */
 497 #ifdef S_ISGID
 498     if (ismode (mode_bits, S_ISGID))
 499         mode[6] = (mode[6] == 'x') ? 's' : 'S';
 500 #endif /* S_ISGID */
 501 #ifdef S_ISVTX
 502     if (ismode (mode_bits, S_ISVTX))
 503         mode[9] = (mode[9] == 'x') ? 't' : 'T';
 504 #endif /* S_ISVTX */
 505     return mode;
 506 }
 507
 508 /* --------------------------------------------------------------------------------------------- */
 509 /**
 510  *  p: string which might contain an url with a password (this parameter is
 511  *  modified in place).
 512  *  has_prefix = 0: The first parameter is an url without a prefix
 513  *  (user[:pass]@]machine[:port][remote-dir). Delete
 514  *  the password.
 515  *  has_prefix = 1: Search p for known url prefixes. If found delete
 516  *  the password from the url.
 517  *  Caveat: only the first url is found
 518  */
 519
 520 char *
 521 strip_password (char *p, int has_prefix)
 522 {
 523     static const struct
 524     {
 525         const char *name;
 526         size_t len;
 527     } prefixes[] =
 528     {
 529         /* *INDENT-OFF* */
 530         { "/#ftp:", 6 },
 531         { "ftp://", 6 },
 532         { "/#smb:", 6 },
 533         { "smb://", 6 },
 534         { "/#sh:", 5 },
 535         { "sh://", 5 },
 536         { "ssh://", 6 }
 537         /* *INDENT-ON* */
 538     };
 539
 540     char *at, *inner_colon, *dir;
 541     size_t i;
 542     char *result = p;
 543
 544     for (i = 0; i < sizeof (prefixes) / sizeof (prefixes[0]); i++)
 545     {
 546         char *q;
 547
 548         if (has_prefix)
 549         {
 550             q = strstr (p, prefixes[i].name);
 551             if (q == NULL)
 552                 continue;
 553             else
 554                 p = q + prefixes[i].len;
 555         }
 556
 557         dir = strchr (p, PATH_SEP);
 558         if (dir != NULL)
 559             *dir = '\0';
 560
 561         /* search for any possible user */
 562         at = strrchr (p, '@');
 563
 564         if (dir)
 565             *dir = PATH_SEP;
 566
 567         /* We have a username */
 568         if (at)
 569         {
 570             inner_colon = memchr (p, ':', at - p);
 571             if (inner_colon)
 572                 memmove (inner_colon, at, strlen (at) + 1);
 573         }
 574         break;
 575     }
 576     return (result);
 577 }
 578
 579 /* --------------------------------------------------------------------------------------------- */
 580
 581 const char *
 582 strip_home_and_password (const char *dir)
 583 {
 584     size_t len;
 585     static char newdir[MC_MAXPATHLEN];
 586
 587     len = strlen (mc_config_get_home_dir ());
 588     if (mc_config_get_home_dir () != NULL && strncmp (dir, mc_config_get_home_dir (), len) == 0 &&
 589         (dir[len] == PATH_SEP || dir[len] == '\0'))
 590     {
 591         newdir[0] = '~';
 592         g_strlcpy (&newdir[1], &dir[len], sizeof (newdir) - 1);
 593         return newdir;
 594     }
 595
 596     /* We do not strip homes in /#ftp tree, I do not like ~'s there
 597        (see ftpfs.c why) */
 598     g_strlcpy (newdir, dir, sizeof (newdir));
 599     strip_password (newdir, 1);
 600     return newdir;
 601 }
 602
 603 /* --------------------------------------------------------------------------------------------- */
 604
 605 const char *
 606 extension (const char *filename)
 607 {
 608     const char *d = strrchr (filename, '.');
 609     return (d != NULL) ? d + 1 : "";
 610 }
 611
 612 /* --------------------------------------------------------------------------------------------- */
 613
 614 int
 615 check_for_default (const char *default_file, const char *file)
 616 {
 617     if (!exist_file (file))
 618     {
 619         FileOpContext *ctx;
 620         FileOpTotalContext *tctx;
 621
 622         if (!exist_file (default_file))
 623             return -1;
 624
 625         ctx = file_op_context_new (OP_COPY);
 626         tctx = file_op_total_context_new ();
 627         file_op_context_create_ui (ctx, 0, FALSE);
 628         copy_file_file (tctx, ctx, default_file, file);
 629         file_op_total_context_destroy (tctx);
 630         file_op_context_destroy (ctx);
 631     }
 632
 633     return 0;
 634 }
 635
 636 /* --------------------------------------------------------------------------------------------- */
 637
 638 char *
 639 load_mc_home_file (const char *from, const char *filename, char **allocated_filename)
 640 {
 641     char *hintfile_base, *hintfile;
 642     char *lang;
 643     char *data;
 644
 645     hintfile_base = g_build_filename (from, filename, (char *) NULL);
 646     lang = guess_message_value ();
 647
 648     hintfile = g_strconcat (hintfile_base, ".", lang, (char *) NULL);
 649     if (!g_file_get_contents (hintfile, &data, NULL, NULL))
 650     {
 651         /* Fall back to the two-letter language code */
 652         if (lang[0] != '\0' && lang[1] != '\0')
 653             lang[2] = '\0';
 654         g_free (hintfile);
 655         hintfile = g_strconcat (hintfile_base, ".", lang, (char *) NULL);
 656         if (!g_file_get_contents (hintfile, &data, NULL, NULL))
 657         {
 658             g_free (hintfile);
 659             hintfile = hintfile_base;
 660             g_file_get_contents (hintfile_base, &data, NULL, NULL);
 661         }
 662     }
 663
 664     g_free (lang);
 665
 666     if (hintfile != hintfile_base)
 667         g_free (hintfile_base);
 668
 669     if (allocated_filename != NULL)
 670         *allocated_filename = hintfile;
 671     else
 672         g_free (hintfile);
 673
 674     return data;
 675 }
 676
 677 /* --------------------------------------------------------------------------------------------- */
 678
 679 const char *
 680 extract_line (const char *s, const char *top)
 681 {
 682     static char tmp_line[BUF_MEDIUM];
 683     char *t = tmp_line;
 684
 685     while (*s && *s != '\n' && (size_t) (t - tmp_line) < sizeof (tmp_line) - 1 && s < top)
 686         *t++ = *s++;
 687     *t = 0;
 688     return tmp_line;
 689 }
 690
 691 /* --------------------------------------------------------------------------------------------- */
 692 /**
 693  * The basename routine
 694  */
 695
 696 const char *
 697 x_basename (const char *s)
 698 {
 699     const char *where;
 700     return ((where = strrchr (s, PATH_SEP))) ? where + 1 : s;
 701 }
 702
 703 /* --------------------------------------------------------------------------------------------- */
 704
 705 const char *
 706 unix_error_string (int error_num)
 707 {
 708     static char buffer[BUF_LARGE];
 709     gchar *strerror_currentlocale;
 710
 711     strerror_currentlocale = g_locale_from_utf8 (g_strerror (error_num), -1, NULL, NULL, NULL);
 712     g_snprintf (buffer, sizeof (buffer), "%s (%d)", strerror_currentlocale, error_num);
 713     g_free (strerror_currentlocale);
 714
 715     return buffer;
 716 }
 717
 718 /* --------------------------------------------------------------------------------------------- */
 719
 720 const char *
 721 skip_separators (const char *s)
 722 {
 723     const char *su = s;
 724
 725     for (; *su; str_cnext_char (&su))
 726         if (*su != ' ' && *su != '\t' && *su != ',')
 727             break;
 728
 729     return su;
 730 }
 731
 732 /* --------------------------------------------------------------------------------------------- */
 733
 734 const char *
 735 skip_numbers (const char *s)
 736 {
 737     const char *su = s;
 738
 739     for (; *su; str_cnext_char (&su))
 740         if (!str_isdigit (su))
 741             break;
 742
 743     return su;
 744 }
 745
 746 /* --------------------------------------------------------------------------------------------- */
 747 /**
 748  * Remove all control sequences from the argument string.  We define
 749  * "control sequence", in a sort of pidgin BNF, as follows:
 750  *
 751  * control-seq = Esc non-'['
 752  *             | Esc '[' (0 or more digits or ';' or '?') (any other char)
 753  *
 754  * This scheme works for all the terminals described in my termcap /
 755  * terminfo databases, except the Hewlett-Packard 70092 and some Wyse
 756  * terminals.  If I hear from a single person who uses such a terminal
 757  * with MC, I'll be glad to add support for it.  (Dugan)
 758  * Non-printable characters are also removed.
 759  */
 760
 761 char *
 762 strip_ctrl_codes (char *s)
 763 {
 764     char *w;                    /* Current position where the stripped data is written */
 765     char *r;                    /* Current position where the original data is read */
 766     char *n;
 767
 768     if (!s)
 769         return 0;
 770
 771     for (w = s, r = s; *r;)
 772     {
 773         if (*r == ESC_CHAR)
 774         {
 775             /* Skip the control sequence's arguments */ ;
 776             /* '(' need to avoid strange 'B' letter in *Suse (if mc runs under root user) */
 777             if (*(++r) == '[' || *r == '(')
 778             {
 779                 /* strchr() matches trailing binary 0 */
 780                 while (*(++r) && strchr ("0123456789;?", *r));
 781             }
 782             else if (*r == ']')
 783             {
 784                 /*
 785                  * Skip xterm's OSC (Operating System Command)
 786                  * http://www.xfree86.org/current/ctlseqs.html
 787                  * OSC P s ; P t ST
 788                  * OSC P s ; P t BEL
 789                  */
 790                 char *new_r = r;
 791
 792                 for (; *new_r; ++new_r)
 793                 {
 794                     switch (*new_r)
 795                     {
 796                         /* BEL */
 797                     case '\a':
 798                         r = new_r;
 799                         goto osc_out;
 800                     case ESC_CHAR:
 801                         /* ST */
 802                         if (*(new_r + 1) == '\\')
 803                         {
 804                             r = new_r + 1;
 805                             goto osc_out;
 806                         }
 807                     }
 808                 }
 809               osc_out:;
 810             }
 811
 812             /*
 813              * Now we are at the last character of the sequence.
 814              * Skip it unless it's binary 0.
 815              */
 816             if (*r)
 817                 r++;
 818             continue;
 819         }
 820
 821         n = str_get_next_char (r);
 822         if (str_isprint (r))
 823         {
 824             memmove (w, r, n - r);
 825             w += n - r;
 826         }
 827         r = n;
 828     }
 829     *w = 0;
 830     return s;
 831 }
 832
 833 /* --------------------------------------------------------------------------------------------- */
 834
 835 enum compression_type
 836 get_compression_type (int fd, const char *name)
 837 {
 838     unsigned char magic[16];
 839     size_t str_len;
 840
 841     /* Read the magic signature */
 842     if (mc_read (fd, (char *) magic, 4) != 4)
 843         return COMPRESSION_NONE;
 844
 845     /* GZIP_MAGIC and OLD_GZIP_MAGIC */
 846     if (magic[0] == 037 && (magic[1] == 0213 || magic[1] == 0236))
 847     {
 848         return COMPRESSION_GZIP;
 849     }
 850
 851     /* PKZIP_MAGIC */
 852     if (magic[0] == 0120 && magic[1] == 0113 && magic[2] == 003 && magic[3] == 004)
 853     {
 854         /* Read compression type */
 855         mc_lseek (fd, 8, SEEK_SET);
 856         if (mc_read (fd, (char *) magic, 2) != 2)
 857             return COMPRESSION_NONE;
 858
 859         /* Gzip can handle only deflated (8) or stored (0) files */
 860         if ((magic[0] != 8 && magic[0] != 0) || magic[1] != 0)
 861             return COMPRESSION_NONE;
 862
 863         /* Compatible with gzip */
 864         return COMPRESSION_GZIP;
 865     }
 866
 867     /* PACK_MAGIC and LZH_MAGIC and compress magic */
 868     if (magic[0] == 037 && (magic[1] == 036 || magic[1] == 0240 || magic[1] == 0235))
 869     {
 870         /* Compatible with gzip */
 871         return COMPRESSION_GZIP;
 872     }
 873
 874     /* BZIP and BZIP2 files */
 875     if ((magic[0] == 'B') && (magic[1] == 'Z') && (magic[3] >= '1') && (magic[3] <= '9'))
 876     {
 877         switch (magic[2])
 878         {
 879         case '0':
 880             return COMPRESSION_BZIP;
 881         case 'h':
 882             return COMPRESSION_BZIP2;
 883         }
 884     }
 885
 886     /* Support for LZMA (only utils format with magic in header).
 887      * This is the default format of LZMA utils 4.32.1 and later. */
 888
 889     if (mc_read (fd, (char *) magic + 4, 2) != 2)
 890         return COMPRESSION_NONE;
 891
 892     /* LZMA utils format */
 893     if (magic[0] == 0xFF
 894         && magic[1] == 'L'
 895         && magic[2] == 'Z' && magic[3] == 'M' && magic[4] == 'A' && magic[5] == 0x00)
 896         return COMPRESSION_LZMA;
 897
 898     /* XZ compression magic */
 899     if (magic[0] == 0xFD
 900         && magic[1] == 0x37
 901         && magic[2] == 0x7A && magic[3] == 0x58 && magic[4] == 0x5A && magic[5] == 0x00)
 902         return COMPRESSION_XZ;
 903
 904     str_len = strlen (name);
 905     /* HACK: we must belive to extention of LZMA file :) ... */
 906     if ((str_len > 5 && strcmp (&name[str_len - 5], ".lzma") == 0) ||
 907         (str_len > 4 && strcmp (&name[str_len - 4], ".tlz") == 0))
 908         return COMPRESSION_LZMA;
 909
 910     return COMPRESSION_NONE;
 911 }
 912
 913 /* --------------------------------------------------------------------------------------------- */
 914
 915 const char *
 916 decompress_extension (int type)
 917 {
 918     switch (type)
 919     {
 920     case COMPRESSION_GZIP:
 921         return "#ugz";
 922     case COMPRESSION_BZIP:
 923         return "#ubz";
 924     case COMPRESSION_BZIP2:
 925         return "#ubz2";
 926     case COMPRESSION_LZMA:
 927         return "#ulzma";
 928     case COMPRESSION_XZ:
 929         return "#uxz";
 930     }
 931     /* Should never reach this place */
 932     fprintf (stderr, "Fatal: decompress_extension called with an unknown argument\n");
 933     return 0;
 934 }
 935
 936 /* --------------------------------------------------------------------------------------------- */
 937
 938 void
 939 wipe_password (char *passwd)
 940 {
 941     char *p = passwd;
 942
 943     if (!p)
 944         return;
 945     for (; *p; p++)
 946         *p = 0;
 947     g_free (passwd);
 948 }
 949
 950 /* --------------------------------------------------------------------------------------------- */
 951 /**
 952  * Convert "\E" -> esc character and ^x to control-x key and ^^ to ^ key
 953  * @returns a newly allocated string
 954  */
 955
 956 char *
 957 convert_controls (const char *p)
 958 {
 959     char *valcopy = g_strdup (p);
 960     char *q;
 961
 962     /* Parse the escape special character */
 963     for (q = valcopy; *p;)
 964     {
 965         if (*p == '\\')
 966         {
 967             p++;
 968             if ((*p == 'e') || (*p == 'E'))
 969             {
 970                 p++;
 971                 *q++ = ESC_CHAR;
 972             }
 973         }
 974         else
 975         {
 976             if (*p == '^')
 977             {
 978                 p++;
 979                 if (*p == '^')
 980                     *q++ = *p++;
 981                 else
 982                 {
 983                     char c = (*p | 0x20);
 984                     if (c >= 'a' && c <= 'z')
 985                     {
 986                         *q++ = c - 'a' + 1;
 987                         p++;
 988                     }
 989                     else if (*p)
 990                         p++;
 991                 }
 992             }
 993             else
 994                 *q++ = *p++;
 995         }
 996     }
 997     *q = 0;
 998     return valcopy;
 999 }
1000
1001 /* --------------------------------------------------------------------------------------------- */
1002 /**
1003  * Finds out a relative path from first to second, i.e. goes as many ..
1004  * as needed up in first and then goes down using second
1005  */
1006
1007 char *
1008 diff_two_paths (const char *first, const char *second)
1009 {
1010     char *p, *q, *r, *s, *buf = NULL;
1011     int i, j, prevlen = -1, currlen;
1012     char *my_first = NULL, *my_second = NULL;
1013
1014     my_first = resolve_symlinks (first);
1015     if (my_first == NULL)
1016         return NULL;
1017     my_second = resolve_symlinks (second);
1018     if (my_second == NULL)
1019     {
1020         g_free (my_first);
1021         return NULL;
1022     }
1023     for (j = 0; j < 2; j++)
1024     {
1025         p = my_first;
1026         q = my_second;
1027         for (;;)
1028         {
1029             r = strchr (p, PATH_SEP);
1030             s = strchr (q, PATH_SEP);
1031             if (!r || !s)
1032                 break;
1033             *r = 0;
1034             *s = 0;
1035             if (strcmp (p, q))
1036             {
1037                 *r = PATH_SEP;
1038                 *s = PATH_SEP;
1039                 break;
1040             }
1041             else
1042             {
1043                 *r = PATH_SEP;
1044                 *s = PATH_SEP;
1045             }
1046             p = r + 1;
1047             q = s + 1;
1048         }
1049         p--;
1050         for (i = 0; (p = strchr (p + 1, PATH_SEP)) != NULL; i++);
1051         currlen = (i + 1) * 3 + strlen (q) + 1;
1052         if (j)
1053         {
1054             if (currlen < prevlen)
1055                 g_free (buf);
1056             else
1057             {
1058                 g_free (my_first);
1059                 g_free (my_second);
1060                 return buf;
1061             }
1062         }
1063         p = buf = g_malloc (currlen);
1064         prevlen = currlen;
1065         for (; i >= 0; i--, p += 3)
1066             strcpy (p, "../");
1067         strcpy (p, q);
1068     }
1069     g_free (my_first);
1070     g_free (my_second);
1071     return buf;
1072 }
1073
1074 /* --------------------------------------------------------------------------------------------- */
1075 /**
1076  * If filename is NULL, then we just append PATH_SEP to the dir
1077  */
1078
1079 char *
1080 concat_dir_and_file (const char *dir, const char *file)
1081 {
1082     int i = strlen (dir);
1083
1084     if (dir[i - 1] == PATH_SEP)
1085         return g_strconcat (dir, file, (char *) NULL);
1086     else
1087         return g_strconcat (dir, PATH_SEP_STR, file, (char *) NULL);
1088 }
1089
1090 /* --------------------------------------------------------------------------------------------- */
1091 /**
1092  * Append text to GList, remove all entries with the same text
1093  */
1094
1095 GList *
1096 list_append_unique (GList * list, char *text)
1097 {
1098     GList *lc_link;
1099
1100     /*
1101      * Go to the last position and traverse the list backwards
1102      * starting from the second last entry to make sure that we
1103      * are not removing the current link.
1104      */
1105     list = g_list_append (list, text);
1106     list = g_list_last (list);
1107     lc_link = g_list_previous (list);
1108
1109     while (lc_link != NULL)
1110     {
1111         GList *newlink;
1112
1113         newlink = g_list_previous (lc_link);
1114         if (strcmp ((char *) lc_link->data, text) == 0)
1115         {
1116             GList *tmp;
1117
1118             g_free (lc_link->data);
1119             tmp = g_list_remove_link (list, lc_link);
1120             g_list_free_1 (lc_link);
1121         }
1122         lc_link = newlink;
1123     }
1124
1125     return list;
1126 }
1127
1128 /* --------------------------------------------------------------------------------------------- */
1129 /* Following code heavily borrows from libiberty, mkstemps.c */
1130 /*
1131  * Arguments:
1132  * pname (output) - pointer to the name of the temp file (needs g_free).
1133  *                  NULL if the function fails.
1134  * prefix - part of the filename before the random part.
1135  *          Prepend $TMPDIR or /tmp if there are no path separators.
1136  * suffix - if not NULL, part of the filename after the random part.
1137  *
1138  * Result:
1139  * handle of the open file or -1 if couldn't open any.
1140  */
1141
1142 int
1143 mc_mkstemps (char **pname, const char *prefix, const char *suffix)
1144 {
1145     static const char letters[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1146     static unsigned long value;
1147     struct timeval tv;
1148     char *tmpbase;
1149     char *tmpname;
1150     char *XXXXXX;
1151     int count;
1152
1153     if (strchr (prefix, PATH_SEP) == NULL)
1154     {
1155         /* Add prefix first to find the position of XXXXXX */
1156         tmpbase = concat_dir_and_file (mc_tmpdir (), prefix);
1157     }
1158     else
1159     {
1160         tmpbase = g_strdup (prefix);
1161     }
1162
1163     tmpname = g_strconcat (tmpbase, "XXXXXX", suffix, (char *) NULL);
1164     *pname = tmpname;
1165     XXXXXX = &tmpname[strlen (tmpbase)];
1166     g_free (tmpbase);
1167
1168     /* Get some more or less random data.  */
1169     gettimeofday (&tv, NULL);
1170     value += (tv.tv_usec << 16) ^ tv.tv_sec ^ getpid ();
1171
1172     for (count = 0; count < TMP_MAX; ++count)
1173     {
1174         unsigned long v = value;
1175         int fd;
1176
1177         /* Fill in the random bits.  */
1178         XXXXXX[0] = letters[v % 62];
1179         v /= 62;
1180         XXXXXX[1] = letters[v % 62];
1181         v /= 62;
1182         XXXXXX[2] = letters[v % 62];
1183         v /= 62;
1184         XXXXXX[3] = letters[v % 62];
1185         v /= 62;
1186         XXXXXX[4] = letters[v % 62];
1187         v /= 62;
1188         XXXXXX[5] = letters[v % 62];
1189
1190         fd = open (tmpname, O_RDWR | O_CREAT | O_TRUNC | O_EXCL, S_IRUSR | S_IWUSR);
1191         if (fd >= 0)
1192         {
1193             /* Successfully created.  */
1194             return fd;
1195         }
1196
1197         /* This is a random value.  It is only necessary that the next
1198            TMP_MAX values generated by adding 7777 to VALUE are different
1199            with (module 2^32).  */
1200         value += 7777;
1201     }
1202
1203     /* Unsuccessful. Free the filename. */
1204     g_free (tmpname);
1205     *pname = NULL;
1206
1207     return -1;
1208 }
1209
1210 /* --------------------------------------------------------------------------------------------- */
1211 /**
1212  * Read and restore position for the given filename.
1213  * If there is no stored data, return line 1 and col 0.
1214  */
1215
1216 void
1217 load_file_position (const char *filename, long *line, long *column, off_t * offset,
1218                     GArray ** bookmarks)
1219 {
1220     char *fn;
1221     FILE *f;
1222     char buf[MC_MAXPATHLEN + 100];
1223     const size_t len = strlen (filename);
1224
1225     /* defaults */
1226     *line = 1;
1227     *column = 0;
1228     *offset = 0;
1229
1230     /* open file with positions */
1231     fn = g_build_filename (mc_config_get_cache_path (), MC_FILEPOS_FILE, NULL);
1232     f = fopen (fn, "r");
1233     g_free (fn);
1234     if (f == NULL)
1235         return;
1236
1237     /* prepare array for serialized bookmarks */
1238     *bookmarks = g_array_sized_new (FALSE, FALSE, sizeof (size_t), MAX_SAVED_BOOKMARKS);
1239
1240     while (fgets (buf, sizeof (buf), f) != NULL)
1241     {
1242         const char *p;
1243         gchar **pos_tokens;
1244
1245         /* check if the filename matches the beginning of string */
1246         if (strncmp (buf, filename, len) != 0)
1247             continue;
1248
1249         /* followed by single space */
1250         if (buf[len] != ' ')
1251             continue;
1252
1253         /* and string without spaces */
1254         p = &buf[len + 1];
1255         if (strchr (p, ' ') != NULL)
1256             continue;
1257
1258         pos_tokens = g_strsplit (p, ";", 3 + MAX_SAVED_BOOKMARKS);
1259         if (pos_tokens[0] == NULL)
1260         {
1261             *line = 1;
1262             *column = 0;
1263             *offset = 0;
1264         }
1265         else
1266         {
1267             *line = strtol (pos_tokens[0], NULL, 10);
1268             if (pos_tokens[1] == NULL)
1269             {
1270                 *column = 0;
1271                 *offset = 0;
1272             }
1273             else
1274             {
1275                 *column = strtol (pos_tokens[1], NULL, 10);
1276                 if (pos_tokens[2] == NULL)
1277                     *offset = 0;
1278                 else
1279                 {
1280                     size_t i;
1281
1282                     *offset = strtoll (pos_tokens[2], NULL, 10);
1283
1284                     for (i = 0; i < MAX_SAVED_BOOKMARKS && pos_tokens[3 + i] != NULL; i++)
1285                     {
1286                         size_t val;
1287
1288                         val = strtoul (pos_tokens[3 + i], NULL, 10);
1289                         g_array_append_val (*bookmarks, val);
1290                     }
1291                 }
1292             }
1293         }
1294
1295         g_strfreev (pos_tokens);
1296     }
1297
1298     fclose (f);
1299 }
1300
1301 /* --------------------------------------------------------------------------------------------- */
1302 /**
1303  * Save position for the given file
1304  */
1305
1306 void
1307 save_file_position (const char *filename, long line, long column, off_t offset, GArray * bookmarks)
1308 {
1309     static size_t filepos_max_saved_entries = 0;
1310     char *fn, *tmp_fn;
1311     FILE *f, *tmp_f;
1312     char buf[MC_MAXPATHLEN + 100];
1313     size_t i;
1314     const size_t len = strlen (filename);
1315     gboolean src_error = FALSE;
1316
1317     if (filepos_max_saved_entries == 0)
1318         filepos_max_saved_entries = mc_config_get_int (mc_main_config, CONFIG_APP_SECTION,
1319                                                        "filepos_max_saved_entries", 1024);
1320
1321     fn = g_build_filename (mc_config_get_cache_path (), MC_FILEPOS_FILE, NULL);
1322     if (fn == NULL)
1323         goto early_error;
1324
1325     mc_util_make_backup_if_possible (fn, TMP_SUFFIX);
1326
1327     /* open file */
1328     f = fopen (fn, "w");
1329     if (f == NULL)
1330         goto open_target_error;
1331
1332     tmp_fn = g_strdup_printf ("%s" TMP_SUFFIX, fn);
1333     tmp_f = fopen (tmp_fn, "r");
1334     if (tmp_f == NULL)
1335     {
1336         src_error = TRUE;
1337         goto open_source_error;
1338     }
1339
1340     /* put the new record */
1341     if (line != 1 || column != 0 || bookmarks != NULL)
1342     {
1343         if (fprintf (f, "%s %ld;%ld;%" PRIuMAX, filename, line, column, (uintmax_t) offset) < 0)
1344             goto write_position_error;
1345         if (bookmarks != NULL)
1346             for (i = 0; i < bookmarks->len && i < MAX_SAVED_BOOKMARKS; i++)
1347                 if (fprintf (f, ";%zu", g_array_index (bookmarks, size_t, i)) < 0)
1348                     goto write_position_error;
1349
1350         if (fprintf (f, "\n") < 0)
1351             goto write_position_error;
1352     }
1353
1354     i = 1;
1355     while (fgets (buf, sizeof (buf), tmp_f) != NULL)
1356     {
1357         if (buf[len] == ' ' && strncmp (buf, filename, len) == 0
1358             && strchr (&buf[len + 1], ' ') == NULL)
1359             continue;
1360
1361         fprintf (f, "%s", buf);
1362         if (++i > filepos_max_saved_entries)
1363             break;
1364     }
1365
1366   write_position_error:
1367     fclose (tmp_f);
1368   open_source_error:
1369     g_free (tmp_fn);
1370     fclose (f);
1371     if (src_error)
1372         mc_util_restore_from_backup_if_possible (fn, TMP_SUFFIX);
1373     else
1374         mc_util_unlink_backup_if_possible (fn, TMP_SUFFIX);
1375   open_target_error:
1376     g_free (fn);
1377   early_error:
1378     if (bookmarks != NULL)
1379         g_array_free (bookmarks, TRUE);
1380 }
1381
1382 /* --------------------------------------------------------------------------------------------- */
1383
1384 extern int
1385 ascii_alpha_to_cntrl (int ch)
1386 {
1387     if ((ch >= ASCII_A && ch <= ASCII_Z) || (ch >= ASCII_a && ch <= ASCII_z))
1388     {
1389         ch &= 0x1f;
1390     }
1391     return ch;
1392 }
1393
1394 /* --------------------------------------------------------------------------------------------- */
1395
1396 const char *
1397 Q_ (const char *s)
1398 {
1399     const char *result, *sep;
1400
1401     result = _(s);
1402     sep = strchr (result, '|');
1403     return (sep != NULL) ? sep + 1 : result;
1404 }
1405
1406 /* --------------------------------------------------------------------------------------------- */
1407
1408 gboolean
1409 mc_util_make_backup_if_possible (const char *file_name, const char *backup_suffix)
1410 {
1411     struct stat stat_buf;
1412     char *backup_path;
1413     gboolean ret;
1414     if (!exist_file (file_name))
1415         return FALSE;
1416
1417     backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1418
1419     if (backup_path == NULL)
1420         return FALSE;
1421
1422     ret = mc_util_write_backup_content (file_name, backup_path);
1423
1424     if (ret)
1425     {
1426         /* Backup file will have same ownership with main file. */
1427         if (stat (file_name, &stat_buf) == 0)
1428             chmod (backup_path, stat_buf.st_mode);
1429         else
1430             chmod (backup_path, S_IRUSR | S_IWUSR);
1431     }
1432
1433     g_free (backup_path);
1434
1435     return ret;
1436 }
1437
1438 /* --------------------------------------------------------------------------------------------- */
1439
1440 gboolean
1441 mc_util_restore_from_backup_if_possible (const char *file_name, const char *backup_suffix)
1442 {
1443     gboolean ret;
1444     char *backup_path;
1445
1446     backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1447     if (backup_path == NULL)
1448         return FALSE;
1449
1450     ret = mc_util_write_backup_content (backup_path, file_name);
1451     g_free (backup_path);
1452
1453     return ret;
1454 }
1455
1456 /* --------------------------------------------------------------------------------------------- */
1457
1458 gboolean
1459 mc_util_unlink_backup_if_possible (const char *file_name, const char *backup_suffix)
1460 {
1461     char *backup_path;
1462
1463     backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1464     if (backup_path == NULL)
1465         return FALSE;
1466
1467     if (exist_file (backup_path))
1468         mc_unlink (backup_path);
1469
1470     g_free (backup_path);
1471     return TRUE;
1472 }
1473
1474 /* --------------------------------------------------------------------------------------------- */
1475 /**
1476  * partly taken from dcigettext.c, returns "" for default locale
1477  * value should be freed by calling function g_free()
1478  */
1479
1480 char *
1481 guess_message_value (void)
1482 {
1483     static const char *const var[] = {
1484         /* Setting of LC_ALL overwrites all other.  */
1485         /* Do not use LANGUAGE for check user locale and drowing hints */
1486         "LC_ALL",
1487         /* Next comes the name of the desired category.  */
1488         "LC_MESSAGES",
1489         /* Last possibility is the LANG environment variable.  */
1490         "LANG",
1491         /* NULL exit loops */
1492         NULL
1493     };
1494
1495     unsigned i = 0;
1496     const char *locale = NULL;
1497
1498     while (var[i] != NULL)
1499     {
1500         locale = getenv (var[i]);
1501         if (locale != NULL && locale[0] != '\0')
1502             break;
1503         i++;
1504     }
1505
1506     if (locale == NULL)
1507         locale = "";
1508
1509     return g_strdup (locale);
1510 }
1511
1512 /* --------------------------------------------------------------------------------------------- */