static int
mock_server_cleanup(struct mock_server *mock)
{
int child_status;
const char *file;
struct stat sb;
dbus_connection_close(mock->client);
dbus_connection_unref(mock->client);
/* Tell the server thread to quit */
verify_eq (write(mock->sync_fds[0], "X", 1), 1);
/* Wait for the server child, it always returns mock */
verify_eq (waitpid(mock->pid, &child_status, 0), mock->pid);
verify_eq (child_status, 0);
file = strchr(mock->dbus_address, '/');
if (stat(file, &sb) == 0) {
verify_eq (unlink(file), 0);
}
verify_eq (rmdir(mock->temp_dir), 0);
return EOK;
}
static void
mock_server_child(void *data)
{
struct mock_server *mock = data;
struct tevent_context *loop;
struct sbus_connection *server;
bool stop_server = false;
TALLOC_CTX *ctx;
ctx = talloc_new(NULL);
loop = tevent_context_init(ctx);
verify_eq (sbus_new_server(ctx, loop, mock->dbus_address, false,
&server, on_accept_connection, mock), EOK);
tevent_add_fd(loop, ctx, mock->sync_fds[1], TEVENT_FD_READ,
on_sync_fd_written, &stop_server);
/* Synchronization point: test_dbus_setup_mock() should connect */
verify_eq (write(mock->sync_fds[1], "X", 1), 1);
/* Do the loop */
while(!stop_server) {
verify_eq (tevent_loop_once(loop), 0);
}
/* TODO: sbus doesn't support cleanup of a server */
talloc_free(ctx);
}
static int
on_accept_connection(struct sbus_connection *conn,
void *data)
{
struct mock_server *mock = data;
verify_eq (mock->init_fn(conn, mock->init_pvt_data), EOK);
/* Synchronization point: test_dbus_setup_mock() should return */
verify_eq (write(mock->sync_fds[1], "X", 1), 1);
return EOK;
}
struct DBusConnection *
test_dbus_setup_mock(TALLOC_CTX *mem_ctx,
struct tevent_context *loop,
sbus_server_conn_init_fn init_fn,
void *init_pvt_data)
{
struct mock_server *mock;
char dummy;
mock = talloc_zero(mem_ctx, struct mock_server);
talloc_set_destructor(mock, mock_server_cleanup);
mock->init_fn = init_fn;
mock->init_pvt_data = init_pvt_data;
mock->temp_dir = mkdtemp(talloc_strdup(mock, "/tmp/sssd-dbus-tests.XXXXXX"));
verify_neq (mock->temp_dir, NULL);
mock->dbus_address = talloc_asprintf(mock, "unix:path=%s/sbus", mock->temp_dir);
verify_neq (mock->dbus_address, NULL);
/* We use an fd pair as a synchronization device, integrates with tevent well */
verify_eq (socketpair(PF_LOCAL, SOCK_STREAM, 0, mock->sync_fds), 0);
/* Run the dbus server in a child process */
mock->pid = fork();
if (mock->pid == 0) {
mock_server_child(mock);
_exit(0);
}
verify_neq (mock->pid, -1);
/* Synchronization point: wait for sync point in mock_server_child */
verify_eq (read(mock->sync_fds[0], &dummy, 1), 1);
/* Open a shared D-BUS connection to the address */
mock->client = dbus_connection_open_private(mock->dbus_address, NULL);
verify_neq (mock->client, NULL);
/* Synchronization point: wait for sync point in on_accept_connection */
verify_eq (read(mock->sync_fds[0], &dummy, 1), 1);
return mock->client;
}
DBusMessage *
test_dbus_call_sync(DBusConnection *conn, const char *object_path,
const char *interface, const char *method,
DBusError *error, int first_arg_type, ...)
{
DBusMessage *message;
DBusMessage *reply;
va_list va;
message = dbus_message_new_method_call(NULL, object_path, interface, method);
verify_neq(message, NULL);
va_start(va, first_arg_type);
verify_eq(dbus_message_append_args_valist(message, first_arg_type, va), TRUE);
va_end(va);
reply = dbus_connection_send_with_reply_and_block(conn, message, -1, error);
dbus_message_unref(message);
return reply;
}
FC_FUNC( mpi_init_fort , MPI_INIT_FORT)
(int *f_MPI_COMM_WORLD,
int *f_MPI_ANY_SOURCE, int *f_MPI_ANY_TAG,
int *f_MPI_PROC_NULL, int *f_MPI_ROOT,
int *f_MPI_COMM_NULL, int *f_MPI_REQUEST_NULL,
int *f_MPI_GROUP_NULL, int *f_MPI_GROUP_EMPTY,
int *f_MPI_UNDEFINED,
int *f_MPI_MAX_ERROR_STRING,
int *f_MPI_MAX_PROCESSOR_NAME,
int *f_MPI_STATUS_SIZE,
int *f_MPI_SOURCE, int *f_MPI_TAG, int *f_MPI_ERROR,
int *f_status,
int *fsource, int *ftag, int *ferror,
int *f_MPI_INTEGER, void *fint1, void *fint2,
int *f_MPI_LOGICAL, void *flog1, void *flog2,
int *f_MPI_REAL, void *freal1, void *freal2,
int *f_MPI_DOUBLE_PRECISION,
void *fdub1, void *fdub2,
int *f_MPI_COMPLEX, void *fcomp1, void *fcomp2,
int *ierror)
{
int err;
int size;
int offset;
*ierror=MPI_Init(NULL,NULL);
err=0;
/*
* These 3 macros compare things from mpif.h (as passed in by the f_
* arguments) to the values in C (from #including mpi.h).
*
* Unfortunately, this kind of thing is done most easily in a nasty
* looking macto.
*
*/
/*
* verify_eq
* compare value of constants in C and fortran
* i.e. compare *f_<name> to <name>
*/
#define verify_eq(name) \
if (*f_##name != name) \
{ fprintf(stderr,"mpi-serial: mpi_init_fort: %s not consistant " \
"between mpif.h (%d) and mpi.h (%d)\n",\
#name,*f_##name,name); \
err=1; }
#define verify_eq_warn(name) \
if (*f_##name != name) \
{ fprintf(stderr,"mpi-serial: mpi_init_fort: warning: %s not consistant " \
"between mpif.h (%d) and mpi.h (%d)\n",\
#name,*f_##name,name); \
}
/*
* verify_size
* verify that the type name in fortran has the correct
* value (i.e. the size of that data type).
* Determine size by subtracting the pointer values of two
* consecutive array locations.
*/
#define verify_size(name,p1,p2) \
if ( (size=((char *)(p2) - (char *)(p1))) != *f_##name ) \
{ fprintf(stderr,"mpi-serial: mpi_init_fort: mpif.h %s (%d) " \
"does not match actual fortran size (%d)\n", \
#name,*f_##name,size); \
err=1; }
/*
* verify_field
* check the struct member offsets for MPI_Status vs. the
* fortan integer array offsets. E.g. the location of
* status->MPI_SOURCE should be the same as STATUS(MPI_SOURCE)
*/
#define verify_field(name) \
{ offset= (char *)&((MPI_Status *)f_status)->name - (char *)f_status; \
if ( offset != (*f_##name-1)*sizeof(int) ) \
{ fprintf(stderr,"mpi-serial: mpi_init_fort: mpif.h %s (%d) (%d bytes) " \
"is inconsistant w/offset in MPI_Status (%d bytes)\n", \
#name,*f_##name,(*f_##name-1)*sizeof(int),offset); \
err=1; }}
verify_eq(MPI_COMM_WORLD);
verify_eq(MPI_ANY_SOURCE);
verify_eq(MPI_ANY_TAG);
verify_eq(MPI_PROC_NULL);
verify_eq(MPI_ROOT);
verify_eq(MPI_COMM_NULL);
verify_eq(MPI_REQUEST_NULL);
verify_eq(MPI_GROUP_NULL);
verify_eq(MPI_GROUP_EMPTY);
verify_eq(MPI_UNDEFINED);
verify_eq(MPI_MAX_ERROR_STRING);
verify_eq(MPI_MAX_PROCESSOR_NAME);
verify_eq(MPI_STATUS_SIZE);
verify_field(MPI_SOURCE);
verify_field(MPI_TAG);
verify_field(MPI_ERROR);
verify_eq(MPI_INTEGER);
verify_size(MPI_INTEGER,fint1,fint2);
verify_size(MPI_LOGICAL,flog1,flog2);
verify_eq_warn(MPI_REAL);
verify_size(MPI_REAL,freal1,freal2);
verify_eq(MPI_DOUBLE_PRECISION);
verify_size(MPI_DOUBLE_PRECISION,fdub1,fdub2);
verify_size(MPI_COMPLEX,fcomp1,fcomp2);
if (err)
abort();
}
