kdat/File.cpp

   1 // KDat - a tar-based DAT archiver
   2 // Copyright (C) 1998-2000  Sean Vyain, svyain@mail.tds.net
   3 // Copyright (C) 2001-2002  Lawrence Widman, kdat@cardiothink.com
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 2 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU 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  USA
  18
  19 #include <assert.h>
  20 #include <values.h>
  21
  22 #include "File.h"
  23 //Added by qt3to4:
  24 #include <Q3PtrList>
  25
  26 File::File( File* parent, int size, int mtime, int startRecord, int endRecord, const QString & name )
  27         : _stubbed( FALSE ),
  28           _name( name ),
  29           _parent( parent )
  30 {
  31     assert( endRecord >= startRecord );
  32
  33     _union._data._size        = size;
  34     _union._data._mtime       = mtime;
  35     _union._data._startRecord = startRecord;
  36     _union._data._endRecord   = endRecord;
  37 }
  38
  39 File::File( File* parent, FILE* fptr, int offset )
  40         : _stubbed( TRUE ),
  41           _parent( parent )
  42 {
  43     _union._stub._fptr   = fptr;
  44     _union._stub._offset = offset;
  45 }
  46
  47 File::~File()
  48 {
  49     while ( _children.first() ) {
  50         delete _children.first();
  51         _children.removeFirst();
  52     }
  53 }
  54
  55 void File::read( int version )
  56 {
  57     if ( !_stubbed ) {
  58         return;
  59     }
  60
  61     _stubbed = FALSE;
  62
  63     FILE* fptr = _union._stub._fptr;
  64
  65     fseek( fptr, _union._stub._offset, SEEK_SET );
  66
  67     // File name (4 bytes + n chars).
  68     int ival;
  69     fread( &ival, sizeof( ival ), 1, fptr );
  70
  71     char * buf = new char[ival+1];
  72     buf[ival] = '\0';
  73     fread( buf, sizeof( char ), ival, fptr );
  74     _name = buf;
  75
  76     delete [] buf;
  77
  78     // File size (4 bytes).
  79     fread( &ival, sizeof( ival ), 1, fptr );
  80     _union._data._size = ival;
  81
  82     // File modification time (4 bytes).
  83     fread( &ival, sizeof( ival ), 1, fptr );
  84     _union._data._mtime = ival;
  85
  86     // Start record number.
  87     fread( &ival, sizeof( ival ), 1, fptr );
  88     _union._data._startRecord = ival;
  89
  90     // End record number.
  91     fread( &ival, sizeof( ival ), 1, fptr );
  92     _union._data._endRecord = ival;
  93
  94     //%%% This is a kludge to cope with some screwed up tape indexes.
  95     //%%% Hopefully the file with the zero end record is *always* at
  96     //%%% the end of the archive.
  97     if ( ( _union._data._endRecord <= 0 ) && ( _union._data._startRecord != _union._data._endRecord ) ) {
  98         _union._data._endRecord = MAXINT;
  99     }
 100
 101     if ( version > 3 ) {
 102         fread( &ival, sizeof( ival ), 1, fptr );
 103         int rc = ival;
 104         int start = 0;
 105         int end = 0;
 106         for ( int ii = 0; ii < rc; ii++ ) {
 107             fread( &ival, sizeof( ival ), 1, fptr );
 108             start = ival;
 109             fread( &ival, sizeof( ival ), 1, fptr );
 110             end = ival;
 111             _ranges.addRange( start, end );
 112         }
 113     }
 114
 115     //===== Read files =====
 116     fread( &ival, sizeof( ival ), 1, fptr );
 117     for ( int count = ival; count > 0; count-- ) {
 118         fread( &ival, sizeof( ival ), 1, fptr );
 119         addChild( new File( this, fptr, ival ) );
 120     }
 121 }
 122
 123 void File::readAll( int version )
 124 {
 125     read( version );
 126
 127     Q3PtrListIterator<File> i( getChildren() );
 128     for ( ; i.current(); ++i ) {
 129         i.current()->readAll( version );
 130     }
 131 }
 132
 133 void File::write( FILE* fptr )
 134 {
 135     int zero = 0;
 136
 137     // File name (4 bytes + n chars).
 138     int ival = getName().length();
 139     fwrite( &ival, sizeof( ival ), 1, fptr );
 140     fwrite( getName().ascii(), sizeof( char ), ival, fptr );
 141
 142     // File size (4 bytes).
 143     ival = getSize();
 144     fwrite( &ival, sizeof( ival ), 1, fptr );
 145
 146     // File modification time (4 bytes).
 147     ival = getMTime();
 148     fwrite( &ival, sizeof( ival ), 1, fptr );
 149
 150     // Start record number.
 151     ival = getStartRecord();
 152     fwrite( &ival, sizeof( ival ), 1, fptr );
 153
 154     // End record number.
 155     ival = getEndRecord();
 156     fwrite( &ival, sizeof( ival ), 1, fptr );
 157
 158     // Child range list.
 159     ival = _ranges.getRanges().count();
 160     fwrite( &ival, sizeof( ival ), 1, fptr );
 161     Q3PtrListIterator<Range> it( _ranges.getRanges() );
 162     for ( ; it.current(); ++it ) {
 163         ival = it.current()->getStart();
 164         fwrite( &ival, sizeof( ival ), 1, fptr );
 165         ival = it.current()->getEnd();
 166         fwrite( &ival, sizeof( ival ), 1, fptr );
 167     }
 168
 169     // Number of immediate children (4 bytes).
 170     ival = getChildren().count();
 171     fwrite( &ival, sizeof( ival ), 1, fptr );
 172
 173     // Fill in file offsets later...
 174     int fileTable = ftell( fptr );
 175     for ( ; ival > 0; ival-- ) {
 176         fwrite( &zero, sizeof( zero ), 1, fptr );
 177     }
 178
 179     //===== Write files =====
 180     ival = _children.count();
 181     fwrite( &ival, sizeof( ival ), 1, fptr );
 182
 183     Q3PtrListIterator<File> i( _children );
 184     int count = 0;
 185     for ( ; i.current(); ++i, count++ ) {
 186         // Fill in the file offset.
 187         int here = ftell( fptr );
 188         fseek( fptr, fileTable + 4*count, SEEK_SET );
 189         fwrite( &here, sizeof( here ), 1, fptr );
 190         fseek( fptr, here, SEEK_SET );
 191
 192         i.current()->write( fptr );
 193     }
 194 }
 195
 196 bool File::isDirectory()
 197 {
 198     read();
 199
 200     return _name[ _name.length() - 1 ] == '/';
 201 }
 202
 203 int File::getSize()
 204 {
 205     read();
 206
 207     return _union._data._size;
 208 }
 209
 210 int File::getMTime()
 211 {
 212     read();
 213
 214     return _union._data._mtime;
 215 }
 216
 217 int File::getStartRecord()
 218 {
 219     read();
 220
 221     return _union._data._startRecord;
 222 }
 223
 224 int File::getEndRecord()
 225 {
 226     read();
 227
 228     return _union._data._endRecord;
 229 }
 230
 231 QString File::getName()
 232 {
 233     read();
 234
 235     return _name;
 236 }
 237
 238 QString File::getFullPathName()
 239 {
 240     QString tmp = _name.copy();
 241     for ( File* parent = getParent(); parent; parent = parent->getParent() ) {
 242         tmp.prepend( parent->getName() );
 243     }
 244
 245     return tmp;
 246 }
 247
 248 File* File::getParent()
 249 {
 250     return _parent;
 251 }
 252
 253 const Q3PtrList<File>& File::getChildren()
 254 {
 255     read();
 256
 257     return _children;
 258 }
 259
 260 const Q3PtrList<Range>& File::getRanges()
 261 {
 262     read();
 263
 264     return _ranges.getRanges();
 265 }
 266
 267 void File::addChild( File* file )
 268 {
 269     read();
 270
 271     _children.append( file );
 272 }
 273
 274 void File::calcRanges()
 275 {
 276     assert( !_stubbed );
 277
 278     _ranges.clear();
 279     _ranges.addRange( getStartRecord(), getEndRecord() );
 280
 281     Q3PtrListIterator<File> it( getChildren() );
 282     for ( ; it.current(); ++it ) {
 283         it.current()->calcRanges();
 284         Q3PtrListIterator<Range> it2( it.current()->getRanges() );
 285         for ( ; it2.current(); ++it2 ) {
 286             _ranges.addRange( it2.current()->getStart(), it2.current()->getEnd() );
 287         }
 288     }
 289 }