int main(int argc, char *argv[]) { //the endpoints used in message-oriented communication mcapi_endpoint_t red_msg_point; mcapi_endpoint_t yellow_msg_point; mcapi_endpoint_t green_msg_point; //the endpoints used in channel-oriented communication mcapi_endpoint_t yellow_sin_chan; mcapi_endpoint_t yellow_cos_chan; mcapi_endpoint_t yellow_pkt_chan; //status message received in almost all MCAPI-calls mcapi_status_t status; //info-struct received in initialization mcapi_info_t info; //buffer for incoming messages char recv_buf[MAX_MSG_LEN]; //the status code converted to string char status_msg[MCAPI_MAX_STATUS_MSG_LEN]; //size parameter required in some calls size_t size = 1; //an iterator used in loops unsigned int i = 0; //request handle is used to operate wait-calls mcapi_request_t request; //a second request handle! just so that we see it works :) mcapi_request_t request2; //sandles used in channel-messaging mcapi_sclchan_recv_hndl_t sin_handle; mcapi_sclchan_recv_hndl_t cos_handle; mcapi_pktchan_send_hndl_t pkt_handle; //how many scalars we are expecting char count = 0; //buffer of data sent in messages unsigned char* send_buf; printf(COLOR "here\n"); //We are yellow! initialize accordingly mcapi_initialize( THE_DOMAIN, YELLOW_NODE, 0, 0, &info, &status ); check( MCAPI_SUCCESS, status ); //create our side of messaging yellow_msg_point = mcapi_endpoint_create( YELLOW_MSG, &status ); check( MCAPI_SUCCESS, status ); //obtain the red message point red_msg_point = mcapi_endpoint_get( THE_DOMAIN, RED_NODE, RED_MSG, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); printf(COLOR "start-up messaging\n"); //wait for the amount to come mcapi_msg_recv( yellow_msg_point, recv_buf, MAX_MSG_LEN, &size, &status ); check( MCAPI_SUCCESS, status ); //read the count from first byte count = recv_buf[0]; //surprise! this process reserves the buffer with malloc send_buf = (char*)malloc(count*2); //send ack send_buf[0] = 'a'; mcapi_msg_send( yellow_msg_point, red_msg_point, send_buf, 1, 0, &status ); check( MCAPI_SUCCESS, status ); printf(COLOR "start-up messaged with %u bytes. expecting %u scalars\n", size, count ); //open our channel endpoint to sin yellow_sin_chan = mcapi_endpoint_create( YELLOW_SIN, &status ); check( MCAPI_SUCCESS, status ); //open our channel endpoint to cos yellow_cos_chan = mcapi_endpoint_create( YELLOW_COS, &status ); check( MCAPI_SUCCESS, status ); //open our ends, let senders form connection mcapi_sclchan_recv_open_i( &sin_handle, yellow_sin_chan, &request, &status ); check( MCAPI_PENDING, status ); mcapi_sclchan_recv_open_i( &cos_handle, yellow_cos_chan, &request2, &status ); check( MCAPI_PENDING, status ); //wait for it to happen mcapi_wait( &request, &size, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); mcapi_wait( &request2, &size, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); printf(COLOR "beginning the receive value\n"); for ( i = 0; i < 15000; ++i ) { //an iterator used in loops unsigned int j = 0; //start to receveive stuff //i+=2 because our values are two bytes while buf is one byte for ( j = 0; j < count; ++j ) { //receive cos scalar short cval = mcapi_sclchan_recv_uint16( cos_handle, &status ); check( MCAPI_SUCCESS, status ); //receive sin scalar short sval = mcapi_sclchan_recv_uint16( sin_handle, &status ); check( MCAPI_SUCCESS, status ); //addition short sumval = sval + cval; //put to buf send_buf[j*2] = sumval; send_buf[j*2+1] = sumval >> 8; //printf( COLOR "%hX %hhX %hhX\n", sumval, send_buf[j*2], //send_buf[j*2+1] ); } } printf(COLOR "receiving done, closing scalar channels\n"); //close our ends mcapi_sclchan_recv_close_i( sin_handle, &request, &status ); check( MCAPI_PENDING, status ); mcapi_sclchan_recv_close_i( cos_handle, &request2, &status ); check( MCAPI_PENDING, status ); //wait for it to happen mcapi_wait( &request, &size, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); mcapi_wait( &request2, &size, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); printf(COLOR "closed, informing green\n"); //obtain their endpoint green_msg_point = mcapi_endpoint_get( THE_DOMAIN, GREEN_NODE, GREEN_MSG, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); //send the message mcapi_msg_send( yellow_msg_point, green_msg_point, send_buf, 1, 0, &status ); check( MCAPI_SUCCESS, status ); printf(COLOR "informed, opening packet channel\n"); //open our channel endpoint to green yellow_pkt_chan = mcapi_endpoint_create( YELLOW_PKT, &status ); check( MCAPI_SUCCESS, status ); //open our end, let receiver form connection mcapi_pktchan_send_open_i( &pkt_handle, yellow_pkt_chan, &request, &status ); check( MCAPI_PENDING, status ); //wait for it to happen mcapi_wait( &request, &size, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); //now send printf(COLOR "sending the packet\n"); mcapi_pktchan_send( pkt_handle, send_buf, count, &status ); //and now close printf(COLOR "sent the packet, closing\n"); mcapi_pktchan_send_close_i( pkt_handle, &request, &status ); check( MCAPI_PENDING, status ); mcapi_wait( &request, &size, TIMEOUT, &status ); check( MCAPI_SUCCESS, status ); printf(COLOR "closed, shutdown\n"); //free buf free( send_buf ); //shut-down mcapi_finalize( &status ); check( MCAPI_SUCCESS, status ); return EXIT_SUCCESS; }
/************************************************************************ * * FUNCTION * * MCAPID_Destroy_Service * * DESCRIPTION * * This function loops through a list of structures, deallocating * all resources associated with the respective endpoint. * * INPUTS * * *mcapi_struct A pointer to an array of MCAPID_STRUCT * structures populated by * MCAPID_Create_Service(). * * count The number of elements in the mcapi_struct * structure. * * RETURN * * None. The status field of each MCAPID_STRUCT parameter will be * set according to the status of that service request. * *************************************************************************/ void MCAPID_Destroy_Service(MCAPID_STRUCT *mcapi_struct, int count) { int i; for (i = 0; i < count; i ++) { /* Initialize status to success. */ mcapi_struct[i].status = MCAPI_SUCCESS; /* If a service was specified. */ if (mcapi_struct[i].service) { /* Operate on the service field based on the type of endpoint. */ switch (mcapi_struct[i].type) { /* Server endpoints remove services from the registry. */ case MCAPI_CHAN_PKT_RX_TYPE: case MCAPI_CHAN_SCL_RX_TYPE: case MCAPI_MSG_RX_TYPE: /* Remove the service from the registry. */ mcapi_struct[i].status = MCAPID_Remove_Service(mcapi_struct[i].service, mcapi_struct[i].node, mcapi_struct[i].local_port); break; default: break; } } if (mcapi_struct[i].status == MCAPI_SUCCESS) { /* Operate on the structure based on the type of endpoint being * created. */ switch (mcapi_struct[i].type) { /* The TX side of a packet channel. */ case MCAPI_CHAN_PKT_TX_TYPE: /* Close the TX side. */ mcapi_packetchan_send_close_i(mcapi_struct[i].pkt_tx_handle, &mcapi_struct[i].request, &mcapi_struct[i].status); break; case MCAPI_CHAN_PKT_RX_TYPE: /* Close the RX side. */ mcapi_packetchan_recv_close_i(mcapi_struct[i].pkt_rx_handle, &mcapi_struct[i].request, &mcapi_struct[i].status); break; case MCAPI_CHAN_SCL_TX_TYPE: /* Close the TX side. */ mcapi_sclchan_send_close_i(mcapi_struct[i].scl_tx_handle, &mcapi_struct[i].request, &mcapi_struct[i].status); break; case MCAPI_CHAN_SCL_RX_TYPE: /* Close the RX side. */ mcapi_sclchan_recv_close_i(mcapi_struct[i].scl_rx_handle, &mcapi_struct[i].request, &mcapi_struct[i].status); break; default: break; } } /* Delete the local endpoint. */ mcapi_delete_endpoint(mcapi_struct[i].local_endp, &mcapi_struct[i].status); } } /* MCAPID_Destroy_Service */