602 lines
16 KiB
C
602 lines
16 KiB
C
/******************************************************************************
|
|
* Copyright (c) 2005 Eric Petit
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
* to deal in the Software without restriction, including without limitation
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
* DEALINGS IN THE SOFTWARE.
|
|
*****************************************************************************/
|
|
|
|
#include "transmission.h"
|
|
|
|
#ifdef SYS_BEOS
|
|
# define fseeko _fseek
|
|
#endif
|
|
|
|
struct tr_io_s
|
|
{
|
|
tr_torrent_t * tor;
|
|
|
|
/* Position of pieces
|
|
-1 = we haven't started to download this piece yet
|
|
n = we have started or completed the piece in slot n */
|
|
int * pieceSlot;
|
|
|
|
/* Pieces in slot
|
|
-1 = unused slot
|
|
n = piece n */
|
|
int * slotPiece;
|
|
|
|
int slotsUsed;
|
|
};
|
|
|
|
#include "fastresume.h"
|
|
|
|
/***********************************************************************
|
|
* Local prototypes
|
|
**********************************************************************/
|
|
static int createFiles( tr_io_t * );
|
|
static int checkFiles( tr_io_t * );
|
|
static void closeFiles( tr_io_t * );
|
|
static int readOrWriteBytes( tr_io_t *, uint64_t, int, uint8_t *, int );
|
|
static int readOrWriteSlot( tr_io_t * io, int slot, uint8_t * buf,
|
|
int * size, int write );
|
|
static void findSlotForPiece( tr_io_t *, int );
|
|
|
|
#define readBytes(io,o,s,b) readOrWriteBytes(io,o,s,b,0)
|
|
#define writeBytes(io,o,s,b) readOrWriteBytes(io,o,s,b,1)
|
|
|
|
#define readSlot(io,sl,b,s) readOrWriteSlot(io,sl,b,s,0)
|
|
#define writeSlot(io,sl,b,s) readOrWriteSlot(io,sl,b,s,1)
|
|
|
|
/***********************************************************************
|
|
* tr_ioInit
|
|
***********************************************************************
|
|
* Open all files we are going to write to
|
|
**********************************************************************/
|
|
tr_io_t * tr_ioInit( tr_torrent_t * tor )
|
|
{
|
|
tr_io_t * io;
|
|
|
|
io = malloc( sizeof( tr_io_t ) );
|
|
io->tor = tor;
|
|
|
|
if( createFiles( io ) || checkFiles( io ) )
|
|
{
|
|
free( io );
|
|
return NULL;
|
|
}
|
|
|
|
return io;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* tr_ioRead
|
|
***********************************************************************
|
|
*
|
|
**********************************************************************/
|
|
int tr_ioRead( tr_io_t * io, int index, int begin, int length,
|
|
uint8_t * buf )
|
|
{
|
|
uint64_t offset;
|
|
tr_info_t * inf = &io->tor->info;
|
|
|
|
offset = (uint64_t) io->pieceSlot[index] *
|
|
(uint64_t) inf->pieceSize + (uint64_t) begin;
|
|
|
|
return readBytes( io, offset, length, buf );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* tr_ioWrite
|
|
***********************************************************************
|
|
*
|
|
**********************************************************************/
|
|
int tr_ioWrite( tr_io_t * io, int index, int begin, int length,
|
|
uint8_t * buf )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &io->tor->info;
|
|
uint64_t offset;
|
|
int i;
|
|
uint8_t hash[SHA_DIGEST_LENGTH];
|
|
uint8_t * pieceBuf;
|
|
int pieceSize;
|
|
int startBlock, endBlock;
|
|
|
|
if( io->pieceSlot[index] < 0 )
|
|
{
|
|
findSlotForPiece( io, index );
|
|
tr_inf( "Piece %d: starting in slot %d", index,
|
|
io->pieceSlot[index] );
|
|
}
|
|
|
|
offset = (uint64_t) io->pieceSlot[index] *
|
|
(uint64_t) inf->pieceSize + (uint64_t) begin;
|
|
|
|
if( writeBytes( io, offset, length, buf ) )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
startBlock = tr_pieceStartBlock( index );
|
|
endBlock = startBlock + tr_pieceCountBlocks( index );
|
|
for( i = startBlock; i < endBlock; i++ )
|
|
{
|
|
if( tor->blockHave[i] >= 0 )
|
|
{
|
|
/* The piece is not complete */
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* The piece is complete, check the hash */
|
|
pieceSize = tr_pieceSize( index );
|
|
pieceBuf = malloc( pieceSize );
|
|
readBytes( io, (uint64_t) io->pieceSlot[index] *
|
|
(uint64_t) inf->pieceSize, pieceSize, pieceBuf );
|
|
SHA1( pieceBuf, pieceSize, hash );
|
|
free( pieceBuf );
|
|
|
|
if( memcmp( hash, &inf->pieces[20*index], SHA_DIGEST_LENGTH ) )
|
|
{
|
|
tr_inf( "Piece %d (slot %d): hash FAILED", index,
|
|
io->pieceSlot[index] );
|
|
|
|
/* We will need to reload the whole piece */
|
|
for( i = startBlock; i < endBlock; i++ )
|
|
{
|
|
tor->blockHave[i] = 0;
|
|
tor->blockHaveCount -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
tr_inf( "Piece %d (slot %d): hash OK", index,
|
|
io->pieceSlot[index] );
|
|
tr_bitfieldAdd( tor->bitfield, index );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void tr_ioClose( tr_io_t * io )
|
|
{
|
|
closeFiles( io );
|
|
|
|
fastResumeSave( io );
|
|
|
|
free( io->pieceSlot );
|
|
free( io->slotPiece );
|
|
free( io );
|
|
}
|
|
|
|
/***********************************************************************
|
|
* createFiles
|
|
***********************************************************************
|
|
* Make sure the existing folders/files have correct types and
|
|
* permissions, and create missing folders and files
|
|
**********************************************************************/
|
|
static int createFiles( tr_io_t * io )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
int i;
|
|
char * path, * p;
|
|
struct stat sb;
|
|
FILE * file;
|
|
|
|
tr_dbg( "Creating files..." );
|
|
|
|
for( i = 0; i < inf->fileCount; i++ )
|
|
{
|
|
asprintf( &path, "%s/%s", tor->destination, inf->files[i].name );
|
|
|
|
/* Create folders */
|
|
p = path;
|
|
while( ( p = strchr( p, '/' ) ) )
|
|
{
|
|
*p = '\0';
|
|
if( stat( path, &sb ) )
|
|
{
|
|
/* Folder doesn't exist yet */
|
|
mkdir( path, 0755 );
|
|
}
|
|
else if( ( sb.st_mode & S_IFMT ) != S_IFDIR )
|
|
{
|
|
/* Node exists but isn't a folder */
|
|
printf( "Remove %s, it's in the way.\n", path );
|
|
free( path );
|
|
return 1;
|
|
}
|
|
*p = '/';
|
|
p++;
|
|
}
|
|
|
|
if( stat( path, &sb ) )
|
|
{
|
|
/* File doesn't exist yet */
|
|
if( !( file = fopen( path, "w" ) ) )
|
|
{
|
|
tr_err( "Could not create `%s' (%s)", path,
|
|
strerror( errno ) );
|
|
free( path );
|
|
return 1;
|
|
}
|
|
fclose( file );
|
|
}
|
|
else if( ( sb.st_mode & S_IFMT ) != S_IFREG )
|
|
{
|
|
/* Node exists but isn't a file */
|
|
printf( "Remove %s, it's in the way.\n", path );
|
|
free( path );
|
|
return 1;
|
|
}
|
|
|
|
free( path );
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* checkFiles
|
|
***********************************************************************
|
|
* Look for pieces
|
|
**********************************************************************/
|
|
static int checkFiles( tr_io_t * io )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
int i;
|
|
uint8_t * buf;
|
|
uint8_t hash[SHA_DIGEST_LENGTH];
|
|
int startBlock, endBlock;
|
|
|
|
io->pieceSlot = malloc( inf->pieceCount * sizeof( int ) );
|
|
io->slotPiece = malloc( inf->pieceCount * sizeof( int ) );
|
|
|
|
if( !fastResumeLoad( io ) )
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
tr_dbg( "Checking pieces..." );
|
|
|
|
/* Yet we don't have anything */
|
|
memset( io->pieceSlot, 0xFF, inf->pieceCount * sizeof( int ) );
|
|
memset( io->slotPiece, 0xFF, inf->pieceCount * sizeof( int ) );
|
|
memset( tor->bitfield, 0, ( inf->pieceCount + 7 ) / 8 );
|
|
memset( tor->blockHave, 0, tor->blockCount );
|
|
tor->blockHaveCount = 0;
|
|
|
|
/* Check pieces */
|
|
io->slotsUsed = 0;
|
|
buf = malloc( inf->pieceSize );
|
|
for( i = 0; i < inf->pieceCount; i++ )
|
|
{
|
|
int size, j;
|
|
|
|
if( readSlot( io, i, buf, &size ) )
|
|
{
|
|
break;
|
|
}
|
|
|
|
io->slotsUsed = i + 1;
|
|
SHA1( buf, size, hash );
|
|
|
|
for( j = i; j < inf->pieceCount - 1; j++ )
|
|
{
|
|
if( !memcmp( hash, &inf->pieces[20*j], SHA_DIGEST_LENGTH ) )
|
|
{
|
|
int k;
|
|
io->pieceSlot[j] = i;
|
|
io->slotPiece[i] = j;
|
|
tr_bitfieldAdd( tor->bitfield, j );
|
|
|
|
startBlock = tr_pieceStartBlock( j );
|
|
endBlock = startBlock + tr_pieceCountBlocks( j );
|
|
for( k = startBlock; k < endBlock; k++ )
|
|
{
|
|
tor->blockHave[k] = -1;
|
|
tor->blockHaveCount++;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( io->slotPiece[i] > -1 )
|
|
{
|
|
continue;
|
|
}
|
|
|
|
/* Special case for the last piece */
|
|
SHA1( buf, tr_pieceSize( inf->pieceCount - 1 ), hash );
|
|
if( !memcmp( hash, &inf->pieces[20 * (inf->pieceCount - 1)],
|
|
SHA_DIGEST_LENGTH ) )
|
|
{
|
|
io->pieceSlot[inf->pieceCount - 1] = i;
|
|
io->slotPiece[i] = inf->pieceCount - 1;
|
|
tr_bitfieldAdd( tor->bitfield, inf->pieceCount - 1 );
|
|
|
|
startBlock = tr_pieceStartBlock( inf->pieceCount - 1 );
|
|
endBlock = startBlock +
|
|
tr_pieceCountBlocks( inf->pieceCount - 1 );
|
|
for( j = startBlock; j < endBlock; j++ )
|
|
{
|
|
tor->blockHave[j] = -1;
|
|
tor->blockHaveCount++;
|
|
}
|
|
}
|
|
}
|
|
free( buf );
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* closeFiles
|
|
**********************************************************************/
|
|
static void closeFiles( tr_io_t * io )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
int i;
|
|
char * path;
|
|
|
|
for( i = 0; i < inf->fileCount; i++ )
|
|
{
|
|
asprintf( &path, "%s/%s", tor->destination, inf->files[i].name );
|
|
tr_fdFileClose( tor->fdlimit, path );
|
|
free( path );
|
|
}
|
|
}
|
|
|
|
/***********************************************************************
|
|
* readOrWriteBytes
|
|
***********************************************************************
|
|
*
|
|
**********************************************************************/
|
|
static int readOrWriteBytes( tr_io_t * io, uint64_t offset, int size,
|
|
uint8_t * buf, int write )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
int piece = offset / inf->pieceSize;
|
|
int begin = offset % inf->pieceSize;
|
|
|
|
int i;
|
|
uint64_t foo;
|
|
uint64_t posInFile = 0;
|
|
int willRead;
|
|
char * path;
|
|
FILE * file;
|
|
|
|
/* We can't ever read or write more than a piece at a time */
|
|
if( tr_pieceSize( piece ) < begin + size )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* Find which file we shall start reading/writing in */
|
|
foo = 0;
|
|
for( i = 0; i < inf->fileCount; i++ )
|
|
{
|
|
if( offset < foo + inf->files[i].length )
|
|
{
|
|
posInFile = offset - foo;
|
|
break;
|
|
}
|
|
foo += inf->files[i].length;
|
|
}
|
|
|
|
while( size > 0 )
|
|
{
|
|
asprintf( &path, "%s/%s", tor->destination, inf->files[i].name );
|
|
file = tr_fdFileOpen( tor->fdlimit, path );
|
|
free( path );
|
|
|
|
if( !file )
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
willRead = MIN( inf->files[i].length - posInFile,
|
|
(uint64_t) size );
|
|
|
|
if( fseeko( file, posInFile, SEEK_SET ) )
|
|
{
|
|
return 1;
|
|
}
|
|
if( write )
|
|
{
|
|
if( fwrite( buf, willRead, 1, file ) != 1 )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( fread( buf, willRead, 1, file ) != 1 )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
tr_fdFileRelease( tor->fdlimit, file );
|
|
|
|
/* 'willRead' less bytes to do */
|
|
size -= willRead;
|
|
buf += willRead;
|
|
|
|
/* Go to the beginning of the next file */
|
|
i += 1;
|
|
posInFile = 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/***********************************************************************
|
|
* readSlot
|
|
***********************************************************************
|
|
*
|
|
**********************************************************************/
|
|
static int readOrWriteSlot( tr_io_t * io, int slot, uint8_t * buf,
|
|
int * size, int write )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
uint64_t offset = (uint64_t) slot * (uint64_t) inf->pieceSize;
|
|
|
|
*size = 0;
|
|
if( slot == inf->pieceCount - 1 )
|
|
{
|
|
*size = inf->totalSize % inf->pieceSize;
|
|
}
|
|
if( !*size )
|
|
{
|
|
*size = inf->pieceSize;
|
|
}
|
|
|
|
return readOrWriteBytes( io, offset, *size, buf, write );
|
|
}
|
|
|
|
static void invertSlots( tr_io_t * io, int slot1, int slot2 )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
uint8_t * buf1, * buf2;
|
|
int piece1, piece2, foo;
|
|
|
|
buf1 = calloc( inf->pieceSize, 1 );
|
|
buf2 = calloc( inf->pieceSize, 1 );
|
|
|
|
readSlot( io, slot1, buf1, &foo );
|
|
readSlot( io, slot2, buf2, &foo );
|
|
|
|
writeSlot( io, slot1, buf2, &foo );
|
|
writeSlot( io, slot2, buf1, &foo );
|
|
|
|
free( buf1 );
|
|
free( buf2 );
|
|
|
|
piece1 = io->slotPiece[slot1];
|
|
piece2 = io->slotPiece[slot2];
|
|
io->slotPiece[slot1] = piece2;
|
|
io->slotPiece[slot2] = piece1;
|
|
if( piece1 >= 0 )
|
|
{
|
|
io->pieceSlot[piece1] = slot2;
|
|
}
|
|
if( piece2 >= 0 )
|
|
{
|
|
io->pieceSlot[piece2] = slot1;
|
|
}
|
|
}
|
|
|
|
static void reorderPieces( tr_io_t * io )
|
|
{
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
int i, didInvert;
|
|
|
|
/* Try to move pieces to their final places */
|
|
do
|
|
{
|
|
didInvert = 0;
|
|
|
|
for( i = 0; i < inf->pieceCount; i++ )
|
|
{
|
|
if( io->pieceSlot[i] < 0 )
|
|
{
|
|
/* We haven't started this piece yet */
|
|
continue;
|
|
}
|
|
if( io->pieceSlot[i] == i )
|
|
{
|
|
/* Already in place */
|
|
continue;
|
|
}
|
|
if( i >= io->slotsUsed )
|
|
{
|
|
/* File is not big enough yet */
|
|
continue;
|
|
}
|
|
|
|
/* Move piece i into slot i */
|
|
tr_inf( "invert %d and %d", io->pieceSlot[i], i );
|
|
invertSlots( io, i, io->pieceSlot[i] );
|
|
didInvert = 1;
|
|
}
|
|
} while( didInvert );
|
|
}
|
|
|
|
static void findSlotForPiece( tr_io_t * io, int piece )
|
|
{
|
|
int i;
|
|
#if 0
|
|
tr_torrent_t * tor = io->tor;
|
|
tr_info_t * inf = &tor->info;
|
|
|
|
tr_dbg( "Entering findSlotForPiece" );
|
|
|
|
for( i = 0; i < inf->pieceCount; i++ )
|
|
printf( "%02d ", io->slotPiece[i] );
|
|
printf( "\n" );
|
|
for( i = 0; i < inf->pieceCount; i++ )
|
|
printf( "%02d ", io->pieceSlot[i] );
|
|
printf( "\n" );
|
|
#endif
|
|
|
|
/* Look for an empty slot somewhere */
|
|
for( i = 0; i < io->slotsUsed; i++ )
|
|
{
|
|
if( io->slotPiece[i] < 0 )
|
|
{
|
|
io->pieceSlot[piece] = i;
|
|
io->slotPiece[i] = piece;
|
|
goto reorder;
|
|
}
|
|
}
|
|
|
|
/* No empty slot, extend the file */
|
|
io->pieceSlot[piece] = io->slotsUsed;
|
|
io->slotPiece[io->slotsUsed] = piece;
|
|
(io->slotsUsed)++;
|
|
|
|
reorder:
|
|
reorderPieces( io );
|
|
|
|
#if 0
|
|
for( i = 0; i < inf->pieceCount; i++ )
|
|
printf( "%02d ", io->slotPiece[i] );
|
|
printf( "\n" );
|
|
for( i = 0; i < inf->pieceCount; i++ )
|
|
printf( "%02d ", io->pieceSlot[i] );
|
|
printf( "\n" );
|
|
|
|
printf( "Leaving findSlotForPiece\n" );
|
|
#endif
|
|
}
|