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