LONGBOW_TEST_CASE(Global, athenaFIB_CreateEntryList)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
athenaFIB_AddRoute(data->testFIB, data->testName1, data->testVector12);
PARCBitVector *result = athenaFIB_Lookup(data->testFIB, data->testName1, NULL);
assertTrue(parcBitVector_Equals(result, data->testVector12), "Expected lookup to equal test vector");
parcBitVector_Release(&result);
PARCList *entryList = athenaFIB_CreateEntryList(data->testFIB);
assertTrue(parcList_Size(entryList) == 2, "Expected the EntryList to have 2 elements");
AthenaFIBListEntry *entry = parcList_GetAtIndex(entryList, 0);
assertNotNull(entry, "Expect entry at 0 to be non-NULL");
assertTrue(ccnxName_Equals(data->testName1, entry->name), "Expect the name at 0 to be testName1");
assertTrue(entry->linkId == 0, "Expect the routeId at 0 to be 0");
entry = parcList_GetAtIndex(entryList, 1);
assertNotNull(entry, "Expect entry at 1 to be non-NULL");
assertTrue(ccnxName_Equals(data->testName1, entry->name), "Expect the name at 1 to be testName1");
assertTrue(entry->linkId == 42, "Expect the routeId at 0 to be 42");
parcList_Release(&entryList);
}
static CCNxMetaMessage *
_PIT_Command(Athena *athena, CCNxInterest *interest)
{
CCNxMetaMessage *responseMessage;
responseMessage = athenaPIT_ProcessMessage(athena->athenaPIT, interest);
if (responseMessage) {
return responseMessage;
}
CCNxName *ccnxName = ccnxInterest_GetName(interest);
if (ccnxName_GetSegmentCount(ccnxName) > AthenaCommandSegment) {
CCNxNameSegment *nameSegment = ccnxName_GetSegment(ccnxName, AthenaCommandSegment);
char *command = ccnxNameSegment_ToString(nameSegment);
if (strcasecmp(command, AthenaCommand_List) == 0) {
parcLog_Debug(athena->log, "PIT List command invoked");
PARCList *pitEntries = athenaPIT_CreateEntryList(athena->athenaPIT);
printf("\n");
for (size_t i = 0; i < parcList_Size(pitEntries); ++i) {
PARCBuffer *strbuf = parcList_GetAtIndex(pitEntries, i);
char *toprint = parcBuffer_ToString(strbuf);
parcLog_Info(athena->log, "%s\n", toprint);
parcMemory_Deallocate(&toprint);
}
parcList_Release(&pitEntries);
responseMessage = _create_response(athena, ccnxName, "PIT listed on forwarder output log.");
} else {
responseMessage = _create_response(athena, ccnxName, "Unknown command: %s", command);
}
parcMemory_Deallocate(&command);
}
return responseMessage;
}
LONGBOW_TEST_CASE(Global, parcList_Release)
{
PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList);
parcList_Release(&list);
assertNull(list, "Expected null.");
}
LONGBOW_TEST_CASE(Global, PARCList_Add)
{
PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList);
parcList_Add(list, 0);
size_t actual = parcList_Size(list);
assertTrue(1 == actual, "Expected=%d, actual=%zu", 1, actual);
parcList_Release(&list);
}
LONGBOW_TEST_CASE(Local, _metisControlAddConnection_EtherExecute)
{
const char *argv[] = { "add", "connection", "ether", "conn3", "e8-06-88-cd-28-de", "em3" };
PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
parcList_AddAll(args, 6, (void **) &argv[0]);
TestData *data = longBowTestCase_GetClipBoardData(testCase);
MetisCommandOps *ops = _metisControlAddConnection_EtherCreate(data->state);
MetisCommandReturn result = ops->execute(data->state->parser, ops, args);
metisCommandOps_Destroy(&ops);
parcList_Release(&args);
assertTrue(result == MetisCommandReturn_Success, "Valid command line should succeed");
}
LONGBOW_TEST_CASE(Global, PARCList_Copy)
{
char *a = strdup("apple");
char *b = strdup("bananna");
char *c = strdup("cherry");
PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList);
parcList_Add(list, a);
parcList_Add(list, b);
parcList_Add(list, c);
parcList_Release(&list);
}
LONGBOW_TEST_CASE(Local, _metisControlAddConnection_UdpExecute)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
const char *argv[] = { "add", "connection", "tcp", "conn3", "1.2.3.4", "123" };
PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
parcList_AddAll(args, 6, (void **) &argv[0]);
MetisCommandOps *ops = _metisControlAddConnection_UdpCreate(data->state);
MetisCommandReturn result = ops->execute(data->state->parser, ops, args);
metisCommandOps_Destroy(&ops);
parcList_Release(&args);
assertTrue(result == MetisCommandReturn_Success, "Unimplemented execute should have failed");
}
static MetisCommandReturn
testAddRoute(const LongBowTestCase *testCase, int argc, const char *prefix, const char *nexthop, const char *cost)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
metisControlState_SetDebug(data->state, true);
const char *argv[] = { "add", "route", nexthop, prefix, cost };
PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
parcList_AddAll(args, argc, (void **) &argv[0]);
MetisCommandOps *ops = metisControlAddRoute_Create(data->state);
MetisCommandReturn result = ops->execute(data->state->parser, ops, args);
metisCommandOps_Destroy(&ops);
parcList_Release(&args);
return result;
}
LONGBOW_TEST_CASE(Global, PARCList_AddAll)
{
PARCList *list = parcList(parcArrayList_Create(parcArrayList_StdlibFreeFunction), PARCArrayListAsPARCList);
void *elements[] = {
strdup("a"),
strdup("b"),
strdup("c"),
};
parcList_AddAll(list, 3, elements);
size_t actual = parcList_Size(list);
assertTrue(3 == actual, "Expected=%d, actual=%zu", 3, actual);
parcList_Release(&list);
}
static MetisCommandReturn
testListConnections(const LongBowTestCase *testCase, int argc)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
metisControlState_SetDebug(data->state, true);
data->customWriteReadReply = &customWriteReadResponse;
const char *argv[] = { "list", "interfaces" };
PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
parcList_AddAll(args, argc, (void **) &argv[0]);
MetisCommandOps *ops = metisControlListConnections_Create(data->state);
MetisCommandReturn result = ops->execute(data->state->parser, ops, args);
metisCommandOps_Destroy(&ops);
parcList_Release(&args);
return result;
}
static MetisCommandReturn
testDebug(const LongBowTestCase *testCase, MetisCommandOps * (*create)(MetisControlState * state), int argc, bool initialDebugSetting, bool expectedDebugSetting)
{
TestData *data = longBowTestCase_GetClipBoardData(testCase);
const char *argv[] = { "blah", "blah" };
PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
parcList_AddAll(args, argc, (void **) &argv[0]);
metisControlState_SetDebug(data->state, initialDebugSetting);
MetisCommandOps *ops = create(data->state);
MetisCommandReturn result = ops->execute(data->state->parser, ops, args);
if (result == MetisCommandReturn_Success) {
assertTrue(data->state->debugFlag == expectedDebugSetting,
"Debug flag wrong, expected %d got %d",
expectedDebugSetting,
data->state->debugFlag);
}
metisCommandOps_Destroy(&ops);
parcList_Release(&args);
return result;
}
/**
* argc = the exact number of args, don't include the command name
* example: argc = 2, argv = {"Hello", "World"}
*
* expectedResult true means the execute function is called
*/
static void
dispatchCommand(const char *command_string, int argc, char **argv, bool expectedResult)
{
MetisCommandParser *parser = metisCommandParser_Create();
bool execute_called = false;
MetisCommandOps *ops = metisCommandOps_Create(&execute_called, command_string, NULL, test_execute, metisCommandOps_Destroy);
PARCList *args = parcList(parcArrayList_Create(NULL), PARCArrayListAsPARCList);
parcList_AddAll(args, argc, (void **) &argv[0]);
execute_called = false;
metisCommandParser_RegisterCommand(parser, ops);
metisCommandParser_DispatchCommand(parser, args);
if (expectedResult) {
assertTrue(execute_called, "Did not call the execute function");
} else {
assertFalse(execute_called, "The execute function should not have been called but was");
}
metisCommandParser_Destroy(&parser);
parcList_Release(&args);
}
static CCNxMetaMessage *
_FIB_Command(Athena *athena, CCNxInterest *interest, PARCBitVector *ingress)
{
CCNxMetaMessage *responseMessage;
responseMessage = athenaFIB_ProcessMessage(athena->athenaFIB, interest);
if (responseMessage) {
return responseMessage;
}
CCNxName *ccnxName = ccnxInterest_GetName(interest);
if (ccnxName_GetSegmentCount(ccnxName) > AthenaCommandSegment) {
CCNxNameSegment *nameSegment = ccnxName_GetSegment(ccnxName, AthenaCommandSegment);
char *command = ccnxNameSegment_ToString(nameSegment);
if ((strcasecmp(command, AthenaCommand_Add) == 0) || (strcasecmp(command, AthenaCommand_Remove) == 0)) {
char *arguments = _get_arguments(interest);
if (arguments == NULL) {
responseMessage = _create_response(athena, ccnxName, "No link or prefix arguments given to %s route command", command);
parcMemory_Deallocate(&command);
return responseMessage;
}
char linkName[MAXPATHLEN];
char prefix[MAXPATHLEN];
PARCBitVector *linkVector;
// {Add,Remove} Route arguments "<prefix> [<linkName>]", if linkName not specified, use the incoming link id ([de-]registration)
int numberOfArguments = sscanf(arguments, "%s %s", prefix, linkName);
if (numberOfArguments == 2) {
int linkId = athenaTransportLinkAdapter_LinkNameToId(athena->athenaTransportLinkAdapter, linkName);
if (linkId == -1) {
responseMessage = _create_response(athena, ccnxName, "Unknown linkName %s", linkName);
parcMemory_Deallocate(&command);
parcMemory_Deallocate(&arguments);
return responseMessage;
}
linkVector = parcBitVector_Create();
parcBitVector_Set(linkVector, linkId);
} else if (numberOfArguments == 1) { // use ingress link
linkVector = parcBitVector_Acquire(ingress);
} else {
responseMessage = _create_response(athena, ccnxName, "No prefix specified or too many arguments");
parcMemory_Deallocate(&command);
parcMemory_Deallocate(&arguments);
return responseMessage;
}
CCNxName *prefixName = ccnxName_CreateFromCString(prefix);
if (prefixName == NULL) {
responseMessage = _create_response(athena, ccnxName, "Unable to parse prefix %s", prefix);
parcMemory_Deallocate(&command);
parcMemory_Deallocate(&arguments);
parcBitVector_Release(&linkVector);
return responseMessage;
}
int result = false;
if (strcasecmp(command, AthenaCommand_Add) == 0) {
result = athenaFIB_AddRoute(athena->athenaFIB, prefixName, linkVector);
} else if (strcasecmp(command, AthenaCommand_Remove) == 0) {
result = athenaFIB_DeleteRoute(athena->athenaFIB, prefixName, linkVector);
}
if (result == true) {
char *routePrefix = ccnxName_ToString(prefixName);
const char *linkIdName = athenaTransportLinkAdapter_LinkIdToName(athena->athenaTransportLinkAdapter, parcBitVector_NextBitSet(linkVector, 0));
responseMessage = _create_response(athena, ccnxName, "%s route %s -> %s", command, routePrefix, linkIdName);
athenaInterestControl_LogConfigurationChange(athena, ccnxName, "%s %s", routePrefix, linkIdName);
parcMemory_Deallocate(&routePrefix);
} else {
responseMessage = _create_response(athena, ccnxName, "%s failed", command);
}
parcBitVector_Release(&linkVector);
ccnxName_Release(&prefixName);
parcMemory_Deallocate(&arguments);
} else if (strcasecmp(command, AthenaCommand_List) == 0) {
// Need to create the response here because as the FIB doesn't know the linkName
parcLog_Debug(athena->log, "FIB List command invoked");
PARCList *fibEntries = athenaFIB_CreateEntryList(athena->athenaFIB);
responseMessage = _create_FIBList_response(athena, ccnxName, fibEntries);
parcList_Release(&fibEntries);
} else {
responseMessage = _create_response(athena, ccnxName, "Unknown command: %s", command);
}
parcMemory_Deallocate(&command);
}
return responseMessage;
}
bool
metisConfigurationFile_Process(MetisConfigurationFile *configFile)
{
assertNotNull(configFile, "Parameter configFile must be non-null");
// default to a "true" return value and only set to false if we encounter an error.
bool success = true;
#define BUFFERLEN 2048
char buffer[BUFFERLEN];
configFile->linesRead = 0;
// always clear errors and fseek to start of file in case we get called multiple times.
clearerr(configFile->fh);
rewind(configFile->fh);
while (success && fgets(buffer, BUFFERLEN, configFile->fh) != NULL) {
configFile->linesRead++;
char *stripedBuffer = _trim(buffer);
if (strlen(stripedBuffer) > 0) {
if (stripedBuffer[0] != '#') {
// not empty and not a comment
// _parseArgs will modify the string
char *copy = parcMemory_StringDuplicate(stripedBuffer, strlen(stripedBuffer));
PARCList *args = _parseArgs(copy);
MetisCommandReturn result = metisControlState_DispatchCommand(configFile->controlState, args);
// we ignore EXIT from the configuration file
if (result == MetisCommandReturn_Failure) {
if (metisLogger_IsLoggable(metisForwarder_GetLogger(configFile->metis), MetisLoggerFacility_Config, PARCLogLevel_Error)) {
metisLogger_Log(metisForwarder_GetLogger(configFile->metis), MetisLoggerFacility_Config, PARCLogLevel_Error, __func__,
"Error on input file %s line %d: %s",
configFile->filename,
configFile->linesRead,
stripedBuffer);
}
success = false;
}
parcList_Release(&args);
parcMemory_Deallocate((void **) ©);
}
}
}
if (ferror(configFile->fh)) {
if (metisLogger_IsLoggable(metisForwarder_GetLogger(configFile->metis), MetisLoggerFacility_Config, PARCLogLevel_Error)) {
metisLogger_Log(metisForwarder_GetLogger(configFile->metis), MetisLoggerFacility_Config, PARCLogLevel_Error, __func__,
"Error on input file %s line %d: (%d) %s",
configFile->filename,
configFile->linesRead,
errno,
strerror(errno));
}
success = false;
}
return success;
}