virtual void bind(int col,long long v)
{
do_bind(col,v);
}
virtual void bind(int col,unsigned long long v)
{
do_bind(col,v);
}
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 );
}
virtual void bind(int col,int v)
{
do_bind(col,v);
}
static int
do_base( char *uri, char *dn, struct berval *pass, char *base, char *filter, char *pwattr,
int maxloop, int force, int chaserefs, int noinit, int delay,
int action_type, void *action )
{
LDAP *ld = NULL;
int i = 0;
int rc = LDAP_SUCCESS;
ber_int_t msgid;
LDAPMessage *res, *msg;
char **dns = NULL;
struct berval *creds = NULL;
char *attrs[] = { LDAP_NO_ATTRS, NULL };
int ndns = 0;
#ifdef _WIN32
DWORD beg, end;
#else
struct timeval beg, end;
#endif
int version = LDAP_VERSION3;
char *nullstr = "";
ldap_initialize( &ld, uri );
if ( ld == NULL ) {
tester_perror( "ldap_initialize", NULL );
exit( EXIT_FAILURE );
}
(void) ldap_set_option( ld, LDAP_OPT_PROTOCOL_VERSION, &version );
(void) ldap_set_option( ld, LDAP_OPT_REFERRALS,
chaserefs ? LDAP_OPT_ON: LDAP_OPT_OFF );
rc = ldap_sasl_bind_s( ld, dn, LDAP_SASL_SIMPLE, pass, NULL, NULL, NULL );
if ( rc != LDAP_SUCCESS ) {
tester_ldap_error( ld, "ldap_sasl_bind_s", NULL );
exit( EXIT_FAILURE );
}
fprintf( stderr, "PID=%ld - Bind(%d): base=\"%s\", filter=\"%s\" attr=\"%s\".\n",
(long) pid, maxloop, base, filter, pwattr );
if ( pwattr != NULL ) {
attrs[ 0 ] = pwattr;
}
rc = ldap_search_ext( ld, base, LDAP_SCOPE_SUBTREE,
filter, attrs, 0, NULL, NULL, 0, 0, &msgid );
if ( rc != LDAP_SUCCESS ) {
tester_ldap_error( ld, "ldap_search_ext", NULL );
exit( EXIT_FAILURE );
}
while ( ( rc = ldap_result( ld, LDAP_RES_ANY, LDAP_MSG_ONE, NULL, &res ) ) > 0 )
{
BerElement *ber;
struct berval bv;
int done = 0;
for ( msg = ldap_first_message( ld, res ); msg;
msg = ldap_next_message( ld, msg ) )
{
switch ( ldap_msgtype( msg ) ) {
case LDAP_RES_SEARCH_ENTRY:
rc = ldap_get_dn_ber( ld, msg, &ber, &bv );
dns = realloc( dns, (ndns + 1)*sizeof(char *) );
dns[ndns] = ber_strdup( bv.bv_val );
if ( pwattr != NULL ) {
struct berval **values = ldap_get_values_len( ld, msg, pwattr );
creds = realloc( creds, (ndns + 1)*sizeof(struct berval) );
if ( values == NULL ) {
novals:;
creds[ndns].bv_len = 0;
creds[ndns].bv_val = nullstr;
} else {
static struct berval cleartext = BER_BVC( "{CLEARTEXT} " );
struct berval value = *values[ 0 ];
if ( value.bv_val[ 0 ] == '{' ) {
char *end = ber_bvchr( &value, '}' );
if ( end ) {
if ( ber_bvcmp( &value, &cleartext ) == 0 ) {
value.bv_val += cleartext.bv_len;
value.bv_len -= cleartext.bv_len;
} else {
ldap_value_free_len( values );
goto novals;
}
}
}
ber_dupbv( &creds[ndns], &value );
ldap_value_free_len( values );
}
}
ndns++;
ber_free( ber, 0 );
break;
case LDAP_RES_SEARCH_RESULT:
done = 1;
break;
}
if ( done )
break;
}
ldap_msgfree( res );
if ( done ) break;
}
#ifdef _WIN32
beg = GetTickCount();
#else
gettimeofday( &beg, NULL );
#endif
if ( ndns == 0 ) {
tester_error( "No DNs" );
return 1;
}
fprintf( stderr, " PID=%ld - Bind base=\"%s\" filter=\"%s\" got %d values.\n",
(long) pid, base, filter, ndns );
/* Ok, got list of DNs, now start binding to each */
for ( i = 0; i < maxloop; i++ ) {
int j;
struct berval cred = { 0, NULL };
#if 0 /* use high-order bits for better randomness (Numerical Recipes in "C") */
j = rand() % ndns;
#endif
j = ((double)ndns)*rand()/(RAND_MAX + 1.0);
if ( creds && !BER_BVISEMPTY( &creds[j] ) ) {
cred = creds[j];
}
if ( do_bind( uri, dns[j], &cred, 1, force, chaserefs, noinit, &ld,
action_type, action ) && !force )
{
break;
}
if ( delay ) {
sleep( delay );
}
}
if ( ld != NULL ) {
ldap_unbind_ext( ld, NULL, NULL );
ld = NULL;
}
#ifdef _WIN32
end = GetTickCount();
end -= beg;
fprintf( stderr, " PID=%ld - Bind done %d in %d.%03d seconds.\n",
(long) pid, i, end / 1000, end % 1000 );
#else
gettimeofday( &end, NULL );
end.tv_usec -= beg.tv_usec;
if (end.tv_usec < 0 ) {
end.tv_usec += 1000000;
end.tv_sec -= 1;
}
end.tv_sec -= beg.tv_sec;
fprintf( stderr, " PID=%ld - Bind done %d in %ld.%06ld seconds.\n",
(long) pid, i, (long) end.tv_sec, (long) end.tv_usec );
#endif
if ( dns ) {
for ( i = 0; i < ndns; i++ ) {
ber_memfree( dns[i] );
}
free( dns );
}
if ( creds ) {
for ( i = 0; i < ndns; i++ ) {
if ( creds[i].bv_val != nullstr ) {
ber_memfree( creds[i].bv_val );
}
}
free( creds );
}
return 0;
}
static GLboolean
do_test(const struct test_desc *test)
{
GLuint vs;
GLuint progs[2] = { 0 };
GLuint pipes[2];
GLuint bufs[NUM_BUFFERS];
float initial_xfb_buffer_contents[XFB_BUFFER_SIZE];
GLboolean pass = GL_TRUE;
int i;
int num_varyings = test->mode == NO_VARYINGS ? 0 : test->num_buffers;
GLint max_separate_attribs;
char* vstext_sep;
if (test->mode == USEPROGSTAGE_ACTIVE
|| test->mode == USEPROGSTAGE_NOACTIVE
|| test->mode == BIND_PIPELINE) {
piglit_require_extension("GL_ARB_separate_shader_objects");
if (piglit_get_gl_version() >= 32)
asprintf(&vstext_sep, vstext_sep_template, 150);
else
asprintf(&vstext_sep, vstext_sep_template, 110);
}
glGetIntegerv(GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS,
&max_separate_attribs);
printf("MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTIBS=%i\n",
max_separate_attribs);
printf("Compile vertex shader\n");
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext);
if (test->mode == USEPROGSTAGE_ACTIVE
|| test->mode == USEPROGSTAGE_NOACTIVE
|| test->mode == BIND_PIPELINE) {
/* Note, we can't use glCreateShaderProgramv because the setup
* of transform feedback must be done before linking
*/
vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vstext_sep);
progs[0] = glCreateProgram();
glProgramParameteri(progs[0], GL_PROGRAM_SEPARABLE, GL_TRUE);
glAttachShader(progs[0], vs);
} else if (test->mode == NOT_A_PROGRAM) {
printf("Create a program and then delete it\n");
progs[0] = glCreateProgram();
glDeleteProgram(progs[0]);
} else {
progs[0] = glCreateProgram();
glAttachShader(progs[0], vs);
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
printf("Setup transform feedback for %i varyings in %s mode\n",
num_varyings,
test->buffer_mode == GL_INTERLEAVED_ATTRIBS
? "interleaved" : "separate");
glTransformFeedbackVaryings(progs[0], num_varyings,
varyings, test->buffer_mode);
if (test->mode == NOT_A_PROGRAM) {
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
return pass;
}
printf("Link program\n");
glLinkProgram(progs[0]);
pass = piglit_link_check_status(progs[0]) && pass;
if (test->mode == USEPROGSTAGE_ACTIVE
|| test->mode == USEPROGSTAGE_NOACTIVE
|| test->mode == BIND_PIPELINE) {
printf("Create 2nd program for the pipeline\n");
progs[1] = glCreateShaderProgramv(GL_VERTEX_SHADER, 1,
(const char **) &vstext_sep);
pass = piglit_link_check_status(progs[1]) && pass;
}
if (test->mode == USEPROG_ACTIVE || test->mode == LINK_OTHER_ACTIVE) {
printf("Prepare 2nd program\n");
progs[1] = glCreateProgram();
glAttachShader(progs[1], vs);
}
if (test->mode == USEPROG_ACTIVE) {
printf("Link 2nd program\n");
glLinkProgram(progs[1]);
pass = piglit_link_check_status(progs[1]) && pass;
}
if (test->mode == USEPROGSTAGE_ACTIVE
|| test->mode == USEPROGSTAGE_NOACTIVE
|| test->mode == BIND_PIPELINE) {
printf("Use pipeline\n");
glGenProgramPipelines(2, pipes);
glUseProgramStages(pipes[0], GL_VERTEX_SHADER_BIT, progs[0]);
glUseProgramStages(pipes[1], GL_VERTEX_SHADER_BIT, progs[1]);
glBindProgramPipeline(pipes[0]);
} else if (test->mode == SKIP_USE_PROGRAM) {
printf("Don't use program\n");
} else {
printf("Use program\n");
glUseProgram(progs[0]);
}
printf("Prepare %i buffers\n", test->num_buffers);
glGenBuffers(test->num_buffers, bufs);
memset(initial_xfb_buffer_contents, 0,
sizeof(initial_xfb_buffer_contents));
for (i = 0; i < test->num_buffers; ++i) {
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, bufs[i]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER,
sizeof(initial_xfb_buffer_contents),
initial_xfb_buffer_contents, GL_STREAM_READ);
}
switch (test->mode) {
case BIND_MAX:
do_bind(test, bufs[0], max_separate_attribs);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
return pass;
case BIND_BAD_SIZE:
case BIND_BAD_OFFSET:
do_bind(test, bufs[0], 0);
pass = piglit_check_gl_error(GL_INVALID_VALUE) && pass;
return pass;
default:
break;
}
for (i = 0; i < test->num_buffers; ++i) {
if (test->mode == UNBOUND_BUFFER && i == test->param) {
printf("Don't bind buffer %i\n", i);
} else {
do_bind(test, bufs[i], i);
}
}
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
if (test->mode == END_INACTIVE) {
printf("EndTransformFeedback\n");
glEndTransformFeedback();
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
return pass;
}
printf("BeginTransformFeedback\n");
glBeginTransformFeedback(GL_POINTS);
switch (test->mode) {
case UNBOUND_BUFFER:
case NO_VARYINGS:
case SKIP_USE_PROGRAM:
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
default:
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
break;
}
switch (test->mode) {
case BEGIN_ACTIVE:
printf("BeginTransformFeedback\n");
glBeginTransformFeedback(GL_POINTS);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
case USEPROG_ACTIVE:
printf("Use new program\n");
glUseProgram(progs[1]);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
case LINK_CURRENT_ACTIVE:
printf("Link current program\n");
glLinkProgram(progs[0]);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
case LINK_OTHER_ACTIVE:
printf("Link 2nd program\n");
glLinkProgram(progs[1]);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
break;
case BIND_ACTIVE:
do_bind(test, bufs[0], 0);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
case USEPROGSTAGE_ACTIVE:
printf("Use new program stage\n");
glUseProgramStages(pipes[0], GL_VERTEX_SHADER_BIT, progs[1]);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
case USEPROGSTAGE_NOACTIVE:
printf("Use new program stage\n");
glUseProgramStages(pipes[1], GL_VERTEX_SHADER_BIT, progs[1]);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
break;
case BIND_PIPELINE:
printf("Bind a new pipeline\n");
glBindProgramPipeline(pipes[1]);
pass = piglit_check_gl_error(GL_INVALID_OPERATION) && pass;
break;
default:
break;
}
return pass;
}
int uds_ioctl(message *dev_m_in, message *dev_m_out)
{
int rc, minor;
#if DEBUG == 1
static int call_count = 0;
printf("(uds) [%d] uds_ioctl() call_count=%d\n", uds_minor(dev_m_in),
++call_count);
printf("Endpoint: 0x%x | Position 0x%x\n", dev_m_in->USER_ENDPT,
dev_m_in->POSITION);
#endif
minor = uds_minor(dev_m_in);
if (uds_fd_table[minor].state != UDS_INUSE) {
/* attempted to close a socket that hasn't been opened --
* something is very wrong :(
*/
uds_set_reply(dev_m_out, DEV_REVIVE, dev_m_in->USER_ENDPT,
(cp_grant_id_t) dev_m_in->IO_GRANT, EINVAL);
return EINVAL;
}
/* track the system call we are performing in case it gets cancelled */
uds_fd_table[minor].call_nr = dev_m_in->m_type;
uds_fd_table[minor].ioctl = dev_m_in->COUNT;
uds_fd_table[minor].syscall_done = 0;
/* setup select(2) framework */
uds_fd_table[minor].selecting = 0;
/* update the owner endpoint - yes it's really stored in POSITION */
uds_fd_table[minor].owner = dev_m_in->POSITION;
switch (dev_m_in->COUNT) { /* Handle the ioctl(2) command */
case NWIOSUDSCONN:
/* connect to a listening socket -- connect() */
rc = do_connect(dev_m_in, dev_m_out);
break;
case NWIOSUDSACCEPT:
/* accept an incoming connection -- accept() */
rc = do_accept(dev_m_in, dev_m_out);
break;
case NWIOSUDSBLOG:
/* set the backlog_size and put the socket into the
* listening state -- listen()
*/
rc = do_listen(dev_m_in, dev_m_out);
break;
case NWIOSUDSTYPE:
/* set the type for this socket (i.e.
* SOCK_STREAM, SOCK_DGRAM, etc) -- socket()
*/
rc = do_socket(dev_m_in, dev_m_out);
break;
case NWIOSUDSADDR:
/* set the address for this socket -- bind() */
rc = do_bind(dev_m_in, dev_m_out);
break;
case NWIOGUDSADDR:
/* get the address for this socket -- getsockname() */
rc = do_getsockname(dev_m_in, dev_m_out);
break;
case NWIOGUDSPADDR:
/* get the address for the peer -- getpeername() */
rc = do_getpeername(dev_m_in, dev_m_out);
break;
case NWIOSUDSSHUT:
/* shutdown a socket for reading, writing, or
* both -- shutdown()
*/
rc = do_shutdown(dev_m_in, dev_m_out);
break;
case NWIOSUDSPAIR:
/* connect two sockets -- socketpair() */
rc = do_socketpair(dev_m_in, dev_m_out);
break;
case NWIOGUDSSOTYPE:
/* get socket type -- getsockopt(SO_TYPE) */
rc = do_getsockopt_sotype(dev_m_in, dev_m_out);
break;
case NWIOGUDSPEERCRED:
/* get peer endpoint -- getsockopt(SO_PEERCRED) */
rc = do_getsockopt_peercred(dev_m_in, dev_m_out);
break;
case NWIOSUDSTADDR:
/* set target address -- sendto() */
rc = do_sendto(dev_m_in, dev_m_out);
break;
case NWIOGUDSFADDR:
/* get from address -- recvfrom() */
rc = do_recvfrom(dev_m_in, dev_m_out);
break;
case NWIOGUDSSNDBUF:
/* get the send buffer size -- getsockopt(SO_SNDBUF) */
rc = do_getsockopt_sndbuf(dev_m_in, dev_m_out);
break;
case NWIOSUDSSNDBUF:
/* set the send buffer size -- setsockopt(SO_SNDBUF) */
rc = do_setsockopt_sndbuf(dev_m_in, dev_m_out);
break;
case NWIOGUDSRCVBUF:
/* get the send buffer size -- getsockopt(SO_SNDBUF) */
rc = do_getsockopt_rcvbuf(dev_m_in, dev_m_out);
break;
case NWIOSUDSRCVBUF:
/* set the send buffer size -- setsockopt(SO_SNDBUF) */
rc = do_setsockopt_rcvbuf(dev_m_in, dev_m_out);
break;
case NWIOSUDSCTRL:
/* set the control data -- sendmsg() */
rc = do_sendmsg(dev_m_in, dev_m_out);
break;
case NWIOGUDSCTRL:
/* set the control data -- recvmsg() */
rc = do_recvmsg(dev_m_in, dev_m_out);
break;
default:
/* the IOCTL command is not valid for /dev/uds --
* this happens a lot and is normal. a lot of
* libc functions determine the socket type with
* IOCTLs. Any not for us simply get a EBADIOCTL
* response.
*/
rc = EBADIOCTL;
}
if (rc != SUSPEND)
uds_fd_table[minor].syscall_done = 1;
uds_set_reply(dev_m_out, DEV_REVIVE, dev_m_in->USER_ENDPT,
(cp_grant_id_t) dev_m_in->IO_GRANT, rc);
return rc;
}
int use_binder::bind(statement& st, int pos)
{
do_bind(st, pos);
return pos + 1;
}
/* Main program
** ------------
**
** Options:
** -v verify: turn trace output on to stdout
** -a addr Use different tcp port number and style
** -l file Log requests in ths file
** -r file Take rules from this file
** -R file Clear rules and take rules from file.
*/
int main ARGS2 (
int, argc,
char**, argv)
{
int status;
#ifdef RULES
int rulefiles = 0; /* Count number loaded */
#endif
char * addr = ""; /* default address */
WWW_TraceFlag = 0; /* diagnostics off by default */
#ifdef RULES
HTClearRules();
#endif
{
int a;
for (a=1; a<argc; a++) {
if (0==strcmp(argv[a], "-v")) {
WWW_TraceFlag = 1;
} else if (0==strcmp(argv[a], "-a")) {
if (++a<argc) addr = argv[a];
#ifdef RULES
} else if (0==strcmp(argv[a], "-r")) {
if (++a<argc) {
if (HTLoadRules(argv[a]) < 0) exit(-1);
rulefiles++;
}
} else if (0==strcmp(argv[a], "-R")) {
rulefiles++; /* Inhibit rule file load */
#endif
} else if (0==strcmp(argv[a], "-l")) {
if (++a<argc) {
logfile = fopen(argv[a], "a");
log_file_name = argv[a]; /* For WAIS code */
}
if (!logfile) {
fprintf(stderr,
"Can't open log file %s\n", argv[a]);
logfile = stderr;
}
/* Remove because an inet daemon process gets started every request.
fprintf(logfile, "\nhttpd: HTTP Daemon %s started.\n",
VERSION);
*/
} /*ifs */
} /* for */
} /* scope of a */
#ifdef RULES
if (rulefiles==0) { /* No mention */
if (HTLoadRules(RULE_FILE) < 0) exit(-1);
}
#endif
status = do_bind(addr);
if (status<0) {
fprintf(stderr, "Daemon: Bad setup: Can't bind and listen on port.\n");
fprintf(stderr, " (Possibly server already running, for example).\n");
exit(status);
}
status = server_loop();
if (status<0) {
/* printf("Error in server loop.\n"); not error if inetd-started*/
exit(status);
}
exit(0);
return 0; /* For gcc */
}
