Import SQLite 3.7.6.3.

third_party/sqlite/src/ext/async/sqlite3async.c

 /*
 ** 2005 December 14
 **
 ** The author disclaims copyright to this source code.  In place of
 ** a legal notice, here is a blessing:
 **
 **    May you do good and not evil.
 **    May you find forgiveness for yourself and forgive others.
 **    May you share freely, never taking more than you give.
 **
@@ skipping 649 matching lines @@
 ** This method holds the mutex from start to finish.
 */
 static int asyncRead(
   sqlite3_file *pFile, 
   void *zOut, 
   int iAmt, 
   sqlite3_int64 iOffset
 ){
   AsyncFileData *p = ((AsyncFile *)pFile)->pData;
   int rc = SQLITE_OK;
-  sqlite3_int64 filesize;
-  int nRead;
+  sqlite3_int64 filesize = 0;
   sqlite3_file *pBase = p->pBaseRead;
+  sqlite3_int64 iAmt64 = (sqlite3_int64)iAmt;
 
   /* Grab the write queue mutex for the duration of the call */
   async_mutex_enter(ASYNC_MUTEX_QUEUE);
 
   /* If an I/O error has previously occurred in this virtual file 
   ** system, then all subsequent operations fail.
   */
   if( async.ioError!=SQLITE_OK ){
     rc = async.ioError;
     goto asyncread_out;
   }
 
   if( pBase->pMethods ){
+    sqlite3_int64 nRead;
     rc = pBase->pMethods->xFileSize(pBase, &filesize);
     if( rc!=SQLITE_OK ){
       goto asyncread_out;
     }
-    nRead = (int)MIN(filesize - iOffset, iAmt);
+    nRead = MIN(filesize - iOffset, iAmt64);
     if( nRead>0 ){
-      rc = pBase->pMethods->xRead(pBase, zOut, nRead, iOffset);
+      rc = pBase->pMethods->xRead(pBase, zOut, (int)nRead, iOffset);
       ASYNC_TRACE(("READ %s %d bytes at %d\n", p->zName, nRead, iOffset));
     }
   }
 
   if( rc==SQLITE_OK ){
     AsyncWrite *pWrite;
     char *zName = p->zName;
 
     for(pWrite=async.pQueueFirst; pWrite; pWrite = pWrite->pNext){
       if( pWrite->op==ASYNC_WRITE && (
         (pWrite->pFileData==p) ||
         (zName && pWrite->pFileData->zName==zName)
       )){
+        sqlite3_int64 nCopy;
+        sqlite3_int64 nByte64 = (sqlite3_int64)pWrite->nByte;
+
+        /* Set variable iBeginIn to the offset in buffer pWrite->zBuf[] from
+        ** which data should be copied. Set iBeginOut to the offset within
+        ** the output buffer to which data should be copied. If either of
+        ** these offsets is a negative number, set them to 0.
+        */
         sqlite3_int64 iBeginOut = (pWrite->iOffset-iOffset);
         sqlite3_int64 iBeginIn = -iBeginOut;
-        int nCopy;
-
         if( iBeginIn<0 ) iBeginIn = 0;
         if( iBeginOut<0 ) iBeginOut = 0;
-        nCopy = (int)MIN(pWrite->nByte-iBeginIn, iAmt-iBeginOut);
 
+        filesize = MAX(filesize, pWrite->iOffset+nByte64);
+
+        nCopy = MIN(nByte64-iBeginIn, iAmt64-iBeginOut);
         if( nCopy>0 ){
-          memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], nCopy);
+          memcpy(&((char *)zOut)[iBeginOut], &pWrite->zBuf[iBeginIn], (size_t)nCopy);
           ASYNC_TRACE(("OVERREAD %d bytes at %d\n", nCopy, iBeginOut+iOffset));
         }
       }
     }
   }
 
 asyncread_out:
   async_mutex_leave(ASYNC_MUTEX_QUEUE);
+  if( rc==SQLITE_OK && filesize<(iOffset+iAmt) ){
+    rc = SQLITE_IOERR_SHORT_READ;
+  }
   return rc;
 }
 
 /*
 ** Truncate the file to nByte bytes in length. This just adds an entry to 
 ** the write-op list, no IO actually takes place.
 */
 static int asyncTruncate(sqlite3_file *pFile, sqlite3_int64 nByte){
   AsyncFileData *p = ((AsyncFile *)pFile)->pData;
   return addNewAsyncWrite(p, ASYNC_TRUNCATE, nByte, 0, 0);
@@ skipping 390 matching lines @@
     }
     if( pData->pBaseWrite->pMethods ){
       pData->pBaseWrite->pMethods->xClose(pData->pBaseWrite);
     }
     sqlite3_free(pData);
   }
 
   async_mutex_leave(ASYNC_MUTEX_LOCK);
 
   if( rc==SQLITE_OK ){
-    incrOpenFileCount();
     pData->pLock = pLock;
   }
 
   if( rc==SQLITE_OK && isAsyncOpen ){
     rc = addNewAsyncWrite(pData, ASYNC_OPENEXCLUSIVE, (sqlite3_int64)flags,0,0);
     if( rc==SQLITE_OK ){
       if( pOutFlags ) *pOutFlags = flags;
     }else{
       async_mutex_enter(ASYNC_MUTEX_LOCK);
       unlinkAsyncFile(pData);
       async_mutex_leave(ASYNC_MUTEX_LOCK);
       sqlite3_free(pData);
     }
   }
   if( rc!=SQLITE_OK ){
     p->pMethod = 0;
+  }else{
+    incrOpenFileCount();
   }
+
   return rc;
 }
 
 /*
 ** Implementation of sqlite3OsDelete. Add an entry to the end of the 
 ** write-op queue to perform the delete.
 */
 static int asyncDelete(sqlite3_vfs *pAsyncVfs, const char *z, int syncDir){
   UNUSED_PARAMETER(pAsyncVfs);
   return addNewAsyncWrite(0, ASYNC_DELETE, syncDir, (int)strlen(z)+1, z);
@@ skipping 55 matching lines @@
   int rc;
   sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
   rc = pVfs->xFullPathname(pVfs, zPath, nPathOut, zPathOut);
 
   /* Because of the way intra-process file locking works, this backend
   ** needs to return a canonical path. The following block assumes the
   ** file-system uses unix style paths. 
   */
   if( rc==SQLITE_OK ){
     int i, j;
-    int n = nPathOut;
     char *z = zPathOut;
+    int n = (int)strlen(z);
     while( n>1 && z[n-1]=='/' ){ n--; }
     for(i=j=0; i<n; i++){
       if( z[i]=='/' ){
         if( z[i+1]=='/' ) continue;
         if( z[i+1]=='.' && i+2<n && z[i+2]=='/' ){
           i += 1;
           continue;
         }
         if( z[i+1]=='.' && i+3<n && z[i+2]=='.' && z[i+3]=='/' ){
           while( j>0 && z[j-1]!='/' ){ j--; }
@@ skipping 435 matching lines @@
     }
 
     default:
       return SQLITE_ERROR;
   }
   return SQLITE_OK;
 }
 
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO) */