Subversion Repositories funbase_ip_library

#include <assert.h>

#include <limits.h>

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <fcntl.h>

#include <errno.h>

#include <time.h>

#include <mcapi.h>

#define WAIT_TIMEOUT 0xFFFFFFFF

#define mcapi_assert_success(s) \

        if (s != MCAPI_SUCCESS) { printf("%s:%d status %d\n", __FILE__, __LINE__, s); abort(); }

const int tx_port = 1000;

const int rx_port = 1001;

mcapi_pktchan_recv_hndl_t       send_handle;

mcapi_pktchan_recv_hndl_t       recv_handle;

static void connect(int local, int remote)

{

        mcapi_endpoint_t local_send_endpoint;

        mcapi_endpoint_t local_recv_endpoint;

        mcapi_endpoint_t remote_recv_endpoint;

        mcapi_request_t  request;

        mcapi_request_t  send_request;

        mcapi_request_t  recv_request;

        mcapi_status_t   status;

        size_t           size;

        printf("Node %d: Creating tx port %d\n", local, tx_port);

        local_send_endpoint = mcapi_create_endpoint(tx_port, &status);

        mcapi_assert_success(status);

        printf("Node %d: Creating rx port %d\n", local, rx_port);

        local_recv_endpoint = mcapi_create_endpoint(rx_port, &status);

        mcapi_assert_success(status);

        remote_recv_endpoint = mcapi_get_endpoint(remote, rx_port, &status);

        mcapi_assert_success(status);

        printf("Node %d: Connecting %d:%d to %d:%d\n",local, local, tx_port,

               remote, rx_port);

        mcapi_connect_pktchan_i(local_send_endpoint, remote_recv_endpoint,

                                &request, &status);

        mcapi_assert_success(status);

        mcapi_wait(&request, &size, &status, WAIT_TIMEOUT);

        mcapi_assert_success(status);

        printf("Node %d: Connection complete\n", local);

        printf("Node %d: Opening send endpoint\n", local);

        mcapi_open_pktchan_send_i(&send_handle, local_send_endpoint, &send_request,

                                                          &status);

        printf("Node %d: Opening receive endpoint\n", local);

        mcapi_open_pktchan_recv_i(&recv_handle, local_recv_endpoint, &recv_request,

                                                          &status);

        mcapi_wait(&send_request, &size, &status, WAIT_TIMEOUT);

        mcapi_assert_success(status);

        mcapi_wait(&recv_request, &size, &status, WAIT_TIMEOUT);

        mcapi_assert_success(status);

        printf("Node %d: MCAPI negotiation complete! \n", local);

}

void startup(unsigned int local, unsigned int remote)

{

        mcapi_status_t status;

        mcapi_version_t version;

        printf("Node %d: MCAPI Initialized\n",local);

        mcapi_initialize(local, &version, &status);

        mcapi_assert_success(status);

        connect(local, remote);

}

void demo(unsigned int node, int loop)

{

        char outgoing[16];

        char *incoming;

        size_t bytes;

        mcapi_status_t status;

        do {

                memset(outgoing, 0, 16);

                sprintf(outgoing, "hi from node %d", node);

                mcapi_pktchan_send(send_handle, outgoing, strlen(outgoing)+1,

                        &status);

                mcapi_assert_success(status);

                mcapi_pktchan_recv(recv_handle, (void *)&incoming, &bytes,

                        &status);

                printf("received message: %s\n", incoming);

                mcapi_pktchan_free(incoming, &status);

                mcapi_assert_success(status);

                sleep(1);

        } while (loop);

}