static int
auth_conv(int num_msg, const struct pam_message **msg,
struct pam_response **resp, void *appdata)
{
int i;
cred_t *cred = (cred_t *) appdata;
struct pam_response *reply =
malloc(sizeof(struct pam_response) * num_msg);
for (i = 0; i < num_msg; i++) {
switch (msg[i]->msg_style) {
case PAM_PROMPT_ECHO_ON: /* assume want user name */
reply[i].resp_retcode = PAM_SUCCESS;
reply[i].resp = COPY_STRING(cred->uname);
/* PAM frees resp. */
break;
case PAM_PROMPT_ECHO_OFF: /* assume want password */
reply[i].resp_retcode = PAM_SUCCESS;
reply[i].resp = COPY_STRING(cred->pass);
/* PAM frees resp. */
break;
case PAM_TEXT_INFO:
case PAM_ERROR_MSG:
reply[i].resp_retcode = PAM_SUCCESS;
reply[i].resp = NULL;
break;
default: /* unknown message style */
free(reply);
return PAM_CONV_ERR;
}
}
*resp = reply;
return PAM_SUCCESS;
}
void sprint_hw_oq_drops(router_state *rs, char **buf, unsigned int *len) {
char *buffer = calloc(2*HW_OQ_DROPS_LEN + 1, sizeof(char));
unsigned int total_len = 0;
if (rs->is_netfpga) {
char* port_names[8] = {"Q0", "Q1", "Q2", "Q3", "Q4", "Q5", "Q6", "Q7"};
char line[HW_OQ_DROPS_LEN];
bzero(line, HW_OQ_DROPS_LEN);
snprintf(line, HW_OQ_DROPS_LEN, "%4s %10u %4s %10u %4s %10u %4s %10u\n",
port_names[0], get_oq_num_pkts_dropped(&rs->netfpga, 0),
port_names[1], get_oq_num_pkts_dropped(&rs->netfpga, 1),
port_names[2], get_oq_num_pkts_dropped(&rs->netfpga, 2),
port_names[3], get_oq_num_pkts_dropped(&rs->netfpga, 3));
COPY_STRING(buffer, total_len, line);
snprintf(line, HW_OQ_DROPS_LEN, "%4s %10u %4s %10u %4s %10u %4s %10u\n",
port_names[4], get_oq_num_pkts_dropped(&rs->netfpga, 4),
port_names[5], get_oq_num_pkts_dropped(&rs->netfpga, 5),
port_names[6], get_oq_num_pkts_dropped(&rs->netfpga, 6),
port_names[7], get_oq_num_pkts_dropped(&rs->netfpga, 7));
COPY_STRING(buffer, total_len, line);
}
*buf = buffer;
*len = total_len;
}
void sprint_hw_local_ip_filter(router_state *rs, char **buf, unsigned int *len) {
char *buffer = calloc((1+ROUTER_OP_LUT_DST_IP_FILTER_TABLE_DEPTH)*HW_LOCAL_IP_FILTER_LEN + 1, sizeof(char));
unsigned int total_len = 0;
if (rs->is_netfpga) {
int i;
COPY_STRING(buffer, total_len, HW_LOCAL_IP_FILTER_HEADER);
char line[HW_LOCAL_IP_FILTER_LEN];
bzero(line, HW_LOCAL_IP_FILTER_LEN);
char ip_str[16];
struct in_addr ip;
for (i = 0; i < ROUTER_OP_LUT_DST_IP_FILTER_TABLE_DEPTH; ++i) {
writeReg(&rs->netfpga, ROUTER_OP_LUT_DST_IP_FILTER_TABLE_RD_ADDR_REG, i);
readReg(rs->netfpga_regs, ROUTER_OP_LUT_DST_IP_FILTER_TABLE_ENTRY_IP_REG, &ip.s_addr);
ip.s_addr = htonl(ip.s_addr);
inet_ntop(AF_INET, &ip, ip_str, 16);
snprintf(line, HW_LOCAL_IP_FILTER_LEN, "%3u %15s\n", i, ip_str);
COPY_STRING(buffer, total_len, line);
}
}
*buf = buffer;
*len = total_len;
}
void http_request_header_add(const http_request_t * const request, char * name, char * value)
{
char * name_copy, * value_copy;
size_t name_length = strlen(name);
size_t value_length = strlen(value);
COPY_STRING(name_copy, name, name_length);
COPY_STRING(value_copy, value, value_length);
header_list_push(request->headers, name_copy, name_length, true, value_copy, value_length, true);
}
void sprint_hw_nat_table(router_state *rs, char **buf, unsigned int *len) {
struct in_addr ext_ip;
char ext_ip_str[16];
uint32_t ext_port;
uint32_t ext_sum;
struct in_addr int_ip;
char int_ip_str[16];
uint32_t int_port;
uint32_t int_sum;
uint32_t hits;
unsigned int i;
char *buffer = (char *)calloc(strlen(HW_NAT_COL) + 16*HW_NAT_ENTRY_TO_STRING_LEN + 1, sizeof(uint8_t));
unsigned int total_len = 0;
COPY_STRING(buffer, total_len, HW_NAT_COL);
for(i=0; i<16; i++) {
/* write the row number */
//writeReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_RD_ADDR_REG, i);
/* read the 7-tuple (e-ip, e-port, e-sum, i-ip, i-port, i-sum, hits) from hw registers */
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_INT_IP_REG, &int_ip.s_addr);
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_INT_PORT_REG, &int_port);
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_INT_CHKSUM_REG, &int_sum);
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_EXT_IP_REG, &ext_ip.s_addr);
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_EXT_PORT_REG, &ext_port);
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_EXT_CHKSUM_REG, &ext_sum);
//readReg(&(rs->netfpga), ROUTER_OP_LUT_NAT_HIT_REG, &hits);
int_ip.s_addr = htonl(int_ip.s_addr);
ext_ip.s_addr = htonl(ext_ip.s_addr);
char line[HW_NAT_ENTRY_TO_STRING_LEN];
bzero(line, HW_NAT_ENTRY_TO_STRING_LEN);
snprintf(line, HW_NAT_ENTRY_TO_STRING_LEN, "%-3i %-15s %5i 0x%04X %-15s %5i 0x%04X %7u\n",
i,
inet_ntop(AF_INET, &ext_ip, ext_ip_str, 16),
ext_port,
ext_sum,
inet_ntop(AF_INET, &int_ip, int_ip_str, 16),
int_port,
int_sum,
hits);
COPY_STRING(buffer, total_len, line);
}
*buf = buffer;
*len = total_len;
}
void sprint_hw_arp_cache(router_state *rs, char **buf, unsigned int *len) {
uint8_t mac[6];
struct in_addr gw;
bzero(&gw, sizeof(struct in_addr));
char gw_str[16];
bzero(gw_str, 16);
unsigned int mac_lo = 0;
unsigned int mac_hi = 0;
int i;
char *buffer = calloc(strlen(HW_ARP_CACHE_COL) + ROUTER_OP_LUT_ARP_TABLE_DEPTH*HW_ARP_CACHE_ENTRY_TO_STRING_LEN, sizeof(char));
unsigned int total_len = 0;
COPY_STRING(buffer, total_len, HW_ARP_CACHE_COL);
for(i=0; i < ROUTER_OP_LUT_ARP_TABLE_DEPTH; i++) {
/* write the row number */
writeReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_RD_ADDR_REG, i);
/* read the four-touple (mac hi, mac lo, gw, num of misses) */
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_HI_REG, &mac_hi);
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_ENTRY_MAC_LO_REG, &mac_lo);
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ARP_TABLE_ENTRY_NEXT_HOP_IP_REG, &gw.s_addr);
gw.s_addr = htonl(gw.s_addr);
mac[5] = (uint8_t)(mac_hi >> 8);
mac[4] = (uint8_t)mac_hi;
mac[3] = (uint8_t)(mac_lo >> 24);
mac[2] = (uint8_t)(mac_lo >> 16);
mac[1] = (uint8_t)(mac_lo >> 8);
mac[0] = (uint8_t)mac_lo;
char line[HW_ARP_CACHE_ENTRY_TO_STRING_LEN];
bzero(line, HW_ARP_CACHE_ENTRY_TO_STRING_LEN);
snprintf(line, HW_ARP_CACHE_ENTRY_TO_STRING_LEN, "%02X:%02X:%02X:%02X:%02X:%02X\t%-15s\n",
mac[5], mac[4], mac[3], mac[2], mac[1], mac[0],
inet_ntop(AF_INET, &gw, gw_str, 16) );
COPY_STRING(buffer, total_len, line);
mac_hi = 0;
mac_lo = 0;
gw.s_addr = 0;
}
*buf = buffer;
*len = total_len;
}
/** Dialogue between RADIUS and PAM modules
*
* Uses PAM's appdata_ptr so it's thread safe, and doesn't
* have any nasty static variables hanging around.
*/
static int pam_conv(int num_msg, struct pam_message const **msg, struct pam_response **resp, void *appdata_ptr)
{
int count;
struct pam_response *reply;
REQUEST *request;
rlm_pam_data_t *pam_config = (rlm_pam_data_t *) appdata_ptr;
request = pam_config->request;
/* strdup(NULL) doesn't work on some platforms */
#define COPY_STRING(s) ((s) ? strdup(s) : NULL)
reply = rad_malloc(num_msg * sizeof(struct pam_response));
memset(reply, 0, num_msg * sizeof(struct pam_response));
for (count = 0; count < num_msg; count++) {
switch (msg[count]->msg_style) {
case PAM_PROMPT_ECHO_ON:
reply[count].resp_retcode = PAM_SUCCESS;
reply[count].resp = COPY_STRING(pam_config->username);
break;
case PAM_PROMPT_ECHO_OFF:
reply[count].resp_retcode = PAM_SUCCESS;
reply[count].resp = COPY_STRING(pam_config->password);
break;
case PAM_TEXT_INFO:
RDEBUG2("%s", msg[count]->msg);
break;
case PAM_ERROR_MSG:
default:
RERROR("PAM conversation failed");
/* Must be an error of some sort... */
for (count = 0; count < num_msg; count++) {
if (msg[count]->msg_style == PAM_ERROR_MSG) RERROR("%s", msg[count]->msg);
if (reply[count].resp) {
/* could be a password, let's be sanitary */
memset(reply[count].resp, 0, strlen(reply[count].resp));
free(reply[count].resp);
}
}
free(reply);
pam_config->error = true;
return PAM_CONV_ERR;
}
}
*resp = reply;
/* PAM frees reply (including reply[].resp) */
return PAM_SUCCESS;
}
void sprint_hw_rtable(router_state *rs, char **buffer, unsigned int *len) {
struct in_addr ip;
struct in_addr mask;
struct in_addr gw;
char ip_str[16];
char mask_str[16];
char gw_str[16];
unsigned int port;
char iface[IF_LEN];
int i;
char *buf = (char *)calloc(strlen(HW_RTABLE_COL) + ROUTER_OP_LUT_ROUTE_TABLE_DEPTH*HW_RTABLE_ENTRY_TO_STRING_LEN, sizeof(uint8_t));
unsigned int total_len = 0;
COPY_STRING(buf, total_len, HW_RTABLE_COL);
for(i=0; i < ROUTER_OP_LUT_ROUTE_TABLE_DEPTH; i++) {
bzero(&ip, sizeof(struct in_addr));
bzero(&mask, sizeof(struct in_addr));
bzero(&gw, sizeof(struct in_addr));
/* write the row number */
writeReg(rs->netfpga_regs, ROUTER_OP_LUT_ROUTE_TABLE_RD_ADDR_REG, i);
/* read the four-tuple (ip, gw, mask, iface) from the hw registers */
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_IP_REG, &ip.s_addr);
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_MASK_REG, &mask.s_addr);
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_NEXT_HOP_IP_REG, &gw.s_addr);
readReg(rs->netfpga_regs, ROUTER_OP_LUT_ROUTE_TABLE_ENTRY_OUTPUT_PORT_REG, &port);
ip.s_addr = ntohl(ip.s_addr);
mask.s_addr = ntohl(mask.s_addr);
gw.s_addr = ntohl(gw.s_addr);
getIfaceFromOneHotPortNumber(iface, IF_LEN, port);
char line[HW_RTABLE_ENTRY_TO_STRING_LEN];
bzero(line, HW_RTABLE_ENTRY_TO_STRING_LEN);
snprintf(line, HW_RTABLE_ENTRY_TO_STRING_LEN, "%-5i%-20s%-20s%-20s%-20s\n",
i,
inet_ntop(AF_INET, &ip, ip_str, 16),
inet_ntop(AF_INET, &gw, gw_str, 16),
inet_ntop(AF_INET, &mask, mask_str, 16),
iface);
COPY_STRING(buf, total_len, line);
}
*buffer = buf;
*len = total_len;
}
/* NOT THREAD SAFE */
void sprint_if_list(router_state *rs, char **buf, int *len)
{
assert(rs);
assert(buf);
assert(len);
node *iface_walker = 0;
iface_entry *iface = 0;
struct in_addr ip;
struct in_addr mask;
char *buffer = 0;
int total_len = 0;
char ip_str[16];
char mask_str[16];
buffer = calloc(strlen(IFACE_COL) + IFACE_ENTRY_TO_STRING_LEN * node_length(rs->if_list), sizeof(char));
COPY_STRING(buffer, total_len, IFACE_COL);
iface_walker = rs->if_list;
while(iface_walker)
{
iface = (iface_entry *)iface_walker->data;
char if_name[IFACE_MAX_IFACE_LEN+1];
snprintf(if_name, IFACE_MAX_IFACE_LEN, "%s", iface->name);
if_name[IFACE_MAX_IFACE_LEN] = '\0';
ip.s_addr = iface->ip;
mask.s_addr = iface->mask;
char line[IFACE_ENTRY_TO_STRING_LEN];
snprintf(line, IFACE_ENTRY_TO_STRING_LEN, "%-21s %02X:%02X:%02X:%02X:%02X:%02X %-15s %-15s %-5i %-2s %-2s\n",
if_name, (unsigned char)iface->addr[0], (unsigned char)iface->addr[1], (unsigned char)iface->addr[2],
(unsigned char)iface->addr[3], (unsigned char)iface->addr[4], (unsigned char)iface->addr[5],
inet_ntop(AF_INET, &ip, ip_str, 16), inet_ntop(AF_INET, &mask, mask_str, 16), iface->speed,
(iface->is_active == 1) ? "Y" : "N",
(iface->is_wan == 1) ? "Y" : "N");
COPY_STRING(buffer, total_len, line);
iface_walker = iface_walker->next;
}
*buf = buffer;
*len = total_len;
}
/* NOT THREAD SAFE */
void sprint_arp_cache(router_state *rs, char **buf, int *len)
{
assert(rs);
assert(buf);
assert(len);
node *arp_walker = 0;
arp_cache_entry *arp_entry = 0;
time_t now;
double diff;
char *buffer = 0;
int total_len = 0;
buffer = calloc(strlen(ARP_CACHE_COL) + ARP_CACHE_ENTRY_TO_STRING_LEN * node_length(rs->arp_cache), sizeof(char));
COPY_STRING(buffer, total_len, ARP_CACHE_COL);
arp_walker = rs->arp_cache;
while(arp_walker)
{
arp_entry = (arp_cache_entry *)arp_walker->data;
char addr[INET_ADDRSTRLEN];
inet_ntop(AF_INET, &(arp_entry->ip), addr, INET_ADDRSTRLEN);
char ttl[47];
if (arp_entry->is_static == 0) {
time(&now);
diff = difftime(now, arp_entry->TTL);
snprintf(ttl, 47, "%f", rs->arp_ttl - diff);
} else {
snprintf(ttl, 47, "%s", "static");
}
char line[ARP_CACHE_ENTRY_TO_STRING_LEN];
snprintf(line, ARP_CACHE_ENTRY_TO_STRING_LEN, "%-15s %02X:%02X:%02X:%02X:%02X:%02X %-46s\n",
addr, (unsigned char)arp_entry->arp_ha[0], (unsigned char)arp_entry->arp_ha[1], (unsigned char)arp_entry->arp_ha[2],
(unsigned char)arp_entry->arp_ha[3], (unsigned char)arp_entry->arp_ha[4], (unsigned char)arp_entry->arp_ha[5],
ttl);
COPY_STRING(buffer, total_len, line);
arp_walker = arp_walker->next;
}
*buf = buffer;
*len = total_len;
}
void sprint_hw_iface(router_state *rs, char **buf, unsigned int *len) {
char *name;
unsigned int mac_lo = 0;
unsigned int mac_hi = 0;
uint8_t mac[6];
int i = 0;
char *buffer = calloc(strlen(HW_IFACE_COL) + 4*HW_IFACE_ENTRY_TO_STRING_LEN, sizeof(char));
unsigned int total_len = 0;
COPY_STRING(buffer, total_len, HW_IFACE_COL);
for(i=0; i<4; i++) {
switch(i) {
case 0: name = ETH0; break;
case 1: name = ETH1; break;
case 2: name = ETH2; break;
case 3: name = ETH3; break;
default: name = NULL; break;
}
read_hw_iface_mac(rs, i, &mac_hi, &mac_lo);
mac[5] = (uint8_t)(mac_hi >> 8);
mac[4] = (uint8_t)mac_hi;
mac[3] = (uint8_t)(mac_lo >> 24);
mac[2] = (uint8_t)(mac_lo >> 16);
mac[1] = (uint8_t)(mac_lo >> 8);
mac[0] = (uint8_t)mac_lo;
char line[HW_IFACE_ENTRY_TO_STRING_LEN];
bzero(line, HW_IFACE_ENTRY_TO_STRING_LEN);
snprintf(line, HW_IFACE_ENTRY_TO_STRING_LEN, "%-5s\t%02X:%02X:%02X:%02X:%02X:%02X\n",
name,
mac[5], mac[4], mac[3], mac[2], mac[1], mac[0]);
COPY_STRING(buffer, total_len, line);
name = NULL;
mac_hi = 0;
mac_lo = 0;
}
*buf = buffer;
*len = total_len;
}
unicorn_config* read_config_file(char *name) {
char path[2048];
char buf[1024];
unicorn_config *conf = malloc(sizeof(unicorn_config));
conf->keys = malloc(sizeof(char*) * 128);
conf->values = malloc(sizeof(char*) * 128);
conf->num_keys = 0;
sprintf(path, "%s/unicorn_%s.conf", CONFIG_PATH_PREFIX, name);
FILE *f = fopen(path, "r");
if(f) {
while(fgets(buf, 1024, f)) {
char var[1024], val[1024];
int i = 0, read_var = 1;
char *p = var;
memset(var, 0, 1024); memset(val, 0, 1024);
if(buf[0] == '#') continue;
while(i < strlen(buf)) {
if(buf[i] == '\0' || buf[i] == '\n') {
*p = '\0'; break;
} else if(read_var && buf[i] == '=') {
read_var = 0;
*p = '\0';
p = val;
i++;
continue;
}
*p = buf[i]; p++; i++;
}
if(read_var == 0 && strlen(var) > 0 && strlen(val) > 0) {
int key = conf->num_keys;
COPY_STRING(conf->keys[key], var);
COPY_STRING(conf->values[key], val);
conf->num_keys++;
}
}
fclose(f);
return conf;
} else {
printf("Can't find config file at %s.\n", path);
exit(1);
}
return NULL;
}
void sprint_nat_table(router_state *rs, char **buf, unsigned int *len) {
char ext_ip_str[16];
char int_ip_str[16];
int nat_table_size = node_length(rs->nat_table);
time_t now;
uint32_t diff = 0;
char *buffer = (char *)calloc(strlen(NAT_COL) + nat_table_size*NAT_ENTRY_TO_STR_LEN, sizeof(char));
unsigned int total_len = 0;
COPY_STRING(buffer, total_len, NAT_COL);
node *n = rs->nat_table;
while(n) {
nat_entry *ne = (nat_entry *)n->data;
char last_update[47];
bzero(last_update, 47);
time(&now);
diff = (int)difftime(now, ne->last_hits_time);
inet_ntop(AF_INET, &(ne->nat_ext.ip), ext_ip_str, 16);
inet_ntop(AF_INET, &(ne->nat_int.ip), int_ip_str, 16);
char line[NAT_ENTRY_TO_STR_LEN];
bzero(line, NAT_ENTRY_TO_STR_LEN);
snprintf(line, NAT_ENTRY_TO_STR_LEN, "%-15s %-6u %-15s %-6u %-6u %-6u %-7.2f %-12u %-3u %-1s\n",
ext_ip_str,
ntohs(ne->nat_ext.port),
int_ip_str,
ntohs(ne->nat_int.port),
ne->hits,
ne->last_hits,
ne->avg_hits_per_second,
diff,
ne->hw_row,
(ne->is_static == 1) ? "Y" : "N");
COPY_STRING(buffer, total_len, line);
n = n->next;
}
*buf = buffer;
*len = total_len;
}
static int PAM_conv (int num_msg,
const struct pam_message **msg,
struct pam_response **resp,
void *appdata_ptr) {
int count;
struct pam_response *reply;
my_PAM *pam_config = (my_PAM *) appdata_ptr;
/* strdup(NULL) doesn't work on some platforms */
#define COPY_STRING(s) ((s) ? strdup(s) : NULL)
reply = rad_malloc(num_msg * sizeof(struct pam_response));
memset(reply, 0, num_msg * sizeof(struct pam_response));
for (count = 0; count < num_msg; count++) {
switch (msg[count]->msg_style) {
case PAM_PROMPT_ECHO_ON:
reply[count].resp_retcode = PAM_SUCCESS;
reply[count].resp = COPY_STRING(pam_config->username);
break;
case PAM_PROMPT_ECHO_OFF:
reply[count].resp_retcode = PAM_SUCCESS;
reply[count].resp = COPY_STRING(pam_config->password);
break;
case PAM_TEXT_INFO:
/* ignore it... */
break;
case PAM_ERROR_MSG:
default:
/* Must be an error of some sort... */
for (count = 0; count < num_msg; count++) {
if (reply[count].resp) {
/* could be a password, let's be sanitary */
memset(reply[count].resp, 0, strlen(reply[count].resp));
free(reply[count].resp);
}
}
free(reply);
pam_config->error = 1;
return PAM_CONV_ERR;
}
}
*resp = reply;
/* PAM frees reply (including reply[].resp) */
return PAM_SUCCESS;
}
// we don't actually have to fill this data structure, but thought it might be easier
// to work with if we did when changes come about.
bool FillINFOQuery ( const mem_t* data, int data_len, A2S_INFO_t &info, mem_t **pPlayers, mem_t **pPassword ) {
if ( (data[0]!=0xFF) && (data[1]!=0xFF) && (data[2]!=0xFF) && (data[3]!=0xFF) ) return false;
int strcount=0;
mem_t* start = (mem_t *)data;
//byte type;
//byte netversion;
//char server_name[256];
//char map[256];
//char gamedir[256];
//char gamedesc[256];
//short appid;
//byte players;
//byte maxplayers;
//byte bots;
//char dedicated;
//char os;
//bool passwordset;
//bool secure;
//char version[256];
data+=4;
COPY_BYTE(info.type);
COPY_BYTE(info.netversion);
COPY_STRING(info.server_name);
COPY_STRING(info.map);
COPY_STRING(info.gamedir);
COPY_STRING(info.gamedesc);
COPY_SHORT(&info.appid);
*pPlayers = (mem_t *)data;
COPY_BYTE(info.players);
COPY_BYTE(info.maxplayers);
COPY_BYTE(info.bots);
COPY_BYTE(info.dedicated);
COPY_BYTE(info.os);
*pPassword = (mem_t *)data;
COPY_BOOL(info.passwordset);
COPY_BOOL(info.secure);
COPY_STRING(info.version);
return true;
}
/* NOT THREAD SAFE */
void sprint_rtable(router_state *rs, char **buf, int *len)
{
assert(rs);
assert(buf);
assert(len);
node *rtable_walker = 0;
rtable_entry *re = 0;
char *buffer = 0;
int total_len = 0;
char ip_str[16];
char gw_str[16];
char mask_str[16];
buffer = calloc(strlen(RTABLE_COL) + RTABLE_ENTRY_TO_STRING_LEN * node_length(rs->rtable), sizeof(char) );
COPY_STRING(buffer, total_len, RTABLE_COL);
rtable_walker = rs->rtable;
while(rtable_walker) {
re = (rtable_entry *)rtable_walker->data;
char if_name[RTABLE_MAX_IFACE_LEN+1];
snprintf(if_name, RTABLE_MAX_IFACE_LEN, "%s", re->iface);
if_name[RTABLE_MAX_IFACE_LEN] = '\0';
char line[RTABLE_ENTRY_TO_STRING_LEN];
snprintf(line, RTABLE_ENTRY_TO_STRING_LEN, "%-15s %-15s %-15s %-18s %-6s %-6s\n",
inet_ntop(AF_INET, &(re->ip), ip_str, 16), inet_ntop(AF_INET, &(re->gw), gw_str, 16),
inet_ntop(AF_INET, &(re->mask), mask_str, 16), if_name,
(re->is_static == 1) ? "Y" : "N", (re->is_active == 1) ? "Y" : "N");
rtable_walker = rtable_walker->next;
COPY_STRING(buffer, total_len, line);
}
*buf = buffer;
*len = total_len;
}
static int PAM_conv (int num_msg,
#ifdef sun
struct pam_message **msg,
#else
const struct pam_message **msg,
#endif
struct pam_response **resp,
void *appdata_ptr) {
int count = 0, replies = 0;
struct pam_response *reply = NULL;
#define PAM_RESPONSE_SIZE sizeof(struct pam_response)
size_t size = PAM_RESPONSE_SIZE;
#define COPY_STRING(s) (s) ? strdup(s) : (char*)NULL
for (count = 0; count < num_msg; count++) {
switch (msg[count]->msg_style) {
case PAM_PROMPT_ECHO_ON:
/* user name given to PAM already */
return PAM_CONV_ERR;
case PAM_PROMPT_ECHO_OFF:
/* wants password */
if (reply) {
reply = realloc(reply, size);
bzero(reply + size - PAM_RESPONSE_SIZE, PAM_RESPONSE_SIZE);
} else {
reply = (struct pam_response*)malloc(size);
bzero(reply, size);
}
if (!reply)
return PAM_CONV_ERR;
size += PAM_RESPONSE_SIZE;
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = COPY_STRING(PAM_password);
/* PAM frees resp */
break;
case PAM_TEXT_INFO:
/* ignore the informational mesage */
break;
default:
/* unknown or PAM_ERROR_MSG */
if (reply) free (reply);
return PAM_CONV_ERR;
}
}
#undef COPY_STRING
if (reply) *resp = reply;
return PAM_SUCCESS;
}
static int conversation (int num_msg,
#ifndef SOL2
const
#endif
struct pam_message **msg,
struct pam_response **resp, void *appdata_ptr)
{
int replies = 0;
struct pam_response *reply = NULL;
reply = malloc(sizeof(struct pam_response) * num_msg);
if (!reply) return PAM_CONV_ERR;
for (replies = 0; replies < num_msg; replies++) {
switch (msg[replies]->msg_style) {
case PAM_PROMPT_ECHO_ON:
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = COPY_STRING(PAM_username);
/* PAM frees resp */
break;
case PAM_PROMPT_ECHO_OFF:
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = COPY_STRING(PAM_password);
/* PAM frees resp */
break;
case PAM_TEXT_INFO:
/* fall through */
case PAM_ERROR_MSG:
/* ignore it, but pam still wants a NULL response... */
reply[replies].resp_retcode = PAM_SUCCESS;
reply[replies].resp = NULL;
break;
default:
/* Must be an error of some sort... */
free (reply);
return PAM_CONV_ERR;
}
}
*resp = reply;
return PAM_SUCCESS;
}
NMEAMessageRMB::NMEAMessageRMB(const char *message) : BaseNMEAMessage() {
char *fragments[15];
int fragmentCount = 0;
splitMessageIntoFragments(message, strlen(message), fragments, &fragmentCount);
_status = statusFromFragment(fragments[1]);
_xte = atof(fragments[2]);
_directionToSteer = lateralityFromFragment(fragments[3]);
COPY_STRING(_toWaypointID, fragments[4]);
COPY_STRING(_fromWaypointID, fragments[5]);
_destinationLatitude = degreesFromCoordinateString(fragments[6], fragments[7][0]);
_destinationLongitude = degreesFromCoordinateString(fragments[8], fragments[9][0]);
_rangeToDestiation = atof(fragments[10]);
_bearingToDestination = headingFromFragments(fragments[11], "T");
_destinationClosingVelocity = atof(fragments[12]);
_isArrived = fragments[13][0] == 'A' ? true : false;
for (int i = 0; i < fragmentCount; i++) {
free(fragments[i]);
}
}
ERetVal CFile::OpenWrite( const char* _pszFileName )
{
ERetVal eRetVal = RET_OK;
ASSERT( _pszFileName );
if (_pszFileName==NULL )
{
eRetVal = RET_ERR;
LOG(("ERR: Nombre de fichero NULL en OpenWrite"));
}
if (eRetVal==RET_OK)
{
SAFE_DELETE_ARRAY( m_pszFileName );
m_pszFileName = ALLOC_COPY_STRING( _pszFileName );
FILE* fp = fopen( m_pszFileName, "wb" );
if (!fp) // if there is an error, assumes it is because the directory is not created, and so it tries to create all the directory chain
{
char szDir[ MAX_FILENAME_SIZE ];
COPY_STRING( szDir, m_pszFileName );
char* psz = szDir;
char* pszSlash = NULL;
do
{
char* pszSlash = strchr( psz, '/' );
if (pszSlash)
{
*pszSlash = 0;
_mkdir( szDir );
*pszSlash = '/';
psz = pszSlash + 1;
}
} while (pszSlash!=0);
fp = fopen( m_pszFileName, "wb" ); // then tries to create the file again
}
if (!fp) // if still cant, then error
{
eRetVal = RET_ERR;
if (m_bLog)
LOG(("ERR: when trying to open the file (does not exist or cant be read): '%s'", m_pszFileName));
}
m_pFile = fp;
}
UpdateError( eRetVal );
return eRetVal;
}
int
pbs_python_ext_alloc_python_script(
const char *script_path,
struct python_script **py_script /* returned value */
) {
static char func_id[] = "pbs_python_ext_alloc_python_script";
#ifdef PYTHON /* --- BEGIN PYTHON BLOCK --- */
struct python_script *tmp_py_script = (struct python_script *) NULL;
size_t nbytes = sizeof(struct python_script);
struct stat sbuf;
*py_script = (struct python_script *) NULL; /* init, to be safe */
if (!(tmp_py_script = (struct python_script *) malloc(nbytes))) {
log_err(errno, func_id, "failed to malloc struct python_script");
goto ERROR_EXIT;
}
(void) memset(tmp_py_script, 0, nbytes);
/* check for recompile true by default */
tmp_py_script->check_for_recompile = 1;
COPY_STRING(tmp_py_script->path, script_path);
/* store the stat */
if ((stat(script_path, &sbuf) == -1)) {
snprintf(log_buffer, LOG_BUF_SIZE-1,
"failed to stat <%s>", script_path);
log_buffer[LOG_BUF_SIZE-1] = '\0';
log_err(errno, func_id, log_buffer);
goto ERROR_EXIT;
}
(void) memcpy(&(tmp_py_script->cur_sbuf), &sbuf,
sizeof(tmp_py_script->cur_sbuf));
/* ok, we are set with py_script */
*py_script = tmp_py_script;
return 0;
ERROR_EXIT:
if (tmp_py_script) {
pbs_python_ext_free_python_script(tmp_py_script);
free(tmp_py_script);
}
return -1;
#else
log_err(-1, func_id, "--> Python is disabled <--");
return -1;
#endif /* --- END PYTHON BLOCK --- */
}
void
tracker_add_process (tracker_t * tracker,
pid_t pid,
const char *command_line)
{
new_process_t event;
#if 0
g_print ("Add new process %s %d to tracker ", command_line, pid);
#endif
event.header = MAKE_HEADER (NEW_PROCESS, pid);
COPY_STRING (event.command_line, command_line);
tracker_append (tracker, &event, sizeof (event));
}
OPTIONS *copy_options(const OPTIONS *o)
{
OPTIONS *op = malloc(sizeof(OPTIONS));
memcpy(op, o, sizeof(OPTIONS));
#define COPY_STRING(n) if (o->n) op->n = strdup(o->n)
COPY_STRING(device);
COPY_STRING(watch_name);
COPY_STRING(run_as_user);
#ifdef UNSAFE
COPY_STRING(file);
#endif
COPY_STRING(activity_store);
COPY_STRING(race);
COPY_STRING(history_entry);
COPY_STRING(setting_spec);
COPY_STRING(post_processor);
#undef COPY_STRING
return op;
}
int find_master_input(zloop_t *loop, zmq_pollitem_t *item, void *arg) {
maneater_client *cli = (maneater_client *)arg;
zframe_t *incoming = zframe_recv(cli->local_socket);
unsigned char *data = zframe_data(incoming);
int size = zframe_size(incoming);
msgpack_unpacked msg;
size_t off;
MSG_NEXT(&msg, data, size, &off);
assert(msg.data.type == MSGPACK_OBJECT_POSITIVE_INTEGER);
uint64_t msgid = msg.data.via.u64;
int ret = 0, i = 0;
if (msgid == MID_IS_MASTER) {
MSG_NEXT(&msg, data, size, &off);
assert(msg.data.type == MSGPACK_OBJECT_RAW);
char *host;
COPY_STRING(host, msg.data.via.raw.ptr);
cli->master = host;
cli->master_socket = NULL;
for (i=0; i < cli->num_hosts; i++) {
if (!strcmp(cli->hosts[i], host)) {
cli->master_socket = cli->sockets[i];
break;
}
}
assert(cli->master_socket);
struct timeval tim;
gettimeofday(&tim, NULL);
cli->last_tick = tim.tv_sec;
zclock_log("got master: %s", host);
ret = -1;
}
zframe_destroy(&incoming);
return ret;
}
/**
* Parses the ':authority' special header
* into the host and port
*/
static void parse_authority(http_request_t * const request)
{
char * authority = http_request_header_get(request, ":authority");
request->authority = authority;
if (authority) {
char * port = strchr(authority, ':');
if (port) {
COPY_STRING(request->host, authority, port - authority);
request->port = strtoul(port + 1, NULL, 10);
} else {
request->host = strdup(authority);
request->port = 80;
}
} else {
request->host = NULL;
request->port = 0;
}
}
/**
* Parses the ':path' special header into a plain
* path and a query string
*/
static bool parse_path(http_request_t * const request)
{
char * path = http_request_header_get(request, ":path");
if (!path) {
log_append(request->log, LOG_ERROR, "No :path header provided");
return false;
}
char * query = strchr(path, '?');
if (query) {
COPY_STRING(request->path, path, query - path);
} else {
request->path = strdup(path);
}
request->query_string = query ? strdup(query + 1) : NULL;
return true;
}
void
tracker_add_map (tracker_t * tracker,
pid_t pid,
uint64_t start,
uint64_t end,
uint64_t offset,
uint64_t inode,
const char *filename)
{
new_map_t event;
event.header = MAKE_HEADER (NEW_MAP, pid);
COPY_STRING (event.filename, filename);
event.start = start;
event.end = end;
event.offset = offset;
event.inode = inode;
tracker_append (tracker, &event, sizeof (event));
}
void sprint_hw_drops(router_state *rs, char **buf, unsigned int *len) {
char *buffer = calloc(1*HW_DROPS_LEN + 1, sizeof(char));
unsigned int total_len = 0;
if (rs->is_netfpga) {
char* port_names[4] = {"eth0", "eth1", "eth2", "eth3"};
char line[HW_DROPS_LEN];
bzero(line, HW_DROPS_LEN);
snprintf(line, HW_DROPS_LEN, "%4s %10u %4s %10u %4s %10u %4s %10u\n",
port_names[0], get_rx_queue_num_pkts_dropped_full(&rs->netfpga, 0) + get_rx_queue_num_pkts_dropped_bad(&rs->netfpga, 0),
port_names[1], get_rx_queue_num_pkts_dropped_full(&rs->netfpga, 1) + get_rx_queue_num_pkts_dropped_bad(&rs->netfpga, 1),
port_names[2], get_rx_queue_num_pkts_dropped_full(&rs->netfpga, 2) + get_rx_queue_num_pkts_dropped_bad(&rs->netfpga, 2),
port_names[3], get_rx_queue_num_pkts_dropped_full(&rs->netfpga, 3) + get_rx_queue_num_pkts_dropped_bad(&rs->netfpga, 3));
COPY_STRING(buffer, total_len, line);
}
*buf = buffer;
*len = total_len;
}
void sprint_hw_stats(router_state *rs, char **buf, unsigned int *len) {
char *buffer = calloc(4*HW_STATS_LEN + 1, sizeof(char));
unsigned int total_len = 0;
char* port_names[8] = {"eth0", "eth1", "eth2", "eth3", "cpu0", "cpu1", "cpu2", "cpu3"};
lock_netfpga_stats(rs);
int i;
char line[HW_STATS_LEN];
bzero(line, HW_STATS_LEN);
for (i = 0; i < 4; ++i) {
snprintf(line, HW_STATS_LEN, "%-4s %12.2f PPS %12.2f kB/s %-4s %12.2f PPS %12.2f kB/s\n",
port_names[i], rs->stats_avg[i][0], rs->stats_avg[i][1],
port_names[i+4], rs->stats_avg[i+4][0], rs->stats_avg[i+4][1]);
COPY_STRING(buffer, total_len, line);
}
unlock_netfpga_stats(rs);
*buf = buffer;
*len = total_len;
}
NMEAMessageAPB::NMEAMessageAPB(const char *message) : BaseNMEAMessage() {
char *fragments[15];
int fragmentCount = 0;
splitMessageIntoFragments(message, strlen(message), fragments, &fragmentCount);
_isUnreliableFix = fragments[1][0] == 'V' ? true : false;
_isCycleLockWarning = fragments[2][0] == 'V' ? true : false;
_xte = atof(fragments[3]);
_directionToSteer = lateralityFromFragment(fragments[4]);
// TODO: Do XTE units ever change? If so, implement units for XTE
_isArrived = fragments[6][0] == 'A' ? true : false;
_isPerpendicularPassed = fragments[7][0] == 'A' ? true : false;
_bearingOriginToDestination = headingFromFragments(fragments[8], fragments[9]);
COPY_STRING(_destinationWaypointID, fragments[10]);
_bearingPresentToDestination = headingFromFragments(fragments[11], fragments[12]);
_headingToSteerToWaypoint = headingFromFragments(fragments[13], fragments[14]);
for (int i = 0; i < fragmentCount; i++) {
free(fragments[i]);
}
}