/* See ML Guide. */ int Poisson_comm(double x[], void *A_data) { int proc, neighbor, length, *itemp; double send_buffer[2], recv_buffer[2]; MPI_Request request; itemp = (int *) A_data; proc = *itemp; length = 2; if (proc == 0) { neighbor = 1; send_buffer[0] = x[0]; send_buffer[1] = x[1]; post_msg((char *) recv_buffer, length, neighbor, &request); send_msg((char *) send_buffer, length, neighbor); recv_msg((char *) recv_buffer, length, neighbor, &request); x[2] = recv_buffer[1]; x[3] = recv_buffer[0]; } else { neighbor = 0; send_buffer[0] = x[0]; send_buffer[1] = x[2]; post_msg((char *) recv_buffer, length, neighbor, &request); send_msg((char *) send_buffer, length, neighbor); recv_msg((char *) recv_buffer, length, neighbor, &request); x[3] = recv_buffer[1]; x[4] = recv_buffer[0]; } return 0; }
static int exchange_addr_key(void) { struct fi_rma_iov *rma_iov; int ret; rma_iov = buf; if (opts.dst_addr) { rma_iov->addr = fi->domain_attr->mr_mode == FI_MR_SCALABLE ? 0 : (uintptr_t) buf; rma_iov->key = fi_mr_key(mr); ret = send_msg(sizeof *rma_iov); if (ret) return ret; ret = recv_msg(); if (ret) return ret; remote = *rma_iov; } else { ret = recv_msg(); if (ret) return ret; remote = *rma_iov; rma_iov->addr = fi->domain_attr->mr_mode == FI_MR_SCALABLE ? 0 : (uintptr_t) buf; rma_iov->key = fi_mr_key(mr); ret = send_msg(sizeof *rma_iov); if (ret) return ret; } return 0; }
static int sync_test(void) { int ret; ret = dst_addr ? send_msg(16) : recv_msg(16); if (ret) return ret; return dst_addr ? recv_msg(16) : send_msg(16); }
void recv_ack() { char buf[READBUFLEN]; const char *reply; memset(buf, 0, READBUFLEN); reply = recv_msg(buf, READBUFLEN); while (reply && reply[0] != '.') { printf("Unexpected reply: >>%s<<\n", reply); reply = recv_msg(buf, READBUFLEN); } }
static int sync_test(void) { int ret; ret = opts.dst_addr ? send_msg(16, tag_control) : recv_msg(tag_control); if (ret) return ret; ret = opts.dst_addr ? recv_msg(tag_control) : send_msg(16, tag_control); return ret; }
int16_t init_test(int32_t sockfd, char *user, char *password, direction_t direction, uint16_t mtu){ uint8_t *buffer, challenge[CHALLENGE_SIZE], response[RESPONSE_SIZE]; int32_t numbytes, rv=0; buffer = (uint8_t *) malloc(mtu); if (recv_msg(sockfd, buffer, mtu, MSG_OK, &numbytes) != 0){ close(sockfd); free(buffer); return RETURN_ERROR; } switch(direction){ case RECEIVE: rv = send_msg(sockfd, MSG_TCP_DOWN, sizeof(MSG_TCP_DOWN)); break; case SEND: rv = send_msg(sockfd, MSG_TCP_UP, sizeof(MSG_TCP_UP)); break; case BOTH: rv = send_msg(sockfd, MSG_TCP_BOTH, sizeof(MSG_TCP_BOTH)); break; } if (rv != 0){ close(sockfd); free(buffer); return RETURN_ERROR; } rv = recv_msg(sockfd, buffer, mtu, MSG_OK, &numbytes); if (rv == RETURN_OK){ free(buffer); return RETURN_OK; } else if (rv == RETURN_MSG_MISMATCH){ if (numbytes == CHALLENGE_TOTAL_SIZE && memcmp(buffer, CHALLENGE_HEADER, sizeof(CHALLENGE_HEADER)) == 0){ memcpy(challenge, buffer+sizeof(CHALLENGE_HEADER), CHALLENGE_SIZE); craft_response(user, password, challenge, response); if (send_msg(sockfd, response, sizeof(response)) == 0){ if (recv_msg(sockfd, buffer, mtu, MSG_OK, &numbytes) == 0){ free(buffer); return RETURN_OK; } } } } fprintf(stderr, "Auth failed\n"); close(sockfd); free(buffer); return RETURN_ERROR; }
static void clear_all_signalled(CuTest *tc) { apr_status_t rv; int srv = SMALL_NUM_SOCKETS; recv_msg(s, 0, p, tc); recv_msg(s, 2, p, tc); rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC); CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv)); check_sockets(pollarray, s, 0, 0, tc); check_sockets(pollarray, s, 1, 0, tc); check_sockets(pollarray, s, 2, 0, tc); }
static void clear_middle_pollset(CuTest *tc) { apr_status_t rv; int lrv; const apr_pollfd_t *descs = NULL; recv_msg(s, 2, p, tc); recv_msg(s, 5, p, tc); rv = apr_pollset_poll(pollset, 0, &lrv, &descs); CuAssertIntEquals(tc, 1, APR_STATUS_IS_TIMEUP(rv)); CuAssertIntEquals(tc, 0, lrv); CuAssertPtrEquals(tc, NULL, descs); }
static void clear_all_signalled(abts_case *tc, void *data) { apr_status_t rv; int srv = SMALL_NUM_SOCKETS; recv_msg(s, 0, p, tc); recv_msg(s, 2, p, tc); rv = apr_poll(pollarray, SMALL_NUM_SOCKETS, &srv, 2 * APR_USEC_PER_SEC); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv)); check_sockets(pollarray, s, 0, 0, tc); check_sockets(pollarray, s, 1, 0, tc); check_sockets(pollarray, s, 2, 0, tc); }
static void clear_middle_pollset(abts_case *tc, void *data) { apr_status_t rv; int lrv; const apr_pollfd_t *descs = NULL; recv_msg(s, 2, p, tc); recv_msg(s, 5, p, tc); rv = apr_pollset_poll(pollset, 0, &lrv, &descs); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv)); ABTS_INT_EQUAL(tc, 0, lrv); ABTS_PTR_EQUAL(tc, NULL, descs); }
/* Used internally to get and parse replies from the server. */ uint32_t tcp_get_rep(struct nmdb_srv *srv, unsigned char *buf, size_t bsize, unsigned char **payload, size_t *psize) { ssize_t rv; uint32_t id, reply; rv = recv_msg(srv->fd, buf, bsize); if (rv <= 0) return -1; id = * ((uint32_t *) buf + 1); id = ntohl(id); reply = * ((uint32_t *) buf + 2); reply = ntohl(reply); if (id != ID_CODE) { return -1; } if (payload != NULL) { *payload = buf + 4 + 4 + 4; *psize = rv - 4 - 4 - 4; } return reply; }
//Function 2 Send Format: Function_num,inum int MFS_Stat(int inum, MFS_Stat_t* m) { memset(com_t.message, 0, MSG_BUFFER_SIZE); //Clear the send buffer snprintf(com_t.message, 2*sizeof(int), "%d%d", 2, inum); //Function 2 -- MFS_Stat #ifdef DEBUG printf("\n----MFS_Stat Sent message: %s\n", com_t.message); #endif if(send_msg() < 0) return -1; //Once you recieve the response, fill in the MFS_Stat structure if(recv_msg() < 0) { printf(" CLIENT:: Message was not recieved\n"); return -1; } #ifdef DEBUG printf("----MFS_Stat Recieved message: %s\n", com_t.buffer); #endif return 0; }
unsigned int remote_tcp_do_job(void *acc_ctx, const char *param, unsigned int job_len, void ** result_buf) { //printf("job_len = %d\n", job_len); struct timeval t1, t2, dt; unsigned long send_sec, recv_sec; struct acc_context_t *acc_context = (struct acc_context_t *) acc_ctx; struct scheduler_context_t * scheduler_ctx = acc_context->scheduler_context; struct tcp_client_context_t *tcp_ctx = (struct tcp_client_context_t *)acc_context->tcp_context; double max_bps = scheduler_ctx->max_bps; double send_bps, recv_bps; unsigned int recv_buf_size; *result_buf = tcp_ctx->out_buf; char *in_buf = (char *)tcp_ctx->in_buf; int fd = tcp_ctx->to_server_fd; gettimeofday(&t1, NULL); size_t len = send_msg(fd, in_buf, job_len, MTU, max_bps); gettimeofday(&t2, NULL); timersub(&t2,&t1,&dt); send_sec = dt.tv_usec + 1000000* dt.tv_sec; send_bps = ((double)job_len*1000000)/send_sec; int tmp_size = 16; recv_buf_size = recv_msg(fd, *result_buf, tmp_size, MTU, max_bps); recv_buf_size = job_len; printf("Transfer Rate: %.2f KB/s\n", send_bps/1024); return recv_buf_size; }
void GenericCommunicator::RecvThread::runRecvEventLoopClients() { // Host expects one termination request from each client. // Clients expect two termination requests from the host. int nTerminationRequestsExpected = 2; int nTerminationRequests = 0; bool done = false; do { int sender; if( ! recv_msg( sender ) ) { // normal message } else { // wasTerminationRequest CNC_ASSERT( sender == 0 ); // termination request from host ++nTerminationRequests; if ( nTerminationRequests == 1 ) { m_instance.send_termination_request( 0 ); // send back to the host } if ( nTerminationRequests == nTerminationRequestsExpected ) { done = true; } // For the rest of this run, the clients can only communicate // with the host. Disable all other client connections !!! m_channel.invalidate_client_communication_channels(); } } while ( ! done ); }
static void timeout_pollin_pollcb(abts_case *tc, void *data) { apr_status_t rv; pollcb_baton_t pcb; apr_pollfd_t socket_pollfd; POLLCB_PREREQ; recv_msg(s, 0, p, tc); ABTS_PTR_NOTNULL(tc, s[0]); socket_pollfd.desc_type = APR_POLL_SOCKET; socket_pollfd.reqevents = APR_POLLIN; socket_pollfd.desc.s = s[0]; socket_pollfd.client_data = s[0]; rv = apr_pollcb_add(pollcb, &socket_pollfd); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); pcb.count = 0; pcb.tc = tc; rv = apr_pollcb_poll(pollcb, 1, trigger_pollcb_cb, &pcb); ABTS_INT_EQUAL(tc, 1, APR_STATUS_IS_TIMEUP(rv)); ABTS_INT_EQUAL(tc, 0, pcb.count); rv = apr_pollcb_remove(pollcb, &socket_pollfd); ABTS_INT_EQUAL(tc, APR_SUCCESS, rv); }
//Function 3 Send Format: Function_num,inum,No_of_char_bytes,char_bytes,block int MFS_Write(int inum, char* buffer, int block) { memset(com_t.message, 0, MSG_BUFFER_SIZE); //Clear the send buffer int len = strlen(buffer); //Packing the block first before the write content snprintf(com_t.message, 4*sizeof(int), "%d%d%04d%d", 3, inum, len, block); //Function 3 -- MFS_Write strcat(com_t.message, buffer); #ifdef DEBUG printf("\n----MFS_Write Sent message: %s\n", com_t.message); #endif if(send_msg() < 0) return -1; //Once you recieve the response, response is write success or failure if(recv_msg() < 0) { printf(" CLIENT:: Message was not recieved\n"); return -1; } #ifdef DEBUG printf("----MFS_Write Recieved message: %s\n", com_t.buffer); #endif return 0; }
void play(){ if(dnum > 21){ send_msg("win", client_sock); return; } if(pnum > 21){ send_msg("lose", client_sock); return; } send_msg("inp", client_sock); int i = 0; while(recv_msg(buf, 256, client_sock) != 0){ if(!strncmp("hit", buf, 3)){ player[pnumcards] = top(); pnum += player[pnumcards]->value; pnumcards++; send_msg("msg", client_sock); sprintf(String, "Player:"); for(i = 0; i < pnumcards; i++){ strcat(String, " "); strcat(String, player[i]->rep); } strcat(String, "\n"); send_msg(String, client_sock); if(pnum > 21){ send_msg("lose", client_sock); return; }else{ send_msg("inp", client_sock); } }else{ while(dnum < 17){ dealer[dnumcards] = top(); dnum += dealer[dnumcards]->value; dnumcards++; send_msg("msg", client_sock); sprintf(String, "Dealer:"); for(i = 0; i < dnumcards; i++){ strcat(String, " "); strcat(String, dealer[i]->rep); } strcat(String, "\n"); send_msg(String, client_sock); } if(dnum > pnum){ send_msg("lose", client_sock); return; }else if(dnum < pnum){ send_msg("win", client_sock); return; }else{ send_msg("tie", client_sock); return; } } } }
int main() { int msg_id = create_msg_queue(); char buf[_SIZE_]; while(1) { memset(buf,'\0',sizeof(buf)); sleep(20); recv_msg(msg_id,_CLIENT_TYPE_,buf); printf("client -> server:%s\n",buf); printf("请输入:"); fflush(stdout); read(0,buf,sizeof(buf)-1); send_msg(msg_id,_SERVER_TYPE_,buf); } destroy_msg_queue(msg_id); return 0; }
/* * int pause(); * 使自身进程处于挂起状态 *其他进程向其发送信号将使它激活 * * 成功返回信号类型。失败返回-1 */ int pause(){ MSG *p_msg; int signal = -1; p_msg = get_msg(); p_msg->type = MSG_PAUSE; send_msg(p_msg); /* * 这里使借鉴了wait(signal)的设计。因为发送包到处理会有一段时间,因此调用程序完全可能跨越pause()而执行之后的部分程序 * 这是不被允许的。因此使用此循环,因为pause()的进程被激活是有进程向其发送包,所以其接收队列中一定有信号包。 */ while(1){ p_msg = recv_msg(); if(p_msg -> type == MSG_SIGNAL){ signal = p_msg->signal; del_msg(p_msg); return signal; //返回信号的类型 } if(p_msg != (MSG *)NULL) reload_msg(p_msg); //如果出现了自己不需要的消息,将会把该消息重新放入自己的收件箱 } //end while }
bool UDPsocket::recv_msg( char * buf, int & len, bool redirect ) { return recv_msg( buf, len, MAXMESG, redirect ); }
int check_login_via_monitor(const char* username, const char* password) { pstr obuf; msg* sm = NULL; char msg_buf[100 + 100 + 1]; sprintf(msg_buf, "%s|%s", username, password); obuf.buf = msg_buf; obuf.len = strlen(msg_buf); send_free(mk_LoginReq_msg(&obuf)); sm = recv_msg(); if(sm->mtyp == MTYP_LoginResT) { return 1; } else { return 0; } /* if(sm->mtyp != MTYP_LoginResT || sm->payload->ptyp != PTYP_NUM) { error("check_login_via_monitor:malformed msg is received\n"); free_msg(sm); return 0; } else { return !!sm->payload->pval.num; } */ }
int set_ieee(char *ifname, struct ieee_ets *ets_data, struct ieee_pfc *pfc_data, struct dcb_app *app_data) { struct nlmsghdr *nlh; struct rtattr *ieee, *apptbl; nlh = start_msg(RTM_SETDCB, DCB_CMD_IEEE_SET); if (NULL == nlh) return -EIO; addattr_l(nlh, DCB_ATTR_IFNAME, ifname, strlen(ifname) + 1); ieee = addattr_nest(nlh, DCB_ATTR_IEEE); if (ets_data) addattr_l(nlh, DCB_ATTR_IEEE_ETS, ets_data, sizeof(*ets_data)); if (pfc_data) addattr_l(nlh, DCB_ATTR_IEEE_PFC, pfc_data, sizeof(*pfc_data)); if (app_data) { apptbl = addattr_nest(nlh, DCB_ATTR_IEEE_APP_TABLE); addattr_l(nlh, DCB_ATTR_IEEE_APP, app_data, sizeof(*app_data)); #if 1 app_data->protocol++; addattr_l(nlh, DCB_ATTR_IEEE_APP, app_data, sizeof(*app_data)); #endif addattr_nest_end(nlh, apptbl); } addattr_nest_end(nlh, ieee); if (send_msg(nlh)) return -EIO; return recv_msg(DCB_CMD_IEEE_SET, DCB_ATTR_IEEE); }
void sim_client_session::send(message_ptr& msg) { sim_network_provider* rnet = nullptr; if (!s_switch[task_spec::get(msg->header().local_rpc_code)->rpc_call_channel].get(msg->header().to_address, rnet)) { dwarn("cannot find destination node %s:%d in simulator", msg->header().to_address.name.c_str(), static_cast<int>(msg->header().to_address.port) ); return; } auto server_session = rnet->get_server_session(_net.address()); if (nullptr == server_session) { rpc_client_session_ptr cptr = this; server_session.reset(new sim_server_session(*rnet, _net.address(), cptr)); rnet->on_server_session_accepted(server_session); } message_ptr recv_msg(new message(msg->writer().get_buffer())); recv_msg->header().from_address = msg->header().from_address; recv_msg->header().to_address = msg->header().to_address; server_session->on_recv_request(recv_msg, recv_msg->header().from_address == recv_msg->header().to_address ? 0 : rnet->net_delay_milliseconds() ); }
void GenericCommunicator::RecvThread::runRecvEventLoopHost() { // Host expects one termination request from each client. // Clients expect two termination requests from the host. int nTerminationRequestsExpected = m_channel.numProcs() - 1; int nTerminationRequests = 0; bool done = false; do { int client; if( ! recv_msg( client ) ) { // normal message } else { // wasTerminationRequest ++nTerminationRequests; if ( nTerminationRequests == nTerminationRequestsExpected ) { done = true; } } } while ( ! done ); // All clients are shutting down. Send final termination requests: for ( int iClient = 1; iClient < m_channel.numProcs(); ++iClient ) { m_instance.send_termination_request( iClient, true ); // blocking send !!! // The communication with this client is over. Disable the channel: m_channel.deactivate( iClient ); } }
//Function 4 Send Format: Function_num,block int MFS_Read(int inum, char* buffer, int block) { memset(com_t.message, 0, MSG_BUFFER_SIZE); //Clear the send buffer snprintf(com_t.message, 3*sizeof(int), "%d%d%d", 4, inum, block); //Function 4 -- MFS_Read #ifdef DEBUG printf("\n----MFS_Read Sent message: %s\n", com_t.message); #endif if(send_msg() < 0) return -1; //Once you recieve the response, response is written to buffer if(recv_msg() < 0) { printf(" CLIENT:: Message was not recieved\n"); return -1; } #ifdef DEBUG printf("----MFS_Read Recieved message: %s\n", com_t.buffer); #endif return 0; }
int set_hw_app0(char *ifname, appgroup_attribs *app_data) { struct nlmsghdr *nlh; struct rtattr *rta_parent, *rta_child; printf("set_hw_app0: %s\n", ifname); nlh = start_msg(RTM_SETDCB, DCB_CMD_SAPP); if (NULL == nlh) return -EIO; add_rta(nlh, DCB_ATTR_IFNAME, (void *)ifname, strlen(ifname) + 1); rta_parent = add_rta(nlh, DCB_ATTR_APP, NULL, 0); rta_child = add_rta(nlh, DCB_APP_ATTR_IDTYPE, (void *)&app_data->dcb_app_idtype, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_APP_ATTR_ID, (void *)&app_data->dcb_app_id, sizeof(__u16)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); rta_child = add_rta(nlh, DCB_APP_ATTR_PRIORITY, (void *)&app_data->dcb_app_priority, sizeof(__u8)); rta_parent->rta_len += NLA_ALIGN(rta_child->rta_len); if (send_msg(nlh)) return -EIO; return(recv_msg(DCB_CMD_SAPP, DCB_ATTR_APP)); }
int ACE_TMAIN (int, ACE_TCHAR *[]) { long pid = long (ACE_OS::getpid ()); ACE_SV_Message_Queue msgque (SRV_KEY); Message_Block send_msg (SRV_ID, pid, ACE_OS::cuserid (static_cast<char *> (0)), "did you get this?"); Message_Block recv_msg (pid); if (msgque.send (send_msg, send_msg.length ()) < 0) ACE_OS::perror ("msgque.send"), ACE_OS::exit (1); if (msgque.recv (recv_msg, sizeof (Message_Data), recv_msg.type ()) < 0) ACE_OS::perror ("msgrcv"), ACE_OS::exit (1); cout << "a message of length " << recv_msg.length () << " received from server " << recv_msg.pid () << " (user " << recv_msg.user () << "): " << recv_msg.text () << "\n"; return 0; }
//Function 5 Send Format: Function_num,pinum,type,No_of_char_bytes,char_bytes int MFS_Creat(int pinum, int type, char* name) { memset(com_t.message, 0, MSG_BUFFER_SIZE); //Clear the send buffer int len = strlen(name); snprintf(com_t.message, 4*sizeof(int), "%d%d%d%04d", 5, pinum, type, len); //Function 5 -- MFS_Creat strcat(com_t.message, name); #ifdef DEBUG printf("\n----MFS_Creat Sent message: %s\n", com_t.message); #endif if(send_msg() < 0) return -1; //Once you recieve the response, status is returned if(recv_msg() < 0) { printf(" CLIENT:: Message was not recieved\n"); return -1; } #ifdef DEBUG printf("----MFS_Creat Recieved message: %s\n", com_t.buffer); #endif return 0; }
/* * get and parse replies from the server. */ uint32_t tcp_get_rep(moc_srv *srv, unsigned char *buf, size_t bsize, unsigned char **payload, size_t *psize) { ssize_t rv; uint32_t id, reply; rerecv: rv = recv_msg(srv->fd, buf, bsize); if (rv <= 0) { if (errno != EAGAIN) { /* * orderly shutdown or error */ close(srv->fd); srv->fd = -1; } return -1; } id = * ((uint32_t *) buf + 1); id = ntohl(id); reply = * ((uint32_t *) buf + 2); reply = ntohl(reply); if (id < g_reqid) goto rerecv; if (payload != NULL) { *payload = buf + 4 + 4 + 4; *psize = rv - 4 - 4 - 4; } return reply; }
//Function 1 Send Format: Function_num,pinum,No_of_char_bytes,char_bytes int MFS_Lookup(int pinum, char* name) { memset(com_t.message, 0, MSG_BUFFER_SIZE); //Clear the send buffer //Provide the number of bytes to read for the name int len = strlen(name); snprintf(com_t.message, 3*sizeof(int), "%d%d%04d", 1, pinum, len); //Function 1 --LOOKUP strcat(com_t.message, name); #ifdef DEBUG printf("\n----MFS_Lookup Sent message: %s\n", com_t.message); #endif if(send_msg() < 0) return -1; //Recieve yet to write, should return inode num of name, if failure return -1 if(recv_msg() < 0) { printf(" CLIENT:: Message was not recieved\n"); return -1; } #ifdef DEBUG printf("----MFS_Lookup Recieved message: %s\n", com_t.buffer); #endif return 0; }