int athenaTransportLinkAdapter_CloseByName(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, const char *linkName) { if (athenaTransportLinkAdapter->listenerList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index); if (strcmp(athenaTransportLink_GetName(athenaTransportLink), linkName) == 0) { athenaTransportLink_Close(athenaTransportLink); return 0; } } } if (athenaTransportLinkAdapter->instanceList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink) { if (strcmp(athenaTransportLink_GetName(athenaTransportLink), linkName) == 0) { athenaTransportLink_Close(athenaTransportLink); return 0; } } } } errno = ENOENT; return -1; }
LONGBOW_TEST_CASE(Global, PARCList_InsertAtIndex_Last) { PARCArrayList *array = parcArrayList_Create(NULL); parcArrayList_Add(array, (void *) 1); parcArrayList_Add(array, (void *) 2); size_t actual = parcArrayList_Size(array); assertTrue(2 == actual, "Expected=%d, actual=%zu", 2, actual); parcArrayList_InsertAtIndex(array, 2, (void *) 3); actual = parcArrayList_Size(array); assertTrue(3 == actual, "Expected=%d, actual=%zu", 3, actual); void *element0 = parcArrayList_Get(array, 0); assertTrue(element0 == (void *) 1, "Element 1 moved?"); void *element1 = parcArrayList_Get(array, 1); assertTrue(element1 == (void *) 2, "Element 1 moved?"); void *element2 = parcArrayList_Get(array, 2); assertTrue(element2 == (void *) 3, "Element 1 moved?"); parcArrayList_Destroy(&array); }
void athenaTransportLinkAdapter_SetLogLevel(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, const PARCLogLevel level) { // set log level on main athena module parcLog_SetLevel(athenaTransportLinkAdapter->log, level); // set log level on all modules if (athenaTransportLinkAdapter->moduleList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->moduleList); index++) { AthenaTransportLinkModule *athenaTransportLinkModule = parcArrayList_Get(athenaTransportLinkAdapter->moduleList, index); athenaTransportLinkModule_SetLogLevel(athenaTransportLinkModule, level); } } // set log level on all instances if (athenaTransportLinkAdapter->listenerList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index); athenaTransportLink_SetLogLevel(athenaTransportLink, level); } } // set log level on all listener instances if (athenaTransportLinkAdapter->instanceList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink) { athenaTransportLink_SetLogLevel(athenaTransportLink, level); } } } }
void athenaTransportLinkAdapter_Destroy(AthenaTransportLinkAdapter **athenaTransportLinkAdapter) { // release listener instances if ((*athenaTransportLinkAdapter)->listenerList) { for (int index = 0; index < parcArrayList_Size((*athenaTransportLinkAdapter)->listenerList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get((*athenaTransportLinkAdapter)->listenerList, index); athenaTransportLink_Close(athenaTransportLink); } } // release live instances if ((*athenaTransportLinkAdapter)->instanceList) { for (int index = 0; index < parcArrayList_Size((*athenaTransportLinkAdapter)->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get((*athenaTransportLinkAdapter)->instanceList, index); if (athenaTransportLink) { athenaTransportLink_Close(athenaTransportLink); } } } parcArrayList_Destroy(&((*athenaTransportLinkAdapter)->moduleList)); parcArrayList_Destroy(&((*athenaTransportLinkAdapter)->instanceList)); parcArrayList_Destroy(&((*athenaTransportLinkAdapter)->listenerList)); if ((*athenaTransportLinkAdapter)->pollfdReceiveList) { parcMemory_Deallocate(&((*athenaTransportLinkAdapter)->pollfdReceiveList)); parcMemory_Deallocate(&((*athenaTransportLinkAdapter)->pollfdSendList)); parcMemory_Deallocate(&((*athenaTransportLinkAdapter)->pollfdTransportLink)); } parcLog_Release(&((*athenaTransportLinkAdapter)->log)); parcMemory_Deallocate(athenaTransportLinkAdapter); }
/** * @abstract add a new link instance to the AthenaTransportLinkAdapter instance list * @discussion * * When athenaTransportLinkAdapter_Open is called on a link specific module, the module instantiates * the link and then creates a new AthenaTransportLink to interface with the AthenaTransportLinkAdapter. * The AthenaTransportLinkModule passes the new AthenaTransportLink to the AthenaTransportLinkAdapter by * calling AthenaTransportLinkAdapter_AddLink with the new link AthenaTransportLink data. The AthenaTransportLinkAdapter * then places the new link instance on its internal instance list in a pending state until it has been verified and ensures * that the new link doesn't collide (i.e. by name) with any currently registered link before returning success. * * New routable links are placed into instanceList slots that have previously been vacated before being added * to the end of the instanceList. This is in order to keep bit vectors that are based on the instanceList as * small as is necessary. * * @param [in] athenaTransportLinkAdapter link adapter instance * @param [in] linkInstance instance structure created by the link specific module * @return 0 on success, -1 with errno set to indicate the error * * Example: * @code * { * } * @endcode */ static int _athenaTransportLinkAdapter_AddLink(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, AthenaTransportLink *newTransportLink) { int linkId = -1; // Check for existing linkName in listenerList if (athenaTransportLinkAdapter->listenerList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index); if (strcmp(athenaTransportLink_GetName(athenaTransportLink), athenaTransportLink_GetName(newTransportLink)) == 0) { errno = EADDRINUSE; // name is already in listenerList return -1; } } } // Check for existing linkName in the instanceList if (athenaTransportLinkAdapter->instanceList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink) { if (strcmp(athenaTransportLink_GetName(athenaTransportLink), athenaTransportLink_GetName(newTransportLink)) == 0) { errno = EADDRINUSE; // name is already in instanceList return -1; } } else { // remember the first available index found along the way if (linkId == -1) { linkId = index; } } } } // Add to listenerList or instanceList athenaTransportLink_Acquire(newTransportLink); if (athenaTransportLink_IsNotRoutable(newTransportLink)) { // listener bool result = parcArrayList_Add(athenaTransportLinkAdapter->listenerList, newTransportLink); assertTrue(result, "parcArrayList_Add failed to add new listener"); } else { // routable link, add to instances using the last available id if one was seen if (linkId != -1) { parcArrayList_Set(athenaTransportLinkAdapter->instanceList, linkId, newTransportLink); } else { bool result = parcArrayList_Add(athenaTransportLinkAdapter->instanceList, newTransportLink); assertTrue(result, "parcArrayList_Add failed to add new link instance"); } } // If any transport link has a registered file descriptor add it to the general polling list. int eventFd = athenaTransportLink_GetEventFd(newTransportLink); if (eventFd != -1) { _add_to_pollfdList(athenaTransportLinkAdapter, newTransportLink, eventFd); } return 0; }
/** * @abstract called from below the link adapter to coordinate termination of a link instance * @discussion * * This is called exclusively from the Transport Link Module to instigate the removal of * an active link. The link has been flagged closing by the originator. This method * must ensure that all references to the link have been removed and then call the * instance close method to finish the operation. * * @param [in] athenaTransportLinkAdapter link adapter instance * @param [in] athenaTransportLink link instance to remove * * Example: * @code * { * * } * @endcode */ static void _athenaTransportLinkAdapter_RemoveLink(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, AthenaTransportLink *athenaTransportLink) { int linkId = -1; // if this is a listener it can simply be removed if (athenaTransportLink_IsNotRoutable(athenaTransportLink)) { if (athenaTransportLinkAdapter->listenerList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->listenerList); index++) { AthenaTransportLink *transportLink = parcArrayList_Get(athenaTransportLinkAdapter->listenerList, index); if (athenaTransportLink == transportLink) { parcArrayList_RemoveAtIndex(athenaTransportLinkAdapter->listenerList, index); _remove_from_pollfdList(athenaTransportLinkAdapter, athenaTransportLink); parcLog_Debug(athenaTransportLinkAdapter_GetLogger(athenaTransportLinkAdapter), "listener removed: %s", athenaTransportLink_GetName(athenaTransportLink)); athenaTransportLink_Release(&athenaTransportLink); return; } } } } // Remove from our internal instance list. // The index entry remains to be reused by links that are added in the future. if (athenaTransportLinkAdapter->instanceList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *transportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink == transportLink) { parcArrayList_Set(athenaTransportLinkAdapter->instanceList, index, NULL); _remove_from_pollfdList(athenaTransportLinkAdapter, athenaTransportLink); linkId = index; break; } } } assertFalse(linkId == -1, "Attempt to remove link not found in link adapter lists"); // Callback to notify that the link has been removed and references need to be dropped. PARCBitVector *linkVector = parcBitVector_Create(); parcBitVector_Set(linkVector, linkId); athenaTransportLinkAdapter->removeLink(athenaTransportLinkAdapter->removeLinkContext, linkVector); parcBitVector_Release(&linkVector); // we assume all references to the linkId associated with this instance have been // cleared from the PIT and FIB when removeLink returns. parcLog_Debug(athenaTransportLinkAdapter_GetLogger(athenaTransportLinkAdapter), "link removed: %s", athenaTransportLink_GetName(athenaTransportLink)); athenaTransportLink_Release(&athenaTransportLink); }
void parcPublicKey_Validate(PARCArrayList *args) { char *fileName = parcArrayList_Get(args, 2); char *password = parcArrayList_Get(args, 3); PARCSigningInterface *interface = parcPublicKeySignerPkcs12Store_Open(fileName, password, PARC_HASH_SHA256); if (interface == NULL) { printf("Invalid %s\n", fileName); return; } printf("Valid %s\n", fileName); }
int main(int argc, char *argv[]) { char *programName = "parc_publickey"; if (argc < 2) { printUsage(programName); exit(1); } PARCArrayList *args = parcArrayList_Create(NULL); parcArrayList_AddAll(args, (void **) argv, argc); parcSecurity_Init(); char *arg = parcArrayList_Get(args, 1); if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) { printUsage(programName); return 0; } else if (strcmp(arg, "-c") == 0 || strcmp(arg, "--create") == 0) { parcPublicKey_Create(args); } else if (strcmp(arg, "-v") == 0 || strcmp(arg, "--validate") == 0) { parcPublicKey_Validate(args); } else { printUsage(programName); exit(1); } parcSecurity_Fini(); return 0; }
/** * @function metisListenerSet_Add * @abstract Adds the listener to the set * @discussion * Unique set based on pair (MetisEncapType, localAddress) * * @param <#param1#> * @return <#return#> */ bool metisListenerSet_Add(MetisListenerSet *set, MetisListenerOps *ops) { assertNotNull(set, "Parameter set must be non-null"); assertNotNull(ops, "Parameter ops must be non-null"); int opsEncap = ops->getEncapType(ops); const CPIAddress *opsAddress = ops->getListenAddress(ops); // make sure its not in the set size_t length = parcArrayList_Size(set->listOfListeners); for (size_t i = 0; i < length; i++) { MetisListenerOps *entry = parcArrayList_Get(set->listOfListeners, i); int entryEncap = entry->getEncapType(entry); const CPIAddress *entryAddress = entry->getListenAddress(entry); if (opsEncap == entryEncap && cpiAddress_Equals(opsAddress, entryAddress)) { // duplicate return false; } } parcArrayList_Add(set->listOfListeners, ops); return true; }
CPIConnection * cpiConnectionList_Get(CPIConnectionList *list, size_t index) { assertNotNull(list, "Parameter list must be non-null"); CPIConnection *original = (CPIConnection *) parcArrayList_Get(list->listOfConnections, index); return cpiConnection_Copy(original); }
static AthenaTransportLinkModule * _LoadModule(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, const char *moduleName) { PARCArrayList *newModuleList = NULL; // XXX need to dynamically load these, they're all hardwired for now if (strcasecmp(moduleName, "TCP") == 0) { newModuleList = athenaTransportLinkModuleTCP_Init(); } if (strcasecmp(moduleName, "UDP") == 0) { newModuleList = athenaTransportLinkModuleUDP_Init(); } if (strcasecmp(moduleName, "ETH") == 0) { newModuleList = athenaTransportLinkModuleETH_Init(); } if (newModuleList) { for (int index = 0; index < parcArrayList_Size(newModuleList); index++) { AthenaTransportLinkModule *athenaTransportLinkModule = parcArrayList_Get(newModuleList, index); _AddModule(athenaTransportLinkAdapter, athenaTransportLinkModule); } parcArrayList_Destroy(&newModuleList); } return _LookupModule(athenaTransportLinkAdapter, moduleName); }
static MetisNumberSet * _metisStandardPIT_SatisfyInterest(MetisPIT *generic, const MetisMessage *objectMessage) { assertNotNull(generic, "Parameter pit must be non-null"); assertNotNull(objectMessage, "Parameter objectMessage must be non-null"); MetisStandardPIT *pit = metisPIT_Closure(generic); // we need to look in all three tables to see if there's anything // to satisy in each of them and take the union of the reverse path sets. MetisNumberSet *ingressSetUnion = metisNumberSet_Create(); PARCArrayList *list = metisMatchingRulesTable_GetUnion(pit->table, objectMessage); for (size_t i = 0; i < parcArrayList_Size(list); i++) { MetisPitEntry *pitEntry = (MetisPitEntry *) parcArrayList_Get(list, i); // this is a reference counted return const MetisNumberSet *ingressSet = metisPitEntry_GetIngressSet(pitEntry); metisNumberSet_AddSet(ingressSetUnion, ingressSet); // and remove it from the PIT. Key is a reference counted copy of the pit entry message MetisMessage *key = metisPitEntry_GetMessage(pitEntry); metisMatchingRulesTable_RemoveFromBest(pit->table, key); metisMessage_Release(&key); } parcArrayList_Destroy(&list); return ingressSetUnion; }
MetisConnection * metisConnectionList_Get(MetisConnectionList *list, size_t index) { assertNotNull(list, "Parameter list must be non-null"); MetisConnection *original = (MetisConnection *) parcArrayList_Get(list->listOfConnections, index); return original; }
bool cpiInterfaceSet_Equals(const CPIInterfaceSet *a, const CPIInterfaceSet *b) { if (a == NULL && b == NULL) { return true; } if (a == NULL || b == NULL) { return false; } size_t length_a = parcArrayList_Size(a->listOfInterfaces); size_t length_b = parcArrayList_Size(b->listOfInterfaces); if (length_a == length_b) { for (size_t i = 0; i < length_a; i++) { CPIInterface *iface_a = (CPIInterface *) parcArrayList_Get(a->listOfInterfaces, i); // the set is unique by interface id, so if it exists in set b, it // exists there by interface id CPIInterface *iface_b = cpiInterfaceSet_GetByInterfaceIndex(b, cpiInterface_GetInterfaceIndex(iface_a)); if (!cpiInterface_Equals(iface_b, iface_b)) { return false; } } return true; } return false; }
PARCBitVector * athenaTransportLinkAdapter_Send(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, CCNxMetaMessage *ccnxMetaMessage, PARCBitVector *linkOutputVector) { PARCBitVector *resultVector = parcBitVector_Create(); int nextLinkToWrite = 0; if (athenaTransportLinkAdapter->instanceList == NULL) { return resultVector; } while ((nextLinkToWrite = parcBitVector_NextBitSet(linkOutputVector, nextLinkToWrite)) >= 0) { athenaTransportLinkAdapter->stats.messageSend_Attempted++; if (nextLinkToWrite >= parcArrayList_Size(athenaTransportLinkAdapter->instanceList)) { athenaTransportLinkAdapter->stats.messageSend_LinkDoesNotExist++; nextLinkToWrite++; continue; } AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, nextLinkToWrite); if (athenaTransportLink == NULL) { athenaTransportLinkAdapter->stats.messageSend_LinkDoesNotExist++; nextLinkToWrite++; continue; } if (!(athenaTransportLink_GetEvent(athenaTransportLink) & AthenaTransportLinkEvent_Send)) { athenaTransportLinkAdapter->stats.messageSend_LinkNotAcceptingSendRequests++; nextLinkToWrite++; continue; } // If we're sending an interest to a non-local link, // check that it has a sufficient hoplimit. if (ccnxMetaMessage_IsInterest(ccnxMetaMessage)) { if (athenaTransportLink_IsNotLocal(athenaTransportLink)) { if (ccnxInterest_GetHopLimit(ccnxMetaMessage) == 0) { athenaTransportLinkAdapter->stats.messageSend_HopLimitExceeded++; nextLinkToWrite++; continue; } } } int result = athenaTransportLink_Send(athenaTransportLink, ccnxMetaMessage); if (result == 0) { athenaTransportLinkAdapter->stats.messageSent++; parcBitVector_Set(resultVector, nextLinkToWrite); } else { athenaTransportLinkAdapter->stats.messageSend_LinkSendFailed++; } nextLinkToWrite++; } return resultVector; }
int athenaTransportLinkModule_Poll(AthenaTransportLinkModule *athenaTransportLinkModule, int timeout) { athenaTransportLinkModule->stats.module_Poll++; int events = 0; for (int index = 0; index < parcArrayList_Size(athenaTransportLinkModule->instanceList); index++) { AthenaTransportLink *transportLink = parcArrayList_Get(athenaTransportLinkModule->instanceList, index); assertNotNull(transportLink, "Unexpected Null entry in module instance list"); events += athenaTransportLinkModule->pollMethod(transportLink, timeout); } return events; }
/** * Uses the system name (e.g. "en0") * * <#Discussion#> * * @param <#param1#> * @return NULL if not found * * Example: * @code * <#example#> * @endcode */ CPIInterface * cpiInterfaceSet_GetByName(CPIInterfaceSet *set, const char *name) { size_t length = parcArrayList_Size(set->listOfInterfaces); for (size_t i = 0; i < length; i++) { CPIInterface *listEntry = (CPIInterface *) parcArrayList_Get(set->listOfInterfaces, i); if (cpiInterface_NameEquals(listEntry, name)) { return listEntry; } } return NULL; }
CPIInterface * cpiInterfaceSet_GetByInterfaceIndex(const CPIInterfaceSet *set, unsigned interfaceIndex) { size_t length = parcArrayList_Size(set->listOfInterfaces); for (size_t i = 0; i < length; i++) { CPIInterface *listEntry = (CPIInterface *) parcArrayList_Get(set->listOfInterfaces, i); unsigned entryInterfaceIndex = cpiInterface_GetInterfaceIndex(listEntry); if (entryInterfaceIndex == interfaceIndex) { return listEntry; } } return NULL; }
bool parcURIPath_Equals(const PARCURIPath *pathA, const PARCURIPath *pathB) { if (pathA == pathB) { return true; } if (pathA == NULL || pathB == NULL) { return false; } if (parcArrayList_Size(pathA->segments) == parcArrayList_Size(pathB->segments)) { for (size_t i = 0; i < parcArrayList_Size(pathA->segments); i++) { PARCURISegment *segmentA = parcArrayList_Get(pathA->segments, i); PARCURISegment *segmentB = parcArrayList_Get(pathB->segments, i); if (!parcURISegment_Equals(segmentA, segmentB)) { return false; } } return true; } return false; }
LONGBOW_TEST_CASE(Global, PARCList_Get) { PARCArrayList *array = parcArrayList_Create(parcArrayList_StdlibFreeFunction); char *expected = strdup("Hello World"); parcArrayList_Add(array, expected); char *actual = parcArrayList_Get(array, 0); assertTrue(expected == actual, "Expected=%p, actual=%p", (void *) expected, (void *) actual); parcArrayList_Destroy(&array); }
static void _metisCommandLineInterface_RemoveSession(MetisCommandLineInterface *cli, _MetisCommandLineInterface_Session *session) { size_t length = parcArrayList_Size(cli->openSessions); for (size_t i = 0; i < length; i++) { _MetisCommandLineInterface_Session *x = parcArrayList_Get(cli->openSessions, i); if (x == session) { // removing from list will call the session destroyer parcArrayList_RemoveAndDestroyAtIndex(cli->openSessions, i); return; } } assertTrue(0, "Illegal state: did not find a session in openSessions %p", (void *) session); }
bool athenaTransportLinkAdapter_IsNotLocal(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, int linkId) { if (athenaTransportLinkAdapter->instanceList == NULL) { return false; } if ((linkId >= 0) && (linkId < parcArrayList_Size(athenaTransportLinkAdapter->instanceList))) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, linkId); if (athenaTransportLink) { return athenaTransportLink_IsNotLocal(athenaTransportLink); } } return false; }
const char * athenaTransportLinkAdapter_LinkIdToName(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, int linkId) { if (athenaTransportLinkAdapter->instanceList == NULL) { return NULL; } if (linkId < parcArrayList_Size(athenaTransportLinkAdapter->instanceList)) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, linkId); if (athenaTransportLink) { return athenaTransportLink_GetName(athenaTransportLink); } } return NULL; }
void athenaTransportLinkModule_Destroy(AthenaTransportLinkModule **athenaTransportLinkModule) { int index = (int) parcArrayList_Size((*athenaTransportLinkModule)->instanceList); while (index-- > 0) { AthenaTransportLink *transportLink; transportLink = parcArrayList_Get((*athenaTransportLinkModule)->instanceList, 0); athenaTransportLink_Close(transportLink); } parcArrayList_Destroy(&((*athenaTransportLinkModule)->instanceList)); parcMemory_Deallocate(&((*athenaTransportLinkModule)->name)); parcLog_Release(&((*athenaTransportLinkModule)->log)); parcMemory_Deallocate(athenaTransportLinkModule); }
bool cpiConnectionList_Equals(const CPIConnectionList *a, const CPIConnectionList *b) { if (a == NULL && b == NULL) { return true; } if (a == NULL || b == NULL) { return false; } if (parcArrayList_Size(a->listOfConnections) == parcArrayList_Size(b->listOfConnections)) { size_t length = parcArrayList_Size(a->listOfConnections); for (size_t i = 0; i < length; i++) { CPIConnection *tunnel_a = (CPIConnection *) parcArrayList_Get(a->listOfConnections, i); CPIConnection *tunnel_b = (CPIConnection *) parcArrayList_Get(b->listOfConnections, i); if (!cpiConnection_Equals(tunnel_a, tunnel_b)) { return false; } } return true; } return false; }
void parcPublicKey_Create(PARCArrayList *args) { unsigned int keyLength = 1024; unsigned int validityDays = 30; char *fileName = parcArrayList_Get(args, 2); char *password = parcArrayList_Get(args, 3); char *subjectName = parcArrayList_Get(args, 4); if (parcArrayList_Size(args) > 5) { keyLength = (unsigned int) strtoul(parcArrayList_Get(args, 5), NULL, 10); } if (parcArrayList_Size(args) > 6) { validityDays = (unsigned int) strtoul(parcArrayList_Get(args, 6), NULL, 10); } bool result = parcPublicKeySignerPkcs12Store_CreateFile(fileName, password, subjectName, keyLength, validityDays); if (!result) { printf("Error: %s %s", fileName, strerror(errno)); return; } printf("Created %s, key length %d valid for %d days.\n", fileName, keyLength, validityDays); }
PARCBitVector * athenaTransportLinkAdapter_Close(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, PARCBitVector *linkVector) { PARCBitVector *resultVector = parcBitVector_Create(); int nextLinkToClose = 0; while ((nextLinkToClose = parcBitVector_NextBitSet(linkVector, nextLinkToClose)) >= 0) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, nextLinkToClose); if (athenaTransportLink) { athenaTransportLink_Close(athenaTransportLink); parcBitVector_Set(resultVector, nextLinkToClose); nextLinkToClose++; } } return resultVector; }
/** * @abstract called from the link specific adapter to coordinate termination of a link instance * @discussion * * This is called exclusively from the Transport Link specific Module to instigate the * removal of an active link. The link is flagged as closing and the link module is called * to continue the operation. Eventually this should result in the link specific close * method being called, which should finish cleaning state, and deallocate the instance. * * @param [in] athenaTransportLink link adapter instance * @param [in] athenaTransportLink link instance to remove * * Example: * @code * { * * } * @endcode */ static void _athenaTransportLinkModule_RemoveLink(AthenaTransportLinkModule *athenaTransportLinkModule, AthenaTransportLink *athenaTransportLink) { // remove from our list for (int index = 0; index < parcArrayList_Size(athenaTransportLinkModule->instanceList); index++) { AthenaTransportLink *transportLink = parcArrayList_Get(athenaTransportLinkModule->instanceList, index); if (athenaTransportLink == transportLink) { AthenaTransportLink *removedInstance = parcArrayList_RemoveAtIndex(athenaTransportLinkModule->instanceList, index); assertTrue(removedInstance == athenaTransportLink, "Wrong link removed"); break; } } athenaTransportLinkModule->removeLink(athenaTransportLinkModule->removeLinkContext, athenaTransportLink); athenaTransportLink_Release(&athenaTransportLink); }
static AthenaTransportLinkModule * _LookupModule(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, const char *moduleName) { AthenaTransportLinkModule *athenaTransportLinkModule; if (athenaTransportLinkAdapter->moduleList) { for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->moduleList); index++) { athenaTransportLinkModule = parcArrayList_Get(athenaTransportLinkAdapter->moduleList, index); if (strcasecmp(athenaTransportLinkModule_GetName(athenaTransportLinkModule), moduleName) == 0) { return athenaTransportLinkModule; } } } errno = ENOENT; return NULL; }
int athenaTransportLinkAdapter_LinkNameToId(AthenaTransportLinkAdapter *athenaTransportLinkAdapter, const char *linkName) { if (athenaTransportLinkAdapter->instanceList == NULL) { return -1; } for (int index = 0; index < parcArrayList_Size(athenaTransportLinkAdapter->instanceList); index++) { AthenaTransportLink *athenaTransportLink = parcArrayList_Get(athenaTransportLinkAdapter->instanceList, index); if (athenaTransportLink) { if (strcmp(athenaTransportLink_GetName(athenaTransportLink), linkName) == 0) { return index; } } } return -1; }