static int handle_request(struct mg_connection *conn)
{
static const char *PONG_STR =
"{\"version\" : \"brubeck %s\", \"pid\" : %d, \"status\" : \"%s\"}\n";
if (!strcmp(conn->request_method, "GET")) {
if (!strcmp(conn->uri, "/ping")) {
struct brubeck_server *brubeck = conn->server_param;
const char *status = "OK";
if (brubeck->at_capacity)
status = "CAPACITY";
if (!brubeck->running)
status = "SHUTDOWN";
send_headers(conn);
mg_printf_data(conn, PONG_STR, GIT_SHA, getpid(), status);
return MG_TRUE;
}
if (!strcmp(conn->uri, "/stats"))
return send_stats(conn);
if (starts_with(conn->uri, "/metric/"))
return send_metric(conn);
}
if (!strcmp(conn->request_method, "POST")) {
if (starts_with(conn->uri, "/expire/"))
return expire_metric(conn);
}
return MG_FALSE;
}
static int
handle_request(void *cls, struct MHD_Connection *connection,
const char *url, const char *method,
const char *version, const char *upload_data,
size_t *upload_data_size, void **con_cls)
{
int ret;
struct MHD_Response *response = NULL;
struct brubeck_server *brubeck = cls;
if (!strcmp(method, "GET")) {
if (!strcmp(url, "/ping")) {
char *jsonr;
json_t *pong = json_pack("{s:s, s:i, s:s}",
"version", "brubeck " GIT_SHA,
"pid", (int)getpid(),
"status", "OK");
jsonr = json_dumps(pong, JSON_PRESERVE_ORDER);
response = MHD_create_response_from_data(strlen(jsonr), jsonr, 1, 0);
json_decref(pong);
}
else if (!strcmp(url, "/stats"))
response = send_stats(brubeck);
else if (starts_with(url, "/metric/"))
response = send_metric(brubeck, url);
}
else if (!strcmp(method, "POST")) {
if (starts_with(url, "/expire/"))
response = expire_metric(brubeck, url);
}
if (!response) {
static const char *NOT_FOUND = "404 not found";
response = MHD_create_response_from_data(
strlen(NOT_FOUND), (void *)NOT_FOUND, 0, 0);
MHD_add_response_header(response, "Connection", "close");
ret = MHD_queue_response(connection, 404, response);
} else {
MHD_add_response_header(response, "Connection", "close");
MHD_add_response_header(response, "Content-Type", "application/json");
ret = MHD_queue_response(connection, 200, response);
}
MHD_destroy_response(response);
return ret;
}
int main(int argc, char **argv)
{
int opt;
int do_list = 0;
char *do_load = NULL;
while ((opt = getopt(argc, argv, "h?b:lf:a:n:kR:B:")) != EOF) {
switch (opt) {
case 'b':
dbname = optarg;
break;
case 'f':
if (do_load) {
fprintf(stderr, "Duplicate option -f\n");
usage();
}
do_load = optarg;
break;
case 'l':
do_list = 1;
break;
case 'a':
active_probing = atoi(optarg);
break;
case 'n':
negative_timeout = atoi(optarg);
break;
case 'k':
no_kernel_broadcasts = 1;
break;
case 'R':
if ((broadcast_rate = atoi(optarg)) <= 0 ||
(broadcast_rate = 1000/broadcast_rate) <= 0) {
fprintf(stderr, "Invalid ARP rate\n");
exit(-1);
}
break;
case 'B':
if ((broadcast_burst = atoi(optarg)) <= 0 ||
(broadcast_burst = 1000*broadcast_burst) <= 0) {
fprintf(stderr, "Invalid ARP burst\n");
exit(-1);
}
break;
case 'h':
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
ifnum = argc;
ifnames = argv;
ifvec = malloc(argc*sizeof(int));
if (!ifvec) {
perror("malloc");
exit(-1);
}
}
if ((udp_sock = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("socket");
exit(-1);
}
if (ifnum) {
int i;
struct ifreq ifr;
memset(&ifr, 0, sizeof(ifr));
for (i=0; i<ifnum; i++) {
strncpy(ifr.ifr_name, ifnames[i], IFNAMSIZ);
if (ioctl(udp_sock, SIOCGIFINDEX, &ifr)) {
perror("ioctl(SIOCGIFINDEX)");
exit(-1);;
}
ifvec[i] = ifr.ifr_ifindex;
}
}
dbase = dbopen(dbname, O_CREAT|O_RDWR, 0644, DB_HASH, NULL);
if (dbase == NULL) {
perror("db_open");
exit(-1);
}
if (do_load) {
char buf[128];
FILE *fp;
struct dbkey k;
DBT dbkey, dbdat;
dbkey.data = &k;
dbkey.size = sizeof(k);
if (strcmp(do_load, "-") == 0 || strcmp(do_load, "--") == 0) {
fp = stdin;
} else if ((fp = fopen(do_load, "r")) == NULL) {
perror("fopen");
goto do_abort;
}
buf[sizeof(buf)-1] = 0;
while (fgets(buf, sizeof(buf)-1, fp)) {
__u8 b1[6];
char ipbuf[128];
char macbuf[128];
if (buf[0] == '#')
continue;
if (sscanf(buf, "%u%s%s", &k.iface, ipbuf, macbuf) != 3) {
fprintf(stderr, "Wrong format of input file \"%s\"\n", do_load);
goto do_abort;
}
if (strncmp(macbuf, "FAILED:", 7) == 0)
continue;
if (!inet_aton(ipbuf, (struct in_addr*)&k.addr)) {
fprintf(stderr, "Invalid IP address: \"%s\"\n", ipbuf);
goto do_abort;
}
dbdat.data = hexstring_a2n(macbuf, b1, 6);
if (dbdat.data == NULL)
goto do_abort;
dbdat.size = 6;
if (dbase->put(dbase, &dbkey, &dbdat, 0)) {
perror("hash->put");
goto do_abort;
}
}
dbase->sync(dbase, 0);
if (fp != stdin)
fclose(fp);
}
if (do_list) {
DBT dbkey, dbdat;
printf("%-8s %-15s %s\n", "#Ifindex", "IP", "MAC");
while (dbase->seq(dbase, &dbkey, &dbdat, R_NEXT) == 0) {
struct dbkey *key = dbkey.data;
if (handle_if(key->iface)) {
if (!IS_NEG(dbdat.data)) {
char b1[18];
printf("%-8d %-15s %s\n",
key->iface,
inet_ntoa(*(struct in_addr*)&key->addr),
hexstring_n2a(dbdat.data, 6, b1, 18));
} else {
printf("%-8d %-15s FAILED: %dsec ago\n",
key->iface,
inet_ntoa(*(struct in_addr*)&key->addr),
NEG_AGE(dbdat.data));
}
}
}
}
if (do_load || do_list)
goto out;
pset[0].fd = socket(PF_PACKET, SOCK_DGRAM, 0);
if (pset[0].fd < 0) {
perror("socket");
exit(-1);
}
if (1) {
struct sockaddr_ll sll;
memset(&sll, 0, sizeof(sll));
sll.sll_family = AF_PACKET;
sll.sll_protocol = htons(ETH_P_ARP);
sll.sll_ifindex = (ifnum == 1 ? ifvec[0] : 0);
if (bind(pset[0].fd, (struct sockaddr*)&sll, sizeof(sll)) < 0) {
perror("bind");
goto do_abort;
}
}
if (rtnl_open(&rth, RTMGRP_NEIGH) < 0) {
perror("rtnl_open");
goto do_abort;
}
pset[1].fd = rth.fd;
load_initial_table();
if (daemon(0, 0)) {
perror("arpd: daemon");
goto do_abort;
}
openlog("arpd", LOG_PID | LOG_CONS, LOG_DAEMON);
catch_signal(SIGINT, sig_exit);
catch_signal(SIGTERM, sig_exit);
catch_signal(SIGHUP, sig_sync);
catch_signal(SIGUSR1, sig_stats);
#define EVENTS (POLLIN|POLLPRI|POLLERR|POLLHUP)
pset[0].events = EVENTS;
pset[0].revents = 0;
pset[1].events = EVENTS;
pset[1].revents = 0;
sigsetjmp(env, 1);
for (;;) {
in_poll = 1;
if (do_exit)
break;
if (do_sync) {
in_poll = 0;
dbase->sync(dbase, 0);
do_sync = 0;
in_poll = 1;
}
if (do_stats)
send_stats();
if (poll(pset, 2, 30000) > 0) {
in_poll = 0;
if (pset[0].revents&EVENTS)
get_arp_pkt();
if (pset[1].revents&EVENTS)
get_kern_msg();
} else {
do_sync = 1;
}
}
undo_sysctl_adjustments();
out:
dbase->close(dbase);
exit(0);
do_abort:
dbase->close(dbase);
exit(-1);
}
/*
* main:
* The main program.
*/
int
main(int ac, char **av)
{
PLAYER *pp;
int had_char;
static fd_set read_fds;
static FLAG first = TRUE;
static FLAG server = FALSE;
int c;
static struct timeval linger = { 0, 0 };
static struct timeval timeout = { 0, 0 }, *to;
struct spawn *sp, *spnext;
int ret;
int nready;
int fd;
First_arg = av[0];
config();
while ((c = getopt(ac, av, "sp:a:D:")) != -1) {
switch (c) {
case 's':
server = TRUE;
break;
case 'p':
should_announce = FALSE;
Server_port = atoi(optarg);
break;
case 'a':
if (!inet_aton(optarg, (struct in_addr *)&Server_addr))
err(1, "bad interface address: %s", optarg);
break;
case 'D':
config_arg(optarg);
break;
default:
erred:
fprintf(stderr,
"usage: %s [-s] [-a addr] [-Dvar=value ...] "
"[-p port]\n",
av[0]);
exit(2);
}
}
if (optind < ac)
goto erred;
/* Open syslog: */
openlog("huntd", LOG_PID | (conf_logerr && !server? LOG_PERROR : 0),
LOG_DAEMON);
/* Initialise game parameters: */
init();
again:
do {
/* First, poll to see if we can get input */
do {
read_fds = Fds_mask;
errno = 0;
timerclear(&timeout);
nready = select(Num_fds, &read_fds, NULL, NULL,
&timeout);
if (nready < 0 && errno != EINTR) {
logit(LOG_ERR, "select");
cleanup(1);
}
} while (nready < 0);
if (nready == 0) {
/*
* Nothing was ready. We do some work now
* to see if the simulation has any pending work
* to do, and decide if we need to block
* indefinitely or just timeout.
*/
do {
if (conf_simstep && can_moveshots()) {
/*
* block for a short time before continuing
* with explosions, bullets and whatnot
*/
to = &timeout;
to->tv_sec = conf_simstep / 1000000;
to->tv_usec = conf_simstep % 1000000;
} else
/*
* since there's nothing going on,
* just block waiting for external activity
*/
to = NULL;
read_fds = Fds_mask;
errno = 0;
nready = select(Num_fds, &read_fds, NULL, NULL,
to);
if (nready < 0 && errno != EINTR) {
logit(LOG_ERR, "select");
cleanup(1);
}
} while (nready < 0);
}
/* Remember which descriptors are active: */
Have_inp = read_fds;
/* Answer new player connections: */
if (FD_ISSET(Socket, &Have_inp))
answer_first();
/* Continue answering new player connections: */
for (sp = Spawn; sp; ) {
spnext = sp->next;
fd = sp->fd;
if (FD_ISSET(fd, &Have_inp) && answer_next(sp)) {
/*
* Remove from the spawn list. (fd remains in
* read set).
*/
*sp->prevnext = sp->next;
if (sp->next)
sp->next->prevnext = sp->prevnext;
free(sp);
/* We probably consumed all data. */
FD_CLR(fd, &Have_inp);
/* Announce game if this is the first spawn. */
if (first && should_announce)
announce_game();
first = FALSE;
}
sp = spnext;
}
/* Process input and move bullets until we've exhausted input */
had_char = TRUE;
while (had_char) {
moveshots();
for (pp = Player; pp < End_player; )
if (pp->p_death[0] != '\0')
zap(pp, TRUE);
else
pp++;
for (pp = Monitor; pp < End_monitor; )
if (pp->p_death[0] != '\0')
zap(pp, FALSE);
else
pp++;
had_char = FALSE;
for (pp = Player; pp < End_player; pp++)
if (havechar(pp)) {
execute(pp);
pp->p_nexec++;
had_char = TRUE;
}
for (pp = Monitor; pp < End_monitor; pp++)
if (havechar(pp)) {
mon_execute(pp);
pp->p_nexec++;
had_char = TRUE;
}
}
/* Handle a datagram sent to the server socket: */
if (FD_ISSET(Server_socket, &Have_inp))
handle_wkport(Server_socket);
/* Answer statistics connections: */
if (FD_ISSET(Status, &Have_inp))
send_stats();
/* Flush/synchronize all the displays: */
for (pp = Player; pp < End_player; pp++) {
if (FD_ISSET(pp->p_fd, &read_fds)) {
sendcom(pp, READY, pp->p_nexec);
pp->p_nexec = 0;
}
flush(pp);
}
for (pp = Monitor; pp < End_monitor; pp++) {
if (FD_ISSET(pp->p_fd, &read_fds)) {
sendcom(pp, READY, pp->p_nexec);
pp->p_nexec = 0;
}
flush(pp);
}
} while (Nplayer > 0);
/* No more players! */
/* No players yet or a continuous game? */
if (first || conf_linger < 0)
goto again;
/* Wait a short while for one to come back: */
read_fds = Fds_mask;
linger.tv_sec = conf_linger;
while ((ret = select(Num_fds, &read_fds, NULL, NULL, &linger)) < 0) {
if (errno != EINTR) {
logit(LOG_WARNING, "select");
break;
}
read_fds = Fds_mask;
linger.tv_sec = conf_linger;
linger.tv_usec = 0;
}
if (ret > 0)
/* Someone returned! Resume the game: */
goto again;
/* else, it timed out, and the game is really over. */
/* If we are an inetd server, we should re-init the map and restart: */
if (server) {
clear_scores();
makemaze();
clearwalls();
makeboots();
first = TRUE;
goto again;
}
/* Get rid of any attached monitors: */
for (pp = Monitor; pp < End_monitor; )
zap(pp, FALSE);
/* Fin: */
cleanup(0);
exit(0);
}
void handle_sigusr1()
{
send_stats();
}
/*
void draw_points(int r, int g, int b, const std::vector<GLfloat>& v) {
if(v.empty()) {
return;
}
glPointSize(5);
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glColor4ub(r, g, b, 255);
glVertexPointer(2, GL_FLOAT, 0, &v[0]);
glDrawArrays(GL_POINTS, 0, v.size()/2);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
glColor4ub(255, 255, 255, 255);
}
void draw_stats(const std::vector<record_ptr>& records)
{
if(!player_move_record_vertex_array.empty()) {
glDisable(GL_TEXTURE_2D);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glColor4ub(0, 0, 255, 128);
glVertexPointer(2, GL_FLOAT, 0, &player_move_record_vertex_array[0]);
glDrawArrays(GL_LINES, 0, player_move_record_vertex_array.size()/2);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnable(GL_TEXTURE_2D);
glColor4ub(255, 255, 255, 255);
}
draw_points(255, 0, 0, die_record_vertex_array);
draw_points(255, 255, 0, quit_record_vertex_array);
}
*/
void flush()
{
send_stats(write_queue);
threading::lock lck(upload_queue_mutex());
send_stats_signal().notify_one();
}
/* Return values:
* Negative on error
* 0 on success with a reusable socket
* 1 on success with a non-reusable socket */
static int process_request(int client, uid_t uid, request_header * req, void * key)
{
struct cache_entry * entry;
void * reply;
int32_t reply_len;
time_t refresh_interval;
pthread_mutex_t * extra_mutex = NULL;
int r;
if(debug)
printf("Got request type %d (key = [%s]) from UID %d on FD %d\n", req->type, (char *) key, uid, client);
/* first check for control messages */
if(req->type > LASTDBREQ && req->type != GETPWENT && req->type != GETGRENT && req->type != GETAI && req->type != INITGROUPS)
{
if(req->type == SHUTDOWN)
exit(0);
if(req->type == GETSTAT)
{
/* to aid the use of -g in figuring out whether
* gnscd is answering queries correctly, grab
* the cache mutex and release it to make sure
* it's not stuck locked by some thread */
pthread_mutex_lock(&cache_mutex);
pthread_mutex_unlock(&cache_mutex);
send_stats(client, uid);
}
if(req->type == INVALIDATE)
{
/* key is "passwd" "group" or "hosts" */
/* use memcmp not strcmp for security */
/* if it's hosts, call res_init() */
/* NOT IMPLEMENTED */
}
return 1;
}
/* not a control message, so check if the service is disabled */
if(is_disabled(req->type))
{
if(debug)
printf("Service type %d disabled\n", req->type);
r = generate_disabled_reply(req->type, &reply, &reply_len);
if(r < 0)
return -1;
if(write_all(client, reply, reply_len, SHORT_TIMEOUT) != reply_len)
return -1;
return r;
}
/* if it is a GET*ENT query, grab the extra mutex */
if(req->type == GETPWENT)
extra_mutex = pwent_query_mutex;
else if(req->type == GETGRENT)
extra_mutex = grent_query_mutex;
if(extra_mutex)
pthread_mutex_lock(extra_mutex);
pthread_mutex_lock(&cache_mutex);
r = cache_search(req, key, uid, &entry);
if(r < 0 && extra_mutex)
{
if(debug)
printf("Not in the cache, requesting iteration.\n");
/* request it */
r = request_ent_cache(req, key, uid);
if(r >= 0)
r = cache_search(req, key, uid, &entry);
}
if(r >= 0)
{
if(debug)
printf("Found it in the cache!\n");
r = entry->close_socket;
/* reset the refresh count */
entry->refreshes = 0;
if(write_all(client, entry->reply, entry->reply_len, SHORT_TIMEOUT) != entry->reply_len)
r = -1;
pthread_mutex_unlock(&cache_mutex);
if(extra_mutex)
pthread_mutex_unlock(extra_mutex);
return r;
}
pthread_mutex_unlock(&cache_mutex);
if(debug)
printf("Not in the cache.\n");
if(!extra_mutex)
/* find it */
r = generate_reply(req, key, uid, &reply, &reply_len, &refresh_interval);
else
r = -1;
if(r >= 0)
{
int close_socket = r;
int add_result = -1;
if(write_all(client, reply, reply_len, SHORT_TIMEOUT) != reply_len)
{
if(debug)
printf("Failed to write to client %d\n", client);
r = -1;
}
pthread_mutex_lock(&cache_mutex);
/* don't add duplicate entries */
if(cache_search(req, key, uid, &entry) < 0)
add_result = cache_add(req, key, uid, reply, reply_len, close_socket, refresh_interval);
if(add_result < 0)
/* either it was already in the cache or adding it failed */
free(reply);
pthread_mutex_unlock(&cache_mutex);
}
/* if it was a GET*ENT query, release the extra mutex */
if(extra_mutex)
pthread_mutex_unlock(extra_mutex);
return r;
}
