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; }