Improvements to cevfs_build.

Avoid sqlite3HexToBlob as SQLite memory management hasn't been configured yet.
Pass VFS name in as a parameter.

Author: techrah

README.md

@@ -56,14 +56,19 @@ build> $ clang cevfs-all.c cevfs_build.c -O2 -o cevfs_build -lz
 
 Then to create a CEVFS database:
 ```
-./cevfs_build UNCOMPRESSED COMPRESSED KEY VFS_NAME
+./cevfs_build UNCOMPRESSED COMPRESSED VFS_NAME KEY
 ```
 
 parameters:
 - **UNCOMPRESSED**: path to uncompressed database
 - **COMPRESSED**: path to new compressed database
-- **KEY**: encryption key
 - **VFS_NAME**: name to embed in header (10 chars. max.)
+- **KEY**: encryption key
+
+E.g.:
+```
+./cevfs_build myDatabase.db myNewDatabase.db default "x'2F3A995FCE317EA2...'"
+```
 
 ### Creating a Custom Version of SQLite
 It is helpful to have a custom command-line version of `sqlite3` on your development workstation for opening/testing your newly created databases.

cevfs/cevfs.c

@@ -1770,14 +1770,18 @@ int cevfs_create_vfs(
   return sqlite3_vfs_register(pNew, makeDefault);
 }
 
+static int _cevfs_destroy_vfs(sqlite3_vfs *pVfs) {
+  sqlite3_free(pVfs);
+  return SQLITE_OK;
+}
+
 int cevfs_destroy_vfs(const char *zName){
   sqlite3_vfs *pVfs = sqlite3_vfs_find(zName);
   if( pVfs ){
     //cevfs_info *pInfo = (cevfs_info *)pVfs->pAppData;
-    sqlite3_free(pVfs);
-    return SQLITE_OK;
+    return _cevfs_destroy_vfs(pVfs);
   }
-  return SQLITE_NOTFOUND;
+  return CEVFS_ERROR_VFS_DOES_NOT_EXIST;
 }
 
 int cevfs_build(
@@ -1858,12 +1862,11 @@ int cevfs_build(
                 }
               }
             }
-          }
-        }else{
-          rc = SQLITE_CORRUPT;
+          } else rc = SQLITE_CORRUPT;
         }
       }
-    }
+    } else rc = SQLITE_INTERNAL;
+    _cevfs_destroy_vfs(pDestVfs);
   }
   return rc;
 }

cevfs/cevfs.h

@@ -35,10 +35,11 @@ SOFTWARE.
 #define CEVFS_ERROR_MALFORMED_KEY                (CEVFS_ERROR | (2<<8))
 #define CEVFS_ERROR_EXT_VERSION_TOO_OLD          (CEVFS_ERROR | (3<<8))
 #define CEVFS_ERROR_VFS_ALREADY_EXISTS           (CEVFS_ERROR | (4<<8))
-#define CEVFS_ERROR_COMPRESSION_FAILED           (CEVFS_ERROR | (5<<8))
-#define CEVFS_ERROR_DECOMPRESSION_FAILED         (CEVFS_ERROR | (6<<8))
-#define CEVFS_ERROR_ENCRYPTION_FAILED            (CEVFS_ERROR | (7<<8))
-#define CEVFS_ERROR_DECRYPTION_FAILED            (CEVFS_ERROR | (8<<8))
+#define CEVFS_ERROR_VFS_DOES_NOT_EXIST           (CEVFS_ERROR | (5<<8))
+#define CEVFS_ERROR_COMPRESSION_FAILED           (CEVFS_ERROR | (6<<8))
+#define CEVFS_ERROR_DECOMPRESSION_FAILED         (CEVFS_ERROR | (7<<8))
+#define CEVFS_ERROR_ENCRYPTION_FAILED            (CEVFS_ERROR | (8<<8))
+#define CEVFS_ERROR_DECRYPTION_FAILED            (CEVFS_ERROR | (9<<8))
 
 struct CevfsMethods {
   void *pCtx;

cevfs_build/cevfs_build.c

@@ -31,38 +31,86 @@ SOFTWARE.
 #include "cevfs.h"
 #include "xMethods.c"
 
-typedef uint8_t u8;
-
 extern const char *fileTail(const char *z);
-extern void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n);
+typedef unsigned char u8;
+
+/*
+** Taken from SQLite source code.
+** Check to see if this machine uses EBCDIC.  (Yes, believe it or
+** not, there are still machines out there that use EBCDIC.)
+*/
+#if 'A' == '\301'
+# define SQLITE_EBCDIC 1
+#else
+# define SQLITE_ASCII 1
+#endif
+
+/*
+** Taken from SQLite source code.
+** Translate a single byte of Hex into an integer.
+** This routine only works if h really is a valid hexadecimal
+** character:  0..9a..fA..F
+*/
+static u8 hexToInt(int h){
+  assert( (h>='0' && h<='9') ||  (h>='a' && h<='f') ||  (h>='A' && h<='F') );
+#ifdef SQLITE_ASCII
+  h += 9*(1&(h>>6));
+#endif
+#ifdef SQLITE_EBCDIC
+  h += 9*(1&~(h>>4));
+#endif
+  return (u8)(h & 0xf);
+}
+
+/*
+** Taken from SQLite source code.
+** Convert a BLOB literal of the form "x'hhhhhh'" into its binary
+** value.  Return a pointer to its binary value.  Space to hold the
+** binary value has been obtained from malloc and must be freed by
+** the calling routine.
+*/
+static void *hexToBlob(const char *z, int n){
+  char *zBlob;
+  int i;
+
+  zBlob = (char *)malloc(n/2 + 1);
+  n--;
+  if( zBlob ){
+    for(i=0; i<n; i+=2){
+      zBlob[i/2] = (hexToInt(z[i])<<4) | hexToInt(z[i+1]);
+    }
+    zBlob[i/2] = 0;
+  }
+  return zBlob;
+}
+
+// This context will be passed to xAutoDetect and the functions defined within.
+struct context ctx;
 
 int main(int argc, const char * argv[]) {
-  if( argc != 4 ){
+  if( argc != 5 ){
     printf("Usage: %s UNCOMPRESSED COMPRESSED KEY\n", fileTail(argv[0]));
     printf("  UNCOMPRESSED: URI of uncompressed SQLite DB file.\n");
     printf("  COMPRESSED:   URI of new compressed DB with optional ?block_size=<block_size>\n");
+    printf("  VFS_NAME:     Name of VFS to embed in database file.\n");
     printf("  KEY:          Encryption key in the form: x'<hex1><hex2>...<hex32>'\n");
     return EXIT_FAILURE;
   }
 
   int rc;
 
-  // This context will be passed to xAutoDetect and the functions defined within.
-  struct context ctx;
-
   // Convert encryption key string to hex blob.
   // This assumes that the key is in the form of x'<hex-string>'
   // You should, of course, implement proper error checking.
-  const char *key = arvg[3]+2;
-  char *keyBytes = sqlite3HexToBlob(NULL, key, strlen(key)-1);
+  const char *key = argv[4]+2;
+  char *keyBytes = hexToBlob(key, (int)strlen(key)-1);
 
   ctx.pKey   = keyBytes;           // 32-bit encryption hex key
   ctx.nKeySz = kCCKeySizeAES256;   // key size in bytes
   ctx.nIvSz  = kCCBlockSizeAES128; // size of IV in bytes
 
-  // If you will be using the VFS name to determine how you set up your xMethods,
-  // you may want to pass the VFS name as a command line parameter as well.
-  // For now, we'll just pass "CEVFS-default".
-  rc = cevfs_build(argv[1], argv[2], "CEVFS-default", &ctx, cevfsAutoDetect);
+  // You can use the VFS name to determine how you set up your xMethods,
+  // so we pass the VFS name as a command line parameter as well.
+  rc = cevfs_build(argv[1], argv[2], argv[3], &ctx, cevfsAutoDetect);
   return rc;
 }