int parseAlphaChannel(const char *value, draw_color_channel_t *target)
{
char channelBuf[COLOR_CHANNEL_MAX_STR_LEN + 1];
char *pos = (char*)value, *nextpos;
size_t posLen;
unsigned long channelValue;
memset(channelBuf, 0, COLOR_CHANNEL_MAX_STR_LEN + 1);
pos = strchrSet(pos, DIGIT_CHAR_SET);
if (pos == (char*)NULL)
{
whine();
return -1;
}
posLen = strlenWithinSet(pos, DIGIT_CHAR_SET);
if (posLen == 0 || posLen > COLOR_CHANNEL_MAX_STR_LEN)
{
whine();
return -1;
}
strncpy(channelBuf, pos, posLen);
channelValue = strtoul(channelBuf, &nextpos, 10);
RANGE_CHECK(channelValue, COLOR_CHANNEL_MAX_VALUE);
*target = (draw_color_channel_t)(channelValue & 0xFF);
return 0;
}
int set_sched_status(int policy, int priority)
{
int ret, min_prio, max_prio;
struct sched_param sp;
max_prio = sched_get_priority_max(policy);
min_prio = sched_get_priority_min(policy);
if (max_prio == -1 || min_prio == -1)
whine("Cannot determine scheduler prio limits!\n");
else if (priority < min_prio)
priority = min_prio;
else if (priority > max_prio)
priority = max_prio;
memset(&sp, 0, sizeof(sp));
sp.sched_priority = priority;
ret = sched_setscheduler(getpid(), policy, &sp);
if (ret) {
whine("Cannot set scheduler policy!\n");
return -EINVAL;
}
ret = sched_setparam(getpid(), &sp);
if (ret) {
whine("Cannot set scheduler prio!\n");
return -EINVAL;
}
return 0;
}
#include "config.h"
#define SEP "."
#define strbufLength 100
const char *currentSection, *currentName;
char *targetName;
char sectionNameBuf[strbufLength];
void whine(void);
// TODO: use a real regex library for parsing config line values
#define DEFAULT_INI_FILE_NAME "default.ini"
#define POST_CHECK \
if (result != 0) \
{ \
whine(); \
currentName = (const char*)NULL; \
} \
return result;
#define RANGE_CHECK(x, limit) \
if ((x == ULONG_MAX && errno == ERANGE) || x >= limit) \
{ \
whine(); \
return -1; \
}
char *booleanTrueValues[] = {
"true", "t",
"yes", "y",
"enabled", "e",
"on",
(char*)NULL
};
char *booleanFalseValues[] = {
"false", "f",
"no", "n",
"disabled", "d",
"off",
(char*)NULL
};
// this must come in the same order as the atk_button_t enum
char *showRangeMarkerValues[] = {
"a", "b", "c", "d",
"none",
(char*)NULL
};
void whine()
{
if (currentSection == NULL || currentName == NULL) {
return;
}
timestamp();
printf("Could not read value for option \"%s\" under section \"%s\". "
"Using default value.\n",
currentName, currentSection);
}
int testBoolean(char *value, char *targetStrs[], bool *target, bool newValue)
{
for (int i = 0; targetStrs[i] != (char*)NULL; i++)
{
if (stricmp(value, targetStrs[i]) == 0)
{
*target = newValue;
return 0;
}
}
return -1;
}
int parseBoolean(const char *value, bool *target)
{
char strBuf[10];
memset(strBuf, 0, 10);
char *pos = strchrSet((char*)value, ALPHA_CHAR_SET);
if (pos != (char*)NULL)
{
size_t posLen = strlenWithinSet(pos, ALPHA_CHAR_SET);
strncpy(strBuf, pos, posLen);
if (testBoolean(strBuf, booleanTrueValues, target, true) == 0) {
return 0;
}
if (testBoolean(strBuf, booleanFalseValues, target, false) == 0) {
return 0;
}
}
return -1;
}
int parseRangeMarkerValue(const char *value, int which)
{
char strBuf[5];
memset(strBuf, 0, 5);
char *pos = strchrSet((char*)value, ALPHA_CHAR_SET);
if (pos != (char*)NULL)
{
size_t posLen = strlenWithinSet(pos, ALPHA_CHAR_SET);
strncpy(strBuf, pos, posLen);
for (int i = 0; showRangeMarkerValues[i] != (char*)NULL; i++)
{
if (stricmp(strBuf, showRangeMarkerValues[i]) == 0)
{
showButtonRanges[which] = i;
return 0;
}
}
}
return -1;
}
#define COLOR_CHANNELS 4
#define ALPHA_CHANNEL (COLOR_CHANNELS - 1)
#define COLOR_CHANNEL_MAX_STR_LEN 3
#define COLOR_CHANNEL_MAX_VALUE 256 /* exclusive */
int parseColor(
const char *value, draw_color_t *target, draw_color_channel_t defaultOpacity)
{
char channelBuf[COLOR_CHANNEL_MAX_STR_LEN + 1];
char *pos = (char*)value, *nextpos;
size_t posLen;
unsigned long channelValue;
target->a = defaultOpacity;
for (int channel = 0; channel < COLOR_CHANNELS; channel++)
{
pos = strchrSet(pos, DIGIT_CHAR_SET);
if (pos == (char*)NULL && channel != ALPHA_CHANNEL)
{
whine();
return -1;
}
posLen = strlenWithinSet(pos, DIGIT_CHAR_SET);
if (posLen == 0 || posLen > COLOR_CHANNEL_MAX_STR_LEN)
{
if (posLen == 0 && channel == ALPHA_CHANNEL)
{
goto bail_loop;
}
else
{
whine();
return -1;
}
}
memset(channelBuf, 0, sizeof(channelBuf));
strncpy(channelBuf, pos, posLen);
channelValue = strtoul(channelBuf, &nextpos, 10);
RANGE_CHECK(channelValue, COLOR_CHANNEL_MAX_VALUE);
draw_color_channel_t targetValue = (draw_color_channel_t)(channelValue & 0xFF);
// straight r,g,b,a or a,r,g,b mapping gives the wrong color results here
switch (channel) {
case 0:
target->b = targetValue;
break;
case 1:
target->g = targetValue;
break;
case 2:
target->r = targetValue;
break;
case 3:
target->a = targetValue;
break;
}
pos += posLen;
}
bail_loop:
return 0;
}
/*PRINTFLIKE1*/
void
terminate(const char *format, ...)
{
va_list ap;
va_start(ap, format);
whine("ERROR", format, ap);
va_end(ap);
if (terminate_cleanup)
terminate_cleanup();
if (getenv("CTF_ABORT_ON_TERMINATE") != NULL)
abort();
#if defined(__FreeBSD__)
/*
* For the time being just output the termination message, but don't
* return an exit status that would cause the build to fail. We need
* to get as much stuff built as possible before going back and
* figuring out what is wrong with certain files.
*/
exit(0);
#else
exit(1);
#endif
}
int device_bind_irq_to_cpu(int irq, int cpu)
{
int ret;
char buff[256];
char file[256];
/* Note: first CPU begins with CPU 0 */
if (irq < 0 || cpu < 0)
return -EINVAL;
memset(file, 0, sizeof(file));
memset(buff, 0, sizeof(buff));
/* smp_affinity starts counting with CPU 1, 2, ... */
cpu = cpu + 1;
sprintf(file, "/proc/irq/%d/smp_affinity", irq);
FILE *fp = fopen(file, "w");
if (!fp) {
whine("Cannot open file %s!\n", file);
return -ENOENT;
}
sprintf(buff, "%d", cpu);
ret = fwrite(buff, sizeof(buff), 1, fp);
fclose(fp);
return (ret > 0 ? 0 : ret);
}
uint32_t hwt_delegate_rq_receive(struct reconos_hwt *hwt) {
int i;
ssize_t res;
uint32_t handle, arg0, msg_size, *msg;
handle = reconos_osif_read(hwt->osif);
arg0 = reconos_osif_read(hwt->osif);
resource_check_type(hwt, handle, RECONOS_RESOURCE_TYPE_RQ);
msg_size = arg0;
msg = malloc(msg_size);
if (!msg)
panic("rq_receive malloc failed\n");
// read data from rq
res = rq_receive(hwt->cfg->resource[handle].ptr, msg, msg_size);
if (res <= 0 || res > msg_size) {
whine("rq_receive screwed up: %zd\n", res);
reconos_osif_write(hwt->osif, 0);
goto out;
}
// write data to HWT
reconos_osif_write(hwt->osif, (uint32_t) res);
for (i = 0; i < res / sizeof(uint32_t); i++)
reconos_osif_write(hwt->osif, msg[i]);
out:
free(msg);
return 0;
}
void
um_destroy_world(void)
{
whine(("total destruction"));
um_crtf();
um_crti();
}
int af_raw_socket(int af, int proto)
{
int sock;
if (af != AF_INET && af != AF_INET6) {
whine("Wrong AF socket type! Falling back to AF_INET\n");
af = AF_INET;
}
sock = socket(af, SOCK_RAW, proto);
if (sock < 0)
panic("Creation AF socket failed!\n");
return sock;
}
/*PRINTFLIKE1*/
void
warning(const char *format, ...)
{
va_list ap;
va_start(ap, format);
whine("WARNING", format, ap);
va_end(ap);
if (debug_level >= 3)
terminate("Termination due to warning\n");
}
int af_socket(int af)
{
if (af != AF_INET && af != AF_INET6) {
whine("Wrong AF socket type! Falling back to AF_INET\n");
af = AF_INET;
}
int sock = socket(af, SOCK_DGRAM, 0);
if (sock < 0)
panic("Creation AF socket failed!\n");
return sock;
}
static int irq_stats(const char *ifname, struct ifstat *s)
{
int i;
char *ptr, *ptr2;
char buff[4096];
FILE *fp;
/* We exclude lo! */
if (!strncmp("lo", ifname, strlen("lo")))
return 0;
fp = fopen("/proc/interrupts", "r");
if (!fp) {
whine("Cannot open /proc/interrupts!\n");
return -ENOENT;
}
stats_check_alloc(s);
memset(buff, 0, sizeof(buff));
while (fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
if (strstr(buff, ifname) == NULL)
continue;
ptr = buff;
while (*ptr != ':')
ptr++;
*ptr = 0;
s->irq_nr = atoi(buff);
bug_on(s->irq_nr == 0);
for (i = 0; i < s->irqs_len; ++i) {
ptr++;
ptr2 = ptr;
while (*ptr == ' ')
ptr++;
while (*ptr != ' ' && *ptr != 0)
ptr++;
*ptr = 0;
s->irqs[i] = atoi(ptr2);
}
memset(buff, 0, sizeof(buff));
}
fclose(fp);
return 0;
}
static int mem_stats(struct ifstat *s)
{
int ret;
unsigned long total, free;
char *ptr;
char buff[4096];
FILE *fp = fopen("/proc/meminfo", "r");
if (!fp) {
whine("Cannot open /proc/meminfo!\n");
return -ENOENT;
}
memset(buff, 0, sizeof(buff));
while (fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
if ((ptr = strstr(buff, "MemTotal:")) != NULL) {
ptr += strlen("MemTotal:");
ptr++;
while (*ptr == ' ')
ptr++;
ret = sscanf(ptr, "%lu", &total);
if (ret != 1)
total = 0;
} else if ((ptr = strstr(buff, "MemFree:")) != NULL) {
ptr += strlen("MemFree:");
ptr++;
while (*ptr == ' ')
ptr++;
ret = sscanf(ptr, "%lu", &free);
if (ret != 1)
free = 0;
}
memset(buff, 0, sizeof(buff));
}
if (total > 0)
s->mem_used = 100.f * (total - free) / total;
else
s->mem_used = 0.f;
fclose(fp);
return 0;
}
void xmlnode_savetofile(struct xmlnode *node, FILE *f, int level)
{
int i;
int is_short_tag;
char *indent;
struct keyval *kv;
struct xmlnode *ch;
if (node == NULL) {
whine("xmlnode_savetofile: node == NULL");
return;
}
indent = alloca(sizeof(level + 1));
for (i = 0; i < level; i++)
indent[i] = '\t';
indent[level] = '\0';
fprintf(f, "%s<%s", indent, node->tag);
for (i = 0; i < plist_size(node->attributes); i++) {
kv = plist_getval(node->attributes, i);
fprintf(f, " %s=\"%s\"", kv->key, kv->val);
}
is_short_tag = (plist_size(node->childs) == 0) &&
xstr_isnull_or_empty(node->val);
if (is_short_tag) {
fprintf(f, " />");
} else {
fprintf(f, ">");
if (node->val != NULL)
fprintf(f, "%s", node->val);
if (plist_size(node->childs) > 0)
fprintf(f, "\n");
for (i = 0; i < plist_size(node->childs); i++) {
ch = plist_getval(node->childs, i);
xmlnode_savetofile(ch, f, level + 1);
}
if (plist_size(node->childs) > 0)
fprintf(f, "%s", indent);
if (!is_short_tag)
fprintf(f, "</%s>", node->tag);
}
fprintf(f, "\n");
}
static int irq_sstats(struct ifstat *s)
{
int i, rx = 0;
char *ptr, *ptr2;
char buff[4096];
FILE *fp = fopen("/proc/softirqs", "r");
if (!fp) {
whine("Cannot open /proc/softirqs!\n");
return -ENOENT;
}
stats_check_alloc(s);
memset(buff, 0, sizeof(buff));
while (fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
if ((ptr = strstr(buff, "NET_TX:")) == NULL) {
ptr = strstr(buff, "NET_RX:");
if (ptr == NULL)
continue;
rx = 1;
} else {
rx = 0;
}
ptr += strlen("NET_TX:");
for (i = 0; i < s->irqs_len; ++i) {
ptr++;
while (*ptr == ' ')
ptr++;
ptr2 = ptr;
while (*ptr != ' ' && *ptr != 0)
ptr++;
*ptr = 0;
if (rx)
s->irqs_srx[i] = atoi(ptr2);
else
s->irqs_stx[i] = atoi(ptr2);
}
memset(buff, 0, sizeof(buff));
}
fclose(fp);
return 0;
}
int device_irq_number(const char *ifname)
{
/*
* Since fetching IRQ numbers from SIOCGIFMAP is deprecated and not
* supported anymore, we need to grab them from procfs
*/
int irq = 0;
char *buffp;
char buff[512];
char sysname[512];
if (!strncmp("lo", ifname, strlen("lo")))
return 0;
FILE *fp = fopen("/proc/interrupts", "r");
if (!fp) {
whine("Cannot open /proc/interrupts!\n");
return -ENOENT;
}
memset(buff, 0, sizeof(buff));
while (fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
if (strstr(buff, ifname) == NULL)
continue;
buffp = buff;
while (*buffp != ':')
buffp++;
*buffp = 0;
irq = atoi(buff);
memset(buff, 0, sizeof(buff));
}
fclose(fp);
if (irq != 0)
return irq;
/*
* Try sysfs as fallback. Probably wireless devices will be found
* here. We return silently if it fails ...
*/
slprintf(sysname, sizeof(sysname), "/sys/class/net/%s/device/irq",
ifname);
fp = fopen(sysname, "r");
if (!fp)
return -ENOENT;
memset(buff, 0, sizeof(buff));
if(fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
irq = atoi(buff);
}
fclose(fp);
return irq;
}
/*PRINTFLIKE1*/
void
aborterr(const char *format, ...)
{
va_list ap;
va_start(ap, format);
whine("ERROR", format, ap);
va_end(ap);
#if defined(sun)
abort();
#else
exit(0);
#endif
}
static int pcap_mmap_push_file_header(int fd)
{
ssize_t ret;
struct pcap_filehdr hdr;
memset(&hdr, 0, sizeof(hdr));
pcap_prepare_header(&hdr, LINKTYPE_EN10MB, 0,
PCAP_DEFAULT_SNAPSHOT_LEN);
ret = write_or_die(fd, &hdr, sizeof(hdr));
if (unlikely(ret != sizeof(hdr))) {
whine("Failed to write pkt file header!\n");
return -EIO;
}
return 0;
}
static int rxtx_stats(const char *ifname, struct ifstat *s)
{
int ret, found = -1;
char *ptr;
char buf[1024];
FILE *fp = fopen("/proc/net/dev", "r");
if (!fp) {
whine("Cannot open /proc/net/dev!\n");
return -ENOENT;
}
/* Omit header */
ptr = fgets(buf, sizeof(buf), fp);
ptr = fgets(buf, sizeof(buf), fp);
memset(buf, 0, sizeof(buf));
while (fgets(buf, sizeof(buf), fp) != NULL) {
buf[sizeof(buf) -1] = 0;
if (strstr(buf, ifname) == NULL)
continue;
ptr = buf;
while (*ptr != ':')
ptr++;
ptr++;
ret = sscanf(ptr, "%lu%lu%lu%lu%lu%lu%lu%*u%lu%lu%lu%lu%lu%lu%lu",
&s->rx_bytes, &s->rx_packets, &s->rx_errors,
&s->rx_drops, &s->rx_fifo, &s->rx_frame,
&s->rx_multi,
&s->tx_bytes, &s->tx_packets, &s->tx_errors,
&s->tx_drops, &s->tx_fifo, &s->tx_colls,
&s->tx_carrier);
if (ret == 14) {
found = 0;
break;
}
memset(buf, 0, sizeof(buf));
}
fclose(fp);
return found;
}
int main(int argc, char **argv)
{
int ret, verbose = 0, c, opt_index;
char *file = NULL;
if (argc == 1)
help();
while (argc > 2 && (c = getopt_long(argc, argv, short_options,
long_options, &opt_index)) != EOF) {
switch (c) {
case 'h':
help();
break;
case 'v':
version();
break;
case 'V':
verbose = 1;
break;
case 'i':
file = xstrdup(optarg);
break;
case '?':
switch (optopt) {
case 'i':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (argc == 2)
file = xstrdup(argv[1]);
if (!file)
panic("No Berkeley Packet Filter program specified!\n");
ret = compile_filter(file, verbose);
xfree(file);
return ret;
}
int aslookup_prepare(const char *server, const char *port)
{
int ret, fd = -1, try = 1;
struct addrinfo hints, *ahead, *ai;
struct sockaddr_in6 *saddr6;
assert(server && port);
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
hints.ai_flags = AI_NUMERICSERV;
/* This function is really f****d up and seems to have high-stack
* usage since it provokes segfaults in some situations when it is
* directly included in aslookup! */
ret = getaddrinfo(server, port, &hints, &ahead);
if (ret != 0) {
whine("Cannot get address info!\n");
return -EIO;
}
for (ai = ahead; ai != NULL && fd < 0; ai = ai->ai_next) {
if (ai->ai_family == PF_INET6)
saddr6 = (struct sockaddr_in6 *) ai->ai_addr;
fd = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
if (fd < 0)
continue;
ret = connect(fd, ai->ai_addr, ai->ai_addrlen);
if (ret < 0) {
whine("Cannot connect to remote, try %d: %s!\n",
try++, strerror(errno));
close(fd);
fd = -1;
continue;
}
ai_family = ai->ai_family;
ai_socktype = ai->ai_socktype;
ai_protocol = ai->ai_protocol;
memcpy(&ai_ss, ai->ai_addr, ai->ai_addrlen);
close(fd);
break;
}
char *get_cpu_affinity(char *cpu_string, size_t len)
{
int ret, i, cpu;
cpu_set_t cpu_bitmask;
if (len != get_number_cpus() + 1)
return NULL;
CPU_ZERO(&cpu_bitmask);
ret = sched_getaffinity(getpid(), sizeof(cpu_bitmask),
&cpu_bitmask);
if (ret) {
whine("Can't fetch cpu affinity!\n");
return NULL;
}
for (i = 0, cpu_string[len - 1] = 0; i < len - 1; ++i) {
cpu = CPU_ISSET(i, &cpu_bitmask);
cpu_string[i] = (cpu ? '1' : '0');
}
return cpu_string;
}
int handleBoxIDsSection(gamedef_t *gamedef, const char *name, const char *value)
{
unsigned long boxID, valueByte = -1;
char *pos;
currentName = name;
char *boxIDstr = strchr(name, '.');
if (boxIDstr == (char*)NULL)
{
whine();
return -1;
}
boxID = strtoul((boxIDstr + 1), &pos, 16);
RANGE_CHECK(boxID, 0x100);
boxID &= 0xFF;
MATCH_BOX_TYPE_NAME("dummy", b_x);
MATCH_BOX_TYPE_NAME("collision", b_c);
MATCH_BOX_TYPE_NAME("vulnerable", b_v);
MATCH_BOX_TYPE_NAME("counterVulnerable", b_vc);
MATCH_BOX_TYPE_NAME("anywhereJuggleVulnerable", b_va);
MATCH_BOX_TYPE_NAME("otgVulnerable", b_vo);
MATCH_BOX_TYPE_NAME("guard", b_g);
MATCH_BOX_TYPE_NAME("attack", b_a);
MATCH_BOX_TYPE_NAME("projectileVulnerable", b_pv);
MATCH_BOX_TYPE_NAME("projectileAttack", b_pa);
MATCH_BOX_TYPE_NAME("throwable", b_tv);
MATCH_BOX_TYPE_NAME("throw", b_t);
if (valueByte == -1)
{
valueByte = strtoul(value, &pos, 10);
RANGE_CHECK(valueByte, validBoxTypes);
}
timestamp();
printf("Setting box ID %02X to value %02X\n", boxID, valueByte);
currentGame->boxTypeMap[boxID] = (boxtype_t)valueByte;
return 0;
}
int reconos_init() {
// register signal handler to cleanup on Ctrl-C
signal(SIGINT, exithandler);
signal(SIGTERM, exithandler);
signal(SIGABRT, exithandler);
// initialize driver
reconos_drv_init();
// initialize data structure
reconos_runtime.scheduler = NULL;
reconos_runtime.proc_control.fd = reconos_proc_control_open();
if (reconos_runtime.proc_control.fd < 0) {
whine("[reconos-core] unable to open proc control\n");
goto proc_control_failed;
}
reconos_runtime.proc_control.page_faults = 0;
// set reset signal for all HWTs
reconos_proc_control_sys_reset(reconos_runtime.proc_control.fd);
// set pgd
reconos_proc_control_set_pgd(reconos_runtime.proc_control.fd);
#ifdef RECONOS_MMU_true
// create delegate thread
pthread_create(&reconos_runtime.proc_control.page_fault_handler, NULL,
proc_control_page_fault_handler, &reconos_runtime.proc_control);
#endif
goto out;
proc_control_failed:
panic("[reconos-core] reconos_init failed\n");
return -1;
out:
return 0;
}
int poll_error_maybe_die(int sock, struct pollfd *pfd)
{
if ((pfd->revents & (POLLHUP | POLLRDHUP | POLLERR | POLLNVAL)) == 0)
return POLL_NEXT_PKT;
if (pfd->revents & (POLLHUP | POLLRDHUP))
panic("Hangup on socket occured!\n");
if (pfd->revents & POLLERR) {
int tmp;
errno = 0;
/* recv is more specififc on the error */
if (recv(sock, &tmp, sizeof(tmp), MSG_PEEK) >= 0)
return POLL_NEXT_PKT;
if (errno == ENETDOWN)
panic("Interface went down!\n");
return POLL_MOVE_OUT;
}
if (pfd->revents & POLLNVAL) {
whine("Invalid polling request on socket!\n");
return POLL_MOVE_OUT;
}
return POLL_NEXT_PKT;
}
void*
um_postwrite(void **rtnp, p_t target, p_t source, znz_t znz)
{
struct block *tblk;
int yow, ayow = 0;
if (um_likely(!btst(prognowr, target)))
return 0;
while ((tblk = getblk(target))) {
yow = inblk(tblk, source);
ayow = ayow || yow;
whine(("postwrite: shootdown %u -> %u%s",
source, target, yow?" (YOW!)":""));
delblk(tblk);
}
assert(!btst(prognowr, target));
if (!btst(prognowr, source))
return *rtnp = umc_enter(source + 1, znz);
else
return 0;
}
int main(int argc, char **argv)
{
int c, i, j, opt_index;
char *ptr;
bool prio_high = false;
struct mode mode;
void (*enter_mode)(struct mode *mode) = NULL;
check_for_root_maybe_die();
memset(&mode, 0, sizeof(mode));
mode.link_type = LINKTYPE_EN10MB;
mode.print_mode = FNTTYPE_PRINT_NORM;
mode.cpu = CPU_UNKNOWN;
mode.packet_type = PACKET_ALL;
mode.promiscuous = true;
mode.randomize = false;
mode.pcap = PCAP_OPS_SG;
mode.dump_interval = DUMP_INTERVAL;
while ((c = getopt_long(argc, argv, short_options, long_options,
&opt_index)) != EOF) {
switch (c) {
case 'd':
case 'i':
mode.device_in = xstrdup(optarg);
break;
case 'o':
mode.device_out = xstrdup(optarg);
break;
case 'r':
mode.randomize = true;
break;
case 'J':
mode.jumbo_support = 1;
break;
case 'f':
mode.filter = xstrdup(optarg);
break;
case 'M':
mode.promiscuous = false;
break;
case 't':
if (!strncmp(optarg, "host", strlen("host")))
mode.packet_type = PACKET_HOST;
else if (!strncmp(optarg, "broadcast", strlen("broadcast")))
mode.packet_type = PACKET_BROADCAST;
else if (!strncmp(optarg, "multicast", strlen("multicast")))
mode.packet_type = PACKET_MULTICAST;
else if (!strncmp(optarg, "others", strlen("others")))
mode.packet_type = PACKET_OTHERHOST;
else if (!strncmp(optarg, "outgoing", strlen("outgoing")))
mode.packet_type = PACKET_OUTGOING;
else
mode.packet_type = PACKET_ALL;
break;
case 'S':
ptr = optarg;
mode.reserve_size = 0;
for (j = i = strlen(optarg); i > 0; --i) {
if (!isdigit(optarg[j - i]))
break;
ptr++;
}
if (!strncmp(ptr, "KB", strlen("KB")))
mode.reserve_size = 1 << 10;
else if (!strncmp(ptr, "MB", strlen("MB")))
mode.reserve_size = 1 << 20;
else if (!strncmp(ptr, "GB", strlen("GB")))
mode.reserve_size = 1 << 30;
else
panic("Syntax error in ring size param!\n");
*ptr = 0;
mode.reserve_size *= atoi(optarg);
break;
case 'b':
set_cpu_affinity(optarg, 0);
if (mode.cpu != CPU_NOTOUCH)
mode.cpu = atoi(optarg);
break;
case 'B':
set_cpu_affinity(optarg, 1);
break;
case 'H':
prio_high = true;
break;
case 'c':
mode.pcap = PCAP_OPS_RW;
break;
case 'm':
mode.pcap = PCAP_OPS_MMAP;
break;
case 'Q':
mode.cpu = CPU_NOTOUCH;
break;
case 's':
mode.print_mode = FNTTYPE_PRINT_NONE;
break;
case 'q':
mode.print_mode = FNTTYPE_PRINT_LESS;
break;
case 'l':
mode.print_mode = FNTTYPE_PRINT_CHR1;
break;
case 'x':
mode.print_mode = FNTTYPE_PRINT_HEX1;
break;
case 'C':
mode.print_mode = FNTTYPE_PRINT_PAAC;
break;
case 'X':
mode.print_mode = FNTTYPE_PRINT_HEX2;
break;
case 'N':
mode.print_mode = FNTTYPE_PRINT_NOPA;
break;
case 'k':
mode.kpull = (unsigned long) atol(optarg);
break;
case 'n':
frame_cnt_max = (unsigned long) atol(optarg);
break;
case 'F':
mode.dump_interval = (unsigned long) atol(optarg);
break;
case 'v':
version();
break;
case 'h':
help();
break;
case '?':
switch (optopt) {
case 'd':
case 'i':
case 'o':
case 'f':
case 't':
case 'F':
case 'n':
case 'S':
case 'b':
case 'k':
case 'B':
case 'e':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (!mode.device_in)
mode.device_in = xstrdup("any");
register_signal(SIGINT, signal_handler);
register_signal(SIGHUP, signal_handler);
init_pcap(mode.jumbo_support);
tprintf_init();
header();
if (prio_high == true) {
set_proc_prio(get_default_proc_prio());
set_sched_status(get_default_sched_policy(),
get_default_sched_prio());
}
if (mode.device_in && (device_mtu(mode.device_in) ||
!strncmp("any", mode.device_in, strlen(mode.device_in)))) {
if (!mode.device_out) {
mode.dump = 0;
enter_mode = enter_mode_rx_only_or_dump;
} else if (device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_rx_to_tx;
} else {
mode.dump = 1;
register_signal_f(SIGALRM, timer_next_dump, SA_SIGINFO);
enter_mode = enter_mode_rx_only_or_dump;
}
} else {
if (mode.device_out && device_mtu(mode.device_out)) {
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
enter_mode = enter_mode_pcap_to_tx;
} else {
enter_mode = enter_mode_read_pcap;
}
}
if (!enter_mode)
panic("Selection not supported!\n");
enter_mode(&mode);
tprintf_cleanup();
cleanup_pcap();
if (mode.device_in)
xfree(mode.device_in);
if (mode.device_out)
xfree(mode.device_out);
return 0;
}
static int stun_test(const char *server_ip, int server_port,
int transsip_port)
{
int ret, sock, set = 1;
uint8_t pkt[256];
uint8_t rpkt[256];
size_t len, off, max;
struct in_addr in;
struct timeval timeout;
struct stun_header *hdr, *rhdr;
struct stun_attrib *attr;
struct stun_mapped_addr *addr;
struct sockaddr_in saddr, daddr;
fd_set fdset;
if (!server_ip)
return -EINVAL;
sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (sock < 0)
panic("Cannot obtain socket!\n");
ret = setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &set, sizeof(set));
if (ret)
panic("Cannot set socket option!\n");
saddr.sin_family = PF_INET;
saddr.sin_port = htons(transsip_port);
saddr.sin_addr.s_addr = INADDR_ANY;
ret = bind(sock, (struct sockaddr *) &saddr, sizeof(saddr));
if (ret)
panic("Cannot bind udp socket!\n");
len = REQUEST_LEN;
hdr = (struct stun_header *) pkt;
hdr->type = htons(BINDING_REQUEST);
hdr->len = 0;
hdr->magic_cookie = ID_COOKIE_FIELD;
hdr->transid[0] = htonl(rand());
hdr->transid[1] = htonl(rand());
hdr->transid[2] = htonl(rand());
daddr.sin_family = PF_INET;
daddr.sin_port = htons(server_port);
daddr.sin_addr.s_addr = inet_addr(server_ip);
ret = sendto(sock, pkt, len, 0, (struct sockaddr *) &daddr,
sizeof(daddr));
if (ret != len) {
whine("Error sending request (%s)!\n", strerror(errno));
return -EIO;
}
set_timeout(&timeout, TIMEOUT);
FD_ZERO(&fdset);
FD_SET(sock, &fdset);
ret = select(sock + 1, &fdset, NULL, NULL, &timeout);
if (ret <= 0) {
whine("STUN server timeout!\n");
return -EIO;
}
memset(rpkt, 0, sizeof(rpkt));
len = read(sock, rpkt, sizeof(rpkt));
close(sock);
if (len < REQUEST_LEN) {
whine("Bad STUN response (%s)!\n", strerror(errno));
return -EIO;
}
rhdr = (struct stun_header *) rpkt;
if (ntohs(rhdr->type) != BINDING_RESPONSE) {
whine("Wrong STUN response type!\n");
return -EIO;
}
if (rhdr->len == 0) {
whine("No attributes in STUN response!\n");
return -EIO;
}
if (rhdr->magic_cookie != hdr->magic_cookie ||
rhdr->transid[0] != hdr->transid[0] ||
rhdr->transid[1] != hdr->transid[1] ||
rhdr->transid[2] != hdr->transid[2]) {
whine("Got wrong STUN transaction id!\n");
return -EIO;
}
off = REQUEST_LEN;
max = ntohs(rhdr->len) + REQUEST_LEN;
while (off + 8 < max) {
attr = (struct stun_attrib *) (rpkt + off);
if (ntohs(attr->type) != MAPPED_ADDRESS)
goto next;
addr = (struct stun_mapped_addr *) (rpkt + off + 4);
if (addr->family != 0x1)
break;
in.s_addr = addr->ip;
printf("Public mapping %s:%u!\n",
inet_ntoa(in), ntohs(addr->port));
break;
next:
off += 4;
off += ntohs(attr->len);
}
return 0;
}
static int sys_stats(struct ifstat *s)
{
int ret, cpu;
char *ptr, *ptr2;
char buff[4096];
FILE *fp = fopen("/proc/stat", "r");
if (!fp) {
whine("Cannot open /proc/stat!\n");
return -ENOENT;
}
stats_check_alloc(s);
memset(buff, 0, sizeof(buff));
while (fgets(buff, sizeof(buff), fp) != NULL) {
buff[sizeof(buff) - 1] = 0;
if ((ptr = strstr(buff, "cpu")) != NULL) {
ptr += strlen("cpu");
if (*ptr == ' ')
goto next;
ptr2 = ptr;
while (*ptr != ' ' && *ptr != 0)
ptr++;
*ptr = 0;
cpu = atoi(ptr2);
if (cpu < 0 || cpu >= s->irqs_len)
goto next;
ptr++;
ret = sscanf(ptr, "%lu%lu%lu%lu%lu", &s->cpu_user[cpu],
&s->cpu_nice[cpu], &s->cpu_sys[cpu],
&s->cpu_idle[cpu], &s->cpu_iow[cpu]);
if (ret != 5)
goto next;
} else if ((ptr = strstr(buff, "ctxt")) != NULL) {
ptr += strlen("ctxt");
ptr++;
while (*ptr == ' ')
ptr++;
ret = sscanf(ptr, "%lu", &s->ctxt);
if (ret != 1)
s->ctxt = 0;
} else if ((ptr = strstr(buff, "processes")) != NULL) {
ptr += strlen("processes");
ptr++;
while (*ptr == ' ')
ptr++;
ret = sscanf(ptr, "%lu", &s->forks);
if (ret != 1)
s->forks = 0;
} else if ((ptr = strstr(buff, "procs_running")) != NULL) {
ptr += strlen("procs_running");
ptr++;
while (*ptr == ' ')
ptr++;
ret = sscanf(ptr, "%lu", &s->procs_run);
if (ret != 1)
s->procs_run = 0;
} else if ((ptr = strstr(buff, "procs_blocked")) != NULL) {
ptr += strlen("procs_blocked");
ptr++;
while (*ptr == ' ')
ptr++;
ret = sscanf(ptr, "%lu", &s->procs_iow);
if (ret != 1)
s->procs_iow = 0;
}
next:
memset(buff, 0, sizeof(buff));
}
fclose(fp);
return 0;
}
int main(int argc, char **argv)
{
int ret = 0, c, opt_index, udp = 0, ipv4 = -1, daemon = 1, log = 1;
char *port = NULL, *stun = NULL, *dev = NULL, *home = NULL, *alias = NULL;
enum working_mode wmode = MODE_UNKNOW;
if (getuid() != geteuid())
seteuid(getuid());
home = fetch_home_dir();
while ((c = getopt_long(argc, argv, short_options, long_options,
&opt_index)) != EOF) {
switch (c) {
case 'h':
help();
break;
case 'v':
version();
break;
case 'D':
daemon = 0;
break;
case 'N':
log = 0;
break;
case 'C':
wmode = MODE_DUMPC;
break;
case 'S':
wmode = MODE_DUMPS;
break;
case 'c':
wmode = MODE_CLIENT;
if (optarg) {
if (*optarg == '=')
optarg++;
alias = xstrdup(optarg);
}
break;
case 'd':
dev = xstrdup(optarg);
break;
case 'k':
wmode = MODE_KEYGEN;
break;
case '4':
ipv4 = 1;
break;
case '6':
ipv4 = 0;
break;
case 'x':
wmode = MODE_EXPORT;
break;
case 's':
wmode = MODE_SERVER;
break;
case 'u':
udp = 1;
break;
case 't':
stun = xstrdup(optarg);
break;
case 'p':
port = xstrdup(optarg);
break;
case '?':
switch (optopt) {
case 't':
case 'd':
case 'u':
case 'p':
panic("Option -%c requires an argument!\n",
optopt);
default:
if (isprint(optopt))
whine("Unknown option character "
"`0x%X\'!\n", optopt);
die();
}
default:
break;
}
}
if (argc < 2)
help();
register_signal(SIGINT, signal_handler);
register_signal(SIGHUP, signal_handler);
register_signal(SIGTERM, signal_handler);
register_signal(SIGPIPE, signal_handler);
header();
curve25519_selftest();
switch (wmode) {
case MODE_KEYGEN:
ret = main_keygen(home);
break;
case MODE_EXPORT:
ret = main_export(home);
break;
case MODE_DUMPC:
ret = main_dumpc(home);
break;
case MODE_DUMPS:
ret = main_dumps(home);
break;
case MODE_CLIENT:
ret = main_client(home, dev, alias, daemon);
break;
case MODE_SERVER:
if (!port)
panic("No port specified!\n");
if (stun)
print_stun_probe(stun, 3478, strtoul(port, NULL, 10));
ret = main_server(home, dev, port, udp, ipv4, daemon, log);
break;
default:
die();
}
if (dev)
xfree(dev);
if (stun)
xfree(stun);
if (port)
xfree(port);
if (alias)
xfree(alias);
return ret;
}
void main()
{
printf ("Hello, world!\n");
whine();
}
