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