nfile.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <dirent.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/stat.h>
 
#include "SDL_stdinc.h"
 
#include <errno.h>
#include <libgen.h> /* dirname / basename */
#if HAS_POSIX
#include <libgen.h>
#include <sys/types.h>
#include <unistd.h>
#endif /* HAS_POSIX */
#if __WIN32__
#include <windows.h>
#endif /* __WIN32__ */
 
#include "nfile.h"
 
#include "array.h"
#include "conf.h"
#if __MACOSX__
#include "glue_macos.h"
#endif /* __MACOSX__ */
#include "log.h"
 
#if HAS_UNIX && !__MACOSX__

static char *xdgGetEnv( const char *name )
{
   char *env = SDL_getenv( name );
   if ( ( env != NULL ) && ( env[0] != '\0' ) )
      return env;
   /* What errno signifies missing env var? */
   errno = EINVAL;
   return NULL;
}

static char *xdgEnvDup( const char *name )
{
   const char *env = xdgGetEnv( name );
   if ( env != NULL )
      return strdup( env );
   return NULL;
}

static char *xdgGetRelativeHome( const char *envname,
                                 const char *relativefallback )
{
   char *relhome = xdgEnvDup( envname );
   if ( ( relhome == NULL ) && ( errno != ENOMEM ) ) {
      const char  *home;
      unsigned int homelen;
      errno = 0;
      home  = xdgGetEnv( "HOME" );
      if ( home == NULL )
         return NULL;
      homelen = strlen( home );
      unsigned int fallbacklength;
      fallbacklength = strlen( relativefallback );
      relhome        = malloc( homelen + fallbacklength + 1 );
      if ( relhome == NULL )
         return NULL;
      memcpy( relhome, home, homelen );
      memcpy( &relhome[homelen], relativefallback, fallbacklength + 1 );
      relhome[homelen + fallbacklength] = '\0'; /* Just in case. */
   }
   return relhome;
}
#endif /* HAS_UNIX && !__MACOSX__ */
 
static char naev_configPath[PATH_MAX] = "\0"; 
const char *nfile_configPath( void )
{
   if ( naev_configPath[0] == '\0' ) {
      /* Global override is set. */
      if ( conf.datapath ) {
         snprintf( naev_configPath, sizeof( naev_configPath ), "%s/",
                   conf.datapath );
         return naev_configPath;
      }
#if __MACOSX__
      if ( macos_configPath( naev_configPath, sizeof( naev_configPath ) ) !=
           0 ) {
         WARN( _( "Cannot determine config path, using current directory." ) );
         snprintf( naev_configPath, sizeof( naev_configPath ), "./naev/" );
      }
#elif HAS_UNIX
      char *path = xdgGetRelativeHome( "XDG_CONFIG_HOME", "/.config" );
      if ( path == NULL ) {
         WARN( _( "$XDG_CONFIG_HOME isn't set, using current directory." ) );
         path = strdup( "." );
      }
 
      snprintf( naev_configPath, sizeof( naev_configPath ), "%s/naev/", path );
      free( path );
#elif __WIN32__
      char *path = SDL_getenv( "APPDATA" );
      if ( path == NULL ) {
         WARN( _( "%%APPDATA%% isn't set, using current directory." ) );
         path = ".";
      }
      snprintf( naev_configPath, sizeof( naev_configPath ), "%s/naev/", path );
#elif SDL_VERSION_ATLEAST( 3, 0, 0 )
      char *prefpath = SDL_GetPrefPath( "Naev DevTeam", "Naev" );
      strncpy( naev_configPath, sizeof( naev_configPath ), prefpath );
      SDL_free( prefpath );
#else
#error "Feature needs implementation on this Operating System for Naev to work."
#endif
   }
 
   return naev_configPath;
}
 
static char naev_cachePath[PATH_MAX] = "\0"; 
const char *nfile_cachePath( void )
{
   if ( naev_cachePath[0] == '\0' ) {
      /* Global override is set. */
      if ( conf.datapath ) {
         snprintf( naev_cachePath, sizeof( naev_cachePath ), "%s/",
                   conf.datapath );
         return naev_cachePath;
      }
#if __MACOSX__
      if ( macos_cachePath( naev_cachePath, sizeof( naev_cachePath ) ) != 0 ) {
         WARN( _( "Cannot determine cache path, using current directory." ) );
         snprintf( naev_cachePath, sizeof( naev_cachePath ), "./naev/" );
      }
#elif HAS_UNIX
      char *path = xdgGetRelativeHome( "XDG_CACHE_HOME", "/.cache" );
      if ( path == NULL ) {
         WARN( _( "$XDG_CACHE_HOME isn't set, using current directory." ) );
         path = strdup( "." );
      }
 
      snprintf( naev_cachePath, sizeof( naev_cachePath ), "%s/naev/", path );
      free( path );
#elif __WIN32__
      char *path = SDL_getenv( "APPDATA" );
      if ( path == NULL ) {
         WARN( _( "%%APPDATA%% isn't set, using current directory." ) );
         path = ".";
      }
      snprintf( naev_cachePath, sizeof( naev_cachePath ), "%s/naev/", path );
#elif SDL_VERSION_ATLEAST( 3, 0, 0 )
      char *prefpath = SDL_GetPrefPath( "Naev DevTeam", "Naev" );
      strncpy( naev_cachePath, sizeof( naev_cachePath ), prefpath );
      SDL_free( prefpath );
#else
#error "Feature needs implementation on this Operating System for Naev to work."
#endif
   }
 
   return naev_cachePath;
}
 
#if __WIN32__
#define MKDIR !CreateDirectory( opath, NULL )
static int mkpath( const char *path )
#elif HAS_POSIX
#define MKDIR mkdir( opath, mode )
static int mkpath( const char *path, mode_t mode )
#elif SDL_VERSION_ATLEAST( 3, 0, 0 )
#define MKDIR SDL_CreateDirectory( opath )
#else
#error "Feature needs implementation on this Operating System for Naev to work."
#endif
{
   char   opath[PATH_MAX];
   char  *p;
   size_t len;
   int    ret;
 
   if ( path == NULL )
      return 0;
 
   strncpy( opath, path, sizeof( opath ) - 1 );
   opath[sizeof( opath ) - 1] = '\0';
   len                        = strlen( opath );
 
   p = &opath[len - 1];
   if ( nfile_isSeparator( p[0] ) ) {
      p[0] = '\0';
      p--;
   }
 
   // Traverse up until we find a directory that exists.
   for ( ; p >= opath; p-- ) {
      if ( nfile_isSeparator( p[0] ) ) {
         p[0] = '\0';
         if ( nfile_dirExists( opath ) ) {
            p[0] = '/';
            break;
         }
         p[0] = '/';
      }
   }
   // This skips the directory that exists, or puts us
   // back at the start if the loop fell through.
   p++;
 
   // Traverse down, creating directories.
   for ( ; p[0] != '\0'; p++ ) {
      if ( nfile_isSeparator( p[0] ) ) {
         p[0] = '\0';
         ret  = MKDIR;
         if ( ret && ( errno != EEXIST ) )
            return ret;
         p[0] = '/';
      }
   }
 
   // Create the final directory.
   if ( !nfile_dirExists( opath ) ) {
      ret = MKDIR;
      if ( ret )
         return ret;
   }
 
   return 0;
}
#undef MKDIR

int nfile_dirMakeExist( const char *path )
{
   if ( path == NULL )
      return -1;
 
   /* Check if it exists. */
   if ( nfile_dirExists( path ) )
      return 0;
 
#if HAS_POSIX
   if ( mkpath( path, S_IRWXU | S_IRWXG | S_IRWXO ) < 0 ) {
#elif __WIN32__
   if ( mkpath( path ) < 0 ) {
#elif SDL_VERSION_ATLEAST( 3, 0, 0 )
   if ( SDL_CreateDirectory( path ) < 0 ) {
#else
#error "Feature needs implementation on this Operating System for Naev to work."
#endif
      WARN( _( "Dir '%s' does not exist and unable to create: %s" ), path,
            strerror( errno ) );
      return -1;
   }
 
   return 0;
}

int nfile_dirExists( const char *path )
{
   DIR *d;
 
   if ( path == NULL )
      return -1;
 
   d = opendir( path );
   if ( d == NULL )
      return 0;
   closedir( d );
   return 1;
}

int nfile_fileExists( const char *path )
{
   struct stat buf;
 
   if ( path == NULL )
      return -1;
 
   if ( stat( path, &buf ) == 0 ) /* stat worked, file must exist */
      return 1;
 
   /* ANSI C89 compliant method here for reference. Not as precise as stat.
   FILE *f = fopen(file, "rb");
   if (f != NULL) {
      fclose(f);
      return 1;
   }
   */
 
   return 0;
}

int nfile_backupIfExists( const char *path )
{
   char backup[PATH_MAX];
 
   if ( path == NULL )
      return -1;
 
   if ( !nfile_fileExists( path ) )
      return 0;
 
   snprintf( backup, sizeof( backup ), "%s.backup", path );
 
   return nfile_copyIfExists( path, backup );
}

int nfile_copyIfExists( const char *file1, const char *file2 )
{
   FILE  *f_in, *f_out;
   char   buf[8 * 1024];
   size_t lr, lw;
 
   if ( file1 == NULL )
      return -1;
 
   /* Check if input file exists */
   if ( !nfile_fileExists( file1 ) )
      return 0;
 
   /* Open files. */
   f_in  = fopen( file1, "rb" );
   f_out = fopen( file2, "wb" );
   if ( ( f_in == NULL ) || ( f_out == NULL ) ) {
      WARN( _( "Failure to copy '%s' to '%s': %s" ), file1, file2,
            strerror( errno ) );
      if ( f_in != NULL )
         fclose( f_in );
      if ( f_out != NULL )
         fclose( f_out );
      return -1;
   }
 
   /* Copy data over. */
   do {
      lr = fread( buf, 1, sizeof( buf ), f_in );
      if ( ferror( f_in ) )
         goto err;
      else if ( !lr ) {
         if ( feof( f_in ) )
            break;
         goto err;
      }
 
      lw = fwrite( buf, 1, lr, f_out );
      if ( ferror( f_out ) || ( lr != lw ) )
         goto err;
   } while ( lr > 0 );
 
   /* Close files. */
   fclose( f_in );
   fclose( f_out );
 
   return 0;
 
err:
   WARN( _( "Failure to copy '%s' to '%s': %s" ), file1, file2,
         strerror( errno ) );
   fclose( f_in );
   fclose( f_out );
 
   return -1;
}

char *nfile_readFile( size_t *filesize, const char *path )
{
   int         n;
   char       *buf;
   FILE       *file;
   int         len;
   size_t      pos;
   struct stat path_stat;
 
   if ( path == NULL ) {
      *filesize = 0;
      return NULL;
   }
 
   if ( stat( path, &path_stat ) ) {
      WARN( _( "Error occurred while opening '%s': %s" ), path,
            strerror( errno ) );
      *filesize = 0;
      return NULL;
   }
 
   if ( !S_ISREG( path_stat.st_mode ) ) {
      WARN( _( "Error occurred while opening '%s': It is not a regular file" ),
            path );
      *filesize = 0;
      return NULL;
   }
 
   /* Open file. */
   file = fopen( path, "rb" );
   if ( file == NULL ) {
      WARN( _( "Error occurred while opening '%s': %s" ), path,
            strerror( errno ) );
      *filesize = 0;
      return NULL;
   }
 
   /* Get file size. */
   if ( fseek( file, 0L, SEEK_END ) == -1 ) {
      WARN( _( "Error occurred while seeking '%s': %s" ), path,
            strerror( errno ) );
      fclose( file );
      *filesize = 0;
      return NULL;
   }
   len = ftell( file );
   if ( fseek( file, 0L, SEEK_SET ) == -1 ) {
      WARN( _( "Error occurred while seeking '%s': %s" ), path,
            strerror( errno ) );
      fclose( file );
      *filesize = 0;
      return NULL;
   }
 
   /* Allocate buffer. */
   buf = malloc( len + 1 );
   if ( buf == NULL ) {
      WARN( _( "Out of Memory" ) );
      fclose( file );
      *filesize = 0;
      return NULL;
   }
   buf[len] = '\0';
 
   /* Read the file. */
   n = 0;
   while ( n < len ) {
      pos = fread( &buf[n], 1, len - n, file );
      if ( pos <= 0 ) {
         WARN( _( "Error occurred while reading '%s': %s" ), path,
               strerror( errno ) );
         fclose( file );
         *filesize = 0;
         free( buf );
         return NULL;
      }
      n += pos;
   }
 
   /* Close the file. */
   fclose( file );
 
   *filesize = len;
   return buf;
}

int nfile_touch( const char *path )
{
   FILE *f;
 
   if ( path == NULL )
      return -1;
 
   /* Try to open the file, C89 compliant, but not as precise as stat. */
   f = fopen( path, "a+b" );
   if ( f == NULL ) {
      WARN( _( "Unable to touch file '%s': %s" ), path, strerror( errno ) );
      return -1;
   }
 
   fclose( f );
   return 0;
}

int nfile_writeFile( const char *data, size_t len, const char *path )
{
   size_t n;
   FILE  *file;
   size_t pos;
 
   if ( path == NULL )
      return -1;
 
   /* Open file. */
   file = fopen( path, "wb" );
   if ( file == NULL ) {
      WARN( _( "Error occurred while opening '%s': %s" ), path,
            strerror( errno ) );
      return -1;
   }
 
   /* Write the file. */
   n = 0;
   while ( n < len ) {
      pos = fwrite( &data[n], 1, len - n, file );
      if ( pos <= 0 ) {
         WARN( _( "Error occurred while writing '%s': %s" ), path,
               strerror( errno ) );
         fclose( file ); /* don't care about further errors */
         return -1;
      }
      n += pos;
   }
 
   /* Close the file. */
   if ( fclose( file ) == EOF ) {
      WARN( _( "Error occurred while closing '%s': %s" ), path,
            strerror( errno ) );
      return -1;
   }
 
   return 0;
}

int nfile_isSeparator( uint32_t c )
{
   if ( c == '/' )
      return 1;
#if __WIN32__
   else if ( c == '\\' )
      return 1;
#endif /* __WIN32__ */
   return 0;
}
 
int _nfile_concatPaths( char buf[static 1], int maxLength,
                        const char path[static 1], ... )
{
   char       *bufPos;
   char       *bufEnd;
   const char *section;
   va_list     ap;
 
   bufPos = buf;
   bufEnd = buf + maxLength;
   va_start( ap, path );
   section = path;
 
#if DEBUGGING
   if ( section == NULL )
      WARN( _( "First argument to nfile_concatPaths was NULL. This is probably "
               "an error." ) );
#endif /* DEBUGGING */
 
   do {
      // End of arg list?
      if ( section == NULL )
         break;
 
      if ( bufPos > buf ) {
         // Make sure there's a path seperator.
         if ( bufPos[-1] != '/' ) {
            bufPos[0] = '/';
            bufPos += 1;
         }
         // But not too many path seperators.
         if ( *section == '/' )
            section += 1;
      }
 
      // Copy this section
      bufPos = memccpy( bufPos, section, '\0', bufEnd - bufPos );
      if ( bufPos == NULL )
         break;
 
      // Next path section
      section = va_arg( ap, char * );
   } while (
      bufPos-- <
      bufEnd ); // Rewind after compare so we're pointing at the NULL character.
   va_end( ap );
 
   // Did we run out of space?
   if ( section != NULL )
      return -1;
 
   return bufPos - buf;
}

int nfile_simplifyPath( char path[static 1] )
{
   char **dirnames = array_create( char * );
   char  *saveptr  = NULL;
   size_t n        = strlen( path );
   int    absolute = ( path[0] == '/' );
   char  *token    = SDL_strtokr( path, "/", &saveptr );
 
   while ( token != NULL ) {
      /* Skip noop. */
      if ( ( strcmp( token, "" ) == 0 ) || ( strcmp( token, "." ) == 0 ) ) {
         token = SDL_strtokr( NULL, "/", &saveptr );
         continue;
      }
 
      /* Go up if ".." */
      if ( strcmp( token, ".." ) == 0 ) {
         int dn = array_size( dirnames );
         if ( dn > 0 ) {
            free( dirnames[dn - 1] );
            array_erase( &dirnames, &dirnames[dn - 1], &dirnames[dn] );
         }
      } else {
         array_push_back( &dirnames, strdup( token ) );
      }
 
      /* On to the next one. */
      token = SDL_strtokr( NULL, "/", &saveptr );
   }
 
   /* If nothing, we're empty. */
   if ( array_size( dirnames ) <= 0 ) {
      array_free( dirnames );
      path[0] = '\0';
      return 0;
   }
 
   /* Build back the path, assume 'path' is smaller than simplified one. */
   size_t s = 0;
   for ( int i = 0; i < array_size( dirnames ); i++ ) {
      char *ds = dirnames[i];
      if ( ( absolute || ( s > 0 ) ) && ( s < n ) )
         path[s++] = '/';
      for ( size_t j = 0; j < strlen( ds ); j++ )
         if ( s < n )
            path[s++] = ds[j];
      free( ds );
   }
   path[s] = '\0';
   array_free( dirnames );
   return 0;
}
 
#if !SDL_VERSION_ATLEAST( 3, 0, 0 )
#include "nfd.h"
void SDL_ShowOpenFileDialog( SDL_DialogFileCallback callback, void *userdata,
                             SDL_Window                 *window,
                             const SDL_DialogFileFilter *filters,
                             const char *default_location, SDL_bool allow_many )
{
   (void)allow_many;
   (void)window;
   char *filelist[2] = { NULL, NULL };
 
   int n;
   for ( n = 0; filters[n].name != NULL; n++ )
      ;
 
   nfdfilteritem_t *fitem = calloc( n, sizeof( nfdfilteritem_t ) );
   for ( int i = 0; i < n; i++ ) {
      fitem[i].name = filters[i].name;
      fitem[i].spec = filters[i].pattern;
   }
 
   NFD_Init();
 
   nfdchar_t *outPath;
#if __WIN32__
   (void)default_location;
   nfdresult_t result = NFD_OpenDialog( &outPath, fitem, n, NULL );
#else  /* __WIN32__ */
   nfdresult_t result = NFD_OpenDialog( &outPath, fitem, n, default_location );
#endif /* __WIN32__ */
   switch ( result ) {
   case NFD_OKAY:
      filelist[0] = outPath;
      callback( userdata, (const char **)filelist, 0 );
      NFD_FreePath( outPath );
      break;
 
   case NFD_CANCEL:
      callback( userdata, (const char **)filelist, 0 );
      break;
 
   default:
      SDL_SetError( "%s", NFD_GetError() );
      callback( userdata, NULL, -1 );
      break;
   }
 
   NFD_Quit();
 
   free( fitem );
}
 
void SDL_ShowOpenFolderDialog( SDL_DialogFileCallback callback, void *userdata,
                               SDL_Window *window, const char *default_location,
                               SDL_bool allow_many )
{
   (void)allow_many;
   (void)window;
   char *filelist[2] = { NULL, NULL };
 
   NFD_Init();
 
   nfdchar_t *outPath;
#if __WIN32__
   (void)default_location;
   nfdresult_t result = NFD_PickFolder( &outPath, NULL );
#else  /* __WIN32__ */
   nfdresult_t result = NFD_PickFolder( &outPath, default_location );
#endif /* __WIN32__ */
   switch ( result ) {
   case NFD_OKAY:
      filelist[0] = outPath;
      callback( userdata, (const char **)filelist, 0 );
      NFD_FreePath( outPath );
      break;
 
   case NFD_CANCEL:
      callback( userdata, (const char **)filelist, 0 );
      break;
 
   default:
      SDL_SetError( "%s", NFD_GetError() );
      callback( userdata, NULL, -1 );
      break;
   }
 
   NFD_Quit();
}
 
void SDL_ShowSaveFileDialog( SDL_DialogFileCallback callback, void *userdata,
                             SDL_Window                 *window,
                             const SDL_DialogFileFilter *filters,
                             const char                 *default_location )
{
   (void)window;
   char *filelist[2] = { NULL, NULL };
   char *tmp, *bname, *dname;
 
   int n;
   for ( n = 0; filters[n].name != NULL; n++ )
      ;
 
   nfdfilteritem_t *fitem = calloc( n, sizeof( nfdfilteritem_t ) );
   for ( int i = 0; i < n; i++ ) {
      fitem[i].name = filters[i].name;
      fitem[i].spec = filters[i].pattern;
   }
 
   /* Get paths. */
   tmp   = strdup( default_location );
   dname = strdup( dirname( tmp ) );
   free( tmp );
   tmp   = strdup( default_location );
   bname = strdup( basename( tmp ) );
   free( tmp );
 
   NFD_Init();
 
   nfdchar_t *outPath;
#if __WIN32__
   nfdresult_t result = NFD_SaveDialog( &outPath, fitem, n, NULL, bname );
#else  /* __WIN32__ */
   nfdresult_t result = NFD_SaveDialog( &outPath, fitem, n, dname, bname );
#endif /* __WIN32__ */
   switch ( result ) {
   case NFD_OKAY:
      filelist[0] = outPath;
      callback( userdata, (const char **)filelist, 0 );
      NFD_FreePath( outPath );
      break;
 
   case NFD_CANCEL:
      callback( userdata, (const char **)filelist, 0 );
      break;
 
   default:
      SDL_SetError( "%s", NFD_GetError() );
      callback( userdata, NULL, -1 );
      break;
   }
 
   NFD_Quit();
 
   free( dname );
   free( bname );
   free( fitem );
}
#endif /* ! SDL_VERSION_ATLEAST(3,0,0) */