src/ui_fileops.c

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