4 Copyright (C) 1994, 1995, 1996, 1998, 1999, 2000, 2001, 2002, 2003,
5 2004, 2005, 2007, 2009, 2011
6 The Free Software Foundation, Inc.
9 Miguel de Icaza, 1994, 1995, 1996
10 Janne Kukonlehto, 1994, 1995, 1996
11 Dugan Porter, 1994, 1995, 1996
12 Jakub Jelinek, 1994, 1995, 1996
13 Mauricio Plaza, 1994, 1995, 1996
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/>.
32 * \brief Source: various utilities
45 #include <sys/types.h>
49 #include "lib/global.h"
50 #include "lib/mcconfig.h"
51 #include "lib/fileloc.h"
52 #include "lib/vfs/vfs.h"
53 #include "lib/strutil.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 */
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 /* --------------------------------------------------------------------------------------------- */
82 is_7bit_printable (unsigned char c
)
84 return (c
> 31 && c
< 127);
87 /* --------------------------------------------------------------------------------------------- */
90 is_iso_printable (unsigned char c
)
92 return ((c
> 31 && c
< 127) || c
>= 160);
95 /* --------------------------------------------------------------------------------------------- */
98 is_8bit_printable (unsigned char c
)
100 /* "Full 8 bits output" doesn't work on xterm */
101 if (mc_global
.tty
.xterm_flag
)
102 return is_iso_printable (c
);
104 return (c
> 31 && c
!= 127 && c
!= 155);
107 /* --------------------------------------------------------------------------------------------- */
110 resolve_symlinks (const vfs_path_t
* vpath
)
113 char *buf
, *buf2
, *q
, *r
, c
;
119 p
= p2
= vfs_path_to_str (vpath
);
120 r
= buf
= g_malloc (MC_MAXPATHLEN
);
121 buf2
= g_malloc (MC_MAXPATHLEN
);
127 q
= strchr (p
+ 1, PATH_SEP
);
130 q
= strchr (p
+ 1, 0);
136 if (mc_lstat (vpath
, &mybuf
) < 0)
142 if (!S_ISLNK (mybuf
.st_mode
))
148 len
= mc_readlink (vpath
, buf2
, MC_MAXPATHLEN
- 1);
156 if (*buf2
== PATH_SEP
)
161 canonicalize_pathname (buf
);
163 if (!*r
|| *(r
- 1) != PATH_SEP
)
164 /* FIXME: this condition is always true because r points to the EOL */
175 strcpy (buf
, PATH_SEP_STR
);
176 else if (*(r
- 1) == PATH_SEP
&& r
!= buf
+ 1)
185 /* --------------------------------------------------------------------------------------------- */
188 mc_util_write_backup_content (const char *from_file_name
, const char *to_file_name
)
193 gboolean ret1
= TRUE
;
195 if (!g_file_get_contents (from_file_name
, &contents
, &length
, NULL
))
198 backup_fd
= fopen (to_file_name
, "w");
199 if (backup_fd
== NULL
)
205 if (fwrite ((const void *) contents
, 1, length
, backup_fd
) != length
)
209 ret2
= fflush (backup_fd
);
210 ret2
= fclose (backup_fd
);
216 /* --------------------------------------------------------------------------------------------- */
217 /*** public functions ****************************************************************************/
218 /* --------------------------------------------------------------------------------------------- */
226 /* "Display bits" is ignored, since the user controls the output
227 by setting the output codepage */
228 return is_8bit_printable (c
);
230 if (!mc_global
.eight_bit_clean
)
231 return is_7bit_printable (c
);
233 if (mc_global
.full_eight_bits
)
235 return is_8bit_printable (c
);
238 return is_iso_printable (c
);
239 #endif /* !HAVE_CHARSET */
242 /* --------------------------------------------------------------------------------------------- */
244 * Quote the filename for the purpose of inserting it into the command
245 * line. If quote_percent is 1, replace "%" with "%%" - the percent is
246 * processed by the mc command line.
249 name_quote (const char *s
, int quote_percent
)
253 d
= ret
= g_malloc (strlen (s
) * 2 + 2 + 1);
305 /* --------------------------------------------------------------------------------------------- */
308 fake_name_quote (const char *s
, int quote_percent
)
310 (void) quote_percent
;
314 /* --------------------------------------------------------------------------------------------- */
316 * path_trunc() is the same as str_trunc() but
317 * it deletes possible password from path for security
322 path_trunc (const char *path
, size_t trunc_len
)
328 vpath
= vfs_path_from_str (path
);
329 secure_path
= vfs_path_to_str_flags (vpath
, 0, VPF_STRIP_PASSWORD
);
330 vfs_path_free (vpath
);
332 ret
= str_trunc (secure_path
, trunc_len
);
333 g_free (secure_path
);
338 /* --------------------------------------------------------------------------------------------- */
341 size_trunc (uintmax_t size
, gboolean use_si
)
343 static char x
[BUF_TINY
];
344 uintmax_t divisor
= 1;
345 const char *xtra
= "";
347 if (size
> 999999999UL)
349 divisor
= use_si
? 1000 : 1024;
350 xtra
= use_si
? "k" : "K";
352 if (size
/ divisor
> 999999999UL)
354 divisor
= use_si
? (1000 * 1000) : (1024 * 1024);
355 xtra
= use_si
? "m" : "M";
357 if (size
/ divisor
> 999999999UL)
359 divisor
= use_si
? (1000 * 1000 * 1000) : (1024 * 1024 * 1024);
360 xtra
= use_si
? "g" : "G";
364 g_snprintf (x
, sizeof (x
), "%.0f%s", 1.0 * size
/ divisor
, xtra
);
368 /* --------------------------------------------------------------------------------------------- */
371 size_trunc_sep (uintmax_t size
, gboolean use_si
)
378 p
= y
= size_trunc (size
, use_si
);
380 d
= x
+ sizeof (x
) - 1;
382 while (p
>= y
&& isalpha ((unsigned char) *p
))
384 for (count
= 0; p
>= y
; count
++)
399 /* --------------------------------------------------------------------------------------------- */
401 * Print file SIZE to BUFFER, but don't exceed LEN characters,
402 * not including trailing 0. BUFFER should be at least LEN+1 long.
403 * This function is called for every file on panels, so avoid
404 * floating point by any means.
406 * Units: size units (filesystem sizes are 1K blocks)
407 * 0=bytes, 1=Kbytes, 2=Mbytes, etc.
411 size_trunc_len (char *buffer
, unsigned int len
, uintmax_t size
, int units
, gboolean use_si
)
413 /* Avoid taking power for every file. */
415 static const uintmax_t power10
[] = {
416 /* we hope that size of uintmax_t is 4 bytes at least */
427 /* maximmum value of uintmax_t (in case of 4 bytes) is
430 #if SIZEOF_UINTMAX_T == 8
438 10000000000000000ULL,
439 100000000000000000ULL,
440 1000000000000000000ULL,
441 10000000000000000000ULL
442 /* maximmum value of uintmax_t (in case of 8 bytes) is
448 static const char *const suffix
[] = { "", "K", "M", "G", "T", "P", "E", "Z", "Y", NULL
};
449 static const char *const suffix_lc
[] = { "", "k", "m", "g", "t", "p", "e", "z", "y", NULL
};
454 #if SIZEOF_UINTMAX_T == 8
455 /* 20 decimal digits are required to represent 8 bytes */
459 /* 10 decimal digits are required to represent 4 bytes */
465 * recalculate from 1024 base to 1000 base if units>0
466 * We can't just multiply by 1024 - that might cause overflow
467 * if off_t type is too small
470 for (j
= 0; j
< units
; j
++)
472 uintmax_t size_remain
;
474 size_remain
= ((size
% 125) * 1024) / 1000; /* size mod 125, recalculated */
475 size
= size
/ 125; /* 128/125 = 1024/1000 */
476 size
= size
* 128; /* This will convert size from multiple of 1024 to multiple of 1000 */
477 size
+= size_remain
; /* Re-add remainder lost by division/multiplication */
480 for (j
= units
; suffix
[j
] != NULL
; j
++)
486 /* Empty files will print "0" even with minimal width. */
487 g_snprintf (buffer
, len
+ 1, "0");
491 /* Use "~K" or just "K" if len is 1. Use "B" for bytes. */
492 g_snprintf (buffer
, len
+ 1, (len
> 1) ? "~%s" : "%s",
493 (j
> 1) ? (use_si
? suffix_lc
[j
- 1] : suffix
[j
- 1]) : "B");
497 if (size
< power10
[len
- (j
> 0 ? 1 : 0)])
499 g_snprintf (buffer
, len
+ 1, "%" PRIuMAX
"%s", size
, use_si
? suffix_lc
[j
] : suffix
[j
]);
503 /* Powers of 1000 or 1024, with rounding. */
505 size
= (size
+ 500) / 1000;
507 size
= (size
+ 512) >> 10;
511 /* --------------------------------------------------------------------------------------------- */
514 string_perm (mode_t mode_bits
)
516 static char mode
[11];
518 strcpy (mode
, "----------");
519 if (S_ISDIR (mode_bits
))
521 if (S_ISCHR (mode_bits
))
523 if (S_ISBLK (mode_bits
))
525 if (S_ISLNK (mode_bits
))
527 if (S_ISFIFO (mode_bits
))
529 if (S_ISNAM (mode_bits
))
531 if (S_ISSOCK (mode_bits
))
533 if (S_ISDOOR (mode_bits
))
535 if (ismode (mode_bits
, S_IXOTH
))
537 if (ismode (mode_bits
, S_IWOTH
))
539 if (ismode (mode_bits
, S_IROTH
))
541 if (ismode (mode_bits
, S_IXGRP
))
543 if (ismode (mode_bits
, S_IWGRP
))
545 if (ismode (mode_bits
, S_IRGRP
))
547 if (ismode (mode_bits
, S_IXUSR
))
549 if (ismode (mode_bits
, S_IWUSR
))
551 if (ismode (mode_bits
, S_IRUSR
))
554 if (ismode (mode_bits
, S_ISUID
))
555 mode
[3] = (mode
[3] == 'x') ? 's' : 'S';
558 if (ismode (mode_bits
, S_ISGID
))
559 mode
[6] = (mode
[6] == 'x') ? 's' : 'S';
562 if (ismode (mode_bits
, S_ISVTX
))
563 mode
[9] = (mode
[9] == 'x') ? 't' : 'T';
568 /* --------------------------------------------------------------------------------------------- */
571 extension (const char *filename
)
573 const char *d
= strrchr (filename
, '.');
574 return (d
!= NULL
) ? d
+ 1 : "";
577 /* --------------------------------------------------------------------------------------------- */
580 load_mc_home_file (const char *from
, const char *filename
, char **allocated_filename
)
582 char *hintfile_base
, *hintfile
;
586 hintfile_base
= g_build_filename (from
, filename
, (char *) NULL
);
587 lang
= guess_message_value ();
589 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
590 if (!g_file_get_contents (hintfile
, &data
, NULL
, NULL
))
592 /* Fall back to the two-letter language code */
593 if (lang
[0] != '\0' && lang
[1] != '\0')
596 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
597 if (!g_file_get_contents (hintfile
, &data
, NULL
, NULL
))
600 hintfile
= hintfile_base
;
601 g_file_get_contents (hintfile_base
, &data
, NULL
, NULL
);
607 if (hintfile
!= hintfile_base
)
608 g_free (hintfile_base
);
610 if (allocated_filename
!= NULL
)
611 *allocated_filename
= hintfile
;
618 /* --------------------------------------------------------------------------------------------- */
621 extract_line (const char *s
, const char *top
)
623 static char tmp_line
[BUF_MEDIUM
];
626 while (*s
&& *s
!= '\n' && (size_t) (t
- tmp_line
) < sizeof (tmp_line
) - 1 && s
< top
)
632 /* --------------------------------------------------------------------------------------------- */
634 * The basename routine
638 x_basename (const char *s
)
640 const char *url_delim
, *path_sep
;
642 url_delim
= g_strrstr (s
, VFS_PATH_URL_DELIMITER
);
643 path_sep
= strrchr (s
, PATH_SEP
);
645 if (url_delim
== NULL
646 || url_delim
< path_sep
- strlen (VFS_PATH_URL_DELIMITER
)
647 || url_delim
- s
+ strlen (VFS_PATH_URL_DELIMITER
) < strlen (s
))
649 /* avoid trailing PATH_SEP, if present */
650 if (s
[strlen (s
) - 1] == PATH_SEP
)
652 while (--path_sep
> s
&& *path_sep
!= PATH_SEP
);
653 return (path_sep
!= s
) ? path_sep
+ 1 : s
;
656 return (path_sep
!= NULL
) ? path_sep
+ 1 : s
;
659 while (--url_delim
> s
&& *url_delim
!= PATH_SEP
);
660 while (--url_delim
> s
&& *url_delim
!= PATH_SEP
);
662 return (url_delim
== s
) ? s
: url_delim
+ 1;
665 /* --------------------------------------------------------------------------------------------- */
668 unix_error_string (int error_num
)
670 static char buffer
[BUF_LARGE
];
671 gchar
*strerror_currentlocale
;
673 strerror_currentlocale
= g_locale_from_utf8 (g_strerror (error_num
), -1, NULL
, NULL
, NULL
);
674 g_snprintf (buffer
, sizeof (buffer
), "%s (%d)", strerror_currentlocale
, error_num
);
675 g_free (strerror_currentlocale
);
680 /* --------------------------------------------------------------------------------------------- */
683 skip_separators (const char *s
)
687 for (; *su
; str_cnext_char (&su
))
688 if (*su
!= ' ' && *su
!= '\t' && *su
!= ',')
694 /* --------------------------------------------------------------------------------------------- */
697 skip_numbers (const char *s
)
701 for (; *su
; str_cnext_char (&su
))
702 if (!str_isdigit (su
))
708 /* --------------------------------------------------------------------------------------------- */
710 * Remove all control sequences from the argument string. We define
711 * "control sequence", in a sort of pidgin BNF, as follows:
713 * control-seq = Esc non-'['
714 * | Esc '[' (0 or more digits or ';' or '?') (any other char)
716 * This scheme works for all the terminals described in my termcap /
717 * terminfo databases, except the Hewlett-Packard 70092 and some Wyse
718 * terminals. If I hear from a single person who uses such a terminal
719 * with MC, I'll be glad to add support for it. (Dugan)
720 * Non-printable characters are also removed.
724 strip_ctrl_codes (char *s
)
726 char *w
; /* Current position where the stripped data is written */
727 char *r
; /* Current position where the original data is read */
733 for (w
= s
, r
= s
; *r
;)
737 /* Skip the control sequence's arguments */ ;
738 /* '(' need to avoid strange 'B' letter in *Suse (if mc runs under root user) */
739 if (*(++r
) == '[' || *r
== '(')
741 /* strchr() matches trailing binary 0 */
742 while (*(++r
) && strchr ("0123456789;?", *r
));
747 * Skip xterm's OSC (Operating System Command)
748 * http://www.xfree86.org/current/ctlseqs.html
754 for (; *new_r
; ++new_r
)
764 if (*(new_r
+ 1) == '\\')
775 * Now we are at the last character of the sequence.
776 * Skip it unless it's binary 0.
783 n
= str_get_next_char (r
);
786 memmove (w
, r
, n
- r
);
795 /* --------------------------------------------------------------------------------------------- */
797 enum compression_type
798 get_compression_type (int fd
, const char *name
)
800 unsigned char magic
[16];
803 /* Read the magic signature */
804 if (mc_read (fd
, (char *) magic
, 4) != 4)
805 return COMPRESSION_NONE
;
807 /* GZIP_MAGIC and OLD_GZIP_MAGIC */
808 if (magic
[0] == 037 && (magic
[1] == 0213 || magic
[1] == 0236))
810 return COMPRESSION_GZIP
;
814 if (magic
[0] == 0120 && magic
[1] == 0113 && magic
[2] == 003 && magic
[3] == 004)
816 /* Read compression type */
817 mc_lseek (fd
, 8, SEEK_SET
);
818 if (mc_read (fd
, (char *) magic
, 2) != 2)
819 return COMPRESSION_NONE
;
821 /* Gzip can handle only deflated (8) or stored (0) files */
822 if ((magic
[0] != 8 && magic
[0] != 0) || magic
[1] != 0)
823 return COMPRESSION_NONE
;
825 /* Compatible with gzip */
826 return COMPRESSION_GZIP
;
829 /* PACK_MAGIC and LZH_MAGIC and compress magic */
830 if (magic
[0] == 037 && (magic
[1] == 036 || magic
[1] == 0240 || magic
[1] == 0235))
832 /* Compatible with gzip */
833 return COMPRESSION_GZIP
;
836 /* BZIP and BZIP2 files */
837 if ((magic
[0] == 'B') && (magic
[1] == 'Z') && (magic
[3] >= '1') && (magic
[3] <= '9'))
842 return COMPRESSION_BZIP
;
844 return COMPRESSION_BZIP2
;
848 /* Support for LZMA (only utils format with magic in header).
849 * This is the default format of LZMA utils 4.32.1 and later. */
851 if (mc_read (fd
, (char *) magic
+ 4, 2) != 2)
852 return COMPRESSION_NONE
;
854 /* LZMA utils format */
857 && magic
[2] == 'Z' && magic
[3] == 'M' && magic
[4] == 'A' && magic
[5] == 0x00)
858 return COMPRESSION_LZMA
;
860 /* XZ compression magic */
863 && magic
[2] == 0x7A && magic
[3] == 0x58 && magic
[4] == 0x5A && magic
[5] == 0x00)
864 return COMPRESSION_XZ
;
866 str_len
= strlen (name
);
867 /* HACK: we must belive to extention of LZMA file :) ... */
868 if ((str_len
> 5 && strcmp (&name
[str_len
- 5], ".lzma") == 0) ||
869 (str_len
> 4 && strcmp (&name
[str_len
- 4], ".tlz") == 0))
870 return COMPRESSION_LZMA
;
872 return COMPRESSION_NONE
;
875 /* --------------------------------------------------------------------------------------------- */
878 decompress_extension (int type
)
882 case COMPRESSION_GZIP
:
883 return "/ugz" VFS_PATH_URL_DELIMITER
;
884 case COMPRESSION_BZIP
:
885 return "/ubz" VFS_PATH_URL_DELIMITER
;
886 case COMPRESSION_BZIP2
:
887 return "/ubz2" VFS_PATH_URL_DELIMITER
;
888 case COMPRESSION_LZMA
:
889 return "/ulzma" VFS_PATH_URL_DELIMITER
;
891 return "/uxz" VFS_PATH_URL_DELIMITER
;
893 /* Should never reach this place */
894 fprintf (stderr
, "Fatal: decompress_extension called with an unknown argument\n");
898 /* --------------------------------------------------------------------------------------------- */
901 wipe_password (char *passwd
)
912 /* --------------------------------------------------------------------------------------------- */
914 * Convert "\E" -> esc character and ^x to control-x key and ^^ to ^ key
916 * @param p pointer to string
918 * @return newly allocated string
922 convert_controls (const char *p
)
924 char *valcopy
= g_strdup (p
);
927 /* Parse the escape special character */
928 for (q
= valcopy
; *p
;)
933 if ((*p
== 'e') || (*p
== 'E'))
948 char c
= (*p
| 0x20);
949 if (c
>= 'a' && c
<= 'z')
966 /* --------------------------------------------------------------------------------------------- */
968 * Finds out a relative path from first to second, i.e. goes as many ..
969 * as needed up in first and then goes down using second
973 diff_two_paths (const vfs_path_t
* vpath1
, const vfs_path_t
* vpath2
)
975 char *p
, *q
, *r
, *s
, *buf
= NULL
;
976 int i
, j
, prevlen
= -1, currlen
;
977 char *my_first
= NULL
, *my_second
= NULL
;
979 my_first
= resolve_symlinks (vpath1
);
980 if (my_first
== NULL
)
983 my_second
= resolve_symlinks (vpath2
);
984 if (my_second
== NULL
)
987 for (j
= 0; j
< 2; j
++)
993 r
= strchr (p
, PATH_SEP
);
994 s
= strchr (q
, PATH_SEP
);
995 if (r
== NULL
|| s
== NULL
)
999 if (strcmp (p
, q
) != 0)
1013 for (i
= 0; (p
= strchr (p
+ 1, PATH_SEP
)) != NULL
; i
++)
1015 currlen
= (i
+ 1) * 3 + strlen (q
) + 1;
1018 if (currlen
< prevlen
)
1023 p
= buf
= g_malloc (currlen
);
1025 for (; i
>= 0; i
--, p
+= 3)
1036 /* --------------------------------------------------------------------------------------------- */
1038 * Append text to GList, remove all entries with the same text
1042 list_append_unique (GList
* list
, char *text
)
1047 * Go to the last position and traverse the list backwards
1048 * starting from the second last entry to make sure that we
1049 * are not removing the current link.
1051 list
= g_list_append (list
, text
);
1052 list
= g_list_last (list
);
1053 lc_link
= g_list_previous (list
);
1055 while (lc_link
!= NULL
)
1059 newlink
= g_list_previous (lc_link
);
1060 if (strcmp ((char *) lc_link
->data
, text
) == 0)
1064 g_free (lc_link
->data
);
1065 tmp
= g_list_remove_link (list
, lc_link
);
1066 g_list_free_1 (lc_link
);
1074 /* --------------------------------------------------------------------------------------------- */
1076 * Read and restore position for the given filename.
1077 * If there is no stored data, return line 1 and col 0.
1081 load_file_position (const vfs_path_t
* filename_vpath
, long *line
, long *column
, off_t
* offset
,
1082 GArray
** bookmarks
)
1086 char buf
[MC_MAXPATHLEN
+ 100];
1087 const size_t len
= vfs_path_len (filename_vpath
);
1095 /* open file with positions */
1096 fn
= mc_config_get_full_path (MC_FILEPOS_FILE
);
1097 f
= fopen (fn
, "r");
1102 /* prepare array for serialized bookmarks */
1103 *bookmarks
= g_array_sized_new (FALSE
, FALSE
, sizeof (size_t), MAX_SAVED_BOOKMARKS
);
1104 filename
= vfs_path_to_str (filename_vpath
);
1106 while (fgets (buf
, sizeof (buf
), f
) != NULL
)
1111 /* check if the filename matches the beginning of string */
1112 if (strncmp (buf
, filename
, len
) != 0)
1115 /* followed by single space */
1116 if (buf
[len
] != ' ')
1119 /* and string without spaces */
1121 if (strchr (p
, ' ') != NULL
)
1124 pos_tokens
= g_strsplit (p
, ";", 3 + MAX_SAVED_BOOKMARKS
);
1125 if (pos_tokens
[0] == NULL
)
1133 *line
= strtol (pos_tokens
[0], NULL
, 10);
1134 if (pos_tokens
[1] == NULL
)
1141 *column
= strtol (pos_tokens
[1], NULL
, 10);
1142 if (pos_tokens
[2] == NULL
)
1148 *offset
= (off_t
) g_ascii_strtoll (pos_tokens
[2], NULL
, 10);
1150 for (i
= 0; i
< MAX_SAVED_BOOKMARKS
&& pos_tokens
[3 + i
] != NULL
; i
++)
1154 val
= strtoul (pos_tokens
[3 + i
], NULL
, 10);
1155 g_array_append_val (*bookmarks
, val
);
1161 g_strfreev (pos_tokens
);
1168 /* --------------------------------------------------------------------------------------------- */
1170 * Save position for the given file
1174 save_file_position (const vfs_path_t
* filename_vpath
, long line
, long column
, off_t offset
,
1177 static size_t filepos_max_saved_entries
= 0;
1180 char buf
[MC_MAXPATHLEN
+ 100];
1182 const size_t len
= vfs_path_len (filename_vpath
);
1183 gboolean src_error
= FALSE
;
1186 if (filepos_max_saved_entries
== 0)
1187 filepos_max_saved_entries
= mc_config_get_int (mc_main_config
, CONFIG_APP_SECTION
,
1188 "filepos_max_saved_entries", 1024);
1190 fn
= mc_config_get_full_path (MC_FILEPOS_FILE
);
1194 mc_util_make_backup_if_possible (fn
, TMP_SUFFIX
);
1197 f
= fopen (fn
, "w");
1199 goto open_target_error
;
1201 tmp_fn
= g_strdup_printf ("%s" TMP_SUFFIX
, fn
);
1202 tmp_f
= fopen (tmp_fn
, "r");
1206 goto open_source_error
;
1209 filename
= vfs_path_to_str (filename_vpath
);
1210 /* put the new record */
1211 if (line
!= 1 || column
!= 0 || bookmarks
!= NULL
)
1213 if (fprintf (f
, "%s %ld;%ld;%" PRIuMAX
, filename
, line
, column
, (uintmax_t) offset
) < 0)
1214 goto write_position_error
;
1215 if (bookmarks
!= NULL
)
1216 for (i
= 0; i
< bookmarks
->len
&& i
< MAX_SAVED_BOOKMARKS
; i
++)
1217 if (fprintf (f
, ";%zu", g_array_index (bookmarks
, size_t, i
)) < 0)
1218 goto write_position_error
;
1220 if (fprintf (f
, "\n") < 0)
1221 goto write_position_error
;
1225 while (fgets (buf
, sizeof (buf
), tmp_f
) != NULL
)
1227 if (buf
[len
] == ' ' && strncmp (buf
, filename
, len
) == 0
1228 && strchr (&buf
[len
+ 1], ' ') == NULL
)
1231 fprintf (f
, "%s", buf
);
1232 if (++i
> filepos_max_saved_entries
)
1236 write_position_error
:
1243 mc_util_restore_from_backup_if_possible (fn
, TMP_SUFFIX
);
1245 mc_util_unlink_backup_if_possible (fn
, TMP_SUFFIX
);
1249 if (bookmarks
!= NULL
)
1250 g_array_free (bookmarks
, TRUE
);
1253 /* --------------------------------------------------------------------------------------------- */
1256 ascii_alpha_to_cntrl (int ch
)
1258 if ((ch
>= ASCII_A
&& ch
<= ASCII_Z
) || (ch
>= ASCII_a
&& ch
<= ASCII_z
))
1265 /* --------------------------------------------------------------------------------------------- */
1270 const char *result
, *sep
;
1273 sep
= strchr (result
, '|');
1274 return (sep
!= NULL
) ? sep
+ 1 : result
;
1277 /* --------------------------------------------------------------------------------------------- */
1280 mc_util_make_backup_if_possible (const char *file_name
, const char *backup_suffix
)
1282 struct stat stat_buf
;
1285 if (!exist_file (file_name
))
1288 backup_path
= g_strdup_printf ("%s%s", file_name
, backup_suffix
);
1290 if (backup_path
== NULL
)
1293 ret
= mc_util_write_backup_content (file_name
, backup_path
);
1297 /* Backup file will have same ownership with main file. */
1298 if (stat (file_name
, &stat_buf
) == 0)
1299 chmod (backup_path
, stat_buf
.st_mode
);
1301 chmod (backup_path
, S_IRUSR
| S_IWUSR
);
1304 g_free (backup_path
);
1309 /* --------------------------------------------------------------------------------------------- */
1312 mc_util_restore_from_backup_if_possible (const char *file_name
, const char *backup_suffix
)
1317 backup_path
= g_strdup_printf ("%s%s", file_name
, backup_suffix
);
1318 if (backup_path
== NULL
)
1321 ret
= mc_util_write_backup_content (backup_path
, file_name
);
1322 g_free (backup_path
);
1327 /* --------------------------------------------------------------------------------------------- */
1330 mc_util_unlink_backup_if_possible (const char *file_name
, const char *backup_suffix
)
1334 backup_path
= g_strdup_printf ("%s%s", file_name
, backup_suffix
);
1335 if (backup_path
== NULL
)
1338 if (exist_file (backup_path
))
1342 vpath
= vfs_path_from_str (backup_path
);
1344 vfs_path_free (vpath
);
1347 g_free (backup_path
);
1351 /* --------------------------------------------------------------------------------------------- */
1353 * partly taken from dcigettext.c, returns "" for default locale
1354 * value should be freed by calling function g_free()
1358 guess_message_value (void)
1360 static const char *const var
[] = {
1361 /* Setting of LC_ALL overwrites all other. */
1362 /* Do not use LANGUAGE for check user locale and drowing hints */
1364 /* Next comes the name of the desired category. */
1366 /* Last possibility is the LANG environment variable. */
1368 /* NULL exit loops */
1373 const char *locale
= NULL
;
1375 while (var
[i
] != NULL
)
1377 locale
= getenv (var
[i
]);
1378 if (locale
!= NULL
&& locale
[0] != '\0')
1386 return g_strdup (locale
);
1389 /* --------------------------------------------------------------------------------------------- */