void
core_init(struct Core *core)
{
memset(core, 0, sizeof(*core));
/*
* Create two databases. One database is for loading new/changed
* content. The other database is used by the running system, with
* multiple thtreads querying it. Once loaded, changes will be moved
* from the loading db to the running db in a thread-safe manner.
* (This is similar to cfg_load/cfg_run).
*/
core->db_load = catalog_create();
core->db_run = catalog_create();
}
int
pcap2zone(int argc, char *argv[])
{
struct Pcap2Zone pcap2zone[1];
struct Catalog *catalog;
int i;
/*
* Create a catalog/database
*/
catalog = catalog_create();
pcap2zone->db = catalog;
/*
* Initialize it with a pseudo-SOA record for the root zone
*/
{
static const struct DomainPointer root = {(const unsigned char*)"\0",1};
struct ZoneFileParser *parser;
parser = zonefile_begin(
root, /* origin */
60, /* TTL */
10000, /* filesize */
"<pcap2zone>", /* filename */
zonefile_load, /* callback */
catalog /* callback data */
);
LOAD("$TTL 60\r\n"
"@ IN SOA ns hostmaster (\r\n"
" 2003080800 ; sn = serial number\r\n"
" 172800 ; ref = refresh = 2d\r\n"
" 15m ; ret = update retry = 15m\r\n"
" 1209600 ; ex = expiry = 2w\r\n"
" 1H ; nx = nxdomain ttl = 1h\r\n"
" )\r\n", parser);
zonefile_end(parser);
}
for (i=2; i<argc; i++) {
const char *filename = argv[i];
struct Tracker tracker[1];
struct PcapFile *p;
//uint64_t filesize;
memset(tracker, 0, sizeof(tracker[0]));
//filesize =
tracker_get_filesize(tracker, filename);
p = pcapfile_openread(filename);
if (p == NULL) {
perror(filename);
continue;
}
for (;;) {
unsigned char buf[65536];
int x;
unsigned secs;
unsigned usecs;
unsigned original_length;
unsigned bytes_read;
x = pcapfile_readframe(
p,
&secs, &usecs,
&original_length, &bytes_read,
buf,
sizeof(buf)
);
if (x <= 0)
break;
{
struct PreprocessedInfo info;
unsigned x;
x = preprocess_frame(
buf,
bytes_read,
1,
&info);
if (x && info.found == FOUND_DNS && info.port_src == 53)
grab_dns_response(catalog, buf, info.found_offset, bytes_read);
}
tracker_report(tracker, bytes_read);
}
pcapfile_close(p);
}
return Success;
}
int
perftest(int argc, char *argv[])
{
struct PerfTest perftest[1];
struct ZoneFileParser *parser;
struct Catalog *db;
size_t i;
perftest->loop_count = 10000000;
/*
* Create a pseudo-network subsystem for generating packets
*/
perftest->server.parent = perftest;
perftest->server.adapter = adapter_create(
perftest_alloc_packet,
perftest_server_to_client_response,
&perftest->server);
adapter_add_ipv4(perftest->server.adapter, 0xC0A80101, 0xFFFFffff);
/* create a catalog/database, this is where all the parsed zonefile
* records will be put */
perftest->db = catalog_create();
perftest->thread->catalog = perftest->db;
db = perftest->db;
/*
* Parse a sample zone
*/
parser = zonefile_begin(
example_origin, /* origin */
60, /* TTL */
10000, /* filesize */
"<perftest>", /* filename */
zonefile_load, /* callback */
db, /* callback data */
0
);
zonefile_set_singlestep(parser);
for (i=0; perftest_zone[i]; i++) {
zonefile_parse(parser,
(const unsigned char*)perftest_zone[i],
strlen(perftest_zone[i])
);
}
zonefile_end(parser);
/*
* Send packets. This creates one thread per CPU processing requests.
*/
{
unsigned threads_desired = pixie_cpu_get_count();
uint64_t start, stop;
double requests_per_second;
fprintf(stderr, "running %u threads\n", threads_desired);
start = pixie_gettime();
for (i=0; i<threads_desired; i++) {
__sync_fetch_and_add(&threads_running, 1);
pixie_begin_thread((void(*)(void*))run_perf, 0, perftest);
}
while (threads_running)
pixie_usleep(1000);
stop = pixie_gettime();
requests_per_second = 1000000.0
* (1.0 * threads_desired * perftest->loop_count)
/ (stop - start);
fprintf(stderr, "queries = %u\n", (unsigned)(threads_desired * perftest->loop_count));
fprintf(stderr, "seconds = %5.3f\n", (stop - start)/1000000.0);
fprintf(stderr, "queries/second = %5.3f\n", requests_per_second);
}
exit(1);
return 0;
}
