The Tor Browser: security/nss/lib/dbm/tests/lots.c@b8a032363ba2 (annotated)

security/nss/lib/dbm/tests/lots.c@b8a032363ba2 (annotated)

security/nss/lib/dbm/tests/lots.c

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /* use sequental numbers printed to strings
  * to store lots and lots of entries in the
  * database.
  *
  * Start with 100 entries, put them and then
  * read them out.  Then delete the first
  * half and verify that all of the first half
  * is gone and then verify that the second
  * half is still there.
  * Then add the first half back and verify
  * again.  Then delete the middle third
  * and verify again.
  * Then increase the size by 1000 and do
  * the whole add delete thing again.
  *
  * The data for each object is the number string translated
  * to hex and replicated a random number of times.  The
  * number of times that the data is replicated is the first
  * int32 in the data.
  */
 #include <stdio.h>
 #include <stdlib.h>
 #ifdef STDC_HEADERS
 #include <stdarg.h>
 #else
 #include <varargs.h>
 #endif
 #ifdef HAVE_MEMORY_H
 #include <memory.h>
 #endif
 #include <string.h>
 #include <assert.h>
 #include "mcom_db.h"
 DB *database=0;
 int MsgPriority=5;
 #if defined(_WINDOWS) && !defined(WIN32)
 #define int32 long
 #define uint32 unsigned long
 #else
 #define int32 int
 #define uint32 unsigned int
 #endif
 typedef enum {
 USE_LARGE_KEY,
 USE_SMALL_KEY
 } key_type_enum;
 #define TraceMe(priority, msg) 		\
 	do {							\
 		if(priority <= MsgPriority)	\
 		  {							\
 			ReportStatus msg;		\
 		  }							\
 	} while(0)
 int
 ReportStatus(char *string, ...)
 {
     va_list args;
 #ifdef STDC_HEADERS
     va_start(args, string);
 #else
     va_start(args);
 #endif
     vfprintf(stderr, string, args);
     va_end(args);
 	fprintf (stderr, "\n");
 	return(0);
 }
 int
 ReportError(char *string, ...)
 {
     va_list args;
 #ifdef STDC_HEADERS
     va_start(args, string);
 #else
     va_start(args);
 #endif
 	fprintf (stderr, "\n	");
     vfprintf(stderr, string, args);
 	fprintf (stderr, "\n");
     va_end(args);
 	return(0);
 }
 DBT * MakeLargeKey(int32 num)
 {
 	int32 low_bits;
 	static DBT rv;
 	static char *string_rv=0;
 	int rep_char;
 	size_t size;
 	if(string_rv)
 		free(string_rv);
 	/* generate a really large text key derived from
 	 * an int32
 	 */
 	low_bits = (num % 10000) + 1;
 	/* get the repeat char from the low 26 */
 	rep_char = (char) ((low_bits % 26) + 'a');
 	/* malloc a string low_bits wide */
 	size = low_bits*sizeof(char);
 	string_rv = (char *)malloc(size);
 	memset(string_rv, rep_char, size);
 	rv.data = string_rv;
 	rv.size = size;
 	return(&rv);
 }
 DBT * MakeSmallKey(int32 num)
 {
 	static DBT rv;
 	static char data_string[64];
 	rv.data = data_string;
 	sprintf(data_string, "%ld", (long)num);
 	rv.size = strlen(data_string);
 	return(&rv);
 }
 DBT * GenKey(int32 num, key_type_enum key_type)
 {
 	DBT *key;
 	switch(key_type)
 	  {
 		case USE_LARGE_KEY:
 			key = MakeLargeKey(num);
 			break;
 		case USE_SMALL_KEY:
 			key = MakeSmallKey(num);
 			break;
 		default:
 			abort();
 			break;
 	  }
 	return(key);
 }
 int
 SeqDatabase()
 {
 	int status;
 	DBT key, data;
 	ReportStatus("SEQuencing through database...");
 	/* seq through the whole database */
     if(!(status = (*database->seq)(database, &key, &data, R_FIRST)))
 	  {
         while(!(status = (database->seq) (database, &key, &data, R_NEXT)))
 			; /* null body */
 	  }
 	if(status < 0)
 		ReportError("Error seq'ing database");
 	return(status);
 }
 int
 VerifyData(DBT *data, int32 num, key_type_enum key_type)
 {
 	int32 count, compare_num;
 	size_t size;
 	int32 *int32_array;
 	/* The first int32 is count
 	 * The other n entries should
 	 * all equal num
 	 */
 	if(data->size < sizeof(int32))
 	  {
 		ReportError("Data size corrupted");
 		return -1;
 	  }
 	memcpy(&count, data->data, sizeof(int32));
 	size = sizeof(int32)*(count+1);
 	if(size != data->size)
 	  {
 		ReportError("Data size corrupted");
 		return -1;
 	  }
 	int32_array = (int32*)data->data;
 	for(;count > 0; count--)
 	  {
 		memcpy(&compare_num, &int32_array[count], sizeof(int32));
 		if(compare_num != num)
 	      {
 		    ReportError("Data corrupted");
 		    return -1;
 	      }
 	  }
 	return(0);
 }
 /* verify that a range of number strings exist
  * or don't exist. And that the data is valid
  */
 #define SHOULD_EXIST 1
 #define SHOULD_NOT_EXIST 0
 int
 VerifyRange(int32 low, int32 high, int32 should_exist, key_type_enum key_type)
 {
 	DBT *key, data;
 	int32 num;
 	int status;
 	TraceMe(1, ("Verifying: %ld to %ld, using %s keys",
 		    low, high, key_type == USE_SMALL_KEY ? "SMALL" : "LARGE"));
 	for(num = low; num <= high; num++)
 	  {
 		key = GenKey(num, key_type);
 		status = (*database->get)(database, key, &data, 0);
 		if(status == 0)
 		  {
 			/* got the item */
 			if(!should_exist)
 			  {
 				ReportError("Item exists but shouldn't: %ld", num);
 			  }
 			else
 			  {
 			    /* else verify the data */
 			    VerifyData(&data, num, key_type);
 			  }
 		  }
 		else if(status > 0)
 		  {
 			/* item not found */
 			if(should_exist)
 			  {
 				ReportError("Item not found but should be: %ld", num);
 			  }
 		  }
 		else
 		  {
 			/* database error */
 			ReportError("Database error");
 			return(-1);
 		  }
 	  }
 	TraceMe(1, ("Correctly verified: %ld to %ld", low, high));
 	return(0);
 }
 DBT *
 GenData(int32 num)
 {
 	int32 n;
 	static DBT *data=0;
 	int32 *int32_array;
 	size_t size;
 	if(!data)
 	  {
 		data = (DBT*)malloc(sizeof(DBT));
 		data->size = 0;
 		data->data = 0;
 	  }
 	else if(data->data)
 	  {
 		free(data->data);
 	  }
 	n = rand();
 	n = n % 512;  /* bound to a 2K size */
 	size = sizeof(int32)*(n+1);
 	int32_array = (int32 *) malloc(size);
 	memcpy(&int32_array[0], &n, sizeof(int32));
 	for(; n > 0; n--)
 	  {
 		memcpy(&int32_array[n], &num, sizeof(int32));
 	  }
 	data->data = (void*)int32_array;
 	data->size = size;
 	return(data);
 }
 #define ADD_RANGE 1
 #define DELETE_RANGE 2
 int
 AddOrDelRange(int32 low, int32 high, int action, key_type_enum key_type)
 {
 	DBT *key, *data;
 #if 0 /* only do this if your really analy checking the puts */
 	DBT tmp_data;
 #endif
 	int32 num;
 	int status;
 	if(action != ADD_RANGE && action != DELETE_RANGE)
 		assert(0);
 	if(action == ADD_RANGE)
 	  {
 		TraceMe(1, ("Adding: %ld to %ld: %s keys", low, high,
 		    	key_type == USE_SMALL_KEY ? "SMALL" : "LARGE"));
 	  }
 	else
 	  {
 		TraceMe(1, ("Deleting: %ld to %ld: %s keys", low, high,
 		    	key_type == USE_SMALL_KEY ? "SMALL" : "LARGE"));
 	  }
 	for(num = low; num <= high; num++)
 	  {
 		key = GenKey(num, key_type);
 		if(action == ADD_RANGE)
 		  {
 			data = GenData(num);
 			status = (*database->put)(database, key, data, 0);
 		  }
 		else
 		  {
 			status = (*database->del)(database, key, 0);
 		  }
 		if(status < 0)
 		  {
 			ReportError("Database error %s item: %ld",
 							action == ADD_RANGE ? "ADDING" : "DELETING",
 							num);
 		  }
 		else if(status > 0)
 		  {
 			ReportError("Could not %s item: %ld",
 							action == ADD_RANGE ? "ADD" : "DELETE",
 							num);
 		  }
 		else if(action == ADD_RANGE)
 		  {
 #define SYNC_EVERY_TIME
 #ifdef SYNC_EVERY_TIME
 			status = (*database->sync)(database, 0);
 			if(status != 0)
 				ReportError("Database error syncing after add");
 #endif
 #if 0 /* only do this if your really analy checking the puts */
 			/* make sure we can still get it
 			 */
 			status = (*database->get)(database, key, &tmp_data, 0);
 			if(status != 0)
 			  {
 				ReportError("Database error checking item just added: %d",
 							num);
 			  }
 			else
 			  {
 				/* now verify that none of the ones we already
 				 * put in have disappeared
 				 */
 				VerifyRange(low, num, SHOULD_EXIST, key_type);
 			  }
 #endif
 		  }
 	  }
 	if(action == ADD_RANGE)
 	  {
 		TraceMe(1, ("Successfully added: %ld to %ld", low, high));
 	  }
 	else
 	  {
 		TraceMe(1, ("Successfully deleted: %ld to %ld", low, high));
 	  }
 	return(0);
 }
 int
 TestRange(int32 low, int32 range, key_type_enum key_type)
 {
 	int status; int32 low_of_range1, high_of_range1; int32 low_of_range2, high_of_range2;
 	int32 low_of_range3, high_of_range3;
 	status = AddOrDelRange(low, low+range, ADD_RANGE, key_type);
 	status = VerifyRange(low, low+range, SHOULD_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 1"));
 	SeqDatabase();
 	low_of_range1 = low;
 	high_of_range1 = low+(range/2);
 	low_of_range2 = high_of_range1+1;
 	high_of_range2 = low+range;
 	status = AddOrDelRange(low_of_range1, high_of_range1, DELETE_RANGE, key_type);
 	status = VerifyRange(low_of_range1, high_of_range1, SHOULD_NOT_EXIST, key_type);
 	status = VerifyRange(low_of_range2, low_of_range2, SHOULD_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 2"));
 	SeqDatabase();
 	status = AddOrDelRange(low_of_range1, high_of_range1, ADD_RANGE, key_type);
 	/* the whole thing should exist now */
 	status = VerifyRange(low, low+range, SHOULD_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 3"));
 	SeqDatabase();
 	status = AddOrDelRange(low_of_range2, high_of_range2, DELETE_RANGE, key_type);
 	status = VerifyRange(low_of_range1, high_of_range1, SHOULD_EXIST, key_type);
 	status = VerifyRange(low_of_range2, high_of_range2, SHOULD_NOT_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 4"));
 	SeqDatabase();
 	status = AddOrDelRange(low_of_range2, high_of_range2, ADD_RANGE, key_type);
 	/* the whole thing should exist now */
 	status = VerifyRange(low, low+range, SHOULD_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 5"));
 	SeqDatabase();
 	low_of_range1 = low;
 	high_of_range1 = low+(range/3);
 	low_of_range2 = high_of_range1+1;
 	high_of_range2 = high_of_range1+(range/3);
 	low_of_range3 = high_of_range2+1;
 	high_of_range3 = low+range;
 	/* delete range 2 */
 	status = AddOrDelRange(low_of_range2, high_of_range2, DELETE_RANGE, key_type);
 	status = VerifyRange(low_of_range1, high_of_range1, SHOULD_EXIST, key_type);
 	status = VerifyRange(low_of_range2, low_of_range2, SHOULD_NOT_EXIST, key_type);
 	status = VerifyRange(low_of_range3, low_of_range2, SHOULD_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 6"));
 	SeqDatabase();
 	status = AddOrDelRange(low_of_range2, high_of_range2, ADD_RANGE, key_type);
 	/* the whole thing should exist now */
 	status = VerifyRange(low, low+range, SHOULD_EXIST, key_type);
 	TraceMe(1, ("Finished with sub test 7"));
 	return(0);
 }
 #define START_RANGE 109876
 int
 main(int argc, char **argv)
 {
 	int32 i, j=0;
     int quick_exit = 0;
     int large_keys = 0;
     HASHINFO hash_info = {
 *1024,
 ,
 ,
 ,
 ,
 };
     if(argc > 1)
       {
         while(argc > 1)
 	  {
             if(!strcmp(argv[argc-1], "-quick"))
                 quick_exit = 1;
             else if(!strcmp(argv[argc-1], "-large"))
 			  {
                 large_keys = 1;
 			  }
             argc--;
           }
       }
 	database = dbopen("test.db", O_RDWR | O_CREAT, 0644, DB_HASH, &hash_info);
 	if(!database)
 	  {
 		ReportError("Could not open database");
 #ifdef unix
 		perror("");
 #endif
 		exit(1);
 	  }
 	if(quick_exit)
 	  {
 		if(large_keys)
 			TestRange(START_RANGE, 200, USE_LARGE_KEY);
 		else
 			TestRange(START_RANGE, 200, USE_SMALL_KEY);
 		(*database->sync)(database, 0);
 		(*database->close)(database);
         exit(0);
 	  }
 	for(i=100; i < 10000000; i+=200)
 	  {
 		if(1 || j)
 		  {
 			TestRange(START_RANGE, i, USE_LARGE_KEY);
 			j = 0;
 		  }
 		else
 		  {
 			TestRange(START_RANGE, i, USE_SMALL_KEY);
 			j = 1;
 		  }
 		if(1 == rand() % 3)
 		  {
 			(*database->sync)(database, 0);
 		  }
 		if(1 == rand() % 3)
 	 	  {
 			/* close and reopen */
 			(*database->close)(database);
 			database = dbopen("test.db", O_RDWR | O_CREAT, 0644, DB_HASH, 0);
 			if(!database)
 	  		{
 				ReportError("Could not reopen database");
 #ifdef unix
 				perror("");
 #endif
 				exit(1);
 	  		}
 	 	  }
 		else
 		  {
 			/* reopen database without closeing the other */
 			database = dbopen("test.db", O_RDWR | O_CREAT, 0644, DB_HASH, 0);
 			if(!database)
 	  		{
 				ReportError("Could not reopen database "
 							"after not closing the other");
 #ifdef unix
 				perror("");
 #endif
 				exit(1);
 	  		}
 	 	  }
 	  }
 	return(0);
 }

The Tor Browser / annotate

security/nss/lib/dbm/tests/lots.c@b8a032363ba2 (annotated)

security/nss/lib/dbm/tests/lots.c