src/files.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <string.h>
   5 #include <ctype.h>
   6 #include <unistd.h>
   7 #include <sys/types.h>
   8 #include <sys/wait.h>
   9 #include <sys/stat.h>
  10 #include <fcntl.h>
  11 #include <errno.h>
  12 #include <dirent.h>
  13 #include <stdarg.h>
  14 #include <WINGs/WINGs.h>
  15 #include <WINGs/WUtil.h>
  16
  17 #include "FSViewer.h"
  18 #include "FSUtils.h"
  19 #include "misc.h"
  20
  21 static Bool  DISPLAY_HIDDEN_FILES = False;
  22 static Bool  SORT_TOGGLE          = True;
  23
  24 static int   copy(ino_t *inodes, int n_inodes, char *oldpath, char *newpath);
  25 static int   copyfile(char *oldpath, char *newpath);
  26 static int   copydir(ino_t *inodes, int n_inodes, struct stat *oldstats,
  27                      char *oldpath, char *newpath);
  28
  29 /*
  30 ** Here's an example of how to sort a singly-linked list.  I think it
  31 ** can be modified to sort a doubly-linked list, but it would get a bit
  32 ** more complicated.  Note that this is a recursive method, but the
  33 ** recursion depth is limited to be proportional to the base 2 log of
  34 ** the length of the list, so it won't "run away" and blow the stack.
  35 **
  36 **  10/21/93 rdg  Fixed bug -- function was okay, but called incorrectly.
  37 ** linked list sort -- public domain by Ray Gardner  5/90
  38 */
  39
  40 /*
  41    Taken from the code snippet website (sorry no URL)
  42    Functions modified on 98/10/14 by George Clernon (clernong@tinet.ie)
  43    for Workplace.app list type.
  44 */
  45
  46 /* returns < 0 if *p sorts lower than *q */
  47 int keycmp (FileInfo *p, FileInfo *q)
  48 {
  49     if( FSGetIntegerForName("SortOrder") )
  50         return strcasecmp(p->name, q->name);
  51     else
  52         return strcasecmp(q->name, p->name);
  53 }
  54
  55 /* merge 2 lists under dummy head item */
  56 FileInfo *lmerge (FileInfo *p, FileInfo *q)
  57 {
  58     FileInfo *r, head;
  59
  60     for ( r = &head; p && q; )
  61     {
  62         if ( keycmp(p, q) < 0 )
  63         {
  64             r = r->next = p;
  65             p = p->next;
  66         }
  67         else
  68         {
  69             r = r->next = q;
  70             q = q->next;
  71         }
  72     }
  73     r->next = (p ? p : q);
  74
  75     return head.next;
  76 }
  77
  78 /* split list into 2 parts, sort each recursively, merge */
  79 FileInfo *lsort (FileInfo *p)
  80 {
  81     FileInfo *q, *r;
  82
  83     if ( p )
  84     {
  85         q = p;
  86         for ( r = q->next; r && (r = r->next) != NULL; r = r->next )
  87             q = q->next;
  88
  89         r = q->next;
  90         q->next = NULL;
  91
  92         if ( r )
  93             p = lmerge(lsort(r), lsort(p));
  94     }
  95     return p;
  96 }
  97
  98 /* FileInfo *GetDirList(char *path) */
  99 /* { */
 100 /*     char           *fullPath; */
 101 /*     FileInfo       *top; */
 102 /*     FileInfo       *fileList; */
 103 /*     struct dirent  *dirent; */
 104 /*     DIR            *dir; */
 105
 106 /*     fullPath = wexpandpath(path); */
 107
 108 /*     dir = opendir(fullPath); */
 109 /*     if (!dir) */
 110 /*     { */
 111 /*      printf("Unable to open dir: %s\n", path); */
 112 /*      return NULL; */
 113 /*     } */
 114
 115 /*     fileList = (FileInfo *) wmalloc(sizeof(FileInfo)); */
 116 /*     fileList->next = NULL; */
 117 /*     fileList->name = NULL; */
 118 /*     fileList->fileType = NORMAL; */
 119 /*     fileList->imgName = NULL; */
 120 /*     fileList->abbrev = NULL; */
 121 /*     top = fileList; */
 122
 123 /*     dirent = readdir(dir); */
 124 /*     while(dirent)  */
 125 /*     { */
 126 /*      GetFileInfo(fullPath, dirent->d_name, fileList); */
 127
 128 /*      dirent = readdir(dir); */
 129
 130 /*      if(dirent) */
 131 /*      { */
 132 /*          fileList->next = (FileInfo *) wmalloc(sizeof(FileInfo)); */
 133 /*          fileList = fileList->next; */
 134 /*          fileList->next = NULL; */
 135 /*      } */
 136 /*     } */
 137
 138 /*     closedir(dir); */
 139
 140 /*     if(fullPath) */
 141 /*      free(fullPath); */
 142
 143 /*     return lsort(top); */
 144 /* } */
 145
 146 FileInfo *GetDirList(char *path)
 147 {
 148     Bool            mixed    = False;
 149     Bool            dirFirst = False;
 150     char           *fullPath = NULL;
 151     FileInfo       *topDir   = NULL;
 152     FileInfo       *topFile  = NULL;
 153     FileInfo       *dirList  = NULL;
 154     FileInfo       *fileList = NULL;
 155     FileInfo       *fileInfo = NULL;
 156     struct dirent  *dirent   = NULL;
 157     DIR            *dir      = NULL;
 158
 159     fullPath = wexpandpath(path);
 160
 161     dir = opendir(fullPath);
 162     if (!dir)
 163     {
 164 /*      printf("Unable to open dir: %s\n", path); */
 165         return NULL;
 166     }
 167
 168     if(FSGetIntegerForName("SortDisplay") == 0)
 169         mixed = True;
 170     else if(FSGetIntegerForName("SortDisplay") == 2)
 171         dirFirst = True;
 172
 173     while( (dirent = readdir(dir)) != NULL)
 174     {
 175         fileInfo = FSCreateFileInfo();
 176
 177         GetFileInfo(fullPath, dirent->d_name, fileInfo);
 178
 179         if( !mixed && isDirectory(fileInfo->fileType) )
 180         {
 181             if(dirList)
 182             {
 183                 dirList->next = fileInfo;
 184                 dirList = dirList->next;
 185             }
 186             else
 187             {
 188                 dirList = fileInfo;
 189                 topDir  = dirList;
 190             }
 191         }
 192         else
 193         {
 194             if(fileList)
 195             {
 196                 fileList->next = fileInfo;
 197                 fileList = fileList->next;
 198             }
 199             else
 200             {
 201                 fileList = fileInfo;
 202                 topFile  = fileList;
 203             }
 204         }
 205     }
 206
 207     closedir(dir);
 208
 209     if(fullPath)
 210         free(fullPath);
 211
 212     if(topFile)
 213          fileList = lsort(topFile);
 214     if(topDir)
 215         dirList = lsort(topDir);
 216
 217     if(dirFirst)
 218     {
 219         if(dirList)
 220         {
 221             topFile = dirList;
 222             while(dirList->next != NULL)
 223                 dirList = dirList->next;
 224             dirList->next = fileList;
 225         }
 226         else
 227             topFile = fileList;
 228     }
 229     else
 230     {
 231         if(fileList)
 232         {
 233             topFile = fileList;
 234             while(fileList->next != NULL)
 235                 fileList = fileList->next;
 236             fileList->next = dirList;
 237         }
 238         else
 239             topFile = dirList;
 240     }
 241
 242     return topFile;
 243 }
 244
 245 void GetFileInfo(char* path, char *name, FileInfo* fileInfo)
 246 {
 247     struct stat *st;
 248     char        *pathname;
 249     char        *fileName;
 250     char        *dirPath;
 251
 252     st = (struct stat *) wmalloc(sizeof(struct stat));
 253
 254     /* make abosolute pathname */
 255     pathname = (char *) wmalloc(strlen(path)+strlen(name)+1);
 256     strcpy(pathname, path);
 257     pathname = strcat(pathname, name);
 258
 259     /* get  information of a file represented by pathname */
 260     if (stat(pathname, st) == -1)
 261         wwarning(_("%s GetFileInfo %d: Stat Error for %s\n"),
 262                  __FILE__, __LINE__, pathname);
 263
 264     if(strcmp("/", pathname) == 0)
 265     {
 266         fileInfo->fileType = ROOT;
 267         fileName = FSNodeName();
 268     }
 269     else if(strcmp(FSGetHomeDir(), pathname) == 0) {
 270         fileInfo->fileType = HOME;
 271         fileName = (char *) wmalloc(strlen(name)+1);
 272         strcpy(fileName, name);
 273     }
 274     else
 275     {
 276         if(S_ISDIR(st->st_mode))
 277             fileInfo->fileType = DIRECTORY;
 278         else
 279             fileInfo->fileType = NORMAL;
 280
 281         fileName = (char *) wmalloc(strlen(name)+1);
 282         strcpy(fileName, name);
 283     }
 284
 285     dirPath = (char *) wmalloc(strlen(path)+1);
 286     strcpy(dirPath, path);
 287
 288     fileInfo->name = fileName;
 289     fileInfo->path = dirPath;
 290
 291     if(fileInfo->fileType == ROOT)
 292         fileInfo->extn = wstrdup("ROOT");
 293     else
 294         fileInfo->extn = wstrdup(GetFileExtn(fileInfo->name));
 295
 296     fileInfo->imgName = GetFileImgName(GetFileExtn(fileName),
 297                                        fileInfo->fileType);
 298     fileInfo->abbrev = GetFileAbbrev(fileName);
 299
 300
 301     fileInfo->st = st;
 302
 303 /*     if (st) */
 304 /*     { */
 305 /*      free(st); */
 306 /*      st = NULL; */
 307 /*     } */
 308
 309     if(pathname)
 310     {
 311         free(pathname);
 312         pathname = NULL;
 313     }
 314
 315 }
 316
 317 char*
 318 RemoveFileExtension(char* filename)
 319 {
 320     char *tmp;
 321     char *str;
 322     int len;
 323
 324     tmp = strrchr(filename, '.');
 325
 326     len = strlen(filename)-strlen(tmp);
 327
 328     str = (char *) wmalloc(len+1);
 329     strncpy(str, filename, len);
 330     str[len] = '\0';
 331
 332     return str;
 333 }
 334
 335 char *
 336 GetFileExtn(char *filename)
 337 {
 338     char *extn;
 339
 340     if(FSStringMatch("*.tar.gz", filename))
 341         return wstrdup(".tar.gz");
 342
 343     extn = strrchr(filename, '.');
 344
 345     if(extn == NULL)
 346     {
 347 /*      extn = (char *) wmalloc(strlen(filename)+1); */
 348 /*      strcpy(extn, filename); */
 349         extn = wstrdup(filename);
 350     }
 351
 352     return extn;
 353
 354 }
 355
 356 char *GetFileAbbrev(char *fileName)
 357 {
 358     char *abbrev;
 359 /*     int i; */
 360
 361     abbrev = (char *) wmalloc(strlen(fileName)+1);
 362
 363     if (strlen(fileName)>19)
 364     {
 365         strncpy(abbrev, fileName, 16);
 366         abbrev[16] = '\0';
 367         strcat(abbrev, "...");
 368
 369     }
 370     else
 371     {
 372         strcpy(abbrev, fileName);
 373     }
 374
 375     return abbrev;
 376 }
 377
 378 char* GetFileImgName(char *fileName, enum FileType fileType)
 379 {
 380     /*WMPropList* dict, value = NULL;*/
 381     char *extn = NULL;
 382     char *icon = NULL;
 383     char *name = NULL;
 384
 385     /*
 386      * I'm not sure what should happen here
 387      * Cos the event should really arise.
 388      * Need to improve error handling in functions
 389      * that call this one
 390     */
 391     if(fileName == NULL)
 392         return wstrdup(DEFAULT_STR);
 393
 394
 395     if(fileType == ROOT)
 396         extn = wstrdup("ROOT");
 397     else
 398         extn = wstrdup(GetFileExtn(fileName));
 399
 400     name = FSGetStringForNameKey(extn, "icon");
 401
 402     if(name == NULL)
 403     {
 404         if(fileType == DIRECTORY)
 405             name = FSGetStringForName(DIR_STR);
 406         else if(fileType == ROOT)
 407             name = FSGetStringForNameKey(ROOT_STR, "icon");
 408         else if(fileType == HOME)
 409             name = FSGetStringForName(HOME_STR);
 410         else
 411             name = FSGetStringForName(DEFAULT_STR);
 412     }
 413
 414     icon = LocateImage(name);
 415     if(name)
 416         free(name);
 417     if(extn)
 418         free(extn);
 419
 420     if(icon)
 421         return icon;
 422     else
 423         return wstrdup(DEFAULT_STR);
 424
 425 /*     dict = PLGetDictionaryEntry(filesDB, PLMakeString(extn)); */
 426 /*     if(dict && PLIsDictionary(dict)) */
 427 /*     { */
 428 /*      value = PLGetDictionaryEntry(dict, PLMakeString("icon")); */
 429 /*     } */
 430
 431 /*     if(value == NULL) */
 432 /*     { */
 433 /*      if(fileType == DIRECTORY) */
 434 /*          value = PLGetDictionaryEntry(filesDB, PLMakeString(DIR_STR)); */
 435 /*      else if(fileType == ROOT) */
 436 /*          value = PLGetDictionaryEntry(filesDB, PLMakeString(ROOT_STR)); */
 437 /*      else if(fileType == HOME) */
 438 /*          value = PLGetDictionaryEntry(filesDB, PLMakeString(HOME_STR)); */
 439 /*      else */
 440 /*      { */
 441 /*          value = PLGetDictionaryEntry(filesDB, PLMakeString(DEFAULT_STR)); */
 442 /*      } */
 443 /*     }             */
 444
 445 /*     if(extn) */
 446 /*      free(extn); */
 447
 448      /* No Icons at all!! */
 449 /*     if(value == NULL) */
 450 /*     { */
 451 /*      return DEFAULT_STR; */
 452 /*     } */
 453
 454 /*     return PLGetString(value); */
 455
 456 }
 457
 458 char*
 459 GetNameFromPathname(char* pathname)
 460 {
 461     char *str;
 462
 463     str = strrchr(pathname, '/');
 464     str++;
 465
 466     return wstrdup(str);
 467 }
 468
 469 char* GetPathFromPathname(char* pathname)
 470 {
 471     int lenTot;
 472     int lenName;
 473     int lenPath;
 474     char *path;
 475
 476     lenTot = strlen(pathname);
 477     lenName = strlen(GetNameFromPathname(pathname));
 478     lenPath = lenTot - lenName;
 479
 480     path = (char *) wmalloc(lenPath+1);
 481     strncpy(path, pathname, lenPath);
 482     path[lenPath] = '\0';
 483
 484     return path;
 485 }
 486
 487 char* GetPathnameFromPathName(char* path, char *name)
 488 {
 489     int len;
 490     char *pathname;
 491
 492     len = strlen(GetNameFromPathname(path));
 493     if(len)
 494     {
 495         pathname = (char *)wmalloc(strlen(path)+strlen(name)+2);
 496         strcpy(pathname, path);
 497         strcat(pathname, "/");
 498         strcat(pathname, name);
 499     }
 500     else
 501     {
 502         pathname = (char *)wmalloc(strlen(path)+strlen(name)+1);
 503         strcpy(pathname, path);
 504         strcat(pathname, name);
 505     }
 506
 507     return pathname;
 508 }
 509
 510 Bool isDirectory(enum FileType fileType)
 511 {
 512
 513     if(fileType == DIRECTORY || fileType == ROOT || fileType == HOME)
 514         return True;
 515
 516     return False;
 517 }
 518
 519 Bool
 520 DisplayFile(char *str, char *filter, FileType fileType)
 521 {
 522
 523 /*     if(str[0] != '.') */
 524 /*     { */
 525 /*      return True; */
 526 /*     } */
 527 /*     else if(DISPLAY_HIDDEN_FILES) */
 528 /*     { */
 529 /*      if(str[1] != '.' && str[1] != '\0') */
 530 /*          return True; */
 531 /*     } */
 532
 533 /*     return False; */
 534
 535
 536     if( !strcmp(".", str) || !strcmp("..", str) )
 537         return False;
 538     else if( filter && !isDirectory(fileType) )
 539         if( !FSStringMatch(filter, str) )
 540             return False;
 541
 542     if( str[0] == '.' )
 543         return FSGetIntegerForName("DisplayDotFiles");/* DISPLAY_HIDDEN_FILES; */
 544
 545     return True;
 546 }
 547
 548 void
 549 FSToggleDisplayHiddenFiles()
 550 {
 551 /*     DISPLAY_HIDDEN_FILES = !DISPLAY_HIDDEN_FILES; */
 552 /*    if( FSGetIntegerForName("DisplayDotFiles") )
 553         FSSetIntegerForName("DisplayDotFiles", 0);
 554     else
 555         FSSetIntegerForName("DisplayDotFiles", 1);*/
 556   FSSetIntegerForName("DisplayDotFiles",
 557     !FSGetIntegerForName("DisplayDotFiles"));
 558 }
 559
 560 void
 561 FSToggleSort()
 562 {
 563 /*     SORT_TOGGLE = !SORT_TOGGLE; */
 564 /*    if( FSGetIntegerForName("SortOrder") )
 565         FSSetIntegerForName("SortOrder", 0);
 566     else
 567         FSSetIntegerForName("SortOrder", 1);*/
 568   FSSetIntegerForName("SortOrder",
 569     !FSGetIntegerForName("SortOrder"));
 570 }
 571
 572 FileInfo *
 573 FSCreateFileInfo()
 574 {
 575
 576     FileInfo *fileInfo;
 577
 578     fileInfo = (FileInfo *) wmalloc(sizeof(FileInfo));
 579     memset(fileInfo, 0, sizeof(FileInfo));
 580 /*     fileInfo->next = NULL; */
 581 /*     fileInfo->name = NULL; */
 582 /*     fileInfo->path = NULL; */
 583     fileInfo->fileType = NORMAL;
 584     fileInfo->imgName  = GetFileImgName(NULL_STR, NORMAL);
 585 /*     fileInfo->abbrev = NULL; */
 586 /*     fileInfo->extn   = NULL; */
 587 /*     fileInfo->st     = NULL; */
 588
 589     return fileInfo;
 590
 591 }
 592
 593
 594 void
 595 FSCopyFileInfo(FileInfo *src, FileInfo *dest)
 596 {
 597
 598     if(src == NULL || dest == NULL)
 599         return;
 600
 601     if(src->name)
 602     {
 603         dest->name = (char *) wrealloc(dest->name, strlen(src->name)+1);
 604         strcpy(dest->name, src->name);
 605     }
 606     else
 607         dest->name = NULL;
 608
 609     if(src->path)
 610     {
 611         dest->path =(char *) wrealloc(dest->path, strlen(src->path)+1);
 612         strcpy(dest->path, src->path);
 613     }
 614     else
 615         dest->path = NULL;
 616
 617     if(src->extn)
 618     {
 619         dest->extn = (char *) wrealloc(dest->extn, strlen(src->extn)+1);
 620         strcpy(dest->extn, src->extn);
 621     }
 622     else
 623         dest->extn = NULL;
 624
 625     if(src->abbrev)
 626     {
 627         dest->abbrev = (char *) wrealloc(dest->abbrev, strlen(src->abbrev)+1);
 628         strcpy(dest->abbrev, src->abbrev);
 629     }
 630     else
 631         dest->abbrev = NULL;
 632
 633     if(src->imgName)
 634     {
 635         dest->imgName = (char*)wrealloc(dest->imgName, strlen(src->imgName)+1);
 636         strcpy(dest->imgName, src->imgName);
 637     }
 638     else
 639         dest->imgName = NULL;
 640
 641     dest->fileType = src->fileType;
 642
 643     /*
 644      * Not sure if I really want to do this!!!
 645      * It should be done though, I think I'll call back later
 646      */
 647 /*     if(src->next) */
 648 /*     { */
 649 /*      dest->next = FSCreateFileInfo(); */
 650 /*      FSCopyFileInfo(src->next, dest->next); */
 651 /*     } */
 652 }
 653
 654
 655 void
 656 FSFreeFileInfo(FileInfo *fileInfo)
 657 {
 658     if(!fileInfo)
 659         return;
 660
 661     if(fileInfo->name)
 662     {
 663         free(fileInfo->name);
 664         fileInfo->name = NULL;
 665     }
 666     if(fileInfo->path)
 667     {
 668         free(fileInfo->path);
 669         fileInfo->path = NULL;
 670     }
 671     if(fileInfo->imgName)
 672     {
 673         free(fileInfo->imgName);
 674         fileInfo->imgName = NULL;
 675     }
 676     if(fileInfo->extn)
 677     {
 678         free(fileInfo->extn);
 679         fileInfo->extn = NULL;
 680     }
 681     if(fileInfo->abbrev)
 682     {
 683         free(fileInfo->abbrev);
 684         fileInfo->abbrev = NULL;
 685     }
 686     if (fileInfo->st)
 687     {
 688         free(fileInfo->st);
 689         fileInfo->st = NULL;
 690     }
 691
 692     if(fileInfo->next)
 693         FSFreeFileInfo(fileInfo->next);
 694
 695     free(fileInfo);
 696     fileInfo = NULL;
 697 }
 698
 699 /* check whether a file exists */
 700 int
 701 FSFileExists(char *path)
 702 {
 703   struct stat stats;
 704
 705   return (!lstat(path, &stats));
 706 }
 707
 708 FileInfo *
 709 FSGetFileInfo(char* pathname)
 710 {
 711     char *path;
 712     char *name;
 713     FileInfo *fileInfo = FSCreateFileInfo();
 714
 715     name = GetNameFromPathname(pathname);
 716     path = GetPathFromPathname(pathname);
 717
 718     GetFileInfo(path, name, fileInfo);
 719
 720     return fileInfo;
 721 }
 722
 723 /* create a new directory */
 724 int
 725 FSCreateNewFile(char *path, mode_t mode)
 726 {
 727     int file = open(path, O_WRONLY|O_CREAT|O_EXCL, mode);
 728
 729     if (file == -1 || close(file))
 730         return -1;
 731     else
 732         return 0;
 733 }
 734
 735 /* create a new file */
 736 int
 737 FSCreateNewDirectory(char *path, mode_t mode)
 738 {
 739     return mkdir(path, mode);
 740
 741 /*     if (mkdir(path, mode))  */
 742 /*     { */
 743 /*      char s[0xff]; */
 744
 745 /*      sprintf(s, "Error creating folder %s:", path); */
 746 /*      FSErrorDialog("File Operation Error", s); */
 747 /*     } */
 748 }
 749
 750 /*-------------------------------------------------------------------------*/
 751
 752 /* recursive copy operation */
 753
 754 int
 755 FSRCopy(char *oldpath, char *newpath)
 756 {
 757     return copy((ino_t *)NULL, 0, oldpath, newpath);
 758 }
 759
 760 static int
 761 copyfile(char *oldpath, char *newpath)
 762 {
 763     struct stat stats;
 764     int src = -1, dest = -1, n, errno_ret;
 765     char buf[BUFSIZ];
 766
 767     if ((src = open(oldpath, O_RDONLY)) == -1 || stat(oldpath, &stats))
 768         goto err;
 769     else if ((dest = creat(newpath, stats.st_mode)) == -1)
 770         goto err;
 771
 772     while ( (n = read(src, buf, BUFSIZ)) != 0)
 773         if ( n == -1 || write(dest, buf, n) != n )
 774             goto err;
 775
 776     if (close(src))
 777     {
 778         src = -1;
 779         goto err;
 780     }
 781     else
 782         return close(dest);
 783
 784  err:
 785     errno_ret = errno;
 786     if (src != -1) close(src);
 787     if (dest != -1) close(dest);
 788     errno = errno_ret;
 789     return -1;
 790 }
 791
 792 static int
 793 copydir(ino_t *inodes, int n_inodes, struct stat *oldstats,
 794         char *oldpath, char *newpath)
 795 {
 796     DIR *dir;
 797     struct dirent *entry;
 798     int i, ol = strlen(oldpath), nl = strlen(newpath);
 799     struct stat newstats;
 800     mode_t umask = FSGetUMask();
 801
 802     for (i = n_inodes-1; i >= 0; i--)
 803         if (inodes[i] == oldstats->st_ino)
 804         {
 805             errno = EINVAL;
 806             return -1;
 807         }
 808
 809     if ((mkdir(newpath, umask & 0777) < 0 && errno != EEXIST) ||
 810         lstat(newpath, &newstats) ||
 811         !(dir = opendir(oldpath)))
 812         return -1;
 813
 814     inodes = (ino_t *) wrealloc(inodes, (n_inodes+1)*sizeof(ino_t));
 815     inodes[n_inodes++] = newstats.st_ino;
 816
 817     for(i = 0; (entry = readdir(dir)); i++)
 818         if (entry->d_name[0] != '.' || (entry->d_name[1] != '\0'
 819                                         && (entry->d_name[1] != '.' ||
 820                                             entry->d_name[2] != '\0')))
 821         {
 822             int ol1 = ol, nl1 = nl, l = strlen(entry->d_name);
 823             char *oldpath1 = (char *)alloca(ol1+l+2);
 824             char *newpath1 = (char *)alloca(nl1+l+2);
 825
 826             strcpy(oldpath1, oldpath);
 827             strcpy(newpath1, newpath);
 828             if (oldpath1[ol1-1] != '/')
 829                 oldpath1[ol1++] = '/';
 830             if (newpath1[nl1-1] != '/')
 831                 newpath1[nl1++] = '/';
 832             strcpy(oldpath1+ol1, entry->d_name);
 833             strcpy(newpath1+nl1, entry->d_name);
 834             if (copy(inodes, n_inodes, oldpath1, newpath1))
 835             {
 836                 /* take care of recursive errors */
 837                 char s[0xff];
 838                 sprintf(s, _("Error copying %s:"), oldpath1);
 839                 FSErrorDialog(_("File Operation Error"), s);
 840             }
 841         }
 842
 843     inodes = (ino_t *) wrealloc(inodes, (n_inodes-1)*sizeof(ino_t));
 844     return closedir(dir);
 845 }
 846
 847 static int
 848 copy(ino_t *inodes, int n_inodes, char *oldpath, char *newpath)
 849 {
 850     struct stat stats;
 851     mode_t umask = FSGetUMask();
 852
 853     if (lstat(oldpath, &stats))
 854         return -1;
 855
 856     /* Directory: copy recursively */
 857     if (S_ISDIR(stats.st_mode))
 858         return copydir(inodes, n_inodes, &stats, oldpath, newpath);
 859
 860     /* Regular file: copy block by block */
 861     else if (S_ISREG(stats.st_mode))
 862         return copyfile(oldpath, newpath);
 863
 864     /* Fifo: make a new one */
 865     else if (S_ISFIFO(stats.st_mode))
 866         return mkfifo(newpath, umask & 0666);
 867
 868     /* Device: make a new one */
 869     else if (S_ISBLK(stats.st_mode) || S_ISCHR(stats.st_mode) ||
 870              S_ISSOCK(stats.st_mode))
 871         return mknod(newpath, umask & 0666, stats.st_rdev);
 872
 873     /* Symbolic link: make a new one */
 874     else if (S_ISLNK(stats.st_mode))
 875     {
 876         char lnk[MAX_LEN+1];
 877         int l = readlink(oldpath, lnk, MAX_LEN);
 878
 879         if (l<0)
 880             return -1;
 881         lnk[l] = '\0';
 882         return(symlink(lnk, newpath));
 883     }
 884
 885     /* This shouldn't happen */
 886     else
 887     {
 888         char s[0xff];
 889         sprintf(s, _("Unrecognized File type: %s"), oldpath);
 890         FSErrorDialog(_("File Operation Error"), s);
 891
 892         return 0;
 893     }
 894 }
 895
 896 /*-------------------------------------------------------------------------*/
 897
 898 /* recursive delete */
 899
 900 int
 901 FSRDel(char *path)
 902 {
 903     struct stat stats;
 904
 905     if (lstat(path, &stats))
 906         return -1;
 907
 908     if (S_ISDIR(stats.st_mode))
 909     {
 910         DIR *dir;
 911         struct dirent *entry;
 912         int i, pl = strlen(path);
 913
 914         if (!(dir = opendir(path)))
 915             return -1;
 916
 917         for(i = 0; (entry = readdir(dir)); i++)
 918             if (entry->d_name[0] != '.' || (entry->d_name[1] != '\0'
 919                                             && (entry->d_name[1] != '.' ||
 920                                                 entry->d_name[2] != '\0')))
 921             {
 922                 int pl1 = pl, l = strlen(entry->d_name);
 923                 char *path1 = (char *)alloca(pl1+l+2);
 924
 925                 strcpy(path1, path);
 926                 if (path1[pl1-1] != '/')
 927                     path1[pl1++] = '/';
 928                 strcpy(path1+pl1, entry->d_name);
 929                 if (FSRDel(path1)) {
 930                     /* take care of recursive errors */
 931                     char s[0xff];
 932                     sprintf(s, _("Error deleting %s:"), path);
 933                     FSErrorDialog(_("File Operation Error"), s);
 934                 }
 935             }
 936
 937         if (closedir(dir))
 938             return -1;
 939         else
 940             return rmdir(path);
 941     }
 942     else
 943         return unlink(path);
 944 }
 945
 946 void
 947 FSCopy(FileInfo *src, FileInfo *dest)
 948 {
 949     struct stat stats;
 950     int i, toi, n_copied = 0;
 951     char *from = NULL;
 952     char to[MAX_LEN];
 953
 954     from  = GetPathnameFromPathName(src->path, src->name);
 955     strcpy(to, GetPathnameFromPathName(dest->path, dest->name));
 956
 957     if (access(to, W_OK) && isDirectory(dest->fileType))
 958     {
 959         char s[0xff];
 960
 961         sprintf(s, _("No write access to %s"), to);
 962         FSErrorDialog(_("File Operation Error"), s);
 963         if(from)
 964             free(from);
 965         return;
 966     }
 967
 968     /*
 969        if target exists and is a directory, copy the source
 970        into that directory
 971     */
 972     if(!stat(to, &stats) && S_ISDIR(stats.st_mode))
 973     {
 974         if (!strcmp(from, to))
 975         {
 976             FSErrorDialog(_("File Operation Error"),
 977                           _("Copy: Source and destination are identical"));
 978             if(from)
 979                 free(from);
 980             return;
 981         }
 982
 983         toi = strlen(to);
 984         if(to[toi-1] != '/')
 985         {
 986             to[toi++] = '/';
 987             to[toi] = '\0';
 988         }
 989
 990         /*
 991           Should do a loop here that goes through each element
 992           of the FileInfo list, checks and copies it
 993         */
 994         strcpy(to+toi, src->name);
 995         if(FSFileExists(to) /* && resources.confirm_overwrite */)
 996         {
 997             char s[0xff];
 998             sprintf(s, _("Copy: file %s already exists at destination"),
 999                     src->name);
1000             if(FSConfirmationDialog(_("Overwrite?"), s))
1001             {
1002                 if(from)
1003                     free(from);
1004                 return;
1005             }
1006         }
1007
1008         if(FSRCopy(from, to))
1009         {
1010             char s[0xff];
1011             sprintf(s, _("Error copying %s:"), from);
1012             FSErrorDialog(_("File Operation Error"), s);
1013         }
1014         else
1015             n_copied++;
1016
1017     }
1018     /*
1019        otherwise only a single file may be selected;
1020        copy it to the target file
1021     */
1022 /*     else if (popups.fw->n_selections > 1)  */
1023 /*     { */
1024 /*      error("Copy: target for multiple files", "must be a folder"); */
1025 /*      goto out; */
1026 /*     }  */
1027     else
1028     {
1029         struct stat stats1;
1030
1031         if(!stat(from, &stats1) && S_ISDIR(stats1.st_mode))
1032         {
1033             FSErrorDialog(_("File Operation Error"),
1034                           _("Cannot copy a directory to a file"));
1035             if(from)
1036                 free(from);
1037             return;
1038         }
1039
1040         if (!lstat(to, &stats) && !lstat(from, &stats1) &&
1041             stats.st_ino == stats1.st_ino)
1042         {
1043             FSErrorDialog(_("File Operation Error"),
1044                           _("Copy: Source and destination are identical"));
1045             if(from)
1046                 free(from);
1047             return;
1048         }
1049
1050         if (FSFileExists(to) /* && resources.confirm_overwrite */)
1051         {
1052             char s[0xff];
1053             sprintf(s, _("Copy: file %s already exists"), to);
1054             if(FSConfirmationDialog(_("Overwrite?"), s))
1055             {
1056                 if(from)
1057                     free(from);
1058                 return;
1059             }
1060         }
1061
1062         if (FSRCopy(from, to))
1063         {
1064             char s[0xff];
1065             sprintf(s, _("Error copying %s:"), from);
1066             FSErrorDialog(_("File Operation Error"), s);
1067         }
1068         else
1069             n_copied = 1;
1070
1071     }
1072     if (n_copied)
1073         FSUpdateFileView(FileCopy, src, dest);
1074
1075     if(from)
1076         free(from);
1077 }
1078
1079 void
1080 FSDelete(FileInfo *item)
1081 {
1082     char s[0xff];
1083     char *itemName;
1084     int i, n_deleted = 0;
1085
1086     itemName = GetPathnameFromPathName(item->path, item->name);
1087
1088     if (isDirectory(item->fileType))
1089         if (!strcmp(item->name, ".") || !strcmp(item->name, ".."))
1090         {
1091           FSErrorDialog(_("File Operation Error"), _("Cannot delete . or .."));
1092           if(itemName)
1093               free(itemName);
1094           return;
1095         }
1096     /*       else if (resources.confirm_delete_folder) */
1097     /*       { */
1098
1099 /*     sprintf(s, "Do you REALLY wish to delete folder %s"\ */
1100 /*          "and ALL items contained in it?", itemName); */
1101
1102     sprintf(s, _("Do you REALLY wish to delete %s"), itemName);
1103
1104     if(FSConfirmationDialog(_("File Operation"), s))
1105     {
1106         if(itemName)
1107             free(itemName);
1108         return;
1109     }
1110 /*       } */
1111
1112     if (FSRDel(itemName))
1113     {
1114         sprintf(s, _("Error deleting %s:"), itemName);
1115         FSErrorDialog(_("File Operation Error"), s);
1116     }
1117     else
1118         n_deleted++;
1119
1120     if(n_deleted)
1121         FSUpdateFileView(FileDelete, item, NULL);
1122
1123     if(itemName)
1124         free(itemName);
1125 }
1126
1127 void
1128 FSMove(FileInfo *src, FileInfo *dest)
1129 {
1130     struct stat stats;
1131     int i, toi, n_moved = 0;
1132     char *from = NULL;
1133     char to[MAX_LEN];
1134
1135     from  = GetPathnameFromPathName(src->path, src->name);
1136     strcpy(to, GetPathnameFromPathName(dest->path, dest->name));
1137
1138     if(access(to, W_OK) && isDirectory(dest->fileType))
1139     {
1140         char s[0xff];
1141
1142         sprintf(s, _("No write access to %s"), to);
1143         FSErrorDialog(_("File Operation Error"), s);
1144         if(from)
1145             free(from);
1146         return;
1147     }
1148
1149     /*
1150        if target exists and is a directory, move the source
1151        into that directory
1152     */
1153     if(!stat(to, &stats) && S_ISDIR(stats.st_mode))
1154     {
1155         if (!strcmp(from, to))
1156         {
1157             FSErrorDialog(_("File Operation Error"),
1158                           _("Move: Source and destination are identical"));
1159             if(from)
1160                 free(from);
1161             return;
1162         }
1163
1164         toi = strlen(to);
1165         if(to[toi-1] != '/')
1166         {
1167             to[toi++] = '/';
1168             to[toi] = '\0';
1169         }
1170
1171         /*
1172           Should do a loop here that goes through each element
1173           of the FileInfo list, checks and moves it
1174         */
1175         strcpy(to+toi, src->name);
1176         if(FSFileExists(to) /* && resources.confirm_overwrite */)
1177         {
1178             char s[0xff];
1179             sprintf(s, _("Move: file %s already exists at destination"),
1180                     src->name);
1181             if(FSConfirmationDialog(_("Overwrite?"), s))
1182             {
1183                 if(from)
1184                     free(from);
1185             }
1186                 return;
1187         }
1188
1189         if(rename(from, to))
1190         {
1191             char s[0xff];
1192             sprintf(s, _("Error copying %s:"), from);
1193             FSErrorDialog(_("File Operation Error"), s);
1194             if(from)
1195                 free(from);
1196         }
1197         else
1198             n_moved++;
1199     }
1200     /*
1201        otherwise only a single file may be selected;
1202        copy it to the target file
1203     */
1204 /*     else if (popups.fw->n_selections > 1)  */
1205 /*     { */
1206 /*      error("Copy: target for multiple files", "must be a folder"); */
1207 /*      goto out; */
1208 /*     }  */
1209     else
1210     {
1211         struct stat stats1;
1212
1213         if(!stat(from, &stats1) && S_ISDIR(stats1.st_mode))
1214         {
1215             FSErrorDialog(_("File Operation Error"),
1216                           _("Cannot move a directory to a file"));
1217             if(from)
1218                 free(from);
1219             return;
1220         }
1221
1222         if (!lstat(to, &stats) && !lstat(from, &stats1) &&
1223             stats.st_ino == stats1.st_ino)
1224         {
1225             FSErrorDialog(_("File Operation Error"),
1226                           _("Move: Source and destination are identical"));
1227             if(from)
1228                 free(from);
1229             return;
1230         }
1231
1232         if (FSFileExists(to) /* && resources.confirm_overwrite */)
1233         {
1234             char s[0xff];
1235             sprintf(s, _("Move: file %s already exists"), to);
1236             if(FSConfirmationDialog(_("Overwrite?"), s))
1237             {
1238                 if(from)
1239                     free(from);
1240                 return;
1241             }
1242         }
1243
1244         if (rename(from, to))
1245         {
1246             char s[0xff];
1247             sprintf(s, _("Error renaming %s:"), from);
1248             FSErrorDialog(_("File Operation Error"), s);
1249         }
1250         else
1251             n_moved = 1;
1252     }
1253
1254     if (n_moved)
1255         FSUpdateFileView(FileMove, src, dest);
1256
1257     if(from)
1258         free(from);
1259 }
1260
1261 void
1262 FSRename(FileInfo *src, FileInfo *dest)
1263 {
1264     struct stat stats;
1265     struct stat stats1;
1266     int i, toi, n_renamed = 0;
1267     char *from = NULL;
1268     char *to = NULL;
1269
1270     from  = GetPathnameFromPathName(src->path, src->name);
1271     to    = GetPathnameFromPathName(dest->path, dest->name);
1272
1273
1274     if (!lstat(to, &stats) && !lstat(from, &stats1) &&
1275         stats.st_ino == stats1.st_ino)
1276     {
1277         FSErrorDialog(_("File Operation Error"),
1278                       _("Rename: Source and destination are identical"));
1279         if(from)
1280             free(from);
1281         if(to)
1282             free(to);
1283         return;
1284     }
1285
1286     if (FSFileExists(to) /* && resources.confirm_overwrite */)
1287     {
1288         char s[0xff];
1289         sprintf(s, _("Rename: file %s already exists"), to);
1290         if(FSConfirmationDialog(_("Overwrite?"), s))
1291         {
1292             if(from)
1293                 free(from);
1294             if(to)
1295                 free(to);
1296             return;
1297         }
1298     }
1299
1300     if (rename(from, to))
1301     {
1302         char s[0xff];
1303         sprintf(s, _("Error renaming %s:"), from);
1304         FSErrorDialog(_("File Operation Error"), s);
1305     }
1306     else
1307         n_renamed = 1;
1308
1309     if (n_renamed)
1310         FSUpdateFileView(FileRename, src, dest);
1311
1312     if(from)
1313         free(from);
1314     if(to)
1315         free(to);
1316 }
1317
1318 void
1319 FSLink(FileInfo *src, FileInfo *dest)
1320 {
1321     struct stat stats;
1322     int i, toi, n_linked = 0;
1323     char *from = NULL;
1324     char *to   = NULL;
1325
1326     from  = GetPathnameFromPathName(src->path, src->name);
1327     to = GetPathnameFromPathName(dest->path, dest->name);
1328
1329     /*
1330        if target exists and is a directory,
1331        link the source into that directory
1332     */
1333     if(!stat(to, &stats) && S_ISDIR(stats.st_mode))
1334     {
1335         if (!strcmp(from, to))
1336         {
1337             FSErrorDialog(_("File Operation Error"),
1338                           _("Copy: Source and destination are identical"));
1339             if(from)
1340                 free(from);
1341             if(to)
1342                 free(to);
1343             return;
1344         }
1345
1346         toi = strlen(to);
1347         if(to[toi-1] != '/')
1348         {
1349             to[toi++] = '/';
1350             to[toi] = '\0';
1351         }
1352
1353         /*
1354           Should do a loop here that goes through each element
1355           of the FileInfo list, checks and copies it
1356         */
1357         strcpy(to+toi, src->name);
1358         if(FSFileExists(to) /* && resources.confirm_overwrite */)
1359         {
1360             char s[0xff];
1361             sprintf(s, _("Link: file %s already exists at destination"),
1362                     src->name);
1363             if(FSConfirmationDialog(_("Overwrite?"), s))
1364             {
1365                 if(from)
1366                     free(from);
1367                 if(to)
1368                     free(to);
1369                 return;
1370             }
1371         }
1372
1373         if (symlink(from,to))
1374         {
1375             char s[0xff];
1376             sprintf(s, _("Error linking %s to %s"), from, to);
1377             FSErrorDialog(_("File Operation Error"), s);
1378         }
1379         else
1380             n_linked++;
1381     }
1382     /* otherwise only a single file may be selected;
1383        link it to the target file */
1384 /*     else if (popups.fw->n_selections > 1) { */
1385
1386 /*       error("Link: target for multiple files", "must be a folder"); */
1387 /*       goto out; */
1388
1389 /*     } */
1390     else
1391     {
1392         struct stat stats1;
1393
1394         if (!lstat(to, &stats) && !lstat(from, &stats1) &&
1395             stats.st_ino == stats1.st_ino)
1396         {
1397             FSErrorDialog(_("File Operation Error"),
1398                           _("Link: Source and destination are identical"));
1399             if(from)
1400                 free(from);
1401             if(to)
1402                 free(to);
1403             return;
1404         }
1405
1406         if (FSFileExists(to) /* && resources.confirm_overwrite */)
1407         {
1408             char s[0xff];
1409             sprintf(s, _("Link: file %s already exists"), to);
1410             if(FSConfirmationDialog(_("Overwrite?"), s))
1411             {
1412                 if(from)
1413                     free(from);
1414                 if(to)
1415                     free(to);
1416                 return;
1417             }
1418         }
1419
1420         if(symlink(from,to))
1421         {
1422             char s[0xff];
1423             sprintf(s, _("Error linking %s to %s"), from, to);
1424             FSErrorDialog(_("File Operation Error"), s);
1425         }
1426         else
1427             n_linked = 1;
1428     }
1429
1430     if (n_linked)
1431         FSUpdateFileView(FileLink, src, dest);
1432
1433     if(from)
1434         free(from);
1435     if(to)
1436         free(to);
1437
1438 }