The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 /* 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/. */

 /***********************************************************************

 **

 ** Name: dbmalloc.c

 **

 ** Description: Testing malloc (OBSOLETE)

 **

 ** Modification History:

 ** 14-May-97 AGarcia- Converted the test to accomodate the debug_mode flag.

 **	         The debug mode will print all of the printfs associated with this test.

 **			 The regress mode will be the default mode. Since the regress tool limits

 **           the output to a one line status:PASS or FAIL,all of the printf statements

 **			 have been handled with an if (debug_mode) statement. 

 ***********************************************************************/

 #include <stdio.h>

 #include <stdlib.h>

 #include <time.h>

 #include <string.h>

 #include "nspr.h"

 void

 usage

 (

     void

 )

 {

     fprintf(stderr, "Usage: dbmalloc ('-m'|'-s') '-f' num_fails ('-d'|'-n') filename [...]\n");

     exit(0);

 }

 typedef struct node_struct

 {

     struct node_struct *next, *prev;

     int line;

     char value[4];

 }

     node_t,

    *node_pt;

 node_pt get_node(const char *line)

 {

     node_pt rv;

     int l = strlen(line);

     rv = (node_pt)PR_MALLOC(sizeof(node_t) + l + 1 - 4);

     if( (node_pt)0 == rv ) return (node_pt)0;

     memcpy(&rv->value[0], line, l+1);

     rv->next = rv->prev = (node_pt)0;

     return rv;

 }

 void

 dump

 (

     const char *name,

     node_pt     node,

     int         mf,

     int         debug

 )

 {

     if( (node_pt)0 != node->prev ) dump(name, node->prev, mf, debug);

     if( 0 != debug ) printf("[%s]: %6d: %s", name, node->line, node->value);

     if( node->line == mf ) fprintf(stderr, "[%s]: Line %d was allocated!\n", name, node->line);

     if( (node_pt)0 != node->next ) dump(name, node->next, mf, debug);

     return;

 }

 void

 release

 (

     node_pt node

 )

 {

     if( (node_pt)0 != node->prev ) release(node->prev);

     if( (node_pt)0 != node->next ) release(node->next);

     PR_DELETE(node);

 }

 int

 t2

 (

     const char *name,

     int         mf,

     int         debug

 )

 {

     int rv;

     FILE *fp;

     int l = 0;

     node_pt head = (node_pt)0;

     char buffer[ BUFSIZ ];

     fp = fopen(name, "r");

     if( (FILE *)0 == fp )

     {

         fprintf(stderr, "[%s]: Cannot open \"%s.\"\n", name, name);

         return -1;

     }

     /* fgets mallocs a buffer, first time through. */

     if( (char *)0 == fgets(buffer, BUFSIZ, fp) )

     {

         fprintf(stderr, "[%s]: \"%s\" is empty.\n", name, name);

         (void)fclose(fp);

         return -1;

     }

     rewind(fp);

     if( PR_SUCCESS != PR_ClearMallocCount() )

     {

         fprintf(stderr, "[%s]: Cannot clear malloc count.\n", name);

         (void)fclose(fp);

         return -1;

     }

     if( PR_SUCCESS != PR_SetMallocCountdown(mf) )

     {

         fprintf(stderr, "[%s]: Cannot set malloc countdown to %d\n", name, mf);

         (void)fclose(fp);

         return -1;

     }

     while( fgets(buffer, BUFSIZ, fp) )

     {

         node_pt n;

         node_pt *w = &head;

         if( (strlen(buffer) == (BUFSIZ-1)) && (buffer[BUFSIZ-2] != '\n') )

             buffer[BUFSIZ-2] == '\n';

         l++;

         n = get_node(buffer);

         if( (node_pt)0 == n ) 

         {

             printf("[%s]: Line %d: malloc failure!\n", name, l);

             continue;

         }

         n->line = l;

         while( 1 )

         {

             int comp;

             if( (node_pt)0 == *w )

             {

                 *w = n;

                 break;

             }

             comp = strcmp((*w)->value, n->value);

             if( comp < 0 ) w = &(*w)->next;

             else w = &(*w)->prev;

         }

     }

     (void)fclose(fp);

     dump(name, head, mf, debug);

     rv = PR_GetMallocCount();

     PR_ClearMallocCountdown();

     release(head);

     return rv;

 }

 int nf = 0;

 int debug = 0;

 void

 test

 (

     const char *name

 )

 {

     int n, i;

     extern int nf, debug;

     printf("[%s]: starting test 0\n", name);

     n = t2(name, 0, debug);

     if( -1 == n ) return;

     printf("[%s]: test 0 had %ld allocations.\n", name, n);

     if( 0 >= n ) return;

     for( i = 0; i < nf; i++ )

     {

         int which = rand() % n;

         if( 0 == which ) printf("[%s]: starting test %d -- no allocation should fail\n", name, i+1);

         else printf("[%s]: starting test %d -- allocation %d should fail\n", name, i+1, which);

         (void)t2(name, which, debug);

         printf("[%s]: test %d done.\n", name, i+1);

     }

     return;

 }

 int main(int argc, char **argv)

 {

     int okay = 0;

     int multithread = 0;

     struct threadlist

     {

         struct threadlist *next;

         PRThread *thread;

     }

         *threadhead = (struct threadlist *)0;

     extern int nf, debug;

     srand(time(0));

     PR_Init(PR_USER_THREAD, PR_PRIORITY_NORMAL, 0);

     PR_STDIO_INIT();

     printf("[main]: We %s using the debugging malloc.\n",

            PR_IsDebuggingMalloc() ? "ARE" : "ARE NOT");

     while( argv++, --argc )

     {

         if( '-' == argv[0][0] )

         {

             switch( argv[0][1] )

             {

                 case 'f':

                     nf = atoi(argv[0][2] ? &argv[0][2] :

                               --argc ? *++argv : "0");

                     break;

                 case 'd':

                     debug = 1;

                     break;

                 case 'n':

                     debug = 0;

                     break;

                 case 'm':

                     multithread = 1;

                     break;

                 case 's':

                     multithread = 0;

                     break;

                 default:

                     usage();

                     break;

             }

         }

         else

         {

             FILE *fp = fopen(*argv, "r");

             if( (FILE *)0 == fp )

             {

                 fprintf(stderr, "Cannot open \"%s.\"\n", *argv);

                 continue;

             }

             okay++;

             (void)fclose(fp);

             if( multithread )

             {

                 struct threadlist *n;

                 n = (struct threadlist *)malloc(sizeof(struct threadlist));

                 if( (struct threadlist *)0 == n ) 

                 {

                     fprintf(stderr, "This is getting tedious. \"%s\"\n", *argv);

                     continue;

                 }

                 n->next = threadhead;

                 n->thread = PR_CreateThread(PR_USER_THREAD, (void (*)(void *))test, 

                                             *argv, PR_PRIORITY_NORMAL, 

                                             PR_LOCAL_THREAD, PR_JOINABLE_THREAD,

                                             0);

                 if( (PRThread *)0 == n->thread )

                 {

                     fprintf(stderr, "Can't create thread for \"%s.\"\n", *argv);

                     continue;

                 }

                 else

                 {

                     threadhead = n;

                 }

             }

             else

             {

                 test(*argv);

             }

         }

     }

     if( okay == 0 ) usage();

     else while( (struct threadlist *)0 != threadhead )

     {

         struct threadlist *x = threadhead->next;

         (void)PR_JoinThread(threadhead->thread);

         PR_DELETE(threadhead);

         threadhead = x;

     }

     return 0;

 }