int pipe_send_cache_reply( ECM_DATA *ecm, struct cardserver_data *cs) { if ( !cache_check_request(ecm->ecm[0], ecm->sid, cs->onid, ecm->caid, ecm->hash) ) return 0; uchar buf[64]; // 32 por defecto buf[0] = PIPE_CACHE_REPLY; buf[2] = ecm->ecm[0]; buf[3] = (ecm->sid)>>8; buf[4] = (ecm->sid)&0xff; buf[5] = (cs->onid)>>8; buf[6] = (cs->onid)&0xff; buf[7] = (ecm->caid)>>8; buf[8] = (ecm->caid)&0xff; buf[9] = ecm->hash>>24; buf[10] = ecm->hash>>16; buf[11] = ecm->hash>>8; buf[12] = ecm->hash & 0xff; if (ecm->dcwstatus==STAT_DCW_SUCCESS) { memcpy(buf+13, ecm->cw, 16); buf[1] = 11+16; pipe_send( srvsocks[0], buf, 13+16); } else { buf[1] = 11; pipe_send( srvsocks[0], buf, 13); } return 1; }
DWORD WINAPI PipeReadThread(LPVOID param) { DWORD numread, br; char buffer[IRCLINE]; int threadnum = (int)param; while (1) { BOOL eol = FALSE; DWORD State; memset(buffer,0,sizeof(buffer)); if (!PeekNamedPipe(pipe_read,buffer,IRCLINE,&br,NULL,NULL)) { pipe_send(pipesock,pipe_chan,"[CMD]: Could not read data from proccess\r\n"); clearthread(threadnum); ExitThread(1); } if (br == 0) { //nothing to read if (GetExitCodeProcess(pipe_Hproc,&State)) { if (State != STILL_ACTIVE) { Close_Handles(); pipe_send(pipesock,pipe_chan,"[CMD]: Proccess has terminated.\r\n"); clearthread(threadnum); ExitThread (0); } } Sleep(10); //process pause and retry continue; } DWORD cbyte; for (cbyte=0;cbyte<br;cbyte++) { if (buffer[cbyte] == '\n') { eol = TRUE; break; } } if (eol) br = cbyte + 1; else br = 512; memset(buffer,0,sizeof(buffer)); if (!ReadFile(pipe_read, buffer, br, &numread, NULL)) break; pipe_send(pipesock,pipe_chan,buffer); } pipe_send(pipesock,pipe_chan,"[CMD]: Could not read data from proccess.\r\n"); clearthread(threadnum); ExitThread (0); }
/* * The thread start routine for pipe stage threads. * Each will wait for a data item passed from the * caller or the previous stage, modify the data * and pass it along to the next (or final) stage. */ void *pipe_stage (void *arg) { stage_t *stage = (stage_t*)arg; stage_t *next_stage = stage->next; int status; status = pthread_mutex_lock (&stage->mutex); if (status != 0) err_abort (status, "Lock pipe stage"); while (1) { while (stage->data_ready != 1) { status = pthread_cond_wait (&stage->avail, &stage->mutex); if (status != 0) err_abort (status, "Wait for previous stage"); } pipe_send (next_stage, stage->data + 1); stage->data_ready = 0; status = pthread_cond_signal (&stage->ready); if (status != 0) err_abort (status, "Wake next stage"); } /* * Notice that the routine never unlocks the stage->mutex. * The call to pthread_cond_wait implicitly unlocks the * mutex while the thread is waiting, allowing other threads * to make progress. Because the loop never terminates, this * function has no need to unlock the mutex explicitly. */ return NULL; }
void Sync(ArgStruct *p) { int bogus; /* Parent */ if (p->tr) { pipe_send(pipe_to_child, &bogus, sizeof(bogus)); pipe_recv(pipe_to_parent, &bogus, sizeof(bogus)); } /* Child */ else { pipe_recv(pipe_to_child, &bogus, sizeof(bogus)); pipe_send(pipe_to_parent, &bogus, sizeof(bogus)); } }
int pipe_start(pipe_t *pipe, int value) { PCHECK(pthread_mutex_lock(&pipe->mutex)); pipe->active++; PCHECK(pthread_mutex_unlock(&pipe->mutex)); //诛仙乘首先进来 pipe_send(pipe->head, value); return 0; }
void pipe_start(pipe_t *pipe, long value) { int status; stage_t *stage = pipe->head; status = pthread_mutex_lock(&pipe->mutex); pipe->actives++; status = pthread_mutex_unlock(&pipe->mutex); pipe_send(pipe->head, value); }
/* * External interface to start a pipeline by passing * data to the first stage. The routine returns while * the pipeline processes in parallel. Call the * pipe_result return to collect the final stage values * (note that the pipe will stall when each stage fills, * until the result is collected). */ int pipe_start (pipe_t *pipe, long value) { int status; status = pthread_mutex_lock (&pipe->mutex); if (status != 0) err_abort (status, "Lock pipe mutex"); pipe->active++; status = pthread_mutex_unlock (&pipe->mutex); if (status != 0) err_abort (status, "Unlock pipe mutex"); pipe_send (pipe->head, value); return 0; }
static int _impl_sync(rh_aout_api_itf self, rh_asmp_itf sample) { int e = -1; struct sles_api_instance * instance = (struct sles_api_instance *)self; const struct io_command_struct cmd = { SYNC_COMMAND, sample }; if( sample ) { // create a reference for the command pipe (*sample)->addref(sample); if((e = pipe_send(self, &cmd))!=0) (*sample)->close(&sample); } return e; }
int pipe_send_cache_find( ECM_DATA *ecm, struct cardserver_data *cs) { if ( !cache_check_request(ecm->ecm[0], ecm->sid, cs->onid, ecm->caid, ecm->hash) ) return 0; //send pipe to cache uchar buf[64]; // 32 por defecto buf[0] = PIPE_CACHE_FIND; buf[1] = 14; // Data length buf[2] = ecm->ecm[0]; buf[3] = (ecm->sid)>>8; buf[4] = (ecm->sid)&0xff; buf[5] = (cs->onid)>>8; buf[6] = (cs->onid)&0xff; buf[7] = (ecm->caid)>>8; buf[8] = (ecm->caid)&0xff; buf[9] = ecm->hash>>24; buf[10] = ecm->hash>>16; buf[11] = ecm->hash>>8; buf[12] = ecm->hash & 0xff; buf[13] = ecm->provid>>16; buf[14] = ecm->provid>>8; buf[15] = ecm->provid & 0xff; //debugf(" Pipe Ecm->Cache: PIPE_CACHE_FIND %04x:%04x:%08x\n",ecm->caid, ecm->sid, ecm->hash); pipe_send( srvsocks[0], buf, 16); return 1; }
void *stage_deal(void *arg) { int status; stage_t *stage = (stage_t *)arg; stage_t *stage_next = stage->next; status = pthread_mutex_lock(&stage->mutex); while (1) { while (!stage->data_ready) status = pthread_cond_wait(&stage->avail, &stage->mutex); pipe_send(stage_next, stage->data + 1); stage->data_ready = 0; status = pthread_cond_signal(&stage->ready); } }
int _impl_consumed_buffer(rh_aout_api_itf self, rh_asmp_itf sample) { int e = -1; struct sles_api_instance * instance = (struct sles_api_instance *)self; const struct io_command_struct cmd = { CONSUMED_BUFFER, sample }; if( sample ) { // create a reference for the command pipe (*sample)->addref(sample); if((e = pipe_send(self, &cmd))!=0) (*sample)->close(&sample); } return e; }
static inline void _server_pipe_write(void) { ASSERT(pipe_c != NULL); ssize_t status = pipe_send(pipe_c, "", 1); if (status == 0 || status == CC_EAGAIN) { /* retry write */ log_verb("server core: retry send on pipe"); event_add_write(ctx->evb, pipe_write_id(pipe_c), NULL); } else if (status == CC_ERROR) { /* other reasn write can't be done */ log_error("could not write to pipe - %s", strerror(pipe_c->err)); } /* else, pipe write succeeded and no action needs to be taken */ }
/* * External interface to start a pipeline by passing data to the first stage. * The routine returns while the pipeline processes in parallel. Call the * pipe_result return to collect the final stage values (note that the pipeline * will stall when each stage fills, until the result is collected). */ int pipe_start(pipe_t *pipe, long value) { int status; status = pthread_mutex_lock(&pipe->mutex); status_check(status, "Lock pipe mutex"); if (pipe->active >= pipe->stages) { fprintf(stdout, "Pipeline is fully, please try later.\n"); status = pthread_mutex_unlock(&pipe->mutex); status_check(status, "Unlock pipe mutex"); return 1; } pipe->active++; status = pthread_mutex_unlock(&pipe->mutex); status_check(status, "Unlock pipe mutex"); pipe_send(pipe->head, value); return 0; }
static int _impl_shutdown(rh_aout_api_itf * itf) { struct sles_api_instance * instance; if(!itf) return -1; instance = (struct sles_api_instance *)*itf; if(instance) { if( instance->outputMix ) (*instance->outputMix)->Destroy(instance->outputMix); if( instance->engineObject ) (*instance->engineObject)->Destroy(instance->engineObject); if(instance->thread) { const struct io_command_struct cmd = { EXIT_COMMAND, NULL }; if( pipe_send( *itf, &cmd ) == 0) while(instance->thread) sched_yield(); } close_all_channels(*itf); bucket_free(instance->aout_itf_bucket); instance->aout_itf_bucket = NULL; close(instance->cmd_pipe.write); instance->cmd_pipe.write = 0; close(instance->cmd_pipe.read); instance->cmd_pipe.read = 0; free(instance->interface); free(instance); } *itf = NULL; return 0; }
// thread handle void * pipe_stage(void *arg) { stage_t *this= (stage_t *)arg; stage_t *next = this->next; PCHECK(pthread_mutex_lock(&this->mutex)); while (1) { //process forever while (this->data_ready != 1) { printf("thread:%u send wait avail \n", (int)pthread_self()); PCHECK(pthread_cond_wait(&this->avail, &this->mutex)); } printf("thread:%u send wait avail up\n", (int)pthread_self()); sleep(1); pipe_send(next, this->data + 1); this->data_ready = 0; //自己清空自己的ready PCHECK(pthread_cond_signal(&this->ready)); // PCHECK(pthread_cond_signal(&next->ready)); } }
void SendTime(ArgStruct *p, double *t) { /* Only child calls SendTime */ pipe_send(pipe_to_parent, t, sizeof(*t)); }
void SendRepeat(ArgStruct *p, int rpt) { /* Only parent calls SendRepeat */ pipe_send(pipe_to_child, &rpt, sizeof(rpt)); }
void cache_recvmsg() { unsigned int recv_ip; unsigned short recv_port; unsigned char buf[1024]; struct sockaddr_in si_other; socklen_t slen=sizeof(si_other); uint ticks = GetTickCount(); struct cs_cachepeer_data *peer; int received = recvfrom( cfg.cachesock, buf, sizeof(buf), 0, (struct sockaddr*)&si_other, &slen); memcpy( &recv_ip, &si_other.sin_addr, 4); recv_port = ntohs(si_other.sin_port); if (received>0) { if (flag_debugnet) { debugf(" cache: recv data (%d) from address (%s:%d)\n", received, ip2string(recv_ip), recv_port ); debughex(buf,received); } // Store Data struct cache_data req; switch(buf[0]) { case TYPE_REQUEST: // Check Peer peer = getpeerbyaddr(recv_ip,recv_port); if (!peer) { peer = getpeerbyip(recv_ip); if (!peer) break; } peer->lastactivity = ticks; //peer->totreq++; // Check Multics diferent version if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break; // Check CSP if (received==20) { // arbiter number strcpy(peer->program,"CSP"); break; } // Check Status if (peer->disabled) break; // Get DATA req.tag = buf[1]; req.sid = (buf[2]<<8) | buf[3]; req.onid = (buf[4]<<8) | buf[5]; req.caid = (buf[6]<<8) | buf[7]; req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11]; // Check Cache Request if (!cache_check(&req)) break; // peer->reqnb++; // ADD CACHE struct cache_data *pcache = cache_fetch( &req ); if (pcache==NULL) { //*debugf(" [CACHE] << Cache Request from %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash); pcache = cache_new( &req ); if (cfg.cache.trackermode) { // Send REQUEST to all Peers struct cs_cachepeer_data *p = cfg.cachepeer; while (p) { if (!p->disabled) if (p->host->ip && p->port) if ( (p->lastactivity+75000)>ticks ) if ( !p->fblock0onid || pcache->onid ) cache_send_request(pcache,p); p = p->next; } pcache->sendcache = 1; cfg.cachereq++; } } else if (!cfg.cache.trackermode) { if ( (pcache->status==CACHE_STAT_DCW)&&(pcache->sendcache!=2) ) { //debugf(" [CACHE] << Request Reply >> to peer %s %04x:%04x:%08x\n", peer->host->name, req.caid, req.sid, req.hash); peer->ihitfwd++; peer->hitfwd++; cache_send_reply(pcache,peer); } } break; case TYPE_REPLY: // Check Peer peer = getpeerbyaddr(recv_ip,recv_port); if (!peer) { peer = getpeerbyip(recv_ip); if (!peer) break; } peer->lastactivity = ticks; //peer->totrep++; // Check Multics diferent version if ( !strcmp("MultiCS",peer->program) && (!strcmp("r63",peer->version)||!strcmp("r64",peer->version)||!strcmp("r65",peer->version)||!strcmp("r66",peer->version)||!strcmp("r67",peer->version)||!strcmp("r68",peer->version)||!strcmp("r69",peer->version)||!strcmp("r70",peer->version)||!strcmp("r71",peer->version)||!strcmp("r72",peer->version)||!strcmp("r73",peer->version)||!strcmp("r74",peer->version)||!strcmp("r75",peer->version)||!strcmp("r76",peer->version)||!strcmp("r77",peer->version)||!strcmp("r78",peer->version)||!strcmp("r79",peer->version)||!strcmp("r80",peer->version)||!strcmp("r81",peer->version)||!strcmp("r82",peer->version)||!strcmp("r83",peer->version)||!strcmp("r84",peer->version)||!strcmp("r85",peer->version)) ) break; // Check Status if (peer->disabled) break; // 02 80 00CD 0001 0500 8D1DB359 80 // failed // 02 80 00CD 0001 0500 8D1DB359 80 00CD 0000 0500 63339F359A663232B73158405A255DDC // OLD // 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW if (buf[12]!=buf[1]) { //peer->rep_badheader++; break; } req.tag = buf[1]; req.sid = (buf[2]<<8) | buf[3]; req.onid = (buf[4]<<8) | buf[5]; req.caid = (buf[6]<<8) | buf[7]; req.hash = (buf[8]<<24) | (buf[9]<<16) | (buf[10]<<8) |buf[11]; // Check Cache Request if (!cache_check(&req)) { //peer->rep_badfields++; break; } // if (received==13) { // FAILED //peer->rep_failed++; //*debugf(" [CACHE] <| Failed Cache Reply from %s (CAID:%04x SID:%04x ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.onid); // NOTHING TO DO break; } else if (received>=29) { // 02 80 001F 0001 0100 9A3BA1C1 80 BC02DB99DE3D526D5702D42D4C249505 0005 6361726431 // NEW if ( !acceptDCW(buf+13) ) { //peer->rep_baddcw++; break; } //*debugf(" [CACHE] << Good Cache Reply from %s %04x:%04x:%08x (ONID:%04x)\n", peer->host->name, req.caid, req.sid, req.hash, req.onid); peer->repok++; // Request+Reply // Search for Cache data struct cache_data *pcache = cache_fetch( &req ); if (pcache==NULL) pcache = cache_new( &req ); if (pcache->status!=CACHE_STAT_DCW) { //*debugf(" [CACHE] Update Cache DCW %04x:%04x:%08x\n", pcache->caid, pcache->sid, pcache->hash); pcache->peerid = peer->id; memcpy(pcache->cw, buf+13, 16); pcache->status = CACHE_STAT_DCW; if (pcache->sendpipe) { uchar buf[128]; // 32 por defecto buf[0] = PIPE_CACHE_FIND_SUCCESS; buf[1] = 11+2+16; // Data length buf[2] = pcache->tag; buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff; buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff; buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff; buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff; buf[13] = peer->id>>8; buf[14] = peer->id&0xff; memcpy( buf+15, pcache->cw, 16); //*debugf(" pipe Cache->Ecm: PIPE_CACHE_FIND_SUCCESS %04x:%04x:%08x\n",pcache->caid, pcache->sid, pcache->hash); // debughex(buf, 13+16); pipe_send( srvsocks[1], buf, 13+2+16); //pcache->sendpipe = 0; } if (cfg.cache.trackermode) { // Send REQUEST to all Peers struct cs_cachepeer_data *p = cfg.cachepeer; while (p) { if (!p->disabled) if (p->host->ip && p->port) if ( (p->lastactivity+75000)>ticks ) if ( !p->fblock0onid || pcache->onid ) cache_send_reply(pcache,p); p = p->next; } pcache->sendcache = 2; cfg.cacherep++; } } else if ( pcache->sendpipe && memcmp(pcache->cw, buf+13, 16) ) { // resend to server pcache->peerid = peer->id; memcpy(pcache->cw, buf+13, 16); pcache->status = CACHE_STAT_DCW; uchar buf[128]; // 32 por defecto buf[0] = PIPE_CACHE_FIND_SUCCESS; buf[1] = 11+2+16; // Data length buf[2] = pcache->tag; buf[3] = pcache->sid>>8; buf[4] = pcache->sid&0xff; buf[5] = pcache->onid>>8; buf[6] = pcache->onid&0xff; buf[7] = pcache->caid>>8; buf[8] = pcache->caid&0xff; buf[9] = pcache->hash>>24; buf[10] = pcache->hash>>16; buf[11] = pcache->hash>>8; buf[12] = pcache->hash & 0xff; buf[13] = peer->id>>8; buf[14] = peer->id&0xff; memcpy( buf+15, pcache->cw, 16); pipe_send( srvsocks[1], buf, 13+2+16); }
/* Send data over a socket, possibly including Mach ports. */ error_t S_socket_send (struct sock_user *user, struct addr *dest_addr, int flags, char *data, size_t data_len, mach_port_t *ports, size_t num_ports, char *control, size_t control_len, size_t *amount) { error_t err = 0; struct pipe *pipe; struct sock *sock, *dest_sock; struct addr *source_addr; if (!user) return EOPNOTSUPP; sock = user->sock; if (flags & MSG_OOB) /* BSD local sockets don't support OOB data. */ return EOPNOTSUPP; if (dest_addr) { err = addr_get_sock (dest_addr, &dest_sock); if (err == EADDRNOTAVAIL) /* The server went away. */ err = ECONNREFUSED; if (err) return err; if (sock->pipe_class != dest_sock->pipe_class) /* Sending to a different type of socket! */ err = EINVAL; /* ? XXX */ } else dest_sock = 0; /* We could provide a source address for all writes, but we only do so for connectionless sockets because that's the only place it's required, and it's more efficient not to. */ if (!err && sock->pipe_class->flags & PIPE_CLASS_CONNECTIONLESS) err = sock_get_addr (sock, &source_addr); else source_addr = NULL; if (!err) { if (dest_sock) /* Grab the destination socket's read pipe directly, and stuff data into it. This is not quite the usage sock_acquire_read_pipe was intended for, but it will work, as the only inappropriate errors occur on a broken pipe, which shouldn't be possible with the sort of sockets with which we can use socket_send... XXXX */ err = sock_acquire_read_pipe (dest_sock, &pipe); else /* No address, must be a connected socket... */ err = sock_acquire_write_pipe (sock, &pipe); if (!err) { err = pipe_send (pipe, sock->flags & PFLOCAL_SOCK_NONBLOCK, source_addr, data, data_len, control, control_len, ports, num_ports, amount); if (dest_sock) pipe_release_reader (pipe); else pipe_release_writer (pipe); } if (err) /* The send failed, so free any resources it would have consumed (mig gets rid of memory, but we have to do everything else). */ { if (source_addr) ports_port_deref (source_addr); while (num_ports-- > 0) mach_port_deallocate (mach_task_self (), *ports++); } } if (dest_sock) sock_deref (dest_sock); return err; }