Changeset 1356 for trunk/libtransmission/inout.c

Timestamp:

Jan 14, 2007, 12:00:21 PM (15 years ago)

Author:

titer

Message:

Merge io branch into trunk

File:

• trunk/libtransmission/inout.c (modified) (14 diffs)

trunk/libtransmission/inout.c

@@ -47 +47 @@
  * Local prototypes
  **********************************************************************/
-static int  createFiles( tr_io_t * );
 static int  checkFiles( tr_io_t * );
 static void closeFiles( tr_io_t * );
@@ -96 +95 @@
     io->tor = tor;
 
-    if( createFiles( io ) || checkFiles( io ) )
+    if( checkFiles( io ) )
     {
         free( io );
@@ -107 +106 @@
 /***********************************************************************
  * tr_ioRead
- ***********************************************************************
- *
  **********************************************************************/
 int tr_ioRead( tr_io_t * io, int index, int begin, int length,
                uint8_t * buf )
 {
+    tr_info_t * inf = &io->tor->info;
     uint64_t    offset;
-    tr_info_t * inf = &io->tor->info;
 
     offset = (uint64_t) io->pieceSlot[index] *
@@ -124 +121 @@
 /***********************************************************************
  * 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, hashFailed;
-    uint8_t        hash[SHA_DIGEST_LENGTH];
-    uint8_t      * pieceBuf;
-    int            pieceSize;
-    int            startBlock, endBlock;
 
     if( io->pieceSlot[index] < 0 )
@@ -149 +138 @@
         (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( !tr_cpBlockIsComplete( tor->completion, i ) )
-        {
-            /* The piece is not complete */
-            return 0;
-        }
-    }
-
-    /* The piece is complete, check the hash */
+    return writeBytes( io, offset, length, buf );
+}
+
+/***********************************************************************
+ * tr_ioHash
+ **********************************************************************/
+int tr_ioHash( tr_io_t * io, int index )
+{
+    tr_torrent_t * tor = io->tor;
+    tr_info_t    * inf = &io->tor->info;
+    int            pieceSize;
+    uint8_t      * pieceBuf;
+    uint8_t        hash[SHA_DIGEST_LENGTH];
+    int            hashFailed;
+    int            ret;
+    int            i;
+
+    if( !tr_cpPieceIsComplete( tor->completion, index ) )
+    {
+        return TR_ERROR_ASSERT;
+    }
+
     pieceSize = tr_pieceSize( index );
     pieceBuf  = malloc( pieceSize );
-    readBytes( io, (uint64_t) io->pieceSlot[index] *
-               (uint64_t) inf->pieceSize, pieceSize, pieceBuf );
+    if( ( ret = readBytes( io, (uint64_t) io->pieceSlot[index] *
+                    (uint64_t) inf->pieceSize, pieceSize, pieceBuf ) ) )
+    {
+        free( pieceBuf );
+        return ret;
+    }
     SHA1( pieceBuf, pieceSize, hash );
     free( pieceBuf );
@@ -178 +176 @@
         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++ )
-        {
-            tr_cpBlockRem( tor->completion, i );
-        }
+        tr_cpPieceRem( tor->completion, index );
     }
     else
@@ -201 +194 @@
 }
 
+/***********************************************************************
+ * tr_ioSync
+ **********************************************************************/
+void tr_ioSync( tr_io_t * io )
+{
+    closeFiles( io );
+    fastResumeSave( io );
+}
+
+/***********************************************************************
+ * tr_ioClose
+ **********************************************************************/
 void tr_ioClose( tr_io_t * io )
 {
-    closeFiles( io );
-
-    fastResumeSave( io );
+    tr_ioSync( io );
 
     free( io->pieceSlot );
     free( io->slotPiece );
     free( io );
-}
-
-void tr_ioSaveResume( tr_io_t * io )
-{
-    fastResumeSave( 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;
-    int           file;
-
-    tr_dbg( "Creating files..." );
-
-    for( i = 0; i < inf->fileCount; i++ )
-    {
-        asprintf( &path, "%s/%s", tor->destination, inf->files[i].name );
-
-        /* Create folders */
-        if( NULL != ( p = strrchr( path, '/' ) ) )
-        {
-            *p = '\0';
-            if( tr_mkdir( path ) )
-            {
-                free( path );
-                return 1;
-            }
-            *p = '/';
-        }
-
-        /* Empty folders use a dummy "" file, skip those */
-        if( p == &path[strlen( path ) - 1] )
-        {
-            free( path );
-            continue;
-        }
-
-        if( stat( path, &sb ) )
-        {
-            /* File doesn't exist yet */
-            if( ( file = open( path, O_WRONLY|O_CREAT|O_TRUNC, 0666 ) ) < 0 )
-            {
-                tr_err( "Could not create `%s' (%s)", path,
-                        strerror( errno ) );
-                free( path );
-                return 1;
-            }
-            close( file );
-        }
-        else if( ( sb.st_mode & S_IFMT ) != S_IFREG )
-        {
-            /* Node exists but isn't a file */
-            /* XXX this should be reported to the frontend somehow */
-            tr_err( "Remove %s, it's in the way.", path );
-            free( path );
-            return 1;
-        }
-
-        free( path );
-    }
-
-    return 0;
 }
 
@@ -370 +300 @@
 
     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 );
+        tr_fdFileClose( tor->fdlimit, tor->destination,
+                        inf->files[i].name );
     }
 }
@@ -396 +324 @@
     int    i;
     size_t cur;
-    char * path;
     int    file;
     iofunc readOrWrite = isWrite ? (iofunc) write : (iofunc) read;
+    int    ret = 0;
 
     /* Release the torrent lock so the UI can still update itself if
@@ -408 +336 @@
     {
         tr_err( "readOrWriteBytes: trying to write more than a piece" );
-        goto fail;
+        ret = TR_ERROR_ASSERT;
+        goto cleanup;
     }
 
@@ -426 +355 @@
         tr_err( "readOrWriteBytes: offset out of range (%"PRIu64", %d, %d)",
                 offset, size, isWrite );
-        goto fail;
+        ret = TR_ERROR_ASSERT;
+        goto cleanup;
     }
 
@@ -443 +373 @@
         if( cur > 0 )
         {
-            /* Now let's get a stream on the file... */
-            asprintf( &path, "%s/%s", tor->destination, inf->files[i].name );
-            file = tr_fdFileOpen( tor->fdlimit, path );
+            /* Now let's get a descriptor on the file... */
+            file = tr_fdFileOpen( tor->fdlimit, tor->destination,
+                                  inf->files[i].name, isWrite );
             if( file < 0 )
             {
-                tr_err( "readOrWriteBytes: could not open file '%s'", path );
-                free( path );
-                goto fail;
-            }
-            free( path );
+                ret = file;
+                goto cleanup;
+            }
 
             /* seek to the right offset... */
             if( lseek( file, offset, SEEK_SET ) < 0 )
             {
-                goto fail;
+                tr_fdFileRelease( tor->fdlimit, file );
+                ret = TR_ERROR_IO_OTHER;
+                goto cleanup;
             }
 
@@ -463 +393 @@
             if( readOrWrite( file, buf, cur ) != cur )
             {
-                goto fail;
-            }
-
-            /* and close the stream. */
+                tr_fdFileRelease( tor->fdlimit, file );
+                ret = TR_ERROR_IO_OTHER;
+                goto cleanup;
+            }
+
+            /* and release the descriptor. */
             tr_fdFileRelease( tor->fdlimit, file );
         }
@@ -477 +409 @@
     }
 
+cleanup:
     tr_lockLock( &tor->lock );
-    return 0;
-
-fail:
-    tr_lockLock( &tor->lock );
-    return 1;
+    return ret;
 }