static CCNxMetaMessage *
_TemplateReceive(AthenaTransportLink *athenaTransportLink)
{
struct _TemplateLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
CCNxMetaMessage *ccnxMetaMessage = NULL;
PARCBuffer *wireFormatBuffer = _internalRECEIVE(linkData);
// On error, just return and retry.
if (wireFormatBuffer == NULL) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "read error (%s)", strerror(errno));
return NULL;
}
// Construct, and return a ccnxMetaMessage from the wire format buffer.
ccnxMetaMessage = ccnxMetaMessage_CreateFromWireFormatBuffer(wireFormatBuffer);
if (ccnxMetaMessage == NULL) {
linkData->_stats.receive_DecodeFailed++;
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink), "Failed to decode message from received packet.");
}
parcBuffer_Release(&wireFormatBuffer);
if (parcDeque_Size(linkData->queue) > 0) { // if there's another message, mark an event.
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Receive);
}
return ccnxMetaMessage;
}
//
// Peek at the header and derive our total message length
//
static size_t
_messageLengthFromHeader(AthenaTransportLink *athenaTransportLink, _UDPLinkData *linkData)
{
// Peek at our message header to determine the total length of buffer we need to allocate.
size_t fixedHeaderLength = ccnxCodecTlvPacket_MinimalHeaderLength();
PARCBuffer *wireFormatBuffer = parcBuffer_Allocate(fixedHeaderLength);
const uint8_t *peekBuffer = parcBuffer_Overlay(wireFormatBuffer, 0);
ssize_t readCount = recv(linkData->fd, (void *) peekBuffer, fixedHeaderLength, MSG_PEEK);
if (readCount == -1) {
parcBuffer_Release(&wireFormatBuffer);
if ((errno == EAGAIN) || (errno == EINTR)) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "recv retry (%s)", strerror(errno));
linkData->_stats.receive_ReadRetry++;
} else {
linkData->_stats.receive_ReadError++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "recv error (%s)", strerror(errno));
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Error);
}
return -1;
}
// A zero read means no data
if (readCount == 0) {
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
// Check for a short header read, since we're only peeking here we just return and retry later
if (readCount != fixedHeaderLength) {
linkData->_stats.receive_ReadHeaderFailure++;
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
// Obtain the total size of the message from the header
size_t messageLength = ccnxCodecTlvPacket_GetPacketLength(wireFormatBuffer);
parcBuffer_Release(&wireFormatBuffer);
// Could do more to check the integrity of the message and framing.
// If length is greater than our MTU we will find out in the read.
if (messageLength < fixedHeaderLength) {
linkData->_stats.receive_BadMessageLength++;
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink), "Framing error, flushing link.");
char trash[MAXPATHLEN];
// Flush link to attempt to resync our framing
while (read(linkData->fd, trash, sizeof(trash)) == sizeof(trash)) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink), "... flushing link.");
}
return -1;
}
return messageLength;
}
//
// Receive a message from the specified link.
//
static CCNxMetaMessage *
_ETHReceiveMessage(AthenaTransportLink *athenaTransportLink, struct ether_addr *peerAddress, socklen_t *peerAddressLength)
{
struct _ETHLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
CCNxMetaMessage *ccnxMetaMessage = NULL;
AthenaTransportLinkEvent events = 0;
PARCBuffer *message = athenaEthernet_Receive(linkData->athenaEthernet, -1, &events);
if (message == NULL) {
return NULL;
}
// Mark any pending events
if (events) {
athenaTransportLink_SetEvent(athenaTransportLink, events);
}
// Map the header
struct ether_header *header = parcBuffer_Overlay(message, sizeof(struct ether_header));
// If the destination does not match my address, drop the message
if (memcmp(&linkData->link.myAddress, header->ether_dhost, ETHER_ADDR_LEN * sizeof(uint8_t)) != 0) {
linkData->_stats.receive_NoLinkDestination++;
parcBuffer_Release(&message);
return NULL;
}
assertTrue(header->ether_type == htons(CCNX_ETHERTYPE), "Unexpected ether type %x", header->ether_type);
// Set peerAddress from header source address
*peerAddressLength = ETHER_ADDR_LEN * sizeof(uint8_t);
memcpy(peerAddress, header->ether_shost, *peerAddressLength);
parcBuffer_SetPosition(message, sizeof(struct ether_header));
PARCBuffer *wireFormatBuffer = parcBuffer_Slice(message);
parcBuffer_Release(&message);
parcBuffer_SetPosition(wireFormatBuffer, 0);
// Construct, and return a ccnxMetaMessage from the wire format buffer.
ccnxMetaMessage = ccnxMetaMessage_CreateFromWireFormatBuffer(wireFormatBuffer);
if (ccnxMetaMessage == NULL) {
linkData->_stats.receive_DecodeFailed++;
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink), "Failed to decode message from received packet.");
} else if (ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage) == CCNxTlvDictionary_SchemaVersion_V0) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"received deprecated version %d message\n", ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage));
}
parcBuffer_Release(&wireFormatBuffer);
return ccnxMetaMessage;
}
static void
_TemplateClose(AthenaTransportLink *athenaTransportLink)
{
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"link %s closed", athenaTransportLink_GetName(athenaTransportLink));
_TemplateLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
_TemplateLinkData_Destroy(&linkData);
}
static AthenaTransportLink *
_newLink(AthenaTransportLink *athenaTransportLink, _UDPLinkData *newLinkData)
{
// Accept a new tunnel connection.
// Clone a new link from the current listener.
const char *derivedLinkName = _createNameFromLinkData(&newLinkData->link);
AthenaTransportLink *newTransportLink = athenaTransportLink_Clone(athenaTransportLink,
derivedLinkName,
_UDPSend,
_UDPReceiveProxy,
_UDPClose);
if (newTransportLink == NULL) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"athenaTransportLink_Clone failed");
parcMemory_Deallocate(&derivedLinkName);
_UDPLinkData_Destroy(&newLinkData);
return NULL;
}
_setConnectLinkState(newTransportLink, newLinkData);
// Send the new link up to be added.
int result = athenaTransportLink_AddLink(athenaTransportLink, newTransportLink);
if (result == -1) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"athenaTransportLink_AddLink failed: %s", strerror(errno));
_UDPLinkData_Destroy(&newLinkData);
athenaTransportLink_Release(&newTransportLink);
} else {
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"new link accepted by %s: %s %s",
athenaTransportLink_GetName(athenaTransportLink), derivedLinkName,
athenaTransportLink_IsNotLocal(athenaTransportLink) ? "" : "(Local)");
}
parcMemory_Deallocate(&derivedLinkName);
// Could pass a message back here regarding the new link.
return newTransportLink;
}
static bool
_linkIsEOF(AthenaTransportLink *athenaTransportLink)
{
struct _UDPLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
// If poll indicates there's a read event and a subsequent read returns zero our peer has hungup.
struct pollfd pollfd = { .fd = linkData->fd, .events = POLLIN };
int events = poll(&pollfd, 1, 0);
if (events == -1) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink), "poll error (%s)", strerror(errno));
return true; // poll error, close the link
} else if (events == 0) {
// there are no pending events, was truly a zero read
return false;
}
if (pollfd.revents & POLLIN) {
char peekBuffer;
ssize_t readCount = recv(linkData->fd, (void *) &peekBuffer, 1, MSG_PEEK);
if (readCount == -1) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK)) { // read blocked
linkData->_stats.receive_ReadWouldBlock++;
return false;
}
return true; // read error
}
if (readCount == 0) { // EOF
return true;
}
}
return false;
}
static void
_UDPClose(AthenaTransportLink *athenaTransportLink)
{
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"link %s closed", athenaTransportLink_GetName(athenaTransportLink));
_UDPLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
}
//
// Open a listener which will create new links when messages arrive and queue them appropriately.
// Listeners are inherently insecure, as an adversary could easily create many connections that are never closed.
//
static AthenaTransportLink *
_UDPOpenListener(AthenaTransportLinkModule *athenaTransportLinkModule, const char *linkName, struct sockaddr_in *destination, size_t mtu)
{
const char *derivedLinkName;
_UDPLinkData *linkData = _UDPLinkData_Create();
linkData->multiplexTable = parcHashCodeTable_Create(_connectionEquals, _connectionHashCode, NULL, _closeConnection);
assertNotNull(linkData->multiplexTable, "Could not create multiplex table for new listener");
linkData->link.myAddress = *destination;
linkData->link.myAddressLength = sizeof(struct sockaddr_in);
linkData->link.mtu = mtu;
linkData->fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (linkData->fd < 0) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"socket error (%s)", strerror(errno));
_UDPLinkData_Destroy(&linkData);
return NULL;
}
int result = _setSocketOptions(athenaTransportLinkModule, linkData->fd);
if (result) {
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
// Set non-blocking flag
int flags = fcntl(linkData->fd, F_GETFL, NULL);
if (flags < 0) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"fcntl failed to get non-blocking flag (%s)", strerror(errno));
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
result = fcntl(linkData->fd, F_SETFL, flags | O_NONBLOCK);
if (result) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"fcntl failed to set non-blocking flag (%s)", strerror(errno));
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
// bind to listen on requested address
result = bind(linkData->fd, (struct sockaddr *) &linkData->link.myAddress, linkData->link.myAddressLength);
if (result) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"bind error (%s)", strerror(errno));
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
derivedLinkName = _createNameFromLinkData(&linkData->link);
if (linkName == NULL) {
linkName = derivedLinkName;
}
// Listener doesn't require a send method. The receive method is used to establish new connections.
AthenaTransportLink *athenaTransportLink = athenaTransportLink_Create(linkName,
NULL,
_UDPReceiveListener,
_UDPClose);
if (athenaTransportLink == NULL) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"athenaTransportLink_Create failed");
parcMemory_Deallocate(&derivedLinkName);
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return athenaTransportLink;
}
athenaTransportLink_SetPrivateData(athenaTransportLink, linkData);
athenaTransportLink_SetEventFd(athenaTransportLink, linkData->fd);
// Links established for listening are not used to route messages.
// They can be kept in a listener list that doesn't consume a linkId.
athenaTransportLink_SetRoutable(athenaTransportLink, false);
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"new listener established: Name=\"%s\" (%s)", linkName, derivedLinkName);
parcMemory_Deallocate(&derivedLinkName);
return athenaTransportLink;
}
//
// Open a UDP point to point connection.
//
static AthenaTransportLink *
_UDPOpenConnection(AthenaTransportLinkModule *athenaTransportLinkModule, const char *linkName, struct sockaddr_in *source, struct sockaddr_in *destination, size_t mtu)
{
const char *derivedLinkName;
_UDPLinkData *linkData = _UDPLinkData_Create();
linkData->link.peerAddress = *((struct sockaddr_in *) destination);
linkData->link.peerAddressLength = sizeof(struct sockaddr_in);
linkData->link.mtu = mtu;
linkData->fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (linkData->fd < 0) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule), "socket error (%s)", strerror(errno));
_UDPLinkData_Destroy(&linkData);
return NULL;
}
int result = _setSocketOptions(athenaTransportLinkModule, linkData->fd);
if (result) {
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
// bind the local endpoint so we can know our allocated port if it was wildcarded
result = bind(linkData->fd, (struct sockaddr *) source, sizeof(struct sockaddr_in));
if (result) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"bind error (%s)", strerror(errno));
close(linkData->fd);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
// Retrieve the local endpoint data, used to create the derived name.
linkData->link.myAddressLength = sizeof(struct sockaddr_in);
result = getsockname(linkData->fd, (struct sockaddr *) &linkData->link.myAddress, &linkData->link.myAddressLength);
if (result != 0) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"Failed to obtain endpoint information from getsockname.");
_UDPLinkData_Destroy(&linkData);
return NULL;
}
derivedLinkName = _createNameFromLinkData(&linkData->link);
if (linkName == NULL) {
linkName = derivedLinkName;
}
AthenaTransportLink *athenaTransportLink = athenaTransportLink_Create(linkName,
_UDPSend,
_UDPReceive,
_UDPClose);
if (athenaTransportLink == NULL) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"athenaTransportLink_Create failed");
parcMemory_Deallocate(&derivedLinkName);
_UDPLinkData_Destroy(&linkData);
return NULL;
}
_setConnectLinkState(athenaTransportLink, linkData);
// Enable Send? XXX
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Send);
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"new link established: Name=\"%s\" (%s)", linkName, derivedLinkName);
parcMemory_Deallocate(&derivedLinkName);
return athenaTransportLink;
return NULL;
}
//
// Receive a message from the specified link.
//
static CCNxMetaMessage *
_UDPReceiveMessage(AthenaTransportLink *athenaTransportLink, struct sockaddr_in *peerAddress, socklen_t *peerAddressLength)
{
struct _UDPLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
CCNxMetaMessage *ccnxMetaMessage = NULL;
size_t messageLength;
// If an MTU has been set, allocate a buffer of that size to avoid having to peek at the message,
// othersize derive the link from the header and allocate a buffer based on the message size.
if ((messageLength = linkData->link.mtu) == 0) {
messageLength = _messageLengthFromHeader(athenaTransportLink, linkData);
if (messageLength <= 0) {
return NULL;
}
}
PARCBuffer *wireFormatBuffer = parcBuffer_Allocate(messageLength);
char *buffer = parcBuffer_Overlay(wireFormatBuffer, 0);
*peerAddressLength = (socklen_t) sizeof(struct sockaddr_in);
ssize_t readCount = recvfrom(linkData->fd, buffer, messageLength, 0, (struct sockaddr *) peerAddress, peerAddressLength);
// On error, just return and retry.
if (readCount == -1) {
linkData->_stats.receive_ReadError++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "read error (%s)", strerror(errno));
parcBuffer_Release(&wireFormatBuffer);
return NULL;
}
// A zero read means either no more data is currently available or our peer hungup.
// Just return to retry as we'll detect EOF when we come back at the top of UDPReceive
if (readCount == 0) {
parcBuffer_Release(&wireFormatBuffer);
return NULL;
}
// If it was it a short read just return to retry later.
while (readCount < messageLength) {
linkData->_stats.receive_ShortRead++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "short read error (%s)", strerror(errno));
parcBuffer_Release(&wireFormatBuffer);
return NULL;
}
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "received message (size=%d)", readCount);
parcBuffer_SetPosition(wireFormatBuffer, parcBuffer_Position(wireFormatBuffer) + readCount);
parcBuffer_Flip(wireFormatBuffer);
// Construct, and return a ccnxMetaMessage from the wire format buffer.
ccnxMetaMessage = ccnxMetaMessage_CreateFromWireFormatBuffer(wireFormatBuffer);
if (ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage) == CCNxTlvDictionary_SchemaVersion_V0) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"received deprecated version %d message\n", ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage));
}
if (ccnxMetaMessage == NULL) {
linkData->_stats.receive_DecodeFailed++;
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink), "Failed to decode message from received packet.");
}
parcBuffer_Release(&wireFormatBuffer);
return ccnxMetaMessage;
}
static int
_UDPSend(AthenaTransportLink *athenaTransportLink, CCNxMetaMessage *ccnxMetaMessage)
{
struct _UDPLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
if (ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage) == CCNxTlvDictionary_SchemaVersion_V0) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"sending deprecated version %d message\n", ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage));
}
// Get a wire format buffer and write it out.
PARCBuffer *wireFormatBuffer = ccnxWireFormatMessage_GetWireFormatBuffer(ccnxMetaMessage);
if (wireFormatBuffer == NULL) {
CCNxCodecNetworkBufferIoVec *iovec = ccnxWireFormatMessage_GetIoVec(ccnxMetaMessage);
assertNotNull(iovec, "Null io vector");
size_t iovcnt = ccnxCodecNetworkBufferIoVec_GetCount((CCNxCodecNetworkBufferIoVec *) iovec);
const struct iovec *array = ccnxCodecNetworkBufferIoVec_GetArray((CCNxCodecNetworkBufferIoVec *) iovec);
// If it's a single vector wrap it in a buffer to avoid a copy
if (iovcnt == 1) {
wireFormatBuffer = parcBuffer_Wrap(array[0].iov_base, array[0].iov_len, 0, array[0].iov_len);
} else {
size_t totalbytes = 0;
for (int i = 0; i < iovcnt; i++) {
totalbytes += array[i].iov_len;
}
wireFormatBuffer = parcBuffer_Allocate(totalbytes);
for (int i = 0; i < iovcnt; i++) {
parcBuffer_PutArray(wireFormatBuffer, array[i].iov_len, array[i].iov_base);
}
parcBuffer_Flip(wireFormatBuffer);
}
} else {
wireFormatBuffer = parcBuffer_Acquire(wireFormatBuffer);
}
size_t length = parcBuffer_Limit(wireFormatBuffer);
char *buffer = parcBuffer_Overlay(wireFormatBuffer, length);
if (linkData->link.mtu) {
if (length > linkData->link.mtu) {
errno = EMSGSIZE;
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
}
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"sending message (size=%d)", length);
ssize_t writeCount = 0;
#ifdef LINUX_IGNORESIGPIPE
writeCount = sendto(linkData->fd, buffer, length, MSG_NOSIGNAL,
(struct sockaddr *) &linkData->link.peerAddress, linkData->link.peerAddressLength);
#else
writeCount = sendto(linkData->fd, buffer, length, 0,
(struct sockaddr *) &linkData->link.peerAddress, linkData->link.peerAddressLength);
#endif
// on error close the link, else return to retry a zero write
if (writeCount == -1) {
if (errno == EPIPE) {
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Error);
}
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"send error (%s)", strerror(errno));
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
// Short write
if (writeCount != length) {
linkData->_stats.receive_ShortWrite++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "short write");
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
parcBuffer_Release(&wireFormatBuffer);
return 0;
}
static int
_UDPSend(AthenaTransportLink *athenaTransportLink, CCNxMetaMessage *ccnxMetaMessage)
{
struct _UDPLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
if (ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage) == CCNxTlvDictionary_SchemaVersion_V0) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"sending deprecated version %d message\n", ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage));
}
// Get a wire format buffer and write it out.
PARCBuffer *wireFormatBuffer = athenaTransportLinkModule_GetMessageBuffer(ccnxMetaMessage);
parcBuffer_SetPosition(wireFormatBuffer, 0);
size_t length = parcBuffer_Limit(wireFormatBuffer);
char *buffer = parcBuffer_Overlay(wireFormatBuffer, length);
if (linkData->link.mtu) {
if (length > linkData->link.mtu) {
errno = EMSGSIZE;
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
}
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"sending message (size=%d)", length);
ssize_t writeCount = 0;
#ifdef LINUX_IGNORESIGPIPE
writeCount = sendto(linkData->fd, buffer, length, MSG_NOSIGNAL,
(struct sockaddr *) &linkData->link.peerAddress, linkData->link.peerAddressLength);
#else
writeCount = sendto(linkData->fd, buffer, length, 0,
(struct sockaddr *) &linkData->link.peerAddress, linkData->link.peerAddressLength);
#endif
// on error close the link, else return to retry a zero write
if (writeCount == -1) {
if ((errno == EAGAIN) || (errno == EINTR)) {
linkData->_stats.send_SendRetry++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "send retry (%s)", strerror(errno));
} else {
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Error);
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"send error (%s)", strerror(errno));
}
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
// Short write
if (writeCount != length) {
linkData->_stats.send_ShortWrite++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "short write");
parcBuffer_Release(&wireFormatBuffer);
return -1;
}
parcBuffer_Release(&wireFormatBuffer);
return 0;
}
//
// Open a listener which will create new links when messages arrive and queue them appropriately.
// Listeners are inherently insecure, as an adversary could easily create many connections that are never closed.
//
static AthenaTransportLink *
_ETHOpenListener(AthenaTransportLinkModule *athenaTransportLinkModule, const char *linkName, const char *device, struct ether_addr *source, size_t mtu)
{
const char *derivedLinkName;
_ETHLinkData *linkData = _ETHLinkData_Create();
linkData->multiplexTable = parcHashCodeTable_Create(_connectionEquals, _connectionHashCode, NULL, _closeConnection);
assertNotNull(linkData->multiplexTable, "Could not create multiplex table for new listener");
linkData->athenaEthernet = athenaEthernet_Create(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
device, CCNX_ETHERTYPE);
if (linkData->athenaEthernet == NULL) {
_ETHLinkData_Destroy(&linkData);
return NULL;
}
// Use specified source MAC address, or default to device MAC
if (source) {
memcpy(&(linkData->link.myAddress), source, sizeof(struct ether_addr));
} else {
athenaEthernet_GetMAC(linkData->athenaEthernet, &(linkData->link.myAddress));
}
linkData->link.myAddressLength = ETHER_ADDR_LEN;
if (linkData->athenaEthernet == NULL) {
parcLog_Error(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
"athenaEthernet_Create error");
_ETHLinkData_Destroy(&linkData);
return NULL;
}
derivedLinkName = _createNameFromLinkData(&linkData->link, true);
if (linkName == NULL) {
linkName = derivedLinkName;
}
// Listener doesn't require a send method. The receive method is used to establish new connections.
AthenaTransportLink *athenaTransportLink = athenaTransportLink_Create(linkName,
NULL,
_ETHReceiveListener,
_ETHClose);
if (athenaTransportLink == NULL) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"athenaTransportLink_Create failed");
parcMemory_Deallocate(&derivedLinkName);
_ETHLinkData_Destroy(&linkData);
return athenaTransportLink;
}
athenaTransportLink_SetPrivateData(athenaTransportLink, linkData);
athenaTransportLink_SetEventFd(athenaTransportLink, athenaEthernet_GetDescriptor(linkData->athenaEthernet));
// Links established for listening are not used to route messages.
// They can be kept in a listener list that doesn't consume a linkId.
athenaTransportLink_SetRoutable(athenaTransportLink, false);
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"new listener established: Name=\"%s\" (%s)", linkName, derivedLinkName);
parcMemory_Deallocate(&derivedLinkName);
return athenaTransportLink;
}
//
// Open a point to point connection.
//
static AthenaTransportLink *
_ETHOpenConnection(AthenaTransportLinkModule *athenaTransportLinkModule, const char *linkName, const char *device, struct ether_addr *source, struct ether_addr *destination, size_t mtu)
{
const char *derivedLinkName;
_ETHLinkData *linkData = _ETHLinkData_Create();
linkData->athenaEthernet = athenaEthernet_Create(athenaTransportLinkModule_GetLogger(athenaTransportLinkModule),
device, CCNX_ETHERTYPE);
if (linkData->athenaEthernet == NULL) {
_ETHLinkData_Destroy(&linkData);
return NULL;
}
// Use our default MAC address if none specified.
if (source == NULL) {
athenaEthernet_GetMAC(linkData->athenaEthernet, &(linkData->link.myAddress));
linkData->link.myAddressLength = ETHER_ADDR_LEN;
} else {
memcpy(&(linkData->link.myAddress), source, sizeof(struct ether_addr));
}
// If there's no destination specified, drop the request.
if (destination == NULL) {
_ETHLinkData_Destroy(&linkData);
return NULL;
}
// Copy the peer destination address into our link data
memcpy(&(linkData->link.peerAddress), destination, sizeof(struct ether_addr));
derivedLinkName = _createNameFromLinkData(&linkData->link, false);
if (linkName == NULL) {
linkName = derivedLinkName;
}
AthenaTransportLink *athenaTransportLink = athenaTransportLink_Create(linkName,
_ETHSend,
_ETHReceive,
_ETHClose);
if (athenaTransportLink == NULL) {
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"athenaTransportLink_Create failed");
parcMemory_Deallocate(&derivedLinkName);
_ETHLinkData_Destroy(&linkData);
return NULL;
}
_setConnectLinkState(athenaTransportLink, linkData);
// Enable Sends
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Send);
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink),
"new link established: Name=\"%s\" (%s)", linkName, derivedLinkName);
parcMemory_Deallocate(&derivedLinkName);
return athenaTransportLink;
return NULL;
}
static int
_ETHSend(AthenaTransportLink *athenaTransportLink, CCNxMetaMessage *ccnxMetaMessage)
{
struct _ETHLinkData *linkData = athenaTransportLink_GetPrivateData(athenaTransportLink);
if (ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage) == CCNxTlvDictionary_SchemaVersion_V0) {
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"sending deprecated version %d message\n", ccnxTlvDictionary_GetSchemaVersion(ccnxMetaMessage));
}
// Construct our header to prepend
struct ether_header header;
memcpy(header.ether_shost, &(linkData->link.myAddress), ETHER_ADDR_LEN * sizeof(uint8_t));
memcpy(header.ether_dhost, &(linkData->link.peerAddress), ETHER_ADDR_LEN * sizeof(uint8_t));
header.ether_type = htons(athenaEthernet_GetEtherType(linkData->athenaEthernet));
// An iovec to contain the header and packet data
struct iovec iov[2];
struct iovec *array = iov;
int iovcnt = 2;
size_t messageLength = 0;
// If the iovec we're prepending to has more than one element, allocatedIovec holds the
// allocated IO vector of the right size that we must deallocate before returning.
struct iovec *allocatedIovec = NULL;
// Attach the header and populate the iovec
CCNxCodecNetworkBufferIoVec *iovec = athenaTransportLinkModule_GetMessageIoVector(ccnxMetaMessage);
iovcnt = ccnxCodecNetworkBufferIoVec_GetCount((CCNxCodecNetworkBufferIoVec *) iovec);
const struct iovec *networkBufferIovec = ccnxCodecNetworkBufferIoVec_GetArray((CCNxCodecNetworkBufferIoVec *) iovec);
// Trivial case, single iovec element.
if (iovcnt == 1) {
// Header
array[0].iov_len = sizeof(struct ether_header);
array[0].iov_base = &header;
// Message content
array[1].iov_len = networkBufferIovec->iov_len;
array[1].iov_base = networkBufferIovec->iov_base;
messageLength = array[0].iov_len + array[1].iov_len;
} else {
// Allocate a new iovec if more than one vector
allocatedIovec = parcMemory_Allocate(sizeof(struct iovec) * (iovcnt + 1));
array = allocatedIovec;
// Header
array[0].iov_len = sizeof(struct ether_header);
array[0].iov_base = &header;
messageLength = array[0].iov_len;
// Append message content
for (int i = 0; i < iovcnt; i++) {
array[i + 1].iov_len = networkBufferIovec[i].iov_len;
array[i + 1].iov_base = networkBufferIovec[i].iov_base;
messageLength += array[i + 1].iov_len;
}
}
iovcnt++; // increment for the header
if (linkData->link.mtu) {
if (messageLength > linkData->link.mtu) {
if (allocatedIovec != NULL) {
parcMemory_Deallocate(&allocatedIovec);
}
ccnxCodecNetworkBufferIoVec_Release(&iovec);
errno = EMSGSIZE;
return -1;
}
}
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink),
"sending message (size=%d)", messageLength);
ssize_t writeCount = 0;
writeCount = athenaEthernet_Send(linkData->athenaEthernet, array, iovcnt);
ccnxCodecNetworkBufferIoVec_Release(&iovec);
// Free up any storage allocated for a non-singular iovec
if (allocatedIovec != NULL) {
parcMemory_Deallocate(&allocatedIovec);
array = NULL;
}
// on error close the link, else return to retry a zero write
if (writeCount == -1) {
if ((errno == EAGAIN) || (errno == EINTR)) {
parcLog_Info(athenaTransportLink_GetLogger(athenaTransportLink), "send retry");
linkData->_stats.send_Retry++;
return -1;
}
athenaTransportLink_SetEvent(athenaTransportLink, AthenaTransportLinkEvent_Error);
parcLog_Error(athenaTransportLink_GetLogger(athenaTransportLink),
"send error (%s)", strerror(errno));
linkData->_stats.send_Error++;
return -1;
}
// Short write
if (writeCount != messageLength) {
linkData->_stats.send_ShortWrite++;
parcLog_Debug(athenaTransportLink_GetLogger(athenaTransportLink), "short write");
return -1;
}
return 0;
}
