Merge branch '3607_cleanup'
[midnight-commander.git] / lib / util.c
blobf22c88561d0ff8f1bbf4a3c49bde31f5d2836b42
1 /*
2 Various utilities
4 Copyright (C) 1994-2016
5 Free Software Foundation, Inc.
7 Written by:
8 Miguel de Icaza, 1994, 1995, 1996
9 Janne Kukonlehto, 1994, 1995, 1996
10 Dugan Porter, 1994, 1995, 1996
11 Jakub Jelinek, 1994, 1995, 1996
12 Mauricio Plaza, 1994, 1995, 1996
13 Slava Zanko <slavazanko@gmail.com>, 2013
15 This file is part of the Midnight Commander.
17 The Midnight Commander is free software: you can redistribute it
18 and/or modify it under the terms of the GNU General Public License as
19 published by the Free Software Foundation, either version 3 of the License,
20 or (at your option) any later version.
22 The Midnight Commander is distributed in the hope that it will be useful,
23 but WITHOUT ANY WARRANTY; without even the implied warranty of
24 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 GNU General Public License for more details.
27 You should have received a copy of the GNU General Public License
28 along with this program. If not, see <http://www.gnu.org/licenses/>.
31 /** \file lib/util.c
32 * \brief Source: various utilities
35 #include <config.h>
37 #include <ctype.h>
38 #include <limits.h>
39 #include <stdarg.h>
40 #include <stdio.h>
41 #include <stdlib.h>
42 #include <string.h>
43 #include <sys/time.h>
44 #include <sys/types.h>
45 #include <sys/stat.h>
46 #include <unistd.h>
48 #include "lib/global.h"
49 #include "lib/mcconfig.h"
50 #include "lib/fileloc.h"
51 #include "lib/vfs/vfs.h"
52 #include "lib/strutil.h"
53 #include "lib/util.h"
54 #include "lib/timer.h"
56 /*** global variables ****************************************************************************/
58 /*** file scope macro definitions ****************************************************************/
60 #define ismode(n,m) ((n & m) == m)
62 /* Number of attempts to create a temporary file */
63 #ifndef TMP_MAX
64 #define TMP_MAX 16384
65 #endif /* !TMP_MAX */
67 #define TMP_SUFFIX ".tmp"
69 #define ASCII_A (0x40 + 1)
70 #define ASCII_Z (0x40 + 26)
71 #define ASCII_a (0x60 + 1)
72 #define ASCII_z (0x60 + 26)
74 /*** file scope type declarations ****************************************************************/
76 /*** file scope variables ************************************************************************/
78 /*** file scope functions ************************************************************************/
79 /* --------------------------------------------------------------------------------------------- */
81 #ifndef HAVE_CHARSET
82 static inline int
83 is_7bit_printable (unsigned char c)
85 return (c > 31 && c < 127);
87 #endif
89 /* --------------------------------------------------------------------------------------------- */
91 static inline int
92 is_iso_printable (unsigned char c)
94 return ((c > 31 && c < 127) || c >= 160);
97 /* --------------------------------------------------------------------------------------------- */
99 static inline int
100 is_8bit_printable (unsigned char c)
102 /* "Full 8 bits output" doesn't work on xterm */
103 if (mc_global.tty.xterm_flag)
104 return is_iso_printable (c);
106 return (c > 31 && c != 127 && c != 155);
109 /* --------------------------------------------------------------------------------------------- */
111 static char *
112 resolve_symlinks (const vfs_path_t * vpath)
114 char *p, *p2;
115 char *buf, *buf2, *q, *r, c;
116 struct stat mybuf;
118 if (vpath->relative)
119 return NULL;
121 p = p2 = g_strdup (vfs_path_as_str (vpath));
122 r = buf = g_malloc (MC_MAXPATHLEN);
123 buf2 = g_malloc (MC_MAXPATHLEN);
124 *r++ = PATH_SEP;
125 *r = 0;
129 q = strchr (p + 1, PATH_SEP);
130 if (!q)
132 q = strchr (p + 1, 0);
133 if (q == p + 1)
134 break;
136 c = *q;
137 *q = 0;
138 if (mc_lstat (vpath, &mybuf) < 0)
140 MC_PTR_FREE (buf);
141 goto ret;
143 if (!S_ISLNK (mybuf.st_mode))
144 strcpy (r, p + 1);
145 else
147 int len;
149 len = mc_readlink (vpath, buf2, MC_MAXPATHLEN - 1);
150 if (len < 0)
152 MC_PTR_FREE (buf);
153 goto ret;
155 buf2[len] = 0;
156 if (IS_PATH_SEP (*buf2))
157 strcpy (buf, buf2);
158 else
159 strcpy (r, buf2);
161 canonicalize_pathname (buf);
162 r = strchr (buf, 0);
163 if (*r == '\0' || !IS_PATH_SEP (r[-1]))
164 /* FIXME: this condition is always true because r points to the EOL */
166 *r++ = PATH_SEP;
167 *r = '\0';
169 *q = c;
170 p = q;
172 while (c != '\0');
174 if (*buf == '\0')
175 strcpy (buf, PATH_SEP_STR);
176 else if (IS_PATH_SEP (r[-1]) && r != buf + 1)
177 r[-1] = '\0';
179 ret:
180 g_free (buf2);
181 g_free (p2);
182 return buf;
185 /* --------------------------------------------------------------------------------------------- */
187 static gboolean
188 mc_util_write_backup_content (const char *from_file_name, const char *to_file_name)
190 FILE *backup_fd;
191 char *contents;
192 gsize length;
193 gboolean ret1 = TRUE;
195 if (!g_file_get_contents (from_file_name, &contents, &length, NULL))
196 return FALSE;
198 backup_fd = fopen (to_file_name, "w");
199 if (backup_fd == NULL)
201 g_free (contents);
202 return FALSE;
205 if (fwrite ((const void *) contents, 1, length, backup_fd) != length)
206 ret1 = FALSE;
208 int ret2;
210 /* cppcheck-suppress redundantAssignment */
211 ret2 = fflush (backup_fd);
212 /* cppcheck-suppress redundantAssignment */
213 ret2 = fclose (backup_fd);
214 (void) ret2;
216 g_free (contents);
217 return ret1;
220 /* --------------------------------------------------------------------------------------------- */
221 /*** public functions ****************************************************************************/
222 /* --------------------------------------------------------------------------------------------- */
225 is_printable (int c)
227 c &= 0xff;
229 #ifdef HAVE_CHARSET
230 /* "Display bits" is ignored, since the user controls the output
231 by setting the output codepage */
232 return is_8bit_printable (c);
233 #else
234 if (!mc_global.eight_bit_clean)
235 return is_7bit_printable (c);
237 if (mc_global.full_eight_bits)
239 return is_8bit_printable (c);
241 else
242 return is_iso_printable (c);
243 #endif /* !HAVE_CHARSET */
246 /* --------------------------------------------------------------------------------------------- */
248 * Quote the filename for the purpose of inserting it into the command
249 * line. If quote_percent is TRUE, replace "%" with "%%" - the percent is
250 * processed by the mc command line.
252 char *
253 name_quote (const char *s, gboolean quote_percent)
255 GString *ret;
257 ret = g_string_sized_new (64);
259 if (*s == '-')
260 g_string_append (ret, "." PATH_SEP_STR);
262 for (; *s != '\0'; s++)
264 switch (*s)
266 case '%':
267 if (quote_percent)
268 g_string_append_c (ret, '%');
269 break;
270 case '\'':
271 case '\\':
272 case '\r':
273 case '\n':
274 case '\t':
275 case '"':
276 case ';':
277 case ' ':
278 case '?':
279 case '|':
280 case '[':
281 case ']':
282 case '{':
283 case '}':
284 case '<':
285 case '>':
286 case '`':
287 case '!':
288 case '$':
289 case '&':
290 case '*':
291 case '(':
292 case ')':
293 g_string_append_c (ret, '\\');
294 break;
295 case '~':
296 case '#':
297 if (ret->len == 0)
298 g_string_append_c (ret, '\\');
299 break;
300 default:
301 break;
303 g_string_append_c (ret, *s);
306 return g_string_free (ret, FALSE);
309 /* --------------------------------------------------------------------------------------------- */
311 char *
312 fake_name_quote (const char *s, gboolean quote_percent)
314 (void) quote_percent;
315 return g_strdup (s);
318 /* --------------------------------------------------------------------------------------------- */
320 * path_trunc() is the same as str_trunc() but
321 * it deletes possible password from path for security
322 * reasons.
325 const char *
326 path_trunc (const char *path, size_t trunc_len)
328 vfs_path_t *vpath;
329 char *secure_path;
330 const char *ret;
332 vpath = vfs_path_from_str (path);
333 secure_path = vfs_path_to_str_flags (vpath, 0, VPF_STRIP_PASSWORD);
334 vfs_path_free (vpath);
336 ret = str_trunc (secure_path, trunc_len);
337 g_free (secure_path);
339 return ret;
342 /* --------------------------------------------------------------------------------------------- */
344 const char *
345 size_trunc (uintmax_t size, gboolean use_si)
347 static char x[BUF_TINY];
348 uintmax_t divisor = 1;
349 const char *xtra = "";
351 if (size > 999999999UL)
353 divisor = use_si ? 1000 : 1024;
354 xtra = use_si ? "k" : "K";
356 if (size / divisor > 999999999UL)
358 divisor = use_si ? (1000 * 1000) : (1024 * 1024);
359 xtra = use_si ? "m" : "M";
361 if (size / divisor > 999999999UL)
363 divisor = use_si ? (1000 * 1000 * 1000) : (1024 * 1024 * 1024);
364 xtra = use_si ? "g" : "G";
368 g_snprintf (x, sizeof (x), "%.0f%s", 1.0 * size / divisor, xtra);
369 return x;
372 /* --------------------------------------------------------------------------------------------- */
374 const char *
375 size_trunc_sep (uintmax_t size, gboolean use_si)
377 static char x[60];
378 int count;
379 const char *p, *y;
380 char *d;
382 p = y = size_trunc (size, use_si);
383 p += strlen (p) - 1;
384 d = x + sizeof (x) - 1;
385 *d-- = '\0';
386 while (p >= y && isalpha ((unsigned char) *p))
387 *d-- = *p--;
388 for (count = 0; p >= y; count++)
390 if (count == 3)
392 *d-- = ',';
393 count = 0;
395 *d-- = *p--;
397 d++;
398 if (*d == ',')
399 d++;
400 return d;
403 /* --------------------------------------------------------------------------------------------- */
405 * Print file SIZE to BUFFER, but don't exceed LEN characters,
406 * not including trailing 0. BUFFER should be at least LEN+1 long.
407 * This function is called for every file on panels, so avoid
408 * floating point by any means.
410 * Units: size units (filesystem sizes are 1K blocks)
411 * 0=bytes, 1=Kbytes, 2=Mbytes, etc.
414 void
415 size_trunc_len (char *buffer, unsigned int len, uintmax_t size, int units, gboolean use_si)
417 /* Avoid taking power for every file. */
418 /* *INDENT-OFF* */
419 static const uintmax_t power10[] = {
420 /* we hope that size of uintmax_t is 4 bytes at least */
421 1ULL,
422 10ULL,
423 100ULL,
424 1000ULL,
425 10000ULL,
426 100000ULL,
427 1000000ULL,
428 10000000ULL,
429 100000000ULL,
430 1000000000ULL
431 /* maximum value of uintmax_t (in case of 4 bytes) is
432 4294967295
434 #if SIZEOF_UINTMAX_T == 8
436 10000000000ULL,
437 100000000000ULL,
438 1000000000000ULL,
439 10000000000000ULL,
440 100000000000000ULL,
441 1000000000000000ULL,
442 10000000000000000ULL,
443 100000000000000000ULL,
444 1000000000000000000ULL,
445 10000000000000000000ULL
446 /* maximum value of uintmax_t (in case of 8 bytes) is
447 18447644073710439615
449 #endif
451 /* *INDENT-ON* */
452 static const char *const suffix[] = { "", "K", "M", "G", "T", "P", "E", "Z", "Y", NULL };
453 static const char *const suffix_lc[] = { "", "k", "m", "g", "t", "p", "e", "z", "y", NULL };
455 const char *const *sfx = use_si ? suffix_lc : suffix;
456 int j = 0;
458 if (len == 0)
459 len = 9;
460 #if SIZEOF_UINTMAX_T == 8
461 /* 20 decimal digits are required to represent 8 bytes */
462 else if (len > 19)
463 len = 19;
464 #else
465 /* 10 decimal digits are required to represent 4 bytes */
466 else if (len > 9)
467 len = 9;
468 #endif
471 * recalculate from 1024 base to 1000 base if units>0
472 * We can't just multiply by 1024 - that might cause overflow
473 * if uintmax_t type is too small
475 if (use_si)
476 for (j = 0; j < units; j++)
478 uintmax_t size_remain;
480 size_remain = ((size % 125) * 1024) / 1000; /* size mod 125, recalculated */
481 size /= 125; /* 128/125 = 1024/1000 */
482 size *= 128; /* This will convert size from multiple of 1024 to multiple of 1000 */
483 size += size_remain; /* Re-add remainder lost by division/multiplication */
486 for (j = units; sfx[j] != NULL; j++)
488 if (size == 0)
490 if (j == units)
492 /* Empty files will print "0" even with minimal width. */
493 g_snprintf (buffer, len + 1, "%s", "0");
495 else
497 /* Use "~K" or just "K" if len is 1. Use "B" for bytes. */
498 g_snprintf (buffer, len + 1, (len > 1) ? "~%s" : "%s", (j > 1) ? sfx[j - 1] : "B");
500 break;
503 if (size < power10[len - (j > 0 ? 1 : 0)])
505 g_snprintf (buffer, len + 1, "%" PRIuMAX "%s", size, sfx[j]);
506 break;
509 /* Powers of 1000 or 1024, with rounding. */
510 if (use_si)
511 size = (size + 500) / 1000;
512 else
513 size = (size + 512) >> 10;
517 /* --------------------------------------------------------------------------------------------- */
519 const char *
520 string_perm (mode_t mode_bits)
522 static char mode[11];
524 strcpy (mode, "----------");
525 if (S_ISDIR (mode_bits))
526 mode[0] = 'd';
527 if (S_ISCHR (mode_bits))
528 mode[0] = 'c';
529 if (S_ISBLK (mode_bits))
530 mode[0] = 'b';
531 if (S_ISLNK (mode_bits))
532 mode[0] = 'l';
533 if (S_ISFIFO (mode_bits))
534 mode[0] = 'p';
535 if (S_ISNAM (mode_bits))
536 mode[0] = 'n';
537 if (S_ISSOCK (mode_bits))
538 mode[0] = 's';
539 if (S_ISDOOR (mode_bits))
540 mode[0] = 'D';
541 if (ismode (mode_bits, S_IXOTH))
542 mode[9] = 'x';
543 if (ismode (mode_bits, S_IWOTH))
544 mode[8] = 'w';
545 if (ismode (mode_bits, S_IROTH))
546 mode[7] = 'r';
547 if (ismode (mode_bits, S_IXGRP))
548 mode[6] = 'x';
549 if (ismode (mode_bits, S_IWGRP))
550 mode[5] = 'w';
551 if (ismode (mode_bits, S_IRGRP))
552 mode[4] = 'r';
553 if (ismode (mode_bits, S_IXUSR))
554 mode[3] = 'x';
555 if (ismode (mode_bits, S_IWUSR))
556 mode[2] = 'w';
557 if (ismode (mode_bits, S_IRUSR))
558 mode[1] = 'r';
559 #ifdef S_ISUID
560 if (ismode (mode_bits, S_ISUID))
561 mode[3] = (mode[3] == 'x') ? 's' : 'S';
562 #endif /* S_ISUID */
563 #ifdef S_ISGID
564 if (ismode (mode_bits, S_ISGID))
565 mode[6] = (mode[6] == 'x') ? 's' : 'S';
566 #endif /* S_ISGID */
567 #ifdef S_ISVTX
568 if (ismode (mode_bits, S_ISVTX))
569 mode[9] = (mode[9] == 'x') ? 't' : 'T';
570 #endif /* S_ISVTX */
571 return mode;
574 /* --------------------------------------------------------------------------------------------- */
576 const char *
577 extension (const char *filename)
579 const char *d = strrchr (filename, '.');
580 return (d != NULL) ? d + 1 : "";
583 /* --------------------------------------------------------------------------------------------- */
585 char *
586 load_mc_home_file (const char *from, const char *filename, char **allocated_filename,
587 size_t * length)
589 char *hintfile_base, *hintfile;
590 char *lang;
591 char *data;
593 hintfile_base = g_build_filename (from, filename, (char *) NULL);
594 lang = guess_message_value ();
596 hintfile = g_strconcat (hintfile_base, ".", lang, (char *) NULL);
597 if (!g_file_get_contents (hintfile, &data, length, NULL))
599 /* Fall back to the two-letter language code */
600 if (lang[0] != '\0' && lang[1] != '\0')
601 lang[2] = '\0';
602 g_free (hintfile);
603 hintfile = g_strconcat (hintfile_base, ".", lang, (char *) NULL);
604 if (!g_file_get_contents (hintfile, &data, length, NULL))
606 g_free (hintfile);
607 hintfile = hintfile_base;
608 g_file_get_contents (hintfile_base, &data, length, NULL);
612 g_free (lang);
614 if (hintfile != hintfile_base)
615 g_free (hintfile_base);
617 if (allocated_filename != NULL)
618 *allocated_filename = hintfile;
619 else
620 g_free (hintfile);
622 return data;
625 /* --------------------------------------------------------------------------------------------- */
627 const char *
628 extract_line (const char *s, const char *top)
630 static char tmp_line[BUF_MEDIUM];
631 char *t = tmp_line;
633 while (*s && *s != '\n' && (size_t) (t - tmp_line) < sizeof (tmp_line) - 1 && s < top)
634 *t++ = *s++;
635 *t = 0;
636 return tmp_line;
639 /* --------------------------------------------------------------------------------------------- */
641 * The basename routine
644 const char *
645 x_basename (const char *s)
647 const char *url_delim, *path_sep;
649 url_delim = g_strrstr (s, VFS_PATH_URL_DELIMITER);
650 path_sep = strrchr (s, PATH_SEP);
652 if (path_sep == NULL)
653 return s;
655 if (url_delim == NULL
656 || url_delim < path_sep - strlen (VFS_PATH_URL_DELIMITER)
657 || url_delim - s + strlen (VFS_PATH_URL_DELIMITER) < strlen (s))
659 /* avoid trailing PATH_SEP, if present */
660 if (!IS_PATH_SEP (s[strlen (s) - 1]))
661 return (path_sep != NULL) ? path_sep + 1 : s;
663 while (--path_sep > s && !IS_PATH_SEP (*path_sep))
665 return (path_sep != s) ? path_sep + 1 : s;
668 while (--url_delim > s && !IS_PATH_SEP (*url_delim))
670 while (--url_delim > s && !IS_PATH_SEP (*url_delim))
673 return (url_delim == s) ? s : url_delim + 1;
676 /* --------------------------------------------------------------------------------------------- */
678 const char *
679 unix_error_string (int error_num)
681 static char buffer[BUF_LARGE];
682 gchar *strerror_currentlocale;
684 strerror_currentlocale = g_locale_from_utf8 (g_strerror (error_num), -1, NULL, NULL, NULL);
685 g_snprintf (buffer, sizeof (buffer), "%s (%d)", strerror_currentlocale, error_num);
686 g_free (strerror_currentlocale);
688 return buffer;
691 /* --------------------------------------------------------------------------------------------- */
693 const char *
694 skip_separators (const char *s)
696 const char *su = s;
698 for (; *su; str_cnext_char (&su))
699 if (*su != ' ' && *su != '\t' && *su != ',')
700 break;
702 return su;
705 /* --------------------------------------------------------------------------------------------- */
707 const char *
708 skip_numbers (const char *s)
710 const char *su = s;
712 for (; *su; str_cnext_char (&su))
713 if (!str_isdigit (su))
714 break;
716 return su;
719 /* --------------------------------------------------------------------------------------------- */
721 * Remove all control sequences from the argument string. We define
722 * "control sequence", in a sort of pidgin BNF, as follows:
724 * control-seq = Esc non-'['
725 * | Esc '[' (0 or more digits or ';' or ':' or '?') (any other char)
727 * The 256-color and true-color escape sequences should allow either ';' or ':' inside as separator,
728 * actually, ':' is the more correct according to ECMA-48.
729 * Some terminal emulators (e.g. xterm, gnome-terminal) support this.
731 * Non-printable characters are also removed.
734 char *
735 strip_ctrl_codes (char *s)
737 char *w; /* Current position where the stripped data is written */
738 char *r; /* Current position where the original data is read */
740 if (s == NULL)
741 return NULL;
743 for (w = s, r = s; *r != '\0';)
745 if (*r == ESC_CHAR)
747 /* Skip the control sequence's arguments */ ;
748 /* '(' need to avoid strange 'B' letter in *Suse (if mc runs under root user) */
749 if (*(++r) == '[' || *r == '(')
751 /* strchr() matches trailing binary 0 */
752 while (*(++r) != '\0' && strchr ("0123456789;:?", *r) != NULL)
755 else if (*r == ']')
758 * Skip xterm's OSC (Operating System Command)
759 * http://www.xfree86.org/current/ctlseqs.html
760 * OSC P s ; P t ST
761 * OSC P s ; P t BEL
763 char *new_r = r;
765 for (; *new_r != '\0'; ++new_r)
767 switch (*new_r)
769 /* BEL */
770 case '\a':
771 r = new_r;
772 goto osc_out;
773 case ESC_CHAR:
774 /* ST */
775 if (*(new_r + 1) == '\\')
777 r = new_r + 1;
778 goto osc_out;
780 default:
781 break;
784 osc_out:
789 * Now we are at the last character of the sequence.
790 * Skip it unless it's binary 0.
792 if (*r != '\0')
793 r++;
795 else
797 char *n;
799 n = str_get_next_char (r);
800 if (str_isprint (r))
802 memmove (w, r, n - r);
803 w += n - r;
805 r = n;
809 *w = '\0';
810 return s;
813 /* --------------------------------------------------------------------------------------------- */
815 enum compression_type
816 get_compression_type (int fd, const char *name)
818 unsigned char magic[16];
819 size_t str_len;
821 /* Read the magic signature */
822 if (mc_read (fd, (char *) magic, 4) != 4)
823 return COMPRESSION_NONE;
825 /* GZIP_MAGIC and OLD_GZIP_MAGIC */
826 if (magic[0] == 037 && (magic[1] == 0213 || magic[1] == 0236))
828 return COMPRESSION_GZIP;
831 /* PKZIP_MAGIC */
832 if (magic[0] == 0120 && magic[1] == 0113 && magic[2] == 003 && magic[3] == 004)
834 /* Read compression type */
835 mc_lseek (fd, 8, SEEK_SET);
836 if (mc_read (fd, (char *) magic, 2) != 2)
837 return COMPRESSION_NONE;
839 /* Gzip can handle only deflated (8) or stored (0) files */
840 if ((magic[0] != 8 && magic[0] != 0) || magic[1] != 0)
841 return COMPRESSION_NONE;
843 /* Compatible with gzip */
844 return COMPRESSION_GZIP;
847 /* PACK_MAGIC and LZH_MAGIC and compress magic */
848 if (magic[0] == 037 && (magic[1] == 036 || magic[1] == 0240 || magic[1] == 0235))
850 /* Compatible with gzip */
851 return COMPRESSION_GZIP;
854 /* BZIP and BZIP2 files */
855 if ((magic[0] == 'B') && (magic[1] == 'Z') && (magic[3] >= '1') && (magic[3] <= '9'))
857 switch (magic[2])
859 case '0':
860 return COMPRESSION_BZIP;
861 case 'h':
862 return COMPRESSION_BZIP2;
863 default:
864 break;
868 /* LZ4 format - v1.5.0 - 0x184D2204 (little endian) */
869 if (magic[0] == 0x04 && magic[1] == 0x22 && magic[2] == 0x4d && magic[3] == 0x18)
870 return COMPRESSION_LZ4;
872 if (mc_read (fd, (char *) magic + 4, 2) != 2)
873 return COMPRESSION_NONE;
875 /* LZIP files */
876 if (magic[0] == 'L'
877 && magic[1] == 'Z'
878 && magic[2] == 'I' && magic[3] == 'P' && (magic[4] == 0x00 || magic[4] == 0x01))
879 return COMPRESSION_LZIP;
881 /* Support for LZMA (only utils format with magic in header).
882 * This is the default format of LZMA utils 4.32.1 and later. */
883 if (magic[0] == 0xFF
884 && magic[1] == 'L'
885 && magic[2] == 'Z' && magic[3] == 'M' && magic[4] == 'A' && magic[5] == 0x00)
886 return COMPRESSION_LZMA;
888 /* XZ compression magic */
889 if (magic[0] == 0xFD
890 && magic[1] == 0x37
891 && magic[2] == 0x7A && magic[3] == 0x58 && magic[4] == 0x5A && magic[5] == 0x00)
892 return COMPRESSION_XZ;
894 str_len = strlen (name);
895 /* HACK: we must belive to extension of LZMA file :) ... */
896 if ((str_len > 5 && strcmp (&name[str_len - 5], ".lzma") == 0) ||
897 (str_len > 4 && strcmp (&name[str_len - 4], ".tlz") == 0))
898 return COMPRESSION_LZMA;
900 return COMPRESSION_NONE;
903 /* --------------------------------------------------------------------------------------------- */
905 const char *
906 decompress_extension (int type)
908 switch (type)
910 case COMPRESSION_GZIP:
911 return "/ugz" VFS_PATH_URL_DELIMITER;
912 case COMPRESSION_BZIP:
913 return "/ubz" VFS_PATH_URL_DELIMITER;
914 case COMPRESSION_BZIP2:
915 return "/ubz2" VFS_PATH_URL_DELIMITER;
916 case COMPRESSION_LZIP:
917 return "/ulz" VFS_PATH_URL_DELIMITER;
918 case COMPRESSION_LZ4:
919 return "/ulz4" VFS_PATH_URL_DELIMITER;
920 case COMPRESSION_LZMA:
921 return "/ulzma" VFS_PATH_URL_DELIMITER;
922 case COMPRESSION_XZ:
923 return "/uxz" VFS_PATH_URL_DELIMITER;
924 default:
925 break;
927 /* Should never reach this place */
928 fprintf (stderr, "Fatal: decompress_extension called with an unknown argument\n");
929 return 0;
932 /* --------------------------------------------------------------------------------------------- */
934 void
935 wipe_password (char *passwd)
937 char *p = passwd;
939 if (!p)
940 return;
941 for (; *p; p++)
942 *p = 0;
943 g_free (passwd);
946 /* --------------------------------------------------------------------------------------------- */
948 * Convert "\E" -> esc character and ^x to control-x key and ^^ to ^ key
950 * @param p pointer to string
952 * @return newly allocated string
955 char *
956 convert_controls (const char *p)
958 char *valcopy = g_strdup (p);
959 char *q;
961 /* Parse the escape special character */
962 for (q = valcopy; *p;)
964 if (*p == '\\')
966 p++;
967 if ((*p == 'e') || (*p == 'E'))
969 p++;
970 *q++ = ESC_CHAR;
973 else
975 if (*p == '^')
977 p++;
978 if (*p == '^')
979 *q++ = *p++;
980 else
982 char c = (*p | 0x20);
983 if (c >= 'a' && c <= 'z')
985 *q++ = c - 'a' + 1;
986 p++;
988 else if (*p)
989 p++;
992 else
993 *q++ = *p++;
996 *q = 0;
997 return valcopy;
1000 /* --------------------------------------------------------------------------------------------- */
1002 * Finds out a relative path from first to second, i.e. goes as many ..
1003 * as needed up in first and then goes down using second
1006 char *
1007 diff_two_paths (const vfs_path_t * vpath1, const vfs_path_t * vpath2)
1009 char *p, *q, *r, *s, *buf = NULL;
1010 int i, j, prevlen = -1, currlen;
1011 char *my_first = NULL, *my_second = NULL;
1013 my_first = resolve_symlinks (vpath1);
1014 if (my_first == NULL)
1015 goto ret;
1017 my_second = resolve_symlinks (vpath2);
1018 if (my_second == NULL)
1019 goto ret;
1021 for (j = 0; j < 2; j++)
1023 p = my_first;
1024 q = my_second;
1025 while (TRUE)
1027 r = strchr (p, PATH_SEP);
1028 s = strchr (q, PATH_SEP);
1029 if (r == NULL || s == NULL)
1030 break;
1031 *r = '\0';
1032 *s = '\0';
1033 if (strcmp (p, q) != 0)
1035 *r = PATH_SEP;
1036 *s = PATH_SEP;
1037 break;
1040 *r = PATH_SEP;
1041 *s = PATH_SEP;
1043 p = r + 1;
1044 q = s + 1;
1046 p--;
1047 for (i = 0; (p = strchr (p + 1, PATH_SEP)) != NULL; i++)
1049 currlen = (i + 1) * 3 + strlen (q) + 1;
1050 if (j != 0)
1052 if (currlen < prevlen)
1053 g_free (buf);
1054 else
1055 goto ret;
1057 p = buf = g_malloc (currlen);
1058 prevlen = currlen;
1059 for (; i >= 0; i--, p += 3)
1060 strcpy (p, "../");
1061 strcpy (p, q);
1064 ret:
1065 g_free (my_first);
1066 g_free (my_second);
1067 return buf;
1070 /* --------------------------------------------------------------------------------------------- */
1072 * Append text to GList, remove all entries with the same text
1075 GList *
1076 list_append_unique (GList * list, char *text)
1078 GList *lc_link;
1081 * Go to the last position and traverse the list backwards
1082 * starting from the second last entry to make sure that we
1083 * are not removing the current link.
1085 list = g_list_append (list, text);
1086 list = g_list_last (list);
1087 lc_link = g_list_previous (list);
1089 while (lc_link != NULL)
1091 GList *newlink;
1093 newlink = g_list_previous (lc_link);
1094 if (strcmp ((char *) lc_link->data, text) == 0)
1096 GList *tmp;
1098 g_free (lc_link->data);
1099 tmp = g_list_remove_link (list, lc_link);
1100 (void) tmp;
1101 g_list_free_1 (lc_link);
1103 lc_link = newlink;
1106 return list;
1109 /* --------------------------------------------------------------------------------------------- */
1111 * Read and restore position for the given filename.
1112 * If there is no stored data, return line 1 and col 0.
1115 void
1116 load_file_position (const vfs_path_t * filename_vpath, long *line, long *column, off_t * offset,
1117 GArray ** bookmarks)
1119 char *fn;
1120 FILE *f;
1121 char buf[MC_MAXPATHLEN + 100];
1122 const size_t len = vfs_path_len (filename_vpath);
1124 /* defaults */
1125 *line = 1;
1126 *column = 0;
1127 *offset = 0;
1129 /* open file with positions */
1130 fn = mc_config_get_full_path (MC_FILEPOS_FILE);
1131 f = fopen (fn, "r");
1132 g_free (fn);
1133 if (f == NULL)
1134 return;
1136 /* prepare array for serialized bookmarks */
1137 if (bookmarks != NULL)
1138 *bookmarks = g_array_sized_new (FALSE, FALSE, sizeof (size_t), MAX_SAVED_BOOKMARKS);
1140 while (fgets (buf, sizeof (buf), f) != NULL)
1142 const char *p;
1143 gchar **pos_tokens;
1145 /* check if the filename matches the beginning of string */
1146 if (strncmp (buf, vfs_path_as_str (filename_vpath), len) != 0)
1147 continue;
1149 /* followed by single space */
1150 if (buf[len] != ' ')
1151 continue;
1153 /* and string without spaces */
1154 p = &buf[len + 1];
1155 if (strchr (p, ' ') != NULL)
1156 continue;
1158 pos_tokens = g_strsplit (p, ";", 3 + MAX_SAVED_BOOKMARKS);
1159 if (pos_tokens[0] == NULL)
1161 *line = 1;
1162 *column = 0;
1163 *offset = 0;
1165 else
1167 *line = strtol (pos_tokens[0], NULL, 10);
1168 if (pos_tokens[1] == NULL)
1170 *column = 0;
1171 *offset = 0;
1173 else
1175 *column = strtol (pos_tokens[1], NULL, 10);
1176 if (pos_tokens[2] == NULL)
1177 *offset = 0;
1178 else if (bookmarks != NULL)
1180 size_t i;
1182 *offset = (off_t) g_ascii_strtoll (pos_tokens[2], NULL, 10);
1184 for (i = 0; i < MAX_SAVED_BOOKMARKS && pos_tokens[3 + i] != NULL; i++)
1186 size_t val;
1188 val = strtoul (pos_tokens[3 + i], NULL, 10);
1189 g_array_append_val (*bookmarks, val);
1195 g_strfreev (pos_tokens);
1198 fclose (f);
1201 /* --------------------------------------------------------------------------------------------- */
1203 * Save position for the given file
1206 void
1207 save_file_position (const vfs_path_t * filename_vpath, long line, long column, off_t offset,
1208 GArray * bookmarks)
1210 static size_t filepos_max_saved_entries = 0;
1211 char *fn, *tmp_fn;
1212 FILE *f, *tmp_f;
1213 char buf[MC_MAXPATHLEN + 100];
1214 size_t i;
1215 const size_t len = vfs_path_len (filename_vpath);
1216 gboolean src_error = FALSE;
1218 if (filepos_max_saved_entries == 0)
1219 filepos_max_saved_entries = mc_config_get_int (mc_global.main_config, CONFIG_APP_SECTION,
1220 "filepos_max_saved_entries", 1024);
1222 fn = mc_config_get_full_path (MC_FILEPOS_FILE);
1223 if (fn == NULL)
1224 goto early_error;
1226 mc_util_make_backup_if_possible (fn, TMP_SUFFIX);
1228 /* open file */
1229 f = fopen (fn, "w");
1230 if (f == NULL)
1231 goto open_target_error;
1233 tmp_fn = g_strdup_printf ("%s" TMP_SUFFIX, fn);
1234 tmp_f = fopen (tmp_fn, "r");
1235 if (tmp_f == NULL)
1237 src_error = TRUE;
1238 goto open_source_error;
1241 /* put the new record */
1242 if (line != 1 || column != 0 || bookmarks != NULL)
1244 if (fprintf
1245 (f, "%s %ld;%ld;%" PRIuMAX, vfs_path_as_str (filename_vpath), line, column,
1246 (uintmax_t) offset) < 0)
1247 goto write_position_error;
1248 if (bookmarks != NULL)
1249 for (i = 0; i < bookmarks->len && i < MAX_SAVED_BOOKMARKS; i++)
1250 if (fprintf (f, ";%zu", g_array_index (bookmarks, size_t, i)) < 0)
1251 goto write_position_error;
1253 if (fprintf (f, "\n") < 0)
1254 goto write_position_error;
1257 i = 1;
1258 while (fgets (buf, sizeof (buf), tmp_f) != NULL)
1260 if (buf[len] == ' ' && strncmp (buf, vfs_path_as_str (filename_vpath), len) == 0
1261 && strchr (&buf[len + 1], ' ') == NULL)
1262 continue;
1264 fprintf (f, "%s", buf);
1265 if (++i > filepos_max_saved_entries)
1266 break;
1269 write_position_error:
1270 fclose (tmp_f);
1271 open_source_error:
1272 g_free (tmp_fn);
1273 fclose (f);
1274 if (src_error)
1275 mc_util_restore_from_backup_if_possible (fn, TMP_SUFFIX);
1276 else
1277 mc_util_unlink_backup_if_possible (fn, TMP_SUFFIX);
1278 open_target_error:
1279 g_free (fn);
1280 early_error:
1281 if (bookmarks != NULL)
1282 g_array_free (bookmarks, TRUE);
1285 /* --------------------------------------------------------------------------------------------- */
1287 extern int
1288 ascii_alpha_to_cntrl (int ch)
1290 if ((ch >= ASCII_A && ch <= ASCII_Z) || (ch >= ASCII_a && ch <= ASCII_z))
1292 ch &= 0x1f;
1294 return ch;
1297 /* --------------------------------------------------------------------------------------------- */
1299 const char *
1300 Q_ (const char *s)
1302 const char *result, *sep;
1304 result = _(s);
1305 sep = strchr (result, '|');
1306 return (sep != NULL) ? sep + 1 : result;
1309 /* --------------------------------------------------------------------------------------------- */
1311 gboolean
1312 mc_util_make_backup_if_possible (const char *file_name, const char *backup_suffix)
1314 struct stat stat_buf;
1315 char *backup_path;
1316 gboolean ret;
1317 if (!exist_file (file_name))
1318 return FALSE;
1320 backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1322 if (backup_path == NULL)
1323 return FALSE;
1325 ret = mc_util_write_backup_content (file_name, backup_path);
1327 if (ret)
1329 /* Backup file will have same ownership with main file. */
1330 if (stat (file_name, &stat_buf) == 0)
1331 chmod (backup_path, stat_buf.st_mode);
1332 else
1333 chmod (backup_path, S_IRUSR | S_IWUSR);
1336 g_free (backup_path);
1338 return ret;
1341 /* --------------------------------------------------------------------------------------------- */
1343 gboolean
1344 mc_util_restore_from_backup_if_possible (const char *file_name, const char *backup_suffix)
1346 gboolean ret;
1347 char *backup_path;
1349 backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1350 if (backup_path == NULL)
1351 return FALSE;
1353 ret = mc_util_write_backup_content (backup_path, file_name);
1354 g_free (backup_path);
1356 return ret;
1359 /* --------------------------------------------------------------------------------------------- */
1361 gboolean
1362 mc_util_unlink_backup_if_possible (const char *file_name, const char *backup_suffix)
1364 char *backup_path;
1366 backup_path = g_strdup_printf ("%s%s", file_name, backup_suffix);
1367 if (backup_path == NULL)
1368 return FALSE;
1370 if (exist_file (backup_path))
1372 vfs_path_t *vpath;
1374 vpath = vfs_path_from_str (backup_path);
1375 mc_unlink (vpath);
1376 vfs_path_free (vpath);
1379 g_free (backup_path);
1380 return TRUE;
1383 /* --------------------------------------------------------------------------------------------- */
1385 * partly taken from dcigettext.c, returns "" for default locale
1386 * value should be freed by calling function g_free()
1389 char *
1390 guess_message_value (void)
1392 static const char *const var[] = {
1393 /* Setting of LC_ALL overwrites all other. */
1394 /* Do not use LANGUAGE for check user locale and drowing hints */
1395 "LC_ALL",
1396 /* Next comes the name of the desired category. */
1397 "LC_MESSAGES",
1398 /* Last possibility is the LANG environment variable. */
1399 "LANG",
1400 /* NULL exit loops */
1401 NULL
1404 unsigned i = 0;
1405 const char *locale = NULL;
1407 while (var[i] != NULL)
1409 locale = getenv (var[i]);
1410 if (locale != NULL && locale[0] != '\0')
1411 break;
1412 i++;
1415 if (locale == NULL)
1416 locale = "";
1418 return g_strdup (locale);
1421 /* --------------------------------------------------------------------------------------------- */
1423 * Propagate error in simple way.
1425 * @param dest error return location
1426 * @param code error code
1427 * @param format printf()-style format for error message
1428 * @param ... parameters for message format
1431 void
1432 mc_propagate_error (GError ** dest, int code, const char *format, ...)
1434 if (dest != NULL && *dest == NULL)
1436 GError *tmp_error;
1437 va_list args;
1439 va_start (args, format);
1440 tmp_error = g_error_new_valist (MC_ERROR, code, format, args);
1441 va_end (args);
1443 g_propagate_error (dest, tmp_error);
1447 /* --------------------------------------------------------------------------------------------- */
1449 * Replace existing error in simple way.
1451 * @param dest error return location
1452 * @param code error code
1453 * @param format printf()-style format for error message
1454 * @param ... parameters for message format
1457 void
1458 mc_replace_error (GError ** dest, int code, const char *format, ...)
1460 if (dest != NULL)
1462 GError *tmp_error;
1463 va_list args;
1465 va_start (args, format);
1466 tmp_error = g_error_new_valist (MC_ERROR, code, format, args);
1467 va_end (args);
1469 g_error_free (*dest);
1470 *dest = NULL;
1471 g_propagate_error (dest, tmp_error);
1475 /* --------------------------------------------------------------------------------------------- */
1478 * Returns if the given duration has elapsed since the given timestamp,
1479 * and if it has then updates the timestamp.
1481 * @param timestamp the last timestamp in microseconds, updated if the given time elapsed
1482 * @param deleay amount of time in microseconds
1484 * @return TRUE if clock skew detected, FALSE otherwise
1486 gboolean
1487 mc_time_elapsed (guint64 * timestamp, guint64 delay)
1489 guint64 now;
1491 now = mc_timer_elapsed (mc_global.timer);
1493 if (now >= *timestamp && now < *timestamp + delay)
1494 return FALSE;
1496 *timestamp = now;
1497 return TRUE;
1500 /* --------------------------------------------------------------------------------------------- */