grpc_transport *grpc_create_chttp2_transport(
const grpc_channel_args *channel_args, grpc_endpoint *ep, grpc_mdctx *mdctx,
int is_client) {
grpc_chttp2_transport *t = gpr_malloc(sizeof(grpc_chttp2_transport));
init_transport(t, channel_args, ep, mdctx, is_client);
return &t->base;
}
void grpc_create_chttp2_transport(grpc_transport_setup_callback setup,
void *arg,
const grpc_channel_args *channel_args,
grpc_endpoint *ep, gpr_slice *slices,
size_t nslices, grpc_mdctx *mdctx,
int is_client) {
grpc_chttp2_transport *t = gpr_malloc(sizeof(grpc_chttp2_transport));
init_transport(t, setup, arg, channel_args, ep, slices, nslices, mdctx,
is_client);
}
/* this should be called once at beginning to setup everything */
int
nfs_init(struct ip_addr server)
{
mapping_t map;
init_transport(server);
/* make and RPC to get mountd info */
map.prog = MNT_NUMBER;
map.vers = MNT_VERSION;
map.prot = IPPROTO_UDP;
if (map_getport(&map) == 0) {
debug("mountd port number is %d\n", map.port);
mount_port = map.port;
if (mount_port == 0) {
printf("!!! Mount port invalid\n");
return 1;
}
} else {
printf("!!! Error getting mountd port number\n");
return 1;
}
/* make and RPC to get nfs info */
map.prog = NFS_NUMBER;
map.vers = NFS_VERSION;
map.prot = IPPROTO_UDP;
if(map_getport(&map) == 0) {
debug( "nfs port number is %d\n", map.port );
nfs_port = map.port;
} else {
if (nfs_port == 0) {
printf("!!! Invalid NFS port\n");
return 1;
}
debug( "Error getting NFS port number\n" );
return 1;
}
return 0;
}
/**
@brief Allocate and initialize a transport_client.
@param server Domain name where the Jabber server resides.
@param port Port used for connecting to Jabber (0 if using UNIX domain socket).
@param unix_path Name of Jabber's socket in file system (if using UNIX domain socket).
@param component Boolean; true if we're a Jabber component.
@return A pointer to a newly created transport_client.
Create a transport_client with a transport_session and an empty message queue (but don't
open a connection yet). Install a callback function in the transport_session to enqueue
incoming messages.
The calling code is responsible for freeing the transport_client by calling client_free().
*/
transport_client* client_init( const char* server, int port, const char* unix_path, int component ) {
if(server == NULL) return NULL;
/* build and clear the client object */
transport_client* client = safe_malloc( sizeof( transport_client) );
/* start with an empty message queue */
client->msg_q_head = NULL;
client->msg_q_tail = NULL;
/* build the session */
client->session = init_transport( server, port, unix_path, client, component );
client->session->message_callback = client_message_handler;
client->error = 0;
client->host = strdup(server);
client->xmpp_id = NULL;
return client;
}
/*
* Main thread. Sits on the message queue and waits for something to do.
*
* The transport thread for the ibm will issue a delayed request for
* requests supporting delayed requests. Otherwise will issue the request
* and wait for response.
*/
void *
transport_thread(
void *vxport)
{
robo_event_t *event;
xport_state_t *transport = (xport_state_t *)vxport;
struct sigaction sig_action;
sigset_t signal_set, full_block_set;
sigfillset(&full_block_set);
sigemptyset(&signal_set); /* signals to except. */
sigaddset(&signal_set, SIGCHLD);
mutex_lock(&transport->mutex); /* wait for go */
mutex_unlock(&transport->mutex);
l_mess = transport->library->un->dis_mes[DIS_MES_NORM];
lc_mess = transport->library->un->dis_mes[DIS_MES_CRIT];
thr_sigsetmask(SIG_SETMASK, &full_block_set, NULL);
memset(&sig_action, 0, sizeof (struct sigaction));
(void) sigemptyset(&sig_action.sa_mask);
sig_action.sa_flags = SA_RESTART;
sig_action.sa_handler = SIG_DFL;
(void) sigaction(SIGCHLD, &sig_action, NULL);
for (;;) {
mutex_lock(&transport->list_mutex);
if (transport->active_count == 0)
cond_wait(&transport->list_condit,
&transport->list_mutex);
if (transport->active_count == 0) { /* check to make sure */
mutex_unlock(&transport->list_mutex);
continue;
}
event = transport->first;
transport->first = unlink_list(event);
transport->active_count--;
mutex_unlock(&transport->list_mutex);
ETRACE((LOG_NOTICE, "EvTr %#x(%#x) - \n",
event, (event->type == EVENT_TYPE_MESS) ?
event->request.message.command :
event->request.internal.command));
event->next = NULL;
/* Everyone must take care of disposing of the event */
switch (event->type) {
case EVENT_TYPE_INTERNAL:
switch (event->request.internal.command) {
case ROBOT_INTRL_LOAD_MEDIA:
if (transport->library->un->state <= DEV_IDLE) {
load(transport->library, event);
} else {
disp_of_event(transport->library,
event, EINVAL);
}
break;
case ROBOT_INTRL_FORCE_MEDIA:
force(transport->library, event);
break;
case ROBOT_INTRL_DISMOUNT_MEDIA:
dismount(transport->library, event);
break;
case ROBOT_INTRL_INIT:
init_transport(transport);
disp_of_event(transport->library, event, 0);
break;
case ROBOT_INTRL_VIEW_DATABASE:
view(transport->library, event);
break;
case ROBOT_INTRL_QUERY_DRIVE:
query_drv(transport->library, event);
break;
case ROBOT_INTRL_QUERY_LIBRARY:
query_lib(transport->library, event);
break;
case ROBOT_INTRL_SET_CATEGORY:
set_category(transport->library, event);
break;
case ROBOT_INTRL_SHUTDOWN:
transport->thread = (thread_t)- 1;
thr_exit((void *)NULL);
break;
default:
disp_of_event(transport->library, event,
EINVAL);
break;
}
break;
case EVENT_TYPE_MESS:
if (event->request.message.magic != MESSAGE_MAGIC) {
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:bad magic: %s:%d.\n",
__FILE__, __LINE__);
disp_of_event(transport->library, event,
EINVAL);
break;
}
switch (event->request.message.command) {
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:msq_bad: %s:%d.\n",
__FILE__, __LINE__);
disp_of_event(transport->library, event,
EINVAL);
break;
}
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:event_bad: %s:%d.\n",
__FILE__, __LINE__);
disp_of_event(transport->library, event, EINVAL);
break;
}
}
}
/*
* Main thread. Sits on the message queue and waits for something to do.
*/
void *
transport_thread(
void *vxport)
{
int exit_status = 0, err;
robo_event_t *event;
xport_state_t *transport = (xport_state_t *)vxport;
int is_api = IS_GENERIC_API(transport->library->un->type);
dev_ent_t *un = transport->library->un;
mutex_lock(&transport->mutex); /* wait for go */
mutex_unlock(&transport->mutex);
for (;;) {
mutex_lock(&transport->list_mutex);
if (transport->active_count == 0)
cond_wait(&transport->list_condit,
&transport->list_mutex);
if (transport->active_count == 0) { /* check to make sure */
mutex_unlock(&transport->list_mutex);
continue;
}
event = transport->first;
transport->first = unlink_list(event);
transport->active_count--;
mutex_unlock(&transport->list_mutex);
ETRACE((LOG_NOTICE, "EvTr %#x(%#x) -",
event, (event->type == EVENT_TYPE_MESS) ?
event->request.message.command :
event->request.internal.command));
err = 0;
switch (event->type) {
case EVENT_TYPE_INTERNAL:
switch (event->request.internal.command) {
case ROBOT_INTRL_MOVE_MEDIA:
if (is_api == TRUE) {
err = EINVAL;
break;
} else {
if (un->state <= DEV_IDLE) {
err = move(transport->library,
event);
} else {
err = EINVAL;
}
}
break;
case ROBOT_INTRL_EXCH_MEDIA:
if (is_api == TRUE) {
err = EINVAL;
break;
} else {
if (un->state <= DEV_IDLE) {
err = exchange(
transport->library, event);
} else {
err = EINVAL;
}
}
break;
case ROBOT_INTRL_INIT:
init_transport(transport);
if (is_api == TRUE) {
disp_of_event(transport->library,
event, 0);
}
break;
case ROBOT_INTRL_SHUTDOWN:
transport->thread = (thread_t)- 1;
thr_exit(&exit_status);
break;
case ROBOT_INTRL_LOAD_MEDIA:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_load_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_FORCE_MEDIA:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_force_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_DISMOUNT_MEDIA:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_dismount_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_VIEW_DATABASE:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_view_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_DRIVE_ACCESS:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_drive_access_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_QUERY_DRIVE:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_query_drive_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
case ROBOT_INTRL_GET_SIDE_INFO:
if (is_api == FALSE) {
err = EINVAL;
break;
}
event->next = (robo_event_t *)
transport->library;
err = thr_create(NULL, MD_THR_STK,
api_getsideinfo_command,
(void *)event, THR_DETACHED, NULL);
if (err)
DevLog(DL_ERR(6038),
event->request.internal.command,
err);
break;
default:
err = EINVAL;
break;
}
break;
case EVENT_TYPE_MESS:
if (event->request.message.magic != MESSAGE_MAGIC) {
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:bad magic: %s:%d.",
__FILE__, __LINE__);
break;
}
switch (event->request.message.command) {
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:msq_bad: %s:%d.",
__FILE__, __LINE__);
err = EINVAL;
break;
}
default:
if (DBG_LVL(SAM_DBG_DEBUG))
sam_syslog(LOG_DEBUG,
"xpt_thr:event_bad: %s:%d.",
__FILE__, __LINE__);
err = EINVAL;
break;
}
if (is_api == FALSE) {
disp_of_event(transport->library, event, err);
} else if (err) {
/* call disp_of_event only if an error on grau */
if (err < 0)
err = errno;
disp_of_event(transport->library, event, err);
}
}
}
Reader::Reader(::DDS::DomainParticipant_ptr dp,
int history_depth,
int max_samples_per_instance)
: max_samples_per_instance_(max_samples_per_instance),
dp_(::DDS::DomainParticipant::_duplicate (dp))
{
sub_ = dp->create_subscriber(SUBSCRIBER_QOS_DEFAULT,
::DDS::SubscriberListener::_nil());
if (CORBA::is_nil (sub_.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_subscriber failed.\n")));
throw TestException() ;
}
// Initialize the transport
if (0 != init_transport() )
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) init_transport failed!\n")));
throw TestException() ;
}
// Attach the subscriber to the transport.
TAO::DCPS::SubscriberImpl* sub_impl
= TAO::DCPS::reference_to_servant<TAO::DCPS::SubscriberImpl> (sub_.in ());
if (0 == sub_impl)
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) Failed to obtain servant ::TAO::DCPS::SubscriberImpl\n")));
throw TestException() ;
}
sub_impl->attach_transport(reader_transport_impl.in());
::DDS::TopicDescription_var description =
dp->lookup_topicdescription(MY_TOPIC);
if (CORBA::is_nil (description.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) lookup_topicdescription failed.\n")));
throw TestException() ;
}
::DDS::DataReaderQos dr_qos;
sub_->get_default_datareader_qos (dr_qos);
dr_qos.history.depth = history_depth ;
dr_qos.resource_limits.max_samples_per_instance =
max_samples_per_instance ;
dr_qos.liveliness.lease_duration.sec =
static_cast<CORBA::Long> (max_blocking_time.sec ());
dr_qos.liveliness.lease_duration.nanosec = 0 ;
::DDS::DataReaderListener_var drl
= ::TAO::DCPS::servant_to_reference(&drl_servant_);
::DDS::DataReader_var dr = sub_->create_datareader(description.in (),
dr_qos,
// ::DDS::DataReaderListener::_nil()
drl.in ());
if (CORBA::is_nil (dr.in ()))
{
ACE_ERROR ((LM_ERROR,
ACE_TEXT("(%P|%t) create_datareader failed.\n")));
throw TestException() ;
}
}
int
main(int argc, char *argv[])
{
struct netconfig *nconf;
void *nc_handle; /* Net config handle */
struct rlimit rl;
int maxrec = RPC_MAXDATASIZE;
parseargs(argc, argv);
/* Check that another rpcbind isn't already running. */
if ((rpcbindlockfd = (open(RPCBINDDLOCK,
O_RDONLY|O_CREAT, 0444))) == -1)
err(1, "%s", RPCBINDDLOCK);
if(flock(rpcbindlockfd, LOCK_EX|LOCK_NB) == -1 && errno == EWOULDBLOCK)
errx(1, "another rpcbind is already running. Aborting");
getrlimit(RLIMIT_NOFILE, &rl);
if (rl.rlim_cur < 128) {
if (rl.rlim_max <= 128)
rl.rlim_cur = rl.rlim_max;
else
rl.rlim_cur = 128;
setrlimit(RLIMIT_NOFILE, &rl);
}
openlog("rpcbind", LOG_CONS, LOG_DAEMON);
if (geteuid()) { /* This command allowed only to root */
fprintf(stderr, "Sorry. You are not superuser\n");
exit(1);
}
/*
* Make sure we use the local service file
* for service lookkups
*/
__nss_configure_lookup("services", "files");
nc_handle = setnetconfig(); /* open netconfig file */
if (nc_handle == NULL) {
syslog(LOG_ERR, "could not read /etc/netconfig");
exit(1);
}
nconf = getnetconfigent("local");
if (nconf == NULL)
nconf = getnetconfigent("unix");
if (nconf == NULL) {
syslog(LOG_ERR, "%s: can't find local transport\n", argv[0]);
exit(1);
}
rpc_control(RPC_SVC_CONNMAXREC_SET, &maxrec);
init_transport(nconf);
while ((nconf = getnetconfig(nc_handle))) {
if (nconf->nc_flag & NC_VISIBLE)
init_transport(nconf);
}
endnetconfig(nc_handle);
#ifdef PORTMAP
if (!udptrans)
udptrans = "";
if (!tcptrans)
tcptrans = "";
#endif
/* catch the usual termination signals for graceful exit */
(void) signal(SIGCHLD, reap);
(void) signal(SIGINT, terminate);
(void) signal(SIGTERM, terminate);
(void) signal(SIGQUIT, terminate);
/* ignore others that could get sent */
(void) signal(SIGPIPE, SIG_IGN);
(void) signal(SIGHUP, SIG_IGN);
(void) signal(SIGUSR1, SIG_IGN);
(void) signal(SIGUSR2, SIG_IGN);
if (debugging) {
#ifdef RPCBIND_DEBUG
printf("rpcbind debugging enabled.");
if (doabort) {
printf(" Will abort on errors!\n");
} else {
printf("\n");
}
#endif
} else {
if (daemon(0, 0))
err(1, "fork failed");
}
if (runasdaemon || rpcbinduser) {
struct passwd *p;
char *id = runasdaemon ? RUN_AS : rpcbinduser;
/*
* Make sure we use the local password file
* for these lookups.
*/
__nss_configure_lookup("passwd", "files");
if((p = getpwnam(id)) == NULL) {
syslog(LOG_ERR, "cannot get uid of '%s': %m", id);
exit(1);
}
if (setgid(p->pw_gid) == -1) {
syslog(LOG_ERR, "setgid to '%s' (%d) failed: %m", id, p->pw_gid);
exit(1);
}
if (setuid(p->pw_uid) == -1) {
syslog(LOG_ERR, "setuid to '%s' (%d) failed: %m", id, p->pw_uid);
exit(1);
}
}
#ifdef WARMSTART
if (warmstart) {
read_warmstart();
}
#endif
network_init();
my_svc_run();
syslog(LOG_ERR, "svc_run returned unexpectedly");
rpcbind_abort();
/* NOTREACHED */
return 0;
}
int
rpcbind_main(void *arg)
#endif
{
struct netconfig *nconf;
void *nc_handle; /* Net config handle */
struct rlimit rl;
int maxrec = RPC_MAXDATASIZE;
#ifdef RPCBIND_RUMP
svc_fdset_init(SVC_FDSET_MT);
#else
parseargs(argc, argv);
#endif
if (getrlimit(RLIMIT_NOFILE, &rl) == -1)
err(EXIT_FAILURE, "getrlimit(RLIMIT_NOFILE)");
if (rl.rlim_cur < 128) {
if (rl.rlim_max <= 128)
rl.rlim_cur = rl.rlim_max;
else
rl.rlim_cur = 128;
if (setrlimit(RLIMIT_NOFILE, &rl) < 0)
err(EXIT_FAILURE, "setrlimit(RLIMIT_NOFILE)");
}
nc_handle = setnetconfig(); /* open netconfig file */
if (nc_handle == NULL)
errx(EXIT_FAILURE, "could not read /etc/netconfig");
#ifdef PORTMAP
udptrans = "";
tcptrans = "";
#endif
nconf = getnetconfigent("local");
if (nconf == NULL)
errx(EXIT_FAILURE, "can't find local transport");
rpc_control(RPC_SVC_CONNMAXREC_SET, &maxrec);
init_transport(nconf);
while ((nconf = getnetconfig(nc_handle))) {
if (nconf->nc_flag & NC_VISIBLE)
init_transport(nconf);
}
endnetconfig(nc_handle);
/* catch the usual termination signals for graceful exit */
(void) signal(SIGCHLD, reap);
(void) signal(SIGINT, terminate);
(void) signal(SIGTERM, terminate);
(void) signal(SIGQUIT, terminate);
/* ignore others that could get sent */
(void) signal(SIGPIPE, SIG_IGN);
#ifndef RPCBIND_RUMP
(void) signal(SIGHUP, SIG_IGN);
#endif
(void) signal(SIGUSR1, SIG_IGN);
(void) signal(SIGUSR2, SIG_IGN);
#ifdef WARMSTART
if (warmstart) {
read_warmstart();
}
#endif
if (debugging) {
printf("rpcbind debugging enabled.");
if (doabort) {
printf(" Will abort on errors!\n");
} else {
printf("\n");
}
} else {
if (daemon(0, 0))
err(EXIT_FAILURE, "fork failed");
}
openlog("rpcbind", 0, LOG_DAEMON);
pidfile(NULL);
if (runasdaemon) {
struct passwd *p;
if((p = getpwnam(RUN_AS)) == NULL) {
syslog(LOG_ERR, "cannot get uid of daemon: %m");
exit(EXIT_FAILURE);
}
if (setuid(p->pw_uid) == -1) {
syslog(LOG_ERR, "setuid to daemon failed: %m");
exit(EXIT_FAILURE);
}
}
network_init();
#ifdef RPCBIND_RUMP
sem_post(&gensem);
#endif
my_svc_run();
syslog(LOG_ERR, "svc_run returned unexpectedly");
rpcbind_abort();
/* NOTREACHED */
return EXIT_SUCCESS;
}
int main(int argc, char* argv[]){
int i=0, nRow, nCol=NY+2, myid, nProcs, NlocX, rest;
float *temp, *temp_new;
double tinit, tstart, tstop, tio;
char filename_0[25];
char filename_1[25];
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &myid);
MPI_Comm_size(MPI_COMM_WORLD, &nProcs);
NlocX = NY / nProcs;
rest = NY % nProcs;
if(myid == nProcs - 1)
NlocX += rest;
for(i=0;i<25;i++){
filename_0[i] = 0;
filename_1[i] = 0;
}
sprintf(filename_0, "transport-mpi_%d.dat\n", myid);
printf("I am process %d and my dimension is %d x %d. Filename will be %s\n", myid, NlocX, NY, filename);
printf("-----------------------\n");
nRow = NlocX+2;
temp = (float *) malloc (nRow*nCol*sizeof(float));
temp_new = (float *) malloc (nRow*nCol*sizeof(float));
if(0 && myid == 0){
tinit = seconds();
temp = (float *) malloc (nRow*nCol*sizeof(float));
temp_new = (float *) malloc (nRow*nCol*sizeof(float));
init_transport(temp, myid);
update_boundaries_PBC(temp);
#ifdef __DEBUG
float before=summa(NX, NY, temp);
printf(" sum temp before: %f\n",before);
#endif
tstop = seconds();
printf("\ninitialization done\n");
printf("cpu time in seconds %.3g\n", tstop-tinit );
tstart = seconds();
save_gnuplot("transport-serial.dat", temp);
tstop = seconds();
tio = tstop - tstart;
tstart = seconds();
for(i=1;i<=STEPS;++i) {
evolve(DT, temp, temp_new);
update_boundaries_PBC(temp);
}
tstop = seconds();
printf("\nevolution done\n");
printf("cpu time in seconds %.3g\n", tstop-tstart);
#ifdef __DEBUG
float after=summa(NX, NY, temp);
printf(" sum temp after: %f\n",after);
#endif
tstart = seconds();
save_gnuplot("transport-end-serial.dat", temp);
tstop = seconds();
tio = tio + tstop - tstart;
printf("\nsave_data done\n");
printf("IO time in seconds %.3g\n", tio);
printf("\ntotal cpu time in seconds %.3g\n", tstop - tinit);
free(temp);
free(temp_new);
}
MPI_Finalize();
return 0;
}
