/* member functions for ServiceList class */ void add_service(struct ServiceList* sl, char *fun, char *serv){ if(sl->head == NULL){ sl->head = new_service(fun, serv); sl->tail = sl->head; } else if(sl->head->next == NULL){ sl->head->next = new_service(fun, serv); sl->tail = sl->head->next; sl->tail->pre = sl->head; } else{ sl->tail->next = new_service(fun, serv); sl->tail->next->pre = sl->tail; sl->tail = sl->tail->next; } }
void mlt_repository_register( mlt_repository self, mlt_service_type service_type, const char *service, mlt_register_callback symbol ) { // Add the entry point to the corresponding service list switch ( service_type ) { case consumer_type: mlt_properties_set_data( self->consumers, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL ); break; case filter_type: mlt_properties_set_data( self->filters, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL ); break; case producer_type: mlt_properties_set_data( self->producers, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL ); break; case transition_type: mlt_properties_set_data( self->transitions, service, new_service( symbol ), 0, ( mlt_destructor )mlt_properties_close, NULL ); break; default: break; } }
int main(int argc,char **argv) { setup_signal_handler(); InitNetSystem(); struct netservice *tcpclient = new_service(); tcpclient->connect(tcpclient,"127.0.0.1",8010,(void*)tcpclient,on_connect,10000); while(!stop){ tcpclient->loop(tcpclient,50); } destroy_service(&tcpclient); CleanNetSystem(); return 0; }
/* add all services found in the PAT */ static void pat_scan_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end; int sid, pmt_pid; char *provider_name, *name; char buf[256]; #ifdef DEBUG_SI printf("PAT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != PAT_TID) return; for(;;) { sid = get16(&p, p_end); if (sid < 0) break; pmt_pid = get16(&p, p_end) & 0x1fff; if (pmt_pid < 0) break; #ifdef DEBUG_SI printf("sid=0x%x pid=0x%x\n", sid, pmt_pid); #endif if (sid == 0x0000) { /* NIT info */ } else { /* add the service with a dummy name */ snprintf(buf, sizeof(buf), "Service %x\n", sid); name = av_strdup(buf); provider_name = av_strdup(""); if (name && provider_name) { new_service(ts, sid, provider_name, name); } else { av_freep(&name); av_freep(&provider_name); } } } ts->stop_parse = 1; /* remove filter */ mpegts_close_filter(ts, ts->pat_filter); ts->pat_filter = NULL; }
CNetService SNetCacheAPIImpl::FindOrCreateService(const string& service_name) { pair<TNetServiceByName::iterator, bool> loc(m_ServicesFromKeys.insert( TNetServiceByName::value_type(service_name, CNetService()))); if (!loc.second) return loc.first->second; CNetService new_service(new SNetServiceImpl(service_name, m_Service)); loc.first->second = new_service; return new_service; }
/* * kern_return_t * bootstrap_create_service(mach_port_t bootstrap_port, * name_t service_name, * mach_port_t *service_port) * * Creates a service named "service_name" and returns send rights to that * port in "service_port." The port may later be checked in as if this * port were configured in the bootstrap configuration file. * * Errors: Returns appropriate kernel errors on rpc failure. * Returns BOOTSTRAP_NAME_IN_USE, if service already exists. */ kern_return_t x_bootstrap_create_service( mach_port_t bootstrap_port, name_t service_name, mach_port_t *service_port) { server_t *serverp; service_t *servicep; bootstrap_info_t *bootstrap; kern_return_t result; bootstrap = lookup_bootstrap_by_port(bootstrap_port); if (!bootstrap || !active_bootstrap(bootstrap)) return BOOTSTRAP_NOT_PRIVILEGED; debug("Service creation attempt for service %s bootstrap %x", service_name, bootstrap_port); servicep = lookup_service_by_name(bootstrap, service_name); if (servicep) { debug("Service creation attempt for service %s failed, " "service already exists", service_name); return BOOTSTRAP_NAME_IN_USE; } serverp = lookup_server_by_port(bootstrap_port); result = mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, service_port); if (result != KERN_SUCCESS) kern_fatal(result, "port_allocate"); result = mach_port_insert_right(mach_task_self(), *service_port, *service_port, MACH_MSG_TYPE_MAKE_SEND); if (result != KERN_SUCCESS) kern_fatal(result, "failed to insert send right"); if (serverp) serverp->activity++; servicep = new_service(bootstrap, service_name, *service_port, !ACTIVE, DECLARED, serverp); info("Created new service %x in bootstrap %x: %s", servicep->port, bootstrap->bootstrap_port, service_name); return BOOTSTRAP_SUCCESS; }
asynnet_t asynnet_new(uint8_t pollercount) { if(pollercount == 0)return NULL; if(pollercount > MAX_NETPOLLER) pollercount = MAX_NETPOLLER; asynnet_t asynet = calloc(1,sizeof(*asynet)); if(!asynet) return NULL; asynet->poller_count = pollercount; //创建线程池 int32_t i = 0; for(; i < pollercount;++i) { asynet->netpollers[i].poller_thd = create_thread(THREAD_JOINABLE); asynet->netpollers[i].mq_in = new_msgque(32,mq_item_destroyer); asynet->netpollers[i].netpoller = new_service(); thread_start_run(asynet->netpollers[i].poller_thd,mainloop,(void*)&asynet->netpollers[i]); } return asynet; }
Service& use_service() { boost::asio::detail::mutex::scoped_lock lock(mutex_); // First see if there is an existing service object for the given type. boost::asio::io_service::service* service = first_service_; while (service) { if (service_id_matches(*service, Service::id)) return *static_cast<Service*>(service); service = service->next_; } // Create a new service object. The service registry's mutex is not locked // at this time to allow for nested calls into this function from the new // service's constructor. lock.unlock(); std::auto_ptr<Service> new_service(new Service(owner_)); init_service_id(*new_service, Service::id); Service& new_service_ref = *new_service; lock.lock(); // Check that nobody else created another service object of the same type // while the lock was released. service = first_service_; while (service) { if (service_id_matches(*service, Service::id)) return *static_cast<Service*>(service); service = service->next_; } // Service was successfully initialised, pass ownership to registry. new_service->next_ = first_service_; first_service_ = new_service.release(); return new_service_ref; }
void CExportStrategy::x_Process_Pssm(CRef<CPssmWithParameters> & pssm) { if (pssm.Empty()) { NCBI_THROW(CBlastException, eInvalidArgument, "Empty reference for query pssm."); } // Throw exception if pssm is invalid CPsiBlastValidate::Pssm(*pssm); string psi_program("blastp"); string old_service("plain"); string new_service("psi"); string deltablast("delta_blast"); if (m_QueueSearchRequest->GetProgram() != psi_program) { NCBI_THROW(CBlastException, eNotSupported, "PSI-Blast is only supported for blastp."); } if ((m_QueueSearchRequest->GetService() != old_service) && (m_QueueSearchRequest->GetService() != new_service) && (m_QueueSearchRequest->GetService() != deltablast)) { NCBI_THROW(CBlastException, eInvalidArgument, string("PSI-Blast cannot also be ") + m_QueueSearchRequest->GetService() + "."); } CRef<CBlast4_queries> queries_p(new CBlast4_queries); queries_p->SetPssm(*pssm); m_QueueSearchRequest->SetQueries(*queries_p); m_QueueSearchRequest->SetService(new_service); }
void observe_service(interface *i,struct l2host *l2,struct l3host *l3, unsigned proto,unsigned port, const wchar_t *srv,const wchar_t *srvver){ const omphalos_ctx *octx = get_octx(); l4srv *services,**prev,*cur; services = l3_getservices(l3); for(prev = &services ; (cur = *prev) ; prev = &cur->next){ if(cur->proto > proto){ break; }else if(cur->proto == proto){ if(cur->port > port){ break; }else if(cur->port == port){ int r; if((r = wcscmp(cur->srv,srv)) == 0){ return; }else if(r > 0){ break; } } } } if((cur = new_service(proto,port,srv,srvver)) == NULL){ return; } cur->next = *prev; *prev = cur; if(l3_setservices(l3,services)){ *prev = cur->next; free_service(cur); }else if(octx->iface.srv_event){ cur->opaque = octx->iface.srv_event(i,l2,l3,cur); } }
int main(int argc,char **argv) { mutil_thread = 0; setup_signal_handler(); init_clients(); InitNetSystem(); struct netservice *tcpserver = new_service(); tcpserver->listen(tcpserver,argv[1],atoi(argv[2]),(void*)tcpserver,accept_client); uint32_t tick,now; tick = now = GetSystemMs(); while(!stop){ tcpserver->loop(tcpserver,50); now = GetSystemMs(); if(now - tick > 1000) { printf("client_count:%d,send_count:%d\n",client_count,(packet_send_count*1000)/(now-tick)); tick = now; packet_send_count = 0; } } destroy_service(&tcpserver); CleanNetSystem(); return 0; }
/* serv must be the form [server_name]:[port_number] */ struct ServiceList* new_ServiceList(char *fun, char *serv){ struct ServiceList *s = (struct ServiceList*)malloc(sizeof(struct ServiceList)); s->head = new_service(fun, serv); s->tail = s->head; return s; }
static void sdt_cb(void *opaque, const uint8_t *section, int section_len) { MpegTSContext *ts = opaque; SectionHeader h1, *h = &h1; const uint8_t *p, *p_end, *desc_list_end, *desc_end; int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type; char *name, *provider_name; #ifdef DEBUG_SI printf("SDT:\n"); av_hex_dump(stdout, (uint8_t *)section, section_len); #endif p_end = section + section_len - 4; p = section; if (parse_section_header(h, &p, p_end) < 0) return; if (h->tid != SDT_TID) return; onid = get16(&p, p_end); if (onid < 0) return; val = get8(&p, p_end); if (val < 0) return; for(;;) { sid = get16(&p, p_end); if (sid < 0) break; val = get8(&p, p_end); if (val < 0) break; desc_list_len = get16(&p, p_end) & 0xfff; if (desc_list_len < 0) break; desc_list_end = p + desc_list_len; if (desc_list_end > p_end) break; for(;;) { desc_tag = get8(&p, desc_list_end); if (desc_tag < 0) break; desc_len = get8(&p, desc_list_end); desc_end = p + desc_len; if (desc_end > desc_list_end) break; #ifdef DEBUG_SI printf("tag: 0x%02x len=%d\n", desc_tag, desc_len); #endif switch(desc_tag) { case 0x48: service_type = get8(&p, p_end); if (service_type < 0) break; provider_name = getstr8(&p, p_end); if (!provider_name) break; name = getstr8(&p, p_end); if (!name) break; new_service(ts, sid, provider_name, name); break; default: break; } p = desc_end; } p = desc_list_end; } ts->stop_parse = 1; /* remove filter */ mpegts_close_filter(ts, ts->sdt_filter); ts->sdt_filter = NULL; }
/* * kern_return_t * bootstrap_register(mach_port_t bootstrap_port, * name_t service_name, * mach_port_t service_port) * * Registers send rights for the port service_port for the service named by * service_name. Registering a declared service or registering a service for * which bootstrap has receive rights via a port backup notification is * allowed. * The previous service port will be deallocated. Restarting services wishing * to resume service for previous clients must first attempt to checkin to the * service. * * Errors: Returns appropriate kernel errors on rpc failure. * Returns BOOTSTRAP_NOT_PRIVILEGED, if request directed to * unprivileged bootstrap port. * Returns BOOTSTRAP_SERVICE_ACTIVE, if service has already been * register or checked-in. */ kern_return_t x_bootstrap_register( mach_port_t bootstrap_port, name_t service_name, mach_port_t service_port) { kern_return_t result; service_t *servicep; server_t *serverp; bootstrap_info_t *bootstrap; mach_port_t old_port; debug("Register attempt for service %s port %x", service_name, service_port); /* * Validate the bootstrap. */ bootstrap = lookup_bootstrap_by_port(bootstrap_port); if (!bootstrap || !active_bootstrap(bootstrap)) return BOOTSTRAP_NOT_PRIVILEGED; /* * If this bootstrap port is for a server, or it's an unprivileged * bootstrap can't register the port. */ serverp = lookup_server_by_port(bootstrap_port); servicep = lookup_service_by_name(bootstrap, service_name); if (servicep && servicep->server && servicep->server != serverp) return BOOTSTRAP_NOT_PRIVILEGED; if (servicep == NULL || servicep->bootstrap != bootstrap) { servicep = new_service(bootstrap, service_name, service_port, ACTIVE, REGISTERED, NULL_SERVER); debug("Registered new service %s", service_name); } else { if (servicep->isActive) { debug("Register: service %s already active, port %x", servicep->name, servicep->port); ASSERT(!canReceive(servicep->port)); return BOOTSTRAP_SERVICE_ACTIVE; } old_port = servicep->port; if (servicep->servicetype == DECLARED) { servicep->servicetype = REGISTERED; if (servicep->server) { ASSERT(servicep->server == serverp); ASSERT(active_server(serverp)); servicep->server = NULL_SERVER; serverp->activity++; } result = mach_port_mod_refs( mach_task_self(), old_port, MACH_PORT_RIGHT_RECEIVE, -1); if (result != KERN_SUCCESS) kern_fatal(result, "mach_port_mod_refs"); } result = mach_port_deallocate( mach_task_self(), old_port); if (result != KERN_SUCCESS) kern_fatal(result, "mach_port_mod_refs"); servicep->port = service_port; servicep->isActive = TRUE; debug("Re-registered inactive service %x bootstrap %x: %s", servicep->port, servicep->bootstrap->bootstrap_port, service_name); } /* detect the new service port going dead */ result = mach_port_request_notification( mach_task_self(), service_port, MACH_NOTIFY_DEAD_NAME, 0, notify_port, MACH_MSG_TYPE_MAKE_SEND_ONCE, &old_port); if (result != KERN_SUCCESS) { debug("Can't request notification on service %x bootstrap %x: %s", service_port, servicep->bootstrap->bootstrap_port, "must be dead"); delete_service(servicep); return BOOTSTRAP_SUCCESS; } else if (old_port != MACH_PORT_NULL) { debug("deallocating old notification port (%x) for service %x", old_port, service_port); result = mach_port_deallocate( mach_task_self(), old_port); if (result != KERN_SUCCESS) kern_fatal(result, "mach_port_deallocate"); } info("Registered service %x bootstrap %x: %s", servicep->port, servicep->bootstrap->bootstrap_port, servicep->name); return BOOTSTRAP_SUCCESS; }