TEST_F(SearchDirTest, file_go) {
expectFile("b.txt", dir_visit_next_go);
expectFile("a.txt", dir_visit_next_go);
t_write_to_file("a.txt", "");
t_write_to_file("b.txt", "");
do_search(-1);
CHECK_SEARCHDIR_RESULT();
}
bool TestHTTPServer::wait(const QUrl &expect, const QUrl &reply, const QUrl &body)
{
m_state = AwaitingHeader;
m_data.clear();
QFile expectFile(expect.toLocalFile());
if (!expectFile.open(QIODevice::ReadOnly)) return false;
QFile replyFile(reply.toLocalFile());
if (!replyFile.open(QIODevice::ReadOnly)) return false;
bodyData = QByteArray();
if (body.isValid()) {
QFile bodyFile(body.toLocalFile());
if (!bodyFile.open(QIODevice::ReadOnly)) return false;
bodyData = bodyFile.readAll();
}
const QByteArray serverHostUrl = QByteArrayLiteral("127.0.0.1:") + QByteArray::number(server.serverPort());
QByteArray line;
bool headers_done = false;
while (!(line = expectFile.readLine()).isEmpty()) {
line.replace('\r', "");
if (line.at(0) == '\n') {
headers_done = true;
continue;
}
if (headers_done) {
waitData.body.append(line);
} else {
line.replace("{{ServerHostUrl}}", serverHostUrl);
waitData.headers.append(line);
}
}
/*
while (waitData.endsWith('\n'))
waitData = waitData.left(waitData.count() - 1);
*/
replyData = replyFile.readAll();
if (!replyData.endsWith('\n'))
replyData.append("\n");
replyData.append("Content-length: " + QByteArray::number(bodyData.length()));
replyData .append("\n\n");
for (int ii = 0; ii < replyData.count(); ++ii) {
if (replyData.at(ii) == '\n' && (!ii || replyData.at(ii - 1) != '\r')) {
replyData.insert(ii, '\r');
++ii;
}
}
replyData.append(bodyData);
return true;
}
TEST_F(SearchDirTest, dir_basic) {
expectEnter("a", dir_visit_next_go);
expectFile("a.txt", dir_visit_next_go);
expectLeave("a", dir_visit_next_go);
t_dir_make("a");
t_write_to_file("a/a.txt", "");
do_search(-1);
CHECK_SEARCHDIR_RESULT();
}
bool TestHTTPServer::wait(const QUrl &expect, const QUrl &reply, const QUrl &body)
{
m_hasFailed = false;
QFile expectFile(expect.toLocalFile());
if (!expectFile.open(QIODevice::ReadOnly)) return false;
QFile replyFile(reply.toLocalFile());
if (!replyFile.open(QIODevice::ReadOnly)) return false;
bodyData = QByteArray();
if (body.isValid()) {
QFile bodyFile(body.toLocalFile());
if (!bodyFile.open(QIODevice::ReadOnly)) return false;
bodyData = bodyFile.readAll();
}
waitData = expectFile.readAll();
/*
while (waitData.endsWith('\n'))
waitData = waitData.left(waitData.count() - 1);
*/
replyData = replyFile.readAll();
if (!replyData.endsWith('\n'))
replyData.append("\n");
replyData.append("Content-length: " + QByteArray::number(bodyData.length()));
replyData .append("\n\n");
for (int ii = 0; ii < replyData.count(); ++ii) {
if (replyData.at(ii) == '\n' && (!ii || replyData.at(ii - 1) != '\r')) {
replyData.insert(ii, '\r');
++ii;
}
}
replyData.append(bodyData);
return true;
}
int HSPReadConfigFile(HSP *sp)
{
EnumHSPObject level[HSP_MAX_CONFIG_DEPTH + 5];
int depth = 0;
level[depth] = HSPOBJ_HSP;
// could have used something like bison to make a complete parser with
// strict rules, but for simplicity we just allow the current object
// to double as a state variable that determines what is allowed next.
for(HSPToken *tok = readTokens(sp); tok; tok = tok->nxt) {
if(depth > HSP_MAX_CONFIG_DEPTH) {
// depth overrun
parseError(sp, tok, "too many '{'s", "");
return NO;
}
else if(tok->stok == HSPTOKEN_ENDOBJ) {
// end of level, pop the stack
if(depth > 0) --depth;
else {
parseError(sp, tok, "too many '}'s ", "");
return NO;
}
}
else switch(level[depth]) {
case HSPOBJ_HSP:
// must start by opening an sFlow object
if((tok = expectToken(sp, tok, HSPTOKEN_SFLOW)) == NULL) return NO;
if((tok = expectToken(sp, tok, HSPTOKEN_STARTOBJ)) == NULL) return NO;
newSFlow(sp);
level[++depth] = HSPOBJ_SFLOW;
break;
case HSPOBJ_SFLOW:
switch(tok->stok) {
// Perhaps these sp->xxx settings should be outside the sflow { } block?
// ======================================================================
case HSPTOKEN_LOOPBACK:
if((tok = expectLoopback(sp, tok)) == NULL) return NO;
break;
case HSPTOKEN_DNSSD:
if((tok = expectONOFF(sp, tok, &sp->DNSSD)) == NULL) return NO;
break;
case HSPTOKEN_DNSSD_DOMAIN:
if((tok = expectDNSSD_domain(sp, tok)) == NULL) return NO;
break;
case HSPTOKEN_REFRESH_ADAPTORS:
if((tok = expectInteger32(sp, tok, &sp->refreshAdaptorListSecs, 60, 3600)) == NULL) return NO;
break;
case HSPTOKEN_REFRESH_VMS:
if((tok = expectInteger32(sp, tok, &sp->refreshVMListSecs, 60, 3600)) == NULL) return NO;
break;
case HSPTOKEN_FORGET_VMS:
if((tok = expectInteger32(sp, tok, &sp->forgetVMSecs, 60, 0xFFFFFFFF)) == NULL) return NO;
break;
// ======================================================================
case HSPTOKEN_COLLECTOR:
if((tok = expectToken(sp, tok, HSPTOKEN_STARTOBJ)) == NULL) return NO;
newCollector(sp->sFlow->sFlowSettings_file);
level[++depth] = HSPOBJ_COLLECTOR;
break;
case HSPTOKEN_SAMPLING:
case HSPTOKEN_PACKETSAMPLINGRATE:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->samplingRate, 0, 65535)) == NULL) return NO;
break;
case HSPTOKEN_POLLING:
case HSPTOKEN_COUNTERPOLLINGINTERVAL:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->pollingInterval, 0, 300)) == NULL) return NO;
break;
case HSPTOKEN_AGENTIP:
if((tok = expectIP(sp, tok, &sp->sFlow->agentIP, NULL)) == NULL) return NO;
sp->sFlow->explicitAgentIP = YES;
break;
case HSPTOKEN_AGENTCIDR:
{
HSPCIDR cidr = { 0 };
if((tok = expectCIDR(sp, tok, &cidr)) == NULL) return NO;
addAgentCIDR(sp->sFlow->sFlowSettings_file, &cidr);
}
break;
case HSPTOKEN_AGENT:
if((tok = expectDevice(sp, tok, &sp->sFlow->agentDevice)) == NULL) return NO;
sp->sFlow->explicitAgentDevice = YES;
break;
case HSPTOKEN_SUBAGENTID:
if((tok = expectInteger32(sp, tok, &sp->sFlow->subAgentId, 0, HSP_MAX_SUBAGENTID)) == NULL) return NO;
break;
case HSPTOKEN_UUID:
if((tok = expectUUID(sp, tok, sp->uuid)) == NULL) return NO;
break;
case HSPTOKEN_HEADERBYTES:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->headerBytes, 0, HSP_MAX_HEADER_BYTES)) == NULL) return NO;
break;
case HSPTOKEN_DATAGRAMBYTES:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->datagramBytes, SFL_MIN_DATAGRAM_SIZE, SFL_MAX_DATAGRAM_SIZE)) == NULL) return NO;
break;
case HSPTOKEN_XEN_UPDATE_DOMINFO:
if((tok = expectONOFF(sp, tok, &sp->sFlow->sFlowSettings_file->xen_update_dominfo)) == NULL) return NO;
break;
case HSPTOKEN_XEN_DSK:
if((tok = expectONOFF(sp, tok, &sp->sFlow->sFlowSettings_file->xen_dsk)) == NULL) return NO;
break;
case HSPTOKEN_ULOGGROUP:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->ulogGroup, 1, 32)) == NULL) return NO;
break;
case HSPTOKEN_NFLOGGROUP:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->nflogGroup, 1, 0xFFFFFFFF)) == NULL) return NO;
break;
case HSPTOKEN_ULOGPROBABILITY:
if((tok = expectDouble(sp, tok, &sp->sFlow->sFlowSettings_file->ulogProbability, 0.0, 1.0)) == NULL) return NO;
break;
case HSPTOKEN_NFLOGPROBABILITY:
if((tok = expectDouble(sp, tok, &sp->sFlow->sFlowSettings_file->nflogProbability, 0.0, 1.0)) == NULL) return NO;
break;
case HSPTOKEN_JSONPORT:
if((tok = expectInteger32(sp, tok, &sp->sFlow->sFlowSettings_file->jsonPort, 1025, 65535)) == NULL) return NO;
break;
case HSPTOKEN_JSONFIFO:
// expect a file name such as "/tmp/hsflowd_json_fifo" that was created using mkfifo(1)
if((tok = expectFile(sp, tok, &sp->sFlow->sFlowSettings_file->jsonFIFO)) == NULL) return NO;
break;
case HSPTOKEN_SAMPLINGDIRECTION:
if((tok = expectDirection(sp, tok, &sp->sFlow->sFlowSettings_file->samplingDirection)) == NULL) return NO;
break;
default:
// handle wildcards here - allow sampling.<app>=<n> and polling.<app>=<secs>
if(tok->str && strncasecmp(tok->str, "sampling.", 9) == 0) {
char *app = tok->str + 9;
uint32_t sampling_n=0;
if((tok = expectInteger32(sp, tok, &sampling_n, 0, 65535)) == NULL) return NO;
setApplicationSampling(sp->sFlow->sFlowSettings_file, app, sampling_n);
}
else if(tok->str && strncasecmp(tok->str, "polling.", 8) == 0) {
char *app = tok->str + 8;
uint32_t polling_secs=0;
if((tok = expectInteger32(sp, tok, &polling_secs, 0, 300)) == NULL) return NO;
setApplicationPolling(sp->sFlow->sFlowSettings_file, app, polling_secs);
}
else {
parseError(sp, tok, "unexpected sFlow setting", "");
return NO;
}
break;
}
break;
case HSPOBJ_COLLECTOR:
{
HSPCollector *col = sp->sFlow->sFlowSettings_file->collectors;
switch(tok->stok) {
case HSPTOKEN_IP:
if((tok = expectIP(sp, tok, &col->ipAddr, (struct sockaddr *)&col->sendSocketAddr)) == NULL) return NO;
break;
case HSPTOKEN_UDPPORT:
if((tok = expectInteger32(sp, tok, &col->udpPort, 1, 65535)) == NULL) return NO;
break;
default:
parseError(sp, tok, "unexpected collector setting", "");
return NO;
break;
}
}
break;
default:
parseError(sp, tok, "unexpected state", "");
}
}
// OK we consumed all the tokens, but we still need to run some sanity checks to make sure
// we have a usable configuration...
int parseOK = YES;
if(sp->sFlow == NULL) {
myLog(LOG_ERR, "parse error in %s : sFlow not found", sp->configFile);
parseOK = NO;
}
else {
if(sp->sFlow->sFlowSettings_file->numCollectors == 0 && sp->DNSSD == NO) {
myLog(LOG_ERR, "parse error in %s : DNS-SD is off and no collectors are defined", sp->configFile);
parseOK = NO;
}
for(HSPCollector *coll = sp->sFlow->sFlowSettings_file->collectors; coll; coll = coll->nxt) {
//////////////////////// collector /////////////////////////
if(coll->ipAddr.type == 0) {
myLog(LOG_ERR, "parse error in %s : collector has no IP", sp->configFile);
parseOK = NO;
}
}
}
if(sp->sFlow->sFlowSettings_file->ulogProbability > 0) {
sp->sFlow->sFlowSettings_file->ulogSamplingRate = (uint32_t)(1.0 / sp->sFlow->sFlowSettings_file->ulogProbability);
}
if(sp->sFlow->sFlowSettings_file->nflogProbability > 0) {
sp->sFlow->sFlowSettings_file->nflogSamplingRate = (uint32_t)(1.0 / sp->sFlow->sFlowSettings_file->nflogProbability);
}
return parseOK;
}