Import SQLite 3.8.7.4.

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 926 matching lines @@
 */
 static int asyncFileControl(sqlite3_file *id, int op, void *pArg){
   switch( op ){
     case SQLITE_FCNTL_LOCKSTATE: {
       async_mutex_enter(ASYNC_MUTEX_LOCK);
       *(int*)pArg = ((AsyncFile*)id)->pData->lock.eLock;
       async_mutex_leave(ASYNC_MUTEX_LOCK);
       return SQLITE_OK;
     }
   }
-  return SQLITE_ERROR;
+  return SQLITE_NOTFOUND;
 }
 
 /* 
 ** Return the device characteristics and sector-size of the device. It
 ** is tricky to implement these correctly, as this backend might 
 ** not have an open file handle at this point.
 */
 static int asyncSectorSize(sqlite3_file *pFile){
   UNUSED_PARAMETER(pFile);
   return 512;
@@ skipping 79 matching lines @@
   sqlite3_vfs *pVfs = (sqlite3_vfs *)pAsyncVfs->pAppData;
   AsyncFile *p = (AsyncFile *)pFile;
   int nName = 0;
   int rc = SQLITE_OK;
   int nByte;
   AsyncFileData *pData;
   AsyncLock *pLock = 0;
   char *z;
   int isAsyncOpen = doAsynchronousOpen(flags);
 
-  /* If zName is NULL, then the upper layer is requesting an anonymous file */
+  /* If zName is NULL, then the upper layer is requesting an anonymous file.
+  ** Otherwise, allocate enough space to make a copy of the file name (along
+  ** with the second nul-terminator byte required by xOpen).
+  */
   if( zName ){
-    nName = (int)strlen(zName)+1;
+    nName = (int)strlen(zName);
   }
 
   nByte = (
     sizeof(AsyncFileData) +        /* AsyncFileData structure */
     2 * pVfs->szOsFile +           /* AsyncFileData.pBaseRead and pBaseWrite */
-    nName                          /* AsyncFileData.zName */
+    nName + 2                      /* AsyncFileData.zName */
   ); 
   z = sqlite3_malloc(nByte);
   if( !z ){
     return SQLITE_NOMEM;
   }
   memset(z, 0, nByte);
   pData = (AsyncFileData*)z;
   z += sizeof(pData[0]);
   pData->pBaseRead = (sqlite3_file*)z;
   z += pVfs->szOsFile;
@@ skipping 434 matching lines @@
           assert(pData->lock.eAsyncLock>=pData->lock.eLock);
           rc = getFileLock(pData->pLock);
           async_mutex_leave(ASYNC_MUTEX_LOCK);
         }
         break;
       }
 
       case ASYNC_DELETE:
         ASYNC_TRACE(("DELETE %s\n", p->zBuf));
         rc = pVfs->xDelete(pVfs, p->zBuf, (int)p->iOffset);
+        if( rc==SQLITE_IOERR_DELETE_NOENT ) rc = SQLITE_OK;
         break;
 
       case ASYNC_OPENEXCLUSIVE: {
         int flags = (int)p->iOffset;
         AsyncFileData *pData = p->pFileData;
         ASYNC_TRACE(("OPEN %s flags=%d\n", p->zBuf, (int)p->iOffset));
         assert(pData->pBaseRead->pMethods==0 && pData->pBaseWrite->pMethods==0);
         rc = pVfs->xOpen(pVfs, pData->zName, pData->pBaseRead, flags, 0);
         assert( holdingMutex==0 );
         async_mutex_enter(ASYNC_MUTEX_QUEUE);
@@ skipping 168 matching lines @@
     }
 
     default:
       return SQLITE_ERROR;
   }
   return SQLITE_OK;
 }
 
 #endif /* !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ASYNCIO) */