common/SC_DirUtils.cpp

   1 /*
   2  *  Copyright (c) 2005 Tim Walters. All rights reserved.
   3  *  Created by Tim Walters on 10/19/05.
   4  *
   5  *  This program is free software; you can redistribute it and/or
   6  *  modify it under the terms of the GNU General Public License as
   7  *  published by the Free Software Foundation; either version 2 of the
   8  *  License, or (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful, but
  11  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  *  General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License
  16  *  along with this program; if not, write to the Free Software
  17  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
  18  *  USA
  19  *
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdio.h>
  25
  26 #ifdef _WIN32
  27 # include <direct.h>
  28 # include "SC_Win32Utils.h"
  29 #else
  30 # include <unistd.h>
  31 # include <dirent.h>
  32 # include <glob.h>
  33 # include <sys/param.h>
  34 # include <sys/stat.h>
  35 # include <sys/types.h>
  36 #endif
  37
  38 #include "SC_DirUtils.h"
  39
  40 #if defined(__APPLE__) || defined(SC_IPHONE)
  41 #ifndef _SC_StandAloneInfo_
  42 # include "SC_StandAloneInfo_Darwin.h"
  43 #endif
  44 # include <CoreFoundation/CFString.h>
  45 # include <CoreFoundation/CFBundle.h>
  46 #ifndef SC_IPHONE
  47 # include <CoreServices/CoreServices.h>
  48 #endif
  49 #endif
  50
  51 const char * gIdeName = "none";
  52
  53 // Add a component to a path.
  54
  55 void sc_AppendToPath(char *path, size_t max_size, const char *component)
  56 {
  57         size_t currentLength = strlen(path);
  58         if (currentLength >= max_size-1)
  59                 return;
  60         path[currentLength] = SC_PATH_DELIMITER[0];
  61         path[currentLength+1] = 0;
  62         ++currentLength;
  63
  64         char * tail = path + currentLength;
  65         size_t remain = max_size - currentLength;
  66
  67         strncat(tail, component, remain);
  68 }
  69
  70
  71 char *sc_StandardizePath(const char *path, char *newpath2)
  72 {
  73         char newpath1[MAXPATHLEN];
  74
  75         newpath1[0] = '\0';
  76         newpath2[0] = '\0';
  77
  78         size_t pathLen = strlen(path);
  79
  80         if ((pathLen >= 2) && (path[0] == '~') && ((path[1] == '/') || (path[1] == '\\'))) {
  81                 char home[PATH_MAX];
  82                 sc_GetUserHomeDirectory(home, PATH_MAX);
  83
  84                 if (home != 0) {
  85                         if ((pathLen - 1 + strlen(home)) >= MAXPATHLEN) {
  86                                 return 0;
  87                         }
  88                         strcpy(newpath1, home);
  89                         strcat(newpath1, path + 1);
  90                 } else {
  91                         if (pathLen >= MAXPATHLEN) {
  92                                 return 0;
  93                         }
  94                         strcpy(newpath1, path);
  95                         newpath1[0] = '.';
  96                 }
  97         } else {
  98                 if (pathLen >= MAXPATHLEN) {
  99                         return 0;
 100                 }
 101                 strcpy(newpath1, path);
 102         }
 103
 104         bool isAlias = false;
 105         if(sc_ResolveIfAlias(newpath1, newpath2, isAlias, PATH_MAX)!=0) {
 106                 strcpy(newpath2, newpath1);
 107         }
 108
 109         return newpath2;
 110 }
 111
 112
 113 // Returns TRUE iff dirname is an existing directory.
 114
 115 bool sc_DirectoryExists(const char *dirname)
 116 {
 117 #if defined(_WIN32)
 118         DWORD attr = GetFileAttributes(dirname);
 119         return ((attr != INVALID_FILE_ATTRIBUTES) &&
 120                         (attr & FILE_ATTRIBUTE_DIRECTORY));
 121 #else
 122         struct stat buf;
 123         return ((stat(dirname, &buf) == 0) &&
 124                         S_ISDIR(buf.st_mode));
 125 #endif
 126 }
 127
 128 bool sc_IsSymlink(const char* path)
 129 {
 130 #if defined(_WIN32)
 131         // FIXME
 132         return false;
 133 #else
 134         struct stat buf;
 135
 136         return ((stat(path, &buf) == 0) &&
 137                         S_ISLNK(buf.st_mode));
 138 #endif
 139 }
 140
 141 bool sc_IsNonHostPlatformDir(const char *name)
 142 {
 143 #if defined(SC_IPHONE)
 144         const char a[] = "linux", b[] = "windows", c[]="osx";
 145 #elif defined(__APPLE__)
 146         const char a[] = "linux", b[] = "windows", c[]="iphone";
 147 #elif defined(__linux__)
 148         const char a[] = "osx", b[] = "windows", c[]="iphone";
 149 #elif defined(__FreeBSD__)
 150         const char a[] = "osx", b[] = "windows", c[]="iphone";
 151 #elif defined(_WIN32)
 152         const char a[] = "osx", b[] = "linux", c[]="iphone";
 153 #endif
 154         return ((strcmp(name, a) == 0) ||
 155                         (strcmp(name, b) == 0) ||
 156                         (strcmp(name, c) == 0));
 157 }
 158
 159
 160 // Returns TRUE iff 'name' is special directory '.' or '..'
 161
 162 inline static bool sc_IsSpecialDirectory(const char* name)
 163 {
 164         return (strcmp(name, ".") == 0) || (strcmp(name, "..")  == 0);
 165 }
 166
 167 // Returns TRUE iff 'name' is to be ignored during compilation.
 168
 169 bool sc_SkipDirectory(const char *name)
 170 {
 171         return ((strcasecmp(name, "help") == 0) ||
 172                         (strcasecmp(name, "ignore") == 0) ||
 173                         (strcmp(name, ".svn") == 0) ||
 174                         (strcmp(name, ".git") == 0) ||
 175                         (strcmp(name, "_darcs") == 0) ||
 176                         ((strncmp(name, "scide_", 6) == 0) && (strcmp(name+6, gIdeName) != 0)) ||
 177                         sc_IsNonHostPlatformDir(name));
 178 }
 179
 180
 181 int sc_ResolveIfAlias(const char *path, char *returnPath, bool &isAlias, int length)
 182 {
 183         isAlias = false;
 184 #if defined(__APPLE__) && !defined(SC_IPHONE)
 185         FSRef dirRef;
 186         OSStatus osStatusErr = FSPathMakeRef ((const UInt8 *) path, &dirRef, NULL);
 187         if ( !osStatusErr ) {
 188                 Boolean isFolder;
 189                 Boolean wasAliased;
 190                 OSErr err = FSResolveAliasFile (&dirRef, true, &isFolder, &wasAliased);
 191                 if (err)
 192                 {
 193                         return -1;
 194                 }
 195                 isAlias = wasAliased;
 196                 if (wasAliased)
 197                 {
 198                         UInt8 resolvedPath[PATH_MAX];
 199                         osStatusErr = FSRefMakePath (&dirRef, resolvedPath, length);
 200                         if (osStatusErr)
 201                         {
 202                                 return -1;
 203                         }
 204                         strncpy(returnPath, (char *) resolvedPath, length);
 205                         return 0;
 206                 }
 207         }
 208 #endif
 209         strcpy(returnPath, path);
 210         return 0;
 211 }
 212
 213 // Support for Bundles
 214
 215 #if defined(__APPLE__) && !defined(SC_IPHONE)   // running on OS X
 216
 217 // Support for stand-alone applications
 218
 219 bool sc_IsStandAlone()
 220 {
 221         return SC_StandAloneInfo::IsStandAlone();
 222 }
 223
 224 void sc_GetResourceDirectory(char* pathBuf, int length)
 225 {
 226         SC_StandAloneInfo::GetResourceDir(pathBuf, length);
 227 }
 228
 229 #elif defined(SC_IPHONE)
 230
 231 bool sc_IsStandAlone()
 232 {
 233         return false;
 234 }
 235
 236 void sc_GetResourceDirectory(char* pathBuf, int length)
 237 {
 238         sc_GetUserAppSupportDirectory(pathBuf, length);
 239 }
 240
 241 #elif defined(__unix__)
 242
 243 bool sc_IsStandAlone()
 244 {
 245         return false;
 246 }
 247
 248 void sc_GetResourceDirectory(char* pathBuf, int length)
 249 {
 250 #ifdef SC_DATA_DIR
 251         strncpy(pathBuf, SC_DATA_DIR, length);
 252 #else
 253         strncpy(pathBuf, "/usr/share/SuperCollider", length);
 254 #endif
 255 }
 256
 257 #else
 258
 259 bool sc_IsStandAlone()
 260 {
 261         return false;
 262 }
 263
 264 static void sc_GetResourceDirectoryFromAppDirectory(char* pathBuf, int length)
 265 {
 266         char * result = getcwd(pathBuf, length);
 267         if (result != pathBuf)
 268                 throw std::runtime_error("cannot get current working directory");
 269 }
 270
 271
 272 void sc_GetResourceDirectory(char* pathBuf, int length)
 273 {
 274         return sc_GetResourceDirectoryFromAppDirectory(pathBuf, length);
 275 }
 276
 277 #endif
 278
 279
 280
 281 // Support for Extensions
 282
 283 // Get the user home directory.
 284
 285 void sc_GetUserHomeDirectory(char *str, int size)
 286 {
 287 #ifndef _WIN32
 288         const char *home = getenv("HOME");
 289         if(home!=NULL){
 290                 strncpy(str, home, size);
 291         }else{
 292                 // cwd is not the user home directory; but this is better than leaving mem uninitialised.
 293                 strcpy(str, "./");
 294         }
 295 #else
 296         win32_GetHomeFolder(str,size);
 297 #endif
 298 }
 299
 300
 301 // Get the System level data directory.
 302
 303 void sc_GetSystemAppSupportDirectory(char *str, int size)
 304 {
 305         strncpy(str,
 306 #if defined(SC_DATA_DIR)
 307                         SC_DATA_DIR,
 308 #elif defined(SC_IPHONE)
 309                         "/",
 310 #elif defined(__APPLE__)
 311                         "/Library/Application Support/SuperCollider",
 312 #elif defined(_WIN32)
 313                         ( getenv("SC_SYSAPPSUP_PATH")==NULL ) ? "C:\\SuperCollider" : getenv("SC_SYSAPPSUP_PATH"),
 314 #else
 315                         "/usr/local/share/SuperCollider",
 316 #endif
 317                         size);
 318 }
 319
 320
 321 // Get the User level data directory.
 322
 323 void sc_GetUserAppSupportDirectory(char *str, int size)
 324 {
 325         // XDG support according to http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
 326         const char * xdg_data_home = getenv("XDG_DATA_HOME");
 327         if (xdg_data_home) {
 328                 strncpy(str, xdg_data_home, size);
 329                 sc_AppendToPath(str, size, "SuperCollider");
 330                 return;
 331         }
 332
 333         sc_GetUserHomeDirectory(str, size);
 334
 335 #if defined(SC_IPHONE)
 336         sc_AppendToPath(str, size, "Documents");
 337 #elif defined(__APPLE__)
 338         sc_AppendToPath(str, size, "Library/Application Support/SuperCollider");
 339 #elif defined(_WIN32)
 340         sc_AppendToPath(str, size, "SuperCollider");
 341 #else
 342         sc_AppendToPath(str, size, ".local/share/SuperCollider");
 343 #endif
 344 }
 345
 346
 347 // Get the System level 'Extensions' directory.
 348
 349 void sc_GetSystemExtensionDirectory(char *str, int size)
 350 {
 351         sc_GetSystemAppSupportDirectory(str, size);
 352         sc_AppendToPath(str, size, "Extensions");
 353 }
 354
 355
 356 // Get the System level 'Extensions' directory.
 357
 358 void sc_GetUserExtensionDirectory(char *str, int size)
 359 {
 360         sc_GetUserAppSupportDirectory(str, size);
 361         sc_AppendToPath(str, size, "Extensions");
 362 }
 363
 364 // Get the directory for the configuration files.
 365 void sc_GetUserConfigDirectory(char *str, int size)
 366 {
 367         // XDG support according to http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
 368         const char * xdg_config_home = getenv("XDG_CONFIG_HOME");
 369         if (xdg_config_home) {
 370                 strncpy(str, xdg_config_home, size);
 371                 sc_AppendToPath(str, size, "SuperCollider");
 372         }
 373
 374 #if defined(__linux__) || defined(__freebsd__)
 375         char * home = str;
 376
 377         sc_GetUserHomeDirectory(str, size);
 378         sc_AppendToPath(str, size, ".config/SuperCollider");
 379 #else
 380         sc_GetUserAppSupportDirectory(str, size);
 381 #endif
 382 }
 383
 384
 385 // Directory access
 386
 387 struct SC_DirHandle
 388 {
 389 #ifdef _WIN32
 390         HANDLE mHandle;
 391         WIN32_FIND_DATA mEntry;
 392         bool mAtEnd;
 393 #else
 394         DIR* mHandle;
 395         struct dirent* mEntry;
 396 #endif
 397 };
 398
 399 SC_DirHandle* sc_OpenDir(const char* dirname)
 400 {
 401         SC_DirHandle* dir = new SC_DirHandle;
 402         memset(dir, 0, sizeof(SC_DirHandle));
 403
 404 #ifdef _WIN32
 405         char allInDir[PATH_MAX];
 406         snprintf(allInDir, PATH_MAX, "%s\\*.*", dirname);
 407
 408         dir->mHandle = ::FindFirstFile(allInDir, &dir->mEntry);
 409         if (dir->mHandle == INVALID_HANDLE_VALUE) {
 410                 delete dir;
 411                 return 0;
 412         }
 413
 414         dir->mAtEnd = false;
 415 #else
 416         dir->mHandle = opendir(dirname);
 417         if (!dir->mHandle) {
 418                 delete dir;
 419                 return 0;
 420         }
 421 #endif
 422
 423         return dir;
 424 }
 425
 426 void sc_CloseDir(SC_DirHandle* dir)
 427 {
 428 #ifdef _WIN32
 429         ::FindClose(dir->mHandle);
 430 #else
 431         closedir(dir->mHandle);
 432 #endif
 433         delete dir;
 434 }
 435
 436 bool sc_ReadDir(SC_DirHandle* dir, const char* dirname, char* path, bool& skipEntry)
 437 {
 438 #ifdef _WIN32
 439         bool success = true;
 440
 441         if (dir->mAtEnd)
 442                 return false;
 443
 444         const char* entry = dir->mEntry.cFileName;
 445
 446         if (sc_IsSpecialDirectory(entry) || (skipEntry && sc_SkipDirectory(entry))) {
 447                 skipEntry = true;
 448                 success = true;
 449         } else {
 450                 skipEntry = false;
 451                 success = true;
 452         }
 453
 454     char entrypathname[PATH_MAX];
 455         strncpy(entrypathname, dirname, PATH_MAX);
 456         sc_AppendToPath(entrypathname, PATH_MAX, dir->mEntry.cFileName);
 457
 458         bool isAlias = false;
 459         sc_ResolveIfAlias(entrypathname, path, isAlias, PATH_MAX);
 460
 461         if (!::FindNextFile(dir->mHandle, &dir->mEntry)) {
 462                 dir->mAtEnd = true;
 463         }
 464
 465         return true;
 466 #else
 467         if (!dir->mHandle)
 468                 return false;
 469
 470         dir->mEntry = readdir(dir->mHandle);
 471         if (!dir->mEntry)
 472                 return false;
 473
 474         const char* entry = dir->mEntry->d_name;
 475
 476         if (sc_IsSpecialDirectory(entry) || (skipEntry && sc_SkipDirectory(entry))) {
 477                 skipEntry = true;
 478                 return true;
 479         } else {
 480                 skipEntry = false;
 481         }
 482
 483         // construct path from dir entry
 484         char entrypathname[PATH_MAX];
 485         strncpy(entrypathname, dirname, PATH_MAX);
 486         sc_AppendToPath(entrypathname, PATH_MAX, dir->mEntry->d_name);
 487
 488         // resolve path
 489         bool isAlias = false;
 490         if (sc_ResolveIfAlias(entrypathname, path, isAlias, strlen(entrypathname))<0)
 491         {
 492                 skipEntry = true;
 493         }
 494
 495         return true;
 496 #endif
 497 }
 498
 499
 500 // Globbing
 501
 502 struct SC_GlobHandle
 503 {
 504 #ifdef _WIN32
 505         HANDLE mHandle;
 506         char mFolder[PATH_MAX];
 507         WIN32_FIND_DATA mEntry;
 508         char mEntryPath[PATH_MAX];
 509         bool mAtEnd;
 510 #else
 511         glob_t mHandle;
 512         size_t mEntry;
 513 #endif
 514 };
 515
 516 SC_GlobHandle* sc_Glob(const char* pattern)
 517 {
 518         SC_GlobHandle* glob = new SC_GlobHandle;
 519
 520 #ifdef _WIN32
 521         char patternWin[1024];
 522
 523         strncpy(patternWin, pattern, 1024);
 524         patternWin[1023] = 0;
 525         win32_ReplaceCharInString(patternWin, 1024, '/', '\\');
 526
 527         win32_ExtractContainingFolder(glob->mFolder, patternWin, PATH_MAX);
 528
 529         glob->mHandle = ::FindFirstFile(patternWin, &glob->mEntry);
 530         if (glob->mHandle == INVALID_HANDLE_VALUE) {
 531                 delete glob;
 532                 return 0;
 533         }
 534
 535         glob->mAtEnd = false;
 536 #else
 537         int flags = GLOB_MARK | GLOB_TILDE;
 538 #ifdef __APPLE__
 539         flags |= GLOB_QUOTE;
 540 #endif
 541
 542         int err = ::glob(pattern, flags, NULL, &glob->mHandle);
 543         if (err < 0) {
 544                 delete glob;
 545                 return 0;
 546         }
 547
 548         glob->mEntry = 0;
 549 #endif
 550
 551         return glob;
 552 }
 553
 554 void sc_GlobFree(SC_GlobHandle* glob)
 555 {
 556 #ifdef _WIN32
 557         ::FindClose(glob->mHandle);
 558 #else
 559         globfree(&glob->mHandle);
 560 #endif
 561         delete glob;
 562 }
 563
 564 const char* sc_GlobNext(SC_GlobHandle* glob)
 565 {
 566 #ifdef _WIN32
 567         if (glob->mAtEnd)
 568                 return 0;
 569         strncpy(glob->mEntryPath, glob->mFolder, PATH_MAX);
 570         sc_AppendToPath(glob->mEntryPath, PATH_MAX, glob->mEntry.cFileName);
 571         if (!::FindNextFile(glob->mHandle, &glob->mEntry))
 572                 glob->mAtEnd = true;
 573         return glob->mEntryPath;
 574 #else
 575         if (glob->mEntry >= glob->mHandle.gl_pathc)
 576                 return 0;
 577         return glob->mHandle.gl_pathv[glob->mEntry++];
 578 #endif
 579 }