ADDED   ext/userauth/sqlite3userauth.h
Index: ext/userauth/sqlite3userauth.h
==================================================================
--- /dev/null
+++ ext/userauth/sqlite3userauth.h
@@ -0,0 +1,88 @@
+/*
+** 2014-09-08
+**
+** 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.
+**
+*************************************************************************
+**
+** This file contains the application interface definitions for the
+** user-authentication extension feature.
+**
+** To compile with the user-authentication feature, append this file to
+** end of an SQLite amalgamation header file ("sqlite3.h"), then add
+** the SQLITE_USER_AUTHENTICATION compile-time option.  See the
+** user-auth.txt file in the same source directory as this file for
+** additional information.
+*/
+#ifdef SQLITE_USER_AUTHENTICATION
+
+/*
+** If a database contains the SQLITE_USER table, then the
+** sqlite3_user_authenticate() interface must be invoked with an
+** appropriate username and password prior to enable read and write
+** access to the database.
+**
+** Return SQLITE_OK on success or SQLITE_ERROR if the username/password
+** combination is incorrect or unknown.
+**
+** If the SQLITE_USER table is not present in the database file, then
+** this interface is a harmless no-op returnning SQLITE_OK.
+*/
+int sqlite3_user_authenticate(
+  sqlite3 *db,           /* The database connection */
+  const char *zUsername, /* Username */
+  const char *aPW,       /* Password or credentials */
+  int nPW                /* Number of bytes in aPW[] */
+);
+
+/*
+** The sqlite3_user_add() interface can be used (by an admin user only)
+** to create a new user.  When called on a no-authentication-required
+** database, this routine converts the database into an authentication-
+** required database, automatically makes the added user an
+** administrator, and logs in the current connection as that user.
+** The sqlite3_user_add() interface only works for the "main" database, not
+** for any ATTACH-ed databases.  Any call to sqlite3_user_add() by a
+** non-admin user results in an error.
+*/
+int sqlite3_user_add(
+  sqlite3 *db,           /* Database connection */
+  const char *zUsername, /* Username to be added */
+  const char *aPW,       /* Password or credentials */
+  int nPW,               /* Number of bytes in aPW[] */
+  int isAdmin            /* True to give new user admin privilege */
+);
+
+/*
+** The sqlite3_user_change() interface can be used to change a users
+** login credentials or admin privilege.  Any user can change their own
+** login credentials.  Only an admin user can change another users login
+** credentials or admin privilege setting.  No user may change their own 
+** admin privilege setting.
+*/
+int sqlite3_user_change(
+  sqlite3 *db,           /* Database connection */
+  const char *zUsername, /* Username to change */
+  const char *aPW,       /* New password or credentials */
+  int nPW,               /* Number of bytes in aPW[] */
+  int isAdmin            /* Modified admin privilege for the user */
+);
+
+/*
+** The sqlite3_user_delete() interface can be used (by an admin user only)
+** to delete a user.  The currently logged-in user cannot be deleted,
+** which guarantees that there is always an admin user and hence that
+** the database cannot be converted into a no-authentication-required
+** database.
+*/
+int sqlite3_user_delete(
+  sqlite3 *db,           /* Database connection */
+  const char *zUsername  /* Username to remove */
+);
+
+#endif /* SQLITE_USER_AUTHENTICATION */

ADDED   ext/userauth/user-auth.txt
Index: ext/userauth/user-auth.txt
==================================================================
--- /dev/null
+++ ext/userauth/user-auth.txt
@@ -0,0 +1,164 @@
+Activate the user authentication logic by including the
+ext/userauth/userauth.c source code file in the build and
+adding the -DSQLITE_USER_AUTHENTICATION compile-time option.
+The ext/userauth/sqlite3userauth.h header file is available to
+applications to define the interface.
+
+When using the SQLite amalgamation, it is sufficient to append
+the ext/userauth/userauth.c source file onto the end of the
+amalgamation.
+
+The following new APIs are available when user authentication is
+activated:
+
+   int sqlite3_user_authenticate(
+     sqlite3 *db,           /* The database connection */
+     const char *zUsername, /* Username */
+     const char *aPW,       /* Password or credentials */
+     int nPW                /* Number of bytes in aPW[] */
+   );
+   
+   int sqlite3_user_add(
+     sqlite3 *db,           /* Database connection */
+     const char *zUsername, /* Username to be added */
+     const char *aPW,       /* Password or credentials */
+     int nPW,               /* Number of bytes in aPW[] */
+     int isAdmin            /* True to give new user admin privilege */
+   );
+   
+   int sqlite3_user_change(
+     sqlite3 *db,           /* Database connection */
+     const char *zUsername, /* Username to change */
+     const void *aPW,       /* Modified password or credentials */
+     int nPW,               /* Number of bytes in aPW[] */
+     int isAdmin            /* Modified admin privilege for the user */
+   );
+   
+   int sqlite3_user_delete(
+     sqlite3 *db,           /* Database connection */
+     const char *zUsername  /* Username to remove */
+   );
+
+With this extension, a database can be marked as requiring authentication.
+By default a database does not require authentication.
+
+The sqlite3_open(), sqlite3_open16(), and sqlite3_open_v2() interfaces
+work as before: they open a new database connection.  However, if the
+database being opened requires authentication, then attempts to read
+or write from the database will fail with an SQLITE_AUTH error until 
+after sqlite3_user_authenticate() has been called successfully.  The 
+sqlite3_user_authenticate() call will return SQLITE_OK if the 
+authentication credentials are accepted and SQLITE_ERROR if not.
+
+Calling sqlite3_user_authenticate() on a no-authentication-required
+database connection is a harmless no-op.  
+
+If the database is encrypted, then sqlite3_key_v2() must be called first,
+with the correct decryption key, prior to invoking sqlite3_user_authenticate().
+
+To recapitulate: When opening an existing unencrypted authentication-
+required database, the call sequence is:
+
+    sqlite3_open_v2()
+    sqlite3_user_authenticate();
+    /* Database is now usable */
+
+To open an existing, encrypted, authentication-required database, the
+call sequence is:
+
+    sqlite3_open_v2();
+    sqlite3_key_v2();
+    sqlite3_user_authenticate();
+    /* Database is now usable */
+
+When opening a no-authentication-required database, the database
+connection is treated as if it was authenticated as an admin user.
+
+When ATTACH-ing new database files to a connection, each newly attached
+database that is an authentication-required database is checked using
+the same username and password as supplied to the main database.  If that
+check fails, then the ATTACH command fails with an SQLITE_AUTH error.
+
+The sqlite3_user_add() interface can be used (by an admin user only)
+to create a new user.  When called on a no-authentication-required
+database and when A is true, the sqlite3_user_add(D,U,P,N,A) routine
+converts the database into an authentication-required database and
+logs in the database connection D as user U with password P,N.
+To convert a no-authentication-required database into an authentication-
+required database, the isAdmin parameter must be true.  If
+sqlite3_user_add(D,U,P,N,A) is called on a no-authentication-required
+database and A is false, then the call fails with an SQLITE_AUTH error.
+
+Any call to sqlite3_user_add() by a non-admin user results in an error.
+
+Hence, to create a new, unencrypted, authentication-required database,
+the call sequence is:
+
+    sqlite3_open_v2();
+    sqlite3_user_add();
+
+And to create a new, encrypted, authentication-required database, the call
+sequence is:
+
+    sqlite3_open_v2();
+    sqlite3_key_v2();
+    sqlite3_user_add();
+
+The sqlite3_user_delete() interface can be used (by an admin user only)
+to delete a user.  The currently logged-in user cannot be deleted,
+which guarantees that there is always an admin user and hence that
+the database cannot be converted into a no-authentication-required
+database.
+
+The sqlite3_user_change() interface can be used to change a users
+login credentials or admin privilege.  Any user can change their own
+password.  Only an admin user can change another users login
+credentials or admin privilege setting.  No user may change their own 
+admin privilege setting.
+
+The sqlite3_set_authorizer() callback is modified to take a 7th parameter
+which is the username of the currently logged in user, or NULL for a
+no-authentication-required database.
+
+-----------------------------------------------------------------------------
+Implementation notes:
+
+An authentication-required database is identified by the presence of a
+new table:
+
+    CREATE TABLE sqlite_user(
+      uname TEXT PRIMARY KEY,
+      isAdmin BOOLEAN,
+      pw BLOB
+    ) WITHOUT ROWID;
+
+The sqlite_user table is inaccessible (unreadable and unwriteable) to
+non-admin users and is read-only for admin users.  However, if the same
+database file is opened by a version of SQLite that omits
+the -DSQLITE_USER_AUTHENTICATION compile-time option, then the sqlite_user
+table will be readable by anybody and writeable by anybody if
+the "PRAGMA writable_schema=ON" statement is run first.
+
+The sqlite_user.pw field is encoded by a built-in SQL function
+"sqlite_crypt(X,Y)".  The two arguments are both BLOBs.  The first argument
+is the plaintext password supplied to the sqlite3_user_authenticate()
+interface.  The second argument is the sqlite_user.pw value and is supplied
+so that the function can extract the "salt" used by the password encoder.
+The result of sqlite_crypt(X,Y) is another blob which is the value that
+ends up being stored in sqlite_user.pw.  To verify credentials X supplied
+by the sqlite3_user_authenticate() routine, SQLite runs:
+
+    sqlite_user.pw == sqlite_crypt(X, sqlite_user.pw)
+
+To compute an appropriate sqlite_user.pw value from a new or modified
+password X, sqlite_crypt(X,NULL) is run.  A new random salt is selected
+when the second argument is NULL.
+
+The built-in version of of sqlite_crypt() uses a simple Ceasar-cypher
+which prevents passwords from being revealed by searching the raw database
+for ASCII text, but is otherwise trivally broken.  For better password
+security, the database should be encrypted using the SQLite Encryption
+Extension or similar technology.  Or, the application can use the
+sqlite3_create_function() interface to provide an alternative
+implementation of sqlite_crypt() that computes a stronger password hash,
+perhaps using a cryptographic hash function like SHA1.

ADDED   ext/userauth/userauth.c
Index: ext/userauth/userauth.c
==================================================================
--- /dev/null
+++ ext/userauth/userauth.c
@@ -0,0 +1,355 @@
+/*
+** 2014-09-08
+**
+** 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.
+**
+*************************************************************************
+**
+** This file contains the bulk of the implementation of the
+** user-authentication extension feature.  Some parts of the user-
+** authentication code are contained within the SQLite core (in the
+** src/ subdirectory of the main source code tree) but those parts
+** that could reasonable be separated out are moved into this file.
+**
+** To compile with the user-authentication feature, append this file to
+** end of an SQLite amalgamation, then add the SQLITE_USER_AUTHENTICATION
+** compile-time option.  See the user-auth.txt file in the same source
+** directory as this file for additional information.
+*/
+#ifdef SQLITE_USER_AUTHENTICATION
+#ifndef _SQLITEINT_H_
+# include "sqliteInt.h"
+#endif
+
+/*
+** Prepare an SQL statement for use by the user authentication logic.
+** Return a pointer to the prepared statement on success.  Return a
+** NULL pointer if there is an error of any kind.
+*/
+static sqlite3_stmt *sqlite3UserAuthPrepare(
+  sqlite3 *db,
+  const char *zFormat,
+  ...
+){
+  sqlite3_stmt *pStmt;
+  char *zSql;
+  int rc;
+  va_list ap;
+  int savedFlags = db->flags;
+
+  va_start(ap, zFormat);
+  zSql = sqlite3_vmprintf(zFormat, ap);
+  va_end(ap);
+  if( zSql==0 ) return 0;
+  db->flags |= SQLITE_WriteSchema;
+  rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0);
+  db->flags = savedFlags;
+  sqlite3_free(zSql);
+  if( rc ){
+    sqlite3_finalize(pStmt);
+    pStmt = 0;
+  }
+  return pStmt;
+}
+
+/*
+** Check to see if the sqlite_user table exists in database zDb.
+*/
+static int userTableExists(sqlite3 *db, const char *zDb){
+  int rc;
+  sqlite3_mutex_enter(db->mutex);
+  sqlite3BtreeEnterAll(db);
+  if( db->init.busy==0 ){
+    char *zErr = 0;
+    sqlite3Init(db, &zErr);
+    sqlite3DbFree(db, zErr);
+  }
+  rc = sqlite3FindTable(db, "sqlite_user", zDb)!=0;
+  sqlite3BtreeLeaveAll(db);
+  sqlite3_mutex_leave(db->mutex);
+  return rc;
+}
+
+/*
+** Check to see if database zDb has a "sqlite_user" table and if it does
+** whether that table can authenticate zUser with nPw,zPw.  Write one of
+** the UAUTH_* user authorization level codes into *peAuth and return a
+** result code.
+*/
+static int userAuthCheckLogin(
+  sqlite3 *db,               /* The database connection to check */
+  const char *zDb,           /* Name of specific database to check */
+  u8 *peAuth                 /* OUT: One of UAUTH_* constants */
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+
+  *peAuth = UAUTH_Unknown;
+  if( !userTableExists(db, "main") ){
+    *peAuth = UAUTH_Admin;  /* No sqlite_user table.  Everybody is admin. */
+    return SQLITE_OK;
+  }
+  if( db->auth.zAuthUser==0 ){
+    *peAuth = UAUTH_Fail;
+    return SQLITE_OK;
+  }
+  pStmt = sqlite3UserAuthPrepare(db,
+            "SELECT pw=sqlite_crypt(?1,pw), isAdmin FROM \"%w\".sqlite_user"
+            " WHERE uname=?2", zDb);
+  if( pStmt==0 ) return SQLITE_NOMEM;
+  sqlite3_bind_blob(pStmt, 1, db->auth.zAuthPW, db->auth.nAuthPW,SQLITE_STATIC);
+  sqlite3_bind_text(pStmt, 2, db->auth.zAuthUser, -1, SQLITE_STATIC);
+  rc = sqlite3_step(pStmt);
+  if( rc==SQLITE_ROW && sqlite3_column_int(pStmt,0) ){
+    *peAuth = sqlite3_column_int(pStmt, 1) + UAUTH_User;
+  }else{
+    *peAuth = UAUTH_Fail;
+  }
+  return sqlite3_finalize(pStmt);
+}
+int sqlite3UserAuthCheckLogin(
+  sqlite3 *db,               /* The database connection to check */
+  const char *zDb,           /* Name of specific database to check */
+  u8 *peAuth                 /* OUT: One of UAUTH_* constants */
+){
+  int rc;
+  u8 savedAuthLevel;
+  assert( zDb!=0 );
+  assert( peAuth!=0 );
+  savedAuthLevel = db->auth.authLevel;
+  db->auth.authLevel = UAUTH_Admin;
+  rc = userAuthCheckLogin(db, zDb, peAuth);
+  db->auth.authLevel = savedAuthLevel;
+  return rc;
+}
+
+/*
+** If the current authLevel is UAUTH_Unknown, the take actions to figure
+** out what authLevel should be
+*/
+void sqlite3UserAuthInit(sqlite3 *db){
+  if( db->auth.authLevel==UAUTH_Unknown ){
+    u8 authLevel = UAUTH_Fail;
+    sqlite3UserAuthCheckLogin(db, "main", &authLevel);
+    db->auth.authLevel = authLevel;
+    if( authLevel<UAUTH_Admin ) db->flags &= ~SQLITE_WriteSchema;
+  }
+}
+
+/*
+** Implementation of the sqlite_crypt(X,Y) function.
+**
+** If Y is NULL then generate a new hash for password X and return that
+** hash.  If Y is not null, then generate a hash for password X using the
+** same salt as the previous hash Y and return the new hash.
+*/
+void sqlite3CryptFunc(
+  sqlite3_context *context,
+  int NotUsed,
+  sqlite3_value **argv
+){
+  const char *zIn;
+  int nIn, ii;
+  u8 *zOut;
+  char zSalt[8];
+  zIn = sqlite3_value_blob(argv[0]);
+  nIn = sqlite3_value_bytes(argv[0]);
+  if( sqlite3_value_type(argv[1])==SQLITE_BLOB
+   && sqlite3_value_bytes(argv[1])==nIn+sizeof(zSalt)
+  ){
+    memcpy(zSalt, sqlite3_value_blob(argv[1]), sizeof(zSalt));
+  }else{
+    sqlite3_randomness(sizeof(zSalt), zSalt);
+  }
+  zOut = sqlite3_malloc( nIn+sizeof(zSalt) );
+  if( zOut==0 ){
+    sqlite3_result_error_nomem(context);
+  }else{
+    memcpy(zOut, zSalt, sizeof(zSalt));
+    for(ii=0; ii<nIn; ii++){
+      zOut[ii+sizeof(zSalt)] = zIn[ii]^zSalt[ii&0x7];
+    }
+    sqlite3_result_blob(context, zOut, nIn+sizeof(zSalt), sqlite3_free);
+  }
+}
+
+/*
+** If a database contains the SQLITE_USER table, then the
+** sqlite3_user_authenticate() interface must be invoked with an
+** appropriate username and password prior to enable read and write
+** access to the database.
+**
+** Return SQLITE_OK on success or SQLITE_ERROR if the username/password
+** combination is incorrect or unknown.
+**
+** If the SQLITE_USER table is not present in the database file, then
+** this interface is a harmless no-op returnning SQLITE_OK.
+*/
+int sqlite3_user_authenticate(
+  sqlite3 *db,           /* The database connection */
+  const char *zUsername, /* Username */
+  const char *zPW,       /* Password or credentials */
+  int nPW                /* Number of bytes in aPW[] */
+){
+  int rc;
+  u8 authLevel = UAUTH_Fail;
+  db->auth.authLevel = UAUTH_Unknown;
+  sqlite3_free(db->auth.zAuthUser);
+  sqlite3_free(db->auth.zAuthPW);
+  memset(&db->auth, 0, sizeof(db->auth));
+  db->auth.zAuthUser = sqlite3_mprintf("%s", zUsername);
+  if( db->auth.zAuthUser==0 ) return SQLITE_NOMEM;
+  db->auth.zAuthPW = sqlite3_malloc( nPW+1 );
+  if( db->auth.zAuthPW==0 ) return SQLITE_NOMEM;
+  memcpy(db->auth.zAuthPW,zPW,nPW);
+  db->auth.nAuthPW = nPW;
+  rc = sqlite3UserAuthCheckLogin(db, "main", &authLevel);
+  db->auth.authLevel = authLevel;
+  sqlite3ExpirePreparedStatements(db);
+  if( rc ){
+    return rc;           /* OOM error, I/O error, etc. */
+  }
+  if( authLevel<UAUTH_User ){
+    return SQLITE_AUTH;  /* Incorrect username and/or password */
+  }
+  return SQLITE_OK;      /* Successful login */
+}
+
+/*
+** The sqlite3_user_add() interface can be used (by an admin user only)
+** to create a new user.  When called on a no-authentication-required
+** database, this routine converts the database into an authentication-
+** required database, automatically makes the added user an
+** administrator, and logs in the current connection as that user.
+** The sqlite3_user_add() interface only works for the "main" database, not
+** for any ATTACH-ed databases.  Any call to sqlite3_user_add() by a
+** non-admin user results in an error.
+*/
+int sqlite3_user_add(
+  sqlite3 *db,           /* Database connection */
+  const char *zUsername, /* Username to be added */
+  const char *aPW,       /* Password or credentials */
+  int nPW,               /* Number of bytes in aPW[] */
+  int isAdmin            /* True to give new user admin privilege */
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+  sqlite3UserAuthInit(db);
+  if( db->auth.authLevel<UAUTH_Admin ) return SQLITE_AUTH;
+  if( !userTableExists(db, "main") ){
+    if( !isAdmin ) return SQLITE_AUTH;
+    pStmt = sqlite3UserAuthPrepare(db, 
+              "CREATE TABLE sqlite_user(\n"
+              "  uname TEXT PRIMARY KEY,\n"
+              "  isAdmin BOOLEAN,\n"
+              "  pw BLOB\n"
+              ") WITHOUT ROWID;");
+    if( pStmt==0 ) return SQLITE_NOMEM;
+    sqlite3_step(pStmt);
+    rc = sqlite3_finalize(pStmt);
+    if( rc ) return rc;
+  }
+  pStmt = sqlite3UserAuthPrepare(db, 
+            "INSERT INTO sqlite_user(uname,isAdmin,pw)"
+            " VALUES(%Q,%d,sqlite_crypt(?1,NULL))",
+            zUsername, isAdmin!=0);
+  if( pStmt==0 ) return SQLITE_NOMEM;
+  sqlite3_bind_blob(pStmt, 1, aPW, nPW, SQLITE_STATIC);
+  sqlite3_step(pStmt);
+  rc = sqlite3_finalize(pStmt);
+  if( rc ) return rc;
+  if( db->auth.zAuthUser==0 ){
+    assert( isAdmin!=0 );
+    sqlite3_user_authenticate(db, zUsername, aPW, nPW);
+  }
+  return SQLITE_OK;
+}
+
+/*
+** The sqlite3_user_change() interface can be used to change a users
+** login credentials or admin privilege.  Any user can change their own
+** login credentials.  Only an admin user can change another users login
+** credentials or admin privilege setting.  No user may change their own 
+** admin privilege setting.
+*/
+int sqlite3_user_change(
+  sqlite3 *db,           /* Database connection */
+  const char *zUsername, /* Username to change */
+  const char *aPW,       /* Modified password or credentials */
+  int nPW,               /* Number of bytes in aPW[] */
+  int isAdmin            /* Modified admin privilege for the user */
+){
+  sqlite3_stmt *pStmt;
+  int rc;
+  u8 authLevel;
+
+  authLevel = db->auth.authLevel;
+  if( authLevel<UAUTH_User ){
+    /* Must be logged in to make a change */
+    return SQLITE_AUTH;
+  }
+  if( strcmp(db->auth.zAuthUser, zUsername)!=0 ){
+    if( db->auth.authLevel<UAUTH_Admin ){
+      /* Must be an administrator to change a different user */
+      return SQLITE_AUTH;
+    }
+  }else if( isAdmin!=(authLevel==UAUTH_Admin) ){
+    /* Cannot change the isAdmin setting for self */
+    return SQLITE_AUTH;
+  }
+  db->auth.authLevel = UAUTH_Admin;
+  if( !userTableExists(db, "main") ){
+    /* This routine is a no-op if the user to be modified does not exist */
+  }else{
+    pStmt = sqlite3UserAuthPrepare(db,
+              "UPDATE sqlite_user SET isAdmin=%d, pw=sqlite_crypt(?1,NULL)"
+              " WHERE uname=%Q", isAdmin, zUsername);
+    if( pStmt==0 ){
+      rc = SQLITE_NOMEM;
+    }else{
+      sqlite3_bind_blob(pStmt, 1, aPW, nPW, SQLITE_STATIC);
+      sqlite3_step(pStmt);
+      rc = sqlite3_finalize(pStmt);
+    }
+  }
+  db->auth.authLevel = authLevel;
+  return rc;
+}
+
+/*
+** The sqlite3_user_delete() interface can be used (by an admin user only)
+** to delete a user.  The currently logged-in user cannot be deleted,
+** which guarantees that there is always an admin user and hence that
+** the database cannot be converted into a no-authentication-required
+** database.
+*/
+int sqlite3_user_delete(
+  sqlite3 *db,           /* Database connection */
+  const char *zUsername  /* Username to remove */
+){
+  sqlite3_stmt *pStmt;
+  if( db->auth.authLevel<UAUTH_Admin ){
+    /* Must be an administrator to delete a user */
+    return SQLITE_AUTH;
+  }
+  if( strcmp(db->auth.zAuthUser, zUsername)==0 ){
+    /* Cannot delete self */
+    return SQLITE_AUTH;
+  }
+  if( !userTableExists(db, "main") ){
+    /* This routine is a no-op if the user to be deleted does not exist */
+    return SQLITE_OK;
+  }
+  pStmt = sqlite3UserAuthPrepare(db,
+              "DELETE FROM sqlite_user WHERE uname=%Q", zUsername);
+  if( pStmt==0 ) return SQLITE_NOMEM;
+  sqlite3_step(pStmt);
+  return sqlite3_finalize(pStmt);
+}
+
+#endif /* SQLITE_USER_AUTHENTICATION */

Index: main.mk
==================================================================
--- main.mk
+++ main.mk
@@ -44,11 +44,11 @@
 
 # This is how we compile
 #
 TCCX =  $(TCC) $(OPTS) -I. -I$(TOP)/src -I$(TOP) 
 TCCX += -I$(TOP)/ext/rtree -I$(TOP)/ext/icu -I$(TOP)/ext/fts3
-TCCX += -I$(TOP)/ext/async
+TCCX += -I$(TOP)/ext/async -I$(TOP)/ext/userauth
 
 # Object files for the SQLite library.
 #
 LIBOBJ+= vdbe.o parse.o \
          alter.o analyze.o attach.o auth.o \
@@ -65,11 +65,11 @@
          mutex.o mutex_noop.o mutex_unix.o mutex_w32.o \
          notify.o opcodes.o os.o os_unix.o os_win.o \
          pager.o pcache.o pcache1.o pragma.o prepare.o printf.o \
          random.o resolve.o rowset.o rtree.o select.o status.o \
          table.o threads.o tokenize.o trigger.o \
-         update.o util.o vacuum.o \
+         update.o userauth.o util.o vacuum.o \
          vdbeapi.o vdbeaux.o vdbeblob.o vdbemem.o vdbesort.o \
 	 vdbetrace.o wal.o walker.o where.o utf.o vtab.o
 
 
 
@@ -212,11 +212,13 @@
   $(TOP)/ext/icu/icu.c
 SRC += \
   $(TOP)/ext/rtree/sqlite3rtree.h \
   $(TOP)/ext/rtree/rtree.h \
   $(TOP)/ext/rtree/rtree.c
-
+SRC += \
+  $(TOP)/ext/userauth/userauth.c \
+  $(TOP)/ext/userauth/sqlite3userauth.h
 
 # Generated source code files
 #
 SRC += \
   keywordhash.h \
@@ -375,10 +377,12 @@
   $(TOP)/ext/fts3/fts3_tokenizer.h
 EXTHDR += \
   $(TOP)/ext/rtree/rtree.h
 EXTHDR += \
   $(TOP)/ext/icu/sqliteicu.h
+EXTHDR += \
+  $(TOP)/ext/userauth/sqlite3userauth.h
 
 # This is the default Makefile target.  The objects listed here
 # are what get build when you type just "make" with no arguments.
 #
 all:	sqlite3.h libsqlite3.a sqlite3$(EXE)
@@ -555,10 +559,13 @@
 fts3_write.o:	$(TOP)/ext/fts3/fts3_write.c $(HDR) $(EXTHDR)
 	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/fts3/fts3_write.c
 
 rtree.o:	$(TOP)/ext/rtree/rtree.c $(HDR) $(EXTHDR)
 	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/rtree/rtree.c
+
+userauth.o:	$(TOP)/ext/userauth/userauth.c $(HDR) $(EXTHDR)
+	$(TCCX) -DSQLITE_CORE -c $(TOP)/ext/userauth/userauth.c
 
 
 # Rules for building test programs and for running tests
 #
 tclsqlite3:	$(TOP)/src/tclsqlite.c libsqlite3.a

Index: src/attach.c
==================================================================
--- src/attach.c
+++ src/attach.c
@@ -205,10 +205,19 @@
   if( rc==SQLITE_OK ){
     sqlite3BtreeEnterAll(db);
     rc = sqlite3Init(db, &zErrDyn);
     sqlite3BtreeLeaveAll(db);
   }
+#ifdef SQLITE_USER_AUTHENTICATION
+  if( rc==SQLITE_OK ){
+    u8 newAuth = 0;
+    rc = sqlite3UserAuthCheckLogin(db, zName, &newAuth);
+    if( newAuth<db->auth.authLevel ){
+      rc = SQLITE_AUTH_USER;
+    }
+  }
+#endif
   if( rc ){
     int iDb = db->nDb - 1;
     assert( iDb>=2 );
     if( db->aDb[iDb].pBt ){
       sqlite3BtreeClose(db->aDb[iDb].pBt);

Index: src/auth.c
==================================================================
--- src/auth.c
+++ src/auth.c
@@ -71,11 +71,11 @@
   sqlite3 *db,
   int (*xAuth)(void*,int,const char*,const char*,const char*,const char*),
   void *pArg
 ){
   sqlite3_mutex_enter(db->mutex);
-  db->xAuth = xAuth;
+  db->xAuth = (sqlite3_xauth)xAuth;
   db->pAuthArg = pArg;
   sqlite3ExpirePreparedStatements(db);
   sqlite3_mutex_leave(db->mutex);
   return SQLITE_OK;
 }
@@ -106,11 +106,15 @@
 ){
   sqlite3 *db = pParse->db;       /* Database handle */
   char *zDb = db->aDb[iDb].zName; /* Name of attached database */
   int rc;                         /* Auth callback return code */
 
-  rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext);
+  rc = db->xAuth(db->pAuthArg, SQLITE_READ, zTab,zCol,zDb,pParse->zAuthContext
+#ifdef SQLITE_USER_AUTHENTICATION
+                 ,db->auth.zAuthUser
+#endif
+                );
   if( rc==SQLITE_DENY ){
     if( db->nDb>2 || iDb!=0 ){
       sqlite3ErrorMsg(pParse, "access to %s.%s.%s is prohibited",zDb,zTab,zCol);
     }else{
       sqlite3ErrorMsg(pParse, "access to %s.%s is prohibited", zTab, zCol);
@@ -206,11 +210,15 @@
   }
 
   if( db->xAuth==0 ){
     return SQLITE_OK;
   }
-  rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext);
+  rc = db->xAuth(db->pAuthArg, code, zArg1, zArg2, zArg3, pParse->zAuthContext
+#ifdef SQLITE_USER_AUTHENTICATION
+                 ,db->auth.zAuthUser
+#endif
+                );
   if( rc==SQLITE_DENY ){
     sqlite3ErrorMsg(pParse, "not authorized");
     pParse->rc = SQLITE_AUTH;
   }else if( rc!=SQLITE_OK && rc!=SQLITE_IGNORE ){
     rc = SQLITE_DENY;

Index: src/build.c
==================================================================
--- src/build.c
+++ src/build.c
@@ -153,10 +153,21 @@
   assert( !pParse->isMultiWrite 
        || sqlite3VdbeAssertMayAbort(v, pParse->mayAbort));
   if( v ){
     while( sqlite3VdbeDeletePriorOpcode(v, OP_Close) ){}
     sqlite3VdbeAddOp0(v, OP_Halt);
+
+#if SQLITE_USER_AUTHENTICATION
+    if( pParse->nTableLock>0 && db->init.busy==0 ){
+      sqlite3UserAuthInit(db);
+      if( db->auth.authLevel<UAUTH_User ){
+        pParse->rc = SQLITE_AUTH_USER;
+        sqlite3ErrorMsg(pParse, "user not authenticated");
+        return;
+      }
+    }
+#endif
 
     /* The cookie mask contains one bit for each database file open.
     ** (Bit 0 is for main, bit 1 is for temp, and so forth.)  Bits are
     ** set for each database that is used.  Generate code to start a
     ** transaction on each used database and to verify the schema cookie
@@ -269,10 +280,20 @@
   sqlite3DbFree(db, zSql);
   memcpy(&pParse->nVar, saveBuf, SAVE_SZ);
   pParse->nested--;
 }
 
+#if SQLITE_USER_AUTHENTICATION
+/*
+** Return TRUE if zTable is the name of the system table that stores the
+** list of users and their access credentials.
+*/
+int sqlite3UserAuthTable(const char *zTable){
+  return sqlite3_stricmp(zTable, "sqlite_user")==0;
+}
+#endif
+
 /*
 ** Locate the in-memory structure that describes a particular database
 ** table given the name of that table and (optionally) the name of the
 ** database containing the table.  Return NULL if not found.
 **
@@ -287,10 +308,17 @@
   Table *p = 0;
   int i;
   assert( zName!=0 );
   /* All mutexes are required for schema access.  Make sure we hold them. */
   assert( zDatabase!=0 || sqlite3BtreeHoldsAllMutexes(db) );
+#if SQLITE_USER_AUTHENTICATION
+  /* Only the admin user is allowed to know that the sqlite_user table
+  ** exists */
+  if( db->auth.authLevel<UAUTH_Admin && sqlite3UserAuthTable(zName)!=0 ){
+    return 0;
+  }
+#endif
   for(i=OMIT_TEMPDB; i<db->nDb; i++){
     int j = (i<2) ? i^1 : i;   /* Search TEMP before MAIN */
     if( zDatabase!=0 && sqlite3StrICmp(zDatabase, db->aDb[j].zName) ) continue;
     assert( sqlite3SchemaMutexHeld(db, j, 0) );
     p = sqlite3HashFind(&db->aDb[j].pSchema->tblHash, zName);
@@ -331,10 +359,16 @@
     }else{
       sqlite3ErrorMsg(pParse, "%s: %s", zMsg, zName);
     }
     pParse->checkSchema = 1;
   }
+#if SQLITE_USER_AUTHENICATION
+  else if( pParse->db->auth.authLevel<UAUTH_User ){
+    sqlite3ErrorMsg(pParse, "user not authenticated");
+    p = 0;
+  }
+#endif
   return p;
 }
 
 /*
 ** Locate the table identified by *p.
@@ -2050,11 +2084,11 @@
   Table *pSelTab;   /* A fake table from which we get the result set */
   Select *pSel;     /* Copy of the SELECT that implements the view */
   int nErr = 0;     /* Number of errors encountered */
   int n;            /* Temporarily holds the number of cursors assigned */
   sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
-  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
+  sqlite3_xauth xAuth;       /* Saved xAuth pointer */
 
   assert( pTable );
 
 #ifndef SQLITE_OMIT_VIRTUALTABLE
   if( sqlite3VtabCallConnect(pParse, pTable) ){
@@ -2865,10 +2899,14 @@
   pDb = &db->aDb[iDb];
 
   assert( pTab!=0 );
   assert( pParse->nErr==0 );
   if( sqlite3StrNICmp(pTab->zName, "sqlite_", 7)==0 
+       && db->init.busy==0
+#if SQLITE_USER_AUTHENTICATION
+       && sqlite3UserAuthTable(pTab->zName)==0
+#endif
        && sqlite3StrNICmp(&pTab->zName[7],"altertab_",9)!=0 ){
     sqlite3ErrorMsg(pParse, "table %s may not be indexed", pTab->zName);
     goto exit_create_index;
   }
 #ifndef SQLITE_OMIT_VIEW

Index: src/ctime.c
==================================================================
--- src/ctime.c
+++ src/ctime.c
@@ -365,10 +365,13 @@
 #if defined(SQLITE_THREADSAFE)
   "THREADSAFE=" CTIMEOPT_VAL(SQLITE_THREADSAFE),
 #endif
 #ifdef SQLITE_USE_ALLOCA
   "USE_ALLOCA",
+#endif
+#ifdef SQLITE_USER_AUTHENTICATION
+  "USER_AUTHENTICATION",
 #endif
 #ifdef SQLITE_WIN32_MALLOC
   "WIN32_MALLOC",
 #endif
 #ifdef SQLITE_ZERO_MALLOC

Index: src/func.c
==================================================================
--- src/func.c
+++ src/func.c
@@ -1693,10 +1693,13 @@
     VFUNCTION(randomblob,        1, 0, 0, randomBlob       ),
     FUNCTION(nullif,             2, 0, 1, nullifFunc       ),
     FUNCTION(sqlite_version,     0, 0, 0, versionFunc      ),
     FUNCTION(sqlite_source_id,   0, 0, 0, sourceidFunc     ),
     FUNCTION(sqlite_log,         2, 0, 0, errlogFunc       ),
+#if SQLITE_USER_AUTHENTICATION
+    FUNCTION(sqlite_crypt,       2, 0, 0, sqlite3CryptFunc ),
+#endif
 #ifndef SQLITE_OMIT_COMPILEOPTION_DIAGS
     FUNCTION(sqlite_compileoption_used,1, 0, 0, compileoptionusedFunc  ),
     FUNCTION(sqlite_compileoption_get, 1, 0, 0, compileoptiongetFunc  ),
 #endif /* SQLITE_OMIT_COMPILEOPTION_DIAGS */
     FUNCTION(quote,              1, 0, 0, quoteFunc        ),

Index: src/legacy.c
==================================================================
--- src/legacy.c
+++ src/legacy.c
@@ -123,11 +123,11 @@
 exec_out:
   if( pStmt ) sqlite3VdbeFinalize((Vdbe *)pStmt);
   sqlite3DbFree(db, azCols);
 
   rc = sqlite3ApiExit(db, rc);
-  if( rc!=SQLITE_OK && ALWAYS(rc==sqlite3_errcode(db)) && pzErrMsg ){
+  if( rc!=SQLITE_OK && pzErrMsg ){
     int nErrMsg = 1 + sqlite3Strlen30(sqlite3_errmsg(db));
     *pzErrMsg = sqlite3Malloc(nErrMsg);
     if( *pzErrMsg ){
       memcpy(*pzErrMsg, sqlite3_errmsg(db), nErrMsg);
     }else{

Index: src/main.c
==================================================================
--- src/main.c
+++ src/main.c
@@ -983,10 +983,14 @@
 #endif
 
   sqlite3Error(db, SQLITE_OK); /* Deallocates any cached error strings. */
   sqlite3ValueFree(db->pErr);
   sqlite3CloseExtensions(db);
+#if SQLITE_USER_AUTHENTICATION
+  sqlite3_free(db->auth.zAuthUser);
+  sqlite3_free(db->auth.zAuthPW);
+#endif
 
   db->magic = SQLITE_MAGIC_ERROR;
 
   /* The temp-database schema is allocated differently from the other schema
   ** objects (using sqliteMalloc() directly, instead of sqlite3BtreeSchema()).
@@ -2563,11 +2567,10 @@
     sqlite3Error(db, rc);
     goto opendb_out;
   }
   db->aDb[0].pSchema = sqlite3SchemaGet(db, db->aDb[0].pBt);
   db->aDb[1].pSchema = sqlite3SchemaGet(db, 0);
-
 
   /* The default safety_level for the main database is 'full'; for the temp
   ** database it is 'NONE'. This matches the pager layer defaults.  
   */
   db->aDb[0].zName = "main";

Index: src/pragma.c
==================================================================
--- src/pragma.c
+++ src/pragma.c
@@ -1395,10 +1395,16 @@
       if( db->autoCommit==0 ){
         /* Foreign key support may not be enabled or disabled while not
         ** in auto-commit mode.  */
         mask &= ~(SQLITE_ForeignKeys);
       }
+#if SQLITE_USER_AUTHENTICATION
+      if( db->auth.authLevel==UAUTH_User ){
+        /* Do not allow non-admin users to modify the schema arbitrarily */
+        mask &= ~(SQLITE_WriteSchema);
+      }
+#endif
 
       if( sqlite3GetBoolean(zRight, 0) ){
         db->flags |= mask;
       }else{
         db->flags &= ~mask;

Index: src/prepare.c
==================================================================
--- src/prepare.c
+++ src/prepare.c
@@ -326,11 +326,11 @@
     zSql = sqlite3MPrintf(db, 
         "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
         db->aDb[iDb].zName, zMasterName);
 #ifndef SQLITE_OMIT_AUTHORIZATION
     {
-      int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
+      sqlite3_xauth xAuth;
       xAuth = db->xAuth;
       db->xAuth = 0;
 #endif
       rc = sqlite3_exec(db, zSql, sqlite3InitCallback, &initData, 0);
 #ifndef SQLITE_OMIT_AUTHORIZATION
@@ -392,10 +392,11 @@
 int sqlite3Init(sqlite3 *db, char **pzErrMsg){
   int i, rc;
   int commit_internal = !(db->flags&SQLITE_InternChanges);
   
   assert( sqlite3_mutex_held(db->mutex) );
+  assert( db->init.busy==0 );
   rc = SQLITE_OK;
   db->init.busy = 1;
   for(i=0; rc==SQLITE_OK && i<db->nDb; i++){
     if( DbHasProperty(db, i, DB_SchemaLoaded) || i==1 ) continue;
     rc = sqlite3InitOne(db, i, pzErrMsg);
@@ -407,12 +408,12 @@
   /* Once all the other databases have been initialized, load the schema
   ** for the TEMP database. This is loaded last, as the TEMP database
   ** schema may contain references to objects in other databases.
   */
 #ifndef SQLITE_OMIT_TEMPDB
-  if( rc==SQLITE_OK && ALWAYS(db->nDb>1)
-                    && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
+  assert( db->nDb>1 );
+  if( rc==SQLITE_OK && !DbHasProperty(db, 1, DB_SchemaLoaded) ){
     rc = sqlite3InitOne(db, 1, pzErrMsg);
     if( rc ){
       sqlite3ResetOneSchema(db, 1);
     }
   }

Index: src/shell.c
==================================================================
--- src/shell.c
+++ src/shell.c
@@ -31,10 +31,13 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 #include <assert.h>
 #include "sqlite3.h"
+#if SQLITE_USER_AUTHENTICATION
+# include "sqlite3userauth.h"
+#endif
 #include <ctype.h>
 #include <stdarg.h>
 
 #if !defined(_WIN32) && !defined(WIN32)
 # include <signal.h>
@@ -3433,10 +3436,75 @@
       sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
     }
 #endif
   }else
 
+#if SQLITE_USER_AUTHENTICATION
+  if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
+    if( nArg<2 ){
+      fprintf(stderr, "Usage: .user SUBCOMMAND ...\n");
+      rc = 1;
+      goto meta_command_exit;
+    }
+    open_db(p, 0);
+    if( strcmp(azArg[1],"login")==0 ){
+      if( nArg!=4 ){
+        fprintf(stderr, "Usage: .user login USER PASSWORD\n");
+        rc = 1;
+        goto meta_command_exit;
+      }
+      rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
+                                    (int)strlen(azArg[3]));
+      if( rc ){
+        fprintf(stderr, "Authentication failed for user %s\n", azArg[2]);
+        rc = 1;
+      }
+    }else if( strcmp(azArg[1],"add")==0 ){
+      if( nArg!=5 ){
+        fprintf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
+        rc = 1;
+        goto meta_command_exit;
+      }
+      rc = sqlite3_user_add(p->db, azArg[2],
+                            azArg[3], (int)strlen(azArg[3]),
+                            booleanValue(azArg[4]));
+      if( rc ){
+        fprintf(stderr, "User-Add failed: %d\n", rc);
+        rc = 1;
+      }
+    }else if( strcmp(azArg[1],"edit")==0 ){
+      if( nArg!=5 ){
+        fprintf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
+        rc = 1;
+        goto meta_command_exit;
+      }
+      rc = sqlite3_user_change(p->db, azArg[2],
+                              azArg[3], (int)strlen(azArg[3]),
+                              booleanValue(azArg[4]));
+      if( rc ){
+        fprintf(stderr, "User-Edit failed: %d\n", rc);
+        rc = 1;
+      }
+    }else if( strcmp(azArg[1],"delete")==0 ){
+      if( nArg!=3 ){
+        fprintf(stderr, "Usage: .user delete USER\n");
+        rc = 1;
+        goto meta_command_exit;
+      }
+      rc = sqlite3_user_delete(p->db, azArg[2]);
+      if( rc ){
+        fprintf(stderr, "User-Delete failed: %d\n", rc);
+        rc = 1;
+      }
+    }else{
+      fprintf(stderr, "Usage: .user login|add|edit|delete ...\n");
+      rc = 1;
+      goto meta_command_exit;
+    }    
+  }else
+#endif /* SQLITE_USER_AUTHENTICATION */
+
   if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
     fprintf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
         sqlite3_libversion(), sqlite3_sourceid());
   }else
 

Index: src/sqlite.h.in
==================================================================
--- src/sqlite.h.in
+++ src/sqlite.h.in
@@ -490,10 +490,11 @@
 #define SQLITE_CONSTRAINT_VTAB         (SQLITE_CONSTRAINT | (9<<8))
 #define SQLITE_CONSTRAINT_ROWID        (SQLITE_CONSTRAINT |(10<<8))
 #define SQLITE_NOTICE_RECOVER_WAL      (SQLITE_NOTICE | (1<<8))
 #define SQLITE_NOTICE_RECOVER_ROLLBACK (SQLITE_NOTICE | (2<<8))
 #define SQLITE_WARNING_AUTOINDEX       (SQLITE_WARNING | (1<<8))
+#define SQLITE_AUTH_USER               (SQLITE_AUTH | (1<<8))
 
 /*
 ** CAPI3REF: Flags For File Open Operations
 **
 ** These bit values are intended for use in the

Index: src/sqliteInt.h
==================================================================
--- src/sqliteInt.h
+++ src/sqliteInt.h
@@ -985,10 +985,49 @@
 ** Collisions are on the FuncDef.pHash chain.
 */
 struct FuncDefHash {
   FuncDef *a[23];       /* Hash table for functions */
 };
+
+#ifdef SQLITE_USER_AUTHENTICATION
+/*
+** Information held in the "sqlite3" database connection object and used
+** to manage user authentication.
+*/
+typedef struct sqlite3_userauth sqlite3_userauth;
+struct sqlite3_userauth {
+  u8 authLevel;                 /* Current authentication level */
+  int nAuthPW;                  /* Size of the zAuthPW in bytes */
+  char *zAuthPW;                /* Password used to authenticate */
+  char *zAuthUser;              /* User name used to authenticate */
+};
+
+/* Allowed values for sqlite3_userauth.authLevel */
+#define UAUTH_Unknown     0     /* Authentication not yet checked */
+#define UAUTH_Fail        1     /* User authentication failed */
+#define UAUTH_User        2     /* Authenticated as a normal user */
+#define UAUTH_Admin       3     /* Authenticated as an administrator */
+
+/* Functions used only by user authorization logic */
+int sqlite3UserAuthTable(const char*);
+int sqlite3UserAuthCheckLogin(sqlite3*,const char*,u8*);
+void sqlite3UserAuthInit(sqlite3*);
+void sqlite3CryptFunc(sqlite3_context*,int,sqlite3_value**);
+
+#endif /* SQLITE_USER_AUTHENTICATION */
+
+/*
+** typedef for the authorization callback function.
+*/
+#ifdef SQLITE_USER_AUTHENTICATION
+  typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
+                               const char*, const char*);
+#else
+  typedef int (*sqlite3_xauth)(void*,int,const char*,const char*,const char*,
+                               const char*);
+#endif
+
 
 /*
 ** Each database connection is an instance of the following structure.
 */
 struct sqlite3 {
@@ -1053,12 +1092,11 @@
     volatile int isInterrupted; /* True if sqlite3_interrupt has been called */
     double notUsed1;            /* Spacer */
   } u1;
   Lookaside lookaside;          /* Lookaside malloc configuration */
 #ifndef SQLITE_OMIT_AUTHORIZATION
-  int (*xAuth)(void*,int,const char*,const char*,const char*,const char*);
-                                /* Access authorization function */
+  sqlite3_xauth xAuth;          /* Access authorization function */
   void *pAuthArg;               /* 1st argument to the access auth function */
 #endif
 #ifndef SQLITE_OMIT_PROGRESS_CALLBACK
   int (*xProgress)(void *);     /* The progress callback */
   void *pProgressArg;           /* Argument to the progress callback */
@@ -1080,11 +1118,10 @@
   int nSavepoint;               /* Number of non-transaction savepoints */
   int nStatement;               /* Number of nested statement-transactions  */
   i64 nDeferredCons;            /* Net deferred constraints this transaction. */
   i64 nDeferredImmCons;         /* Net deferred immediate constraints */
   int *pnBytesFreed;            /* If not NULL, increment this in DbFree() */
-
 #ifdef SQLITE_ENABLE_UNLOCK_NOTIFY
   /* The following variables are all protected by the STATIC_MASTER 
   ** mutex, not by sqlite3.mutex. They are used by code in notify.c. 
   **
   ** When X.pUnlockConnection==Y, that means that X is waiting for Y to
@@ -1098,10 +1135,13 @@
   sqlite3 *pUnlockConnection;           /* Connection to watch for unlock */
   void *pUnlockArg;                     /* Argument to xUnlockNotify */
   void (*xUnlockNotify)(void **, int);  /* Unlock notify callback */
   sqlite3 *pNextBlocked;        /* Next in list of all blocked connections */
 #endif
+#ifdef SQLITE_USER_AUTHENTICATION
+  sqlite3_userauth auth;        /* User authentication information */
+#endif
 };
 
 /*
 ** A macro to discover the encoding of a database.
 */

Index: src/tclsqlite.c
==================================================================
--- src/tclsqlite.c
+++ src/tclsqlite.c
@@ -870,10 +870,13 @@
   int code,
   const char *zArg1,
   const char *zArg2,
   const char *zArg3,
   const char *zArg4
+#ifdef SQLITE_USER_AUTHENTICATION
+  ,const char *zArg5
+#endif
 ){
   const char *zCode;
   Tcl_DString str;
   int rc;
   const char *zReply;
@@ -922,10 +925,13 @@
   Tcl_DStringAppendElement(&str, zCode);
   Tcl_DStringAppendElement(&str, zArg1 ? zArg1 : "");
   Tcl_DStringAppendElement(&str, zArg2 ? zArg2 : "");
   Tcl_DStringAppendElement(&str, zArg3 ? zArg3 : "");
   Tcl_DStringAppendElement(&str, zArg4 ? zArg4 : "");
+#ifdef SQLITE_USER_AUTHENTICATION
+  Tcl_DStringAppendElement(&str, zArg5 ? zArg5 : "");
+#endif  
   rc = Tcl_GlobalEval(pDb->interp, Tcl_DStringValue(&str));
   Tcl_DStringFree(&str);
   zReply = rc==TCL_OK ? Tcl_GetStringResult(pDb->interp) : "SQLITE_DENY";
   if( strcmp(zReply,"SQLITE_OK")==0 ){
     rc = SQLITE_OK;
@@ -1698,12 +1704,15 @@
         memcpy(pDb->zAuth, zAuth, len+1);
       }else{
         pDb->zAuth = 0;
       }
       if( pDb->zAuth ){
+        typedef int (*sqlite3_auth_cb)(
+           void*,int,const char*,const char*,
+           const char*,const char*);
         pDb->interp = interp;
-        sqlite3_set_authorizer(pDb->db, auth_callback, pDb);
+        sqlite3_set_authorizer(pDb->db,(sqlite3_auth_cb)auth_callback,pDb);
       }else{
         sqlite3_set_authorizer(pDb->db, 0, 0);
       }
     }
 #endif

Index: src/test1.c
==================================================================
--- src/test1.c
+++ src/test1.c
@@ -6495,10 +6495,136 @@
   Tcl_AppendResult(interp, "sql error: ", sqlite3_errmsg(db), 0);
   return TCL_ERROR;
 }
 
 
+#ifdef SQLITE_USER_AUTHENTICATION
+#include "sqlite3userauth.h"
+/*
+** tclcmd:  sqlite3_user_authenticate DB USERNAME PASSWORD
+*/
+static int test_user_authenticate(
+  ClientData clientData, /* Unused */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  char *zUser = 0;
+  char *zPasswd = 0;
+  int nPasswd = 0;
+  sqlite3 *db;
+  int rc;
+
+  if( objc!=4 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
+    return TCL_ERROR;
+  }
+  zUser = Tcl_GetString(objv[2]);
+  zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd);
+  rc = sqlite3_user_authenticate(db, zUser, zPasswd, nPasswd);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+#endif /* SQLITE_USER_AUTHENTICATION */
+
+#ifdef SQLITE_USER_AUTHENTICATION
+/*
+** tclcmd:  sqlite3_user_add DB USERNAME PASSWORD ISADMIN
+*/
+static int test_user_add(
+  ClientData clientData, /* Unused */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  char *zUser = 0;
+  char *zPasswd = 0;
+  int nPasswd = 0;
+  int isAdmin = 0;
+  sqlite3 *db;
+  int rc;
+
+  if( objc!=5 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
+    return TCL_ERROR;
+  }
+  zUser = Tcl_GetString(objv[2]);
+  zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd);
+  Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin);
+  rc = sqlite3_user_add(db, zUser, zPasswd, nPasswd, isAdmin);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+#endif /* SQLITE_USER_AUTHENTICATION */
+
+#ifdef SQLITE_USER_AUTHENTICATION
+/*
+** tclcmd:  sqlite3_user_change DB USERNAME PASSWORD ISADMIN
+*/
+static int test_user_change(
+  ClientData clientData, /* Unused */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  char *zUser = 0;
+  char *zPasswd = 0;
+  int nPasswd = 0;
+  int isAdmin = 0;
+  sqlite3 *db;
+  int rc;
+
+  if( objc!=5 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME PASSWORD ISADMIN");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
+    return TCL_ERROR;
+  }
+  zUser = Tcl_GetString(objv[2]);
+  zPasswd = Tcl_GetStringFromObj(objv[3], &nPasswd);
+  Tcl_GetBooleanFromObj(interp, objv[4], &isAdmin);
+  rc = sqlite3_user_change(db, zUser, zPasswd, nPasswd, isAdmin);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+#endif /* SQLITE_USER_AUTHENTICATION */
+
+#ifdef SQLITE_USER_AUTHENTICATION
+/*
+** tclcmd:  sqlite3_user_delete DB USERNAME
+*/
+static int test_user_delete(
+  ClientData clientData, /* Unused */
+  Tcl_Interp *interp,    /* The TCL interpreter that invoked this command */
+  int objc,              /* Number of arguments */
+  Tcl_Obj *CONST objv[]  /* Command arguments */
+){
+  char *zUser = 0;
+  sqlite3 *db;
+  int rc;
+
+  if( objc!=3 ){
+    Tcl_WrongNumArgs(interp, 1, objv, "DB USERNAME");
+    return TCL_ERROR;
+  }
+  if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ){
+    return TCL_ERROR;
+  }
+  zUser = Tcl_GetString(objv[2]);
+  rc = sqlite3_user_delete(db, zUser);
+  Tcl_SetResult(interp, (char *)t1ErrorName(rc), TCL_STATIC);
+  return TCL_OK;
+}
+#endif /* SQLITE_USER_AUTHENTICATION */
+
 /*
 ** Register commands with the TCL interpreter.
 */
 int Sqlitetest1_Init(Tcl_Interp *interp){
   extern int sqlite3_search_count;
@@ -6732,10 +6858,17 @@
      { "getrusage", test_getrusage },
 #endif
      { "load_static_extension", tclLoadStaticExtensionCmd },
      { "sorter_test_fakeheap", sorter_test_fakeheap },
      { "sorter_test_sort4_helper", sorter_test_sort4_helper },
+#ifdef SQLITE_USER_AUTHENTICATION
+     { "sqlite3_user_authenticate", test_user_authenticate, 0 },
+     { "sqlite3_user_add",          test_user_add,          0 },
+     { "sqlite3_user_change",       test_user_change,       0 },
+     { "sqlite3_user_delete",       test_user_delete,       0 },
+#endif
+
   };
   static int bitmask_size = sizeof(Bitmask)*8;
   int i;
   extern int sqlite3_sync_count, sqlite3_fullsync_count;
   extern int sqlite3_opentemp_count;

Index: src/test_config.c
==================================================================
--- src/test_config.c
+++ src/test_config.c
@@ -600,10 +600,16 @@
 #ifdef SQLITE_SECURE_DELETE
   Tcl_SetVar2(interp, "sqlite_options", "secure_delete", "1", TCL_GLOBAL_ONLY);
 #else
   Tcl_SetVar2(interp, "sqlite_options", "secure_delete", "0", TCL_GLOBAL_ONLY);
 #endif
+
+#ifdef SQLITE_USER_AUTHENTICATION
+  Tcl_SetVar2(interp, "sqlite_options", "userauth", "1", TCL_GLOBAL_ONLY);
+#else
+  Tcl_SetVar2(interp, "sqlite_options", "userauth", "0", TCL_GLOBAL_ONLY);
+#endif
 
 #ifdef SQLITE_MULTIPLEX_EXT_OVWR
   Tcl_SetVar2(interp, "sqlite_options", "multiplex_ext_overwrite", "1", TCL_GLOBAL_ONLY);
 #else
   Tcl_SetVar2(interp, "sqlite_options", "multiplex_ext_overwrite", "0", TCL_GLOBAL_ONLY);

Index: test/auth.test
==================================================================
--- test/auth.test
+++ test/auth.test
@@ -34,11 +34,11 @@
 }
 
 do_test auth-1.1.1 {
   db close
   set ::DB [sqlite3 db test.db]
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -59,11 +59,11 @@
 } {1 {no such column: x}}
 do_test auth-1.2 {
   execsql {SELECT name FROM sqlite_master}
 } {}
 do_test auth-1.3.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -80,11 +80,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {}
 
 ifcapable tempdb {
   do_test auth-1.5 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
         return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -92,11 +92,11 @@
   } {1 {not authorized}}
   do_test auth-1.6 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {}
   do_test auth-1.7.1 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -110,11 +110,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {}
 }
 
 do_test auth-1.9 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -122,11 +122,11 @@
 } {0 {}}
 do_test auth-1.10 {
   execsql {SELECT name FROM sqlite_master}
 } {}
 do_test auth-1.11 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -137,11 +137,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {}
 
 ifcapable tempdb {
   do_test auth-1.13 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
         return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -149,11 +149,11 @@
   } {0 {}}
   do_test auth-1.14 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {}
   do_test auth-1.15 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -163,11 +163,11 @@
   do_test auth-1.16 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {}
   
   do_test auth-1.17 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -179,11 +179,11 @@
   } {t1}
 }
 
 do_test auth-1.19.1 {
   set ::authargs {}
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TEMP_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -196,11 +196,11 @@
 do_test auth-1.20 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 do_test auth-1.21.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -212,11 +212,11 @@
 } {t2 {} main {}}
 do_test auth-1.22 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.23.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -230,11 +230,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 ifcapable tempdb {
   do_test auth-1.25 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -243,11 +243,11 @@
   } {1 {not authorized}}
   do_test auth-1.26 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.27 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -258,11 +258,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
 }
 
 do_test auth-1.29 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="t2"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -270,11 +270,11 @@
 } {1 {not authorized}}
 do_test auth-1.30 {
   execsql {SELECT * FROM t2}
 } {}
 do_test auth-1.31 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="t2"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -282,11 +282,11 @@
 } {0 {}}
 do_test auth-1.32 {
   execsql {SELECT * FROM t2}
 } {}
 do_test auth-1.33 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="t1"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -295,11 +295,11 @@
 do_test auth-1.34 {
   execsql {SELECT * FROM t2}
 } {1 2 3}
 
 do_test auth-1.35.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -311,57 +311,57 @@
     catchsql {SELECT * FROM two.t2}
   } {1 {access to two.t2.b is prohibited}}
   execsql {DETACH DATABASE two}
 }
 do_test auth-1.36 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2}
 } {0 {1 {} 3}}
 do_test auth-1.37 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2 WHERE b=2}
 } {0 {}}
 do_test auth-1.38 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="a"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2 WHERE b=2}
 } {0 {{} 2 3}}
 do_test auth-1.39 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2 WHERE b IS NULL}
 } {0 {1 {} 3}}
 do_test auth-1.40 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
   catchsql {SELECT a,c FROM t2 WHERE b IS NULL}
 } {1 {access to t2.b is prohibited}}
   
 do_test auth-1.41 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_UPDATE" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -369,11 +369,11 @@
 } {0 {}}
 do_test auth-1.42 {
   execsql {SELECT * FROM t2}
 } {11 2 3}
 do_test auth-1.43 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_UPDATE" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -381,11 +381,11 @@
 } {1 {not authorized}}
 do_test auth-1.44 {
   execsql {SELECT * FROM t2}
 } {11 2 3}
 do_test auth-1.45 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_UPDATE" && $arg1=="t2" && $arg2=="b"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -394,11 +394,11 @@
 do_test auth-1.46 {
   execsql {SELECT * FROM t2}
 } {11 2 33}
 
 do_test auth-1.47 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="t2"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -406,11 +406,11 @@
 } {1 {not authorized}}
 do_test auth-1.48 {
   execsql {SELECT * FROM t2}
 } {11 2 33}
 do_test auth-1.49 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="t2"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -422,29 +422,29 @@
 do_test auth-1.50.2 {
   execsql {INSERT INTO t2 VALUES(11, 2, 33)}
 } {}
 
 do_test auth-1.51 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_SELECT"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2}
 } {1 {not authorized}}
 do_test auth-1.52 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_SELECT"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2}
 } {0 {}}
 do_test auth-1.53 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_SELECT"} {
       return SQLITE_OK
     }
     return SQLITE_OK
   }
@@ -460,11 +460,11 @@
 do_test auth-1.55 {
   execsql {SELECT * FROM t2}
 } {11 2 33 7 8 9}
 
 do_test auth-1.63 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
        return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -472,11 +472,11 @@
 } {1 {not authorized}}
 do_test auth-1.64 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.65 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="t2"} {
        return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -486,11 +486,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 ifcapable tempdb {
   do_test auth-1.67 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
          return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -498,11 +498,11 @@
   } {1 {not authorized}}
   do_test auth-1.68 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.69 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="t1"} {
          return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -512,11 +512,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
 }
 
 do_test auth-1.71 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
        return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -524,11 +524,11 @@
 } {0 {}}
 do_test auth-1.72 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.73 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="t2"} {
        return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -538,11 +538,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 ifcapable tempdb {
   do_test auth-1.75 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
          return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -550,11 +550,11 @@
   } {0 {}}
   do_test auth-1.76 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.77 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="t1"} {
          return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -567,11 +567,11 @@
 
 # Test cases auth-1.79 to auth-1.124 test creating and dropping views.
 # Omit these if the library was compiled with views omitted.
 ifcapable view {
 do_test auth-1.79 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_VIEW"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4] 
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -583,11 +583,11 @@
 } {v1 {} main {}}
 do_test auth-1.81 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.82 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_VIEW"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4] 
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -601,11 +601,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 ifcapable tempdb {
   do_test auth-1.85 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_VIEW"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4] 
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -617,11 +617,11 @@
   } {v1 {} temp {}}
   do_test auth-1.87 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.88 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_VIEW"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4] 
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -635,11 +635,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
 }
 
 do_test auth-1.91 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -647,11 +647,11 @@
 } {1 {not authorized}}
 do_test auth-1.92 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.93 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -661,11 +661,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 ifcapable tempdb {
   do_test auth-1.95 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
         return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -673,11 +673,11 @@
   } {1 {not authorized}}
   do_test auth-1.96 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.97 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
         return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -687,11 +687,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
 }
 
 do_test auth-1.99 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -702,11 +702,11 @@
 } {1 {not authorized}}
 do_test auth-1.100 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 v2}
 do_test auth-1.101 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_VIEW"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -718,11 +718,11 @@
 } {v2 {} main {}}
 do_test auth-1.103 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 v2}
 do_test auth-1.104 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -730,11 +730,11 @@
 } {0 {}}
 do_test auth-1.105 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 v2}
 do_test auth-1.106 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_VIEW"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -746,11 +746,11 @@
 } {v2 {} main {}}
 do_test auth-1.108 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 v2}
 do_test auth-1.109 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_VIEW"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -765,11 +765,11 @@
 } {t2}
 
 
 ifcapable tempdb {
   do_test auth-1.112 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
         return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -780,11 +780,11 @@
   } {1 {not authorized}}
   do_test auth-1.113 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 v1}
   do_test auth-1.114 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_VIEW"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -796,11 +796,11 @@
   } {v1 {} temp {}}
   do_test auth-1.116 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 v1}
   do_test auth-1.117 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
         return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -808,11 +808,11 @@
   } {0 {}}
   do_test auth-1.118 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 v1}
   do_test auth-1.119 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_VIEW"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -824,11 +824,11 @@
   } {v1 {} temp {}}
   do_test auth-1.121 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 v1}
   do_test auth-1.122 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_VIEW"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_OK
       }
       return SQLITE_OK
@@ -847,11 +847,11 @@
 # Test cases auth-1.125 to auth-1.176 test creating and dropping triggers.
 # Omit these if the library was compiled with triggers omitted.
 #
 ifcapable trigger&&tempdb {
 do_test auth-1.125 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -867,11 +867,11 @@
 } {r2 t2 main {}}
 do_test auth-1.127 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.128 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -883,11 +883,11 @@
 } {1 {not authorized}}
 do_test auth-1.129 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.130 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -903,11 +903,11 @@
 } {r2 t2 main {}}
 do_test auth-1.132 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.133 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -919,11 +919,11 @@
 } {0 {}}
 do_test auth-1.134 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.135 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -942,11 +942,11 @@
   execsql {
     SELECT name FROM sqlite_master WHERE type='trigger'
   }
 } {r2}
 do_test auth-1.136.3 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     lappend ::authargs $code $arg1 $arg2 $arg3 $arg4
     return SQLITE_OK
   }
   set ::authargs {}
   execsql {
@@ -961,11 +961,11 @@
 } {3}
 do_test auth-1.137 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 tx r2}
 do_test auth-1.138 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TEMP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -981,11 +981,11 @@
 } {r1 t1 temp {}}
 do_test auth-1.140 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1}
 do_test auth-1.141 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -997,11 +997,11 @@
 } {1 {not authorized}}
 do_test auth-1.142 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1}
 do_test auth-1.143 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TEMP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1017,11 +1017,11 @@
 } {r1 t1 temp {}}
 do_test auth-1.145 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1}
 do_test auth-1.146 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -1033,11 +1033,11 @@
 } {0 {}}
 do_test auth-1.147 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1}
 do_test auth-1.148 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_TEMP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1054,11 +1054,11 @@
 do_test auth-1.150 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1 r1}
 
 do_test auth-1.151 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -1066,11 +1066,11 @@
 } {1 {not authorized}}
 do_test auth-1.152 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 tx r2}
 do_test auth-1.153 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1082,11 +1082,11 @@
 } {r2 t2 main {}}
 do_test auth-1.155 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 tx r2}
 do_test auth-1.156 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -1094,11 +1094,11 @@
 } {0 {}}
 do_test auth-1.157 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 tx r2}
 do_test auth-1.158 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1110,11 +1110,11 @@
 } {r2 t2 main {}}
 do_test auth-1.160 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 tx r2}
 do_test auth-1.161 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1131,11 +1131,11 @@
     SELECT name FROM sqlite_master;
   }
 } {t2}
 
 do_test auth-1.164 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -1143,11 +1143,11 @@
 } {1 {not authorized}}
 do_test auth-1.165 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1 r1}
 do_test auth-1.166 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TEMP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1159,11 +1159,11 @@
 } {r1 t1 temp {}}
 do_test auth-1.168 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1 r1}
 do_test auth-1.169 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -1171,11 +1171,11 @@
 } {0 {}}
 do_test auth-1.170 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1 r1}
 do_test auth-1.171 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TEMP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1187,11 +1187,11 @@
 } {r1 t1 temp {}}
 do_test auth-1.173 {
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1 r1}
 do_test auth-1.174 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_TEMP_TRIGGER"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1205,11 +1205,11 @@
   execsql {SELECT name FROM sqlite_temp_master}
 } {t1}
 } ;# ifcapable trigger
 
 do_test auth-1.177 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_INDEX"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1221,11 +1221,11 @@
 } {i2 t2 main {}}
 do_test auth-1.179 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.180 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -1233,11 +1233,11 @@
 } {1 {not authorized}}
 do_test auth-1.181 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.182 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_INDEX"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1249,11 +1249,11 @@
 } {i2 t2 main {}}
 do_test auth-1.184 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.185 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_INSERT" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -1261,11 +1261,11 @@
 } {0 {}}
 do_test auth-1.186 {
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 do_test auth-1.187 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_CREATE_INDEX"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1279,11 +1279,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2 i2}
 
 ifcapable tempdb {
   do_test auth-1.190 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_INDEX"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -1295,11 +1295,11 @@
   } {i1 t1 temp {}}
   do_test auth-1.192 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.193 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
         return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -1307,11 +1307,11 @@
   } {1 {not authorized}}
   do_test auth-1.194 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.195 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_INDEX"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -1323,11 +1323,11 @@
   } {i1 t1 temp {}}
   do_test auth-1.197 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.198 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_INSERT" && $arg1=="sqlite_temp_master"} {
         return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -1335,11 +1335,11 @@
   } {0 {}}
   do_test auth-1.199 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
   do_test auth-1.200 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_CREATE_TEMP_INDEX"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_OK
       }
       return SQLITE_OK
@@ -1353,11 +1353,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 i1}
 }
 
 do_test auth-1.203 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -1365,11 +1365,11 @@
 } {1 {not authorized}}
 do_test auth-1.204 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 i2}
 do_test auth-1.205 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_INDEX"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1381,11 +1381,11 @@
 } {i2 t2 main {}}
 do_test auth-1.207 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 i2}
 do_test auth-1.208 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DELETE" && $arg1=="sqlite_master"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -1393,11 +1393,11 @@
 } {0 {}}
 do_test auth-1.209 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 i2}
 do_test auth-1.210 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_INDEX"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1409,11 +1409,11 @@
 } {i2 t2 main {}}
 do_test auth-1.212 {
   execsql {SELECT name FROM sqlite_master}
 } {t2 i2}
 do_test auth-1.213 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_DROP_INDEX"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1427,11 +1427,11 @@
   execsql {SELECT name FROM sqlite_master}
 } {t2}
 
 ifcapable tempdb {
   do_test auth-1.216 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
         return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -1439,11 +1439,11 @@
   } {1 {not authorized}}
   do_test auth-1.217 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 i1}
   do_test auth-1.218 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_INDEX"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -1455,11 +1455,11 @@
   } {i1 t1 temp {}}
   do_test auth-1.220 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 i1}
   do_test auth-1.221 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DELETE" && $arg1=="sqlite_temp_master"} {
         return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -1467,11 +1467,11 @@
   } {0 {}}
   do_test auth-1.222 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 i1}
   do_test auth-1.223 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_INDEX"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -1483,11 +1483,11 @@
   } {i1 t1 temp {}}
   do_test auth-1.225 {
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1 i1}
   do_test auth-1.226 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DROP_TEMP_INDEX"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_OK
       }
       return SQLITE_OK
@@ -1501,11 +1501,11 @@
     execsql {SELECT name FROM sqlite_temp_master}
   } {t1}
 }
 
 do_test auth-1.229 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_PRAGMA"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1517,11 +1517,11 @@
 } {full_column_names on {} {}}
 do_test auth-1.231 {
   execsql2 {SELECT a FROM t2}
 } {a 11 a 7}
 do_test auth-1.232 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_PRAGMA"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1533,11 +1533,11 @@
 } {full_column_names on {} {}}
 do_test auth-1.234 {
   execsql2 {SELECT a FROM t2}
 } {a 11 a 7}
 do_test auth-1.235 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_PRAGMA"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1546,11 +1546,11 @@
 } {0 {}}
 do_test auth-1.236 {
   execsql2 {SELECT a FROM t2}
 } {t2.a 11 t2.a 7}
 do_test auth-1.237 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_PRAGMA"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1563,11 +1563,11 @@
 do_test auth-1.239 {
   execsql2 {SELECT a FROM t2}
 } {a 11 a 7}
 
 do_test auth-1.240 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_TRANSACTION"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1576,11 +1576,11 @@
 } {1 {not authorized}}
 do_test auth-1.241 {
   set ::authargs
 } {BEGIN {} {} {}}
 do_test auth-1.242 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_TRANSACTION" && $arg1!="BEGIN"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1616,11 +1616,11 @@
 # ticket #340 - authorization for ATTACH and DETACH.
 #
 ifcapable attach {
   do_test auth-1.251 {
     db authorizer ::auth
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_ATTACH"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       }
       return SQLITE_OK
     }
@@ -1642,11 +1642,11 @@
     db eval {ATTACH ':mem' || 'ory:' AS test1}
     set ::authargs
   } {{} {} {} {}}
   do_test auth-1.253 {
     catchsql {DETACH DATABASE test1}
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_ATTACH"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -1658,11 +1658,11 @@
   do_test auth-1.254 {
     lindex [execsql {PRAGMA database_list}] 7
   } {}
   do_test auth-1.255 {
     catchsql {DETACH DATABASE test1}
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_ATTACH"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -1673,11 +1673,11 @@
   } {0 {}}
   do_test auth-1.256 {
     lindex [execsql {PRAGMA database_list}] 7
   } {}
   do_test auth-1.257 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DETACH"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_OK
       }
       return SQLITE_OK
@@ -1690,11 +1690,11 @@
   do_test auth-1.258 {
     lindex [execsql {PRAGMA database_list}] 7
   } {}
   do_test auth-1.259 {
     execsql {ATTACH DATABASE ':memory:' AS test1}
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_DETACH"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -1708,11 +1708,11 @@
     do_test auth-1.260 {
       lindex [execsql {PRAGMA database_list}] 7
     } {test1}
     } ;# ifcapable schema_pragmas
     do_test auth-1.261 {
-      proc auth {code arg1 arg2 arg3 arg4} {
+      proc auth {code arg1 arg2 arg3 arg4 args} {
         if {$code=="SQLITE_DETACH"} {
           set ::authargs [list $arg1 $arg2 $arg3 $arg4]
           return SQLITE_DENY
         }
         return SQLITE_OK
@@ -1733,11 +1733,11 @@
     # Authorization for ALTER TABLE. These tests are omitted if the library
     # was built without ALTER TABLE support.
     ifcapable altertable {
     
       do_test auth-1.263 {
-        proc auth {code arg1 arg2 arg3 arg4} {
+        proc auth {code arg1 arg2 arg3 arg4 args} {
           if {$code=="SQLITE_ALTER_TABLE"} {
             set ::authargs [list $arg1 $arg2 $arg3 $arg4]
             return SQLITE_OK
           }
           return SQLITE_OK
@@ -1751,11 +1751,11 @@
       } {t1x}
       do_test auth-1.265 {
         set authargs
       } {temp t1 {} {}}
       do_test auth-1.266 {
-        proc auth {code arg1 arg2 arg3 arg4} {
+        proc auth {code arg1 arg2 arg3 arg4 args} {
           if {$code=="SQLITE_ALTER_TABLE"} {
             set ::authargs [list $arg1 $arg2 $arg3 $arg4]
             return SQLITE_IGNORE
           }
           return SQLITE_OK
@@ -1769,11 +1769,11 @@
       } {t1x}
       do_test auth-1.268 {
         set authargs
       } {temp t1x {} {}}
       do_test auth-1.269 {
-        proc auth {code arg1 arg2 arg3 arg4} {
+        proc auth {code arg1 arg2 arg3 arg4 args} {
           if {$code=="SQLITE_ALTER_TABLE"} {
             set ::authargs [list $arg1 $arg2 $arg3 $arg4]
             return SQLITE_DENY
           }
           return SQLITE_OK
@@ -1802,11 +1802,11 @@
 ifcapable  altertable {
 db authorizer {}
 catchsql {ALTER TABLE t1x RENAME TO t1}
 db authorizer ::auth
 do_test auth-1.272 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_ALTER_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_OK
     }
     return SQLITE_OK
@@ -1820,11 +1820,11 @@
 } {t2x}
 do_test auth-1.274 {
   set authargs
 } {main t2 {} {}}
 do_test auth-1.275 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_ALTER_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_IGNORE
     }
     return SQLITE_OK
@@ -1838,11 +1838,11 @@
 } {t2x}
 do_test auth-1.277 {
   set authargs
 } {main t2x {} {}}
 do_test auth-1.278 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_ALTER_TABLE"} {
       set ::authargs [list $arg1 $arg2 $arg3 $arg4]
       return SQLITE_DENY
     }
     return SQLITE_OK
@@ -1865,11 +1865,11 @@
 # Test the authorization callbacks for the REINDEX command.
 ifcapable reindex {
 
 proc auth {code args} {
   if {$code=="SQLITE_REINDEX"} {
-    set ::authargs [concat $::authargs $args]
+    set ::authargs [concat $::authargs [lrange $args 0 3]]
   }
   return SQLITE_OK
 }
 db authorizer auth
 do_test auth-1.281 {
@@ -1948,11 +1948,11 @@
     }
     set ::authargs
   } {t3_idx2 {} temp {} t3_idx1 {} temp {} sqlite_autoindex_t3_1 {} temp {}}
   proc auth {code args} {
     if {$code=="SQLITE_REINDEX"} {
-      set ::authargs [concat $::authargs $args]
+      set ::authargs [concat $::authargs [lrange $args 0 3]]
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
   do_test auth-1.292 {
@@ -1971,11 +1971,11 @@
 } ;# ifcapable reindex 
 
 ifcapable analyze {
   proc auth {code args} {
     if {$code=="SQLITE_ANALYZE"} {
-      set ::authargs [concat $::authargs $args]
+      set ::authargs [concat $::authargs [lrange $args 0 3]]
     }
     return SQLITE_OK
   }
   do_test auth-1.294 {
     set ::authargs {}
@@ -2018,11 +2018,11 @@
 # These tests are omitted if the library
 # was built without ALTER TABLE support.
 ifcapable {altertable} {
   do_test auth-1.300 {
     execsql {CREATE TABLE t5(x)}
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_ALTER_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_OK
       }
       return SQLITE_OK
@@ -2037,11 +2037,11 @@
   } {1}
   do_test auth-1.302 {
     set authargs
   } {main t5 {} {}}
   do_test auth-1.303 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_ALTER_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_IGNORE
       }
       return SQLITE_OK
@@ -2056,11 +2056,11 @@
   } {0}
   do_test auth-1.305 {
     set authargs
   } {main t5 {} {}}
   do_test auth-1.306 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_ALTER_TABLE"} {
         set ::authargs [list $arg1 $arg2 $arg3 $arg4]
         return SQLITE_DENY
       }
       return SQLITE_OK
@@ -2080,11 +2080,11 @@
   execsql {DROP TABLE t5}
 } ;# ifcapable altertable
 
 ifcapable {cte} {
   do_test auth-1.310 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_RECURSIVE"} {
         return SQLITE_DENY
       }
       return SQLITE_OK
     }
@@ -2115,11 +2115,11 @@
     SELECT * FROM t1 LEFT JOIN auth1314;
   } {1 {not authorized}}
 } ;# ifcapable cte
 
 do_test auth-2.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t3" && $arg2=="x"} {
       return SQLITE_DENY
     }
     return SQLITE_OK
   }
@@ -2135,11 +2135,11 @@
 } {1 {access to t3.x is prohibited}}
 do_test auth-2.3 {
   catchsql {SELECT OID,y,z FROM t3}
 } {1 {access to t3.x is prohibited}}
 do_test auth-2.4 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t3" && $arg2=="x"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -2148,11 +2148,11 @@
 } {0 {{} 55 66}}
 do_test auth-2.5 {
   catchsql {SELECT rowid,y,z FROM t3}
 } {0 {{} 55 66}}
 do_test auth-2.6 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t3" && $arg2=="ROWID"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -2160,11 +2160,11 @@
 } {0 {44 55 66}}
 do_test auth-2.7 {
   catchsql {SELECT ROWID,y,z FROM t3}
 } {0 {44 55 66}}
 do_test auth-2.8 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="ROWID"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -2179,11 +2179,11 @@
   # the error code is SQLITE_SCHEMA, not SQLITE_ERROR as required by the test
   # case after this one.
   #
   db cache flush
 
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="ROWID"} {
       return bogus
     }
     return SQLITE_OK
   }
@@ -2191,29 +2191,29 @@
 } {1 {authorizer malfunction}}
 do_test auth-2.9.2 {
   db errorcode
 } {1}
 do_test auth-2.10 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_SELECT"} {
       return bogus
     }
     return SQLITE_OK
   }
   catchsql {SELECT ROWID,b,c FROM t2}
 } {1 {authorizer malfunction}}
 do_test auth-2.11.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg2=="a"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
   catchsql {SELECT * FROM t2, t3}
 } {0 {{} 2 33 44 55 66 {} 8 9 44 55 66}}
 do_test auth-2.11.2 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_READ" && $arg2=="x"} {
       return SQLITE_IGNORE
     }
     return SQLITE_OK
   }
@@ -2222,11 +2222,11 @@
 
 # Make sure the OLD and NEW pseudo-tables of a trigger get authorized.
 #
 ifcapable trigger {
   do_test auth-3.1 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       return SQLITE_OK
     }
     execsql {
       CREATE TABLE tx(a1,a2,b1,b2,c1,c2);
       CREATE TRIGGER r1 AFTER UPDATE ON t2 FOR EACH ROW BEGIN
@@ -2235,11 +2235,11 @@
       UPDATE t2 SET a=a+1;
       SELECT * FROM tx;
     }
   } {11 12 2 2 33 33 7 8 8 8 9 9}
   do_test auth-3.2 {
-    proc auth {code arg1 arg2 arg3 arg4} {
+    proc auth {code arg1 arg2 arg3 arg4 args} {
       if {$code=="SQLITE_READ" && $arg1=="t2" && $arg2=="c"} {
         return SQLITE_IGNORE
       }
       return SQLITE_OK
     }
@@ -2253,11 +2253,11 @@
 
 # Make sure the names of views and triggers are passed on on arg4.
 #
 ifcapable trigger {
 do_test auth-4.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     lappend ::authargs $code $arg1 $arg2 $arg3 $arg4
     return SQLITE_OK
   }
   set authargs {}
   execsql {
@@ -2338,11 +2338,11 @@
 
 # Ticket #1338:  Make sure authentication works in the presence of an AS
 # clause.
 #
 do_test auth-5.1 {
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     return SQLITE_OK
   }
   execsql {
     SELECT count(a) AS cnt FROM t4 ORDER BY cnt
   }
@@ -2391,11 +2391,11 @@
       END;
     }
   } {}
   set ::authargs [list]
   proc auth {args} {
-    eval lappend ::authargs $args
+    eval lappend ::authargs [lrange $args 0 4]
     return SQLITE_OK
   }
   do_test auth-5.3.2 {
     execsql { INSERT INTO t5 (x) values(0) }
     set ::authargs
@@ -2417,11 +2417,11 @@
     INSERT INTO t6 VALUES(1,2,3,4,5,6,7,8);
   }
 } {}
 set ::authargs [list]
 proc auth {args} {
-  eval lappend ::authargs $args
+  eval lappend ::authargs [lrange $args 0 4]
   return SQLITE_OK
 }
 do_test auth-6.2 {
   execsql {UPDATE t6 SET rowID=rowID+100}
   set ::authargs

Index: test/auth2.test
==================================================================
--- test/auth2.test
+++ test/auth2.test
@@ -29,11 +29,11 @@
   execsql {
     CREATE TABLE t1(a,b,c);
     INSERT INTO t1 VALUES(1,2,3);
   }
   set ::flist {}
-  proc auth {code arg1 arg2 arg3 arg4} {
+  proc auth {code arg1 arg2 arg3 arg4 args} {
     if {$code=="SQLITE_FUNCTION"} {
       lappend ::flist $arg2
       if {$arg2=="max"} {
         return SQLITE_DENY
       } elseif {$arg2=="min"} {
@@ -78,11 +78,11 @@
 db close
 sqlite3 db test.db
 sqlite3 db2 test.db
 proc auth {args} {
   global authargs
-  append authargs $args\n
+  append authargs [lrange $args 0 4]\n
   return SQLITE_OK
 }
 db auth auth
 do_test auth2-2.1 {
   set ::authargs {}

Index: test/auth3.test
==================================================================
--- test/auth3.test
+++ test/auth3.test
@@ -28,11 +28,11 @@
 # Disable the statement cache for these tests.
 # 
 db cache size 0
 
 db authorizer ::auth
-proc auth {code arg1 arg2 arg3 arg4} {
+proc auth {code arg1 arg2 arg3 arg4 args} {
   if {$code=="SQLITE_DELETE"} {
     return $::authcode
   }
   return SQLITE_OK
 }

Index: test/fkey2.test
==================================================================
--- test/fkey2.test
+++ test/fkey2.test
@@ -1552,11 +1552,11 @@
       CREATE TABLE short(d, e, f REFERENCES long);
       CREATE TABLE mid(g, h, i REFERENCES long DEFERRABLE INITIALLY DEFERRED);
     }
   } {}
 
-  proc auth {args} {eval lappend ::authargs $args ; return SQLITE_OK}
+  proc auth {args} {eval lappend ::authargs [lrange $args 0 4]; return SQLITE_OK}
   db auth auth
 
   # An insert on the parent table must read the child key of any deferred
   # foreign key constraints. But not the child key of immediate constraints.
   set authargs {}

Index: test/fts4aa.test
==================================================================
--- test/fts4aa.test
+++ test/fts4aa.test
@@ -168,11 +168,11 @@
 }
 
 # Should get the same search results when an authorizer prevents
 # all PRAGMA statements.
 #
-proc no_pragma_auth {code arg1 arg2 arg3 arg4} {
+proc no_pragma_auth {code arg1 arg2 arg3 arg4 args} {
   if {$code=="SQLITE_PRAGMA"} {return SQLITE_DENY}
   return SQLITE_OK;
 }
 do_test fts4aa-4.0 {
   db auth ::no_pragma_auth

Index: test/savepoint.test
==================================================================
--- test/savepoint.test
+++ test/savepoint.test
@@ -559,11 +559,11 @@
 
 # Test that the authorization callback works.
 #
 ifcapable auth {
   proc auth {args} {
-    eval lappend ::authdata $args
+    eval lappend ::authdata [lrange $args 0 4]
     return SQLITE_OK
   }
   db auth auth
 
   do_test savepoint-9.1 {
@@ -581,11 +581,11 @@
     execsql { RELEASE sp1 }
     set ::authdata
   } {SQLITE_SAVEPOINT RELEASE sp1 {} {}}
 
   proc auth {args} {
-    eval lappend ::authdata $args
+    eval lappend ::authdata [lrange $args 0 4]
     return SQLITE_DENY
   }
   db auth auth
 
   do_test savepoint-9.4 {

ADDED   test/userauth01.test
Index: test/userauth01.test
==================================================================
--- /dev/null
+++ test/userauth01.test
@@ -0,0 +1,257 @@
+# 2014-09-10
+#
+# 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.
+#
+#***********************************************************************
+# 
+# This file implements tests of the SQLITE_USER_AUTHENTICATION extension.
+#
+
+set testdir [file dirname $argv0]
+source $testdir/tester.tcl
+set testprefix userauth01
+
+ifcapable !userauth {
+  finish_test
+  return
+}
+
+# Create a no-authentication-required database
+#
+do_execsql_test userauth01-1.0 {
+  CREATE TABLE t1(x);
+  INSERT INTO t1 VALUES(1),(2.5),('three'),(x'4444'),(NULL);
+  SELECT quote(x) FROM t1 ORDER BY x;
+  SELECT name FROM sqlite_master;
+} {NULL 1 2.5 'three' X'4444' t1}
+
+# Calling sqlite3_user_authenticate() on a no-authentication-required
+# database connection is a harmless no-op.  
+#
+do_test userauth01-1.1 {
+  sqlite3_user_authenticate db alice pw-4-alice
+  execsql {
+    SELECT quote(x) FROM t1 ORDER BY x;
+    SELECT name FROM sqlite_master;
+  }
+} {NULL 1 2.5 'three' X'4444' t1}
+
+# If sqlite3_user_add(D,U,P,N,A) is called on a no-authentication-required
+# database and A is false, then the call fails with an SQLITE_AUTH error.
+#
+do_test userauth01-1.2 {
+  sqlite3_user_add db bob pw-4-bob 0
+} {SQLITE_AUTH}
+do_test userauth01-1.3 {
+  execsql {
+    SELECT quote(x) FROM t1 ORDER BY x;
+    SELECT name FROM sqlite_master;
+  }
+} {NULL 1 2.5 'three' X'4444' t1}
+
+# When called on a no-authentication-required
+# database and when A is true, the sqlite3_user_add(D,U,P,N,A) routine
+# converts the database into an authentication-required database and
+# logs the database connection D in using user U with password P,N.
+#  
+do_test userauth01-1.4 {
+  sqlite3_user_add db alice pw-4-alice 1
+} {SQLITE_OK}
+do_test userauth01-1.5 {
+  execsql {
+    SELECT quote(x) FROM t1 ORDER BY x;
+    SELECT uname, isadmin FROM sqlite_user ORDER BY uname;
+    SELECT name FROM sqlite_master ORDER BY name;
+  }
+} {NULL 1 2.5 'three' X'4444' alice 1 sqlite_user t1}
+
+# The sqlite3_user_add() interface can be used (by an admin user only)
+# to create a new user.
+#
+do_test userauth01-1.6 {
+  sqlite3_user_add db bob pw-4-bob 0
+  sqlite3_user_add db cindy pw-4-cindy 0
+  sqlite3_user_add db david pw-4-david 0
+  execsql {
+    SELECT uname, isadmin FROM sqlite_user ORDER BY uname;
+  }
+} {alice 1 bob 0 cindy 0 david 0}
+
+# The sqlite_user table is inaccessible (unreadable and unwriteable) to
+# non-admin users and is read-only for admin users.  However, if the same
+#
+do_test userauth01-1.7 {
+  sqlite3 db2 test.db
+  sqlite3_user_authenticate db2 cindy pw-4-cindy
+  db2 eval {
+    SELECT quote(x) FROM t1 ORDER BY x;
+    SELECT name FROM sqlite_master ORDER BY name;
+  }
+} {NULL 1 2.5 'three' X'4444' sqlite_user t1}
+do_test userauth01-1.8 {
+  catchsql {
+    SELECT uname, isadmin FROM sqlite_user ORDER BY uname;
+  } db2
+} {1 {no such table: sqlite_user}}
+
+# Any user can change their own password.  
+#
+do_test userauth01-1.9 {
+  sqlite3_user_change db2 cindy xyzzy-cindy 0
+} {SQLITE_OK}
+do_test userauth01-1.10 {
+  sqlite3_user_authenticate db2 cindy pw-4-cindy
+} {SQLITE_AUTH}
+do_test userauth01-1.11 {
+  sqlite3_user_authenticate db2 cindy xyzzy-cindy
+} {SQLITE_OK}
+do_test userauth01-1.12 {
+  sqlite3_user_change db alice xyzzy-alice 1
+} {SQLITE_OK}
+do_test userauth01-1.13 {
+  sqlite3_user_authenticate db alice pw-4-alice
+} {SQLITE_AUTH}
+do_test userauth01-1.14 {
+  sqlite3_user_authenticate db alice xyzzy-alice
+} {SQLITE_OK}
+
+# No user may change their own admin privilege setting.
+#
+do_test userauth01-1.15 {
+  sqlite3_user_change db alice xyzzy-alice 0
+} {SQLITE_AUTH}
+do_test userauth01-1.16 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 bob 0 cindy 0 david 0}
+do_test userauth01-1.17 {
+  sqlite3_user_change db2 cindy xyzzy-cindy 1
+} {SQLITE_AUTH}
+do_test userauth01-1.18 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 bob 0 cindy 0 david 0}
+
+# The sqlite3_user_change() interface can be used to change a users
+# login credentials or admin privilege.
+#
+do_test userauth01-1.20 {
+  sqlite3_user_change db david xyzzy-david 1
+} {SQLITE_OK}
+do_test userauth01-1.21 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 bob 0 cindy 0 david 1}
+do_test userauth01-1.22 {
+  sqlite3_user_authenticate db2 david xyzzy-david
+} {SQLITE_OK}
+do_test userauth01-1.23 {
+  db2 eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 bob 0 cindy 0 david 1}
+do_test userauth01-1.24 {
+  sqlite3_user_change db david pw-4-david 0
+} {SQLITE_OK}
+do_test userauth01-1.25 {
+  sqlite3_user_authenticate db2 david pw-4-david
+} {SQLITE_OK}
+do_test userauth01-1.26 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 bob 0 cindy 0 david 0}
+do_test userauth01-1.27 {
+  catchsql {SELECT uname, isadmin FROM sqlite_user ORDER BY uname} db2
+} {1 {no such table: sqlite_user}}
+
+# Only an admin user can change another users login
+# credentials or admin privilege setting.
+#
+do_test userauth01-1.30 {
+  sqlite3_user_change db2 bob xyzzy-bob 1
+} {SQLITE_AUTH}
+do_test userauth01-1.31 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 bob 0 cindy 0 david 0}
+
+# The sqlite3_user_delete() interface can be used (by an admin user only)
+# to delete a user.
+#
+do_test userauth01-1.40 {
+  sqlite3_user_delete db bob
+} {SQLITE_OK}
+do_test userauth01-1.41 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 cindy 0 david 0}
+do_test userauth01-1.42 {
+  sqlite3_user_delete db2 cindy
+} {SQLITE_AUTH}
+do_test userauth01-1.43 {
+  sqlite3_user_delete db2 alice
+} {SQLITE_AUTH}
+do_test userauth01-1.44 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 cindy 0 david 0}
+
+# The currently logged-in user cannot be deleted
+#
+do_test userauth01-1.50 {
+  sqlite3_user_delete db alice
+} {SQLITE_AUTH}
+do_test userauth01-1.51 {
+  db eval {SELECT uname, isadmin FROM sqlite_user ORDER BY uname}
+} {alice 1 cindy 0 david 0}
+
+# When ATTACH-ing new database files to a connection, each newly attached
+# database that is an authentication-required database is checked using
+# the same username and password as supplied to the main database.  If that
+# check fails, then the ATTACH command fails with an SQLITE_AUTH error.
+#
+do_test userauth01-1.60 {
+  forcedelete test3.db
+  sqlite3 db3 test3.db
+  sqlite3_user_add db3 alice xyzzy-alice 1
+} {SQLITE_OK}
+do_test userauth01-1.61 {
+  db3 eval {
+    CREATE TABLE t3(a,b,c); INSERT INTO t3 VALUES(1,2,3);
+    SELECT * FROM t3;
+  }
+} {1 2 3}
+do_test userauth01-1.62 {
+  db eval {
+    ATTACH 'test3.db' AS aux;
+    SELECT * FROM t1, t3 ORDER BY x LIMIT 1;
+    DETACH aux;
+  }
+} {{} 1 2 3}
+do_test userauth01-1.63 {
+  sqlite3_user_change db alice pw-4-alice 1
+  sqlite3_user_authenticate db alice pw-4-alice
+  catchsql {
+    ATTACH 'test3.db' AS aux;
+  }
+} {1 {unable to open database: test3.db}}
+do_test userauth01-1.64 {
+  sqlite3_extended_errcode db
+} {SQLITE_AUTH}
+do_test userauth01-1.65 {
+  db eval {PRAGMA database_list}
+} {~/test3.db/}
+
+# The sqlite3_set_authorizer() callback is modified to take a 7th parameter
+# which is the username of the currently logged in user, or NULL for a
+# no-authentication-required database.
+#
+proc auth {args} {
+  lappend ::authargs $args
+  return SQLITE_OK
+}
+do_test authuser01-2.1 {
+  unset -nocomplain ::authargs
+  db auth auth
+  db eval {SELECT x FROM t1}
+  set ::authargs
+} {/SQLITE_SELECT {} {} {} {} alice/}  
+
+
+finish_test

Index: test/vtab3.test
==================================================================
--- test/vtab3.test
+++ test/vtab3.test
@@ -23,11 +23,11 @@
 
 set ::auth_fail 0
 set ::auth_log [list]
 set ::auth_filter [list SQLITE_READ SQLITE_UPDATE SQLITE_SELECT SQLITE_PRAGMA]
 
-proc auth {code arg1 arg2 arg3 arg4} {
+proc auth {code arg1 arg2 arg3 arg4 args} {
   if {[lsearch $::auth_filter $code]>-1} {
     return SQLITE_OK
   }
   lappend ::auth_log $code $arg1 $arg2 $arg3 $arg4
   incr ::auth_fail -1

Index: test/without_rowid3.test
==================================================================
--- test/without_rowid3.test
+++ test/without_rowid3.test
@@ -1619,11 +1619,11 @@
       CREATE TABLE short(d, e, f REFERENCES long);
       CREATE TABLE mid(g, h, i REFERENCES long DEFERRABLE INITIALLY DEFERRED);
     }
   } {}
 
-  proc auth {args} {eval lappend ::authargs $args ; return SQLITE_OK}
+  proc auth {args} {eval lappend ::authargs [lrange $args 0 4]; return SQLITE_OK}
   db auth auth
 
   # An insert on the parent table must read the child key of any deferred
   # foreign key constraints. But not the child key of immediate constraints.
   set authargs {}