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 #include "sqlite3.h" 16 #include "tcl.h" 17 #include <stdlib.h> 18 #include <string.h> 19 #include <assert.h> 20 21 22 /* 23 ** Allocate nByte bytes of space using sqlite3_malloc(). If the 24 ** allocation fails, call sqlite3_result_error_nomem() to notify 25 ** the database handle that malloc() has failed. 26 */ 27 static void *testContextMalloc(sqlite3_context *context, int nByte){ 28 char *z = sqlite3_malloc(nByte); 29 if( !z && nByte>0 ){ 30 sqlite3_result_error_nomem(context); 31 } 32 return z; 33 } 34 35 /* 36 ** This function generates a string of random characters. Used for 37 ** generating test data. 38 */ 39 static void randStr(sqlite3_context *context, int argc, sqlite3_value **argv){ 40 static const unsigned char zSrc[] = 41 "abcdefghijklmnopqrstuvwxyz" 42 "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 43 "0123456789" 44 ".-!,:*^+=_|?/<> "; 45 int iMin, iMax, n, r, i; 46 unsigned char zBuf[1000]; 47 48 /* It used to be possible to call randstr() with any number of arguments, 49 ** but now it is registered with SQLite as requiring exactly 2. 50 */ 51 assert(argc==2); 52 53 iMin = sqlite3_value_int(argv[0]); 54 if( iMin<0 ) iMin = 0; 55 if( iMin>=sizeof(zBuf) ) iMin = sizeof(zBuf)-1; 56 iMax = sqlite3_value_int(argv[1]); 57 if( iMax<iMin ) iMax = iMin; 58 if( iMax>=sizeof(zBuf) ) iMax = sizeof(zBuf)-1; 59 n = iMin; 60 if( iMax>iMin ){ 61 sqlite3_randomness(sizeof(r), &r); 62 r &= 0x7fffffff; 63 n += r%(iMax + 1 - iMin); 64 } 65 assert( n<sizeof(zBuf) ); 66 sqlite3_randomness(n, zBuf); 67 for(i=0; i<n; i++){ 68 zBuf[i] = zSrc[zBuf[i]%(sizeof(zSrc)-1)]; 69 } 70 zBuf[n] = 0; 71 sqlite3_result_text(context, (char*)zBuf, n, SQLITE_TRANSIENT); 72 } 73 74 /* 75 ** The following two SQL functions are used to test returning a text 76 ** result with a destructor. Function 'test_destructor' takes one argument 77 ** and returns the same argument interpreted as TEXT. A destructor is 78 ** passed with the sqlite3_result_text() call. 79 ** 80 ** SQL function 'test_destructor_count' returns the number of outstanding 81 ** allocations made by 'test_destructor'; 82 ** 83 ** WARNING: Not threadsafe. 84 */ 85 static int test_destructor_count_var = 0; 86 static void destructor(void *p){ 87 char *zVal = (char *)p; 88 assert(zVal); 89 zVal--; 90 sqlite3_free(zVal); 91 test_destructor_count_var--; 92 } 93 static void test_destructor( 94 sqlite3_context *pCtx, 95 int nArg, 96 sqlite3_value **argv 97 ){ 98 char *zVal; 99 int len; 100 101 test_destructor_count_var++; 102 assert( nArg==1 ); 103 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 104 len = sqlite3_value_bytes(argv[0]); 105 zVal = testContextMalloc(pCtx, len+3); 106 if( !zVal ){ 107 return; 108 } 109 zVal[len+1] = 0; 110 zVal[len+2] = 0; 111 zVal++; 112 memcpy(zVal, sqlite3_value_text(argv[0]), len); 113 sqlite3_result_text(pCtx, zVal, -1, destructor); 114 } 115 #ifndef SQLITE_OMIT_UTF16 116 static void test_destructor16( 117 sqlite3_context *pCtx, 118 int nArg, 119 sqlite3_value **argv 120 ){ 121 char *zVal; 122 int len; 123 124 test_destructor_count_var++; 125 assert( nArg==1 ); 126 if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; 127 len = sqlite3_value_bytes16(argv[0]); 128 zVal = testContextMalloc(pCtx, len+3); 129 if( !zVal ){ 130 return; 131 } 132 zVal[len+1] = 0; 133 zVal[len+2] = 0; 134 zVal++; 135 memcpy(zVal, sqlite3_value_text16(argv[0]), len); 136 sqlite3_result_text16(pCtx, zVal, -1, destructor); 137 } 138 #endif 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 ** The following aggregate function, test_agg_errmsg16(), takes zero 149 ** arguments. It returns the text value returned by the sqlite3_errmsg16() 150 ** API function. 151 */ 152 #ifndef SQLITE_OMIT_BUILTIN_TEST 153 void sqlite3BeginBenignMalloc(void); 154 void sqlite3EndBenignMalloc(void); 155 #else 156 #define sqlite3BeginBenignMalloc() 157 #define sqlite3EndBenignMalloc() 158 #endif 159 static void test_agg_errmsg16_step(sqlite3_context *a, int b,sqlite3_value **c){ 160 } 161 static void test_agg_errmsg16_final(sqlite3_context *ctx){ 162 #ifndef SQLITE_OMIT_UTF16 163 const void *z; 164 sqlite3 * db = sqlite3_context_db_handle(ctx); 165 sqlite3_aggregate_context(ctx, 2048); 166 sqlite3BeginBenignMalloc(); 167 z = sqlite3_errmsg16(db); 168 sqlite3EndBenignMalloc(); 169 sqlite3_result_text16(ctx, z, -1, SQLITE_TRANSIENT); 170 #endif 171 } 172 173 /* 174 ** Routines for testing the sqlite3_get_auxdata() and sqlite3_set_auxdata() 175 ** interface. 176 ** 177 ** The test_auxdata() SQL function attempts to register each of its arguments 178 ** as auxiliary data. If there are no prior registrations of aux data for 179 ** that argument (meaning the argument is not a constant or this is its first 180 ** call) then the result for that argument is 0. If there is a prior 181 ** registration, the result for that argument is 1. The overall result 182 ** is the individual argument results separated by spaces. 183 */ 184 static void free_test_auxdata(void *p) {sqlite3_free(p);} 185 static void test_auxdata( 186 sqlite3_context *pCtx, 187 int nArg, 188 sqlite3_value **argv 189 ){ 190 int i; 191 char *zRet = testContextMalloc(pCtx, nArg*2); 192 if( !zRet ) return; 193 memset(zRet, 0, nArg*2); 194 for(i=0; i<nArg; i++){ 195 char const *z = (char*)sqlite3_value_text(argv[i]); 196 if( z ){ 197 int n; 198 char *zAux = sqlite3_get_auxdata(pCtx, i); 199 if( zAux ){ 200 zRet[i*2] = '1'; 201 assert( strcmp(zAux,z)==0 ); 202 }else { 203 zRet[i*2] = '0'; 204 } 205 n = strlen(z) + 1; 206 zAux = testContextMalloc(pCtx, n); 207 if( zAux ){ 208 memcpy(zAux, z, n); 209 sqlite3_set_auxdata(pCtx, i, zAux, free_test_auxdata); 210 } 211 zRet[i*2+1] = ' '; 212 } 213 } 214 sqlite3_result_text(pCtx, zRet, 2*nArg-1, free_test_auxdata); 215 } 216 217 /* 218 ** A function to test error reporting from user functions. This function 219 ** returns a copy of its first argument as the error message. If the 220 ** second argument exists, it becomes the error code. 221 */ 222 static void test_error( 223 sqlite3_context *pCtx, 224 int nArg, 225 sqlite3_value **argv 226 ){ 227 sqlite3_result_error(pCtx, (char*)sqlite3_value_text(argv[0]), -1); 228 if( nArg==2 ){ 229 sqlite3_result_error_code(pCtx, sqlite3_value_int(argv[1])); 230 } 231 } 232 233 /* 234 ** Implementation of the counter(X) function. If X is an integer 235 ** constant, then the first invocation will return X. The second X+1. 236 ** and so forth. Can be used (for example) to provide a sequence number 237 ** in a result set. 238 */ 239 static void counterFunc( 240 sqlite3_context *pCtx, /* Function context */ 241 int nArg, /* Number of function arguments */ 242 sqlite3_value **argv /* Values for all function arguments */ 243 ){ 244 int *pCounter = (int*)sqlite3_get_auxdata(pCtx, 0); 245 if( pCounter==0 ){ 246 pCounter = sqlite3_malloc( sizeof(*pCounter) ); 247 if( pCounter==0 ){ 248 sqlite3_result_error_nomem(pCtx); 249 return; 250 } 251 *pCounter = sqlite3_value_int(argv[0]); 252 sqlite3_set_auxdata(pCtx, 0, pCounter, sqlite3_free); 253 }else{ 254 ++*pCounter; 255 } 256 sqlite3_result_int(pCtx, *pCounter); 257 } 258 259 260 /* 261 ** This function takes two arguments. It performance UTF-8/16 type 262 ** conversions on the first argument then returns a copy of the second 263 ** argument. 264 ** 265 ** This function is used in cases such as the following: 266 ** 267 ** SELECT test_isolation(x,x) FROM t1; 268 ** 269 ** We want to verify that the type conversions that occur on the 270 ** first argument do not invalidate the second argument. 271 */ 272 static void test_isolation( 273 sqlite3_context *pCtx, 274 int nArg, 275 sqlite3_value **argv 276 ){ 277 #ifndef SQLITE_OMIT_UTF16 278 sqlite3_value_text16(argv[0]); 279 sqlite3_value_text(argv[0]); 280 sqlite3_value_text16(argv[0]); 281 sqlite3_value_text(argv[0]); 282 #endif 283 sqlite3_result_value(pCtx, argv[1]); 284 } 285 286 /* 287 ** Invoke an SQL statement recursively. The function result is the 288 ** first column of the first row of the result set. 289 */ 290 static void test_eval( 291 sqlite3_context *pCtx, 292 int nArg, 293 sqlite3_value **argv 294 ){ 295 sqlite3_stmt *pStmt; 296 int rc; 297 sqlite3 *db = sqlite3_context_db_handle(pCtx); 298 const char *zSql; 299 300 zSql = (char*)sqlite3_value_text(argv[0]); 301 rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, 0); 302 if( rc==SQLITE_OK ){ 303 rc = sqlite3_step(pStmt); 304 if( rc==SQLITE_ROW ){ 305 sqlite3_result_value(pCtx, sqlite3_column_value(pStmt, 0)); 306 } 307 rc = sqlite3_finalize(pStmt); 308 } 309 if( rc ){ 310 char *zErr; 311 assert( pStmt==0 ); 312 zErr = sqlite3_mprintf("sqlite3_prepare_v2() error: %s",sqlite3_errmsg(db)); 313 sqlite3_result_text(pCtx, zErr, -1, sqlite3_free); 314 sqlite3_result_error_code(pCtx, rc); 315 } 316 } 317 318 319 /* 320 ** convert one character from hex to binary 321 */ 322 static int testHexChar(char c){ 323 if( c>='0' && c<='9' ){ 324 return c - '0'; 325 }else if( c>='a' && c<='f' ){ 326 return c - 'a' + 10; 327 }else if( c>='A' && c<='F' ){ 328 return c - 'A' + 10; 329 } 330 return 0; 331 } 332 333 /* 334 ** Convert hex to binary. 335 */ 336 static void testHexToBin(const char *zIn, char *zOut){ 337 while( zIn[0] && zIn[1] ){ 338 *(zOut++) = (testHexChar(zIn[0])<<4) + testHexChar(zIn[1]); 339 zIn += 2; 340 } 341 } 342 343 /* 344 ** hex_to_utf16be(HEX) 345 ** 346 ** Convert the input string from HEX into binary. Then return the 347 ** result using sqlite3_result_text16le(). 348 */ 349 #ifndef SQLITE_OMIT_UTF16 350 static void testHexToUtf16be( 351 sqlite3_context *pCtx, 352 int nArg, 353 sqlite3_value **argv 354 ){ 355 int n; 356 const char *zIn; 357 char *zOut; 358 assert( nArg==1 ); 359 n = sqlite3_value_bytes(argv[0]); 360 zIn = (const char*)sqlite3_value_text(argv[0]); 361 zOut = sqlite3_malloc( n/2 ); 362 if( zOut==0 ){ 363 sqlite3_result_error_nomem(pCtx); 364 }else{ 365 testHexToBin(zIn, zOut); 366 sqlite3_result_text16be(pCtx, zOut, n/2, sqlite3_free); 367 } 368 } 369 #endif 370 371 /* 372 ** hex_to_utf8(HEX) 373 ** 374 ** Convert the input string from HEX into binary. Then return the 375 ** result using sqlite3_result_text16le(). 376 */ 377 static void testHexToUtf8( 378 sqlite3_context *pCtx, 379 int nArg, 380 sqlite3_value **argv 381 ){ 382 int n; 383 const char *zIn; 384 char *zOut; 385 assert( nArg==1 ); 386 n = sqlite3_value_bytes(argv[0]); 387 zIn = (const char*)sqlite3_value_text(argv[0]); 388 zOut = sqlite3_malloc( n/2 ); 389 if( zOut==0 ){ 390 sqlite3_result_error_nomem(pCtx); 391 }else{ 392 testHexToBin(zIn, zOut); 393 sqlite3_result_text(pCtx, zOut, n/2, sqlite3_free); 394 } 395 } 396 397 /* 398 ** hex_to_utf16le(HEX) 399 ** 400 ** Convert the input string from HEX into binary. Then return the 401 ** result using sqlite3_result_text16le(). 402 */ 403 #ifndef SQLITE_OMIT_UTF16 404 static void testHexToUtf16le( 405 sqlite3_context *pCtx, 406 int nArg, 407 sqlite3_value **argv 408 ){ 409 int n; 410 const char *zIn; 411 char *zOut; 412 assert( nArg==1 ); 413 n = sqlite3_value_bytes(argv[0]); 414 zIn = (const char*)sqlite3_value_text(argv[0]); 415 zOut = sqlite3_malloc( n/2 ); 416 if( zOut==0 ){ 417 sqlite3_result_error_nomem(pCtx); 418 }else{ 419 testHexToBin(zIn, zOut); 420 sqlite3_result_text16le(pCtx, zOut, n/2, sqlite3_free); 421 } 422 } 423 #endif 424 425 static int registerTestFunctions(sqlite3 *db){ 426 static const struct { 427 char *zName; 428 signed char nArg; 429 unsigned char eTextRep; /* 1: UTF-16. 0: UTF-8 */ 430 void (*xFunc)(sqlite3_context*,int,sqlite3_value **); 431 } aFuncs[] = { 432 { "randstr", 2, SQLITE_UTF8, randStr }, 433 { "test_destructor", 1, SQLITE_UTF8, test_destructor}, 434 #ifndef SQLITE_OMIT_UTF16 435 { "test_destructor16", 1, SQLITE_UTF8, test_destructor16}, 436 { "hex_to_utf16be", 1, SQLITE_UTF8, testHexToUtf16be}, 437 { "hex_to_utf16le", 1, SQLITE_UTF8, testHexToUtf16le}, 438 #endif 439 { "hex_to_utf8", 1, SQLITE_UTF8, testHexToUtf8}, 440 { "test_destructor_count", 0, SQLITE_UTF8, test_destructor_count}, 441 { "test_auxdata", -1, SQLITE_UTF8, test_auxdata}, 442 { "test_error", 1, SQLITE_UTF8, test_error}, 443 { "test_error", 2, SQLITE_UTF8, test_error}, 444 { "test_eval", 1, SQLITE_UTF8, test_eval}, 445 { "test_isolation", 2, SQLITE_UTF8, test_isolation}, 446 { "test_counter", 1, SQLITE_UTF8, counterFunc}, 447 }; 448 int i; 449 450 for(i=0; i<sizeof(aFuncs)/sizeof(aFuncs[0]); i++){ 451 sqlite3_create_function(db, aFuncs[i].zName, aFuncs[i].nArg, 452 aFuncs[i].eTextRep, 0, aFuncs[i].xFunc, 0, 0); 453 } 454 455 sqlite3_create_function(db, "test_agg_errmsg16", 0, SQLITE_ANY, 0, 0, 456 test_agg_errmsg16_step, test_agg_errmsg16_final); 457 458 return SQLITE_OK; 459 } 460 461 /* 462 ** TCLCMD: autoinstall_test_functions 463 ** 464 ** Invoke this TCL command to use sqlite3_auto_extension() to cause 465 ** the standard set of test functions to be loaded into each new 466 ** database connection. 467 */ 468 static int autoinstall_test_funcs( 469 void * clientData, 470 Tcl_Interp *interp, 471 int objc, 472 Tcl_Obj *CONST objv[] 473 ){ 474 extern int Md5_Register(sqlite3*); 475 int rc = sqlite3_auto_extension((void*)registerTestFunctions); 476 if( rc==SQLITE_OK ){ 477 rc = sqlite3_auto_extension((void*)Md5_Register); 478 } 479 Tcl_SetObjResult(interp, Tcl_NewIntObj(rc)); 480 return TCL_OK; 481 } 482 483 /* 484 ** A bogus step function and finalizer function. 485 */ 486 static void tStep(sqlite3_context *a, int b, sqlite3_value **c){} 487 static void tFinal(sqlite3_context *a){} 488 489 490 /* 491 ** tclcmd: abuse_create_function 492 ** 493 ** Make various calls to sqlite3_create_function that do not have valid 494 ** parameters. Verify that the error condition is detected and reported. 495 */ 496 static int abuse_create_function( 497 void * clientData, 498 Tcl_Interp *interp, 499 int objc, 500 Tcl_Obj *CONST objv[] 501 ){ 502 extern int getDbPointer(Tcl_Interp*, const char*, sqlite3**); 503 sqlite3 *db; 504 int rc; 505 int mxArg; 506 507 if( getDbPointer(interp, Tcl_GetString(objv[1]), &db) ) return TCL_ERROR; 508 509 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep,tStep,tFinal); 510 if( rc!=SQLITE_MISUSE ) goto abuse_err; 511 512 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, tStep, 0); 513 if( rc!=SQLITE_MISUSE ) goto abuse_err; 514 515 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, tStep, 0, tFinal); 516 if( rc!=SQLITE_MISUSE) goto abuse_err; 517 518 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, 0, tFinal); 519 if( rc!=SQLITE_MISUSE ) goto abuse_err; 520 521 rc = sqlite3_create_function(db, "tx", 1, SQLITE_UTF8, 0, 0, tStep, 0); 522 if( rc!=SQLITE_MISUSE ) goto abuse_err; 523 524 rc = sqlite3_create_function(db, "tx", -2, SQLITE_UTF8, 0, tStep, 0, 0); 525 if( rc!=SQLITE_MISUSE ) goto abuse_err; 526 527 rc = sqlite3_create_function(db, "tx", 128, SQLITE_UTF8, 0, tStep, 0, 0); 528 if( rc!=SQLITE_MISUSE ) goto abuse_err; 529 530 rc = sqlite3_create_function(db, "funcxx" 531 "_123456789_123456789_123456789_123456789_123456789" 532 "_123456789_123456789_123456789_123456789_123456789" 533 "_123456789_123456789_123456789_123456789_123456789" 534 "_123456789_123456789_123456789_123456789_123456789" 535 "_123456789_123456789_123456789_123456789_123456789", 536 1, SQLITE_UTF8, 0, tStep, 0, 0); 537 if( rc!=SQLITE_MISUSE ) goto abuse_err; 538 539 /* This last function registration should actually work. Generate 540 ** a no-op function (that always returns NULL) and which has the 541 ** maximum-length function name and the maximum number of parameters. 542 */ 543 sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, 10000); 544 mxArg = sqlite3_limit(db, SQLITE_LIMIT_FUNCTION_ARG, -1); 545 rc = sqlite3_create_function(db, "nullx" 546 "_123456789_123456789_123456789_123456789_123456789" 547 "_123456789_123456789_123456789_123456789_123456789" 548 "_123456789_123456789_123456789_123456789_123456789" 549 "_123456789_123456789_123456789_123456789_123456789" 550 "_123456789_123456789_123456789_123456789_123456789", 551 mxArg, SQLITE_UTF8, 0, tStep, 0, 0); 552 if( rc!=SQLITE_OK ) goto abuse_err; 553 554 return TCL_OK; 555 556 abuse_err: 557 Tcl_AppendResult(interp, "sqlite3_create_function abused test failed", 558 (char*)0); 559 return TCL_ERROR; 560 } 561 562 /* 563 ** Register commands with the TCL interpreter. 564 */ 565 int Sqlitetest_func_Init(Tcl_Interp *interp){ 566 static struct { 567 char *zName; 568 Tcl_ObjCmdProc *xProc; 569 } aObjCmd[] = { 570 { "autoinstall_test_functions", autoinstall_test_funcs }, 571 { "abuse_create_function", abuse_create_function }, 572 }; 573 int i; 574 extern int Md5_Register(sqlite3*); 575 576 for(i=0; i<sizeof(aObjCmd)/sizeof(aObjCmd[0]); i++){ 577 Tcl_CreateObjCommand(interp, aObjCmd[i].zName, aObjCmd[i].xProc, 0, 0); 578 } 579 sqlite3_initialize(); 580 sqlite3_auto_extension((void*)registerTestFunctions); 581 sqlite3_auto_extension((void*)Md5_Register); 582 return TCL_OK; 583 } 584
