ndata.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <limits.h>
#include <stdarg.h>
#include <stdlib.h>
#if WIN32
#include <windows.h>
#endif /* WIN32 */
 
#include "physfs.h"
#include "SDL.h"
 
#include "naev.h"
#include "ndata.h"
 
#include "array.h"
#include "conf.h"
#include "env.h"
#if MACOS
#include "glue_macos.h"
#endif /* MACOS */
#include "log.h"
#include "nfile.h"
#include "nstring.h"
#include "plugin.h"
 
/*
 * Prototypes.
 */
static void ndata_testVersion (void);
static int ndata_found (void);
static int ndata_enumerateCallback( void* data, const char* origdir, const char* fname );
 
static int ndata_found( void )
{
   /* Verify that we can find VERSION and start.xml.
    * This is arbitrary, but these are among the hard dependencies to self-identify and start.
    */
   return PHYSFS_exists( "VERSION" ) && PHYSFS_exists( START_DATA_PATH );
}
 
static void ndata_testVersion (void)
{
   size_t size;
   char *buf, cbuf[PATH_MAX];
   int diff;
 
   if (!ndata_found())
      ERR( _("Unable to find game data. You may need to install, specify a datapath, or run using naev.sh (if developing).") );
 
   /* Parse version. */
   buf = ndata_read( "VERSION", &size );
   for (size_t i=0; i<MIN(size,PATH_MAX-1); i++)
      cbuf[i] = buf[i];
   cbuf[MIN(size-1,PATH_MAX-1)] = '\0';
   diff = naev_versionCompare( cbuf );
   if (diff != 0) {
      WARN( _("ndata version inconsistency with this version of Naev!") );
      WARN( _("Expected ndata version %s got %s."), naev_version( 0 ), cbuf );
      if (ABS(diff) > 2)
         ERR( _("Please get a compatible ndata version!") );
      if (ABS(diff) > 1)
         WARN( _("Naev will probably crash now as the versions are probably not compatible.") );
   }
   free( buf );
}
 
void ndata_setupWriteDir (void)
{
   /* Global override is set. */
   if (conf.datapath) {
      PHYSFS_setWriteDir( conf.datapath );
      return;
   }
#if MACOS
   /* For historical reasons predating physfs adoption, this case is different. */
   PHYSFS_setWriteDir( PHYSFS_getPrefDir( ".", "org.naev.Naev" ) );
#else
   PHYSFS_setWriteDir( PHYSFS_getPrefDir( ".", "naev" ) );
#endif /* MACOS */
   if (PHYSFS_getWriteDir() == NULL) {
      WARN(_("Cannot determine data path, using current directory."));
      PHYSFS_setWriteDir( "./naev/" );
   }
}
 
void ndata_setupReadDirs (void)
{
   char buf[ PATH_MAX ];
 
   if ( conf.ndata != NULL && PHYSFS_mount( conf.ndata, NULL, 1 ) )
      LOG(_("Added datapath from conf.lua file: %s"), conf.ndata);
 
#if MACOS
   if ( !ndata_found() && macos_isBundle() && macos_resourcesPath( buf, PATH_MAX-4 ) >= 0 && strncat( buf, "/dat", 4 ) ) {
      LOG(_("Trying default datapath: %s"), buf);
      PHYSFS_mount( buf, NULL, 1 );
   }
#endif /* MACOS */
 
   if ( !ndata_found() && env.isAppImage && nfile_concatPaths( buf, PATH_MAX, env.appdir, PKGDATADIR, "dat" ) >= 0 ) {
      LOG(_("Trying default datapath: %s"), buf);
      PHYSFS_mount( buf, NULL, 1 );
   }
 
   if (!ndata_found() && nfile_concatPaths( buf, PATH_MAX, PKGDATADIR, "dat" ) >= 0) {
      LOG(_("Trying default datapath: %s"), buf);
      PHYSFS_mount( buf, NULL, 1 );
   }
 
   if (!ndata_found() && nfile_concatPaths( buf, PATH_MAX, PHYSFS_getBaseDir(), "dat" ) >= 0) {
      LOG(_("Trying default datapath: %s"), buf);
      PHYSFS_mount( buf, NULL, 1 );
   }
 
   PHYSFS_mount( PHYSFS_getWriteDir(), NULL, 0 );
 
   /* Load plugins I guess. */
   plugin_init();
 
   ndata_testVersion();
}
 
void* ndata_read( const char* path, size_t *filesize )
{
   char *buf;
   PHYSFS_file *file;
   PHYSFS_sint64 len, n;
   size_t pos;
   PHYSFS_Stat path_stat;
 
   if (!PHYSFS_stat( path, &path_stat )) {
      WARN( _( "Error occurred while opening '%s': %s" ), path,
            _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
      *filesize = 0;
      return NULL;
   }
   if (path_stat.filetype != PHYSFS_FILETYPE_REGULAR) {
      WARN( _( "Error occurred while opening '%s': It is not a regular file" ), path );
      *filesize = 0;
      return NULL;
   }
 
   /* Open file. */
   file = PHYSFS_openRead( path );
   if ( file == NULL ) {
      WARN( _( "Error occurred while opening '%s': %s" ), path,
            _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
      *filesize = 0;
      return NULL;
   }
 
   /* Get file size. TODO: Don't assume this is always possible? */
   len = PHYSFS_fileLength( file );
   if ( len == -1 ) {
      WARN( _( "Error occurred while seeking '%s': %s" ), path,
            _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
      PHYSFS_close( file );
      *filesize = 0;
      return NULL;
   }
 
   /* Allocate buffer. */
   buf = malloc( len+1 );
   if (buf == NULL) {
      WARN(_("Out of Memory"));
      PHYSFS_close( file );
      *filesize = 0;
      return NULL;
   }
   buf[len] = '\0';
 
   /* Read the file. */
   n = 0;
   while ( n < len ) {
      pos = PHYSFS_readBytes( file, &buf[ n ], len - n );
      if ( pos <= 0 ) {
         WARN( _( "Error occurred while reading '%s': %s" ), path,
            _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
         PHYSFS_close( file );
         *filesize = 0;
         free(buf);
         return NULL;
      }
      n += pos;
   }
 
   /* Close the file. */
   PHYSFS_close(file);
 
   *filesize = len;
   return buf;
}
 
char **ndata_listRecursive( const char *path )
{
   char **files = array_create( char * );
   PHYSFS_enumerate( path, ndata_enumerateCallback, &files );
   /* Ensure unique. PhysicsFS can enumerate a path twice if it's in multiple components of a union. */
   qsort( files, array_size(files), sizeof(char*), strsort );
   for (int i=0; i+1<array_size(files); i++)
      if (strcmp(files[i], files[i+1]) == 0) {
         free( files[i] );
         array_erase( &files, &files[i], &files[i+1] );
         i--; /* We're not done checking for dups of files[i]. */
      }
   return files;
}
 
static int ndata_enumerateCallback( void* data, const char* origdir, const char* fname )
{
   char *path;
   const char *fmt;
   size_t dir_len;
   PHYSFS_Stat stat;
 
   dir_len = strlen( origdir );
   fmt = dir_len && origdir[dir_len-1]=='/' ? "%s%s" : "%s/%s";
   asprintf( &path, fmt, origdir, fname );
   if (!PHYSFS_stat( path, &stat )) {
      WARN( _("PhysicsFS: Cannot stat %s: %s"), path,
            _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
      free( path );
   }
   else if (stat.filetype == PHYSFS_FILETYPE_REGULAR)
      array_push_back( (char***)data, path );
   else if (stat.filetype == PHYSFS_FILETYPE_DIRECTORY ) {
      PHYSFS_enumerate( path, ndata_enumerateCallback, data );
      free( path );
   }
   else
      free( path );
   return PHYSFS_ENUM_OK;
}
 
int ndata_backupIfExists( const char *path )
{
   char backup[ PATH_MAX ];
 
   if (path == NULL)
      return -1;
 
   if (!PHYSFS_exists( path ))
      return 0;
 
   snprintf(backup, sizeof(backup), "%s.backup", path);
 
   return ndata_copyIfExists( path, backup );
}
 
int ndata_copyIfExists( const char* file1, const char* file2 )
{
   PHYSFS_File *f_in, *f_out;
   char buf[ 8*1024 ];
   PHYSFS_sint64 lr, lw;
 
   if (file1 == NULL)
      return -1;
 
   /* Check if input file exists */
   if (!PHYSFS_exists(file1))
      return 0;
 
   /* Open files. */
   f_in  = PHYSFS_openRead( file1 );
   f_out = PHYSFS_openWrite( file2 );
   if ((f_in==NULL) || (f_out==NULL)) {
      WARN( _("Failure to copy '%s' to '%s': %s"), file1, file2,
            _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
      if (f_in!=NULL)
         PHYSFS_close(f_in);
      return -1;
   }
 
   /* Copy data over. */
   do {
      lr = PHYSFS_readBytes( f_in, buf, sizeof(buf) );
      if (lr == -1)
         goto err;
      else if (!lr) {
         if (PHYSFS_eof( f_in ))
            break;
         goto err;
      }
 
      lw = PHYSFS_writeBytes( f_out, buf, lr );
      if (lr != lw)
         goto err;
   } while (lr > 0);
 
   /* Close files. */
   PHYSFS_close( f_in );
   PHYSFS_close( f_out );
 
   return 0;
 
err:
   WARN( _("Failure to copy '%s' to '%s': %s"), file1, file2,
         _(PHYSFS_getErrorByCode( PHYSFS_getLastErrorCode() ) ) );
   PHYSFS_close( f_in );
   PHYSFS_close( f_out );
 
   return -1;
}
 
int ndata_matchExt( const char *path, const char *ext )
{
   int i;
   /* Find the dot. */
   for (i=strlen(path)-1; i>0; i--)
      if (path[i] == '.')
         break;
   if (i<=0)
      return 0;
   return strcmp( &path[i+1], ext )==0;
}
 
int ndata_getPathDefault( char *path, int len, const char *default_path, const char *filename )
{
   PHYSFS_Stat path_stat;
   snprintf( path, len, "%s%s", default_path, filename );
   if (PHYSFS_stat( path, &path_stat ) && (path_stat.filetype == PHYSFS_FILETYPE_REGULAR))
      return 1;
   snprintf( path, len, "%s", filename );
   if (PHYSFS_stat( path, &path_stat ) && (path_stat.filetype == PHYSFS_FILETYPE_REGULAR))
      return 1;
   return 0;
}