LOCATION loc;
NODE_INFO ni;

// find and print details of all discovered management processes
loc = mhpeFindMaster(0);
while (loc != BAD_LOCATION) {
    if (GetRtNodeInfo(loc, &ni)) {
        printf("loc %u: %s (%s)\n", loc, ni.szNodeName, ni.NetIdType == NETID_TYPE_NONE ? "local" : "remote");
    }
    loc = mhpeFindMaster(loc);
}

HPESTATUS st;
MHPEHANDLE if_handle = BAD_RTHANDLE;
LOCATION node_loc = THIS_LOCATION;
const char *if_name = "ie1g0";

// attach to the management process at the given location
st = mhpeAttachMaster(node_loc);
if (st != E_OK) {
        fprintf(stderr, "Failed to attach to master at location %u\n", node_loc);
}
else {
        // attempt to open an interface
        st = mhpeOpenInterface(node_loc, if_name, &if_handle);
        if (st != E_OK) {
                // if the interface does not already exist, we may attempt to create
        st = mhpeCreateInterfaceWithOptions(node_loc, if_name, opts, sizeof(*opts), &if_handle);
        }
}

MHPESTATUS st;
HPE_INTERFACE_ENDPOINTS mhpe_endp;
char epname[64];
DWORD index;

// Get endpoint information from the interface (count of each endpoint type)
// h is the handle of an open interface
st = mhpeGetInterfaceInfo(h, MHPE_INFO_INTERFACE_ENDPOINTS, (LPVOID)&mhpe_endp, sizeof(mhpe_endp));
if (st != E_OK) {
        mhpeCloseInterface(h);
        printf("mhpeGetInterfaceInfo(HPE_INFO_INTERFACE_ENDPOINTS) failed with status %04x\n", st);
        return 1;
}
printf("\t%u Endpoints: %u tx, %u rx, %u timer\n",
        mhpe_endp.n_endpoints, mhpe_endp.n_tx_queues,
        mhpe_endp.n_rx_queues, mhpe_endp.n_1588timers);

// Enumerate all endpoint names
for (index = 0; ; index++) {
        if (0 != mhpeEnumEndpoints(h, index, epname, sizeof(epname)))
                break;
        printf("Endpoint %u: %s\n", index, epname);
}

MHPESTATUS st;
MHPEHANDLE tx_ep;
DWORD channel = 1;              // use endpoint index 1

// h is the handle of an open interface
st = mhpeOpenEndpoint(h, MHPE_EP_TX_QUEUE, channel, EP_ACC_WRITE_SHARE, &tx_ep);
if (st != E_OK) {
        printf("Failed to open Tx endpoint %u on %s\n", channel, h);
        return;
}
// Optionally call mhpeSetTransmitAttributes to change the transmit queue properties. 
// For example, enable transmit timestamps:
st = mhpeSetTransmitAttributes(tx_ep, HPE_TX_TIMESTAMP_2STEP);
if (st != E_OK) {
        printf("Failed to set TX timestamps\n");
}
else {
        printf("Enabled TX timestmaps\n");
}

// user function to initialize the frames to be transmitted
FillTransmitPayload(tx_buffers[0].fragments[1].ptr);

mhpeAttachTransmitBufferSet(tx_ep, tx_buffers);
st = hpeStartTransmitter(tx_ep);

// Wait for transmission to complete
// 'interrupts' contains the interrupt mode that the interface was opened with
if (interrupts & OUTPUT_INTERRUPT) {
        for (j = 0; j < (int)txs->buffer_count; j++) {
                if ((st = mhpeWaitForTransmitComplete(tx_ep, 1000000)) != E_OK) {
                        printf("TX: hpeWaitForTransmitComplete failed: %04x\n", st);
                        goto close;
                }
        }
}
else {
        // wait for transmit to complete
        while (mhpeGetTransmitterState(tx_ep, &txstate) == E_OK
                && txstate == HPE_TXBUSY)
                RtSleepEx(1);
}

// user function to initialize the frames to be transmitted
MHPEBUFFER *rxbuffer;

mhpeWaitForReceiveComplete(rx_ep, 1000000);
if (mhpeGetReceiveBuffer(handle, &rxbuffer) == E_OK)
    process_buffer_data(rxbuffer->ptr, rxbuffer->used);       // user function