PARCBuffer *
parcLogFormatText_FormatEntry(const PARCLogEntry *entry)
{
PARCBuffer *payload = parcLogEntry_GetPayload(entry);
char theTime[64];
parcTime_TimevalAsRFC3339(parcLogEntry_GetTimeStamp(entry), theTime);
PARCBufferComposer *composer = parcBufferComposer_Allocate(128);
parcBufferComposer_PutStrings(composer,
theTime, " ",
parcLogLevel_ToString(parcLogEntry_GetLevel(entry)), " ",
parcLogEntry_GetHostName(entry), " ",
parcLogEntry_GetApplicationName(entry), " ",
parcLogEntry_GetProcessName(entry), " ", NULL);
parcBufferComposer_Format(composer, "%" PRId64 " [ ", parcLogEntry_GetMessageId(entry));
parcBufferComposer_PutBuffer(composer, payload);
parcBufferComposer_PutStrings(composer, " ]\n", NULL);
PARCBuffer *result = parcBuffer_Flip(parcBuffer_Acquire(parcBufferComposer_GetBuffer(composer)));
parcBufferComposer_Release(&composer);
return result;
}
PARCJSONParser *
parcJSONParser_Create(PARCBuffer *buffer)
{
PARCJSONParser *result = parcObject_CreateInstance(PARCJSONParser);
result->ignore = " \t\n";
result->buffer = parcBuffer_Acquire(buffer);
return result;
}
int
reader_writer(CCNxPortalFactory *factory, const char *uri)
{
CCNxPortal *portal = ccnxPortalFactory_GetInstance(factory, ccnxPortalTypeDatagram, ccnxPortalProtocol_TLV, &ccnxPortalAttributes_Blocking);
CCNxName *prefix = ccnxName_CreateFromURI(uri);
CCNxName *bye = ccnxName_CreateFromURI("lci:/Hello/Goodbye%21");
CCNxName *contentname = ccnxName_CreateFromURI("lci:/Hello/World");
if (ccnxPortal_Listen(portal, prefix, 365 * 86400, CCNxStackTimeout_Never)) {
CCNxMetaMessage *msg;
while ((msg = ccnxPortal_Receive(portal, CCNxStackTimeout_Never)) != NULL) {
if (ccnxMetaMessage_IsInterest(msg)) {
CCNxInterest *interest = ccnxMetaMessage_GetInterest(msg);
CCNxName *interestName = ccnxInterest_GetName(interest);
if (ccnxName_Equals(interestName, contentname)) {
const PARCKeyId *publisherKeyId = ccnxPortal_GetKeyId(portal);
char buffer[128];
time_t theTime = time(0);
sprintf(buffer, "Hello World. The time is %s", ctime(&theTime));
PARCBuffer *payload = parcBuffer_CreateFromArray(buffer, 128);
parcBuffer_Flip(payload);
PARCBuffer *b = parcBuffer_Acquire(payload);
CCNxContentObject *uob = ccnxContentObject_CreateWithDataPayload(contentname, b);
// missing NULL check, case 1024
CCNxMetaMessage *message = ccnxMetaMessage_CreateFromContentObject(uob);
if (ccnxPortal_Send(portal, message, CCNxTransportStackTimeCCNxStackTimeout_Neverout_Never) == false) {
fprintf(stderr, "ccnx_write failed\n");
}
// ccnxMessage_Release(message);
} else if (ccnxName_Equals(interestName, bye)) {
break;
}
} else {
ccnxMetaMessage_Display(msg, 0);
}
ccnxMetaMessage_Release(&msg);
}
}
ccnxName_Release(&prefix);
ccnxName_Release(&bye);
ccnxName_Release(&contentname);
ccnxPortal_Release(&portal);
return 0;
}
PARCURISegment *
parcURISegment_CreateFromBuffer(PARCBuffer *buffer)
{
PARCURISegment *result = parcObject_CreateInstance(PARCURISegment);
if (result != NULL) {
result->buffer = parcBuffer_Acquire(buffer);
}
return result;
}
CCNxManifestHashGroupPointer *
ccnxManifestHashGroupPointer_Create(CCNxManifestHashGroupPointerType type, const PARCBuffer *digest)
{
CCNxManifestHashGroupPointer *ptr = parcObject_CreateAndClearInstance(CCNxManifestHashGroupPointer);
if (ptr != NULL) {
ptr->pointerType = type;
ptr->digest = parcBuffer_Acquire(digest);
}
return ptr;
}
CCNxNameSegment *
ccnxNameSegment_CreateLabelValue(const CCNxNameLabel *label, const PARCBuffer *value)
{
CCNxNameSegment *result = parcObject_CreateInstance(CCNxNameSegment);
if (result != NULL) {
result->label = ccnxNameLabel_Acquire(label);
result->type = ccnxNameLabel_GetType(label);
result->value = parcBuffer_Acquire(value);
}
return result;
}
PARCJSONValue *
parcJSONValue_CreateFromString(PARCBuffer *value)
{
parcBuffer_OptionalAssertValid(value);
PARCJSONValue *result = _createValue(PARCJSONValueType_String);
if (result != NULL) {
result->value.string = parcBuffer_Acquire(value);
}
return result;
}
PARCBufferChunker *
parcBufferChunker_Create(PARCBuffer *data, size_t chunkSize)
{
PARCBufferChunker *chunker = parcObject_CreateInstance(PARCBufferChunker);
if (chunker != NULL) {
chunker->chunkSize = chunkSize;
chunker->data = parcBuffer_Acquire(data);
chunker->currentElement = NULL;
}
return chunker;
}
static void *
_parcChunker_Next(PARCFileChunker *chunker, void *state)
{
PARCBuffer *buffer = _parcChunker_NextFromBuffer(chunker, state);
if (chunker->currentElement != NULL) {
parcBuffer_Release(&chunker->currentElement);
}
if (buffer != NULL) {
chunker->currentElement = parcBuffer_Acquire(buffer);
}
return state;
}
/**
* Create a PKCS12 signing context for use in ccnx_Signing from the provided key. It is destroyed
* by parc_Signing when the signing context is destroyed.
*
* Example:
* @code
* <#example#>
* @endcode
*/
PARCSigningInterface *
parcSymmetricSignerFileStore_Create(PARCBuffer *secret_key, PARCCryptoHashType hmacHashType)
{
_PARCAesSignerFileStore *keystore = parcMemory_AllocateAndClear(sizeof(_PARCAesSignerFileStore));
assertNotNull(keystore, "parcMemory_AllocateAndClear(%zu) returned NULL, cannot allocate keystore", sizeof(_PARCAesSignerFileStore));
keystore->hashType = hmacHashType;
switch (hmacHashType) {
case PARC_HASH_SHA256:
keystore->hashLength = SHA256_DIGEST_LENGTH;
keystore->opensslMd = EVP_sha256();
break;
case PARC_HASH_SHA512:
keystore->hashLength = SHA512_DIGEST_LENGTH;
keystore->opensslMd = EVP_sha512();
break;
default:
parcBuffer_Release(&secret_key);
parcMemory_Deallocate((void **) &keystore);
trapIllegalValue(hmacHashType, "Unknown HMAC hash type: %d", hmacHashType);
}
keystore->secretKey = parcBuffer_Acquire(secret_key);
// the signer key digest is SHA256, independent of the HMAC digest
PARCCryptoHasher *hasher = parcCryptoHasher_Create(PARC_HASH_SHA256);
parcCryptoHasher_Init(hasher);
parcCryptoHasher_UpdateBuffer(hasher, secret_key);
keystore->secretKeyHash = parcCryptoHasher_Finalize(hasher);
parcCryptoHasher_Release(&hasher);
// create the functor from the template then specialize it to this keystore.
// This depends on keystore->secret_key being set. It will cause a callback
// into hmac_setup()
keystore->hasherFunctor = functor_hmac;
keystore->hasherFunctor.functor_env = keystore;
keystore->hasher = parcCryptoHasher_CustomHasher(keystore->hashType, keystore->hasherFunctor);
PARCSigningInterface *signer = parcMemory_AllocateAndClear(sizeof(PARCSigningInterface));
assertNotNull(signer, "parcMemory_AllocateAndClear(%zu) returned NULL", sizeof(PARCSigningInterface));
*signer = aeskeystoreinterface;
signer->interfaceContext = keystore;
return signer;
}
PARCLogEntry *
parcLogEntry_Create(PARCLogLevel level,
const char *hostName,
const char *applicationName,
const char *processName,
const uint64_t messageId,
const struct timeval timeStamp,
PARCBuffer *payload)
{
PARCLogEntry *result = parcObject_CreateInstance(PARCLogEntry);
if (result == NULL) {
trapOutOfMemory("Creating an instance of PARCLogEntry.");
}
result->version = _parcLog_Version;
result->timeStamp = timeStamp;
result->hostName = parcMemory_StringDuplicate(hostName, strlen(hostName));
result->applicationName = parcMemory_StringDuplicate(applicationName, strlen(applicationName));
result->processName = parcMemory_StringDuplicate(processName, strlen(processName));
result->messageId = messageId;
result->level = level;
result->payload = parcBuffer_Acquire(payload);
return result;
}
PARCBuffer *
athenaTransportLinkModule_CreateMessageBuffer(CCNxMetaMessage *message)
{
PARCBuffer *buffer = ccnxWireFormatMessage_GetWireFormatBuffer(message);
// If there is no PARCBuffer present, check for an IO vector and convert that into a contiguous buffer.
if (buffer == NULL) {
CCNxCodecNetworkBufferIoVec *iovec = ccnxWireFormatMessage_GetIoVec(message);
if (iovec == NULL) { // if there's no iovec or buffer, encode the message and return the iovec
athena_EncodeMessage(message);
iovec = ccnxWireFormatMessage_GetIoVec(message);
}
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) {
buffer = 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;
}
buffer = parcBuffer_Allocate(totalbytes);
for (int i = 0; i < iovcnt; i++) {
parcBuffer_PutArray(buffer, array[i].iov_len, array[i].iov_base);
}
parcBuffer_Flip(buffer);
}
} else {
buffer = parcBuffer_Acquire(buffer);
}
return buffer;
}
void
ccnxManifestHashGroup_SetOverallDataDigest(CCNxManifestHashGroup *group, const PARCBuffer *digest)
{
group->overallDataDigest = parcBuffer_Acquire(digest);
}
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;
}
