Author: nhosoi Update of /cvs/dirsec/ldapserver/ldap/servers/slapd/tools/rsearch In directory cvs-int.fedora.redhat.com:/tmp/cvs-serv12072/rsearch Added Files: Makefile addthread.c addthread.h infadd.c infadd.h main.c nametable.c nametable.h rsearch.c rsearch.h sdattable.c sdattable.h searchthread.c searchthread.h Log Message: [170348] RSEARCH needs to be updated Integrating rsearch and infadd source codes from DSRK into the Directory Server build tree. --- NEW FILE Makefile --- # # BEGIN COPYRIGHT BLOCK # This Program is free software; you can redistribute it and/or modify it under # the terms of the GNU General Public License as published by the Free Software # Foundation; version 2 of the License. # # This Program is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along with # this Program; if not, write to the Free Software Foundation, Inc., 59 Temple # Place, Suite 330, Boston, MA 02111-1307 USA. # # In addition, as a special exception, Red Hat, Inc. gives You the additional # right to link the code of this Program with code not covered under the GNU # General Public License ("Non-GPL Code") and to distribute linked combinations # including the two, subject to the limitations in this paragraph. Non-GPL Code # permitted under this exception must only link to the code of this Program # through those well defined interfaces identified in the file named EXCEPTION # found in the source code files (the "Approved Interfaces"). The files of # Non-GPL Code may instantiate templates or use macros or inline functions from # the Approved Interfaces without causing the resulting work to be covered by # the GNU General Public License. Only Red Hat, Inc. may make changes or # additions to the list of Approved Interfaces. You must obey the GNU General # Public License in all respects for all of the Program code and other code used # in conjunction with the Program except the Non-GPL Code covered by this # exception. If you modify this file, you may extend this exception to your # version of the file, but you are not obligated to do so. If you do not wish to # provide this exception without modification, you must delete this exception # statement from your version and license this file solely under the GPL without # exception. # # # Copyright (C) 2001 Sun Microsystems, Inc. Used by permission. # Copyright (C) 2005 Red Hat, Inc. # All rights reserved. # END COPYRIGHT BLOCK # # # gnu makefile for LDAP Server tools. # LDAP_SRC = ../../../.. BUILD_ROOT = ../../../../.. NOSTDCLEAN=true # don't let nsconfig.mk define target clean NOSTDSTRIP=true # don't let nsconfig.mk define target strip NSPR20=true # probably should be defined somewhere else (not sure where) OBJDEST = $(OBJDIR)/servers/tools/obj BINDIR = $(RELDIR)/shared/bin DATDIR = $(RELDIR)/shared/data SLAPD_OBJDIR = $(LDAP_OBJDIR) include $(BUILD_ROOT)/nsdefs.mk include $(BUILD_ROOT)/nsconfig.mk include $(LDAP_SRC)/nsldap.mk INCLUDES+=-I$(DB_INCLUDE) SLAPDHDIR = ../ ifeq ($(ARCH), OSF1) PLATFORM_SPECIFIC_EXTRA_LIBRARY = -lcxx else # OSF1 # oems might need to edit this for their platform PLATFORM_SPECIFIC_EXTRA_LIBRARY = endif # OSF1 INCLUDES += $(SSLINCLUDE) DEFS += $(SSL) CFLAGS += $(ARCH_CFLAGS) INCLUDES += -I$(SLAPDHDIR) -I$(LDAP_ADMINCDIR) INCLUDES += -I$(ACLINC) INCLUDES += -I ../../plugins/rever LDFLAGS += $(EXLDFLAGS) $(SSLLIBFLAG) DEPLIBS= EXTRA_LIBS_DEP = $(LDAPSDK_DEP) $(DB_LIB_DEP) $(LDAP_COMMON_LIBS_DEP) EXTRA_LIBS += $(LDAPLINK) $(DB_LIB) \ $(PLATFORM_SPECIFIC_EXTRA_LIBRARY) \ $(ALIBS) $(NSPRLINK) $(SECURITYLINK) \ $(THREADSLIB) $(LDAP_COMMON_LIBS) ifeq ($(ARCH), Linux) EXTRA_LIBS += -lcrypt endif KEYUPG_LIBS_DEP= KEYUPG_LIBS=$(LDAP_LIBLITEKEY) # It looks like all of the latest versions of Unix that we ship on # have a good enough heap implementations that they don't need # SmartHeap. We still need it on NT. ifneq ($(ARCH), WINNT) LDAP_DONT_USE_SMARTHEAP=1 endif # Don't use smartheap for debug builds on NT ifeq ($(ARCH), WINNT) ifeq ($(DEBUG), full) LDAP_DONT_USE_SMARTHEAP=1 endif endif ifndef LDAP_DONT_USE_SMARTHEAP include $(BUILD_ROOT)/ns_usesh.mk _smartheap_depend = $(SH_LIB_DEP) else CFLAGS+=-DLDAP_DONT_USE_SMARTHEAP endif RSEARCHSRC := nametable.c sdattable.c searchthread.c rsearch.c INFADDSRC := nametable.c addthread.c infadd.c DATAFILES := scripts/dbgen-GivenNames scripts/dbgen-FamilyNames scripts/dbgen-OrgUnits DBGEN := scripts/dbgen.pl ifeq ($(OS_ARCH), WINNT) OBJEXT :=.obj else OBJEXT :=.o endif RSEARCHOBJS = $(addprefix $(OBJDEST)/, $(RSEARCHSRC:.c=$(OBJEXT))) INFADDOBJS = $(addprefix $(OBJDEST)/, $(INFADDSRC:.c=$(OBJEXT))) HDIR = $(LDAP_SRC)/include ALL_OBJS = $(RSEARCHOBJS) $(INFADDOBJS) RSEARCH = $(addsuffix $(EXE_SUFFIX), $(addprefix $(BINDIR)/, rsearch)) INFADD = $(addsuffix $(EXE_SUFFIX), $(addprefix $(BINDIR)/, infadd)) DBGEN = $(addsuffix $(EXE_SUFFIX), $(addprefix $(BINDIR)/, dbgen.pl)) BINS= $(RSEARCH) $(INFADD) $(DBGEN) all: $(OBJDEST) $(BINDIR) $(BINS) $(DATDIR) $(RSEARCH): $(RSEARCHOBJS) $(BINDIR) $(LINK_EXE) $(RSEARCHOBJS) $(LDAP_LIBLDIF) -chmod 755 $(RSEARCH) $(INFADD): $(INFADDOBJS) $(BINDIR) $(LINK_EXE) $(INFADDOBJS) $(LDAP_LIBLDIF) -chmod 755 $(INFADD) $(DBGEN): scripts/dbgen.pl $(BINDIR) cp scripts/dbgen.pl $(BINDIR) -chmod 755 $(DBGEN) $(OBJDEST): if [ ! -d $(OBJDEST) ]; then \ $(MKDIR) $(OBJDEST); \ fi $(BINDIR): if [ ! -d $(BINDIR) ]; then \ $(MKDIR) $(BINDIR); \ fi $(DATDIR): -$(RM) -r $(DATDIR) -$(MKDIR) $(DATDIR) cp scripts/dbgen-* $(DATDIR) clean: -$(RM) $(ALL_OBJS) -$(RM) -r $(BINS) $(DATDIR) --- NEW FILE addthread.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef XP_UNIX #include <unistd.h> #endif #include "nspr.h" #include <netinet/tcp.h> /* for TCP_NODELAY */ #include "ldap.h" #include "addthread.h" #include "infadd.h" /* local data for a search thread */ struct _addthread { PRUint32 addCount; PRUint32 addTotal; PRUint32 failCount; double mintime; double maxtime; LDAP *ld; PRThread *tid; PRLock *lock; int id; int alive; char *blob; int retry; }; /*** unique id generator ***/ static unsigned long uniqueid = 0; void at_initID(unsigned long i) { uniqueid = i; /* before threading */ } unsigned long getID(void) { static PRLock *lock = NULL; unsigned long ret; if (!lock) { /* initialize */ lock = PR_NewLock(); } PR_Lock(lock); ret = uniqueid++; PR_Unlock(lock); return ret; } /* new addthread */ AddThread *at_new(void) { AddThread *at = (AddThread *)malloc(sizeof(AddThread)); if (!at) return NULL; at->addCount = at->failCount = at->addTotal = 0; at->mintime = 10000; at->maxtime = 0; at->ld = NULL; at->tid = NULL; at->id = 0; at->alive = 1; at->retry = 0; at->lock = PR_NewLock(); at->blob = NULL; /* make sure the id generator has initialized */ getID(); return at; } static void at_bail(AddThread *at) { PR_Lock(at->lock); at->alive = -10; PR_Unlock(at->lock); } void at_setThread(AddThread *at, PRThread *tid, int id) { at->tid = tid; at->id = id; } int at_getThread(AddThread *at, PRThread **tid) { if (tid) *tid = at->tid; return at->id; } static void at_enableTCPnodelay(AddThread *at) { LBER_SOCKET s = 0; int val = 1; if (ldap_get_option(at->ld, LDAP_OPT_DESC, (void *)&s) != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed on ldap_get_option\n", at->id); return; } if (setsockopt(s, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val))) fprintf(stderr, "T%d: failed in setsockopt\n", at->id); } /* NOTE: currently these are unused */ #if 0 /* abruptly disconnect an LDAP connection without unbinding */ static void at_disconnect(AddThread *at) { LBER_SOCKET s = 0; if (ldap_get_option(at->ld, LDAP_OPT_DESC, (void *)&s) != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed on ldap_get_option\n", at->id); return; } #ifdef XP_WIN if (closesocket(s)) fprintf(stderr, "T%d: failed to disconnect\n", at->id); #else if (close(s)) fprintf(stderr, "T%d: failed to disconnect\n", at->id); #endif } #endif static void at_bind(AddThread *at) { int ret; int retry = 0; at->ld = ldap_init(hostname, port); if (! at->ld) { fprintf(stderr, "T%d: failed to init: %s port %d\n", at->id, hostname, port); return; } while (retry < 10) { ret = ldap_simple_bind_s(at->ld, strlen(username) ? username : NULL, strlen(password) ? password : NULL); if (LDAP_SUCCESS == ret) { return; /* ok */ } else if (LDAP_CONNECT_ERROR == ret) { retry++; } else { break; } } fprintf(stderr, "T%d: failed to bind, ldap_simple_bind_s returned %d\n", at->id, ret); } #if 0 static void at_unbind(AddThread *at) { if (ldap_unbind(at->ld) != LDAP_SUCCESS) fprintf(stderr, "T%d: failed to unbind\n", at->id); } #endif /* 0 */ static void at_random_tel_number(char *s) { static char *areaCode[] = { "303", "408", "415", "423", "510", "650", "714", "803", "864", "901" }; int index = rand() % 10; sprintf(s, "+1 %s %03d %04d", areaCode[index], rand()%1000, rand()%10000); } static int at_add(AddThread *at) { LDAPMod *attrs[10]; LDAPMod attr_cn, attr_sn, attr_givenname, attr_objectclass, attr_uid, attr_mail, attr_telephonenumber, attr_audio, attr_password; struct berval audio_berval; struct berval *audio_values[2]; char dn[100], uid[10], telno[20], *sn, *givenname, cn[50], mail[50]; char *cn_values[2], *sn_values[2], *givenname_values[2]; char *uid_values[2], *mail_values[2], *telno_values[2]; #if 1 char *objectclass_values[] = { "top", "person", "organizationalPerson", "inetOrgPerson", NULL }; #else char *objectclass_values[] = { "inetOrgPerson", NULL }; #endif int ret; /* make up the strings */ sprintf(uid, "%lu", getID()); at_random_tel_number(telno); sn = nt_getrand(family_names); givenname = nt_getrand(given_names); sprintf(cn, "%s %s %s", givenname, sn, uid); sprintf(mail, &quot;%s%s(a)example.com&quot;, givenname, uid); sprintf(dn, "cn=%s,%s", cn, suffix); cn_values[0] = cn; cn_values[1] = NULL; sn_values[0] = sn; sn_values[1] = NULL; givenname_values[0] = givenname; givenname_values[1] = NULL; uid_values[0] = uid; uid_values[1] = NULL; mail_values[0] = mail; mail_values[1] = NULL; telno_values[0] = telno; telno_values[1] = NULL; attrs[0] = &attr_objectclass; attrs[1] = &attr_cn; attrs[2] = &attr_sn; attrs[3] = &attr_givenname; attrs[4] = &attr_uid; attrs[5] = &attr_password; attrs[6] = &attr_mail; attrs[7] = &attr_telephonenumber; if (blobsize > 0) { audio_values[0] = &audio_berval; audio_values[1] = 0; audio_berval.bv_len = (blobsize > 32000) ? ((long)rand() * 1039) % blobsize : (rand() % blobsize); audio_berval.bv_val = at->blob; attr_audio.mod_op = LDAP_MOD_BVALUES; attr_audio.mod_type = "audio"; attr_audio.mod_values = (char **)&audio_values; attrs[8] = &attr_audio; attrs[9] = 0; } else attrs[8] = 0; attr_cn.mod_op = LDAP_MOD_ADD; attr_cn.mod_type = "cn"; attr_cn.mod_values = cn_values; attr_sn.mod_op = LDAP_MOD_ADD; attr_sn.mod_type = "sn"; attr_sn.mod_values = sn_values; attr_givenname.mod_op = LDAP_MOD_ADD; attr_givenname.mod_type = "givenname"; attr_givenname.mod_values = givenname_values; attr_objectclass.mod_op = LDAP_MOD_ADD; attr_objectclass.mod_type = "objectClass"; attr_objectclass.mod_values = objectclass_values; attr_uid.mod_op = LDAP_MOD_ADD; attr_uid.mod_type = "uid"; attr_uid.mod_values = uid_values; attr_password.mod_op = LDAP_MOD_ADD; attr_password.mod_type = "userpassword"; attr_password.mod_values = uid_values; attr_mail.mod_op = LDAP_MOD_ADD; attr_mail.mod_type = "mail"; attr_mail.mod_values = mail_values; attr_telephonenumber.mod_op = LDAP_MOD_ADD; attr_telephonenumber.mod_type = "telephonenumber"; attr_telephonenumber.mod_values = telno_values; #if 0 for (i = 0; attrs[i]; i++) { fprintf(stderr, "attr '%s': ", attrs[i]->mod_type); if (strcasecmp(attrs[i]->mod_type, "audio") == 0) fprintf(stderr, "binary data len=%lu\n", ((struct berval **)(attrs[i]->mod_values))[0]->bv_len); else fprintf(stderr, "'%s'\n", attrs[i]->mod_values[0]); } #endif ret = ldap_add_s(at->ld, dn, attrs); if (ret != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed to add, error = %d\n", at->id, ret); } return ret; } /* the main thread */ void infadd_start(void *v) { AddThread *at = (AddThread *)v; PRIntervalTime timer; PRUint32 span, i; int notBound = 1; int ret; /* make the blob if necessary */ if (blobsize > 0) { at->blob = (char *)malloc(blobsize); if (! at->blob) { fprintf(stderr, "T%d: can't allocate blob!\n", at->id); return; } for (i = 0; i < blobsize; i++) at->blob[i] = (char)(rand() & 0xff); } at->alive = 1; while (1) { timer = PR_IntervalNow(); /* bind if we need to */ if (notBound) { at_bind(at); if (noDelay) at_enableTCPnodelay(at); notBound = 0; } ret = at_add(at); if (LDAP_SUCCESS == ret) { span = PR_IntervalToMilliseconds(PR_IntervalNow()-timer); /* update data */ PR_Lock(at->lock); at->addCount++; at->addTotal++; if (at->mintime > span) at->mintime = span; if (at->maxtime < span) at->maxtime = span; at->alive = 1; at->retry = 0; PR_Unlock(at->lock); } else if (LDAP_CONNECT_ERROR == ret && at->retry < 10) { PR_Lock(at->lock); at->retry++; PR_Unlock(at->lock); } else { at_bail(at); return; } } } /* fetches the current min/max times and the search count, and clears them */ void at_getCountMinMax(AddThread *at, PRUint32 *count, PRUint32 *min, PRUint32 *max, PRUint32 *total) { PR_Lock(at->lock); if (count) { *count = at->addCount; at->addCount = 0; } if (min) { *min = at->mintime; at->mintime = 10000; } if (max) { *max = at->maxtime; at->maxtime = 0; } if (total) *total = at->addTotal; at->alive--; PR_Unlock(at->lock); } int at_alive(AddThread *at) { int alive; PR_Lock(at->lock); alive = at->alive; PR_Unlock(at->lock); return alive; } --- NEW FILE addthread.h --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifndef _ADDTHREAD_H #define _ADDTHREAD_H typedef struct _addthread AddThread; AddThread *at_new(void); void at_setThread(AddThread *at, PRThread *tid, int id); int at_getThread(AddThread *at, PRThread **tid); void infadd_start(void *v); void at_getCountMinMax(AddThread *at, PRUint32 *count, PRUint32 *min, PRUint32 *max, PRUint32 *total); int at_alive(AddThread *at); void at_initID(unsigned long i); #endif --- NEW FILE infadd.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ /* * XP port of dboreham's NT tool "infinite_add" * robey, june 1998 * * note: i didn't really port this one, i just wrote a quick version * from scratch. */ #ifdef LINUX #include <sys/param.h> #include <sys/sysinfo.h> #include <getopt.h> #endif #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <time.h> #include "nspr.h" #include "nametable.h" #include "addthread.h" #define DEFAULT_HOSTNAME "localhost" #define DEFAULT_PORT 389 #define DEFAULT_THREADS 1 #define DEFAULT_INTERVAL 10000 /* global data for the threads to share */ char *hostname = DEFAULT_HOSTNAME; PRUint16 port = DEFAULT_PORT; int thread_count = DEFAULT_THREADS; char *suffix = NULL; char *username = NULL; char *password = NULL; PRUint32 blobsize = 0; PRUint32 sampleInterval = DEFAULT_INTERVAL; int noDelay = 0; int quiet = 0; int verbose = 0; int saveQuit = 0; int lmtCount = 0; unsigned long firstUID = 0; NameTable *given_names = NULL, *family_names = NULL; void usage() { fprintf(stdout, "Usage: infadd -s suffix -u bindDN -w password [options]\n" "\nOptions:\n" "-h hostname (default: %s)\n" "-p port (default: %d)\n" "-t threads -- number of threads to spin (default: %d)\n" "-d -- use TCP no-delay\n" "-q -- quiet mode (no status updates)\n" "-v -- verbose mode (give per-thread statistics)\n" "-I num -- first uid (default: 0)\n" "-l count -- limit count; stops when the total count exceeds <count>\n" "-i msec -- sample interval in milliseconds (default: %u)\n" "-R size -- generate <size> random names instead of using\n" " data files\n" "-z size -- add binary blob of average size of <size> bytes\n" "\n", DEFAULT_HOSTNAME, DEFAULT_PORT, DEFAULT_THREADS, DEFAULT_INTERVAL); } /* generate a random name * this generates 'names' like "Gxuvbnrc" but hey, there are Bosnian towns * with less pronouncable names... */ char *randName(void) { char *x; int i, len = (rand() % 7) + 5; x = (char *)malloc(len+1); if (!x) return NULL; x[0] = (rand() % 26)+'A'; for (i = 1; i < len; i++) x[i] = (rand() % 26)+'a'; x[len] = 0; return x; } int fill_table(NameTable *nt, PRUint32 size) { PRUint32 i; char *x; int ret; fprintf(stdout, "Generating random names: 0 "); for (i = 0; i < size; i++) { x = randName(); /* check for duplicates */ while (nt_cis_check(nt, x)) { free(x); x = randName(); } ret = nt_push(nt, x); if ((i % 100) == 0) { fprintf(stdout, "\b\b\b\b\b\b\b%-7d", i); } } fprintf(stdout, "\b\b\b\b\b\b\b%d. Done.\n", size); return ret; } int main(int argc, char **argv) { int ch, index, numThreads, numDead; PRUint32 use_random = 0; AddThread **threads; PRUint32 total = 0, ntotal = 0; int counter; char familynames[35], givennames[35]; srand(time(NULL)); if (argc < 2) { usage(); exit(1); } while ((ch = getopt(argc, argv, "h:p:s:u:w:z:dR:t:i:I:l:qvS")) != EOF) switch (ch) { case 'h': hostname = optarg; break; case 'p': port = (PRUint16)atoi(optarg); break; case 's': suffix = optarg; break; case 'u': username = optarg; break; case 'w': password = optarg; break; case 'z': blobsize = atoi(optarg); break; case 'R': use_random = (PRUint32)atol(optarg); break; case 't': thread_count = atoi(optarg); break; case 'i': sampleInterval = (PRUint32)atol(optarg); break; case 'd': noDelay = 1; break; case 'q': quiet = 1; break; case 'v': verbose = 1; break; case 'S': saveQuit = 1; break; case 'l': lmtCount = atoi(optarg); break; case 'I': firstUID = atoi(optarg); break; default: usage(); exit(1); } if (!suffix || !username || !password) { printf("infadd: missing option\n"); usage(); exit(1); } if (use_random < 0 || sampleInterval <= 0 || thread_count <= 0 || lmtCount < 0 || blobsize < 0 || firstUID < 0) { printf("infadd: invalid option value\n"); usage(); exit(-1); } argc -= optind; argv += optind; PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 0); given_names = nt_new(0); family_names = nt_new(0); if (use_random) { fill_table(given_names, use_random); fill_table(family_names, use_random); } else { if (!access("../data/dbgen-FamilyNames", R_OK)) { strcpy(familynames, "../data/dbgen-FamilyNames"); strcpy(givennames, "../data/dbgen-GivenNames"); } else { strcpy(familynames, "../../data/dbgen-FamilyNames"); strcpy(givennames, "../../data/dbgen-GivenNames"); } fprintf(stdout, "Loading Given-Names ...\n"); if (!nt_load(given_names, givennames)) { fprintf(stdout, "*** Failed to read name table\n"); exit(1); } fprintf(stdout, "Loading Family-Names ...\n"); if (!nt_load(family_names, familynames)) { fprintf(stdout, "*** Failed to read name table\n"); exit(1); } } if (saveQuit) { fprintf(stdout, "Saving Given-Names ...\n"); nt_save(given_names, givennames); fprintf(stdout, "Saving Family-Names ...\n"); nt_save(family_names, familynames); exit(0); } if (firstUID) { at_initID(firstUID); } /* start up threads */ threads = (AddThread **)malloc(thread_count * sizeof(AddThread *)); index = 0; while (thread_count--) { AddThread *at; PRThread *thr; at = at_new(); thr = PR_CreateThread(PR_SYSTEM_THREAD, infadd_start, (void *)at, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); at_setThread(at, thr, index+1); threads[index++] = at; } numThreads = index; fprintf(stdout, "infadd: %d thread%s launched.\n\n", numThreads, numThreads == 1 ? "" : "s"); numDead = 0; counter = 0; while (numThreads) { int x, alive; double tmpv; PR_Sleep(PR_MillisecondsToInterval(sampleInterval)); counter++; /* now check for deadies */ for (x = 0; x < numThreads; x++) { alive = at_alive(threads[x]); if (alive < 1) { int y; PRThread *tid; fprintf(stdout, "T%d DEAD", at_getThread(threads[x], &tid)); if (alive <= -4) { fprintf(stdout, " -- Dead thread being reaped.\n"); PR_JoinThread(tid); for (y = x+1; y < numThreads; y++) threads[y-1] = threads[y]; numThreads--; numDead++; x--; } else fprintf(stdout, " (waiting)\n"); } } /* check the total count */ ntotal = 0; total = 0; for (x = 0; x < numThreads; x++) { PRUint32 count, min, max, ntot; at_getCountMinMax(threads[x], &count, &min, &max, &ntot); total += count; ntotal += ntot; if (!quiet && verbose) fprintf(stdout, "T%d min:%5ums, max:%5ums, count: %3u, total: %u\n", at_getThread(threads[x], NULL), min, max, count, ntot); } if (!quiet && (numThreads > 1 || !verbose)) { fprintf(stdout, "Average rate:%7.2f, total: %u\n", (double)total/(double)numThreads, ntotal); } if (lmtCount && ntotal >= lmtCount) { if (!quiet) { fprintf(stdout, "Total added records: %d, Average rate: %7.2f/thrd, " "%6.2f/sec = %6.4fmsec/op\n", ntotal, (double)ntotal/(double)numThreads, (tmpv = (double)ntotal*1000.0/(counter*sampleInterval)), (double)1000.0/tmpv); } exit(1); } /* watchdogs were reset when we fetched the min/max counters */ } fprintf(stdout, "All threads died. :(\n"); exit(1); } --- NEW FILE infadd.h --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifndef _INFADD_H #define _INFADD_H #include "nametable.h" /* global data for the threads to share */ extern char *hostname; extern PRUint16 port; extern char *suffix; extern char *username; extern char *password; extern PRUint32 blobsize; extern NameTable *given_names; extern NameTable *family_names; extern int noDelay; #endif --- NEW FILE main.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ /* * this was just easier to start from scratch. windows is too different * from nspr. */ #include <stdio.h> #include <stdlib.h> #ifdef XP_UNIX #include <unistd.h> #endif #include "nspr.h" #include "rsearch.h" #include "nametable.h" #include "searchthread.h" void usage() { printf("\nUsage: rsearch -h host -p port -s suffix -D bindDN -w password\n" "-b -- bind before every operation\n" "-u -- don't unbind---just close the connection\n" "-f filter -- Filter\n" "-v -- verbose\n" "-y -- nodelay\n" "-q -- quiet\n" "-l -- logging\n" "-m -- Operaton: Modify. -i required\n" "-d -- Operaton: Delete. -i required\n" "-c -- Operaton: Compare. -i required\n" "-i file -- name file\n" "-A attrs -- Attribute List\n" "-n number -- Reserved for future use\n" "-j number -- Sample interval, in seconds\n" "-t number -- Threads\n\n"); } /* * Convert a string of the form "foo bar baz" * into an array of strings. Returns a pointer * to allocated memory. Array contains pointers * to the string passed in. So the array needs freed, * but the pointers don't. */ char **string_to_list(char* s) { int string_count = 0; int in_space = 1; char *p; for (p = s; *p != '\0'; p++) { if (in_space) { if (' ' != *p) { /* We just found the beginning of a string */ string_count++; in_space = 0; } } else if (' ' == *p) { /* Back in space again */ in_space = 1; } } /* Now we have the suckers counted */ if (string_count > 0) { char **return_array = (char **)malloc((string_count+1)*sizeof(char *)); int index = 0; in_space = 1; for (p = s; *p != '\0'; p++) { if (in_space) { if (' ' != *p) { /* We just found the beginning of a string */ return_array[index++] = p; in_space = 0; } } else if (' ' == *p) { /* Back in space again */ in_space = 1; *p = '\0'; } } return_array[index] = 0; return return_array; } else return 0; } /* global data for the threads to share */ char *hostname = "localhost"; int port = 389; int numeric = 0; int threadCount = 1; int verbose = 0; int logging = 0; int doBind = 0; int cool = 0; int quiet = 0; int noDelay = 0; int noUnBind = 0; char *suffix = "o=Ace Industry,c=us"; char *filter = "cn=*jones*"; char *nameFile = 0; char *bindDN = "cn=Directory Manager"; char *bindPW = "unrestricted"; char **attrToReturn = 0; char *attrList = 0; Operation opType = op_search; NameTable *ntable = NULL; int sampleInterval = 10000; void main(int argc, char** argv) { int index = 0, numThreads, numDead = 0; int ch; SearchThread **threads; while ((ch = getopt(argc, argv, "j:i:h:s:f:p:t:D:w:n:A:bvlyqmcdu")) != EOF) switch (ch) { case 'h': hostname = optarg; break; case 's': suffix = optarg; break; case 'f': filter = optarg; break; case 'i': nameFile = optarg; break; case 'D': bindDN = optarg; break; case 'w': bindPW = optarg; break; case 'A': attrList = optarg; break; case 'p': port = atoi(optarg); break; case 'b': doBind = 1; break; case 'u': noUnBind = 1; break; case 'n': numeric = atoi(optarg); break; case 't': threadCount = atoi(optarg); break; case 'j': sampleInterval = atoi(optarg) * 1000; break; case 'v': verbose = 1; break; case 'q': quiet = 1; break; case 'l': logging = 1; break; case 'y': noDelay = 1; break; case 'm': opType = op_modify; break; case 'd': opType = op_delete; break; case 'c': opType = op_compare; break; case '?': usage(); exit(1); break; default: break; } argc -= optind; argv += optind; PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 0); ntable = nt_new(0); if (nameFile) { if (!nt_load(ntable, nameFile)) { printf("Failed to read name table\n"); exit(1); } } if (attrList) attrToReturn = string_to_list(attrList); /* a "vector" */ threads = (SearchThread **)malloc(threadCount * sizeof(SearchThread *)); while (threadCount--) { SearchThread *st; PRThread *thr; st = st_new(); thr = PR_CreateThread(PR_SYSTEM_THREAD, search_start, (void *)st, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); st_setThread(st, thr, index+1); threads[index++] = st; } numThreads = index; printf("rsearch: %d threads launched.\n\n", numThreads); while (numThreads != numDead) { int x; PR_Sleep(PR_MillisecondsToInterval(sampleInterval)); /* now check for deadies */ for (x = 0; x < numThreads; x++) { if (!st_alive(threads[x])) { int y; PRThread *tid; printf("T%d DEAD.\n", st_getThread(threads[x], &tid)); PR_JoinThread(tid); for (y = x+1; y < numThreads; y++) threads[y-1] = threads[y]; numThreads--; numDead++; x--; } } /* print out stats */ if (!quiet) { PRUint32 total = 0; for (x = 0; x < numThreads; x++) { PRUint32 count, min, max; st_getCountMinMax(threads[x], &count, &min, &max); total += count; printf("T%d min=%4ums, max=%4ums, count = %u\n", st_getThread(threads[x], NULL), min, max, count); } if (numThreads > 1) printf("Average rate = %.2f\n", (double)total/(double)numThreads); } /* watchdogs were reset when we fetched the min/max counters */ } printf("All threads died. (?)\n"); exit(1); } --- NEW FILE nametable.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "nspr.h" #include "nametable.h" struct _nametable { char **data; PRUint32 capacity; PRUint32 size; }; int get_large_random_number() { #ifdef _WIN32 return rand(); #else return random(); #endif } /* * replacement for fgets * This isn't like the real fgets. It fills in 's' but strips off any * trailing linefeed character(s). The return value is 0 if it went * okay. */ int PR_GetLine(PRFileDesc *fd, char *s, unsigned int n) { PRInt32 start, newstart; int x; char *p; /* grab current location in file */ start = PR_Seek(fd, 0, PR_SEEK_CUR); x = PR_Read(fd, s, n-1); if (x <= 0) return 1; /* EOF or other error */ s[x] = 0; p = strchr(s, '\n'); if (p == NULL) p = strchr(s, '\r'); if (p == NULL) { /* assume there was one anyway */ return 0; } *p = 0; newstart = start+strlen(s)+1; if ((p != s) && (*(p-1) == '\r')) *(p-1) = 0; PR_Seek(fd, newstart, PR_SEEK_SET); return 0; } /* new nametable */ NameTable *nt_new(int capacity) { NameTable *nt = (NameTable *)malloc(sizeof(NameTable)); if (!nt) return NULL; if (capacity > 0) { nt->data = (char **)malloc(sizeof(char *) * capacity); if (! nt->data) { free(nt); return NULL; } } else { nt->data = NULL; } nt->capacity = capacity; nt->size = 0; return nt; } /* destroy nametable */ void nt_destroy(NameTable *nt) { int i; if (nt->size) { for (i = 0; i < nt->size; i++) free(nt->data[i]); } free(nt->data); free(nt); } /* push a string into the nametable */ int nt_push(NameTable *nt, char *s) { char **ndata; if (nt->size >= nt->capacity) { /* expando! */ nt->capacity += NT_STEP; ndata = (char **)realloc(nt->data, sizeof(char *) * nt->capacity); if (!ndata) return 0; nt->data = ndata; } nt->data[nt->size++] = s; return nt->size; } /* push the contents of a file into the nt, one line per entry */ int nt_load(NameTable *nt, const char *filename) { PRFileDesc *fd; fd = PR_Open(filename, PR_RDONLY, 0); if (!fd) return 0; while (PR_Available(fd) > 0) { char temp[256], *s; if (PR_GetLine(fd, temp, 256)) break; s = strdup(temp); if (!s) break; if (!nt_push(nt, s)) break; } PR_Close(fd); return nt->size; } /* write a nametable out into a file */ int nt_save(NameTable *nt, const char *filename) { PRFileDesc *fd; int i; fd = PR_Open(filename, PR_WRONLY|PR_CREATE_FILE, 0644); if (!fd) return 0; for (i = 0; i < nt->size; i++) { PR_Write(fd, nt->data[i], strlen(nt->data[i])); PR_Write(fd, "\n", 1); } PR_Close(fd); return 1; } /* painstakingly determine if a given entry is already in the list */ int nt_cis_check(NameTable *nt, const char *name) { int i; for (i = 0; i < nt->size; i++) if (strcasecmp(nt->data[i], name) == 0) return 1; return 0; } /* select a specific entry */ char *nt_get(NameTable *nt, int entry) { return nt->data[entry]; } char *nt_getrand(NameTable *nt) { if (! nt->size) return NULL; /* FIXME: rand() on NT will never return a number >32k */ return nt->data[get_large_random_number() % nt->size]; } /* get all entries */ char **nt_get_all(NameTable *nt ) { return nt->data ; } --- NEW FILE nametable.h --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifndef _NAMETABLE_H #define _NAMETABLE_H /* * a NameTable is a block that just holds an array of (dynamically allocated) * strings. you can read them all in from a file, and then fetch a specific * entry, or just a random one. */ typedef struct _nametable NameTable; /* size that the array should grow by when it fills up */ #define NT_STEP 32 NameTable *nt_new(int capacity); void nt_destroy(NameTable *nt); int nt_push(NameTable *nt, char *s); int nt_load(NameTable *nt, const char *filename); int nt_save(NameTable *nt, const char *filename); int nt_cis_check(NameTable *nt, const char *name); char *nt_get(NameTable *nt, int entry); char **nt_get_all(NameTable *nt ); char *nt_getrand(NameTable *nt); int PR_GetLine(PRFileDesc *fd, char *s, unsigned int n); int get_large_random_number(); #endif --- NEW FILE rsearch.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ /* * XP port of dboreham's NT tool "repeated_search" * robey, march 1998 */ #ifdef LINUX #include <sys/param.h> #include <sys/sysinfo.h> #include <getopt.h> #endif #include <stdio.h> #include <stdlib.h> #ifdef XP_UNIX #include <unistd.h> #endif #include "nspr.h" #include "rsearch.h" #include "nametable.h" #include "searchthread.h" #include "ldap.h" #define DEFAULT_HOSTNAME "localhost" #define DEFAULT_PORT 389 #define DEFAULT_THREADS 1 #define DEFAULT_INTERVAL 10000 void usage() { printf("\nUsage: rsearch -D binddn -w bindpw -s suffix -f filter [options]\n" "-\\? -- print Usage (this message)\n" "-H -- print Usage (this message)\n" "-h host -- ldap server host (default: %s)\n" "-p port -- ldap server port (default: %d)\n" "-S scope -- search SCOPE [%d,%d,or %d] (default: %d)\n" "-b -- bind before every operation\n" "-u -- don't unbind -- just close the connection\n" "-L -- set linger -- connection discarded when closed\n" "-N -- No operation -- just bind (ignore mdc)\n" "-v -- verbose\n" "-y -- nodelay\n" "-q -- quiet\n" #ifndef NDSRK "-l -- logging\n" #endif /* NDSRK */ "-m -- operaton: modify non-indexed attr (description). -B required\n" "-M -- operaton: modify indexed attr (telephonenumber). -B required\n" "-d -- operaton: delete. -B required\n" "-c -- operaton: compare. -B required\n" "-i file -- name file; used for the search filter\n" "-B file -- [DN and] UID file (use '-B \\?' to see the format)\n" "-A attrs -- list of attributes for search request\n" "-a file -- list of attributes for search request in a file\n" " -- (use '-a \\?' to see the format ; -a & -A are mutually exclusive)\n" "-n number -- (reserved for future use)\n" "-j number -- sample interval, in seconds (default: %u)\n" "-t number -- threads (default: %d)\n" "-T number -- Time limit, in seconds; cmd stops when exceeds <number>\n" "-V -- show running average\n" "-C num -- take num samples, then stop\n" "-R num -- drop connection & reconnect every num searches\n" "-x -- Use -B file for binding; ignored if -B is not given\n" "\n", DEFAULT_HOSTNAME, DEFAULT_PORT, LDAP_SCOPE_BASE, LDAP_SCOPE_ONELEVEL, LDAP_SCOPE_SUBTREE, LDAP_SCOPE_SUBTREE, (DEFAULT_INTERVAL/1000), DEFAULT_THREADS); exit(1); } void usage_B() { printf("\nFormat of the file for the '-B <file>' option:\n" "(Assuming each passwd is identical to its corresponding UID.)\n" "\n" "Format 1.\n" "=========\n" "UID: <uid>\n" "...\n" "\n" "Format 2.\n" "=========\n" "DN: <dn>\n" "UID: <uid>\n" "...\n" "\n"); } void usage_A() { printf("\nNote: -A and -a are mutually exclusive options\n"); printf("\nFormat of the file for the '-a <file>' option:\n" "\n" "Format :\n" "=========\n" "<attr>\n" "<attr>\n" "...\n" "\n"); } /* * Convert a string of the form "foo bar baz" * into an array of strings. Returns a pointer * to allocated memory. Array contains pointers * to the string passed in. So the array needs freed, * but the pointers don't. */ char **string_to_list(char* s) { int string_count = 0; int in_space = 1; char *p; for (p = s; *p != '\0'; p++) { if (in_space) { if (' ' != *p) { /* We just found the beginning of a string */ string_count++; in_space = 0; } } else if (' ' == *p) { /* Back in space again */ in_space = 1; } } /* Now we have the suckers counted */ if (string_count > 0) { char **return_array = (char **)malloc((string_count+1)*sizeof(char *)); int index = 0; in_space = 1; for (p = s; *p != '\0'; p++) { if (in_space) { if (' ' != *p) { /* We just found the beginning of a string */ return_array[index++] = p; in_space = 0; } } else if (' ' == *p) { /* Back in space again */ in_space = 1; *p = '\0'; } } return_array[index] = 0; return return_array; } else return 0; } /* global data for the threads to share */ char *hostname = DEFAULT_HOSTNAME; int port = DEFAULT_PORT; int numeric = 0; int threadCount = DEFAULT_THREADS; int verbose = 0; int logging = 0; int doBind = 0; int cool = 0; int quiet = 0; int noDelay = 0; int noUnBind = 0; int noOp = 0; int showRunningAvg = 0; int countLimit = 0; int reconnect = 0; char *suffix = NULL; char *filter = NULL; char *nameFile = 0; char *searchDatFile = 0; char *attrFile = 0; char *bindDN = NULL; char *bindPW = NULL; char **attrToReturn = 0; char *attrList = 0; Operation opType = op_search; NameTable *ntable = NULL; NameTable *attrTable = NULL; SDatTable *sdattable = NULL; int sampleInterval = DEFAULT_INTERVAL; int timeLimit = 0; int setLinger = 0; int useBFile = 0; int myScope = LDAP_SCOPE_SUBTREE; int main(int argc, char** argv) { int index = 0, numThreads, numDead = 0; int ch; int lifeTime; SearchThread **threads; PRUint32 total; double rate, val, cumrate; double sumVal; int counter; if (argc == 1) { usage(); exit(1); } while ((ch = getopt(argc, argv, "B:a:j:i:h:s:f:p:t:T:D:w:n:A:S:C:R:bvlyqmMcduNLHx?V")) != EOF) switch (ch) { case 'h': hostname = optarg; break; case 's': suffix = optarg; break; case 'f': filter = optarg; break; case 'i': nameFile = optarg; break; case 'B': if (optarg[0] == '?') { usage_B(); exit(1); } searchDatFile = optarg; break; case 'D': bindDN = optarg; break; case 'w': bindPW = optarg; break; case 'A': if (!attrFile) attrList = optarg; else usage(); break; case 'p': port = atoi(optarg); break; case 'S': myScope = atoi(optarg); if (myScope < LDAP_SCOPE_BASE || myScope > LDAP_SCOPE_SUBTREE) myScope = LDAP_SCOPE_SUBTREE; break; case 'C': countLimit = atoi(optarg); break; case 'b': doBind = 1; break; case 'u': noUnBind = 1; break; case 'L': setLinger = 1; break; case 'n': numeric = atoi(optarg); break; case 't': threadCount = atoi(optarg); break; case 'j': sampleInterval = atoi(optarg) * 1000; break; case 'v': verbose = 1; break; case 'q': quiet = 1; break; case 'l': logging = 1; break; case 'y': noDelay = 1; break; case 'm': opType = op_modify; break; case 'M': opType = op_idxmodify; break; case 'd': opType = op_delete; break; case 'c': opType = op_compare; break; case 'N': noOp = 1; doBind = 1; /* no use w/o this */ break; case 'T': timeLimit = atoi(optarg); break; case 'V': showRunningAvg = 1; break; case 'R': reconnect = atoi(optarg); break; case 'x': useBFile = 1; break; case 'a': if (optarg[0] == '?') { usage_A(); exit(1); } if (!attrList) attrFile = optarg; else usage(); break; case '?': case 'H': default : usage(); } if ( !suffix || !filter || !bindDN || !bindPW ) { printf("rsearch: missing option\n"); usage(); } if ( timeLimit < 0 || threadCount <= 0 || sampleInterval <= 0 ) { printf("rsearch: invalid option value\n"); usage(); } argc -= optind; argv += optind; PR_Init(PR_SYSTEM_THREAD, PR_PRIORITY_NORMAL, 0); ntable = nt_new(0); if (nameFile) { if (!nt_load(ntable, nameFile)) { printf("Failed to read name table\n"); exit(1); } } attrTable = nt_new(0); if (attrFile) { if (!nt_load(attrTable , attrFile)) { printf ("Failed to read attr name table\n"); exit(1); } } sdattable = sdt_new(0); if (searchDatFile) { if (!sdt_load(sdattable, searchDatFile)) { printf("Failed to read search data table: %s\n", searchDatFile); exit(1); } } if (attrList) attrToReturn = string_to_list(attrList); /* a "vector" */ threads = (SearchThread **)malloc(threadCount * sizeof(SearchThread *)); while (threadCount--) { SearchThread *st; PRThread *thr; st = st_new(); thr = PR_CreateThread(PR_SYSTEM_THREAD, search_start, (void *)st, PR_PRIORITY_NORMAL, PR_GLOBAL_THREAD, PR_JOINABLE_THREAD, 0); st_setThread(st, thr, index+1); threads[index++] = st; } numThreads = index; printf("rsearch: %d threads launched.\n\n", numThreads); lifeTime = 0; counter = 0; sumVal = 0; cumrate = 0.0; while (numThreads) { int x, alive; PR_Sleep(PR_MillisecondsToInterval(sampleInterval)); counter++; lifeTime += sampleInterval/1000; /* now check for deadies */ for (x = 0; x < numThreads; x++) { alive = st_alive(threads[x]); if (alive < 1) { int y; PRThread *tid; printf("T%d no heartbeat", st_getThread(threads[x], &tid)); if (alive <= -4) { printf(" -- Dead thread being reaped.\n"); PR_JoinThread(tid); for (y = x+1; y < numThreads; y++) threads[y-1] = threads[y]; numThreads--; numDead++; x--; } else printf(" (waiting)\n"); } } /* print out stats */ total = 0; for (x = 0; x < numThreads; x++) { PRUint32 count, min, max; st_getCountMinMax(threads[x], &count, &min, &max); total += count; if (!quiet && verbose) printf("T%d min=%4ums, max=%4ums, count = %u\n", st_getThread(threads[x], NULL), min, max, count); } rate = (double)total / (double)numThreads; val = 1000.0 * (double)total / (double)sampleInterval; cumrate += rate; if ((numThreads > 1) || (!verbose)) { if (!quiet) { if (showRunningAvg) printf("Rate: %7.2f/thr (cumul rate: %7.2f/thr)\n", rate, cumrate/(double)counter); else printf("Rate: %7.2f/thr (%6.2f/sec =%7.4fms/op), " "total:%6u (%d thr)\n", rate, val, (double)1000.0/val, total, numThreads); } } if (countLimit && (counter >= countLimit)) { printf("Thank you, and good night.\n"); exit(0); } if (timeLimit && (lifeTime >= timeLimit)) { double tmpv; if (verbose) printf("%d sec >= %d\n", lifeTime, timeLimit); printf("Final Average rate: " "%6.2f/sec = %6.4fmsec/op, total:%6u\n", (tmpv = (val + sumVal)/counter), (double)1000.0/tmpv, total); exit(0); } sumVal += val; /* watchdogs were reset when we fetched the min/max counters */ } printf("All threads died. (?)\n"); exit(1); } --- NEW FILE rsearch.h --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifndef _RSEARCH_H #define _RSEARCH_H typedef enum { op_search, op_modify, op_idxmodify, op_add, op_delete, op_compare } Operation; #include "nametable.h" #include "sdattable.h" /* global data for the threads to share */ extern char *hostname; extern int port; extern int numeric; /**/ extern int threadCount; /**/ extern int verbose; /**/ extern int logging; extern int doBind; extern int setLinger; /**/ extern int cool; /**/ extern int quiet; extern int noDelay; extern int noUnBind; extern int noOp; extern int myScope; extern char *suffix; extern char *filter; /**/ extern char *nameFile; extern char *bindDN; extern char *bindPW; extern char **attrToReturn; /**/ extern char *attrList; extern Operation opType; extern NameTable *ntable; extern NameTable *attrTable; extern SDatTable *sdattable; /**/ extern int sampleInterval; extern int reconnect; extern int useBFile; #endif --- NEW FILE sdattable.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #include <stdio.h> #include <stdlib.h> #include <string.h> #include "nspr.h" #include "nametable.h" #include "sdattable.h" struct _sdattable { char **dns; char **uids; PRUint32 capacity; PRUint32 size; }; /* new searchdata table */ SDatTable *sdt_new(int capacity) { SDatTable *sdt = (SDatTable *)malloc(sizeof(SDatTable)); if (!sdt) return NULL; if (capacity > 0) { sdt->dns = (char **)malloc(sizeof(char *) * capacity); if (! sdt->dns) { free(sdt); return NULL; } sdt->uids = (char **)malloc(sizeof(char *) * capacity); if (! sdt->uids) { free(sdt->dns); free(sdt); return NULL; } } else { sdt->dns = NULL; sdt->uids = NULL; } sdt->capacity = capacity; sdt->size = 0; return sdt; } /* destroy searchdata table */ void sdt_destroy(SDatTable *sdt) { int i; if (sdt->size) { for (i = 0; i < sdt->size; i++) { if (sdt->dns[i]) free(sdt->dns[i]); if (sdt->uids[i]) free(sdt->uids[i]); } } if (sdt->dns); free(sdt->dns); if (sdt->uids); free(sdt->uids); free(sdt); } /* push a string into the searchdata table */ int sdt_push(SDatTable *sdt, char *dn, char *uid) { char **sddns, **sddns0; char **sduids; if (!dn && !uid) return sdt->size; if (sdt->size >= sdt->capacity) { /* expando! */ sdt->capacity += SDT_STEP; sddns = (char **)realloc(sdt->dns, sizeof(char *) * sdt->capacity); if (!sddns) return 0; sddns0 = sdt->dns; sdt->dns = sddns; sduids = (char **)realloc(sdt->uids, sizeof(char *) * sdt->capacity); if (!sduids) { sdt->dns = sddns0; /* restore */ return 0; } sdt->uids = sduids; } sdt->dns[sdt->size] = dn; /* might be null */ sdt->uids[sdt->size] = uid; /* never be null */ return ++sdt->size; } /* push the contents of a file into the sdt, one line per entry */ int sdt_load(SDatTable *sdt, const char *filename) { PRFileDesc *fd; fd = PR_Open(filename, PR_RDONLY, 0); if (!fd) return 0; while (PR_Available(fd) > 0) { int rval; char temp[256]; char *dn = NULL; char *uid = NULL; while (!(rval = PR_GetLine(fd, temp, 256))) { char *p; if (!strncasecmp(temp, "dn:", 3)) { for (p = temp + 4; *p == ' ' || *p == '\t'; p++) ; dn = strdup(p); if (!dn) break; } else if (!strncasecmp(temp, "uid:", 4)) { for (p = temp + 5; *p == ' ' || *p == '\t'; p++) ; uid = strdup(p); if (!uid) break; } if (uid) { /* dn should come earlier than uid */ if (!sdt_push(sdt, dn, uid)) goto out; break; } } if (rval) break; /* PR_GetLine failed */ } out: PR_Close(fd); return sdt->size; } /* write a searchdata table out into a file */ int sdt_save(SDatTable *sdt, const char *filename) { PRFileDesc *fd; int i; fd = PR_Open(filename, PR_WRONLY|PR_CREATE_FILE, 0644); if (!fd) return 0; for (i = 0; i < sdt->size; i++) { if (sdt->dns[i]) { PR_Write(fd, "dn: ", 4); PR_Write(fd, sdt->dns[i], strlen(sdt->dns[i])); PR_Write(fd, "\n", 1); } if (sdt->dns[i]) { PR_Write(fd, "uid: ", 5); PR_Write(fd, sdt->uids[i], strlen(sdt->uids[i])); PR_Write(fd, "\n", 1); } } PR_Close(fd); return 1; } /* painstakingly determine if a given entry is already in the list */ int sdt_cis_check(SDatTable *sdt, const char *name) { int i; for (i = 0; i < sdt->size; i++) { if (strcasecmp(sdt->dns[i], name) == 0) return 1; if (strcasecmp(sdt->uids[i], name) == 0) return 1; } return 0; } /* select a specific entry */ char *sdt_dn_get(SDatTable *sdt, int entry) { return sdt->dns[entry]; } void sdt_dn_set(SDatTable *sdt, int entry, char *dn) { sdt->dns[entry] = strdup(dn); } char *sdt_uid_get(SDatTable *sdt, int entry) { return sdt->uids[entry]; } int sdt_getrand(SDatTable *sdt) { if (! sdt->size) return -1; /* FIXME: rand() on NT will never return a number >32k */ return get_large_random_number() % sdt->size; } int sdt_getlen(SDatTable *sdt) { return sdt->size; } --- NEW FILE sdattable.h --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifndef _SDATTABLE_H #define _SDATTABLE_H /* * a SDatTable is a block that just holds an array of (dynamically allocated) * dn & uid pair (dn might be empty). you can read them all in from a file, * and then fetch a specific entry, or just a random one. */ typedef struct _sdattable SDatTable; /* size that the array should grow by when it fills up */ #define SDT_STEP 32 SDatTable *sdt_new(int capacity); void sdt_destroy(SDatTable *sdt); int sdt_push(SDatTable *sdt, char *dn, char *uid); int sdt_load(SDatTable *sdt, const char *filename); int sdt_save(SDatTable *sdt, const char *filename); int sdt_cis_check(SDatTable *sdt, const char *name); char *sdt_dn_get(SDatTable *sdt, int entry); void sdt_dn_set(SDatTable *sdt, int entry, char *dn); char *sdt_uid_get(SDatTable *sdt, int entry); int sdt_getrand(SDatTable *sdt); int sdt_getlen(SDatTable *sdt); #endif --- NEW FILE searchthread.c --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #include <stdio.h> #include <stdlib.h> #include <string.h> #ifdef XP_UNIX #include <unistd.h> #endif #include <time.h> #include <errno.h> #include "nspr.h" #include <sys/types.h> #include <sys/socket.h> #include <netinet/tcp.h> /* for TCP_NODELAY */ #include "ldap.h" #include "rsearch.h" #include "searchthread.h" /* local data for a search thread */ struct _searchthread { PRUint32 searchCount; PRUint32 failCount; double mintime; double maxtime; LDAP *ld; LDAP *ld2; /* aux LDAP handle */ LBER_SOCKET soc; PRThread *tid; PRLock *lock; int id; int alive; int retry; }; /* new searchthread */ SearchThread *st_new(void) { SearchThread *st = (SearchThread *)malloc(sizeof(SearchThread)); if (!st) return NULL; st->searchCount = st->failCount = 0; st->mintime = 10000; st->maxtime = 0; st->ld = NULL; st->ld2 = NULL; st->soc = -1; st->tid = NULL; st->id = 0; st->alive = 1; st->lock = PR_NewLock(); st->retry = 0; srand(time(0)); return st; } void st_setThread(SearchThread *st, PRThread *tid, int id) { st->tid = tid; st->id = id; } int st_getThread(SearchThread *st, PRThread **tid) { if (tid) *tid = st->tid; return st->id; } static void st_enableTCPnodelay(SearchThread *st) { int val = 1; if (st->soc < 0) { if (ldap_get_option(st->ld, LDAP_OPT_DESC, (void *)&st->soc) != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed on ldap_get_option\n", st->id); return; } } if (setsockopt(st->soc, IPPROTO_TCP, TCP_NODELAY, (char *)&val, sizeof(val))) fprintf(stderr, "T%d: failed in setsockopt 1\n", st->id); } /* abruptly disconnect an LDAP connection without unbinding */ static void st_disconnect(SearchThread *st) { if (st->soc < 0) { if (ldap_get_option(st->ld, LDAP_OPT_DESC, (void *)&st->soc) != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed on ldap_get_option\n", st->id); return; } } #ifdef XP_WIN if (closesocket(st->soc)) fprintf(stderr, "T%d: failed to disconnect\n", st->id); #else if (close(st->soc)) fprintf(stderr, "T%d: failed to disconnect\n", st->id); #endif st->soc = -1; } static int st_bind_core(SearchThread *st, LDAP **ld, char *dn, char *uid) { int ret = 0; int retry = 0; while (1) { ret = ldap_simple_bind_s(*ld, dn, uid); if (LDAP_SUCCESS == ret) { break; } else if (LDAP_CONNECT_ERROR == ret && retry < 10) { retry++; } else { fprintf(stderr, "T%d: failed to bind, ldap_simple_bind_s" "(%s, %s) returned 0x%x (errno %d)\n", st->id, dn, uid, ret, errno); *ld = NULL; return 0; } } return 1; } static int st_bind(SearchThread *st) { if (!st->ld) { st->ld = ldap_init(hostname, port); if (!st->ld) { fprintf(stderr, "T%d: failed to init\n", st->id); return 0; } } if (!st->ld2) { /* aux LDAP handle */ st->ld2 = ldap_init(hostname, port); if (!st->ld2) { fprintf(stderr, "T%d: failed to init 2\n", st->id); return 0; } if (0 == st_bind_core(st, &(st->ld2), strlen(bindDN) ? bindDN : NULL, strlen(bindPW) ? bindPW : NULL)) { return 0; } } if (opType != op_delete && opType != op_modify && opType != op_idxmodify && sdattable && sdt_getlen(sdattable) > 0) { int e; char *dn, *uid; do { e = sdt_getrand(sdattable); } while (e < 0); dn = sdt_dn_get(sdattable, e); uid = sdt_uid_get(sdattable, e); if (useBFile) { /* in this test, assuming uid == password */ if (dn) { if (0 == st_bind_core(st, &(st->ld), dn, uid)) { return 0; } } else if (uid) { char filterBuffer[100]; char *pFilter; struct timeval timeout; int scope = LDAP_SCOPE_SUBTREE, attrsOnly = 0; LDAPMessage *result; int retry = 0; pFilter = filterBuffer; sprintf(filterBuffer, "(uid=%s)", uid); timeout.tv_sec = 3600; timeout.tv_usec = 0; while (1) { int ret = ldap_search_st(st->ld2, suffix, scope, pFilter, NULL, attrsOnly, &timeout, &result); if (LDAP_SUCCESS == ret) { break; } else if ((LDAP_CONNECT_ERROR == ret || (LDAP_TIMEOUT == ret)) && retry < 10) { retry++; } else { fprintf(stderr, "T%d: failed to search 1, error=0x%x\n", st->id, ret); return 0; } } dn = ldap_get_dn(st->ld2, result); if (0 == st_bind_core(st, &(st->ld), dn, uid)) { return 0; } } else { fprintf(stderr, "T%d: no data found, dn: %p, uid: %p\n", st->id, dn, uid); return 0; } } else { if (0 == st_bind_core(st, &(st->ld), dn, uid)) { return 0; } } } else { if (0 == st_bind_core(st, &(st->ld), strlen(bindDN) ? bindDN : NULL, strlen(bindPW) ? bindPW : NULL)) { return 0; } } if (st->soc < 0) { if (ldap_get_option(st->ld, LDAP_OPT_DESC, (void *)&st->soc) != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed on ldap_get_option\n", st->id); return 0; } } if (setLinger) { int val; struct linger l; val = sizeof(struct linger); l.l_onoff = 1; l.l_linger = 0; if (setsockopt(st->soc, SOL_SOCKET, SO_LINGER, (char *)&l, val) < 0) { fprintf(stderr, "T%d: failed in setsockopt 2, errno %d (%d)\n", st->id, errno, st->soc); st->soc = -1; return 0; } } return 1; } static void st_unbind(SearchThread *st) { if (ldap_unbind(st->ld) != LDAP_SUCCESS) fprintf(stderr, "T%d: failed to unbind\n", st->id); st->ld = NULL; st->soc = -1; } static int st_search(SearchThread *st) { char filterBuffer[100]; char *pFilter; struct timeval timeout; int scope, attrsOnly = 0; LDAPMessage *result; int ret; scope = myScope; if (ntable || numeric) { char *s = NULL; char num[8]; if (! numeric) { do { s = nt_getrand(ntable); } while ((s) && (strlen(s) < 1)); } else { sprintf(num, "%d", get_large_random_number() % numeric); s = num; } sprintf(filterBuffer, filter, s); pFilter = filterBuffer; } else { pFilter = filter; } /* Try to get attributes from the attrNameTable */ if (!attrToReturn) attrToReturn = nt_get_all(attrTable); timeout.tv_sec = 30; timeout.tv_usec = 0; ret = ldap_search_st(st->ld, suffix, scope, pFilter, attrToReturn, attrsOnly, &timeout, &result); if (ret != LDAP_SUCCESS) { fprintf(stderr, "T%d: failed to search 2, error=0x%02X\n", st->id, ret); } ldap_msgfree(result); return ret; } static void st_make_random_tel_number(char *pstr) { static char *area_codes[] = {"303", "415", "408", "650", "216", "580", 0}; int idx = rand() % 6; sprintf(pstr, "+1 %s %03d %04d", area_codes[idx], rand() % 1000, rand() % 10000); } static int st_modify_nonidx(SearchThread *st) { LDAPMod *attrs[2]; LDAPMod attr_description; int e; int rval; char *dn = NULL; char description[256]; char *description_values[2]; /* Decide what entry to modify, for this we need a table */ if (NULL == sdattable || sdt_getlen(sdattable) == 0) { fprintf(stderr, "-m option requires a DN file. Use -B file.\n"); return 0; } /* Get the target dn */ do { e = sdt_getrand(sdattable); } while (e < 0); dn = sdt_dn_get(sdattable, e); sprintf(description, "%s modified at %lu", dn, time(NULL)); description_values[0] = description; description_values[1] = NULL; attrs[0] = &attr_description; attrs[1] = NULL; attr_description.mod_op = LDAP_MOD_REPLACE; attr_description.mod_type = "description"; attr_description.mod_values = description_values; rval = ldap_modify_s(st->ld, dn, attrs); if (rval != LDAP_SUCCESS) { fprintf(stderr, "T%d: Failed to modify error=0x%x\n", st->id, rval); fprintf(stderr, "dn: %s\n", dn); } return rval; } static int st_modify_idx(SearchThread *st) { LDAPMod *attrs[2]; LDAPMod attr_telephonenumber; int e; int rval; char *dn = NULL; char telno[32]; char *telephonenumber_values[2]; /* Decide what entry to modify, for this we need a table */ if (NULL == sdattable || sdt_getlen(sdattable) == 0) { fprintf(stderr, "-m option requires a DN file. Use -B file.\n"); return 0; } /* Get the target dn */ do { e = sdt_getrand(sdattable); } while (e < 0); dn = sdt_dn_get(sdattable, e); /* Make new mod values */ st_make_random_tel_number(telno); telephonenumber_values[0] = telno; telephonenumber_values[1] = NULL; attrs[0] = &attr_telephonenumber; attrs[1] = NULL; attr_telephonenumber.mod_op = LDAP_MOD_REPLACE; attr_telephonenumber.mod_type = "telephonenumber"; attr_telephonenumber.mod_values = telephonenumber_values; rval = ldap_modify_s(st->ld, dn, attrs); if (rval != LDAP_SUCCESS) { fprintf(stderr, "T%d: Failed to modify error=0x%x\n", st->id, rval); fprintf(stderr, "dn: %s\n", dn); } return rval; } static int st_compare(SearchThread *st) { int rval; int compare_true; int correct_answer; int e; char *dn = NULL; char *uid = NULL; char uid0[100]; /* Decide what entry to modify, for this we need a table */ if (NULL == sdattable || sdt_getlen(sdattable) == 0) { fprintf(stderr, "-c option requires a DN file. Use -B file.\n"); return 0; } /* Get the target dn */ do { e = sdt_getrand(sdattable); } while (e < 0); dn = sdt_dn_get(sdattable, e); uid = sdt_uid_get(sdattable, e); compare_true = ( (rand() % 5) < 2 ); if (!compare_true) { strcpy(uid0, uid); uid0[0] = '@'; /* make it not matched */ uid = uid0; } rval = ldap_compare_s(st->ld, dn, "uid", uid); correct_answer = compare_true ? LDAP_COMPARE_TRUE : LDAP_COMPARE_FALSE; if (rval == correct_answer) { rval = LDAP_SUCCESS; } else { fprintf(stderr, "T%d: Failed to compare error=0x%x (%d)\n", st->id, rval, correct_answer); fprintf(stderr, "dn: %s, uid: %s\n", dn, uid); } return rval; } static int st_delete(SearchThread *st) { char *dn = NULL; int rval; int e; /* Decide what entry to modify, for this we need a table */ if (NULL == sdattable || sdt_getlen(sdattable) == 0) { fprintf(stderr, "-d option requires a DN file. Use -B file.\n"); return 0; } /* Get the target dn */ do { e = sdt_getrand(sdattable); } while (e < 0); dn = sdt_dn_get(sdattable, e); rval = ldap_delete_s(st->ld, dn); if (rval != LDAP_SUCCESS) { if (rval == LDAP_NO_SUCH_OBJECT) { rval = LDAP_SUCCESS; } else { fprintf(stderr, "T%d: Failed to delete error=0x%x\n", st->id, rval); fprintf(stderr, "dn: %s\n", dn); } } return rval; } /* the main thread */ void search_start(void *v) { SearchThread *st = (SearchThread *)v; PRIntervalTime timer; int notBound = 1, res, searches = 0; PRUint32 span; st->alive = 1; st->ld = 0; while (1) { timer = PR_IntervalNow(); /* bind if we need to */ if (doBind || notBound) { res = st_bind(st); if (noDelay) st_enableTCPnodelay(st); if (!res) { st_unbind(st); continue; /* error */ } notBound = 0; } /* do the operation */ if (!noOp) { switch(opType) { case op_modify: res = st_modify_nonidx(st); break; case op_idxmodify: res = st_modify_idx(st); break; case op_search: res = st_search(st); break; case op_compare: res = st_compare(st); break; case op_delete: res = st_delete(st); break; default: fprintf(stderr, "Illegal operation type specified.\n"); return; } } if (LDAP_SUCCESS == res) { st->retry = 0; } else if (LDAP_CONNECT_ERROR == res && st->retry < 10) { st->retry++; } else { break; /* error */ } if (doBind) { if (noUnBind) st_disconnect(st); st_unbind(st); } else if (reconnect) { searches++; if (searches >= reconnect) { /* unceremoniously disconnect, reconnect next cycle */ st_disconnect(st); st_unbind(st); notBound = 1; searches = 0; } } span = PR_IntervalToMilliseconds(PR_IntervalNow()-timer); /* update data */ PR_Lock(st->lock); if (0 == st->retry) { /* only when succeeded */ st->searchCount++; if (st->mintime > span) st->mintime = span; if (st->maxtime < span) st->maxtime = span; } st->alive = 1; PR_Unlock(st->lock); } } /* fetches the current min/max times and the search count, and clears them */ void st_getCountMinMax(SearchThread *st, PRUint32 *count, PRUint32 *min, PRUint32 *max) { PR_Lock(st->lock); if (count) { *count = st->searchCount; st->searchCount = 0; } if (min) { *min = st->mintime; st->mintime = 10000; } if (max) { *max = st->maxtime; st->maxtime = 0; } st->alive--; PR_Unlock(st->lock); } int st_alive(SearchThread *st) { int alive; PR_Lock(st->lock); alive = st->alive; PR_Unlock(st->lock); return alive; } --- NEW FILE searchthread.h --- /** BEGIN COPYRIGHT BLOCK * Copyright 2001 Sun Microsystems, Inc. * Portions copyright 1999, 2001 Netscape Communications Corporation. * All rights reserved. * END COPYRIGHT BLOCK **/ #ifndef _SEARCHTHREAD_H #define _SEARCHTHREAD_H typedef struct _searchthread SearchThread; SearchThread *st_new(void); void st_setThread(SearchThread *st, PRThread *tid, int id); int st_getThread(SearchThread *st, PRThread **tid); void search_start(void *v); void st_getCountMinMax(SearchThread *st, PRUint32 *count, PRUint32 *min, PRUint32 *max); int st_alive(SearchThread *st); #endif