src/util.c

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