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>
45 #include "../src/tty/win.h" /* xterm_flag */
47 #include "../src/search/search.h"
49 #include "main.h" /* mc_home */
50 #include "cmd.h" /* guess_message_value */
51 #include "mountlist.h"
54 #include "fileopctx.h"
55 #include "file.h" /* copy_file_file() */
62 /*In order to use everywhere the same setup
63 for the locale we use defines */
64 #define FMTYEAR _("%b %e %Y")
65 #define FMTTIME _("%b %e %H:%M")
68 int easy_patterns
= 1;
70 extern void str_replace(char *s
, char from
, char to
)
72 for (; *s
!= '\0'; s
++) {
79 is_7bit_printable (unsigned char c
)
81 return (c
> 31 && c
< 127);
85 is_iso_printable (unsigned char c
)
87 return ((c
> 31 && c
< 127) || c
>= 160);
91 is_8bit_printable (unsigned char c
)
93 /* "Full 8 bits output" doesn't work on xterm */
95 return is_iso_printable (c
);
97 return (c
> 31 && c
!= 127 && c
!= 155);
106 /* "Display bits" is ignored, since the user controls the output
107 by setting the output codepage */
108 return is_8bit_printable (c
);
110 if (!eight_bit_clean
)
111 return is_7bit_printable (c
);
113 if (full_eight_bits
) {
114 return is_8bit_printable (c
);
116 return is_iso_printable (c
);
117 #endif /* !HAVE_CHARSET */
120 /* Calculates the message dimensions (lines and columns) */
122 msglen (const char *text
, int *lines
, int *columns
)
124 int nlines
= 1; /* even the empty string takes one line */
128 for (; *text
!= '\0'; text
++) {
134 if (colindex
> ncolumns
)
144 * Copy from s to d, and trim the beginning if necessary, and prepend
145 * "..." in this case. The destination string can have at most len
146 * bytes, not counting trailing 0.
149 trim (const char *s
, char *d
, int len
)
156 source_len
= strlen (s
);
157 if (source_len
> len
) {
158 /* Cannot fit the whole line */
160 /* We only have room for the dots */
161 memset (d
, '.', len
);
165 /* Begin with ... and add the rest of the source string */
167 strcpy (d
+ 3, s
+ 3 + source_len
- len
);
170 /* We can copy the whole line */
176 * Quote the filename for the purpose of inserting it into the command
177 * line. If quote_percent is 1, replace "%" with "%%" - the percent is
178 * processed by the mc command line.
181 name_quote (const char *s
, int quote_percent
)
185 d
= ret
= g_malloc (strlen (s
) * 2 + 2 + 1);
191 for (; *s
; s
++, d
++) {
235 fake_name_quote (const char *s
, int quote_percent
)
237 (void) quote_percent
;
242 * Remove the middle part of the string to fit given length.
243 * Use "~" to show where the string was truncated.
244 * Return static buffer, no need to free() it.
247 name_trunc (const char *txt
, size_t trunc_len
)
249 return str_trunc (txt
, trunc_len
);
253 * path_trunc() is the same as name_trunc() above but
254 * it deletes possible password from path for security
258 path_trunc (const char *path
, size_t trunc_len
) {
259 char *secure_path
= strip_password (g_strdup (path
), 1);
261 const char *ret
= str_trunc (secure_path
, trunc_len
);
262 g_free (secure_path
);
268 size_trunc (double size
)
270 static char x
[BUF_TINY
];
271 long int divisor
= 1;
272 const char *xtra
= "";
274 if (size
> 999999999L){
275 divisor
= kilobyte_si
?1000:1024;
276 xtra
= kilobyte_si
?"k":"K";
277 if (size
/divisor
> 999999999L){
278 divisor
= kilobyte_si
?(1000*1000):(1024*1024);
279 xtra
= kilobyte_si
?"m":"M";
282 g_snprintf (x
, sizeof (x
), "%.0f%s", (size
/divisor
), xtra
);
287 size_trunc_sep (double size
)
294 p
= y
= size_trunc (size
);
296 d
= x
+ sizeof (x
) - 1;
298 while (p
>= y
&& isalpha ((unsigned char) *p
))
300 for (count
= 0; p
>= y
; count
++){
314 * Print file SIZE to BUFFER, but don't exceed LEN characters,
315 * not including trailing 0. BUFFER should be at least LEN+1 long.
316 * This function is called for every file on panels, so avoid
317 * floating point by any means.
319 * Units: size units (filesystem sizes are 1K blocks)
320 * 0=bytes, 1=Kbytes, 2=Mbytes, etc.
323 size_trunc_len (char *buffer
, unsigned int len
, off_t size
, int units
)
325 /* Avoid taking power for every file. */
326 static const off_t power10
[] =
327 {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000,
329 static const char * const suffix
[] =
330 {"", "K", "M", "G", "T", "P", "E", "Z", "Y", NULL
};
331 static const char * const suffix_lc
[] =
332 {"", "k", "m", "g", "t", "p", "e", "z", "y", NULL
};
340 * recalculate from 1024 base to 1000 base if units>0
341 * We can't just multiply by 1024 - that might cause overflow
342 * if off_t type is too small
344 if (units
&& kilobyte_si
) {
345 for (j
= 0; j
< units
; j
++) {
346 size_remain
=((size
% 125)*1024)/1000; /* size mod 125, recalculated */
347 size
= size
/ 125; /* 128/125 = 1024/1000 */
348 size
= size
* 128; /* This will convert size from multiple of 1024 to multiple of 1000 */
349 size
+= size_remain
; /* Re-add remainder lost by division/multiplication */
353 for (j
= units
; suffix
[j
] != NULL
; j
++) {
356 /* Empty files will print "0" even with minimal width. */
357 g_snprintf (buffer
, len
+ 1, "0");
361 /* Use "~K" or just "K" if len is 1. Use "B" for bytes. */
362 g_snprintf (buffer
, len
+ 1, (len
> 1) ? "~%s" : "%s",
363 (j
> 1) ? (kilobyte_si
? suffix_lc
[j
- 1] : suffix
[j
- 1]) : "B");
367 if (size
< power10
[len
- (j
> 0)]) {
368 g_snprintf (buffer
, len
+ 1, "%lu%s", (unsigned long) size
, kilobyte_si
? suffix_lc
[j
] : suffix
[j
]);
372 /* Powers of 1000 or 1024, with rounding. */
374 size
= (size
+ 500) / 1000;
376 size
= (size
+ 512) >> 10;
384 if ((S_IXUSR
& mode
) || (S_IXGRP
& mode
) || (S_IXOTH
& mode
))
389 #define ismode(n,m) ((n & m) == m)
392 string_perm (mode_t mode_bits
)
394 static char mode
[11];
396 strcpy (mode
, "----------");
397 if (S_ISDIR (mode_bits
))
399 if (S_ISCHR (mode_bits
))
401 if (S_ISBLK (mode_bits
))
403 if (S_ISLNK (mode_bits
))
405 if (S_ISFIFO (mode_bits
))
407 if (S_ISNAM (mode_bits
))
409 if (S_ISSOCK (mode_bits
))
411 if (S_ISDOOR (mode_bits
))
413 if (ismode (mode_bits
, S_IXOTH
))
415 if (ismode (mode_bits
, S_IWOTH
))
417 if (ismode (mode_bits
, S_IROTH
))
419 if (ismode (mode_bits
, S_IXGRP
))
421 if (ismode (mode_bits
, S_IWGRP
))
423 if (ismode (mode_bits
, S_IRGRP
))
425 if (ismode (mode_bits
, S_IXUSR
))
427 if (ismode (mode_bits
, S_IWUSR
))
429 if (ismode (mode_bits
, S_IRUSR
))
432 if (ismode (mode_bits
, S_ISUID
))
433 mode
[3] = (mode
[3] == 'x') ? 's' : 'S';
436 if (ismode (mode_bits
, S_ISGID
))
437 mode
[6] = (mode
[6] == 'x') ? 's' : 'S';
440 if (ismode (mode_bits
, S_ISVTX
))
441 mode
[9] = (mode
[9] == 'x') ? 't' : 'T';
446 /* p: string which might contain an url with a password (this parameter is
448 has_prefix = 0: The first parameter is an url without a prefix
449 (user[:pass]@]machine[:port][remote-dir). Delete
451 has_prefix = 1: Search p for known url prefixes. If found delete
452 the password from the url.
453 Caveat: only the first url is found
456 strip_password (char *p
, int has_prefix
)
458 static const struct {
461 } prefixes
[] = { {"/#ftp:", 6},
471 char *at
, *inner_colon
, *dir
;
475 for (i
= 0; i
< sizeof (prefixes
)/sizeof (prefixes
[0]); i
++) {
479 if((q
= strstr (p
, prefixes
[i
].name
)) == 0)
482 p
= q
+ prefixes
[i
].len
;
485 if ((dir
= strchr (p
, PATH_SEP
)) != NULL
)
488 /* search for any possible user */
489 at
= strrchr (p
, '@');
494 /* We have a username */
496 inner_colon
= memchr (p
, ':', at
- p
);
498 memmove (inner_colon
, at
, strlen(at
) + 1);
506 strip_home_and_password(const char *dir
)
509 static char newdir
[MC_MAXPATHLEN
];
511 if (home_dir
&& !strncmp (dir
, home_dir
, len
= strlen (home_dir
)) &&
512 (dir
[len
] == PATH_SEP
|| dir
[len
] == '\0')){
514 g_strlcpy (&newdir
[1], &dir
[len
], sizeof(newdir
) - 1);
518 /* We do not strip homes in /#ftp tree, I do not like ~'s there
520 g_strlcpy (newdir
, dir
, sizeof(newdir
));
521 strip_password (newdir
, 1);
526 extension (const char *filename
)
528 const char *d
= strrchr (filename
, '.');
529 return (d
!= NULL
) ? d
+ 1 : "";
533 exist_file (const char *name
)
535 return access (name
, R_OK
) == 0;
539 check_for_default (const char *default_file
, const char *file
)
541 if (!exist_file (file
)) {
546 if (!exist_file (default_file
))
549 ctx
= file_op_context_new (OP_COPY
);
550 file_op_context_create_ui (ctx
, 0);
551 copy_file_file (ctx
, default_file
, file
, 1, &count
, &bytes
, 1);
552 file_op_context_destroy (ctx
);
561 load_file (const char *filename
)
568 if ((data_file
= fopen (filename
, "r")) == NULL
){
571 if (fstat (fileno (data_file
), &s
) != 0){
575 data
= g_malloc (s
.st_size
+1);
576 read_size
= fread (data
, 1, s
.st_size
, data_file
);
577 data
[read_size
] = 0;
589 load_mc_home_file (const char *filename
, char **allocated_filename
)
591 char *hintfile_base
, *hintfile
;
595 hintfile_base
= concat_dir_and_file (mc_home
, filename
);
596 lang
= guess_message_value ();
598 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
599 data
= load_file (hintfile
);
603 g_free (hintfile_base
);
604 hintfile_base
= concat_dir_and_file (mc_home_alt
, filename
);
606 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
607 data
= load_file (hintfile
);
610 /* Fall back to the two-letter language code */
611 if (lang
[0] && lang
[1])
613 hintfile
= g_strconcat (hintfile_base
, ".", lang
, (char *) NULL
);
614 data
= load_file (hintfile
);
618 hintfile
= hintfile_base
;
619 data
= load_file (hintfile_base
);
626 if (hintfile
!= hintfile_base
)
627 g_free (hintfile_base
);
629 if (allocated_filename
)
630 *allocated_filename
= hintfile
;
637 /* Check strftime() results. Some systems (i.e. Solaris) have different
638 short-month-name sizes for different locales */
640 i18n_checktimelength (void)
643 time_t testtime
= time (NULL
);
644 struct tm
* lt
= localtime(&testtime
);
647 /* huh, localtime() doesnt seem to work ... falling back to "(invalid)" */
648 length
= str_term_width1 (_(INVALID_TIME_TEXT
));
650 char buf
[MB_LEN_MAX
* MAX_I18NTIMELENGTH
+ 1];
653 strftime (buf
, sizeof(buf
) - 1, FMTTIME
, lt
);
654 a
= str_term_width1 (buf
);
655 strftime (buf
, sizeof(buf
) - 1, FMTYEAR
, lt
);
656 b
= str_term_width1 (buf
);
659 length
= max ((size_t)str_term_width1 (_(INVALID_TIME_TEXT
)), length
);
662 /* Don't handle big differences. Use standard value (email bug, please) */
663 if (length
> MAX_I18NTIMELENGTH
|| length
< MIN_I18NTIMELENGTH
)
664 length
= STD_I18NTIMELENGTH
;
670 file_date (time_t when
)
672 static char timebuf
[MB_LEN_MAX
* MAX_I18NTIMELENGTH
+ 1];
673 time_t current_time
= time ((time_t) 0);
676 if (current_time
> when
+ 6L * 30L * 24L * 60L * 60L /* Old. */
677 || current_time
< when
- 60L * 60L) /* In the future. */
678 /* The file is fairly old or in the future.
679 POSIX says the cutoff is 6 months old;
680 approximate this by 6*30 days.
681 Allow a 1 hour slop factor for what is considered "the future",
682 to allow for NFS server/client clock disagreement.
683 Show the year instead of the time of day. */
689 FMT_LOCALTIME(timebuf
, sizeof (timebuf
), fmt
, when
);
695 extract_line (const char *s
, const char *top
)
697 static char tmp_line
[BUF_MEDIUM
];
700 while (*s
&& *s
!= '\n' && (size_t) (t
- tmp_line
) < sizeof (tmp_line
)-1 && s
< top
)
706 /* The basename routine */
708 x_basename (const char *s
)
711 return ((where
= strrchr (s
, PATH_SEP
))) ? where
+ 1 : s
;
716 unix_error_string (int error_num
)
718 static char buffer
[BUF_LARGE
];
719 #if GLIB_MAJOR_VERSION >= 2
720 gchar
*strerror_currentlocale
;
722 strerror_currentlocale
= g_locale_from_utf8(g_strerror (error_num
), -1, NULL
, NULL
, NULL
);
723 g_snprintf (buffer
, sizeof (buffer
), "%s (%d)",
724 strerror_currentlocale
, error_num
);
725 g_free(strerror_currentlocale
);
727 g_snprintf (buffer
, sizeof (buffer
), "%s (%d)",
728 g_strerror (error_num
), error_num
);
734 skip_separators (const char *s
)
738 for (;*su
; str_cnext_char (&su
))
739 if (*su
!= ' ' && *su
!= '\t' && *su
!= ',') break;
745 skip_numbers (const char *s
)
749 for (;*su
; str_cnext_char (&su
))
750 if (!str_isdigit (su
)) break;
755 /* Remove all control sequences from the argument string. We define
756 * "control sequence", in a sort of pidgin BNF, as follows:
758 * control-seq = Esc non-'['
759 * | Esc '[' (0 or more digits or ';' or '?') (any other char)
761 * This scheme works for all the terminals described in my termcap /
762 * terminfo databases, except the Hewlett-Packard 70092 and some Wyse
763 * terminals. If I hear from a single person who uses such a terminal
764 * with MC, I'll be glad to add support for it. (Dugan)
765 * Non-printable characters are also removed.
769 strip_ctrl_codes (char *s
)
771 char *w
; /* Current position where the stripped data is written */
772 char *r
; /* Current position where the original data is read */
778 for (w
= s
, r
= s
; *r
; ) {
779 if (*r
== ESC_CHAR
) {
780 /* Skip the control sequence's arguments */ ;
782 /* strchr() matches trailing binary 0 */
783 while (*(++r
) && strchr ("0123456789;?", *r
));
787 * Skip xterm's OSC (Operating System Command)
788 * http://www.xfree86.org/current/ctlseqs.html
794 for (; *new_r
; ++new_r
)
804 if (*(new_r
+ 1) == '\\')
815 * Now we are at the last character of the sequence.
816 * Skip it unless it's binary 0.
823 n
= str_get_next_char (r
);
824 if (str_isprint (r
)) {
825 memmove (w
, r
, n
- r
);
837 get_current_wd (char *buffer
, int size
)
842 p
= g_get_current_dir ();
850 memcpy (buffer
, p
, len
);
855 #endif /* !USE_VFS */
857 enum compression_type
858 get_compression_type (int fd
, const char * name
)
860 unsigned char magic
[16];
862 /* Read the magic signature */
863 if (mc_read (fd
, (char *) magic
, 4) != 4)
864 return COMPRESSION_NONE
;
866 /* GZIP_MAGIC and OLD_GZIP_MAGIC */
867 if (magic
[0] == 037 && (magic
[1] == 0213 || magic
[1] == 0236)) {
868 return COMPRESSION_GZIP
;
872 if (magic
[0] == 0120 && magic
[1] == 0113 && magic
[2] == 003
873 && magic
[3] == 004) {
874 /* Read compression type */
875 mc_lseek (fd
, 8, SEEK_SET
);
876 if (mc_read (fd
, (char *) magic
, 2) != 2)
877 return COMPRESSION_NONE
;
879 /* Gzip can handle only deflated (8) or stored (0) files */
880 if ((magic
[0] != 8 && magic
[0] != 0) || magic
[1] != 0)
881 return COMPRESSION_NONE
;
883 /* Compatible with gzip */
884 return COMPRESSION_GZIP
;
887 /* PACK_MAGIC and LZH_MAGIC and compress magic */
889 && (magic
[1] == 036 || magic
[1] == 0240 || magic
[1] == 0235)) {
890 /* Compatible with gzip */
891 return COMPRESSION_GZIP
;
894 /* BZIP and BZIP2 files */
895 if ((magic
[0] == 'B') && (magic
[1] == 'Z') &&
896 (magic
[3] >= '1') && (magic
[3] <= '9')) {
899 return COMPRESSION_BZIP
;
901 return COMPRESSION_BZIP2
;
905 /* Support for LZMA (only utils format with magic in header).
906 * This is the default format of LZMA utils 4.32.1 and later. */
908 if (mc_read(fd
, (char *) magic
+4, 1) == 1)
910 /* LZMA utils format */
919 return COMPRESSION_LZMA
;
922 /* XZ compression magic */
923 if (mc_read(fd
, (char *) magic
+5, 1) == 1)
933 return COMPRESSION_XZ
;
937 /* HACK: we must belive to extention of LZMA file :) ...*/
938 if (strlen(name
) > 5 && strcmp(&name
[strlen(name
)-5],".lzma") == 0)
939 return COMPRESSION_LZMA
;
941 return COMPRESSION_NONE
;
945 decompress_extension (int type
)
948 case COMPRESSION_GZIP
: return "#ugz";
949 case COMPRESSION_BZIP
: return "#ubz";
950 case COMPRESSION_BZIP2
: return "#ubz2";
951 case COMPRESSION_LZMA
: return "#ulzma";
952 case COMPRESSION_XZ
: return "#uxz";
954 /* Should never reach this place */
955 fprintf (stderr
, "Fatal: decompress_extension called with an unknown argument\n");
961 add_hook (Hook
**hook_list
, void (*hook_fn
)(void *), void *data
)
963 Hook
*new_hook
= g_new (Hook
, 1);
965 new_hook
->hook_fn
= hook_fn
;
966 new_hook
->next
= *hook_list
;
967 new_hook
->hook_data
= data
;
969 *hook_list
= new_hook
;
973 execute_hooks (Hook
*hook_list
)
978 /* We copy the hook list first so tahat we let the hook
979 * function call delete_hook
983 add_hook (&new_hook
, hook_list
->hook_fn
, hook_list
->hook_data
);
984 hook_list
= hook_list
->next
;
989 (*new_hook
->hook_fn
)(new_hook
->hook_data
);
990 new_hook
= new_hook
->next
;
993 for (hook_list
= p
; hook_list
;){
995 hook_list
= hook_list
->next
;
1001 delete_hook (Hook
**hook_list
, void (*hook_fn
)(void *))
1003 Hook
*current
, *new_list
, *next
;
1007 for (current
= *hook_list
; current
; current
= next
){
1008 next
= current
->next
;
1009 if (current
->hook_fn
== hook_fn
)
1012 add_hook (&new_list
, current
->hook_fn
, current
->hook_data
);
1014 *hook_list
= new_list
;
1018 hook_present (Hook
*hook_list
, void (*hook_fn
)(void *))
1022 for (p
= hook_list
; p
; p
= p
->next
)
1023 if (p
->hook_fn
== hook_fn
)
1029 wipe_password (char *passwd
)
1040 /* Convert "\E" -> esc character and ^x to control-x key and ^^ to ^ key */
1041 /* Returns a newly allocated string */
1043 convert_controls (const char *p
)
1045 char *valcopy
= g_strdup (p
);
1048 /* Parse the escape special character */
1049 for (q
= valcopy
; *p
;){
1052 if ((*p
== 'e') || (*p
== 'E')){
1062 char c
= (*p
| 0x20);
1063 if (c
>= 'a' && c
<= 'z') {
1078 resolve_symlinks (const char *path
)
1080 char *buf
, *buf2
, *q
, *r
, c
;
1085 if (*path
!= PATH_SEP
)
1087 r
= buf
= g_malloc (MC_MAXPATHLEN
);
1088 buf2
= g_malloc (MC_MAXPATHLEN
);
1093 q
= strchr (p
+ 1, PATH_SEP
);
1095 q
= strchr (p
+ 1, 0);
1101 if (mc_lstat (path
, &mybuf
) < 0) {
1107 if (!S_ISLNK (mybuf
.st_mode
))
1110 len
= mc_readlink (path
, buf2
, MC_MAXPATHLEN
- 1);
1118 if (*buf2
== PATH_SEP
)
1123 canonicalize_pathname (buf
);
1124 r
= strchr (buf
, 0);
1125 if (!*r
|| *(r
- 1) != PATH_SEP
) {
1135 strcpy (buf
, PATH_SEP_STR
);
1136 else if (*(r
- 1) == PATH_SEP
&& r
!= buf
+ 1)
1142 /* Finds out a relative path from first to second, i.e. goes as many ..
1143 * as needed up in first and then goes down using second */
1145 diff_two_paths (const char *first
, const char *second
)
1147 char *p
, *q
, *r
, *s
, *buf
= NULL
;
1148 int i
, j
, prevlen
= -1, currlen
;
1149 char *my_first
= NULL
, *my_second
= NULL
;
1151 my_first
= resolve_symlinks (first
);
1152 if (my_first
== NULL
)
1154 my_second
= resolve_symlinks (second
);
1155 if (my_second
== NULL
) {
1159 for (j
= 0; j
< 2; j
++) {
1163 r
= strchr (p
, PATH_SEP
);
1164 s
= strchr (q
, PATH_SEP
);
1168 if (strcmp (p
, q
)) {
1169 *r
= PATH_SEP
; *s
= PATH_SEP
;
1172 *r
= PATH_SEP
; *s
= PATH_SEP
;
1178 for (i
= 0; (p
= strchr (p
+ 1, PATH_SEP
)) != NULL
; i
++);
1179 currlen
= (i
+ 1) * 3 + strlen (q
) + 1;
1181 if (currlen
< prevlen
)
1189 p
= buf
= g_malloc (currlen
);
1191 for (; i
>= 0; i
--, p
+= 3)
1200 /* If filename is NULL, then we just append PATH_SEP to the dir */
1202 concat_dir_and_file (const char *dir
, const char *file
)
1204 int i
= strlen (dir
);
1206 if (dir
[i
-1] == PATH_SEP
)
1207 return g_strconcat (dir
, file
, (char *) NULL
);
1209 return g_strconcat (dir
, PATH_SEP_STR
, file
, (char *) NULL
);
1212 /* Append text to GList, remove all entries with the same text */
1214 list_append_unique (GList
*list
, char *text
)
1216 GList
*link
, *newlink
, *tmp
;
1219 * Go to the last position and traverse the list backwards
1220 * starting from the second last entry to make sure that we
1221 * are not removing the current link.
1223 list
= g_list_append (list
, text
);
1224 list
= g_list_last (list
);
1225 link
= g_list_previous (list
);
1228 newlink
= g_list_previous (link
);
1229 if (!strcmp ((char *) link
->data
, text
)) {
1230 g_free (link
->data
);
1231 tmp
= g_list_remove_link (list
, link
);
1232 g_list_free_1 (link
);
1240 /* Following code heavily borrows from libiberty, mkstemps.c */
1242 /* Number of attempts to create a temporary file */
1244 #define TMP_MAX 16384
1245 #endif /* !TMP_MAX */
1249 * pname (output) - pointer to the name of the temp file (needs g_free).
1250 * NULL if the function fails.
1251 * prefix - part of the filename before the random part.
1252 * Prepend $TMPDIR or /tmp if there are no path separators.
1253 * suffix - if not NULL, part of the filename after the random part.
1256 * handle of the open file or -1 if couldn't open any.
1259 mc_mkstemps (char **pname
, const char *prefix
, const char *suffix
)
1261 static const char letters
[]
1262 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
1263 static unsigned long value
;
1270 if (strchr (prefix
, PATH_SEP
) == NULL
) {
1271 /* Add prefix first to find the position of XXXXXX */
1272 tmpbase
= concat_dir_and_file (mc_tmpdir (), prefix
);
1274 tmpbase
= g_strdup (prefix
);
1277 tmpname
= g_strconcat (tmpbase
, "XXXXXX", suffix
, (char *) NULL
);
1279 XXXXXX
= &tmpname
[strlen (tmpbase
)];
1282 /* Get some more or less random data. */
1283 gettimeofday (&tv
, NULL
);
1284 value
+= (tv
.tv_usec
<< 16) ^ tv
.tv_sec
^ getpid ();
1286 for (count
= 0; count
< TMP_MAX
; ++count
) {
1287 unsigned long v
= value
;
1290 /* Fill in the random bits. */
1291 XXXXXX
[0] = letters
[v
% 62];
1293 XXXXXX
[1] = letters
[v
% 62];
1295 XXXXXX
[2] = letters
[v
% 62];
1297 XXXXXX
[3] = letters
[v
% 62];
1299 XXXXXX
[4] = letters
[v
% 62];
1301 XXXXXX
[5] = letters
[v
% 62];
1303 fd
= open (tmpname
, O_RDWR
| O_CREAT
| O_TRUNC
| O_EXCL
,
1306 /* Successfully created. */
1310 /* This is a random value. It is only necessary that the next
1311 TMP_MAX values generated by adding 7777 to VALUE are different
1312 with (module 2^32). */
1316 /* Unsuccessful. Free the filename. */
1324 * Read and restore position for the given filename.
1325 * If there is no stored data, return line 1 and col 0.
1328 load_file_position (const char *filename
, long *line
, long *column
)
1332 char buf
[MC_MAXPATHLEN
+ 20];
1339 /* open file with positions */
1340 fn
= concat_dir_and_file (home_dir
, MC_FILEPOS
);
1341 f
= fopen (fn
, "r");
1346 len
= strlen (filename
);
1348 while (fgets (buf
, sizeof (buf
), f
)) {
1351 /* check if the filename matches the beginning of string */
1352 if (strncmp (buf
, filename
, len
) != 0)
1355 /* followed by single space */
1356 if (buf
[len
] != ' ')
1359 /* and string without spaces */
1361 if (strchr (p
, ' '))
1364 *line
= strtol(p
, const_cast(char **, &p
), 10);
1366 *column
= strtol(p
+1, const_cast(char **, &p
), 10);
1375 /* Save position for the given file */
1377 save_file_position (const char *filename
, long line
, long column
)
1381 char buf
[MC_MAXPATHLEN
+ 20];
1385 len
= strlen (filename
);
1387 tmp
= concat_dir_and_file (home_dir
, MC_FILEPOS_TMP
);
1388 fn
= concat_dir_and_file (home_dir
, MC_FILEPOS
);
1390 /* open temporary file */
1391 t
= fopen (tmp
, "w");
1398 /* put the new record */
1399 if (line
!= 1 || column
!= 0) {
1400 fprintf (t
, "%s %ld;%ld\n", filename
, line
, column
);
1403 /* copy records from the old file */
1404 f
= fopen (fn
, "r");
1406 while (fgets (buf
, sizeof (buf
), f
)) {
1407 /* Skip entries for the current filename */
1408 if (strncmp (buf
, filename
, len
) == 0 && buf
[len
] == ' '
1409 && !strchr (&buf
[len
+ 1], ' '))
1412 fprintf (t
, "%s", buf
);
1413 if (++i
> MC_FILEPOS_ENTRIES
)
1426 cstrcasestr (const char *haystack
, const char *needle
)
1428 char *nee
= str_create_search_needle (needle
, 0);
1429 const char *result
= str_search_first (haystack
, nee
, 0);
1430 str_release_search_needle (nee
, 0);
1435 cstrstr (const char *haystack
, const char *needle
)
1437 return strstr(haystack
, needle
);
1441 str_unconst (const char *s
)
1446 #define ASCII_A (0x40 + 1)
1447 #define ASCII_Z (0x40 + 26)
1448 #define ASCII_a (0x60 + 1)
1449 #define ASCII_z (0x60 + 26)
1452 ascii_alpha_to_cntrl (int ch
)
1454 if ((ch
>= ASCII_A
&& ch
<= ASCII_Z
)
1455 || (ch
>= ASCII_a
&& ch
<= ASCII_z
)) {
1464 const char *result
, *sep
;
1467 sep
= strchr(result
, '|');
1468 return (sep
!= NULL
) ? sep
+ 1 : result
;