/* ============================================================================= * 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; }