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