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