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, TRUE);
 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) {
 487                             struct stat st2;
 488                             if (stat(tl, &st2) != 0 || st2.st_mode != st.st_mode) {
 489                                 ret = FALSE;
 490                             }
 491                         }
 492                         }
 493
 494                 tb.actime = st.st_atime;
 495                 tb.modtime = st.st_mtime;
 496                 if (mtime && utime(tl, &tb) < 0) ret = FALSE;
 497                 }
 498
 499         g_free(sl);
 500         g_free(tl);
 501
 502         return ret;
 503 }
 504
 505 /* paths are in filesystem encoding */
 506 static gboolean hard_linked(const gchar *a, const gchar *b)
 507 {
 508         struct stat sta;
 509         struct stat stb;
 510
 511         if (stat(a, &sta) !=  0 || stat(b, &stb) != 0) return FALSE;
 512
 513         return (sta.st_dev == stb.st_dev &&
 514                 sta.st_ino == stb.st_ino);
 515 }
 516
 517 gboolean copy_file(const gchar *s, const gchar *t)
 518 {
 519         FILE *fi = NULL;
 520         FILE *fo = NULL;
 521         gchar *sl = NULL;
 522         gchar *tl = NULL;
 523         gchar *randname = NULL;
 524         gchar buf[16384];
 525         size_t b;
 526         gint ret = FALSE;
 527         gint fd = -1;
 528
 529         sl = path_from_utf8(s);
 530         tl = path_from_utf8(t);
 531
 532         if (hard_linked(sl, tl))
 533                 {
 534                 ret = TRUE;
 535                 goto end;
 536                 }
 537
 538         /* Do not dereference absolute symlinks, but copy them "as is".
 539         * For a relative symlink, we don't know how to properly change it when
 540         * copied/moved to another dir to keep pointing it to same target as
 541         * a relative symlink, so we turn it into absolute symlink using
 542         * realpath() instead. */
 543         struct stat st;
 544         if (lstat_utf8(sl, &st) && S_ISLNK(st.st_mode))
 545                 {
 546                 gchar *link_target;
 547
 548                 link_target = g_malloc(PATH_MAX + 1);
 549                 readlink(sl, link_target, st.st_size);
 550                 link_target[st.st_size] = '\0';
 551
 552                 if (link_target[0] != G_DIR_SEPARATOR) // if it is a relative symlink
 553                         {
 554                         gchar *absolute;
 555
 556                         absolute = g_malloc(PATH_MAX + 1);
 557                         char *lastslash = strrchr(sl, G_DIR_SEPARATOR);
 558                         int len = lastslash - sl + 1;
 559
 560                         strncpy(absolute, sl, len);
 561                         strcpy(absolute + len, link_target);
 562                         strcpy(link_target, absolute);
 563
 564                         char *realPath;
 565                         realPath = realpath(link_target, absolute);
 566
 567                         if (realPath != NULL) // successfully resolved into an absolute path
 568                                 {
 569                                 g_free(link_target);
 570                                 link_target = absolute;
 571                                 }
 572                         else                 // could not get absolute path, got some error instead
 573                                 {
 574                                 g_free(absolute);
 575                                 goto orig_copy;  // so try a "normal" copy
 576                                 }
 577                         }
 578
 579                 if (stat_utf8(tl, &st)) unlink(tl); // first try to remove directory entry in destination directory if such entry exists
 580
 581                 gint success = (symlink(link_target, tl) == 0);
 582                 g_free(link_target);
 583
 584                 if (success)
 585                         {
 586                         ret = TRUE;
 587                         goto end;
 588                         }
 589                 } // if symlink did not succeed, continue on to try a copy procedure
 590         orig_copy:
 591
 592         fi = fopen(sl, "rb");
 593         if (!fi) goto end;
 594
 595         /* First we write to a temporary file, then we rename it on success,
 596            and attributes from original file are copied */
 597         randname = g_strconcat(tl, ".tmp_XXXXXX", NULL);
 598         if (!randname) goto end;
 599
 600         fd = g_mkstemp(randname);
 601         if (fd == -1) goto end;
 602
 603         fo = fdopen(fd, "wb");
 604         if (!fo) {
 605                 close(fd);
 606                 goto end;
 607         }
 608
 609         while ((b = fread(buf, sizeof(gchar), sizeof(buf), fi)) && b != 0)
 610                 {
 611                 if (fwrite(buf, sizeof(gchar), b, fo) != b)
 612                         {
 613                         unlink(randname);
 614                         goto end;
 615                         }
 616                 }
 617
 618         fclose(fi); fi = NULL;
 619         fclose(fo); fo = NULL;
 620
 621         if (rename(randname, tl) < 0) {
 622                 unlink(randname);
 623                 goto end;
 624         }
 625
 626         ret = copy_file_attributes(s, t, TRUE, TRUE);
 627
 628 end:
 629         if (fi) fclose(fi);
 630         if (fo) fclose(fo);
 631         if (sl) g_free(sl);
 632         if (tl) g_free(tl);
 633         if (randname) g_free(randname);
 634         return ret;
 635 }
 636
 637 gboolean move_file(const gchar *s, const gchar *t)
 638 {
 639         gchar *sl, *tl;
 640         gboolean ret = TRUE;
 641
 642         if (!s || !t) return FALSE;
 643
 644         sl = path_from_utf8(s);
 645         tl = path_from_utf8(t);
 646         if (rename(sl, tl) < 0)
 647                 {
 648                 /* this may have failed because moving a file across filesystems
 649                 was attempted, so try copy and delete instead */
 650                 if (copy_file(s, t))
 651                         {
 652                         if (unlink(sl) < 0)
 653                                 {
 654                                 /* err, now we can't delete the source file so return FALSE */
 655                                 ret = FALSE;
 656                                 }
 657                         }
 658                 else
 659                         {
 660                         ret = FALSE;
 661                         }
 662                 }
 663         g_free(sl);
 664         g_free(tl);
 665
 666         return ret;
 667 }
 668
 669 gboolean rename_file(const gchar *s, const gchar *t)
 670 {
 671         gchar *sl, *tl;
 672         gboolean ret;
 673
 674         if (!s || !t) return FALSE;
 675
 676         sl = path_from_utf8(s);
 677         tl = path_from_utf8(t);
 678         ret = (rename(sl, tl) == 0);
 679         g_free(sl);
 680         g_free(tl);
 681
 682         return ret;
 683 }
 684
 685 gchar *get_current_dir(void)
 686 {
 687         gchar *pathl;
 688         gchar *path8;
 689
 690         pathl = g_get_current_dir();
 691         path8 = path_to_utf8(pathl);
 692         g_free(pathl);
 693
 694         return path8;
 695 }
 696
 697 void string_list_free(GList *list)
 698 {
 699         g_list_foreach(list, (GFunc)g_free, NULL);
 700         g_list_free(list);
 701 }
 702
 703 GList *string_list_copy(const GList *list)
 704 {
 705         GList *new_list = NULL;
 706         GList *work = (GList *) list;
 707
 708         while (work)
 709                 {
 710                 gchar *path;
 711
 712                 path = work->data;
 713                 work = work->next;
 714
 715                 new_list = g_list_prepend(new_list, g_strdup(path));
 716                 }
 717
 718         return g_list_reverse(new_list);
 719 }
 720
 721 gchar *unique_filename(const gchar *path, const gchar *ext, const gchar *divider, gboolean pad)
 722 {
 723         gchar *unique;
 724         gint n = 1;
 725
 726         if (!ext) ext = "";
 727         if (!divider) divider = "";
 728
 729         unique = g_strconcat(path, ext, NULL);
 730         while (isname(unique))
 731                 {
 732                 g_free(unique);
 733                 if (pad)
 734                         {
 735                         unique = g_strdup_printf("%s%s%03d%s", path, divider, n, ext);
 736                         }
 737                 else
 738                         {
 739                         unique = g_strdup_printf("%s%s%d%s", path, divider, n, ext);
 740                         }
 741                 n++;
 742                 if (n > 999)
 743                         {
 744                         /* well, we tried */
 745                         g_free(unique);
 746                         return NULL;
 747                         }
 748                 }
 749
 750         return unique;
 751 }
 752
 753 gchar *unique_filename_simple(const gchar *path)
 754 {
 755         gchar *unique;
 756         const gchar *name;
 757         const gchar *ext;
 758
 759         if (!path) return NULL;
 760
 761         name = filename_from_path(path);
 762         if (!name) return NULL;
 763
 764         ext = registered_extension_from_path(name);
 765
 766         if (!ext)
 767                 {
 768                 unique = unique_filename(path, NULL, "_", TRUE);
 769                 }
 770         else
 771                 {
 772                 gchar *base;
 773
 774                 base = remove_extension_from_path(path);
 775                 unique = unique_filename(base, ext, "_", TRUE);
 776                 g_free(base);
 777                 }
 778
 779         return unique;
 780 }
 781
 782 const gchar *filename_from_path(const gchar *path)
 783 {
 784         const gchar *base;
 785
 786         if (!path) return NULL;
 787
 788         base = strrchr(path, G_DIR_SEPARATOR);
 789         if (base) return base + 1;
 790
 791         return path;
 792 }
 793
 794 gchar *remove_level_from_path(const gchar *path)
 795 {
 796         const gchar *base;
 797
 798         if (!path) return NULL;
 799
 800         base = strrchr(path, G_DIR_SEPARATOR);
 801         /* Take account of a file being in the root ( / ) folder - ensure the returned value
 802          * is at least one character long */
 803         if (base) return g_strndup(path, (strlen(path)-strlen(base)) == 0 ? 1 : (strlen(path)-strlen(base)));
 804
 805         return NULL;
 806 }
 807
 808 gboolean file_extension_match(const gchar *path, const gchar *ext)
 809 {
 810         gint p;
 811         gint e;
 812
 813         if (!path) return FALSE;
 814         if (!ext) return TRUE;
 815
 816         p = strlen(path);
 817         e = strlen(ext);
 818
 819         /* FIXME: utf8 */
 820         return (p > e && g_ascii_strncasecmp(path + p - e, ext, e) == 0);
 821 }
 822
 823 gchar *remove_extension_from_path(const gchar *path)
 824 {
 825         const gchar *reg_ext;
 826
 827         if (!path) return NULL;
 828
 829         reg_ext = registered_extension_from_path(path);
 830
 831         return g_strndup(path, strlen(path) - (reg_ext == NULL ? 0 : strlen(reg_ext)));
 832 }
 833
 834 void parse_out_relatives(gchar *path)
 835 {
 836         gint s, t;
 837
 838         if (!path) return;
 839
 840         s = t = 0;
 841
 842         while (path[s] != '\0')
 843                 {
 844                 if (path[s] == G_DIR_SEPARATOR && path[s+1] == '.')
 845                         {
 846                         /* /. occurence, let's see more */
 847                         gint p = s + 2;
 848
 849                         if (path[p] == G_DIR_SEPARATOR || path[p] == '\0')
 850                                 {
 851                                 /* /./ or /., just skip this part */
 852                                 s = p;
 853                                 continue;
 854                                 }
 855                         else if (path[p] == '.' && (path[p+1] == G_DIR_SEPARATOR || path[p+1] == '\0'))
 856                                 {
 857                                 /* /../ or /.., remove previous part, ie. /a/b/../ becomes /a/ */
 858                                 s = p + 1;
 859                                 if (t > 0) t--;
 860                                 while (path[t] != G_DIR_SEPARATOR && t > 0) t--;
 861                                 continue;
 862                                 }
 863                         }
 864
 865                 if (s != t) path[t] = path[s];
 866                 t++;
 867                 s++;
 868                 }
 869
 870         if (t == 0 && path[t] == G_DIR_SEPARATOR) t++;
 871         if (t > 1 && path[t-1] == G_DIR_SEPARATOR) t--;
 872         path[t] = '\0';
 873 }
 874
 875 gboolean file_in_path(const gchar *name)
 876 {
 877         gchar *path;
 878         gchar *namel;
 879         gint p, l;
 880         gboolean ret = FALSE;
 881
 882         if (!name) return FALSE;
 883         path = g_strdup(getenv("PATH"));
 884         if (!path) return FALSE;
 885         namel = path_from_utf8(name);
 886
 887         p = 0;
 888         l = strlen(path);
 889         while (p < l && !ret)
 890                 {
 891                 gchar *f;
 892                 gint e = p;
 893                 while (path[e] != ':' && path[e] != '\0') e++;
 894                 path[e] = '\0';
 895                 e++;
 896                 f = g_build_filename(path + p, namel, NULL);
 897                 if (isfile(f)) ret = TRUE;
 898                 g_free(f);
 899                 p = e;
 900                 }
 901         g_free(namel);
 902         g_free(path);
 903
 904         return ret;
 905 }
 906
 907 gboolean recursive_mkdir_if_not_exists(const gchar *path, mode_t mode)
 908 {
 909         if (!path) return FALSE;
 910
 911         if (!isdir(path))
 912                 {
 913                 gchar *npath = g_strdup(path);
 914                 gchar *p = npath;
 915
 916                 while (p[0] != '\0')
 917                         {
 918                         p++;
 919                         if (p[0] == G_DIR_SEPARATOR || p[0] == '\0')
 920                                 {
 921                                 gboolean end = TRUE;
 922
 923                                 if (p[0] != '\0')
 924                                         {
 925                                         p[0] = '\0';
 926                                         end = FALSE;
 927                                         }
 928
 929                                 if (!isdir(npath))
 930                                         {
 931                                         DEBUG_1("creating sub dir:%s", npath);
 932                                         if (!mkdir_utf8(npath, mode))
 933                                                 {
 934                                                 log_printf("create dir failed: %s\n", npath);
 935                                                 g_free(npath);
 936                                                 return FALSE;
 937                                                 }
 938                                         }
 939
 940                                 if (!end) p[0] = G_DIR_SEPARATOR;
 941                                 }
 942                         }
 943                 g_free(npath);
 944                 }
 945
 946         return TRUE;
 947 }
 948
 949 /* does filename utf8 to filesystem encoding first */
 950 gboolean md5_get_digest_from_file_utf8(const gchar *path, guchar digest[16])
 951 {
 952         gboolean success;
 953         gchar *pathl;
 954
 955         pathl = path_from_utf8(path);
 956         success = md5_get_digest_from_file(pathl, digest);
 957         g_free(pathl);
 958
 959         return success;
 960 }
 961
 962
 963 gchar *md5_text_from_file_utf8(const gchar *path, const gchar *error_text)
 964 {
 965         guchar digest[16];
 966
 967         if (!md5_get_digest_from_file_utf8(path, digest)) return g_strdup(error_text);
 968
 969         return md5_digest_to_text(digest);
 970 }
 971
 972
 973 /* vim: set shiftwidth=8 softtabstop=0 cindent cinoptions={1s: */