int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_sco("Basic Framework - Success", NULL, setup_powered,
test_framework);
test_sco("Basic SCO Socket - Success", NULL, setup_powered,
test_socket);
test_sco("Basic SCO Get Socket Option - Success", NULL, setup_powered,
test_getsockopt);
test_sco("Basic SCO Set Socket Option - Success", NULL, setup_powered,
test_setsockopt);
test_sco("eSCO CVSD - Success", &connect_success, setup_powered,
test_connect);
test_sco("eSCO MSBC - Success", &connect_success, setup_powered,
test_connect_transp);
test_sco_11("SCO CVSD 1.1 - Success", &connect_success, setup_powered,
test_connect);
test_sco_11("SCO MSBC 1.1 - Failure", &connect_failure, setup_powered,
test_connect_transp);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_rfcomm("Basic RFCOMM Socket - Success", NULL,
setup_powered_client, test_basic);
test_rfcomm("Basic RFCOMM Socket Client - Success", &connect_success,
setup_powered_client, test_connect);
test_rfcomm("Basic RFCOMM Socket Client - Write Success",
&connect_send_success, setup_powered_client,
test_connect);
test_rfcomm("Basic RFCOMM Socket Client - Read Success",
&connect_read_success, setup_powered_client,
test_connect);
test_rfcomm("Basic RFCOMM Socket Client - Conn Refused",
&connect_nval, setup_powered_client, test_connect);
test_rfcomm("Basic RFCOMM Socket Server - Success", &listen_success,
setup_powered_server, test_server);
test_rfcomm("Basic RFCOMM Socket Server - Write Success",
&listen_send_success, setup_powered_server,
test_server);
test_rfcomm("Basic RFCOMM Socket Server - Read Success",
&listen_read_success, setup_powered_server,
test_server);
test_rfcomm("Basic RFCOMM Socket Server - Conn Refused", &listen_nval,
setup_powered_server, test_server);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_smp("SMP Server - Basic Request 1",
&smp_server_basic_req_1_test,
setup_powered_server, test_server);
test_smp("SMP Server - Invalid Request 1",
&smp_server_nval_req_1_test,
setup_powered_server, test_server);
test_smp("SMP Server - Invalid Request 2",
&smp_server_nval_req_2_test,
setup_powered_server, test_server);
test_smp("SMP Server - Invalid Request 3",
&smp_server_nval_req_3_test,
setup_powered_server, test_server);
test_smp("SMP Client - Basic Request 1",
&smp_client_basic_req_1_test,
setup_powered_client, test_client);
test_smp("SMP Client - Basic Request 2",
&smp_client_basic_req_2_test,
setup_powered_client, test_client);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
tester_add("/textfile/pagesize", NULL, NULL, test_pagesize, NULL);
tester_add("/textfile/delete", NULL, NULL, test_delete, NULL);
tester_add("/textfile/overwrite", NULL, NULL, test_overwrite, NULL);
tester_add("/textfile/multiple", NULL, NULL, test_multiple, NULL);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_user("User channel open - Success", NULL,
NULL, test_open_success);
test_user("User channel open - Failed", NULL,
setup_powered, test_open_failed);
test_user("User channel open - Power Toggle Success", INT_TO_PTR(true),
toggle_powered, test_open_success);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_hci_local("Reset", NULL, NULL, test_reset);
test_hci_local("Read Local Version Information", NULL, NULL,
test_read_local_version_information);
test_hci_local("Read Local Supported Commands", NULL, NULL,
test_read_local_supported_commands);
test_hci_local("Read Local Supported Features", NULL, NULL,
test_read_local_supported_features);
test_hci_local("Read Local Extended Features", NULL,
setup_features,
test_read_local_extended_features);
test_hci_local("Read Buffer Size", NULL, NULL,
test_read_buffer_size);
test_hci_local("Read Country Code", NULL, NULL,
test_read_country_code);
test_hci_local("Read BD_ADDR", NULL, NULL,
test_read_bd_addr);
test_hci_local("Read Local Supported Codecs", NULL, NULL,
test_read_local_supported_codecs);
test_hci_local("LE Read White List Size", NULL, NULL,
test_le_read_white_list_size);
test_hci_local("LE Clear White List", NULL, NULL,
test_le_clear_white_list);
test_hci_local("LE Encrypt", NULL, NULL,
test_le_encrypt);
test_hci_local("LE Rand", NULL, NULL,
test_le_rand);
test_hci_local("LE Read Local PK", &key_test_data, NULL,
test_le_read_local_pk);
test_hci_local("LE Generate DHKey", &key_test_data,
setup_le_generate_dhkey,
test_le_generate_dhkey);
test_hci_local("Inquiry (LIAC)", NULL, NULL, test_inquiry_liac);
test_hci("Create Connection", NULL,
setup_lt_connectable,
test_create_connection,
teardown_connection);
test_hci("TP/DSU/BV-02-C Reset in Advertising State", NULL,
setup_advertising_initiated,
test_reset_in_advertising_state, NULL);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_l2cap_bredr("Basic L2CAP Socket - Success", NULL,
setup_powered_client, test_basic);
test_l2cap_bredr("L2CAP BR/EDR Client - Success",
&client_connect_success_test,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client - Invalid PSM",
&client_connect_nval_psm_test,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Server - Success",
&l2cap_server_success_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid PSM",
&l2cap_server_nval_psm_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid PDU",
&l2cap_server_nval_pdu_test1,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid Disconnect CID",
&l2cap_server_nval_cid_test1,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid Config CID",
&l2cap_server_nval_cid_test2,
setup_powered_server, test_server);
test_l2cap_le("L2CAP LE Client - Success",
&le_client_connect_success_test,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE Client - Invalid PSM",
&le_client_connect_nval_psm_test,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE Server - Success", &le_server_success_test,
setup_powered_server, test_server);
return tester_run();
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
test_l2cap_bredr("Basic L2CAP Socket - Success", NULL,
setup_powered_client, test_basic);
test_l2cap_bredr("Non-connected getpeername - Failure", NULL,
setup_powered_client,
test_getpeername_not_connected);
test_l2cap_bredr("L2CAP BR/EDR Client - Success",
&client_connect_success_test,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client SSP - Success 1",
&client_connect_ssp_success_test_1,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client SSP - Success 2",
&client_connect_ssp_success_test_2,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client PIN Code - Success",
&client_connect_pin_success_test,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client - Read Success",
&client_connect_read_success_test,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client - Write Success",
&client_connect_write_success_test,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client - Invalid PSM 1",
&client_connect_nval_psm_test_1,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client - Invalid PSM 2",
&client_connect_nval_psm_test_2,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Client - Invalid PSM 3",
&client_connect_nval_psm_test_3,
setup_powered_client, test_connect);
test_l2cap_bredr("L2CAP BR/EDR Server - Success",
&l2cap_server_success_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Read Success",
&l2cap_server_read_success_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Write Success",
&l2cap_server_write_success_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Security Block",
&l2cap_server_sec_block_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid PSM",
&l2cap_server_nval_psm_test,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid PDU",
&l2cap_server_nval_pdu_test1,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid Disconnect CID",
&l2cap_server_nval_cid_test1,
setup_powered_server, test_server);
test_l2cap_bredr("L2CAP BR/EDR Server - Invalid Config CID",
&l2cap_server_nval_cid_test2,
setup_powered_server, test_server);
test_l2cap_le("L2CAP LE Client - Success",
&le_client_connect_success_test_1,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE Client SMP - Success",
&le_client_connect_success_test_2,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE Client - Command Reject",
&le_client_connect_reject_test_1,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE Client - Invalid PSM",
&le_client_connect_nval_psm_test,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE Server - Success", &le_server_success_test,
setup_powered_server, test_server);
test_l2cap_le("L2CAP LE ATT Client - Success",
&le_att_client_connect_success_test_1,
setup_powered_client, test_connect);
test_l2cap_le("L2CAP LE ATT Server - Success",
&le_att_server_success_test_1,
setup_powered_server, test_server);
return tester_run();
}
int
main( int argc, char **argv )
{
int i, j;
char *uri = NULL;
char *host = "localhost";
char *port = NULL;
char *manager = NULL;
char *passwd = NULL;
char *dirname = NULL;
char *progdir = NULL;
int loops = LOOPS;
char *outerloops = OUTERLOOPS;
char *retries = RETRIES;
char *delay = "0";
DIR *datadir;
struct dirent *file;
int friendly = 0;
int chaserefs = 0;
int noattrs = 0;
int nobind = 0;
int noinit = 1;
char *ignore = NULL;
/* search */
char *sfile = NULL;
char *sreqs[MAXREQS];
char *sattrs[MAXREQS];
char *sbase[MAXREQS];
LDAPURLDesc *slud[MAXREQS];
int snum = 0;
char *sargs[MAXARGS];
int sanum;
int sextra_args = 0;
char scmd[MAXPATHLEN];
int swamp = 0;
char swampopt[sizeof("-SSS")];
/* static so that its address can be used in initializer below. */
static char sloops[LDAP_PVT_INTTYPE_CHARS(unsigned long)];
/* read */
char *rfile = NULL;
char *rreqs[MAXREQS];
int rnum = 0;
char *rargs[MAXARGS];
char *rflts[MAXREQS];
int ranum;
int rextra_args = 0;
char rcmd[MAXPATHLEN];
static char rloops[LDAP_PVT_INTTYPE_CHARS(unsigned long)];
/* addel */
char *afiles[MAXREQS];
int anum = 0;
char *aargs[MAXARGS];
int aanum;
char acmd[MAXPATHLEN];
static char aloops[LDAP_PVT_INTTYPE_CHARS(unsigned long)];
/* modrdn */
char *nfile = NULL;
char *nreqs[MAXREQS];
int nnum = 0;
char *nargs[MAXARGS];
int nanum;
char ncmd[MAXPATHLEN];
static char nloops[LDAP_PVT_INTTYPE_CHARS(unsigned long)];
/* modify */
char *mfile = NULL;
char *mreqs[MAXREQS];
char *mdn[MAXREQS];
int mnum = 0;
char *margs[MAXARGS];
int manum;
char mcmd[MAXPATHLEN];
static char mloops[LDAP_PVT_INTTYPE_CHARS(unsigned long)];
/* bind */
char *bfile = NULL;
char *breqs[MAXREQS];
char *bcreds[MAXREQS];
char *battrs[MAXREQS];
int bnum = 0;
char *bargs[MAXARGS];
int banum;
char bcmd[MAXPATHLEN];
static char bloops[LDAP_PVT_INTTYPE_CHARS(unsigned long)];
char **bargs_extra = NULL;
char *friendlyOpt = NULL;
int pw_ask = 0;
char *pw_file = NULL;
/* extra action to do after bind... */
typedef struct extra_t {
char *action;
struct extra_t *next;
} extra_t;
extra_t *extra = NULL;
int nextra = 0;
tester_init( "slapd-tester", TESTER_TESTER );
sloops[0] = '\0';
rloops[0] = '\0';
aloops[0] = '\0';
nloops[0] = '\0';
mloops[0] = '\0';
bloops[0] = '\0';
while ( ( i = getopt( argc, argv, "AB:CD:d:FH:h:Ii:j:L:l:NP:p:r:St:Ww:y:" ) ) != EOF )
{
switch ( i ) {
case 'A':
noattrs++;
break;
case 'B': {
char **p,
**b = ldap_str2charray( optarg, "," );
extra_t **epp;
for ( epp = &extra; *epp; epp = &(*epp)->next )
;
for ( p = b; p[0]; p++ ) {
*epp = calloc( 1, sizeof( extra_t ) );
(*epp)->action = p[0];
epp = &(*epp)->next;
nextra++;
}
ldap_memfree( b );
} break;
case 'C':
chaserefs++;
break;
case 'D': /* slapd manager */
manager = ArgDup( optarg );
break;
case 'd': /* data directory */
dirname = strdup( optarg );
break;
case 'F':
friendly++;
break;
case 'H': /* slapd uri */
uri = strdup( optarg );
break;
case 'h': /* slapd host */
host = strdup( optarg );
break;
case 'I':
noinit = 0;
break;
case 'i':
ignore = optarg;
break;
case 'j': /* the number of parallel clients */
if ( lutil_atoi( &maxkids, optarg ) != 0 ) {
usage( argv[0], 'j' );
}
break;
case 'l': /* the number of loops per client */
if ( !isdigit( (unsigned char) optarg[0] ) ) {
char **p,
**l = ldap_str2charray( optarg, "," );
for ( p = l; p[0]; p++) {
struct {
struct berval type;
char *buf;
} types[] = {
{ BER_BVC( "add=" ), aloops },
{ BER_BVC( "bind=" ), bloops },
{ BER_BVC( "modify=" ), mloops },
{ BER_BVC( "modrdn=" ), nloops },
{ BER_BVC( "read=" ), rloops },
{ BER_BVC( "search=" ), sloops },
{ BER_BVNULL, NULL }
};
int c, n;
for ( c = 0; types[c].type.bv_val; c++ ) {
if ( strncasecmp( p[0], types[c].type.bv_val, types[c].type.bv_len ) == 0 ) {
break;
}
}
if ( types[c].type.bv_val == NULL ) {
usage( argv[0], 'l' );
}
if ( lutil_atoi( &n, &p[0][types[c].type.bv_len] ) != 0 ) {
usage( argv[0], 'l' );
}
snprintf( types[c].buf, sizeof( aloops ), "%d", n );
}
ldap_charray_free( l );
} else if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0], 'l' );
}
break;
case 'L': /* the number of outerloops per client */
outerloops = strdup( optarg );
break;
case 'N':
nobind++;
break;
case 'P': /* prog directory */
progdir = strdup( optarg );
break;
case 'p': /* the servers port number */
port = strdup( optarg );
break;
case 'r': /* the number of retries in case of error */
retries = strdup( optarg );
break;
case 'S':
swamp++;
break;
case 't': /* the delay in seconds between each retry */
delay = strdup( optarg );
break;
case 'w': /* the managers passwd */
passwd = ArgDup( optarg );
memset( optarg, '*', strlen( optarg ) );
break;
case 'W':
pw_ask++;
break;
case 'y':
pw_file = optarg;
break;
default:
usage( argv[0], '\0' );
break;
}
}
if (( dirname == NULL ) || ( port == NULL && uri == NULL ) ||
( manager == NULL ) || ( passwd == NULL ) || ( progdir == NULL ))
{
usage( argv[0], '\0' );
}
#ifdef HAVE_WINSOCK
children = malloc( maxkids * sizeof(HANDLE) );
#endif
/* get the file list */
if ( ( datadir = opendir( dirname )) == NULL ) {
fprintf( stderr, "%s: couldn't open data directory \"%s\".\n",
argv[0], dirname );
exit( EXIT_FAILURE );
}
/* look for search, read, modrdn, and add/delete files */
for ( file = readdir( datadir ); file; file = readdir( datadir )) {
if ( !strcasecmp( file->d_name, TSEARCHFILE )) {
sfile = get_file_name( dirname, file->d_name );
continue;
} else if ( !strcasecmp( file->d_name, TREADFILE )) {
rfile = get_file_name( dirname, file->d_name );
continue;
} else if ( !strcasecmp( file->d_name, TMODRDNFILE )) {
nfile = get_file_name( dirname, file->d_name );
continue;
} else if ( !strcasecmp( file->d_name, TMODIFYFILE )) {
mfile = get_file_name( dirname, file->d_name );
continue;
} else if ( !strncasecmp( file->d_name, TADDFILE, strlen( TADDFILE ))
&& ( anum < MAXREQS )) {
afiles[anum++] = get_file_name( dirname, file->d_name );
continue;
} else if ( !strcasecmp( file->d_name, TBINDFILE )) {
bfile = get_file_name( dirname, file->d_name );
continue;
}
}
closedir( datadir );
if ( pw_ask ) {
passwd = getpassphrase( _("Enter LDAP Password: "******"no data files found.\n" );
exit( EXIT_FAILURE );
}
/* look for search requests */
if ( sfile ) {
snum = get_search_filters( sfile, sreqs, sattrs, sbase, slud );
if ( snum < 0 ) {
fprintf( stderr,
"unable to parse file \"%s\" line %d\n",
sfile, -2*(snum + 1));
exit( EXIT_FAILURE );
}
}
/* look for read requests */
if ( rfile ) {
rnum = get_read_entries( rfile, rreqs, rflts );
if ( rnum < 0 ) {
fprintf( stderr,
"unable to parse file \"%s\" line %d\n",
rfile, -2*(rnum + 1) );
exit( EXIT_FAILURE );
}
}
/* look for modrdn requests */
if ( nfile ) {
nnum = get_read_entries( nfile, nreqs, NULL );
if ( nnum < 0 ) {
fprintf( stderr,
"unable to parse file \"%s\" line %d\n",
nfile, -2*(nnum + 1) );
exit( EXIT_FAILURE );
}
}
/* look for modify requests */
if ( mfile ) {
mnum = get_search_filters( mfile, mreqs, NULL, mdn, NULL );
if ( mnum < 0 ) {
fprintf( stderr,
"unable to parse file \"%s\" line %d\n",
mfile, -2*(mnum + 1) );
exit( EXIT_FAILURE );
}
}
/* look for bind requests */
if ( bfile ) {
bnum = get_search_filters( bfile, bcreds, battrs, breqs, NULL );
if ( bnum < 0 ) {
fprintf( stderr,
"unable to parse file \"%s\" line %d\n",
bfile, -2*(bnum + 1) );
exit( EXIT_FAILURE );
}
}
/* setup friendly option */
switch ( friendly ) {
case 0:
break;
case 1:
friendlyOpt = "-F";
break;
default:
/* NOTE: right now we don't need it more than twice */
case 2:
friendlyOpt = "-FF";
break;
}
/* setup swamp option */
if ( swamp ) {
swampopt[0] = '-';
if ( swamp > 3 ) swamp = 3;
swampopt[swamp + 1] = '\0';
for ( ; swamp-- > 0; ) swampopt[swamp + 1] = 'S';
}
/* setup loop options */
if ( sloops[0] == '\0' ) snprintf( sloops, sizeof( sloops ), "%d", 10 * loops );
if ( rloops[0] == '\0' ) snprintf( rloops, sizeof( rloops ), "%d", 20 * loops );
if ( aloops[0] == '\0' ) snprintf( aloops, sizeof( aloops ), "%d", loops );
if ( nloops[0] == '\0' ) snprintf( nloops, sizeof( nloops ), "%d", loops );
if ( mloops[0] == '\0' ) snprintf( mloops, sizeof( mloops ), "%d", loops );
if ( bloops[0] == '\0' ) snprintf( bloops, sizeof( bloops ), "%d", 20 * loops );
/*
* generate the search clients
*/
sanum = 0;
snprintf( scmd, sizeof scmd, "%s" LDAP_DIRSEP SEARCHCMD,
progdir );
sargs[sanum++] = scmd;
if ( uri ) {
sargs[sanum++] = "-H";
sargs[sanum++] = uri;
} else {
sargs[sanum++] = "-h";
sargs[sanum++] = host;
sargs[sanum++] = "-p";
sargs[sanum++] = port;
}
sargs[sanum++] = "-D";
sargs[sanum++] = manager;
sargs[sanum++] = "-w";
sargs[sanum++] = passwd;
sargs[sanum++] = "-l";
sargs[sanum++] = sloops;
sargs[sanum++] = "-L";
sargs[sanum++] = outerloops;
sargs[sanum++] = "-r";
sargs[sanum++] = retries;
sargs[sanum++] = "-t";
sargs[sanum++] = delay;
if ( friendly ) {
sargs[sanum++] = friendlyOpt;
}
if ( chaserefs ) {
sargs[sanum++] = "-C";
}
if ( noattrs ) {
sargs[sanum++] = "-A";
}
if ( nobind ) {
sargs[sanum++] = "-N";
}
if ( ignore ) {
sargs[sanum++] = "-i";
sargs[sanum++] = ignore;
}
if ( swamp ) {
sargs[sanum++] = swampopt;
}
sargs[sanum++] = "-b";
sargs[sanum++] = NULL; /* will hold the search base */
sargs[sanum++] = "-s";
sargs[sanum++] = NULL; /* will hold the search scope */
sargs[sanum++] = "-f";
sargs[sanum++] = NULL; /* will hold the search request */
sargs[sanum++] = NULL;
sargs[sanum++] = NULL; /* might hold the "attr" request */
sextra_args += 2;
sargs[sanum] = NULL;
/*
* generate the read clients
*/
ranum = 0;
snprintf( rcmd, sizeof rcmd, "%s" LDAP_DIRSEP READCMD,
progdir );
rargs[ranum++] = rcmd;
if ( uri ) {
rargs[ranum++] = "-H";
rargs[ranum++] = uri;
} else {
rargs[ranum++] = "-h";
rargs[ranum++] = host;
rargs[ranum++] = "-p";
rargs[ranum++] = port;
}
rargs[ranum++] = "-D";
rargs[ranum++] = manager;
rargs[ranum++] = "-w";
rargs[ranum++] = passwd;
rargs[ranum++] = "-l";
rargs[ranum++] = rloops;
rargs[ranum++] = "-L";
rargs[ranum++] = outerloops;
rargs[ranum++] = "-r";
rargs[ranum++] = retries;
rargs[ranum++] = "-t";
rargs[ranum++] = delay;
if ( friendly ) {
rargs[ranum++] = friendlyOpt;
}
if ( chaserefs ) {
rargs[ranum++] = "-C";
}
if ( noattrs ) {
rargs[ranum++] = "-A";
}
if ( ignore ) {
rargs[ranum++] = "-i";
rargs[ranum++] = ignore;
}
if ( swamp ) {
rargs[ranum++] = swampopt;
}
rargs[ranum++] = "-e";
rargs[ranum++] = NULL; /* will hold the read entry */
rargs[ranum++] = NULL;
rargs[ranum++] = NULL; /* might hold the filter arg */
rextra_args += 2;
rargs[ranum] = NULL;
/*
* generate the modrdn clients
*/
nanum = 0;
snprintf( ncmd, sizeof ncmd, "%s" LDAP_DIRSEP MODRDNCMD,
progdir );
nargs[nanum++] = ncmd;
if ( uri ) {
nargs[nanum++] = "-H";
nargs[nanum++] = uri;
} else {
nargs[nanum++] = "-h";
nargs[nanum++] = host;
nargs[nanum++] = "-p";
nargs[nanum++] = port;
}
nargs[nanum++] = "-D";
nargs[nanum++] = manager;
nargs[nanum++] = "-w";
nargs[nanum++] = passwd;
nargs[nanum++] = "-l";
nargs[nanum++] = nloops;
nargs[nanum++] = "-L";
nargs[nanum++] = outerloops;
nargs[nanum++] = "-r";
nargs[nanum++] = retries;
nargs[nanum++] = "-t";
nargs[nanum++] = delay;
if ( friendly ) {
nargs[nanum++] = friendlyOpt;
}
if ( chaserefs ) {
nargs[nanum++] = "-C";
}
if ( ignore ) {
nargs[nanum++] = "-i";
nargs[nanum++] = ignore;
}
nargs[nanum++] = "-e";
nargs[nanum++] = NULL; /* will hold the modrdn entry */
nargs[nanum] = NULL;
/*
* generate the modify clients
*/
manum = 0;
snprintf( mcmd, sizeof mcmd, "%s" LDAP_DIRSEP MODIFYCMD,
progdir );
margs[manum++] = mcmd;
if ( uri ) {
margs[manum++] = "-H";
margs[manum++] = uri;
} else {
margs[manum++] = "-h";
margs[manum++] = host;
margs[manum++] = "-p";
margs[manum++] = port;
}
margs[manum++] = "-D";
margs[manum++] = manager;
margs[manum++] = "-w";
margs[manum++] = passwd;
margs[manum++] = "-l";
margs[manum++] = mloops;
margs[manum++] = "-L";
margs[manum++] = outerloops;
margs[manum++] = "-r";
margs[manum++] = retries;
margs[manum++] = "-t";
margs[manum++] = delay;
if ( friendly ) {
margs[manum++] = friendlyOpt;
}
if ( chaserefs ) {
margs[manum++] = "-C";
}
if ( ignore ) {
margs[manum++] = "-i";
margs[manum++] = ignore;
}
margs[manum++] = "-e";
margs[manum++] = NULL; /* will hold the modify entry */
margs[manum++] = "-a";;
margs[manum++] = NULL; /* will hold the ava */
margs[manum] = NULL;
/*
* generate the add/delete clients
*/
aanum = 0;
snprintf( acmd, sizeof acmd, "%s" LDAP_DIRSEP ADDCMD,
progdir );
aargs[aanum++] = acmd;
if ( uri ) {
aargs[aanum++] = "-H";
aargs[aanum++] = uri;
} else {
aargs[aanum++] = "-h";
aargs[aanum++] = host;
aargs[aanum++] = "-p";
aargs[aanum++] = port;
}
aargs[aanum++] = "-D";
aargs[aanum++] = manager;
aargs[aanum++] = "-w";
aargs[aanum++] = passwd;
aargs[aanum++] = "-l";
aargs[aanum++] = aloops;
aargs[aanum++] = "-L";
aargs[aanum++] = outerloops;
aargs[aanum++] = "-r";
aargs[aanum++] = retries;
aargs[aanum++] = "-t";
aargs[aanum++] = delay;
if ( friendly ) {
aargs[aanum++] = friendlyOpt;
}
if ( chaserefs ) {
aargs[aanum++] = "-C";
}
if ( ignore ) {
aargs[aanum++] = "-i";
aargs[aanum++] = ignore;
}
aargs[aanum++] = "-f";
aargs[aanum++] = NULL; /* will hold the add data file */
aargs[aanum] = NULL;
/*
* generate the bind clients
*/
banum = 0;
snprintf( bcmd, sizeof bcmd, "%s" LDAP_DIRSEP BINDCMD,
progdir );
bargs[banum++] = bcmd;
if ( !noinit ) {
bargs[banum++] = "-I"; /* init on each bind */
}
if ( uri ) {
bargs[banum++] = "-H";
bargs[banum++] = uri;
} else {
bargs[banum++] = "-h";
bargs[banum++] = host;
bargs[banum++] = "-p";
bargs[banum++] = port;
}
bargs[banum++] = "-l";
bargs[banum++] = bloops;
bargs[banum++] = "-L";
bargs[banum++] = outerloops;
#if 0
bargs[banum++] = "-r";
bargs[banum++] = retries;
bargs[banum++] = "-t";
bargs[banum++] = delay;
#endif
if ( friendly ) {
bargs[banum++] = friendlyOpt;
}
if ( chaserefs ) {
bargs[banum++] = "-C";
}
if ( ignore ) {
bargs[banum++] = "-i";
bargs[banum++] = ignore;
}
if ( nextra ) {
bargs[banum++] = "-B";
bargs_extra = &bargs[banum++];
}
bargs[banum++] = "-D";
bargs[banum++] = NULL;
bargs[banum++] = "-w";
bargs[banum++] = NULL;
bargs[banum] = NULL;
#define DOREQ(n,j) ((n) && ((maxkids > (n)) ? ((j) < maxkids ) : ((j) < (n))))
for ( j = 0; j < MAXREQS; j++ ) {
/* search */
if ( DOREQ( snum, j ) ) {
int jj = j % snum;
int x = sanum - sextra_args;
/* base */
if ( sbase[jj] != NULL ) {
sargs[sanum - 7] = sbase[jj];
} else {
sargs[sanum - 7] = slud[jj]->lud_dn;
}
/* scope */
if ( slud[jj] != NULL ) {
sargs[sanum - 5] = (char *)ldap_pvt_scope2str( slud[jj]->lud_scope );
} else {
sargs[sanum - 5] = "sub";
}
/* filter */
if ( sreqs[jj] != NULL ) {
sargs[sanum - 3] = sreqs[jj];
} else if ( slud[jj]->lud_filter != NULL ) {
sargs[sanum - 3] = slud[jj]->lud_filter;
} else {
sargs[sanum - 3] = "(objectClass=*)";
}
/* extras */
sargs[x] = NULL;
/* attr */
if ( sattrs[jj] != NULL ) {
sargs[x++] = "-a";
sargs[x++] = sattrs[jj];
}
/* attrs */
if ( slud[jj] != NULL && slud[jj]->lud_attrs != NULL ) {
int i;
for ( i = 0; slud[jj]->lud_attrs[ i ] != NULL && x + i < MAXARGS - 1; i++ ) {
sargs[x + i] = slud[jj]->lud_attrs[ i ];
}
sargs[x + i] = NULL;
}
fork_child( scmd, sargs );
}
/* read */
if ( DOREQ( rnum, j ) ) {
int jj = j % rnum;
int x = ranum - rextra_args;
rargs[ranum - 3] = rreqs[jj];
if ( rflts[jj] != NULL ) {
rargs[x++] = "-f";
rargs[x++] = rflts[jj];
}
rargs[x] = NULL;
fork_child( rcmd, rargs );
}
/* rename */
if ( j < nnum ) {
nargs[nanum - 1] = nreqs[j];
fork_child( ncmd, nargs );
}
/* modify */
if ( j < mnum ) {
margs[manum - 3] = mdn[j];
margs[manum - 1] = mreqs[j];
fork_child( mcmd, margs );
}
/* add/delete */
if ( j < anum ) {
aargs[aanum - 1] = afiles[j];
fork_child( acmd, aargs );
}
/* bind */
if ( DOREQ( bnum, j ) ) {
int jj = j % bnum;
if ( nextra ) {
int n = ((double)nextra)*rand()/(RAND_MAX + 1.0);
extra_t *e;
for ( e = extra; n-- > 0; e = e->next )
;
*bargs_extra = e->action;
}
if ( battrs[jj] != NULL ) {
bargs[banum - 3] = manager ? manager : "";
bargs[banum - 1] = passwd ? passwd : "";
bargs[banum + 0] = "-b";
bargs[banum + 1] = breqs[jj];
bargs[banum + 2] = "-f";
bargs[banum + 3] = bcreds[jj];
bargs[banum + 4] = "-a";
bargs[banum + 5] = battrs[jj];
bargs[banum + 6] = NULL;
} else {
bargs[banum - 3] = breqs[jj];
bargs[banum - 1] = bcreds[jj];
bargs[banum] = NULL;
}
fork_child( bcmd, bargs );
bargs[banum] = NULL;
}
}
wait4kids( -1 );
exit( EXIT_SUCCESS );
}
int
main( int argc, char **argv )
{
int i;
char *host = "localhost";
char *uri = NULL;
int port = -1;
char *manager = NULL;
struct berval passwd = { 0, NULL };
char *filename = NULL;
char *entry = NULL;
int loops = LOOPS;
int outerloops = 1;
int retries = RETRIES;
int delay = 0;
int friendly = 0;
int chaserefs = 0;
LDAPMod **attrs = NULL;
tester_init( "slapd-addel", TESTER_ADDEL );
while ( ( i = getopt( argc, argv, "CD:Ff:H:h:i:L:l:p:r:t:w:" ) ) != EOF )
{
switch ( i ) {
case 'C':
chaserefs++;
break;
case 'F':
friendly++;
break;
case 'H': /* the server's URI */
uri = strdup( optarg );
break;
case 'h': /* the servers host */
host = strdup( optarg );
break;
case 'i':
/* ignored (!) by now */
break;
case 'p': /* the servers port */
if ( lutil_atoi( &port, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'D': /* the servers manager */
manager = strdup( optarg );
break;
case 'w': /* the server managers password */
passwd.bv_val = strdup( optarg );
passwd.bv_len = strlen( optarg );
memset( optarg, '*', passwd.bv_len );
break;
case 'f': /* file with entry search request */
filename = strdup( optarg );
break;
case 'l': /* the number of loops */
if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'L': /* the number of outerloops */
if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'r': /* number of retries */
if ( lutil_atoi( &retries, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 't': /* delay in seconds */
if ( lutil_atoi( &delay, optarg ) != 0 ) {
usage( argv[0] );
}
break;
default:
usage( argv[0] );
break;
}
}
if (( filename == NULL ) || ( port == -1 && uri == NULL ) ||
( manager == NULL ) || ( passwd.bv_val == NULL ))
usage( argv[0] );
entry = get_add_entry( filename, &attrs );
if (( entry == NULL ) || ( *entry == '\0' )) {
fprintf( stderr, "%s: invalid entry DN in file \"%s\".\n",
argv[0], filename );
exit( EXIT_FAILURE );
}
if (( attrs == NULL ) || ( *attrs == '\0' )) {
fprintf( stderr, "%s: invalid attrs in file \"%s\".\n",
argv[0], filename );
exit( EXIT_FAILURE );
}
uri = tester_uri( uri, host, port );
for ( i = 0; i < outerloops; i++ ) {
do_addel( uri, manager, &passwd, entry, attrs,
loops, retries, delay, friendly, chaserefs );
}
exit( EXIT_SUCCESS );
}
__declspec( dllexport ) void
LibInit() {
// do any setup here
tester_init();
}
static int read_nist_nls_data (const char *fname)
{
FILE *fp;
char line[128];
int err = 0;
int got_name = 0;
int got_model = 0;
int got_data = -1;
fp = fopen(fname, "r");
if (fp == NULL) {
fprintf(stderr, "Couldn't open %s\n", fname);
return 1;
}
tester_init();
while (fgets(line, sizeof line, fp) && !err) {
tail_strip(line);
if (strstr(line, "Dataset Name:")) {
err = get_id(line + 13);
if (!err) got_name = 1;
} else if (strstr(line, "Number of Observations:")) {
if (sscanf(line + 24, "%d", &tester.nobs) != 1) {
err = 1;
} else {
if (tester.nobs > 0) {
datainfo = create_new_dataset(&Z, tester.nvars + 1,
tester.nobs, 0);
if (datainfo == NULL) err = 1;
} else {
err = 1;
}
}
} else if (strncmp(line, "Model:", 6) == 0) {
err = read_model_lines(line, fp);
if (!err) got_model = 1;
} else if (strstr(line, "Starting") && strstr(line, "Certified")) {
err = read_params(fp);
} else if (strncmp(line, "Data:", 5) == 0) {
if (got_data < 0) {
got_data = 0;
} else {
err = read_data(fp);
if (!err) got_data = 1;
}
} else if (strstr(line, "Predictor")) {
err = get_nvars(line);
} else if (strstr(line, "evel of Diffic")) {
print_grade(line);
}
}
if (!got_name) {
missing("dataset identifier");
}
if (!got_model) {
missing("model specification");
}
if (tester.nparam == 0) {
missing("parameter values");
}
if (got_data <= 0) {
missing("input data");
} else if (tester.nobs == 0) {
missing("number of observations");
}
fclose(fp);
return err;
}
int
main( int argc, char **argv )
{
int i;
char *uri = NULL;
char *host = "localhost";
int port = -1;
char *manager = NULL;
struct berval passwd = { 0, NULL };
char *entry = NULL;
char *filter = NULL;
int loops = LOOPS;
int outerloops = 1;
int retries = RETRIES;
int delay = 0;
int force = 0;
int chaserefs = 0;
char *srchattrs[] = { "1.1", NULL };
char **attrs = srchattrs;
int noattrs = 0;
int nobind = 0;
tester_init( "slapd-read", TESTER_READ );
/* by default, tolerate referrals and no such object */
tester_ignore_str2errlist( "REFERRAL,NO_SUCH_OBJECT" );
while ( (i = getopt( argc, argv, "ACD:e:Ff:H:h:i:L:l:p:r:St:T:w:" )) != EOF ) {
switch ( i ) {
case 'A':
noattrs++;
break;
case 'C':
chaserefs++;
break;
case 'H': /* the server uri */
uri = strdup( optarg );
break;
case 'h': /* the servers host */
host = strdup( optarg );
break;
case 'i':
tester_ignore_str2errlist( optarg );
break;
case 'N':
nobind++;
break;
case 'p': /* the servers port */
if ( lutil_atoi( &port, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'D': /* the servers manager */
manager = strdup( optarg );
break;
case 'w': /* the server managers password */
passwd.bv_val = strdup( optarg );
passwd.bv_len = strlen( optarg );
memset( optarg, '*', passwd.bv_len );
break;
case 'e': /* DN to search for */
entry = strdup( optarg );
break;
case 'f': /* the search request */
filter = strdup( optarg );
break;
case 'F':
force++;
break;
case 'l': /* the number of loops */
if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'L': /* the number of outerloops */
if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'r': /* the number of retries */
if ( lutil_atoi( &retries, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'S':
swamp++;
break;
case 't': /* delay in seconds */
if ( lutil_atoi( &delay, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'T':
attrs = ldap_str2charray( optarg, "," );
if ( attrs == NULL ) {
usage( argv[0] );
}
break;
default:
usage( argv[0] );
break;
}
}
if (( entry == NULL ) || ( port == -1 && uri == NULL ))
usage( argv[0] );
if ( *entry == '\0' ) {
fprintf( stderr, "%s: invalid EMPTY entry DN.\n",
argv[0] );
exit( EXIT_FAILURE );
}
if ( argv[optind] != NULL ) {
attrs = &argv[optind];
}
uri = tester_uri( uri, host, port );
for ( i = 0; i < outerloops; i++ ) {
if ( filter != NULL ) {
do_random( uri, manager, &passwd, entry, filter, attrs,
noattrs, nobind, loops, retries, delay, force,
chaserefs );
} else {
do_read( uri, manager, &passwd, entry, NULL, attrs,
noattrs, nobind, loops, retries, delay, force,
chaserefs );
}
}
exit( EXIT_SUCCESS );
}
int
main( int argc, char **argv )
{
int i;
char *uri = NULL;
char *host = "localhost";
int port = -1;
char *manager = NULL;
struct berval passwd = { 0, NULL };
char outstr[BUFSIZ];
int ptpass;
int testfail = 0;
tester_init( "slapd-mtread", TESTER_READ );
/* by default, tolerate referrals and no such object */
tester_ignore_str2errlist( "REFERRAL,NO_SUCH_OBJECT" );
while ( (i = getopt( argc, argv, "ACc:D:e:Ff:H:h:i:L:l:M:m:p:r:t:T:w:v" )) != EOF ) {
switch ( i ) {
case 'A':
noattrs++;
break;
case 'C':
chaserefs++;
break;
case 'H': /* the server uri */
uri = strdup( optarg );
break;
case 'h': /* the servers host */
host = strdup( optarg );
break;
case 'i':
tester_ignore_str2errlist( optarg );
break;
case 'N':
nobind++;
break;
case 'v':
verbose++;
break;
case 'p': /* the servers port */
if ( lutil_atoi( &port, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'D': /* the servers manager */
manager = strdup( optarg );
break;
case 'w': /* the server managers password */
passwd.bv_val = strdup( optarg );
passwd.bv_len = strlen( optarg );
memset( optarg, '*', passwd.bv_len );
break;
case 'c': /* the number of connections */
if ( lutil_atoi( &noconns, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'e': /* DN to search for */
entry = strdup( optarg );
break;
case 'f': /* the search request */
filter = strdup( optarg );
break;
case 'F':
force++;
break;
case 'l': /* the number of loops */
if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'L': /* the number of outerloops */
if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'M': /* the number of R/W threads */
if ( lutil_atoi( &rwthreads, optarg ) != 0 ) {
usage( argv[0] );
}
if (rwthreads > MAX_THREAD)
rwthreads = MAX_THREAD;
break;
case 'm': /* the number of threads */
if ( lutil_atoi( &threads, optarg ) != 0 ) {
usage( argv[0] );
}
if (threads > MAX_THREAD)
threads = MAX_THREAD;
break;
case 'r': /* the number of retries */
if ( lutil_atoi( &retries, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 't': /* delay in seconds */
if ( lutil_atoi( &delay, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'T':
attrs = ldap_str2charray( optarg, "," );
if ( attrs == NULL ) {
usage( argv[0] );
}
break;
default:
usage( argv[0] );
break;
}
}
if (( entry == NULL ) || ( port == -1 && uri == NULL ))
usage( argv[0] );
if ( *entry == '\0' ) {
fprintf( stderr, "%s: invalid EMPTY entry DN.\n",
argv[0] );
exit( EXIT_FAILURE );
}
if ( argv[optind] != NULL ) {
attrs = &argv[optind];
}
if (noconns < 1)
noconns = 1;
if (noconns > MAXCONN)
noconns = MAXCONN;
lds = (LDAP **) calloc( sizeof(LDAP *), noconns);
if (lds == NULL) {
fprintf( stderr, "%s: Memory error: calloc noconns.\n",
argv[0] );
exit( EXIT_FAILURE );
}
uri = tester_uri( uri, host, port );
/* One connection and one connection only */
do_conn( uri, manager, &passwd, &ld, nobind, retries, 0 );
lds[0] = ld;
for(i = 1; i < noconns; i++) {
do_conn( uri, manager, &passwd, &lds[i], nobind, retries, i );
}
ldap_pvt_thread_initialize();
snprintf(outstr, BUFSIZ, "MT Test Start: conns: %d (%s)", noconns, uri);
tester_error(outstr);
snprintf(outstr, BUFSIZ, "Threads: RO: %d RW: %d", threads, rwthreads);
tester_error(outstr);
/* Set up read only threads */
for ( i = 0; i < threads; i++ ) {
ldap_pvt_thread_create( &rtid[i], 0, do_onethread, &rtid[i]);
snprintf(outstr, BUFSIZ, "Created RO thread %d", i);
thread_verbose(-1, outstr);
}
/* Set up read/write threads */
for ( i = 0; i < rwthreads; i++ ) {
ldap_pvt_thread_create( &rwtid[i], 0, do_onerwthread, &rwtid[i]);
snprintf(outstr, BUFSIZ, "Created RW thread %d", i + MAX_THREAD);
thread_verbose(-1, outstr);
}
ptpass = outerloops * loops;
/* wait for read only threads to complete */
for ( i = 0; i < threads; i++ )
ldap_pvt_thread_join(rtid[i], NULL);
/* wait for read/write threads to complete */
for ( i = 0; i < rwthreads; i++ )
ldap_pvt_thread_join(rwtid[i], NULL);
for(i = 0; i < noconns; i++) {
if ( lds[i] != NULL ) {
ldap_unbind_ext( lds[i], NULL, NULL );
}
}
free( lds );
for ( i = 0; i < threads; i++ ) {
snprintf(outstr, BUFSIZ, "RO thread %d pass=%d fail=%d", i,
rt_pass[i], rt_fail[i]);
tester_error(outstr);
if (rt_fail[i] != 0 || rt_pass[i] != ptpass) {
snprintf(outstr, BUFSIZ, "FAIL RO thread %d", i);
tester_error(outstr);
testfail++;
}
}
for ( i = 0; i < rwthreads; i++ ) {
snprintf(outstr, BUFSIZ, "RW thread %d pass=%d fail=%d", i + MAX_THREAD,
rwt_pass[i], rwt_fail[i]);
tester_error(outstr);
if (rwt_fail[i] != 0 || rwt_pass[i] != ptpass) {
snprintf(outstr, BUFSIZ, "FAIL RW thread %d", i);
tester_error(outstr);
testfail++;
}
}
snprintf(outstr, BUFSIZ, "MT Test complete" );
tester_error(outstr);
if (testfail)
exit( EXIT_FAILURE );
exit( EXIT_SUCCESS );
}
int main(int argc, char *argv[])
{
tester_init(&argc, &argv);
define_test("/TP/HGRF/RH/BV-01-I", test_hog,
raw_pdu(0x10, 0x01, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x11, 0x06, 0x01, 0x00, 0x04, 0x00, 0x12,
0x18, 0x05, 0x00, 0x08, 0x00, 0x12, 0x18),
raw_pdu(0x10, 0x09, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x01, 0x10, 0x09, 0x00, 0x0a),
raw_pdu(0x08, 0x01, 0x00, 0x04, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x03, 0x00, 0x02, 0x04, 0x00,
0x4b, 0x2a),
raw_pdu(0x08, 0x01, 0x00, 0x04, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x01, 0x00, 0x0a),
raw_pdu(0x08, 0x05, 0x00, 0x08, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x05, 0x00, 0x0a),
raw_pdu(0x08, 0x05, 0x00, 0x08, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x07, 0x00, 0x02, 0x08, 0x00,
0x4b, 0x2a),
raw_pdu(0x0a, 0x04, 0x00),
raw_pdu(0x0b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16),
raw_pdu(0x0a, 0x08, 0x00),
raw_pdu(0x0b, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16),
raw_pdu(0x0c, 0x04, 0x00, 0x16, 0x00),
raw_pdu(0x0d, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16),
raw_pdu(0x0c, 0x08, 0x00, 0x16, 0x00),
raw_pdu(0x0d, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14,
0x15, 0x16),
raw_pdu(0x0c, 0x04, 0x00, 0x2c, 0x00),
raw_pdu(0x0d, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13),
raw_pdu(0x0c, 0x08, 0x00, 0x2c, 0x00),
raw_pdu(0x0d, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d,
0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13));
define_test("/TP/HGRF/RH/BV-08-I", test_hog,
raw_pdu(0x10, 0x01, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x11, 0x06, 0x01, 0x00, 0x05, 0x00, 0x12,
0x18, 0x06, 0x00, 0x0a, 0x00, 0x12, 0x18),
raw_pdu(0x10, 0x0b, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x01, 0x10, 0x0b, 0x00, 0x0a),
raw_pdu(0x08, 0x01, 0x00, 0x05, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x03, 0x00, 0x0a, 0x04, 0x00,
0x4d, 0x2a),
raw_pdu(0x08, 0x01, 0x00, 0x05, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x01, 0x00, 0x0a),
raw_pdu(0x08, 0x06, 0x00, 0x0a, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x06, 0x00, 0x0a),
raw_pdu(0x08, 0x06, 0x00, 0x0a, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x08, 0x00, 0x0a, 0x09, 0x00,
0x4d, 0x2a),
raw_pdu(0x08, 0x04, 0x00, 0x05, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x04, 0x00, 0x0a),
raw_pdu(0x08, 0x09, 0x00, 0x0a, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x09, 0x00, 0x0a),
raw_pdu(0x0a, 0x04, 0x00),
raw_pdu(0x0b, 0xee, 0xee, 0xff, 0xff),
raw_pdu(0x04, 0x05, 0x00, 0x05, 0x00),
raw_pdu(0x05, 0x01, 0x05, 0x00, 0x08, 0x29),
raw_pdu(0x0a, 0x09, 0x00),
raw_pdu(0x0b, 0xff, 0xff, 0xee, 0xee),
raw_pdu(0x04, 0x0a, 0x00, 0x0a, 0x00),
raw_pdu(0x05, 0x01, 0x0a, 0x00, 0x08, 0x29),
raw_pdu(0x0a, 0x05, 0x00),
raw_pdu(0x0b, 0x01, 0x03),
raw_pdu(0x0a, 0x0a, 0x00),
raw_pdu(0x0b, 0x02, 0x03));
define_test("/TP/HGRF/RH/BV-09-I", test_hog,
raw_pdu(0x10, 0x01, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x11, 0x06, 0x01, 0x00, 0x04, 0x00, 0x12,
0x18, 0x05, 0x00, 0x08, 0x00, 0x12, 0x18),
raw_pdu(0x10, 0x09, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x01, 0x10, 0x09, 0x00, 0x0a),
raw_pdu(0x08, 0x01, 0x00, 0x04, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x03, 0x00, 0x02, 0x04, 0x00,
0x4a, 0x2a),
raw_pdu(0x08, 0x01, 0x00, 0x04, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x01, 0x00, 0x0a),
raw_pdu(0x08, 0x05, 0x00, 0x08, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x05, 0x00, 0x0a),
raw_pdu(0x08, 0x05, 0x00, 0x08, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x07, 0x00, 0x02, 0x08, 0x00,
0x4a, 0x2a),
raw_pdu(0x0a, 0x04, 0x00),
raw_pdu(0x0b, 0x01, 0x11, 0x00, 0x01),
raw_pdu(0x0a, 0x08, 0x00),
raw_pdu(0x0b, 0x01, 0x11, 0x00, 0x01));
define_test("/TP/HGRF/RH/BV-06-I", test_hog,
raw_pdu(0x10, 0x01, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x11, 0x06, 0x01, 0x00, 0x05, 0x00, 0x12,
0x18, 0x06, 0x00, 0x0a, 0x00, 0x12, 0x18),
raw_pdu(0x10, 0x0b, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x01, 0x10, 0x0b, 0x00, 0x0a),
raw_pdu(0x08, 0x01, 0x00, 0x05, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x03, 0x00, 0x0a, 0x04, 0x00,
0x4d, 0x2a),
raw_pdu(0x08, 0x01, 0x00, 0x05, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x01, 0x00, 0x0a),
raw_pdu(0x08, 0x06, 0x00, 0x0a, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x06, 0x00, 0x0a),
raw_pdu(0x08, 0x06, 0x00, 0x0a, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x08, 0x00, 0x0a, 0x09, 0x00,
0x4d, 0x2a),
raw_pdu(0x08, 0x04, 0x00, 0x05, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x05, 0x00, 0x0a),
raw_pdu(0x08, 0x09, 0x00, 0x0a, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x09, 0x00, 0x0a),
raw_pdu(0x0a, 0x04, 0x00),
raw_pdu(0x0b, 0xee, 0xee, 0xff, 0xff),
raw_pdu(0x04, 0x05, 0x00, 0x05, 0x00),
raw_pdu(0x05, 0x01, 0x05, 0x00, 0x08, 0x29),
raw_pdu(0x0a, 0x09, 0x00),
raw_pdu(0x0b, 0xff, 0xff, 0xee, 0xee),
raw_pdu(0x04, 0x0a, 0x00, 0x0a, 0x00),
raw_pdu(0x05, 0x01, 0x0a, 0x00, 0x08, 0x29),
raw_pdu(0x0a, 0x05, 0x00),
raw_pdu(0x0b, 0x01, 0x02),
raw_pdu(0x0a, 0x0a, 0x00),
raw_pdu(0x0b, 0x02, 0x02));
define_test("/TP/HGCF/RH/BV-01-I", test_hog,
raw_pdu(0x10, 0x01, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x11, 0x06, 0x01, 0x00, 0x06, 0x00, 0x12,
0x18, 0x07, 0x00, 0x0c, 0x00, 0x12, 0x18),
raw_pdu(0x10, 0x0d, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x01, 0x10, 0x0d, 0x00, 0x0a),
raw_pdu(0x08, 0x01, 0x00, 0x06, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x03, 0x00, 0x1a, 0x04, 0x00,
0x4d, 0x2a),
raw_pdu(0x08, 0x01, 0x00, 0x06, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x01, 0x00, 0x0a),
raw_pdu(0x08, 0x07, 0x00, 0x0c, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x07, 0x00, 0x0a),
raw_pdu(0x08, 0x07, 0x00, 0x0c, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x09, 0x00, 0x1a, 0x0a, 0x00,
0x4d, 0x2a),
raw_pdu(0x08, 0x04, 0x00, 0x06, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x04, 0x00, 0x0a),
raw_pdu(0x08, 0x0a, 0x00, 0x0c, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x0a, 0x00, 0x0a),
raw_pdu(0x0a, 0x04, 0x00),
raw_pdu(0x0b, 0xed, 0x00),
raw_pdu(0x04, 0x05, 0x00, 0x06, 0x00),
raw_pdu(0x05, 0x01, 0x05, 0x00, 0x02, 0x29,
0x06, 0x00, 0x08, 0x29),
raw_pdu(0x0a, 0x0a, 0x00),
raw_pdu(0x0b, 0xed, 0x00),
raw_pdu(0x04, 0x0b, 0x00, 0x0c, 0x00),
raw_pdu(0x05, 0x01, 0x0b, 0x00, 0x02, 0x29,
0x0c, 0x00, 0x08, 0x29),
raw_pdu(0x0a, 0x06, 0x00),
raw_pdu(0x0b, 0x01, 0x01),
raw_pdu(0x0a, 0x0c, 0x00),
raw_pdu(0x0b, 0x02, 0x01),
raw_pdu(0x0a, 0x05, 0x00),
raw_pdu(0x0b, 0x00, 0x00),
raw_pdu(0x0a, 0x0b, 0x00),
raw_pdu(0x0b, 0x00, 0x00),
raw_pdu(0x12, 0x05, 0x00, 0x01, 0x00),
raw_pdu(0x13),
raw_pdu(0x12, 0x0b, 0x00, 0x01, 0x00),
raw_pdu(0x13));
define_test("/TP/HGRF/RH/BV-02-I", test_hog,
raw_pdu(0x10, 0x01, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x11, 0x06, 0x01, 0x00, 0x05, 0x00, 0x12,
0x18, 0x06, 0x00, 0x0a, 0x00, 0x12, 0x18),
raw_pdu(0x10, 0x0b, 0x00, 0xff, 0xff, 0x00, 0x28),
raw_pdu(0x01, 0x10, 0x0b, 0x00, 0x0a),
raw_pdu(0x08, 0x01, 0x00, 0x05, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x03, 0x00, 0x02, 0x04, 0x00,
0x4b, 0x2a),
raw_pdu(0x08, 0x01, 0x00, 0x05, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x01, 0x00, 0x0a),
raw_pdu(0x08, 0x06, 0x00, 0x0a, 0x00, 0x02, 0x28),
raw_pdu(0x01, 0x08, 0x06, 0x00, 0x0a),
raw_pdu(0x08, 0x06, 0x00, 0x0a, 0x00, 0x03, 0x28),
raw_pdu(0x09, 0x07, 0x08, 0x00, 0x02, 0x09, 0x00,
0x4b, 0x2a),
raw_pdu(0x08, 0x04, 0x00, 0x05, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x04, 0x00, 0x0a),
raw_pdu(0x08, 0x09, 0x00, 0x0a, 0x00, 0x03, 0x28),
raw_pdu(0x01, 0x08, 0x09, 0x00, 0x0a),
raw_pdu(0x0a, 0x04, 0x00),
raw_pdu(0x0b, 0x01, 0x02, 0x03),
raw_pdu(0x04, 0x05, 0x00, 0x05, 0x00),
raw_pdu(0x05, 0x01, 0x05, 0x00, 0x07, 0x29),
raw_pdu(0x0a, 0x09, 0x00),
raw_pdu(0x0b, 0x01, 0x02, 0x03),
raw_pdu(0x04, 0x0a, 0x00, 0x0a, 0x00),
raw_pdu(0x05, 0x01, 0x0a, 0x00, 0x07, 0x29),
raw_pdu(0x0a, 0x05, 0x00),
raw_pdu(0x0b, 0x19, 0x2a),
raw_pdu(0x0a, 0x0a, 0x00),
raw_pdu(0x0b, 0x19, 0x2a));
return tester_run();
}
int
main( int argc, char **argv )
{
int i;
char *uri = NULL;
char *host = "localhost";
int port = -1;
char *manager = NULL;
struct berval passwd = { 0, NULL };
char *entry = NULL;
char *ava = NULL;
char *value = NULL;
int loops = LOOPS;
int outerloops = 1;
int retries = RETRIES;
int delay = 0;
int friendly = 0;
int chaserefs = 0;
tester_init( "slapd-modify", TESTER_MODIFY );
while ( ( i = getopt( argc, argv, "a:CD:e:FH:h:i:L:l:p:r:t:w:" ) ) != EOF )
{
switch ( i ) {
case 'C':
chaserefs++;
break;
case 'F':
friendly++;
break;
case 'H': /* the server uri */
uri = strdup( optarg );
break;
case 'h': /* the servers host */
host = strdup( optarg );
break;
case 'i':
/* ignored (!) by now */
break;
case 'p': /* the servers port */
if ( lutil_atoi( &port, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'D': /* the servers manager */
manager = strdup( optarg );
break;
case 'w': /* the server managers password */
passwd.bv_val = strdup( optarg );
passwd.bv_len = strlen( optarg );
memset( optarg, '*', passwd.bv_len );
break;
case 'e': /* entry to modify */
entry = strdup( optarg );
break;
case 'a':
ava = strdup( optarg );
break;
case 'l': /* the number of loops */
if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'L': /* the number of outerloops */
if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 'r': /* number of retries */
if ( lutil_atoi( &retries, optarg ) != 0 ) {
usage( argv[0] );
}
break;
case 't': /* delay in seconds */
if ( lutil_atoi( &delay, optarg ) != 0 ) {
usage( argv[0] );
}
break;
default:
usage( argv[0] );
break;
}
}
if (( entry == NULL ) || ( ava == NULL ) || ( port == -1 && uri == NULL ))
usage( argv[0] );
if ( *entry == '\0' ) {
fprintf( stderr, "%s: invalid EMPTY entry DN.\n",
argv[0] );
exit( EXIT_FAILURE );
}
if ( *ava == '\0' ) {
fprintf( stderr, "%s: invalid EMPTY AVA.\n",
argv[0] );
exit( EXIT_FAILURE );
}
if ( !( value = strchr( ava, ':' ))) {
fprintf( stderr, "%s: invalid AVA.\n",
argv[0] );
exit( EXIT_FAILURE );
}
*value++ = '\0';
while ( *value && isspace( (unsigned char) *value ))
value++;
uri = tester_uri( uri, host, port );
for ( i = 0; i < outerloops; i++ ) {
do_modify( uri, manager, &passwd, entry, ava, value,
loops, retries, delay, friendly, chaserefs );
}
exit( EXIT_SUCCESS );
}
void main(void)
{
tester_init();
}
int
main( int argc, char **argv )
{
int i;
char *uri = NULL;
char *host = "localhost";
char *dn = NULL;
char *base = NULL;
char *filter = "(objectClass=person)";
struct berval pass = { 0, NULL };
char *pwattr = NULL;
int port = -1;
int loops = LOOPS;
int outerloops = 1;
int force = 0;
int chaserefs = 0;
int noinit = 1;
int delay = 0;
/* extra action to do after bind... */
struct berval type[] = {
BER_BVC( "tester=" ),
BER_BVC( "add=" ),
BER_BVC( "bind=" ),
BER_BVC( "modify=" ),
BER_BVC( "modrdn=" ),
BER_BVC( "read=" ),
BER_BVC( "search=" ),
BER_BVNULL
};
LDAPURLDesc *extra_ludp = NULL;
tester_init( "slapd-bind", TESTER_BIND );
/* by default, tolerate invalid credentials */
tester_ignore_str2errlist( "INVALID_CREDENTIALS" );
while ( ( i = getopt( argc, argv, "a:B:b:D:Ff:H:h:Ii:L:l:p:t:w:" ) ) != EOF )
{
switch ( i ) {
case 'a':
pwattr = optarg;
break;
case 'b': /* base DN of a tree of user DNs */
base = optarg;
break;
case 'B':
{
int c;
for ( c = 0; type[c].bv_val; c++ ) {
if ( strncasecmp( optarg, type[c].bv_val, type[c].bv_len ) == 0 )
{
break;
}
}
if ( type[c].bv_val == NULL ) {
usage( argv[0], 'B' );
}
switch ( c ) {
case TESTER_TESTER:
case TESTER_BIND:
/* invalid */
usage( argv[0], 'B' );
case TESTER_SEARCH:
{
if ( ldap_url_parse( &optarg[type[c].bv_len], &extra_ludp ) != LDAP_URL_SUCCESS )
{
usage( argv[0], 'B' );
}
} break;
case TESTER_ADDEL:
case TESTER_MODIFY:
case TESTER_MODRDN:
case TESTER_READ:
/* nothing to do */
break;
default:
assert( 0 );
}
} break;
case 'C':
chaserefs++;
break;
case 'H': /* the server uri */
uri = optarg;
break;
case 'h': /* the servers host */
host = optarg;
break;
case 'i':
tester_ignore_str2errlist( optarg );
break;
case 'p': /* the servers port */
if ( lutil_atoi( &port, optarg ) != 0 ) {
usage( argv[0], 'p' );
}
break;
case 'D':
dn = optarg;
break;
case 'w':
ber_str2bv( optarg, 0, 1, &pass );
memset( optarg, '*', pass.bv_len );
break;
case 'l': /* the number of loops */
if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0], 'l' );
}
break;
case 'L': /* the number of outerloops */
if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
usage( argv[0], 'L' );
}
break;
case 'f':
filter = optarg;
break;
case 'F':
force++;
break;
case 'I':
/* reuse connection */
noinit = 0;
break;
case 't':
/* sleep between binds */
if ( lutil_atoi( &delay, optarg ) != 0 ) {
usage( argv[0], 't' );
}
break;
default:
usage( argv[0], i );
break;
}
}
if ( port == -1 && uri == NULL ) {
usage( argv[0], '\0' );
}
uri = tester_uri( uri, host, port );
for ( i = 0; i < outerloops; i++ ) {
int rc;
if ( base != NULL ) {
rc = do_base( uri, dn, &pass, base, filter, pwattr, loops,
force, chaserefs, noinit, delay, -1, NULL );
} else {
rc = do_bind( uri, dn, &pass, loops,
force, chaserefs, noinit, NULL, -1, NULL );
}
if ( rc == LDAP_SERVER_DOWN )
break;
}
exit( EXIT_SUCCESS );
}
int
main( int argc, char **argv )
{
int i;
char *uri = NULL;
char *host = "localhost";
int port = -1;
char *manager = NULL;
struct berval passwd = { 0, NULL };
char *sbase = NULL;
int scope = LDAP_SCOPE_SUBTREE;
char *filter = NULL;
char *attr = NULL;
char *srchattrs[] = { "cn", "sn", NULL };
char **attrs = srchattrs;
int loops = LOOPS;
int outerloops = 1;
int retries = RETRIES;
int delay = 0;
int force = 0;
int chaserefs = 0;
int noattrs = 0;
int nobind = 0;
tester_init( "slapd-search", TESTER_SEARCH );
/* by default, tolerate referrals and no such object */
tester_ignore_str2errlist( "REFERRAL,NO_SUCH_OBJECT" );
while ( ( i = getopt( argc, argv, "Aa:b:CD:f:FH:h:i:l:L:Np:r:Ss:t:T:w:" ) ) != EOF )
{
switch ( i ) {
case 'A':
noattrs++;
break;
case 'C':
chaserefs++;
break;
case 'H': /* the server uri */
uri = strdup( optarg );
break;
case 'h': /* the servers host */
host = strdup( optarg );
break;
case 'i':
tester_ignore_str2errlist( optarg );
break;
case 'N':
nobind++;
break;
case 'p': /* the servers port */
if ( lutil_atoi( &port, optarg ) != 0 ) {
usage( argv[0], i );
}
break;
case 'D': /* the servers manager */
manager = strdup( optarg );
break;
case 'w': /* the server managers password */
passwd.bv_val = strdup( optarg );
passwd.bv_len = strlen( optarg );
memset( optarg, '*', passwd.bv_len );
break;
case 'a':
attr = strdup( optarg );
break;
case 'b': /* file with search base */
sbase = strdup( optarg );
break;
case 'f': /* the search request */
filter = strdup( optarg );
break;
case 'F':
force++;
break;
case 'l': /* number of loops */
if ( lutil_atoi( &loops, optarg ) != 0 ) {
usage( argv[0], i );
}
break;
case 'L': /* number of loops */
if ( lutil_atoi( &outerloops, optarg ) != 0 ) {
usage( argv[0], i );
}
break;
case 'r': /* number of retries */
if ( lutil_atoi( &retries, optarg ) != 0 ) {
usage( argv[0], i );
}
break;
case 't': /* delay in seconds */
if ( lutil_atoi( &delay, optarg ) != 0 ) {
usage( argv[0], i );
}
break;
case 'T':
attrs = ldap_str2charray( optarg, "," );
if ( attrs == NULL ) {
usage( argv[0], i );
}
break;
case 'S':
swamp++;
break;
case 's':
scope = ldap_pvt_str2scope( optarg );
if ( scope == -1 ) {
usage( argv[0], i );
}
break;
default:
usage( argv[0], i );
break;
}
}
if (( sbase == NULL ) || ( filter == NULL ) || ( port == -1 && uri == NULL ))
usage( argv[0], '\0' );
if ( *filter == '\0' ) {
fprintf( stderr, "%s: invalid EMPTY search filter.\n",
argv[0] );
exit( EXIT_FAILURE );
}
if ( argv[optind] != NULL ) {
attrs = &argv[optind];
}
uri = tester_uri( uri, host, port );
for ( i = 0; i < outerloops; i++ ) {
if ( attr != NULL ) {
do_random( uri, manager, &passwd,
sbase, scope, filter, attr,
attrs, noattrs, nobind,
loops, retries, delay, force, chaserefs );
} else {
do_search( uri, manager, &passwd,
sbase, scope, filter, NULL,
attrs, noattrs, nobind,
loops, retries, delay, force, chaserefs );
}
}
exit( EXIT_SUCCESS );
}
