/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
*/
sqlite3_backup *sqlite3_backup_init(
sqlite3* pDestDb, /* Database to write to */
const char *zDestDb, /* Name of database within pDestDb */
sqlite3* pSrcDb, /* Database connection to read from */
const char *zSrcDb /* Name of database within pSrcDb */
){
sqlite3_backup *p; /* Value to return */
/* Lock the source database handle. The destination database
** handle is not locked in this routine, but it is locked in
** sqlite3_backup_step(). The user is required to ensure that no
** other thread accesses the destination handle for the duration
** of the backup operation. Any attempt to use the destination
** database connection while a backup is in progress may cause
** a malfunction or a deadlock.
*/
sqlite3_mutex_enter(pSrcDb->mutex);
sqlite3_mutex_enter(pDestDb->mutex);
if( pSrcDb==pDestDb ){
sqlite3Error(
pDestDb, SQLITE_ERROR, "source and destination must be distinct"
);
p = 0;
}else {
/* Allocate space for a new sqlite3_backup object */
p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup));
if( !p ){
sqlite3Error(pDestDb, SQLITE_NOMEM, 0);
}
}
/* If the allocation succeeded, populate the new object. */
if( p ){
memset(p, 0, sizeof(sqlite3_backup));
p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
p->pDestDb = pDestDb;
p->pSrcDb = pSrcDb;
p->iNext = 1;
p->isAttached = 0;
if( 0==p->pSrc || 0==p->pDest ){
/* One (or both) of the named databases did not exist. An error has
** already been written into the pDestDb handle. All that is left
** to do here is free the sqlite3_backup structure.
*/
sqlite3_free(p);
p = 0;
}
}
if( p ){
p->pSrc->nBackup++;
}
sqlite3_mutex_leave(pDestDb->mutex);
sqlite3_mutex_leave(pSrcDb->mutex);
return p;
}
/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
*/
sqlite3_backup *sqlite3_backup_init(
sqlite3* pDestDb, /* Database to write to */
const char *zDestDb, /* Name of database within pDestDb */
sqlite3* pSrcDb, /* Database connection to read from */
const char *zSrcDb /* Name of database within pSrcDb */
){
sqlite3_backup *p; /* Value to return */
#ifdef SQLITE_ENABLE_API_ARMOR
if( !sqlite3SafetyCheckOk(pSrcDb)||!sqlite3SafetyCheckOk(pDestDb) ){
(void)SQLITE_MISUSE_BKPT;
return 0;
}
#endif
/* BEGIN SQLCIPHER */
#ifdef SQLITE_HAS_CODEC
{
extern int sqlcipher_find_db_index(sqlite3*, const char*);
extern void sqlite3CodecGetKey(sqlite3*, int, void**, int*);
int srcNKey, destNKey;
void *zKey;
sqlite3CodecGetKey(pSrcDb, sqlcipher_find_db_index(pSrcDb, zSrcDb), &zKey, &srcNKey);
sqlite3CodecGetKey(pDestDb, sqlcipher_find_db_index(pDestDb, zDestDb), &zKey, &destNKey);
zKey = NULL;
if(srcNKey || destNKey) {
sqlite3ErrorWithMsg(pDestDb, SQLITE_ERROR, "backup is not supported with encrypted databases");
return NULL;
}
}
#endif
/* END SQLCIPHER */
/* Lock the source database handle. The destination database
** handle is not locked in this routine, but it is locked in
** sqlite3_backup_step(). The user is required to ensure that no
** other thread accesses the destination handle for the duration
** of the backup operation. Any attempt to use the destination
** database connection while a backup is in progress may cause
** a malfunction or a deadlock.
*/
sqlite3_mutex_enter(pSrcDb->mutex);
sqlite3_mutex_enter(pDestDb->mutex);
if( pSrcDb==pDestDb ){
sqlite3ErrorWithMsg(
pDestDb, SQLITE_ERROR, "source and destination must be distinct"
);
p = 0;
}else {
/* Allocate space for a new sqlite3_backup object...
** EVIDENCE-OF: R-64852-21591 The sqlite3_backup object is created by a
** call to sqlite3_backup_init() and is destroyed by a call to
** sqlite3_backup_finish(). */
p = (sqlite3_backup *)sqlite3MallocZero(sizeof(sqlite3_backup));
if( !p ){
sqlite3Error(pDestDb, SQLITE_NOMEM_BKPT);
}
}
/* If the allocation succeeded, populate the new object. */
if( p ){
p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
p->pDestDb = pDestDb;
p->pSrcDb = pSrcDb;
p->iNext = 1;
p->isAttached = 0;
if( 0==p->pSrc || 0==p->pDest
|| checkReadTransaction(pDestDb, p->pDest)!=SQLITE_OK
){
/* One (or both) of the named databases did not exist or an OOM
** error was hit. Or there is a transaction open on the destination
** database. The error has already been written into the pDestDb
** handle. All that is left to do here is free the sqlite3_backup
** structure. */
sqlite3_free(p);
p = 0;
}
}
if( p ){
p->pSrc->nBackup++;
}
sqlite3_mutex_leave(pDestDb->mutex);
sqlite3_mutex_leave(pSrcDb->mutex);
return p;
}
/*
** Create an sqlite3_backup process to copy the contents of zSrcDb from
** connection handle pSrcDb to zDestDb in pDestDb. If successful, return
** a pointer to the new sqlite3_backup object.
**
** If an error occurs, NULL is returned and an error code and error message
** stored in database handle pDestDb.
** pDestDb Database to write to
** zDestDb Name of database within pDestDb
** pSrcDb Database connection to read from
** zSrcDb Name of database within pSrcDb
*/
sqlite3_backup *sqlite3_backup_init(sqlite3* pDestDb, const char *zDestDb,
sqlite3* pSrcDb, const char *zSrcDb)
{
sqlite3_backup *p; /* Value to return */
Parse parse;
DB_ENV *dbenv;
int ret;
p = NULL;
ret = 0;
if (!pDestDb || !pSrcDb)
return 0;
sqlite3_mutex_enter(pSrcDb->mutex);
sqlite3_mutex_enter(pDestDb->mutex);
if (pSrcDb == pDestDb) {
sqlite3Error(pDestDb, SQLITE_ERROR,
"source and destination must be distinct");
goto err;
}
/* Allocate space for a new sqlite3_backup object */
p = (sqlite3_backup *)sqlite3_malloc(sizeof(sqlite3_backup));
if (!p) {
sqlite3Error(pDestDb, SQLITE_NOMEM, 0);
goto err;
}
memset(p, 0, sizeof(sqlite3_backup));
p->pSrc = findBtree(pDestDb, pSrcDb, zSrcDb);
p->pDest = findBtree(pDestDb, pDestDb, zDestDb);
p->pDestDb = pDestDb;
p->pSrcDb = pSrcDb;
if (0 == p->pSrc) {
p->rc = p->pSrcDb->errCode;
goto err;
}
if (0 == p->pDest) {
p->rc = p->pDestDb->errCode;
goto err;
}
p->iDb = sqlite3FindDbName(pDestDb, zDestDb);
p->srcName = sqlite3_malloc((int)strlen(zSrcDb) + 1);
p->destName = sqlite3_malloc((int)strlen(zDestDb) + 1);
if (0 == p->srcName || 0 == p->destName) {
p->rc = SQLITE_NOMEM;
goto err;
}
strncpy(p->srcName, zSrcDb, strlen(zSrcDb) + 1);
strncpy(p->destName, zDestDb, strlen(zDestDb) + 1);
if (p->pDest->pBt->full_name) {
const char *fullName = p->pDest->pBt->full_name;
p->fullName = sqlite3_malloc((int)strlen(fullName) + 1);
if (!p->fullName) {
p->rc = SQLITE_NOMEM;
goto err;
}
strncpy(p->fullName, fullName, strlen(fullName) + 1);
}
/*
* Make sure the schema has been read in, so the keyInfo
* can be retrieved for the indexes. No-op if already read.
*/
memset(&parse, 0, sizeof(parse));
parse.db = p->pSrcDb;
p->rc = sqlite3ReadSchema(&parse);
if (p->rc != SQLITE_OK) {
if (parse.zErrMsg != NULL)
sqlite3DbFree(p->pSrcDb, parse.zErrMsg);
goto err;
}
/* Begin a transaction on the source. */
if (!p->pSrc->connected) {
if ((p->rc = btreeOpenEnvironment(p->pSrc, 1)) != SQLITE_OK)
goto err;
}
dbenv = p->pSrc->pBt->dbenv;
p->rc = dberr2sqlite(dbenv->txn_begin(dbenv, p->pSrc->family_txn,
&p->srcTxn, 0));
if (p->rc != SQLITE_OK) {
sqlite3Error(pSrcDb, p->rc, 0);
goto err;
}
/*
* Get the page count and list of tables to copy. This will
* result in a read lock on the schema table, held in the
* read transaction.
*/
if ((p->rc = btreeGetPageCount(p->pSrc,
&p->tables, &p->nPagecount, p->srcTxn)) != SQLITE_OK) {
sqlite3Error(pSrcDb, p->rc, 0);
goto err;
}
p->nRemaining = p->nPagecount;
p->pSrc->nBackup++;
p->pDest->nBackup++;
p->lastUpdate = p->pSrc->updateDuringBackup;
goto done;
err: if (p != 0) {
if (pDestDb->errCode == SQLITE_OK)
sqlite3Error(pDestDb, p->rc, 0);
if (p->srcTxn)
p->srcTxn->abort(p->srcTxn);
if (p->srcName != 0)
sqlite3_free(p->srcName);
if (p->destName != 0)
sqlite3_free(p->destName);
if (p->fullName != 0)
sqlite3_free(p->fullName);
if (p->tables != 0)
sqlite3_free(p->tables);
sqlite3_free(p);
p = NULL;
}
done: sqlite3_mutex_leave(pDestDb->mutex);
sqlite3_mutex_leave(pSrcDb->mutex);
return p;
}
