src/ui_fileops.c

   1 /*
   2  * (SLIK) SimpLIstic sKin functions
   3  * (C) 2006 John Ellis
   4  * Copyright (C) 2008 The Geeqie Team
   5  *
   6  * Author: John Ellis
   7  *
   8  * This software is released under the GNU General Public License (GNU GPL).
   9  * Please read the included file COPYING for more information.
  10  * This software comes with no warranty of any kind, use at your own risk!
  11  */
  12
  13 #ifdef HAVE_CONFIG_H
  14 #  include "config.h"
  15 #endif
  16
  17 #include <pwd.h>
  18 #include <stdio.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #include <sys/param.h>
  23 #include <dirent.h>
  24 #include <utime.h>
  25
  26 #include <glib.h>
  27 #include <gtk/gtk.h>    /* for locale warning dialog */
  28
  29 #include "main.h"
  30 #include "ui_fileops.h"
  31
  32 #include "ui_utildlg.h" /* for locale warning dialog */
  33
  34 /*
  35  *-----------------------------------------------------------------------------
  36  * generic file information and manipulation routines (public)
  37  *-----------------------------------------------------------------------------
  38  */
  39
  40
  41
  42 void print_term(const gchar *text_utf8)
  43 {
  44         gchar *text_l;
  45
  46         text_l = g_locale_from_utf8(text_utf8, -1, NULL, NULL, NULL);
  47         fputs((text_l) ? text_l : text_utf8, stdout);
  48         g_free(text_l);
  49 }
  50
  51 static void encoding_dialog(const gchar *path);
  52
  53 static gint encoding_dialog_idle(gpointer data)
  54 {
  55         gchar *path = data;
  56
  57         encoding_dialog(path);
  58         g_free(path);
  59
  60         return FALSE;
  61 }
  62
  63 static gint encoding_dialog_delay(gpointer data)
  64 {
  65         g_idle_add(encoding_dialog_idle, data);
  66
  67         return 0;
  68 }
  69
  70 static void encoding_dialog(const gchar *path)
  71 {
  72         static gint warned_user = FALSE;
  73         GenericDialog *gd;
  74         GString *string;
  75         const gchar *lc;
  76         const gchar *bf;
  77
  78         /* check that gtk is initialized (loop is level > 0) */
  79         if (gtk_main_level() == 0)
  80                 {
  81                 /* gtk not initialized */
  82                 gtk_init_add(encoding_dialog_delay, g_strdup(path));
  83                 return;
  84                 }
  85
  86         if (warned_user) return;
  87         warned_user = TRUE;
  88
  89         lc = getenv("LANG");
  90         bf = getenv("G_BROKEN_FILENAMES");
  91
  92         string = g_string_new("");
  93         g_string_append(string, _("One or more filenames are not encoded with the preferred locale character set.\n"));
  94         g_string_append_printf(string, _("Operations on, and display of these files with %s may not succeed.\n"), PACKAGE);
  95         g_string_append(string, "\n");
  96         g_string_append(string, _("If your filenames are not encoded in utf-8, try setting the environment variable G_BROKEN_FILENAMES=1\n"));
  97         if (bf)
  98                 g_string_append_printf(string, _("It appears G_BROKEN_FILENAMES is set to %s\n"), bf);
  99         else
 100                 g_string_append(string, _("It appears G_BROKEN_FILENAMES is not set\n"));
 101         g_string_append(string, "\n");
 102         g_string_append_printf(string, _("The locale appears to be set to \"%s\"\n(set by the LANG environment variable)\n"), (lc) ? lc : "undefined");
 103         if (lc && (strstr(lc, "UTF-8") || strstr(lc, "utf-8")))
 104                 {
 105                 gchar *name;
 106                 name = g_convert(path, -1, "UTF-8", "ISO-8859-1", NULL, NULL, NULL);
 107                 string = g_string_append(string, _("\nPreferred encoding appears to be UTF-8, however the file:\n"));
 108                 g_string_append_printf(string, "\"%s\"\n", (name) ? name : _("[name not displayable]"));
 109
 110                 if (g_utf8_validate(path, -1, NULL))
 111                         g_string_append_printf(string, _("\"%s\" is encoded in valid UTF-8."), (name) ? name : _("[name not displayable]"));
 112                 else
 113                         g_string_append_printf(string, _("\"%s\" is not encoded in valid UTF-8."), (name) ? name : _("[name not displayable]"));
 114                 g_string_append(string, "\n");
 115                 g_free(name);
 116                 }
 117
 118         gd = generic_dialog_new(_("Filename encoding locale mismatch"),
 119                                 GQ_WMCLASS, "locale warning", NULL, TRUE, NULL, NULL);
 120         generic_dialog_add_button(gd, GTK_STOCK_CLOSE, NULL, NULL, TRUE);
 121
 122         generic_dialog_add_message(gd, GTK_STOCK_DIALOG_WARNING,
 123                                    _("Filename encoding locale mismatch"), string->str);
 124
 125         gtk_widget_show(gd->dialog);
 126
 127         g_string_free(string, TRUE);
 128 }
 129
 130 gchar *path_to_utf8(const gchar *path)
 131 {
 132         gchar *utf8;
 133         GError *error = NULL;
 134
 135         if (!path) return NULL;
 136
 137         utf8 = g_filename_to_utf8(path, -1, NULL, NULL, &error);
 138         if (error)
 139                 {
 140                 log_printf("Unable to convert filename to UTF-8:\n%s\n%s\n", path, error->message);
 141                 g_error_free(error);
 142                 encoding_dialog(path);
 143                 }
 144         if (!utf8)
 145                 {
 146                 /* just let it through, but bad things may happen */
 147                 utf8 = g_strdup(path);
 148                 }
 149
 150         return utf8;
 151 }
 152
 153 gchar *path_from_utf8(const gchar *utf8)
 154 {
 155         gchar *path;
 156         GError *error = NULL;
 157
 158         if (!utf8) return NULL;
 159
 160         path = g_filename_from_utf8(utf8, -1, NULL, NULL, &error);
 161         if (error)
 162                 {
 163                 log_printf("Unable to convert filename to locale from UTF-8:\n%s\n%s\n", utf8, error->message);
 164                 g_error_free(error);
 165                 }
 166         if (!path)
 167                 {
 168                 /* if invalid UTF-8, text probaby still in original form, so just copy it */
 169                 path = g_strdup(utf8);
 170                 }
 171
 172         return path;
 173 }
 174
 175 /* first we try the HOME environment var, if that doesn't work, we try g_get_homedir(). */
 176 const gchar *homedir(void)
 177 {
 178         static gchar *home = NULL;
 179
 180         if (!home)
 181                 home = path_to_utf8(getenv("HOME"));
 182
 183         if (!home)
 184                 home = path_to_utf8(g_get_home_dir());
 185
 186         return home;
 187 }
 188
 189 const gchar *get_rc_dir(void)
 190 {
 191         static gchar *rc_dir = NULL;
 192
 193         if (rc_dir) return rc_dir;
 194
 195         rc_dir = g_build_filename(homedir(), GQ_RC_DIR, NULL);
 196
 197         return rc_dir;
 198 }
 199
 200 const gchar *get_collections_dir(void)
 201 {
 202         static gchar *collections_dir = NULL;
 203
 204         if (collections_dir) return collections_dir;
 205
 206         collections_dir = g_build_filename(get_rc_dir(), GQ_COLLECTIONS_DIR, NULL);
 207
 208         return collections_dir;
 209 }
 210
 211 const gchar *get_trash_dir(void)
 212 {
 213         static gchar *trash_dir = NULL;
 214
 215         if (trash_dir) return trash_dir;
 216
 217         trash_dir = g_build_filename(get_rc_dir(), GQ_TRASH_DIR, NULL);
 218
 219         return trash_dir;
 220 }
 221
 222 gint stat_utf8(const gchar *s, struct stat *st)
 223 {
 224         gchar *sl;
 225         gint ret;
 226
 227         if (!s) return FALSE;
 228         sl = path_from_utf8(s);
 229         ret = (stat(sl, st) == 0);
 230         g_free(sl);
 231
 232         return ret;
 233 }
 234
 235 gint lstat_utf8(const gchar *s, struct stat *st)
 236 {
 237         gchar *sl;
 238         gint ret;
 239
 240         if (!s) return FALSE;
 241         sl = path_from_utf8(s);
 242         ret = (lstat(sl, st) == 0);
 243         g_free(sl);
 244
 245         return ret;
 246 }
 247
 248 gint isname(const gchar *s)
 249 {
 250         struct stat st;
 251
 252         return stat_utf8(s, &st);
 253 }
 254
 255 gint isfile(const gchar *s)
 256 {
 257         struct stat st;
 258
 259         return (stat_utf8(s, &st) && S_ISREG(st.st_mode));
 260 }
 261
 262 gint isdir(const gchar *s)
 263 {
 264         struct stat st;
 265
 266         return (stat_utf8(s ,&st) && S_ISDIR(st.st_mode));
 267 }
 268
 269 gint islink(const gchar *s)
 270 {
 271         struct stat st;
 272
 273         return (lstat_utf8(s ,&st) && S_ISLNK(st.st_mode));
 274 }
 275
 276 gint64 filesize(const gchar *s)
 277 {
 278         struct stat st;
 279
 280         if (!stat_utf8(s, &st)) return 0;
 281         return st.st_size;
 282 }
 283
 284 time_t filetime(const gchar *s)
 285 {
 286         struct stat st;
 287
 288         if (!stat_utf8(s, &st)) return 0;
 289         return st.st_mtime;
 290 }
 291
 292 gint filetime_set(const gchar *s, time_t tval)
 293 {
 294         gint ret = FALSE;
 295
 296         if (tval > 0)
 297                 {
 298                 struct utimbuf ut;
 299                 gchar *sl;
 300
 301                 ut.actime = ut.modtime = tval;
 302
 303                 sl = path_from_utf8(s);
 304                 ret = (utime(sl, &ut) == 0);
 305                 g_free(sl);
 306                 }
 307
 308         return ret;
 309 }
 310
 311 gint access_file(const gchar *s, gint mode)
 312 {
 313         gchar *sl;
 314         gint ret;
 315
 316         if (!s) return FALSE;
 317
 318         sl = path_from_utf8(s);
 319         ret = (access(sl, mode) == 0);
 320         g_free(sl);
 321
 322         return ret;
 323 }
 324
 325 gint unlink_file(const gchar *s)
 326 {
 327         gchar *sl;
 328         gint ret;
 329
 330         if (!s) return FALSE;
 331
 332         sl = path_from_utf8(s);
 333         ret = (unlink(sl) == 0);
 334         g_free(sl);
 335
 336         return ret;
 337 }
 338
 339 gint symlink_utf8(const gchar *source, const gchar *target)
 340 {
 341         gchar *sl;
 342         gchar *tl;
 343         gint ret;
 344
 345         if (!source || !target) return FALSE;
 346
 347         sl = path_from_utf8(source);
 348         tl = path_from_utf8(target);
 349
 350         ret = (symlink(sl, tl) == 0);
 351
 352         g_free(sl);
 353         g_free(tl);
 354
 355         return ret;
 356 }
 357
 358 gint mkdir_utf8(const gchar *s, gint mode)
 359 {
 360         gchar *sl;
 361         gint ret;
 362
 363         if (!s) return FALSE;
 364
 365         sl = path_from_utf8(s);
 366         ret = (mkdir(sl, mode) == 0);
 367         g_free(sl);
 368         return ret;
 369 }
 370
 371 gint rmdir_utf8(const gchar *s)
 372 {
 373         gchar *sl;
 374         gint ret;
 375
 376         if (!s) return FALSE;
 377
 378         sl = path_from_utf8(s);
 379         ret = (rmdir(sl) == 0);
 380         g_free(sl);
 381
 382         return ret;
 383 }
 384
 385 gint copy_file_attributes(const gchar *s, const gchar *t, gint perms, gint mtime)
 386 {
 387         struct stat st;
 388         gchar *sl, *tl;
 389         gint ret = FALSE;
 390
 391         if (!s || !t) return FALSE;
 392
 393         sl = path_from_utf8(s);
 394         tl = path_from_utf8(t);
 395
 396         if (stat(sl, &st) == 0)
 397                 {
 398                 struct utimbuf tb;
 399
 400                 ret = TRUE;
 401
 402                 /* set the dest file attributes to that of source (ignoring errors) */
 403
 404                 if (perms && chown(tl, st.st_uid, st.st_gid) < 0) ret = FALSE;
 405                 if (perms && chmod(tl, st.st_mode) < 0) ret = FALSE;
 406
 407                 tb.actime = st.st_atime;
 408                 tb.modtime = st.st_mtime;
 409                 if (mtime && utime(tl, &tb) < 0) ret = FALSE;
 410                 }
 411
 412         g_free(sl);
 413         g_free(tl);
 414
 415         return ret;
 416 }
 417
 418 /* paths are in filesystem encoding */
 419 static gint hard_linked(const gchar *a, const gchar *b)
 420 {
 421         struct stat sta;
 422         struct stat stb;
 423
 424         if (stat(a, &sta) !=  0 || stat(b, &stb) != 0) return FALSE;
 425
 426         return (sta.st_dev == stb.st_dev &&
 427                 sta.st_ino == stb.st_ino);
 428 }
 429
 430 gint copy_file(const gchar *s, const gchar *t)
 431 {
 432         FILE *fi = NULL;
 433         FILE *fo = NULL;
 434         gchar *sl, *tl;
 435         gchar buf[4096];
 436         size_t b;
 437
 438         sl = path_from_utf8(s);
 439         tl = path_from_utf8(t);
 440
 441         if (hard_linked(sl, tl))
 442                 {
 443                 g_free(sl);
 444                 g_free(tl);
 445                 return TRUE;
 446                 }
 447
 448         fi = fopen(sl, "rb");
 449         if (fi)
 450                 {
 451                 fo = fopen(tl, "wb");
 452                 if (!fo)
 453                         {
 454                         fclose(fi);
 455                         fi = NULL;
 456                         }
 457                 }
 458
 459         g_free(sl);
 460         g_free(tl);
 461
 462         if (!fi || !fo) return FALSE;
 463
 464         while ((b = fread(buf, sizeof(gchar), sizeof(buf), fi)) && b != 0)
 465                 {
 466                 if (fwrite(buf, sizeof(gchar), b, fo) != b)
 467                         {
 468                         fclose(fi);
 469                         fclose(fo);
 470                         return FALSE;
 471                         }
 472                 }
 473
 474         fclose(fi);
 475         fclose(fo);
 476
 477         copy_file_attributes(s, t, TRUE, TRUE);
 478
 479         return TRUE;
 480 }
 481
 482 gint move_file(const gchar *s, const gchar *t)
 483 {
 484         gchar *sl, *tl;
 485         gint ret = TRUE;
 486
 487         if (!s || !t) return FALSE;
 488
 489         sl = path_from_utf8(s);
 490         tl = path_from_utf8(t);
 491         if (rename(sl, tl) < 0)
 492                 {
 493                 /* this may have failed because moving a file across filesystems
 494                 was attempted, so try copy and delete instead */
 495                 if (copy_file(s, t))
 496                         {
 497                         if (unlink(sl) < 0)
 498                                 {
 499                                 /* err, now we can't delete the source file so return FALSE */
 500                                 ret = FALSE;
 501                                 }
 502                         }
 503                 else
 504                         {
 505                         ret = FALSE;
 506                         }
 507                 }
 508         g_free(sl);
 509         g_free(tl);
 510
 511         return ret;
 512 }
 513
 514 gint rename_file(const gchar *s, const gchar *t)
 515 {
 516         gchar *sl, *tl;
 517         gint ret;
 518
 519         if (!s || !t) return FALSE;
 520
 521         sl = path_from_utf8(s);
 522         tl = path_from_utf8(t);
 523         ret = (rename(sl, tl) == 0);
 524         g_free(sl);
 525         g_free(tl);
 526
 527         return ret;
 528 }
 529
 530 gchar *get_current_dir(void)
 531 {
 532         gchar *pathl;
 533         gchar *path8;
 534
 535         pathl = g_get_current_dir();
 536         path8 = path_to_utf8(pathl);
 537         g_free(pathl);
 538
 539         return path8;
 540 }
 541
 542 void string_list_free(GList *list)
 543 {
 544         g_list_foreach(list, (GFunc)g_free, NULL);
 545         g_list_free(list);
 546 }
 547
 548 GList *string_list_copy(GList *list)
 549 {
 550         GList *new_list = NULL;
 551         GList *work;
 552
 553         work = list;
 554         while (work)
 555                 {
 556                 gchar *path;
 557
 558                 path = work->data;
 559                 work = work->next;
 560
 561                 new_list = g_list_prepend(new_list, g_strdup(path));
 562                 }
 563
 564         return g_list_reverse(new_list);
 565 }
 566
 567 gchar *unique_filename(const gchar *path, const gchar *ext, const gchar *divider, gint pad)
 568 {
 569         gchar *unique;
 570         gint n = 1;
 571
 572         if (!ext) ext = "";
 573         if (!divider) divider = "";
 574
 575         unique = g_strconcat(path, ext, NULL);
 576         while (isname(unique))
 577                 {
 578                 g_free(unique);
 579                 if (pad)
 580                         {
 581                         unique = g_strdup_printf("%s%s%03d%s", path, divider, n, ext);
 582                         }
 583                 else
 584                         {
 585                         unique = g_strdup_printf("%s%s%d%s", path, divider, n, ext);
 586                         }
 587                 n++;
 588                 if (n > 999)
 589                         {
 590                         /* well, we tried */
 591                         g_free(unique);
 592                         return NULL;
 593                         }
 594                 }
 595
 596         return unique;
 597 }
 598
 599 gchar *unique_filename_simple(const gchar *path)
 600 {
 601         gchar *unique;
 602         const gchar *name;
 603         const gchar *ext;
 604
 605         if (!path) return NULL;
 606
 607         name = filename_from_path(path);
 608         if (!name) return NULL;
 609
 610         ext = extension_from_path(name);
 611
 612         if (!ext)
 613                 {
 614                 unique = unique_filename(path, NULL, "_", TRUE);
 615                 }
 616         else
 617                 {
 618                 gchar *base;
 619
 620                 base = remove_extension_from_path(path);
 621                 unique = unique_filename(base, ext, "_", TRUE);
 622                 g_free(base);
 623                 }
 624
 625         return unique;
 626 }
 627
 628 const gchar *filename_from_path(const gchar *path)
 629 {
 630         const gchar *base;
 631
 632         if (!path) return NULL;
 633
 634         base = strrchr(path, G_DIR_SEPARATOR);
 635         if (base) return base + 1;
 636
 637         return path;
 638 }
 639
 640 gchar *remove_level_from_path(const gchar *path)
 641 {
 642         gint p = 0, n = -1;
 643
 644         if (!path) return NULL;
 645
 646         while (path[p])
 647                 {
 648                 if (path[p] == G_DIR_SEPARATOR) n = p;
 649                 p++;
 650                 }
 651         if (n <= 0) n++;
 652
 653         return g_strndup(path, (gsize) n);
 654 }
 655
 656 const gchar *extension_from_path(const gchar *path)
 657 {
 658         if (!path) return NULL;
 659         return strrchr(path, '.');
 660 }
 661
 662 gint file_extension_match(const gchar *path, const gchar *ext)
 663 {
 664         gint p;
 665         gint e;
 666
 667         if (!path) return FALSE;
 668         if (!ext) return TRUE;
 669
 670         p = strlen(path);
 671         e = strlen(ext);
 672
 673         /* FIXME: utf8 */
 674         return (p > e && strncasecmp(path + p - e, ext, e) == 0);
 675 }
 676
 677 gchar *remove_extension_from_path(const gchar *path)
 678 {
 679         gint p = 0, n = -1;
 680
 681         if (!path) return NULL;
 682
 683         while (path[p])
 684                 {
 685                 if (path[p] == '.') n = p;
 686                 p++;
 687                 }
 688         if (n < 0) n = p;
 689
 690         return g_strndup(path, (gsize) n);
 691 }
 692
 693 void parse_out_relatives(gchar *path)
 694 {
 695         gint s, t;
 696
 697         if (!path) return;
 698
 699         s = t = 0;
 700
 701         while (path[s] != '\0')
 702                 {
 703                 if (path[s] == G_DIR_SEPARATOR && path[s+1] == '.')
 704                         {
 705                         /* /. occurence, let's see more */
 706                         gint p = s + 2;
 707
 708                         if (path[p] == G_DIR_SEPARATOR || path[p] == '\0')
 709                                 {
 710                                 /* /./ or /., just skip this part */
 711                                 s = p;
 712                                 continue;
 713                                 }
 714                         else if (path[p] == '.' && (path[p+1] == G_DIR_SEPARATOR || path[p+1] == '\0'))
 715                                 {
 716                                 /* /../ or /.., remove previous part, ie. /a/b/../ becomes /a/ */
 717                                 s = p + 1;
 718                                 if (t > 0) t--;
 719                                 while (path[t] != G_DIR_SEPARATOR && t > 0) t--;
 720                                 continue;
 721                                 }
 722                         }
 723
 724                 if (s != t) path[t] = path[s];
 725                 t++;
 726                 s++;
 727                 }
 728
 729         if (t == 0 && path[t] == G_DIR_SEPARATOR) t++;
 730         if (t > 1 && path[t-1] == G_DIR_SEPARATOR) t--;
 731         path[t] = '\0';
 732 }
 733
 734 gint file_in_path(const gchar *name)
 735 {
 736         gchar *path;
 737         gchar *namel;
 738         gint p, l;
 739         gint ret = FALSE;
 740
 741         if (!name) return FALSE;
 742         path = g_strdup(getenv("PATH"));
 743         if (!path) return FALSE;
 744         namel = path_from_utf8(name);
 745
 746         p = 0;
 747         l = strlen(path);
 748         while (p < l && !ret)
 749                 {
 750                 gchar *f;
 751                 gint e = p;
 752                 while (path[e] != ':' && path[e] != '\0') e++;
 753                 path[e] = '\0';
 754                 e++;
 755                 f = g_build_filename(path + p, namel, NULL);
 756                 if (isfile(f)) ret = TRUE;
 757                 g_free(f);
 758                 p = e;
 759                 }
 760         g_free(namel);
 761         g_free(path);
 762
 763         return ret;
 764 }
 765
 766 gboolean recursive_mkdir_if_not_exists(gchar *path, mode_t mode)
 767 {
 768         if (!path) return FALSE;
 769
 770         if (!isdir(path))
 771                 {
 772                 gchar *npath = g_strdup(path);
 773                 gchar *p = npath;
 774
 775                 while (p[0] != '\0')
 776                         {
 777                         p++;
 778                         if (p[0] == G_DIR_SEPARATOR || p[0] == '\0')
 779                                 {
 780                                 gint end = TRUE;
 781
 782                                 if (p[0] != '\0')
 783                                         {
 784                                         p[0] = '\0';
 785                                         end = FALSE;
 786                                         }
 787
 788                                 if (!isdir(npath))
 789                                         {
 790                                         DEBUG_1("creating sub dir:%s", npath);
 791                                         if (!mkdir_utf8(npath, mode))
 792                                                 {
 793                                                 log_printf("create dir failed: %s\n", npath);
 794                                                 g_free(npath);
 795                                                 return FALSE;
 796                                                 }
 797                                         }
 798
 799                                 if (!end) p[0] = G_DIR_SEPARATOR;
 800                                 }
 801                         }
 802                 g_free(npath);
 803                 }
 804
 805         return TRUE;
 806 }
 807
 808
 809
 810 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */