cfile/cfile.c

   1 /* $Id: cfile.c,v 1.30 2004-09-29 22:40:28 schaffner Exp $ */
   2 /*
   3 THE COMPUTER CODE CONTAINED HEREIN IS THE SOLE PROPERTY OF PARALLAX
   4 SOFTWARE CORPORATION ("PARALLAX").  PARALLAX, IN DISTRIBUTING THE CODE TO
   5 END-USERS, AND SUBJECT TO ALL OF THE TERMS AND CONDITIONS HEREIN, GRANTS A
   6 ROYALTY-FREE, PERPETUAL LICENSE TO SUCH END-USERS FOR USE BY SUCH END-USERS
   7 IN USING, DISPLAYING,  AND CREATING DERIVATIVE WORKS THEREOF, SO LONG AS
   8 SUCH USE, DISPLAY OR CREATION IS FOR NON-COMMERCIAL, ROYALTY OR REVENUE
   9 FREE PURPOSES.  IN NO EVENT SHALL THE END-USER USE THE COMPUTER CODE
  10 CONTAINED HEREIN FOR REVENUE-BEARING PURPOSES.  THE END-USER UNDERSTANDS
  11 AND AGREES TO THE TERMS HEREIN AND ACCEPTS THE SAME BY USE OF THIS FILE.
  12 COPYRIGHT 1993-1999 PARALLAX SOFTWARE CORPORATION.  ALL RIGHTS RESERVED.
  13 */
  14
  15 /*
  16  *
  17  * Functions for accessing compressed files.
  18  * (Actually, the files are not compressed, but concatenated within hogfiles)
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <conf.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <string.h>
  28 #ifdef _WIN32_WCE
  29 # include <windows.h>
  30 #elif defined(macintosh)
  31 # include <Files.h>
  32 # include <CFURL.h>
  33 #else
  34 # include <sys/stat.h>
  35 #endif
  36
  37 #include "pstypes.h"
  38 #include "u_mem.h"
  39 #include "strutil.h"
  40 #include "d_io.h"
  41 #include "error.h"
  42 #include "cfile.h"
  43 #include "byteswap.h"
  44
  45 /* a file (if offset == 0) or a part of a hog file */
  46 struct CFILE {
  47         FILE    *file;
  48         int     size;
  49         int     offset;
  50         int     raw_position;
  51 };
  52
  53 struct file_in_hog {
  54         char    name[13];
  55         int     offset;
  56         int     length;
  57 };
  58
  59 #define MAX_FILES_IN_HOG 300
  60
  61 /* a hog file is an archive, like a tar file */
  62 typedef struct {
  63         char filename[64];
  64         int num_files;
  65         struct file_in_hog files[MAX_FILES_IN_HOG];
  66 } hog;
  67
  68 hog *builtin_hog = NULL;
  69 hog *alt_hog = NULL;
  70 hog *d1_hog = NULL;
  71
  72 void free_builtin_hog() { d_free (builtin_hog); }
  73 void free_alt_hog() { d_free (alt_hog); }
  74 void free_d1_hog() { d_free (d1_hog); }
  75
  76 char AltHogDir[64];
  77 char AltHogdir_initialized = 0;
  78
  79 // routine to take a DOS path and turn it into a macintosh
  80 // pathname.  This routine is based on the fact that we should
  81 // see a \ character in the dos path.  The sequence .\ a tthe
  82 // beginning of a path is turned into a :
  83
  84 // routine to take a POSIX style path and turn it into a pre OS X
  85 // pathname.  This routine uses CFURL's. This function is necessary
  86 // because even though fopen exists in StdCLib
  87 // it must take a path in the OS native format.
  88
  89 #ifdef macintosh
  90 void macify_posix_path(char *posix_path, char *mac_path)
  91 {
  92     CFURLRef    url;
  93
  94     url = CFURLCreateWithBytes (kCFAllocatorDefault, (ubyte *) posix_path, strlen(posix_path), GetApplicationTextEncoding(), NULL);
  95     CFURLGetFileSystemRepresentation (url, 0, (ubyte *) mac_path, 255);
  96     CFRelease(url);
  97 }
  98 #endif
  99
 100 void cfile_use_alternate_hogdir( char * path )
 101 {
 102         if ( path )     {
 103                 strcpy( AltHogDir, path );
 104                 AltHogdir_initialized = 1;
 105         } else {
 106                 AltHogdir_initialized = 0;
 107         }
 108 }
 109
 110 //in case no one installs one
 111 int default_error_counter=0;
 112
 113 //ptr to counter of how many critical errors
 114 int *critical_error_counter_ptr=&default_error_counter;
 115
 116 //tell cfile about your critical error counter
 117 void cfile_set_critical_error_counter_ptr(int *ptr)
 118 {
 119         critical_error_counter_ptr = ptr;
 120
 121 }
 122
 123
 124 FILE * cfile_get_filehandle( char * filename, char * mode )
 125 {
 126     FILE * fp;
 127     char temp[128];
 128 #ifdef macintosh
 129     char mac_path[256];
 130 #endif
 131
 132     *critical_error_counter_ptr = 0;
 133 #ifdef macintosh
 134     macify_posix_path(filename, mac_path);
 135     fp = fopen( mac_path, mode );
 136 #else
 137     fp = fopen( filename, mode );
 138 #endif
 139     if ( fp && *critical_error_counter_ptr )    {
 140         fclose(fp);
 141         fp = NULL;
 142     }
 143     if ( (fp==NULL) && (AltHogdir_initialized) )        {
 144         strcpy( temp, AltHogDir );
 145         strcat( temp, "/");
 146         strcat( temp, filename );
 147         *critical_error_counter_ptr = 0;
 148 #ifdef macintosh
 149         macify_posix_path(temp, mac_path);
 150         fp = fopen( mac_path, mode );
 151 #else
 152         fp = fopen( temp, mode );
 153 #endif
 154         if ( fp && *critical_error_counter_ptr )        {
 155             fclose(fp);
 156             fp = NULL;
 157         }
 158     }
 159     return fp;
 160 }
 161
 162 hog * cfile_init_hogfile (char *fname)
 163 {
 164         char id[4];
 165         FILE * fp;
 166         int i, len;
 167
 168         fp = cfile_get_filehandle (fname, "rb");
 169         if (fp == NULL)
 170                 return 0;
 171
 172         // verify that it is really a Descent Hog File
 173         fread( id, 3, 1, fp );
 174         if ( strncmp( id, "DHF", 3 ) )  {
 175                 fclose(fp);
 176                 return NULL;
 177         }
 178
 179         hog *new_hog = (hog *) d_malloc (sizeof (hog));
 180
 181         new_hog->num_files = 0;
 182         strcpy (new_hog->filename, fname);
 183
 184         // read file name or reach EOF
 185         while (! feof (fp)) {
 186                 if (new_hog->num_files >= MAX_FILES_IN_HOG) {
 187                         fclose (fp);
 188                         d_free (new_hog);
 189                         Error ("Exceeded max. number of files in hog (%d).\n",
 190                                MAX_FILES_IN_HOG);
 191                 }
 192                 i = fread (new_hog->files[new_hog->num_files].name, 13, 1, fp);
 193                 if (i != 1)
 194                         break; // we assume it is EOF, so it is OK
 195
 196                 i = fread( &len, 4, 1, fp );
 197                 if (i != 1)
 198                         break;
 199                 new_hog->files[new_hog->num_files].length = INTEL_INT (len);
 200                 new_hog->files[new_hog->num_files].offset = ftell (fp);
 201                 // skip over embedded file:
 202                 i = fseek (fp, INTEL_INT (len), SEEK_CUR);
 203                 new_hog->num_files++;
 204         }
 205         fclose (fp);
 206         return new_hog;
 207 }
 208
 209 // Opens builtin hog given its filename. Returns 1 on success.
 210 int cfile_init(char *hogname)
 211 {
 212         Assert (builtin_hog == NULL);
 213
 214         builtin_hog = cfile_init_hogfile (hogname);
 215         atexit (free_builtin_hog);
 216         return builtin_hog != NULL ? 1 : 0;
 217 }
 218
 219
 220 int cfile_size(char *hogname)
 221 {
 222         CFILE *fp;
 223         int size;
 224
 225         fp = cfopen(hogname, "rb");
 226         if (fp == NULL)
 227                 return -1;
 228         size = ffilelength(fp->file);
 229         cfclose(fp);
 230         return size;
 231 }
 232
 233 FILE * cfile_find_in_hog (char * name, int * length, hog *my_hog) {
 234         FILE * fp;
 235         int i;
 236         for (i = 0; i < my_hog->num_files; i++ )
 237                 if (! stricmp (my_hog->files[i].name, name)) {
 238                         fp = cfile_get_filehandle (my_hog->filename, "rb");
 239                         if (fp == NULL)
 240                                 return NULL;
 241                         fseek (fp,  my_hog->files[i].offset, SEEK_SET);
 242                         *length = my_hog->files[i].length;
 243                         return fp;
 244                 }
 245         return NULL;
 246 }
 247
 248 /*
 249  * return handle for file called "name", embedded in one of the hogfiles
 250  */
 251 FILE * cfile_find_embedded_file (char * name, int * length)
 252 {
 253         FILE * fp;
 254         if (alt_hog) {
 255                 fp = cfile_find_in_hog (name, length, alt_hog);
 256                 if (fp)
 257                         return fp;
 258         }
 259
 260         if (builtin_hog) {
 261                 fp = cfile_find_in_hog (name, length, builtin_hog);
 262                 if (fp)
 263                         return fp;
 264         }
 265
 266         if (d1_hog) {
 267                 fp = cfile_find_in_hog (name, length, d1_hog);
 268                 if (fp)
 269                         return fp;
 270         }
 271
 272         return NULL;
 273 }
 274
 275 int cfile_use_alternate_hogfile (char * name)
 276 {
 277         if (alt_hog) {
 278                 d_free (alt_hog);
 279                 alt_hog = NULL;
 280         }
 281         if (name) {
 282                 alt_hog = cfile_init_hogfile (name);
 283                 atexit (free_alt_hog);
 284                 if (alt_hog)
 285                         return 1; // success
 286         }
 287         return 0;
 288 }
 289
 290 int cfile_use_descent1_hogfile( char * name )
 291 {
 292         if (d1_hog) {
 293                 d_free (d1_hog);
 294                 d1_hog = NULL;
 295         }
 296         if (name) {
 297                 d1_hog = cfile_init_hogfile (name);
 298                 atexit (free_d1_hog);
 299                 if (d1_hog)
 300                         return 1; // success
 301         }
 302         return 0;
 303 }
 304
 305 // cfeof() Tests for end-of-file on a stream
 306 //
 307 // returns a nonzero value after the first read operation that attempts to read
 308 // past the end of the file. It returns 0 if the current position is not end of file.
 309 // There is no error return.
 310
 311 int cfeof(CFILE *cfile)
 312 {
 313         Assert(cfile != NULL);
 314
 315         Assert(cfile->file != NULL);
 316
 317     return (cfile->raw_position >= cfile->size);
 318 }
 319
 320
 321 int cferror(CFILE *cfile)
 322 {
 323         return ferror(cfile->file);
 324 }
 325
 326
 327 int cfexist( char * filename )
 328 {
 329         int length;
 330         FILE *fp;
 331
 332
 333         if (filename[0] != '\x01')
 334                 fp = cfile_get_filehandle( filename, "rb" );            // Check for non-hog file first...
 335         else {
 336                 fp = NULL;              //don't look in dir, only in hogfile
 337                 filename++;
 338         }
 339
 340         if ( fp )       {
 341                 fclose(fp);
 342                 return 1;
 343         }
 344
 345         fp = cfile_find_embedded_file (filename, &length);
 346         if ( fp )       {
 347                 fclose(fp);
 348                 return 2;               // file found in hog
 349         }
 350
 351         return 0;               // Couldn't find it.
 352 }
 353
 354
 355 // Deletes a file.
 356 int cfile_delete(char *filename)
 357 {
 358 #ifndef _WIN32_WCE
 359         return remove(filename);
 360 #else
 361         return !DeleteFile(filename);
 362 #endif
 363 }
 364
 365
 366 // Rename a file.
 367 int cfile_rename(char *oldname, char *newname)
 368 {
 369 #ifndef _WIN32_WCE
 370         return rename(oldname, newname);
 371 #else
 372         return !MoveFile(oldname, newname);
 373 #endif
 374 }
 375
 376
 377 // Make a directory.
 378 int cfile_mkdir(char *pathname)
 379 {
 380 #ifdef _WIN32
 381 # ifdef _WIN32_WCE
 382         return !CreateDirectory(pathname, NULL);
 383 # else
 384         return _mkdir(pathname);
 385 # endif
 386 #elif defined(macintosh)
 387     char        mac_path[256];
 388     Str255      pascal_path;
 389     long        dirID;  // Insists on returning this
 390
 391     macify_posix_path(pathname, mac_path);
 392     CopyCStringToPascal(mac_path, pascal_path);
 393     return DirCreate(0, 0, pascal_path, &dirID);
 394 #else
 395         return mkdir(pathname, 0755);
 396 #endif
 397 }
 398
 399
 400 CFILE * cfopen(char * filename, char * mode )
 401 {
 402         int length;
 403         FILE * fp;
 404         CFILE *cfile;
 405
 406         if (filename[0] != '\x01')
 407                 fp = cfile_get_filehandle( filename, mode );            // Check for non-hog file first...
 408         else {
 409                 fp = NULL;              //don't look in dir, only in hogfile
 410                 filename++;
 411         }
 412
 413         if ( !fp ) {
 414                 fp = cfile_find_embedded_file (filename, &length);
 415                 if ( !fp )
 416                         return NULL;            // No file found
 417                 if (stricmp(mode, "rb"))
 418                         Error("mode must be rb for files in hog.\n");
 419                 cfile = d_malloc ( sizeof(CFILE) );
 420                 if ( cfile == NULL ) {
 421                         fclose(fp);
 422                         return NULL;
 423                 }
 424                 cfile->file = fp;
 425                 cfile->size = length;
 426                 cfile->offset = ftell( fp );
 427                 cfile->raw_position = 0;
 428                 return cfile;
 429         } else {
 430                 cfile = d_malloc ( sizeof(CFILE) );
 431                 if ( cfile == NULL ) {
 432                         fclose(fp);
 433                         return NULL;
 434                 }
 435                 cfile->file = fp;
 436                 cfile->size = ffilelength(fp);
 437                 cfile->offset = 0;
 438                 cfile->raw_position = 0;
 439                 return cfile;
 440         }
 441 }
 442
 443 int cfilelength( CFILE *fp )
 444 {
 445         return fp->size;
 446 }
 447
 448
 449 // cfwrite() writes to the file
 450 //
 451 // returns:   number of full elements actually written
 452 //
 453 //
 454 int cfwrite(void *buf, int elsize, int nelem, CFILE *cfile)
 455 {
 456         int items_written;
 457
 458         Assert(cfile != NULL);
 459         Assert(buf != NULL);
 460         Assert(elsize > 0);
 461
 462         Assert(cfile->file != NULL);
 463         Assert(cfile->offset == 0);
 464
 465         items_written = fwrite(buf, elsize, nelem, cfile->file);
 466         cfile->raw_position = ftell(cfile->file);
 467
 468         return items_written;
 469 }
 470
 471
 472 // cfputc() writes a character to a file
 473 //
 474 // returns:   success ==> returns character written
 475 //            error   ==> EOF
 476 //
 477 int cfputc(int c, CFILE *cfile)
 478 {
 479         int char_written;
 480
 481         Assert(cfile != NULL);
 482
 483         Assert(cfile->file != NULL);
 484         Assert(cfile->offset == 0);
 485
 486         char_written = fputc(c, cfile->file);
 487         cfile->raw_position = ftell(cfile->file);
 488
 489         return char_written;
 490 }
 491
 492
 493 int cfgetc( CFILE * fp )
 494 {
 495         int c;
 496
 497         if (fp->raw_position >= fp->size ) return EOF;
 498
 499         c = getc( fp->file );
 500         if (c!=EOF)
 501                 fp->raw_position = ftell(fp->file)-fp->offset;
 502
 503         return c;
 504 }
 505
 506
 507 // cfputs() writes a string to a file
 508 //
 509 // returns:   success ==> non-negative value
 510 //            error   ==> EOF
 511 //
 512 int cfputs(char *str, CFILE *cfile)
 513 {
 514         int ret;
 515
 516         Assert(cfile != NULL);
 517         Assert(str != NULL);
 518
 519         Assert(cfile->file != NULL);
 520
 521         ret = fputs(str, cfile->file);
 522         cfile->raw_position = ftell(cfile->file);
 523
 524         return ret;
 525 }
 526
 527
 528 char * cfgets( char * buf, size_t n, CFILE * fp )
 529 {
 530         int i;
 531         int c;
 532
 533 #if 0 // don't use the standard fgets, because it will only handle the native line-ending style
 534         if (fp->offset == 0) // This is not an archived file
 535         {
 536                 t = fgets(buf, n, fp->file);
 537                 fp->raw_position = ftell(fp->file);
 538                 return t;
 539         }
 540 #endif
 541
 542         for (i=0; i<n-1; i++ ) {
 543                 do {
 544                         if (fp->raw_position >= fp->size ) {
 545                                 *buf = 0;
 546                                 return NULL;
 547                         }
 548                         c = cfgetc(fp);
 549                         if (c == 0 || c == 10)        // Unix line ending
 550                                 break;
 551                         if (c == 13) {      // Mac or DOS line ending
 552                                 int c1;
 553
 554                                 c1 = cfgetc(fp);
 555                                 if (c1 != EOF)  // The file could end with a Mac line ending
 556                                         cfseek(fp, -1, SEEK_CUR);
 557                                 if ( c1 == 10 ) // DOS line ending
 558                                         continue;
 559                                 else            // Mac line ending
 560                                         break;
 561                         }
 562                 } while ( c == 13 );
 563                 if ( c == 13 )  // because cr-lf is a bad thing on the mac
 564                         c = '\n';   // and anyway -- 0xod is CR on mac, not 0x0a
 565                 if ( c=='\n' ) break;
 566                 *buf++ = c;
 567         }
 568         *buf++ = 0;
 569         return  buf;
 570 }
 571
 572 size_t cfread( void * buf, size_t elsize, size_t nelem, CFILE * fp )
 573 {
 574         unsigned int i, size;
 575
 576         size = elsize * nelem;
 577         if ( size < 1 ) return 0;
 578
 579         i = fread ( buf, 1, size, fp->file );
 580         fp->raw_position += i;
 581         return i/elsize;
 582 }
 583
 584
 585 int cftell( CFILE *fp )
 586 {
 587         return fp->raw_position;
 588 }
 589
 590 int cfseek( CFILE *fp, long int offset, int where )
 591 {
 592         int c, goal_position;
 593
 594         switch( where ) {
 595         case SEEK_SET:
 596                 goal_position = offset;
 597                 break;
 598         case SEEK_CUR:
 599                 goal_position = fp->raw_position+offset;
 600                 break;
 601         case SEEK_END:
 602                 goal_position = fp->size+offset;
 603                 break;
 604         default:
 605                 return 1;
 606         }
 607         c = fseek( fp->file, fp->offset + goal_position, SEEK_SET );
 608         fp->raw_position = ftell(fp->file)-fp->offset;
 609         return c;
 610 }
 611
 612 int cfclose(CFILE *fp)
 613 {
 614         int result;
 615
 616         result = fclose(fp->file);
 617         d_free(fp);
 618
 619         return result;
 620 }
 621
 622 // routines to read basic data types from CFILE's.  Put here to
 623 // simplify mac/pc reading from cfiles.
 624
 625 int cfile_read_int(CFILE *file)
 626 {
 627         int32_t i;
 628
 629         if (cfread( &i, sizeof(i), 1, file) != 1)
 630                 Error( "Error reading int in cfile_read_int()" );
 631
 632         i = INTEL_INT(i);
 633         return i;
 634 }
 635
 636 short cfile_read_short(CFILE *file)
 637 {
 638         int16_t s;
 639
 640         if (cfread( &s, sizeof(s), 1, file) != 1)
 641                 Error( "Error reading short in cfile_read_short()" );
 642
 643         s = INTEL_SHORT(s);
 644         return s;
 645 }
 646
 647 sbyte cfile_read_byte(CFILE *file)
 648 {
 649         sbyte b;
 650
 651         if (cfread( &b, sizeof(b), 1, file) != 1)
 652                 Error( "Error reading byte in cfile_read_byte()" );
 653
 654         return b;
 655 }
 656
 657 fix cfile_read_fix(CFILE *file)
 658 {
 659         fix f;
 660
 661         if (cfread( &f, sizeof(f), 1, file) != 1)
 662                 Error( "Error reading fix in cfile_read_fix()" );
 663
 664         f = (fix)INTEL_INT((int)f);
 665         return f;
 666 }
 667
 668 fixang cfile_read_fixang(CFILE *file)
 669 {
 670         fixang f;
 671
 672         if (cfread(&f, 2, 1, file) != 1)
 673                 Error("Error reading fixang in cfile_read_fixang()");
 674
 675         f = (fixang) INTEL_SHORT((int) f);
 676         return f;
 677 }
 678
 679 void cfile_read_vector(vms_vector *v, CFILE *file)
 680 {
 681         v->x = cfile_read_fix(file);
 682         v->y = cfile_read_fix(file);
 683         v->z = cfile_read_fix(file);
 684 }
 685
 686 void cfile_read_angvec(vms_angvec *v, CFILE *file)
 687 {
 688         v->p = cfile_read_fixang(file);
 689         v->b = cfile_read_fixang(file);
 690         v->h = cfile_read_fixang(file);
 691 }
 692
 693 void cfile_read_matrix(vms_matrix *m,CFILE *file)
 694 {
 695         cfile_read_vector(&m->rvec,file);
 696         cfile_read_vector(&m->uvec,file);
 697         cfile_read_vector(&m->fvec,file);
 698 }
 699
 700
 701 void cfile_read_string(char *buf, int n, CFILE *file)
 702 {
 703         char c;
 704
 705         do {
 706                 c = (char)cfile_read_byte(file);
 707                 if (n > 0)
 708                 {
 709                         *buf++ = c;
 710                         n--;
 711                 }
 712         } while (c != 0);
 713 }
 714
 715
 716 // equivalent write functions of above read functions follow
 717
 718 int cfile_write_int(int i, CFILE *file)
 719 {
 720         i = INTEL_INT(i);
 721         return cfwrite(&i, sizeof(i), 1, file);
 722 }
 723
 724
 725 int cfile_write_short(short s, CFILE *file)
 726 {
 727         s = INTEL_SHORT(s);
 728         return cfwrite(&s, sizeof(s), 1, file);
 729 }
 730
 731
 732 int cfile_write_byte(sbyte b, CFILE *file)
 733 {
 734         return cfwrite(&b, sizeof(b), 1, file);
 735 }
 736
 737
 738 int cfile_write_string(char *buf, CFILE *file)
 739 {
 740         int len;
 741
 742         if ((!buf) || (buf && !buf[0]))
 743                 return cfile_write_byte(0, file);
 744
 745         len = strlen(buf);
 746         if (!cfwrite(buf, len, 1, file))
 747                 return 0;
 748
 749         return cfile_write_byte(0, file);   // write out NULL termination
 750 }