/* =============================================================================
* makeNode
* =============================================================================
*/
static adtree_node_t*
makeNode (long parentIndex,
long index,
long start,
long numRecord,
data_t* dataPtr)
{
adtree_node_t* nodePtr = allocNode(index);
assert(nodePtr);
nodePtr->count = numRecord;
vector_t* varyVectorPtr = nodePtr->varyVectorPtr;
long v;
long numVar = dataPtr->numVar;
for (v = (index + 1); v < numVar; v++) {
adtree_vary_t* varyPtr =
makeVary(parentIndex, v, start, numRecord, dataPtr);
assert(varyPtr);
bool_t status = vector_pushBack(varyVectorPtr, (void*)varyPtr);
assert(status);
}
return nodePtr;
}
static void
insertInt (vector_t* vectorPtr, long* data)
{
printf("Inserting: %li\n", *data);
vector_pushBack(vectorPtr, (void*)data);
printVector(vectorPtr);
}
/* =============================================================================
* net_alloc
* =============================================================================
*/
net_t*
net_alloc (long numNode)
{
net_t* netPtr;
netPtr = (net_t*)SEQ_MALLOC(sizeof(net_t));
if (netPtr) {
vector_t* nodeVectorPtr = vector_alloc(numNode);
if (nodeVectorPtr == NULL) {
SEQ_FREE(netPtr);
return NULL;
}
long i;
for (i = 0; i < numNode; i++) {
net_node_t* nodePtr = allocNode(i);
if (nodePtr == NULL) {
long j;
for (j = 0; j < i; j++) {
nodePtr = (net_node_t*)vector_at(nodeVectorPtr, j);
freeNode(nodePtr);
}
vector_free(nodeVectorPtr);
SEQ_FREE(netPtr);
return NULL;
}
bool_t status = vector_pushBack(nodeVectorPtr, (void*)nodePtr);
assert(status);
}
netPtr->nodeVectorPtr = nodeVectorPtr;
}
return netPtr;
}
/* =============================================================================
* splitIntoPackets
* -- Packets will be equal-size chunks except for last one, which will have
* all extra bytes
* =============================================================================
*/
static void
splitIntoPackets (char* str,
long flowId,
random_t* randomPtr,
vector_t* allocVectorPtr,
queue_t* packetQueuePtr)
{
long numByte = strlen(str);
long numPacket = random_generate(randomPtr) % numByte + 1;
long numDataByte = numByte / numPacket;
long p;
for (p = 0; p < (numPacket - 1); p++) {
bool_t status;
char* bytes = (char*)SEQ_MALLOC(PACKET_HEADER_LENGTH + numDataByte);
assert(bytes);
status = vector_pushBack(allocVectorPtr, (void*)bytes);
assert(status);
packet_t* packetPtr = (packet_t*)bytes;
packetPtr->flowId = flowId;
packetPtr->fragmentId = p;
packetPtr->numFragment = numPacket;
packetPtr->length = numDataByte;
memcpy(packetPtr->data, (str + p * numDataByte), numDataByte);
status = queue_push(packetQueuePtr, (void*)packetPtr);
assert(status);
}
bool_t status;
long lastNumDataByte = numDataByte + numByte % numPacket;
char* bytes = (char*)SEQ_MALLOC(PACKET_HEADER_LENGTH + lastNumDataByte);
assert(bytes);
status = vector_pushBack(allocVectorPtr, (void*)bytes);
assert(status);
packet_t* packetPtr = (packet_t*)bytes;
packetPtr->flowId = flowId;
packetPtr->fragmentId = p;
packetPtr->numFragment = numPacket;
packetPtr->length = lastNumDataByte;
memcpy(packetPtr->data, (str + p * numDataByte), lastNumDataByte);
status = queue_push(packetQueuePtr, (void*)packetPtr);
assert(status);
}
static segments_t*
createSegments (char* segments[])
{
long i = 0;
segments_t* segmentsPtr = (segments_t*)malloc(sizeof(segments));
segmentsPtr->length = strlen(segments[0]);
segmentsPtr->contentsPtr = vector_alloc(1);
while (segments[i] != NULL) {
bool_t status = vector_pushBack(segmentsPtr->contentsPtr,
(void*)segments[i]);
assert(status);
i++;
}
segmentsPtr->minNum = vector_getSize(segmentsPtr->contentsPtr);
return segmentsPtr;
}
static void
testCount (adtree_t* adtreePtr,
data_t* dataPtr,
vector_t* queryVectorPtr,
long index,
long numVar)
{
if (index >= numVar) {
return;
}
long count1 = adtree_getCount(adtreePtr, queryVectorPtr);
long count2 = countData(dataPtr, queryVectorPtr);
if (global_doPrint) {
printQuery(queryVectorPtr);
printf(" count1=%li count2=%li\n", count1, count2);
fflush(stdout);
}
assert(count1 == count2);
query_t query;
long i;
for (i = 1; i < numVar; i++) {
query.index = index + i;
bool_t status = vector_pushBack(queryVectorPtr, (void*)&query);
assert(status);
query.value = 0;
testCount(adtreePtr, dataPtr, queryVectorPtr, query.index, numVar);
query.value = 1;
testCount(adtreePtr, dataPtr, queryVectorPtr, query.index, numVar);
vector_popBack(queryVectorPtr);
}
}
/* =============================================================================
* data_generate
* -- Binary variables of random PDFs
* -- If seed is <0, do not reseed
* -- Returns random network
* =============================================================================
*/
net_t*
data_generate (data_t* dataPtr, long seed, long maxNumParent, long percentParent)
{
random_t* randomPtr = dataPtr->randomPtr;
if (seed >= 0) {
random_seed(randomPtr, seed);
}
/*
* Generate random Bayesian network
*/
long numVar = dataPtr->numVar;
net_t* netPtr = net_alloc(numVar);
assert(netPtr);
net_generateRandomEdges(netPtr, maxNumParent, percentParent, randomPtr);
/*
* Create a threshold for each of the possible permutation of variable
* value instances
*/
long** thresholdsTable = (long**)SEQ_MALLOC(numVar * sizeof(long*));
assert(thresholdsTable);
long v;
for (v = 0; v < numVar; v++) {
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long numThreshold = 1 << list_getSize(parentIdListPtr);
long* thresholds = (long*)SEQ_MALLOC(numThreshold * sizeof(long));
assert(thresholds);
long t;
for (t = 0; t < numThreshold; t++) {
long threshold = random_generate(randomPtr) % (DATA_PRECISION + 1);
thresholds[t] = threshold;
}
thresholdsTable[v] = thresholds;
}
/*
* Create variable dependency ordering for record generation
*/
long* order = (long*)SEQ_MALLOC(numVar * sizeof(long));
assert(order);
long numOrder = 0;
queue_t* workQueuePtr = queue_alloc(-1);
assert(workQueuePtr);
vector_t* dependencyVectorPtr = vector_alloc(1);
assert(dependencyVectorPtr);
bitmap_t* orderedBitmapPtr = bitmap_alloc(numVar);
assert(orderedBitmapPtr);
bitmap_clearAll(orderedBitmapPtr);
bitmap_t* doneBitmapPtr = bitmap_alloc(numVar);
assert(doneBitmapPtr);
bitmap_clearAll(doneBitmapPtr);
v = -1;
while ((v = bitmap_findClear(doneBitmapPtr, (v + 1))) >= 0) {
list_t* childIdListPtr = net_getChildIdListPtr(netPtr, v);
long numChild = list_getSize(childIdListPtr);
if (numChild == 0) {
bool status;
/*
* Use breadth-first search to find net connected to this leaf
*/
queue_clear(workQueuePtr);
status = queue_push(workQueuePtr, (void*)v);
assert(status);
while (!queue_isEmpty(workQueuePtr)) {
long id = (long)queue_pop(workQueuePtr);
status = bitmap_set(doneBitmapPtr, id);
assert(status);
status = vector_pushBack(dependencyVectorPtr, (void*)id);
assert(status);
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, id);
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
status = queue_push(workQueuePtr, (void*)parentId);
assert(status);
}
}
/*
* Create ordering
*/
long i;
long n = vector_getSize(dependencyVectorPtr);
for (i = 0; i < n; i++) {
long id = (long)vector_popBack(dependencyVectorPtr);
if (!bitmap_isSet(orderedBitmapPtr, id)) {
bitmap_set(orderedBitmapPtr, id);
order[numOrder++] = id;
}
}
}
}
assert(numOrder == numVar);
/*
* Create records
*/
char* record = dataPtr->records;
long r;
long numRecord = dataPtr->numRecord;
for (r = 0; r < numRecord; r++) {
long o;
for (o = 0; o < numOrder; o++) {
long v = order[o];
list_t* parentIdListPtr = net_getParentIdListPtr(netPtr, v);
long index = 0;
list_iter_t it;
list_iter_reset(&it, parentIdListPtr);
while (list_iter_hasNext(&it, parentIdListPtr)) {
long parentId = (long)list_iter_next(&it, parentIdListPtr);
long value = record[parentId];
assert(value != DATA_INIT);
index = (index << 1) + value;
}
long rnd = random_generate(randomPtr) % DATA_PRECISION;
long threshold = thresholdsTable[v][index];
record[v] = ((rnd < threshold) ? 1 : 0);
}
record += numVar;
assert(record <= (dataPtr->records + numRecord * numVar));
}
/*
* Clean up
*/
bitmap_free(doneBitmapPtr);
bitmap_free(orderedBitmapPtr);
vector_free(dependencyVectorPtr);
queue_free(workQueuePtr);
SEQ_FREE(order);
for (v = 0; v < numVar; v++) {
SEQ_FREE(thresholdsTable[v]);
}
SEQ_FREE(thresholdsTable);
return netPtr;
}
/* =============================================================================
* segments_create
* -- Populates 'contentsPtr'
* =============================================================================
*/
void
segments_create (segments_t* segmentsPtr, gene_t* genePtr, random_t* randomPtr)
{
vector_t* segmentsContentsPtr;
char** strings;
long segmentLength;
long minNumSegment;
char* geneString;
long geneLength;
bitmap_t* startBitmapPtr;
long numStart;
long i;
long maxZeroRunLength;
assert(segmentsPtr != NULL);
assert(genePtr != NULL);
assert(randomPtr != NULL);
segmentsContentsPtr = segmentsPtr->contentsPtr;
strings = segmentsPtr->strings;
segmentLength = segmentsPtr->length;
minNumSegment = segmentsPtr->minNum;
geneString = genePtr->contents;
geneLength = genePtr->length;
startBitmapPtr = genePtr->startBitmapPtr;
numStart = geneLength - segmentLength + 1;
/* Pick some random segments to start */
for (i = 0; i < minNumSegment; i++) {
long j = (long)(random_generate(randomPtr) % numStart);
bool_t status = bitmap_set(startBitmapPtr, j);
assert(status);
memcpy(strings[i], &(geneString[j]), segmentLength * sizeof(char));
status = vector_pushBack(segmentsContentsPtr, (void*)strings[i]);
assert(status);
}
/* Make sure segment covers start */
i = 0;
if (!bitmap_isSet(startBitmapPtr, i)) {
char* string = (char*)malloc((segmentLength+1) * sizeof(char));
string[segmentLength] = '\0';
memcpy(string, &(geneString[i]), segmentLength * sizeof(char));
bool_t status = vector_pushBack(segmentsContentsPtr, (void*)string);
assert(status);
status = bitmap_set(startBitmapPtr, i);
assert(status);
}
/* Add extra segments to fill holes and ensure overlap */
maxZeroRunLength = segmentLength - 1;
for (i = 0; i < numStart; i++) {
long i_stop = MIN((i+maxZeroRunLength), numStart);
for ( /* continue */; i < i_stop; i++) {
if (bitmap_isSet(startBitmapPtr, i)) {
break;
}
}
if (i == i_stop) {
/* Found big enough hole */
char* string = (char*)malloc((segmentLength+1) * sizeof(char));
string[segmentLength] = '\0';
i = i - 1;
memcpy(string, &(geneString[i]), segmentLength * sizeof(char));
bool_t status = vector_pushBack(segmentsContentsPtr, (void*)string);
assert(status);
status = bitmap_set(startBitmapPtr, i);
assert(status);
}
}
}
/* =============================================================================
* stream_generate
* -- Returns number of attacks generated
* =============================================================================
*/
long
stream_generate (stream_t* streamPtr,
dictionary_t* dictionaryPtr,
long numFlow,
long seed,
long maxLength)
{
long numAttack = 0;
long percentAttack = streamPtr->percentAttack;
random_t* randomPtr = streamPtr->randomPtr;
vector_t* allocVectorPtr = streamPtr->allocVectorPtr;
queue_t* packetQueuePtr = streamPtr->packetQueuePtr;
MAP_T* attackMapPtr = streamPtr->attackMapPtr;
detector_t* detectorPtr = detector_alloc();
detector_addPreprocessor(detectorPtr, &preprocessor_toLower);
random_seed(randomPtr, seed);
queue_clear(packetQueuePtr);
long range = '~' - ' ' + 1;
long f;
for (f = 1; f <= numFlow; f++) {
char* str;
if ((random_generate(randomPtr) % 100) < percentAttack) {
long s = random_generate(randomPtr) % global_numDefaultSignature;
str = dictionary_get(dictionaryPtr, s);
bool_t status =
MAP_INSERT(attackMapPtr, (void*)f, (void*)str);
numAttack++;
} else {
/*
* Create random string
*/
long length = (random_generate(randomPtr) % maxLength) + 1;
str = (char*)malloc((length + 1) * sizeof(char));
bool_t status = vector_pushBack(allocVectorPtr, (void*)str);
long l;
for (l = 0; l < length; l++) {
str[l] = ' ' + (char)(random_generate(randomPtr) % range);
}
str[l] = '\0';
char* str2 = (char*)malloc((length + 1) * sizeof(char));
strcpy(str2, str);
error_t error = detector_process(detectorPtr, str2); /* updates in-place */
if (error == ERROR_SIGNATURE) {
bool_t status = MAP_INSERT(attackMapPtr,
(void*)f,
(void*)str);
numAttack++;
}
free(str2);
}
splitIntoPackets(str, f, randomPtr, allocVectorPtr, packetQueuePtr);
}
queue_shuffle(packetQueuePtr, randomPtr);
detector_free(detectorPtr);
return numAttack;
}
/* =============================================================================
* maze_read
* -- Return number of path to route
* =============================================================================
*/
long
maze_read (maze_t* mazePtr, char* inputFileName)
{
FILE* inputFile = fopen(inputFileName, "rt");
if (!inputFile) {
fprintf(stderr, "Error: Could not read %s\n", inputFileName);
exit(1);
}
/*
* Parse input file
*/
long lineNumber = 0;
long height = -1;
long width = -1;
long depth = -1;
char line[256];
list_t* workListPtr = list_alloc(&coordinate_comparePair);
vector_t* wallVectorPtr = mazePtr->wallVectorPtr;
vector_t* srcVectorPtr = mazePtr->srcVectorPtr;
vector_t* dstVectorPtr = mazePtr->dstVectorPtr;
while (fgets(line, sizeof(line), inputFile)) {
char code;
long x1, y1, z1;
long x2, y2, z2;
long numToken = sscanf(line, " %c %li %li %li %li %li %li",
&code, &x1, &y1, &z1, &x2, &y2, &z2);
lineNumber++;
if (numToken < 1) {
continue;
}
switch (code) {
case '#': { /* comment */
/* ignore line */
break;
}
case 'd': { /* dimensions (format: d x y z) */
if (numToken != 4) {
goto PARSE_ERROR;
}
width = x1;
height = y1;
depth = z1;
if (width < 1 || height < 1 || depth < 1) {
goto PARSE_ERROR;
}
break;
}
case 'p': { /* paths (format: p x1 y1 z1 x2 y2 z2) */
if (numToken != 7) {
goto PARSE_ERROR;
}
coordinate_t* srcPtr = coordinate_alloc(x1, y1, z1);
coordinate_t* dstPtr = coordinate_alloc(x2, y2, z2);
assert(srcPtr);
assert(dstPtr);
if (coordinate_isEqual(srcPtr, dstPtr)) {
goto PARSE_ERROR;
}
pair_t* coordinatePairPtr = pair_alloc(srcPtr, dstPtr);
assert(coordinatePairPtr);
bool_t status = list_insert(workListPtr, (void*)coordinatePairPtr);
assert(status == TRUE);
vector_pushBack(srcVectorPtr, (void*)srcPtr);
vector_pushBack(dstVectorPtr, (void*)dstPtr);
break;
}
case 'w': { /* walls (format: w x y z) */
if (numToken != 4) {
goto PARSE_ERROR;
}
coordinate_t* wallPtr = coordinate_alloc(x1, y1, z1);
vector_pushBack(wallVectorPtr, (void*)wallPtr);
break;
}
PARSE_ERROR:
default: { /* error */
fprintf(stderr, "Error: line %li of %s invalid\n",
lineNumber, inputFileName);
exit(1);
}
}
} /* iterate over lines in input file */
fclose(inputFile);
/*
* Initialize grid contents
*/
if (width < 1 || height < 1 || depth < 1) {
fprintf(stderr, "Error: Invalid dimensions (%li, %li, %li)\n",
width, height, depth);
exit(1);
}
grid_t* gridPtr = grid_alloc(width, height, depth);
assert(gridPtr);
mazePtr->gridPtr = gridPtr;
addToGrid(gridPtr, wallVectorPtr, "wall");
addToGrid(gridPtr, srcVectorPtr, "source");
addToGrid(gridPtr, dstVectorPtr, "destination");
printf("Maze dimensions = %li x %li x %li\n", width, height, depth);
printf("Paths to route = %li\n", list_getSize(workListPtr));
/*
* Initialize work queue
*/
queue_t* workQueuePtr = mazePtr->workQueuePtr;
list_iter_t it;
list_iter_reset(&it, workListPtr);
while (list_iter_hasNext(&it)) {
pair_t* coordinatePairPtr = (pair_t*)list_iter_next(&it);
queue_push(workQueuePtr, (void*)coordinatePairPtr);
}
list_free(workListPtr);
return vector_getSize(srcVectorPtr);
}
/* =============================================================================
* getCount
* =============================================================================
*/
static long
getCount (adtree_node_t* nodePtr,
long i,
long q,
vector_t* queryVectorPtr,
long lastQueryIndex,
adtree_t* adtreePtr)
{
if (nodePtr == NULL) {
return 0;
}
long nodeIndex = nodePtr->index;
if (nodeIndex >= lastQueryIndex) {
return nodePtr->count;
}
long count = 0L;
query_t* queryPtr = (query_t*)vector_at(queryVectorPtr, q);
if (!queryPtr) {
return nodePtr->count;
}
long queryIndex = queryPtr->index;
assert(queryIndex <= lastQueryIndex);
vector_t* varyVectorPtr = nodePtr->varyVectorPtr;
adtree_vary_t* varyPtr =
(adtree_vary_t*)vector_at(varyVectorPtr,
(queryIndex - nodeIndex - 1));
assert(varyPtr);
long queryValue = queryPtr->value;
if (queryValue == varyPtr->mostCommonValue) {
/*
* We do not explicitly store the counts for the most common value.
* We can calculate it by finding the count of the query without
* the current (superCount) and subtracting the count for the
* query with the current toggled (invertCount).
*/
long numQuery = vector_getSize(queryVectorPtr);
vector_t* superQueryVectorPtr = PVECTOR_ALLOC(numQuery - 1);
assert(superQueryVectorPtr);
long qq;
for (qq = 0; qq < numQuery; qq++) {
if (qq != q) {
bool_t status = vector_pushBack(superQueryVectorPtr,
vector_at(queryVectorPtr, qq));
assert(status);
}
}
long superCount = adtree_getCount(adtreePtr, superQueryVectorPtr);
PVECTOR_FREE(superQueryVectorPtr);
long invertCount;
if (queryValue == 0) {
queryPtr->value = 1;
invertCount = getCount(nodePtr,
i,
q,
queryVectorPtr,
lastQueryIndex,
adtreePtr);
queryPtr->value = 0;
} else {
queryPtr->value = 0;
invertCount = getCount(nodePtr,
i,
q,
queryVectorPtr,
lastQueryIndex,
adtreePtr);
queryPtr->value = 1;
}
count += superCount - invertCount;
} else {
if (queryValue == 0) {
count += getCount(varyPtr->zeroNodePtr,
(i + 1),
(q + 1),
queryVectorPtr,
lastQueryIndex,
adtreePtr);
} else if (queryValue == 1) {
count += getCount(varyPtr->oneNodePtr,
(i + 1),
(q + 1),
queryVectorPtr,
lastQueryIndex,
adtreePtr);
} else { /* QUERY_VALUE_WILDCARD */
#if 0
count += getCount(varyPtr->zeroNodePtr,
(i + 1),
(q + 1),
queryVectorPtr,
lastQueryIndex,
adtreePtr);
count += getCount(varyPtr->oneNodePtr,
(i + 1),
(q + 1),
queryVectorPtr,
lastQueryIndex,
adtreePtr);
#else
assert(0); /* catch bugs in learner */
#endif
}
}
return count;
}
