1 /* 2 ** 2008 March 19 3 ** 4 ** The author disclaims copyright to this source code. In place of 5 ** a legal notice, here is a blessing: 6 ** 7 ** May you do good and not evil. 8 ** May you find forgiveness for yourself and forgive others. 9 ** May you share freely, never taking more than you give. 10 ** 11 ************************************************************************* 12 ** Code for testing all sorts of SQLite interfaces. This code 13 ** implements new SQL functions used by the test scripts. 14 ** 15 ** $Id: test_func.c,v 1.8 2008/07/11 21:02:54 drh Exp $ 16 */ 17 #include "sqlite3.h" 18 #include "tcl.h" 19 #include <stdlib.h> 20 #include <string.h> 21 #include <assert.h> 22 23 24 /* 25 ** Allocate nByte bytes of space using sqlite3_malloc(). If the 26 ** allocation fails, call sqlite3_result_error_nomem() to notify 27 ** the database handle that malloc() has failed. 28 */ 29 static void *testContextMalloc(sqlite3_context *context, int nByte){ 30 char *z = sqlite3_malloc(nByte); 31 if( !z && nByte>0 ){ 32 sqlite3_result_error_nomem(context); 33 } 34 return z; 35 } 36 37 /* 38 ** This function generates a string of random characters. Used for 39 ** generating test data. 40 */ 41 static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){ 42 static const unsigned char zSrc[] = 43 "abcdefghijklmnopqrstuvwxyz" 44 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 45 "0123456789" 46 ".-!,:*^+=_|?/<> "; 47 int iMin, iMax, n, r, i; 48 unsigned char zBuf[1000]; 49 50 /* It used to be possible to call randstr() with any number of arguments, 51 ** but now it is registered with SQLite as requiring exactly 2. 52 */ 53 assert(argc==2); 54 55 iMin = sqlite3_value_int(argv[0]); 56 if( iMin<0 ) iMin = 0; 57 if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; 58 iMax = sqlite3_value_int(argv[1]); 59 if( iMax<iMin ) iMax = iMin; 60 if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; 61 n = iMin; 62 if( iMax>iMin ){ 63 sqlite3_randomness(sizeof(r), &r); 64 r &= 0x7fffffff; 65 n += r%(iMax + 1 - iMin); 66 } 67 assert( n<sizeof(zBuf) ); 68 sqlite3_randomness(n, zBuf); 69 for(i=0; i<n; i++){ 70 zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)]; 71 } 72 zBuf[n] = 0; 73 sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT); 74 } 75 76 /* 77 ** The following two SQL functions are used to test returning a text 78 ** result with a destructor. Function 'test_destructor' takes one argument 79 ** and returns the same argument interpreted as TEXT. A destructor is 80 ** passed with the sqlite3_result_text() call. 81 ** 82 ** SQL function 'test_destructor_count' returns the number of outstanding 83 ** allocations made by 'test_destructor'; 84 ** 85 ** WARNING: Not threadsafe. 86 */ 87 static int test_destructor_count_var = 0; 88 static void destructor(void *p){ 89 char *zVal = (char *)p; 90 assert(zVal); 91 zVal--; 92 sqlite3_free(zVal); 93 test_destructor_count_var--; 94 } 95 static void test_destructor( 96 sqlite3_context *pCtx, 97 int nArg, 98 sqlite3_value **argv 99 ){ 100 char *zVal; 101 int len; 102 103 test_destructor_count_var++; 104 assert( nArg==1 ); 105 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 106 len = sqlite3_value_bytes(argv[0]); 107 zVal = testContextMalloc(pCtx, len+3); 108 if( !zVal ){ 109 return; 110 } 111 zVal[len+1] = 0; 112 zVal[len+2] = 0; 113 zVal++; 114 memcpy(zVal, sqlite3_value_text(argv[0]), len); 115 sqlite3_result_text(pCtx, zVal, -1, destructor); 116 } 117 static void test_destructor16( 118 sqlite3_context *pCtx, 119 int nArg, 120 sqlite3_value **argv 121 ){ 122 char *zVal; 123 int len; 124 125 test_destructor_count_var++; 126 assert( nArg==1 ); 127 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 128 len = sqlite3_value_bytes16(argv[0]); 129 zVal = testContextMalloc(pCtx, len+3); 130 if( !zVal ){ 131 return; 132 } 133 zVal[len+1] = 0; 134 zVal[len+2] = 0; 135 zVal++; 136 memcpy(zVal, sqlite3_value_text16(argv[0]), len); 137 sqlite3_result_text16(pCtx, zVal, -1, destructor); 138 } 139 static void test_destructor_count( 140 sqlite3_context *pCtx, 141 int nArg, 142 sqlite3_value **argv 143 ){ 144 sqlite3_result_int(pCtx, test_destructor_count_var); 145 } 146 147 /* 148 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata() 149 ** interface. 150 ** 151 ** The test_auxdata() SQL function attempts to register each of its arguments 152 ** as auxiliary data. If there are no prior registrations of aux data for 153 ** that argument (meaning the argument is not a constant or this is its first 154 ** call) then the result for that argument is 0. If there is a prior 155 ** registration, the result for that argument is 1. The overall result 156 ** is the individual argument results separated by spaces. 157 */ 158 static void free_test_auxdata(void *p) {sqlite3_free(p);} 159 static void test_auxdata( 160 sqlite3_context *pCtx, 161 int nArg, 162 sqlite3_value **argv 163 ){ 164 int i; 165 char *zRet = testContextMalloc(pCtx, nArg*2); 166 if( !zRet ) return; 167 memset(zRet, 0, nArg*2); 168 for(i=0; i<nArg; i++){ 169 char const *z = (char*)sqlite3_value_text(argv[i]); 170 if( z ){ 171 int n; 172 char *zAux = sqlite3_get_auxdata(pCtx, i); 173 if( zAux ){ 174 zRet[i*2] = '1'; 175 assert( strcmp(zAux,z)==0 ); 176 }else { 177 zRet[i*2] = '0'; 178 } 179 n = strlen(z) + 1; 180 zAux = testContextMalloc(pCtx, n); 181 if( zAux ){ 182 memcpy(zAux, z, n); 183 sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata); 184 } 185 zRet[i*2+1] = ' '; 186 } 187 } 188 sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata); 189 } 190 191 /* 192 ** A function to test error reporting from user functions. This function 193 ** returns a copy of its first argument as the error message. If the 194 ** second argument exists, it becomes the error code. 195 */ 196 static void test_error( 197 sqlite3_context *pCtx, 198 int nArg, 199 sqlite3_value **argv 200 ){ 201 sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1); 202 if( nArg==2 ){ 203 sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1])); 204 } 205 } 206 207 /* 208 ** This function takes two arguments. It performance UTF-8/16 type 209 ** conversions on the first argument then returns a copy of the second 210 ** argument. 211 ** 212 ** This function is used in cases such as the following: 213 ** 214 ** SELECT test_isolation(x,x) FROM t1; 215 ** 216 ** We want to verify that the type conversions that occur on the 217 ** first argument do not invalidate the second argument. 218 */ 219 static void test_isolation( 220 sqlite3_context *pCtx, 221 int nArg, 222 sqlite3_value **argv 223 ){ 224 #ifndef SQLITE_OMIT_UTF16 225 sqlite3_value_text16(argv[0]); 226 sqlite3_value_text(argv[0]); 227 sqlite3_value_text16(argv[0]); 228 sqlite3_value_text(argv[0]); 229 #endif 230 sqlite3_result_value(pCtx, argv[1]); 231 } 232 233 /* 234 ** Invoke an SQL statement recursively. The function result is the 235 ** first column of the first row of the result set. 236 */ 237 static void test_eval( 238 sqlite3_context *pCtx, 239 int nArg, 240 sqlite3_value **argv 241 ){ 242 sqlite3_stmt *pStmt; 243 int rc; 244 sqlite3 *db = sqlite3_context_db_handle(pCtx); 245 const char *zSql; 246 247 zSql = (char*)sqlite3_value_text(argv[0]); 248 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 249 if( rc==SQLITE_OK ){ 250 rc = sqlite3_step(pStmt); 251 if( rc==SQLITE_ROW ){ 252 sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0)); 253 } 254 rc = sqlite3_finalize(pStmt); 255 } 256 if( rc ){ 257 char *zErr; 258 assert( pStmt==0 ); 259 zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db)); 260 sqlite3_result_text(pCtx, zErr, -1, sqlite3_free); 261 sqlite3_result_error_code(pCtx, rc); 262 } 263 } 264 265 266 static int registerTestFunctions(sqlite3 *db){ 267 static const struct { 268 char *zName; 269 signed char nArg; 270 unsigned char eTextRep; /* 1: UTF-16. 0: UTF-8 */ 271 void (*xFunc)(sqlite3_context*,int,sqlite3_value **); 272 } aFuncs[] = { 273 { "randstr", 2, SQLITE_UTF8, randStr }, 274 { "test_destructor", 1, SQLITE_UTF8, test_destructor}, 275 { "test_destructor16", 1, SQLITE_UTF8, test_destructor16}, 276 { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count}, 277 { "test_auxdata", -1, SQLITE_UTF8, test_auxdata}, 278 { "test_error", 1, SQLITE_UTF8, test_error}, 279 { "test_error", 2, SQLITE_UTF8, test_error}, 280 { "test_eval", 1, SQLITE_UTF8, test_eval}, 281 { "test_isolation", 2, SQLITE_UTF8, test_isolation}, 282 }; 283 int i; 284 extern int Md5_Register(sqlite3*); 285 286 for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ 287 sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, 288 aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0); 289 } 290 Md5_Register(db); 291 return SQLITE_OK; 292 } 293 294 /* 295 ** TCLCMD: autoinstall_test_functions 296 ** 297 ** Invoke this TCL command to use sqlite3_auto_extension() to cause 298 ** the standard set of test functions to be loaded into each new 299 ** database connection. 300 */ 301 static int autoinstall_test_funcs( 302 void * clientData, 303 Tcl_Interp *interp, 304 int objc, 305 Tcl_Obj *CONST objv[] 306 ){ 307 sqlite3_auto_extension((void*)registerTestFunctions); 308 return TCL_OK; 309 } 310 311 /* 312 ** A bogus step function and finalizer function. 313 */ 314 static void tStep(sqlite3_context *a, int b, sqlite3_value **c){} 315 static void tFinal(sqlite3_context *a){} 316 317 318 /* 319 ** tclcmd: abuse_create_function 320 ** 321 ** Make various calls to sqlite3_create_function that do not have valid 322 ** parameters. Verify that the error condition is detected and reported. 323 */ 324 static int abuse_create_function( 325 void * clientData, 326 Tcl_Interp *interp, 327 int objc, 328 Tcl_Obj *CONST objv[] 329 ){ 330 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 331 sqlite3 *db; 332 int rc; 333 int mxArg; 334 335 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 336 337 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal); 338 if( rc!=SQLITE_ERROR ) goto abuse_err; 339 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 340 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 341 342 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0); 343 if( rc!=SQLITE_ERROR ) goto abuse_err; 344 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 345 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 346 347 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal); 348 if( rc!=SQLITE_ERROR ) goto abuse_err; 349 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 350 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 351 352 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal); 353 if( rc!=SQLITE_ERROR ) goto abuse_err; 354 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 355 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 356 357 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0); 358 if( rc!=SQLITE_ERROR ) goto abuse_err; 359 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 360 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 361 362 rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0); 363 if( rc!=SQLITE_ERROR ) goto abuse_err; 364 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 365 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 366 367 rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0); 368 if( rc!=SQLITE_ERROR ) goto abuse_err; 369 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 370 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 371 372 rc = sqlite3_create_function(db, "funcxx" 373 "_123456789_123456789_123456789_123456789_123456789" 374 "_123456789_123456789_123456789_123456789_123456789" 375 "_123456789_123456789_123456789_123456789_123456789" 376 "_123456789_123456789_123456789_123456789_123456789" 377 "_123456789_123456789_123456789_123456789_123456789", 378 1, SQLITE_UTF8, 0, tStep, 0, 0); 379 if( rc!=SQLITE_ERROR ) goto abuse_err; 380 if( sqlite3_errcode(db)!=SQLITE_ERROR ) goto abuse_err; 381 if( strcmp(sqlite3_errmsg(db), "bad parameters")!=0 ) goto abuse_err; 382 383 /* This last function registration should actually work. Generate 384 ** a no-op function (that always returns NULL) and which has the 385 ** maximum-length function name and the maximum number of parameters. 386 */ 387 sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000); 388 mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1); 389 rc = sqlite3_create_function(db, "nullx" 390 "_123456789_123456789_123456789_123456789_123456789" 391 "_123456789_123456789_123456789_123456789_123456789" 392 "_123456789_123456789_123456789_123456789_123456789" 393 "_123456789_123456789_123456789_123456789_123456789" 394 "_123456789_123456789_123456789_123456789_123456789", 395 mxArg, SQLITE_UTF8, 0, tStep, 0, 0); 396 if( rc!=SQLITE_OK ) goto abuse_err; 397 398 return TCL_OK; 399 400 abuse_err: 401 Tcl_AppendResult(interp, "sqlite3_create_function abused test failed", 402 (char*)0); 403 return TCL_ERROR; 404 } 405 406 407 408 /* 409 ** Register commands with the TCL interpreter. 410 */ 411 int Sqlitetest_func_Init(Tcl_Interp *interp){ 412 static struct { 413 char *zName; 414 Tcl_ObjCmdProc *xProc; 415 } aObjCmd[] = { 416 { "autoinstall_test_functions", autoinstall_test_funcs }, 417 { "abuse_create_function", abuse_create_function }, 418 }; 419 int i; 420 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ 421 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0); 422 } 423 sqlite3_initialize(); 424 sqlite3_auto_extension((void*)registerTestFunctions); 425 return TCL_OK; 426 } 427