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.
8 The file_date routine is mostly from GNU's fileutils package,
9 written by Richard Stallman and David MacKenzie.
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.
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.
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. */
26 * \brief Source: various utilities
39 #include <sys/types.h>
43 #include "lib/global.h"
44 #include "lib/mcconfig.h"
45 #include "lib/fileloc.h"
46 #include "lib/vfs/vfs.h"
47 #include "lib/strutil.h"
50 /*** global variables ****************************************************************************/
52 /*** file scope macro definitions ****************************************************************/
54 #define ismode(n,m) ((n & m) == m)
56 /* Number of attempts to create a temporary file */
61 #define TMP_SUFFIX ".tmp"
63 #define ASCII_A (0x40 + 1)
64 #define ASCII_Z (0x40 + 26)
65 #define ASCII_a (0x60 + 1)
66 #define ASCII_z (0x60 + 26)
68 /*** file scope type declarations ****************************************************************/
70 /*** file scope variables ************************************************************************/
72 /*** file scope functions ************************************************************************/
73 /* --------------------------------------------------------------------------------------------- */
76 is_7bit_printable (unsigned char c
)
78 return (c
> 31 && c
< 127);
81 /* --------------------------------------------------------------------------------------------- */
84 is_iso_printable (unsigned char c
)
86 return ((c
> 31 && c
< 127) || c
>= 160);
89 /* --------------------------------------------------------------------------------------------- */
92 is_8bit_printable (unsigned char c
)
94 /* "Full 8 bits output" doesn't work on xterm */
95 if (mc_global
.tty
.xterm_flag
)
96 return is_iso_printable (c
);
98 return (c
> 31 && c
!= 127 && c
!= 155);
101 /* --------------------------------------------------------------------------------------------- */
104 resolve_symlinks (const char *path
)
106 char *buf
, *buf2
, *q
, *r
, c
;
111 if (*path
!= PATH_SEP
)
113 r
= buf
= g_malloc (MC_MAXPATHLEN
);
114 buf2
= g_malloc (MC_MAXPATHLEN
);
120 q
= strchr (p
+ 1, PATH_SEP
);
123 q
= strchr (p
+ 1, 0);
129 if (mc_lstat (path
, &mybuf
) < 0)
136 if (!S_ISLNK (mybuf
.st_mode
))
140 len
= mc_readlink (path
, buf2
, MC_MAXPATHLEN
- 1);
149 if (*buf2
== PATH_SEP
)
154 canonicalize_pathname (buf
);
156 if (!*r
|| *(r
- 1) != PATH_SEP
)
167 strcpy (buf
, PATH_SEP_STR
);
168 else if (*(r
- 1) == PATH_SEP
&& r
!= buf
+ 1)
174 /* --------------------------------------------------------------------------------------------- */
177 mc_util_write_backup_content (const char *from_file_name
, const char *to_file_name
)
182 gboolean ret1
= TRUE
;
184 if (!g_file_get_contents (from_file_name
, &contents
, &length
, NULL
))
187 backup_fd
= fopen (to_file_name
, "w");
188 if (backup_fd
== NULL
)
194 if (fwrite ((const void *) contents
, 1, length
, backup_fd
) != length
)
198 ret2
= fflush (backup_fd
);
199 ret2
= fclose (backup_fd
);
205 /* --------------------------------------------------------------------------------------------- */
206 /*** public functions ****************************************************************************/
207 /* --------------------------------------------------------------------------------------------- */
215 /* "Display bits" is ignored, since the user controls the output
216 by setting the output codepage */
217 return is_8bit_printable (c
);
219 if (!mc_global
.eight_bit_clean
)
220 return is_7bit_printable (c
);
222 if (mc_global
.full_eight_bits
)
224 return is_8bit_printable (c
);
227 return is_iso_printable (c
);
228 #endif /* !HAVE_CHARSET */
231 /* --------------------------------------------------------------------------------------------- */
233 * Quote the filename for the purpose of inserting it into the command
234 * line. If quote_percent is 1, replace "%" with "%%" - the percent is
235 * processed by the mc command line.
238 name_quote (const char *s
, int quote_percent
)
242 d
= ret
= g_malloc (strlen (s
) * 2 + 2 + 1);
294 /* --------------------------------------------------------------------------------------------- */
297 fake_name_quote (const char *s
, int quote_percent
)
299 (void) quote_percent
;
303 /* --------------------------------------------------------------------------------------------- */
305 * path_trunc() is the same as str_trunc() but
306 * it deletes possible password from path for security
311 path_trunc (const char *path
, size_t trunc_len
)
313 char *secure_path
= strip_password (g_strdup (path
), 1);
315 const char *ret
= str_trunc (secure_path
, trunc_len
);
316 g_free (secure_path
);
321 /* --------------------------------------------------------------------------------------------- */
324 size_trunc (uintmax_t size
, gboolean use_si
)
326 static char x
[BUF_TINY
];
327 uintmax_t divisor
= 1;
328 const char *xtra
= "";
330 if (size
> 999999999UL)
332 divisor
= use_si
? 1000 : 1024;
333 xtra
= use_si
? "k" : "K";
335 if (size
/ divisor
> 999999999UL)
337 divisor
= use_si
? (1000 * 1000) : (1024 * 1024);
338 xtra
= use_si
? "m" : "M";
340 if (size
/ divisor
> 999999999UL)
342 divisor
= use_si
? (1000 * 1000 * 1000) : (1024 * 1024 * 1024);
343 xtra
= use_si
? "g" : "G";
347 g_snprintf (x
, sizeof (x
), "%.0f%s", 1.0 * size
/ divisor
, xtra
);
351 /* --------------------------------------------------------------------------------------------- */
354 size_trunc_sep (uintmax_t size
, gboolean use_si
)
361 p
= y
= size_trunc (size
, use_si
);
363 d
= x
+ sizeof (x
) - 1;
365 while (p
>= y
&& isalpha ((unsigned char) *p
))
367 for (count
= 0; p
>= y
; count
++)
382 /* --------------------------------------------------------------------------------------------- */
384 * Print file SIZE to BUFFER, but don't exceed LEN characters,
385 * not including trailing 0. BUFFER should be at least LEN+1 long.
386 * This function is called for every file on panels, so avoid
387 * floating point by any means.
389 * Units: size units (filesystem sizes are 1K blocks)
390 * 0=bytes, 1=Kbytes, 2=Mbytes, etc.
394 size_trunc_len (char *buffer
, unsigned int len
, uintmax_t size
, int units
, gboolean use_si
)
396 /* Avoid taking power for every file. */
398 static const uintmax_t power10
[] = {
399 /* we hope that size of uintmax_t is 4 bytes at least */
410 /* maximmum value of uintmax_t (in case of 4 bytes) is
413 #if SIZEOF_UINTMAX_T == 8
421 10000000000000000ULL,
422 100000000000000000ULL,
423 1000000000000000000ULL,
424 10000000000000000000ULL
425 /* maximmum value of uintmax_t (in case of 8 bytes) is
431 static const char *const suffix
[] = { "", "K", "M", "G", "T", "P", "E", "Z", "Y", NULL
};
432 static const char *const suffix_lc
[] = { "", "k", "m", "g", "t", "p", "e", "z", "y", NULL
};
438 #if SIZEOF_UINTMAX_T == 8
439 /* 20 decimal digits are required to represent 8 bytes */
443 /* 10 decimal digits are required to represent 4 bytes */
449 * recalculate from 1024 base to 1000 base if units>0
450 * We can't just multiply by 1024 - that might cause overflow
451 * if off_t type is too small
454 for (j
= 0; j
< units
; j
++)
456 size_remain
= ((size
% 125) * 1024) / 1000; /* size mod 125, recalculated */
457 size
= size
/ 125; /* 128/125 = 1024/1000 */
458 size
= size
* 128; /* This will convert size from multiple of 1024 to multiple of 1000 */
459 size
+= size_remain
; /* Re-add remainder lost by division/multiplication */
462 for (j
= units
; suffix
[j
] != NULL
; j
++)
468 /* Empty files will print "0" even with minimal width. */
469 g_snprintf (buffer
, len
+ 1, "0");
473 /* Use "~K" or just "K" if len is 1. Use "B" for bytes. */
474 g_snprintf (buffer
, len
+ 1, (len
> 1) ? "~%s" : "%s",
475 (j
> 1) ? (use_si
? suffix_lc
[j
- 1] : suffix
[j
- 1]) : "B");
479 if (size
< power10
[len
- (j
> 0 ? 1 : 0)])
481 g_snprintf (buffer
, len
+ 1, "%" PRIuMAX
"%s", size
, use_si
? suffix_lc
[j
] : suffix
[j
]);
485 /* Powers of 1000 or 1024, with rounding. */
487 size
= (size
+ 500) / 1000;
489 size
= (size
+ 512) >> 10;
493 /* --------------------------------------------------------------------------------------------- */
496 string_perm (mode_t mode_bits
)
498 static char mode
[11];
500 strcpy (mode
, "----------");
501 if (S_ISDIR (mode_bits
))
503 if (S_ISCHR (mode_bits
))
505 if (S_ISBLK (mode_bits
))
507 if (S_ISLNK (mode_bits
))
509 if (S_ISFIFO (mode_bits
))
511 if (S_ISNAM (mode_bits
))
513 if (S_ISSOCK (mode_bits
))
515 if (S_ISDOOR (mode_bits
))
517 if (ismode (mode_bits
, S_IXOTH
))
519 if (ismode (mode_bits
, S_IWOTH
))
521 if (ismode (mode_bits
, S_IROTH
))
523 if (ismode (mode_bits
, S_IXGRP
))
525 if (ismode (mode_bits
, S_IWGRP
))
527 if (ismode (mode_bits
, S_IRGRP
))
529 if (ismode (mode_bits
, S_IXUSR
))
531 if (ismode (mode_bits
, S_IWUSR
))
533 if (ismode (mode_bits
, S_IRUSR
))
536 if (ismode (mode_bits
, S_ISUID
))
537 mode
[3] = (mode
[3] == 'x') ? 's' : 'S';
540 if (ismode (mode_bits
, S_ISGID
))
541 mode
[6] = (mode
[6] == 'x') ? 's' : 'S';
544 if (ismode (mode_bits
, S_ISVTX
))
545 mode
[9] = (mode
[9] == 'x') ? 't' : 'T';
550 /* --------------------------------------------------------------------------------------------- */
552 * p: string which might contain an url with a password (this parameter is
553 * modified in place).
554 * has_prefix = 0: The first parameter is an url without a prefix
555 * (user[:pass]@]machine[:port][remote-dir). Delete
557 * has_prefix = 1: Search p for known url prefixes. If found delete
558 * the password from the url.
559 * Caveat: only the first url is found
563 strip_password (char *p
, int has_prefix
)
582 char *at
, *inner_colon
, *dir
;
586 for (i
= 0; i
< sizeof (prefixes
) / sizeof (prefixes
[0]); i
++)
592 q
= strstr (p
, prefixes
[i
].name
);
596 p
= q
+ prefixes
[i
].len
;
599 dir
= strchr (p
, PATH_SEP
);
603 /* search for any possible user */
604 at
= strrchr (p
, '@');
609 /* We have a username */
612 inner_colon
= memchr (p
, ':', at
- p
);
614 memmove (inner_colon
, at
, strlen (at
) + 1);
621 /* --------------------------------------------------------------------------------------------- */
624 strip_home_and_password (const char *dir
)
627 static char newdir
[MC_MAXPATHLEN
];
629 len
= strlen (mc_config_get_home_dir ());
630 if (mc_config_get_home_dir () != NULL
&& strncmp (dir
, mc_config_get_home_dir (), len
) == 0 &&
631 (dir
[len
] == PATH_SEP
|| dir
[len
] == '\0'))
634 g_strlcpy (&newdir
[1], &dir
[len
], sizeof (newdir
) - 1);
638 /* We do not strip homes in /#ftp tree, I do not like ~'s there
640 g_strlcpy (newdir
, dir
, sizeof (newdir
));
641 strip_password (newdir
, 1);
645 /* --------------------------------------------------------------------------------------------- */
648 extension (const char *filename
)
650 const char *d
= strrchr (filename
, '.');
651 return (d
!= NULL
) ? d
+ 1 : "";
654 /* --------------------------------------------------------------------------------------------- */
657 load_mc_home_file (const char *from
, const char *filename
, char **allocated_filename
)
659 char *hintfile_base
, *hintfile
;
663 hintfile_base
= g_build_filename (from
, filename
, (char *) NULL
);
664 lang
= guess_message_value ();
666 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
667 if (!g_file_get_contents (hintfile
, &data
, NULL
, NULL
))
669 /* Fall back to the two-letter language code */
670 if (lang
[0] != '\0' && lang
[1] != '\0')
673 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
674 if (!g_file_get_contents (hintfile
, &data
, NULL
, NULL
))
677 hintfile
= hintfile_base
;
678 g_file_get_contents (hintfile_base
, &data
, NULL
, NULL
);
684 if (hintfile
!= hintfile_base
)
685 g_free (hintfile_base
);
687 if (allocated_filename
!= NULL
)
688 *allocated_filename
= hintfile
;
695 /* --------------------------------------------------------------------------------------------- */
698 extract_line (const char *s
, const char *top
)
700 static char tmp_line
[BUF_MEDIUM
];
703 while (*s
&& *s
!= '\n' && (size_t) (t
- tmp_line
) < sizeof (tmp_line
) - 1 && s
< top
)
709 /* --------------------------------------------------------------------------------------------- */
711 * The basename routine
715 x_basename (const char *s
)
717 const char *url_delim
, *path_sep
;
719 url_delim
= g_strrstr (s
, VFS_PATH_URL_DELIMITER
);
720 path_sep
= strrchr (s
, PATH_SEP
);
722 if (url_delim
== NULL
723 || url_delim
< path_sep
- strlen (VFS_PATH_URL_DELIMITER
)
724 || url_delim
- s
+ strlen (VFS_PATH_URL_DELIMITER
) < strlen (s
))
726 /* avoid trailing PATH_SEP, if present */
727 if (s
[strlen (s
) - 1] == PATH_SEP
)
729 while (--path_sep
> s
&& *path_sep
!= PATH_SEP
);
730 return (path_sep
!= s
) ? path_sep
+ 1 : s
;
733 return (path_sep
!= NULL
) ? path_sep
+ 1 : s
;
736 while (--url_delim
> s
&& *url_delim
!= PATH_SEP
);
737 while (--url_delim
> s
&& *url_delim
!= PATH_SEP
);
739 return (url_delim
== s
) ? s
: url_delim
+ 1;
742 /* --------------------------------------------------------------------------------------------- */
745 unix_error_string (int error_num
)
747 static char buffer
[BUF_LARGE
];
748 gchar
*strerror_currentlocale
;
750 strerror_currentlocale
= g_locale_from_utf8 (g_strerror (error_num
), -1, NULL
, NULL
, NULL
);
751 g_snprintf (buffer
, sizeof (buffer
), "%s (%d)", strerror_currentlocale
, error_num
);
752 g_free (strerror_currentlocale
);
757 /* --------------------------------------------------------------------------------------------- */
760 skip_separators (const char *s
)
764 for (; *su
; str_cnext_char (&su
))
765 if (*su
!= ' ' && *su
!= '\t' && *su
!= ',')
771 /* --------------------------------------------------------------------------------------------- */
774 skip_numbers (const char *s
)
778 for (; *su
; str_cnext_char (&su
))
779 if (!str_isdigit (su
))
785 /* --------------------------------------------------------------------------------------------- */
787 * Remove all control sequences from the argument string. We define
788 * "control sequence", in a sort of pidgin BNF, as follows:
790 * control-seq = Esc non-'['
791 * | Esc '[' (0 or more digits or ';' or '?') (any other char)
793 * This scheme works for all the terminals described in my termcap /
794 * terminfo databases, except the Hewlett-Packard 70092 and some Wyse
795 * terminals. If I hear from a single person who uses such a terminal
796 * with MC, I'll be glad to add support for it. (Dugan)
797 * Non-printable characters are also removed.
801 strip_ctrl_codes (char *s
)
803 char *w
; /* Current position where the stripped data is written */
804 char *r
; /* Current position where the original data is read */
810 for (w
= s
, r
= s
; *r
;)
814 /* Skip the control sequence's arguments */ ;
815 /* '(' need to avoid strange 'B' letter in *Suse (if mc runs under root user) */
816 if (*(++r
) == '[' || *r
== '(')
818 /* strchr() matches trailing binary 0 */
819 while (*(++r
) && strchr ("0123456789;?", *r
));
824 * Skip xterm's OSC (Operating System Command)
825 * http://www.xfree86.org/current/ctlseqs.html
831 for (; *new_r
; ++new_r
)
841 if (*(new_r
+ 1) == '\\')
852 * Now we are at the last character of the sequence.
853 * Skip it unless it's binary 0.
860 n
= str_get_next_char (r
);
863 memmove (w
, r
, n
- r
);
872 /* --------------------------------------------------------------------------------------------- */
874 enum compression_type
875 get_compression_type (int fd
, const char *name
)
877 unsigned char magic
[16];
880 /* Read the magic signature */
881 if (mc_read (fd
, (char *) magic
, 4) != 4)
882 return COMPRESSION_NONE
;
884 /* GZIP_MAGIC and OLD_GZIP_MAGIC */
885 if (magic
[0] == 037 && (magic
[1] == 0213 || magic
[1] == 0236))
887 return COMPRESSION_GZIP
;
891 if (magic
[0] == 0120 && magic
[1] == 0113 && magic
[2] == 003 && magic
[3] == 004)
893 /* Read compression type */
894 mc_lseek (fd
, 8, SEEK_SET
);
895 if (mc_read (fd
, (char *) magic
, 2) != 2)
896 return COMPRESSION_NONE
;
898 /* Gzip can handle only deflated (8) or stored (0) files */
899 if ((magic
[0] != 8 && magic
[0] != 0) || magic
[1] != 0)
900 return COMPRESSION_NONE
;
902 /* Compatible with gzip */
903 return COMPRESSION_GZIP
;
906 /* PACK_MAGIC and LZH_MAGIC and compress magic */
907 if (magic
[0] == 037 && (magic
[1] == 036 || magic
[1] == 0240 || magic
[1] == 0235))
909 /* Compatible with gzip */
910 return COMPRESSION_GZIP
;
913 /* BZIP and BZIP2 files */
914 if ((magic
[0] == 'B') && (magic
[1] == 'Z') && (magic
[3] >= '1') && (magic
[3] <= '9'))
919 return COMPRESSION_BZIP
;
921 return COMPRESSION_BZIP2
;
925 /* Support for LZMA (only utils format with magic in header).
926 * This is the default format of LZMA utils 4.32.1 and later. */
928 if (mc_read (fd
, (char *) magic
+ 4, 2) != 2)
929 return COMPRESSION_NONE
;
931 /* LZMA utils format */
934 && magic
[2] == 'Z' && magic
[3] == 'M' && magic
[4] == 'A' && magic
[5] == 0x00)
935 return COMPRESSION_LZMA
;
937 /* XZ compression magic */
940 && magic
[2] == 0x7A && magic
[3] == 0x58 && magic
[4] == 0x5A && magic
[5] == 0x00)
941 return COMPRESSION_XZ
;
943 str_len
= strlen (name
);
944 /* HACK: we must belive to extention of LZMA file :) ... */
945 if ((str_len
> 5 && strcmp (&name
[str_len
- 5], ".lzma") == 0) ||
946 (str_len
> 4 && strcmp (&name
[str_len
- 4], ".tlz") == 0))
947 return COMPRESSION_LZMA
;
949 return COMPRESSION_NONE
;
952 /* --------------------------------------------------------------------------------------------- */
955 decompress_extension (int type
)
959 case COMPRESSION_GZIP
:
960 return "/ugz" VFS_PATH_URL_DELIMITER
;
961 case COMPRESSION_BZIP
:
962 return "/ubz" VFS_PATH_URL_DELIMITER
;
963 case COMPRESSION_BZIP2
:
964 return "/ubz2" VFS_PATH_URL_DELIMITER
;
965 case COMPRESSION_LZMA
:
966 return "/ulzma" VFS_PATH_URL_DELIMITER
;
968 return "/uxz" VFS_PATH_URL_DELIMITER
;
970 /* Should never reach this place */
971 fprintf (stderr
, "Fatal: decompress_extension called with an unknown argument\n");
975 /* --------------------------------------------------------------------------------------------- */
978 wipe_password (char *passwd
)
989 /* --------------------------------------------------------------------------------------------- */
991 * Convert "\E" -> esc character and ^x to control-x key and ^^ to ^ key
992 * @returns a newly allocated string
996 convert_controls (const char *p
)
998 char *valcopy
= g_strdup (p
);
1001 /* Parse the escape special character */
1002 for (q
= valcopy
; *p
;)
1007 if ((*p
== 'e') || (*p
== 'E'))
1022 char c
= (*p
| 0x20);
1023 if (c
>= 'a' && c
<= 'z')
1040 /* --------------------------------------------------------------------------------------------- */
1042 * Finds out a relative path from first to second, i.e. goes as many ..
1043 * as needed up in first and then goes down using second
1047 diff_two_paths (const char *first
, const char *second
)
1049 char *p
, *q
, *r
, *s
, *buf
= NULL
;
1050 int i
, j
, prevlen
= -1, currlen
;
1051 char *my_first
= NULL
, *my_second
= NULL
;
1053 my_first
= resolve_symlinks (first
);
1054 if (my_first
== NULL
)
1056 my_second
= resolve_symlinks (second
);
1057 if (my_second
== NULL
)
1062 for (j
= 0; j
< 2; j
++)
1068 r
= strchr (p
, PATH_SEP
);
1069 s
= strchr (q
, PATH_SEP
);
1089 for (i
= 0; (p
= strchr (p
+ 1, PATH_SEP
)) != NULL
; i
++);
1090 currlen
= (i
+ 1) * 3 + strlen (q
) + 1;
1093 if (currlen
< prevlen
)
1102 p
= buf
= g_malloc (currlen
);
1104 for (; i
>= 0; i
--, p
+= 3)
1113 /* --------------------------------------------------------------------------------------------- */
1115 * If filename is NULL, then we just append PATH_SEP to the dir
1119 concat_dir_and_file (const char *dir
, const char *file
)
1121 int i
= strlen (dir
);
1123 if (dir
[i
- 1] == PATH_SEP
)
1124 return g_strconcat (dir
, file
, (char *) NULL
);
1126 return g_strconcat (dir
, PATH_SEP_STR
, file
, (char *) NULL
);
1129 /* --------------------------------------------------------------------------------------------- */
1131 * Append text to GList, remove all entries with the same text
1135 list_append_unique (GList
* list
, char *text
)
1140 * Go to the last position and traverse the list backwards
1141 * starting from the second last entry to make sure that we
1142 * are not removing the current link.
1144 list
= g_list_append (list
, text
);
1145 list
= g_list_last (list
);
1146 lc_link
= g_list_previous (list
);
1148 while (lc_link
!= NULL
)
1152 newlink
= g_list_previous (lc_link
);
1153 if (strcmp ((char *) lc_link
->data
, text
) == 0)
1157 g_free (lc_link
->data
);
1158 tmp
= g_list_remove_link (list
, lc_link
);
1159 g_list_free_1 (lc_link
);
1167 /* --------------------------------------------------------------------------------------------- */
1168 /* Following code heavily borrows from libiberty, mkstemps.c */
1171 * pname (output) - pointer to the name of the temp file (needs g_free).
1172 * NULL if the function fails.
1173 * prefix - part of the filename before the random part.
1174 * Prepend $TMPDIR or /tmp if there are no path separators.
1175 * suffix - if not NULL, part of the filename after the random part.
1178 * handle of the open file or -1 if couldn't open any.
1182 mc_mkstemps (char **pname
, const char *prefix
, const char *suffix
)
1184 static const char letters
[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1185 static unsigned long value
;
1192 if (strchr (prefix
, PATH_SEP
) == NULL
)
1194 /* Add prefix first to find the position of XXXXXX */
1195 tmpbase
= concat_dir_and_file (mc_tmpdir (), prefix
);
1199 tmpbase
= g_strdup (prefix
);
1202 tmpname
= g_strconcat (tmpbase
, "XXXXXX", suffix
, (char *) NULL
);
1204 XXXXXX
= &tmpname
[strlen (tmpbase
)];
1207 /* Get some more or less random data. */
1208 gettimeofday (&tv
, NULL
);
1209 value
+= (tv
.tv_usec
<< 16) ^ tv
.tv_sec
^ getpid ();
1211 for (count
= 0; count
< TMP_MAX
; ++count
)
1213 unsigned long v
= value
;
1216 /* Fill in the random bits. */
1217 XXXXXX
[0] = letters
[v
% 62];
1219 XXXXXX
[1] = letters
[v
% 62];
1221 XXXXXX
[2] = letters
[v
% 62];
1223 XXXXXX
[3] = letters
[v
% 62];
1225 XXXXXX
[4] = letters
[v
% 62];
1227 XXXXXX
[5] = letters
[v
% 62];
1229 fd
= open (tmpname
, O_RDWR
| O_CREAT
| O_TRUNC
| O_EXCL
, S_IRUSR
| S_IWUSR
);
1232 /* Successfully created. */
1236 /* This is a random value. It is only necessary that the next
1237 TMP_MAX values generated by adding 7777 to VALUE are different
1238 with (module 2^32). */
1242 /* Unsuccessful. Free the filename. */
1249 /* --------------------------------------------------------------------------------------------- */
1251 * Read and restore position for the given filename.
1252 * If there is no stored data, return line 1 and col 0.
1256 load_file_position (const char *filename
, long *line
, long *column
, off_t
* offset
,
1257 GArray
** bookmarks
)
1261 char buf
[MC_MAXPATHLEN
+ 100];
1262 const size_t len
= strlen (filename
);
1269 /* open file with positions */
1270 fn
= g_build_filename (mc_config_get_cache_path (), MC_FILEPOS_FILE
, NULL
);
1271 f
= fopen (fn
, "r");
1276 /* prepare array for serialized bookmarks */
1277 *bookmarks
= g_array_sized_new (FALSE
, FALSE
, sizeof (size_t), MAX_SAVED_BOOKMARKS
);
1279 while (fgets (buf
, sizeof (buf
), f
) != NULL
)
1284 /* check if the filename matches the beginning of string */
1285 if (strncmp (buf
, filename
, len
) != 0)
1288 /* followed by single space */
1289 if (buf
[len
] != ' ')
1292 /* and string without spaces */
1294 if (strchr (p
, ' ') != NULL
)
1297 pos_tokens
= g_strsplit (p
, ";", 3 + MAX_SAVED_BOOKMARKS
);
1298 if (pos_tokens
[0] == NULL
)
1306 *line
= strtol (pos_tokens
[0], NULL
, 10);
1307 if (pos_tokens
[1] == NULL
)
1314 *column
= strtol (pos_tokens
[1], NULL
, 10);
1315 if (pos_tokens
[2] == NULL
)
1321 *offset
= strtoll (pos_tokens
[2], NULL
, 10);
1323 for (i
= 0; i
< MAX_SAVED_BOOKMARKS
&& pos_tokens
[3 + i
] != NULL
; i
++)
1327 val
= strtoul (pos_tokens
[3 + i
], NULL
, 10);
1328 g_array_append_val (*bookmarks
, val
);
1334 g_strfreev (pos_tokens
);
1340 /* --------------------------------------------------------------------------------------------- */
1342 * Save position for the given file
1346 save_file_position (const char *filename
, long line
, long column
, off_t offset
, GArray
* bookmarks
)
1348 static size_t filepos_max_saved_entries
= 0;
1351 char buf
[MC_MAXPATHLEN
+ 100];
1353 const size_t len
= strlen (filename
);
1354 gboolean src_error
= FALSE
;
1356 if (filepos_max_saved_entries
== 0)
1357 filepos_max_saved_entries
= mc_config_get_int (mc_main_config
, CONFIG_APP_SECTION
,
1358 "filepos_max_saved_entries", 1024);
1360 fn
= g_build_filename (mc_config_get_cache_path (), MC_FILEPOS_FILE
, NULL
);
1364 mc_util_make_backup_if_possible (fn
, TMP_SUFFIX
);
1367 f
= fopen (fn
, "w");
1369 goto open_target_error
;
1371 tmp_fn
= g_strdup_printf ("%s" TMP_SUFFIX
, fn
);
1372 tmp_f
= fopen (tmp_fn
, "r");
1376 goto open_source_error
;
1379 /* put the new record */
1380 if (line
!= 1 || column
!= 0 || bookmarks
!= NULL
)
1382 if (fprintf (f
, "%s %ld;%ld;%" PRIuMAX
, filename
, line
, column
, (uintmax_t) offset
) < 0)
1383 goto write_position_error
;
1384 if (bookmarks
!= NULL
)
1385 for (i
= 0; i
< bookmarks
->len
&& i
< MAX_SAVED_BOOKMARKS
; i
++)
1386 if (fprintf (f
, ";%zu", g_array_index (bookmarks
, size_t, i
)) < 0)
1387 goto write_position_error
;
1389 if (fprintf (f
, "\n") < 0)
1390 goto write_position_error
;
1394 while (fgets (buf
, sizeof (buf
), tmp_f
) != NULL
)
1396 if (buf
[len
] == ' ' && strncmp (buf
, filename
, len
) == 0
1397 && strchr (&buf
[len
+ 1], ' ') == NULL
)
1400 fprintf (f
, "%s", buf
);
1401 if (++i
> filepos_max_saved_entries
)
1405 write_position_error
:
1411 mc_util_restore_from_backup_if_possible (fn
, TMP_SUFFIX
);
1413 mc_util_unlink_backup_if_possible (fn
, TMP_SUFFIX
);
1417 if (bookmarks
!= NULL
)
1418 g_array_free (bookmarks
, TRUE
);
1421 /* --------------------------------------------------------------------------------------------- */
1424 ascii_alpha_to_cntrl (int ch
)
1426 if ((ch
>= ASCII_A
&& ch
<= ASCII_Z
) || (ch
>= ASCII_a
&& ch
<= ASCII_z
))
1433 /* --------------------------------------------------------------------------------------------- */
1438 const char *result
, *sep
;
1441 sep
= strchr (result
, '|');
1442 return (sep
!= NULL
) ? sep
+ 1 : result
;
1445 /* --------------------------------------------------------------------------------------------- */
1448 mc_util_make_backup_if_possible (const char *file_name
, const char *backup_suffix
)
1450 struct stat stat_buf
;
1453 if (!exist_file (file_name
))
1456 backup_path
= g_strdup_printf ("%s%s", file_name
, backup_suffix
);
1458 if (backup_path
== NULL
)
1461 ret
= mc_util_write_backup_content (file_name
, backup_path
);
1465 /* Backup file will have same ownership with main file. */
1466 if (stat (file_name
, &stat_buf
) == 0)
1467 chmod (backup_path
, stat_buf
.st_mode
);
1469 chmod (backup_path
, S_IRUSR
| S_IWUSR
);
1472 g_free (backup_path
);
1477 /* --------------------------------------------------------------------------------------------- */
1480 mc_util_restore_from_backup_if_possible (const char *file_name
, const char *backup_suffix
)
1485 backup_path
= g_strdup_printf ("%s%s", file_name
, backup_suffix
);
1486 if (backup_path
== NULL
)
1489 ret
= mc_util_write_backup_content (backup_path
, file_name
);
1490 g_free (backup_path
);
1495 /* --------------------------------------------------------------------------------------------- */
1498 mc_util_unlink_backup_if_possible (const char *file_name
, const char *backup_suffix
)
1502 backup_path
= g_strdup_printf ("%s%s", file_name
, backup_suffix
);
1503 if (backup_path
== NULL
)
1506 if (exist_file (backup_path
))
1507 mc_unlink (backup_path
);
1509 g_free (backup_path
);
1513 /* --------------------------------------------------------------------------------------------- */
1515 * partly taken from dcigettext.c, returns "" for default locale
1516 * value should be freed by calling function g_free()
1520 guess_message_value (void)
1522 static const char *const var
[] = {
1523 /* Setting of LC_ALL overwrites all other. */
1524 /* Do not use LANGUAGE for check user locale and drowing hints */
1526 /* Next comes the name of the desired category. */
1528 /* Last possibility is the LANG environment variable. */
1530 /* NULL exit loops */
1535 const char *locale
= NULL
;
1537 while (var
[i
] != NULL
)
1539 locale
= getenv (var
[i
]);
1540 if (locale
!= NULL
&& locale
[0] != '\0')
1548 return g_strdup (locale
);
1551 /* --------------------------------------------------------------------------------------------- */