int main(int argc, char *argv[])
{
int c;
char *hostname;
char *portname;
char *check;
int B_flag, P_flag, s_flag;
char *t_arg;
(progname=strrchr(argv[0],'/')) ? progname++ : (progname=argv[0]);
B_flag= 0;
P_flag= 0;
s_flag= 0;
t_arg= NULL;
while (c= getopt(argc, argv, "BPst:?"), c != -1)
{
switch(c)
{
case 'B': B_flag= 1; break;
case 'P': P_flag= 1; break;
case 's': s_flag= 1; break;
case 't': t_arg= optarg; break;
case '?': usage();
default:
fatal("getopt failed: '%c'", c);
}
}
if (t_arg)
{
timeout= strtol(t_arg, &check, 0);
if (check[0] != '\0')
fatal("unable to parse timeout '%s'\n", t_arg);
if (timeout <= 0)
fatal("bad timeout '%d'\n", timeout);
}
else
timeout= 0;
if (optind+2 != argc)
usage();
hostname= argv[optind++];
portname= argv[optind++];
bulk= B_flag;
push= P_flag;
stdout_issocket= s_flag;
do_conn(hostname, portname);
/* XXX */
if (timeout)
{
signal(SIGALRM, alrm_io);
alarm(timeout);
}
fullduplex();
exit(0);
}
int pa__init(pa_module * m)
{
struct userdata *u;
pa_sample_spec ss;
pa_channel_map map;
pa_modargs *ma;
struct pollfd *pollfd;
pa_sink_new_data data_sink;
pa_source_new_data data_source;
pa_assert(m);
pa_log("vchan module loading");
if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
pa_log("Failed to parse module arguments.");
goto fail;
}
ss = m->core->default_sample_spec;
map = m->core->default_channel_map;
if (pa_modargs_get_sample_spec_and_channel_map
(ma, &ss, &map, PA_CHANNEL_MAP_DEFAULT) < 0) {
pa_log
("Invalid sample format specification or channel map");
goto fail;
}
u = pa_xnew0(struct userdata, 1);
u->core = m->core;
u->module = m;
m->userdata = u;
pa_memchunk_reset(&u->memchunk_sink);
pa_memchunk_reset(&u->memchunk_source);
u->rtpoll = pa_rtpoll_new();
pa_thread_mq_init(&u->thread_mq, m->core->mainloop, u->rtpoll);
if ((do_conn(u)) < 0) {
pa_log("get_early_allocated_vchan: %s",
pa_cstrerror(errno));
goto fail;
}
/* SINK preparation */
pa_sink_new_data_init(&data_sink);
data_sink.driver = __FILE__;
data_sink.module = m;
pa_sink_new_data_set_name(&data_sink,
pa_modargs_get_value(ma,
"sink_name",
DEFAULT_SINK_NAME));
pa_proplist_sets(data_sink.proplist,
PA_PROP_DEVICE_STRING, DEFAULT_SINK_NAME);
pa_proplist_setf(data_sink.proplist,
PA_PROP_DEVICE_DESCRIPTION,
"Qubes VCHAN sink");
pa_sink_new_data_set_sample_spec(&data_sink, &ss);
pa_sink_new_data_set_channel_map(&data_sink, &map);
if (pa_modargs_get_proplist
(ma, "sink_properties", data_sink.proplist, PA_UPDATE_REPLACE) < 0) {
pa_log("Invalid properties");
pa_sink_new_data_done(&data_sink);
goto fail;
}
u->sink = pa_sink_new(m->core, &data_sink, PA_SINK_LATENCY);
pa_sink_new_data_done(&data_sink);
if (!u->sink) {
pa_log("Failed to create sink.");
goto fail;
}
u->sink->parent.process_msg = sink_process_msg;
u->sink->userdata = u;
pa_sink_set_asyncmsgq(u->sink, u->thread_mq.inq);
pa_sink_set_rtpoll(u->sink, u->rtpoll);
pa_sink_set_max_request(u->sink, VCHAN_BUF);
pa_sink_set_fixed_latency(u->sink,
pa_bytes_to_usec
(VCHAN_BUF,
&u->sink->sample_spec));
u->play_rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
pollfd = pa_rtpoll_item_get_pollfd(u->play_rtpoll_item, NULL);
pollfd->fd = libvchan_fd_for_select(u->play_ctrl);
pollfd->events = POLLIN;
pollfd->revents = 0;
/* SOURCE preparation */
pa_source_new_data_init(&data_source);
data_source.driver = __FILE__;
data_source.module = m;
pa_source_new_data_set_name(&data_source, pa_modargs_get_value(ma, "source_name", DEFAULT_SOURCE_NAME));
pa_proplist_sets(data_source.proplist, PA_PROP_DEVICE_STRING, DEFAULT_SOURCE_NAME);
pa_proplist_setf(data_source.proplist, PA_PROP_DEVICE_DESCRIPTION, "Qubes VCHAN source");
pa_source_new_data_set_sample_spec(&data_source, &ss);
pa_source_new_data_set_channel_map(&data_source, &map);
if (pa_modargs_get_proplist(ma, "source_properties", data_source.proplist, PA_UPDATE_REPLACE) < 0) {
pa_log("Invalid properties");
pa_source_new_data_done(&data_source);
goto fail;
}
u->source = pa_source_new(m->core, &data_source, PA_SOURCE_LATENCY);
pa_source_new_data_done(&data_source);
if (!u->source) {
pa_log("Failed to create source.");
goto fail;
}
u->source->parent.process_msg = source_process_msg;
u->source->userdata = u;
pa_source_set_asyncmsgq(u->source, u->thread_mq.inq);
pa_source_set_rtpoll(u->source, u->rtpoll);
pa_source_set_fixed_latency(u->source, pa_bytes_to_usec(PIPE_BUF, &u->source->sample_spec));
u->rec_rtpoll_item = pa_rtpoll_item_new(u->rtpoll, PA_RTPOLL_NEVER, 1);
pollfd = pa_rtpoll_item_get_pollfd(u->rec_rtpoll_item, NULL);
pollfd->fd = libvchan_fd_for_select(u->rec_ctrl);
pollfd->events = POLLIN;
pollfd->revents = 0;
#if PA_CHECK_VERSION(0,9,22)
if (!(u->thread = pa_thread_new("vchan-sink", thread_func, u))) {
#else
if (!(u->thread = pa_thread_new(thread_func, u))) {
#endif
pa_log("Failed to create thread.");
goto fail;
}
pa_sink_put(u->sink);
pa_source_put(u->source);
pa_modargs_free(ma);
return 0;
fail:
if (ma)
pa_modargs_free(ma);
pa__done(m);
return -1;
}
int pa__get_n_used(pa_module * m)
{
struct userdata *u;
pa_assert(m);
pa_assert_se(u = m->userdata);
return pa_sink_linked_by(u->sink);
}
void pa__done(pa_module * m)
{
struct userdata *u;
pa_assert(m);
if (!(u = m->userdata))
return;
if (u->sink)
pa_sink_unlink(u->sink);
if (u->source)
pa_source_unlink(u->source);
if (u->thread) {
pa_asyncmsgq_send(u->thread_mq.inq, NULL,
PA_MESSAGE_SHUTDOWN, NULL, 0, NULL);
pa_thread_free(u->thread);
}
pa_thread_mq_done(&u->thread_mq);
if (u->sink)
pa_sink_unref(u->sink);
if (u->source)
pa_source_unref(u->source);
if (u->memchunk_sink.memblock)
pa_memblock_unref(u->memchunk_sink.memblock);
if (u->memchunk_source.memblock)
pa_memblock_unref(u->memchunk_source.memblock);
if (u->play_rtpoll_item)
pa_rtpoll_item_free(u->play_rtpoll_item);
if (u->rec_rtpoll_item)
pa_rtpoll_item_free(u->rec_rtpoll_item);
if (u->rtpoll)
pa_rtpoll_free(u->rtpoll);
if (u->play_ctrl)
libvchan_close(u->play_ctrl);
if (u->rec_ctrl)
libvchan_close(u->rec_ctrl);
pa_xfree(u);
}
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 );
}
