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