vpdf/system/directory.c

   1
   2 #define AROS_ALMOST_COMPATIBLE
   3
   4
   5 #include <exec/lists.h>
   6 #include <exec/types.h>
   7 #include <proto/dos.h>
   8 #include <proto/utility.h>
   9 #include <proto/intuition.h>
  10 #include <private/vapor/vapor.h>
  11
  12 #include "directory.h"
  13 #include "dlist.h"
  14 #include "functions.h"
  15 #include "util.h"
  16
  17 #include <stdio.h>
  18 #include <stdlib.h>
  19
  20 /*
  21  * Helper functions
  22  */
  23
  24 char *directoryGetNodeName(struct directory *dir, struct directorynode *node)
  25 {
  26         char *name = NULL;
  27
  28         if (dir != NULL && node != NULL)
  29         {
  30                 int l = strlen(dir->basename) + 1 + strlen(node->name) + 1;
  31
  32                 name = malloc(l);
  33
  34                 if (name != NULL)
  35                 {
  36                         strcpy(name, dir->basename);
  37                         AddPart(name, node->name, l);
  38                 }
  39         }
  40
  41         return name;
  42 }
  43
  44 void directoryFreeNodeName(char *name)
  45 {
  46         free(name);
  47 }
  48
  49 struct directorynode *directoryFindNode(struct directory *dir, char *name)
  50 {
  51         struct directorynode *n;
  52
  53         if (name[ strlen(name) - 1 ] == '/')
  54         {
  55                 name[ strlen(name) - 1 ] = 0;
  56         }
  57
  58         if (FilePart(name) != NULL && strlen(FilePart(name)) > 0)
  59                 name = FilePart(name);
  60
  61
  62         ITERATELIST(n, &dir->list)
  63         {
  64                 if (0 == stricmp(n->name, name))
  65                         return n;
  66         }
  67
  68         return NULL;
  69
  70 }
  71
  72
  73 char *directoryGetParentName(char *dir)
  74 {
  75         char path[ 1024 ];
  76         char *newpath = NULL;
  77         BPTR lock;
  78
  79         if (dir == NULL || strlen(dir) == 0)
  80                 return NULL;
  81
  82         strncpy(path, dir, sizeof(path));
  83
  84         lock = Lock(path, ACCESS_READ);
  85
  86         if (lock)
  87         {
  88                 /* we are in a valid path. use the "good" way */
  89
  90                 BPTR parentLock = ParentDir(lock);
  91                 UnLock(lock);
  92
  93                 if (parentLock && NameFromLock(parentLock, path, sizeof(path)))
  94                 {
  95                         newpath = strdup(path);
  96                 }
  97
  98                 if (parentLock)
  99                         UnLock(parentLock);
 100         }
 101         else
 102         {
 103                 /* we are in some strange path. try to find parent ourself */
 104
 105                 if (strlen(path))
 106                 {
 107                         char *prevPath;
 108
 109                         if (path[ strlen(path) - 1 ] == '/')
 110                         {
 111                                 path[ strlen(path) - 1 ] = 0;
 112                         }
 113
 114                         prevPath = PathPart(path);
 115
 116                         path[ prevPath - path ] = 0;
 117
 118                         newpath = strdup(path);
 119
 120                 }
 121         }
 122
 123         return newpath;
 124 }
 125
 126 /*
 127  * Sort directory tree (single level!).
 128  */
 129
 130 static int dirnodecompare(struct MinNode *n1, struct MinNode *n2)
 131 {
 132         struct directorynode *dn1 = (struct directorynode*)n1;
 133         struct directorynode *dn2 = (struct directorynode*)n2;
 134
 135         if ((dn1->dir && dn2->dir) || (!dn1->dir && !dn2->dir) )
 136         {
 137                 return stricmp(dn1->name, dn2->name);
 138         }
 139         else
 140         {
 141                 if (dn1->dir && !dn2->dir)
 142                         return -1;
 143                 else
 144                         return 1;
 145         }
 146 }
 147
 148 static void directorySort(struct directory *dir)
 149 {
 150         mergesortlist(&dir->list, dirnodecompare);
 151 }
 152
 153
 154 /*
 155  * Scan directory tree.
 156  */
 157
 158 struct directory *directoryScan(const char *path, int flags)
 159 {
 160         BPTR dirLock = Lock(path, ACCESS_READ);
 161         struct FileInfoBlock fib;
 162         struct directory *directory = malloc(sizeof(struct directory) + strlen(path) + 1);
 163
 164         if (dirLock == NULL || directory == NULL)
 165         {
 166                 free(directory);
 167
 168                 if (dirLock)
 169                         UnLock(dirLock);
 170
 171                 return NULL;
 172         }
 173
 174         NEWLIST(&directory->list);
 175         strcpy(directory->basename, path);
 176
 177         if (Examine(dirLock, &fib))
 178         {
 179                 if (isDir(&fib))
 180                 {
 181                         /* fine. we can start examining the entries */
 182
 183                         while(ExNext(dirLock, &fib))
 184                         {
 185                                 /* build new name node */
 186
 187                                 struct directorynode *n = malloc(sizeof(struct directorynode) + strlen(fib.fib_FileName) + 1);
 188
 189                                 if (n)
 190                                 {
 191                                         strcpy(n->name, fib.fib_FileName);
 192                                         n->dir = isDir(&fib);
 193                                         n->subdir = NULL;
 194
 195                                         if (n->dir && (flags & DIRECTORY_SCAN_RECURSIVE))
 196                                         {
 197                                                 char *fullpath = directoryGetNodeName(directory, n);
 198
 199                                                 if (fullpath)
 200                                                 {
 201                                                         n->subdir = directoryScan(fullpath, flags);
 202                                                         directoryFreeNodeName(fullpath);
 203                                                 }
 204                                         }
 205
 206                                         ADDTAIL(&directory->list, n);
 207
 208                                 }
 209                         }
 210                 }
 211
 212                 UnLock(dirLock);
 213
 214         }
 215
 216         if (flags & DIRECTORY_SORT)
 217                 directorySort(directory);
 218
 219         /*
 220          * Debug dump.
 221          */
 222
 223         if (0)
 224         {
 225                 struct directorynode *n;
 226
 227
 228                 printf("Contents of: <%s>\n", directory->basename);
 229
 230                 ITERATELIST(n, &directory->list)
 231                 {
 232                         printf("<%s>\n", n->name);
 233                 }
 234         }
 235
 236         return  directory;
 237 }
 238
 239 DirectoryTraverseResult directoryTraverse(const char *path, int flags, DirectoryTraverseResult (*callback)(struct FileInfoBlock *fib, char *path, int level, void *data), void *data)
 240 {
 241         if (flags & DIRECTORY_SORT)
 242         {
 243                 int rc = DIRECTORY_TRAVERSE_CONTINUE;
 244                 struct directory *directory = directoryScan(path, DIRECTORY_SORT);
 245
 246                 if (directory != NULL)
 247                 {
 248                         struct directorynode *n;
 249
 250                         ITERATELIST(n, &directory->list)
 251                         {
 252                                 char *fullpath = directoryGetNodeName(directory, n);
 253                                 if (fullpath != NULL)
 254                                 {
 255                                         if (n->dir == FALSE)
 256                                                 rc = callback(NULL, fullpath, 0, data);
 257                                         else if (flags & DIRECTORY_SCAN_RECURSIVE)
 258                                                 rc = directoryTraverse(fullpath, flags, callback, data);
 259
 260                                         directoryFreeNodeName(fullpath);
 261                                 }
 262                                 else
 263                                 {
 264                                         rc = DIRECTORY_TRAVERSE_ERROR;
 265                                         break;
 266                                 }
 267
 268                                 if (rc != DIRECTORY_TRAVERSE_CONTINUE)
 269                                         break;
 270                         }
 271
 272                         directoryFree(directory);
 273
 274                 }
 275                 else
 276                 {
 277                         rc = DIRECTORY_TRAVERSE_ERROR;
 278                 }
 279
 280                 return rc;
 281         }
 282         else
 283         {
 284
 285                 BPTR dirLock = Lock(path, ACCESS_READ);
 286                 struct FileInfoBlock fib;
 287                 int bufflen = strlen(path) + 109;
 288                 char *fullpath = malloc(bufflen);
 289                 int rc = DIRECTORY_TRAVERSE_CONTINUE;
 290
 291                 if (dirLock == NULL || fullpath == NULL)
 292                 {
 293                         free(fullpath);
 294                         return DIRECTORY_TRAVERSE_ERROR;
 295                 }
 296
 297                 if (Examine(dirLock, &fib))
 298                 {
 299                         if (isDir(&fib))
 300                         {
 301                                 /* fine. we can start examining the entries */
 302
 303                                 while(rc == DIRECTORY_TRAVERSE_CONTINUE && ExNext(dirLock, &fib))
 304                                 {
 305                                         strcpy(fullpath, path);
 306                                         AddPart(fullpath, fib.fib_FileName, bufflen);
 307
 308                                         if (isDir(&fib) && (flags & DIRECTORY_SCAN_RECURSIVE))
 309                                         {
 310                                                 rc = directoryTraverse(fullpath, flags, callback, data);
 311                                                 if (rc == DIRECTORY_TRAVERSE_OK)
 312                                                         rc = DIRECTORY_TRAVERSE_CONTINUE;
 313                                         }
 314                                         if (!isDir(&fib))
 315                                                 rc = callback(&fib, fullpath, 0, data);
 316                                 }
 317                         }
 318
 319                         UnLock(dirLock);
 320                 }
 321
 322                 free(fullpath);
 323
 324                 if (rc == DIRECTORY_TRAVERSE_ABORTDIR || rc == DIRECTORY_TRAVERSE_CONTINUE)
 325                         rc = DIRECTORY_TRAVERSE_OK;
 326
 327                 return rc;
 328         }
 329 }
 330
 331 void directoryFree(struct directory *dir)
 332 {
 333         if (dir != NULL)
 334         {
 335                 struct directorynode *dn;
 336
 337                 while((dn = (struct directorynode*)GetTail(&dir->list)))
 338                 {
 339                         directoryFree(dn->subdir);
 340                         REMOVE(dn);
 341                         free(dn);
 342                 }
 343
 344                 free(dir);
 345         }
 346 }
 347
 348 int dirCreatePath(char *path)
 349 {
 350         int     pos = 0;
 351         char constructedPath[ 1024 ];
 352
 353         /* check if it doesn't exist */
 354
 355         {
 356                 BPTR lock;
 357                 char *eoPath = PathPart(path);
 358                 char t = eoPath[ 0 ];
 359
 360                 /* temporarely cut the file from path */
 361
 362         eoPath[ 0 ] = 0;
 363
 364                 lock = Lock(path, ACCESS_READ);
 365                 if (lock)
 366                 {
 367                         UnLock(lock);
 368
 369             /* restore file part */
 370
 371                         eoPath[ 0 ] = t;
 372
 373                         return TRUE;
 374                 }
 375
 376                 /* restore file part */
 377
 378                 eoPath[ 0 ] = t;
 379         }
 380
 381         constructedPath[ 0 ] = 0;
 382
 383         do
 384         {
 385                 char buff[ 256 ];
 386                 pos     = SplitName(path, '/', buff, pos, sizeof(buff));
 387
 388                 if (pos != -1)   /* last part is filename itself */
 389                 {
 390                         BPTR dLock;
 391
 392                         AddPart(constructedPath, buff, sizeof(constructedPath));
 393
 394                         dLock = CreateDir(constructedPath);
 395
 396                         if (dLock)
 397                         {
 398                                 UnLock(dLock);
 399                         }
 400                         else
 401                         {
 402                         }
 403                 }
 404
 405         } while(pos != -1);
 406
 407         return TRUE;
 408 }