void calculate_channels_at(point p) {
int dir;
point p2;
if (!map_has_water(p)) {
add_channel(p, &grid(aroma1, p));
for (dir = 1; dir < STAY; dir *= 2) {
p2 = neighbor(p, dir);
// if (!map_has_water(p2)) {
add_channel(p, &grid(aroma1, p2));
// }
}
}
}
int
m_sjoin(user_t *cptr, int parc, char **parv)
{ /* :h6.wiz.cx SJOIN 1021703401 #stuff +tn :@wiz6 */
channel *channel;
time_t ts;
char *tmp;
u_short flag;
if (parc < 4 || (ts = strtol(parv[1], (char **)NULL, 10)) < 0)
return 0;
if (!(channel = find_channel(parv[2])))
channel = add_channel(parv[2], ts, 0);
if (!(tmp = strtok(parv[4], " ")))
return 0;
goto nloop;
while((tmp = strtok(NULL, " "))) {
nloop: flag = 0;
switch (*tmp) {
case '@':
flag = OP;
break;
case '+':
flag = VOICE;
break;
case '%':
flag = HALFOP;
break;
}
if (flag != 0)
tmp++;
add_user_to_channel(find_client(tmp), channel, flag);
}
return 1;
}
void join(t_client *cli, t_packet *pack)
{
char buff[LINE_SIZE];
memset(buff, 0, LINE_SIZE);
if (!pack->arg[0])
{
send_msg(cli->fd, "461 JOIN :Needs more params");
return ;
}
if (pack->arg[0][0] != '#' && pack->arg[0][0] != '&')
{
send_msg(cli->fd, CO(CO(CP(buff, "403 "), pack->arg[0]), NOCHAN));
return ;
}
add_cchannel(&cli->channel, pack->arg[0]);
if (!channel_exists(pack->arg[0]))
add_channel(pack->arg[0]);
broadcast(CO(CO(CO(CO(buff, ":"), cli->login),
JOIN), pack->arg[0]), pack->arg[0]);
CP(buff, "332 ");
CO(buff, pack->arg[0]);
CO(buff, " : ");
send_msg(cli->fd, buff);
users(cli, pack);
}
void options(canal_t *add_chan,int temp){
switch (temp) {
case 1: show_program(add_chan);
break;
case 2: add_channel(add_chan);
break;
case 3: remove_channel(add_chan);
break;
case 4: show_block_channel(add_chan);
break;
case 5: search_channel_num(add_chan);
break;
case 6: search_channel_name(add_chan);
break;
case 7: record_list(add_chan);
break;
case 8: load_list(add_chan);
break;
case 9: record_list_bin(add_chan);
break;
case 10: load_list_bin();
break;
default:
break;
}
}
void
join_channels(u_short nicknum)
{
channel *chan;
u_short i;
switch (me.servtype) {
case SERV_IRCNN:
switch (nicknum) {
case CS:
for (i = 0; me.chans[i]; i++) {
toserv(":%s JOIN %s\r\n", me.sclients[CS].nick, me.chans[i]);
hackops(me.chans[i], me.sclients[CS].nick);
}
break;
case OS:
for (i = 0; me.chans[i]; i++) {
toserv(":%s JOIN %s\r\n", me.sclients[OS].nick, me.chans[i]);
hackops(me.chans[i], me.sclients[OS].nick);
}
if (me.eob == 0) {
tell_chans("\2[EOB]\2 Receiving burst from %s", me.hub->name);
me.htmtime = time(NULL);
}
/* XXX - eskimo's lame services doesn't know what this channel is */
toserv(":%s JOIN # 1\r\n", me.sclients[OS].nick);
hackops("#", me.sclients[OS].nick);
toserv(":%s MODE # +b *!*@*\r\n", me.sclients[OS].nick);
toserv(":%s MODE # +inmsl 1\r\n", me.sclients[OS].nick);
/* XXX - reaper sux */
toserv(":%s JOIN #debug 1\r\n", me.sclients[OS].nick);
servmode("#debug", me.sclients[OS].nick);
toserv(":%s MODE #debug +b *!*@*\r\n", me.sclients[OS].nick);
toserv(":%s MODE #debug +inmsl 1\r\n", me.sclients[OS].nick);
break;
default:
return;
}
break;
case SERV_HYBRD:
/* :h6.wiz.cx SJOIN 1021703401 #stuff +tn :@wiz6 */
if (nicknum != CS && nicknum != OS)
break;
for (i = 0; me.chans[i]; i++)
if ((chan = find_channel(me.chans[i]))) {
toserv(":%s SJOIN %lu %s + :@%s\r\n", me.servname, chan->ts, me.chans[i], me.sclients[nicknum].nick);
add_user_to_channel(find_client(me.sclients[nicknum].nick), find_channel(me.chans[i]), OP);
} else {
toserv(":%s SJOIN %lu %s + :@%s\r\n", me.servname, time(NULL), me.chans[i], me.sclients[nicknum].nick);
add_user_to_channel(find_client(me.sclients[nicknum].nick), add_channel(me.chans[i], time(NULL), 0), OP);
}
break;
}
}
/*
* Add the netbeans socket to the channels.
* Return the channel index.
*/
int
channel_add_netbeans(sock_T fd)
{
int idx = add_channel();
if (idx >= 0)
{
channels[idx].ch_fd = fd;
netbeans_channel = idx;
}
return idx;
}
static void
config(module_t *module, const char *name, const char *value) {
irc_t *irc = (irc_t *)module;
if (strcmp(name, "server") == 0) {
// Prepend server with "#" in case we want SSL
int len = strlen(value)+1;
char *server = malloc(len+1);
if (server) {
server[0] = '#';
strncpy(server+1, value, len);
}
irc->server = server+1;
} else if (strcmp(name, "ssl") == 0) {
if (strcmp(value, "yes") == 0) {
irc->ssl = 1;
} else if (strcmp(value, "no") == 0) {
irc->ssl = 0;
} else {
fprintf(stderr, "SSL option '%s' should be yes or no)\n", value);
}
} else if (strcmp(name, "ipv6") == 0) {
if (strcmp(value, "yes") == 0) {
irc->ipv6 = 1;
} else if (strcmp(value, "no") == 0) {
irc->ipv6 = 0;
} else {
fprintf(stderr, "IPv6 option '%s' should be yes or no)\n", value);
}
} else if (strcmp(name, "port") == 0) {
irc->port = atoi(value);
} else if (strcmp(name, "password") == 0) {
irc->password = strdup(value);
} else if (strcmp(name, "nick") == 0) {
irc->nick = strdup(value);
irc->current_nick = strdup(value);
irc->module.name = irc->current_nick;
} else if (strcmp(name, "username") == 0) {
irc->username = strdup(value);
} else if (strcmp(name, "realname") == 0) {
irc->realname = strdup(value);
} else if (strcmp(name, "channel") == 0) {
add_channel(irc, value);
}
}
static int add_channels(device_cfg_t *cfg, driver_t *driver, device_t *device)
{
int i;
int rec;
if (cfg->channel_num <= 0 || cfg->channel_num > sizeof(cfg->rec))
return -1;
for (i = cfg->channel_num; i > 0; i--) {
rec = (cfg->rec[i-1] == '1' ? 1 : 0);
add_channel(cfg, i, rec, driver, device);
}
return 0;
}
static void print_out(char *channel, char *buf) {
static char outfile[256], server[256], buft[18];
FILE *out = NULL;
time_t t = time(0);
if(channel) snprintf(server, sizeof(server), "-!- %s", channel);
if(strstr(buf, server)) channel="";
create_filepath(outfile, sizeof(outfile), channel, "out");
if(!(out = fopen(outfile, "a"))) return;
if(channel && channel[0]) add_channel(channel);
strftime(buft, sizeof(buft), "%F %R", localtime(&t));
fprintf(out, "%s %s\n", buft, buf);
fclose(out);
}
int
m_join(user_t *cptr, int parc, char **parv)
{
channel *chan;
char *ptr;
if (!cptr || IsServer(cptr) || !parv[1] || !(ptr = strtok(parv[1], ",")))
return 0;
goto loopy;
while ((ptr = strtok(NULL, ","))) {
loopy: if (ptr[0] != '#')
continue;
if (!(chan = find_channel(ptr)))
chan = add_channel(ptr, 0, 0);
add_user_to_channel(cptr, chan, 0);
}
return 1;
}
void hCREATE(struct user *from, char *channels, time_t *ts) {
int i;
struct manyargs chlist;
struct channel *c;
VERIFY_USER(from);
split(&chlist, channels, ',');
for (i = 0; i < chlist.c; i++) {
c = get_channel_by_name(chlist.v[i]);
if (c) {
logfmt(LOG_WARNING, "CREATE for existing channel: %s. Deleting.", chlist.v[i]);
del_channel(c);
}
c = add_channel(chlist.v[i], *ts);
chanusers_join(from, c);
channel_plsprefix(c, from, 'o');
}
}
int main(int argc, char *argv[]) {
int i;
unsigned short port = SERVER_PORT;
struct passwd *spw = getpwuid(getuid());
char *key = NULL, *fullname = NULL;
char prefix[_POSIX_PATH_MAX];
if(!spw) {
fputs("ii: getpwuid() failed\n", stderr);
exit(EXIT_FAILURE);
}
snprintf(nick, sizeof(nick), "%s", spw->pw_name);
snprintf(prefix, sizeof(prefix),"%s/irc", spw->pw_dir);
if (argc <= 1 || (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h')) usage();
for(i = 1; (i + 1 < argc) && (argv[i][0] == '-'); i++) {
switch (argv[i][1]) {
case 'i': snprintf(prefix,sizeof(prefix),"%s", argv[++i]); break;
case 's': host = argv[++i]; break;
case 'p': port = strtol(argv[++i], NULL, 10); break;
case 'n': snprintf(nick,sizeof(nick),"%s", argv[++i]); break;
case 'k': key = getenv(argv[++i]); break;
case 'e': use_ssl = 1; ++i; break;
case 'f': fullname = argv[++i]; break;
default: usage(); break;
}
}
if(use_ssl)
port = port == SERVER_PORT ? SSL_SERVER_PORT : port;
irc = tcpopen(port);
if(!snprintf(path, sizeof(path), "%s/%s", prefix, host)) {
fputs("ii: path to irc directory too long\n", stderr);
exit(EXIT_FAILURE);
}
create_dirtree(path);
add_channel(""); /* master channel */
login(key, fullname);
run();
return EXIT_SUCCESS;
}
void parse_msg(char tokens[MAX_MSG_TOKENS][MAX_MSG_LEN+1],
int length, char *sendbuf, int fd)
{
// app_error("Not Implemented");
// int i = ERR_UNKNOWNCOMMAND;
if(!strcmp(tokens[0],"ADDUSER"))
{
add_user(fd, tokens[1], sendbuf);
} else
if(!strcmp(tokens[0],"ADDCHAN"))
{
add_channel(fd, tokens[1], sendbuf);
} else
if(!strcmp(tokens[0],"REMOVEUSER"))
{
remove_user(fd, tokens[1], sendbuf);
} else
if(!strcmp(tokens[0],"REMOVECHAN"))
{
remove_channel(fd, tokens[1], sendbuf);
} else
if(!strcmp(tokens[0],"NEXTHOP"))
{
next_hop(fd, tokens[1], sendbuf);
} else
if(!strcmp(tokens[0],"NEXTHOPS"))
{
next_hops(fd, atol(tokens[1]), tokens[2], sendbuf);
} else
if(!strcmp(tokens[0],"USERTABLE"))
{
user_table(fd, sendbuf);
} else
if(!strcmp(tokens[0],"CHANTABLE"))
{
channel_table(fd, sendbuf);
} else {
}
return;
}
uint8_t LoRaPHY::request_new_channel(int8_t channel_id, channel_params_t *new_channel)
{
if (!phy_params.custom_channelplans_supported) {
return 0;
}
uint8_t status = 0x03;
if (new_channel->frequency == 0) {
// Remove
if (remove_channel(channel_id) == false) {
status &= 0xFC;
}
} else {
new_channel->band = lookup_band_for_frequency(new_channel->frequency);
switch (add_channel(new_channel, channel_id)) {
case LORAWAN_STATUS_OK: {
break;
}
case LORAWAN_STATUS_FREQUENCY_INVALID: {
status &= 0xFE;
break;
}
case LORAWAN_STATUS_DATARATE_INVALID: {
status &= 0xFD;
break;
}
case LORAWAN_STATUS_FREQ_AND_DR_INVALID: {
status &= 0xFC;
break;
}
default: {
status &= 0xFC;
break;
}
}
}
return status;
}
void ft_join(char *buff, t_client *client, t_server *server)
{
int i;
char **tmp;
(void)server;
tmp = ft_strsplit(buff, ' ');
i = 0;
while (i < MAX_CHANNEL)
{
if (client->channel[i] && tmp[1])
{
if (ft_strcmp(client->channel[i], tmp[1]) == 0)
{
write_to_client(client->sock,
"/join => channel already joined !");
return ;
}
}
i++;
}
add_channel(tmp[1], client);
}
static void
event_numeric(irc_session_t *session, unsigned int event, const char *origin,
const char **params, unsigned int count) {
switch(event) {
case 464:
fprintf(stderr, "[%s] Bad password\n", origin);
break;
case LIBIRC_RFC_RPL_MOTD:
/*
if (count > 1) {
printf("[%s] MOTD: %s\n", origin, params[1]);
}
*/
case LIBIRC_RFC_RPL_MOTDSTART:
case LIBIRC_RFC_RPL_ENDOFMOTD:
break;
case LIBIRC_RFC_RPL_NAMREPLY:
if (count < 4) break;
irc_t *irc = get_module(session);
//printf("[%s] NAMREPLY (%u): ", origin, count);
//print_array(params, count);
//nick, thingy, channel, member member2...
const char *channel_name = params[2];
const char *members = params[3];
char members_copy[256];
channel_t *channel = get_channel(irc, channel_name);
if (!channel) {
// maybe the server joined us to a channel
channel = add_channel(irc, channel_name);
}
strncpy(members_copy, members, sizeof(members_copy));
printf("[%s] Members of %s: %s\n", origin, channel_name, members);
// Add each nick to the list
// ignore nick prefixes
static const char *delimeters = " +@";
for (const char *nick = strtok(members_copy, delimeters);
nick;
nick = strtok(NULL, delimeters)) {
// Don't add outself
if (strcasecmp(nick, irc->current_nick)) {
channel_add_nick(channel, nick);
}
}
case LIBIRC_RFC_RPL_ENDOFNAMES:
break;
case LIBIRC_RFC_ERR_BANNEDFROMCHAN:
case LIBIRC_RFC_ERR_INVITEONLYCHAN:
case LIBIRC_RFC_ERR_BADCHANNELKEY:
case LIBIRC_RFC_ERR_CHANNELISFULL:
case LIBIRC_RFC_ERR_BADCHANMASK:
case LIBIRC_RFC_ERR_NOSUCHCHANNEL:
case LIBIRC_RFC_ERR_TOOMANYCHANNELS:
fprintf(stderr, "Unable to join channel: %s\n",
irc_strerror(irc_errno(session)));
break;
default:
if (debug) {
printf("[%s] %u: ", origin, event);
print_array(params, count);
}
}
}
void silc_command_reply(SilcClient client, SilcClientConnection conn, SilcCommand command, SilcStatus status, SilcStatus error, va_list ap) {
// "infrastructure"
struct t_gui_buffer *channelbuffer, *serverbuffer;
SilcConnectionContext ctx = conn->context;
//SilcPluginChannelList channel;
struct SilcChannelContext *chanCtx;
// possible args
char *str, *topic, *cipher, *hmac;
SilcChannelEntry channel_entry;
SilcUInt32 mode, userlimit;
SilcHashTableList *userlist;
SilcPublicKey key;
SilcDList pubkeys;
size_t strsize;
// needed for the nicklist
SilcClientEntry user_client;
SilcChannelUser user;
struct t_gui_nick *nick = NULL;
switch (command) {
case SILC_COMMAND_JOIN:
str = va_arg(ap, char *);
channel_entry = va_arg(ap, SilcChannelEntry);
mode = va_arg(ap, SilcUInt32);
userlist = va_arg(ap, SilcHashTableList *);
topic = va_arg(ap, char *);
cipher = va_arg(ap, char *);
hmac = va_arg(ap, char *);
key = va_arg(ap, SilcPublicKey);
pubkeys = va_arg(ap, SilcDList);
userlimit = va_arg(ap, SilcUInt32);
chanCtx = malloc(sizeof(struct SilcChannelContext));
chanCtx->channel_name = str;
chanCtx->channel_entry = channel_entry;
chanCtx->connection = conn;
strsize = strlen(channel_entry->channel_name) + strlen(channel_entry->server) + 1;
str = malloc(strsize+1);
snprintf(str, strsize, "%s.%s", channel_entry->channel_name, channel_entry->server);
// create a regular chat buffer and set some senible values
channelbuffer = weechat_buffer_new(str, &silc_plugin_channel_input, chanCtx, NULL, NULL);
weechat_buffer_set(channelbuffer, "name", str);
weechat_buffer_set(channelbuffer, "short_name", channel_entry->channel_name);
weechat_buffer_set(channelbuffer, "title", topic);
weechat_buffer_set(channelbuffer, "hotlist", WEECHAT_HOTLIST_LOW);
weechat_buffer_set(channelbuffer, "nicklist", "1");
chanCtx->channel_buffer = channelbuffer;
channel_entry->context = channelbuffer;
serverbuffer = ctx->server_buffer;
add_channel(channel_entry->channel_name, find_server_for_buffer(serverbuffer), channel_entry, NULL, channelbuffer);
// fill the nicklist with users currently on the channel
while (silc_hash_table_get(userlist, (void **)&user_client, (void **)&user)) {
nick = silc_nicklist_add(user);
}
break;
default:
weechat_log_printf("unhandled command reply for %d", command);
break;
}
}
static int load_config(void)
{
FILE *f;
char buf[1024];
char *val;
char *val2;
int lineno=0;
int x;
f = fopen(config, "r");
if (!f) {
fprintf(stderr, "Unable to open config file '%s': %s\n", config, strerror(errno));
return -1;
}
while(!feof(f)) {
fgets(buf, sizeof(buf), f);
if (!feof(f)) {
lineno++;
val = strchr(buf, '#');
if (val) *val = '\0';
while(strlen(buf) && (buf[strlen(buf) - 1] < 33))
buf[strlen(buf) - 1] = '\0';
if (!strlen(buf))
continue;
val = buf;
while(*val) {
if (*val < 33)
break;
val++;
}
if (*val) {
*val = '\0';
val++;
while(*val && (*val < 33)) val++;
}
if (!strcasecmp(buf, "host")) {
if (val && strlen(val))
strncpy(host, val, sizeof(host) - 1);
else
fprintf(stderr, "host needs an argument (the host) at line %d\n", lineno);
} else if (!strcasecmp(buf, "user")) {
if (val && strlen(val))
strncpy(user, val, sizeof(user) - 1);
else
fprintf(stderr, "user needs an argument (the user) at line %d\n", lineno);
} else if (!strcasecmp(buf, "pass")) {
if (val && strlen(val))
strncpy(pass, val, sizeof(pass) - 1);
else
fprintf(stderr, "pass needs an argument (the password) at line %d\n", lineno);
} else if (!strcasecmp(buf, "smoothfade")) {
smoothfade = 1;
} else if (!strcasecmp(buf, "mutelevel")) {
if (val && (sscanf(val, "%d", &x) == 1) && (x > -1) && (x < 101)) {
mutelevel = x;
} else
fprintf(stderr, "mutelevel must be a number from 0 (most muted) to 100 (no mute) at line %d\n", lineno);
} else if (!strcasecmp(buf, "channel")) {
if (val && strlen(val)) {
val2 = strchr(val, '/');
if (val2) {
*val2 = '\0';
val2++;
add_channel(val, val2);
} else
fprintf(stderr, "channel needs to be of the format Tech/Location at line %d\n", lineno);
} else
fprintf(stderr, "channel needs an argument (the channel) at line %d\n", lineno);
} else {
fprintf(stderr, "ignoring unknown keyword '%s'\n", buf);
}
}
}
fclose(f);
if (!strlen(host))
fprintf(stderr, "no 'host' specification in config file\n");
else if (!strlen(user))
fprintf(stderr, "no 'user' specification in config file\n");
else if (!channels)
fprintf(stderr, "no 'channel' specifications in config file\n");
else
return 0;
return -1;
}
axa_json_res_t
axa_body_to_json(axa_emsg_t *emsg, nmsg_input_t nmsg_input, axa_p_hdr_t *hdr, axa_p_body_t *body, size_t body_len, char **out)
{
struct axa_strbuf *sb = NULL, *sb_tmp = NULL;
axa_json_res_t res;
yajl_gen g = NULL;
int yajl_rc;
char op_str[AXA_P_OP_STRLEN];
char addr_str[INET6_ADDRSTRLEN];
axa_p_direction_t dir;
uint8_t *p, *q;
uint16_t user_objs_cnt, an_objs_cnt;
_axa_p_stats_sys_t *sys;
char time_buf[30];
struct tm *tm_info;
time_t t;
runits_t ru;
_axa_p_stats_user_t *user_obj;
_axa_p_stats_user_rad_an_t *an_obj;
switch(AXA_P2H16(hdr->op)) {
case AXA_P_OP_MISSED_RAD:
case AXA_P_OP_AHIT:
case AXA_P_OP_ALIST:
dir = AXA_P_FROM_RAD;
break;
case AXA_P_OP_USER:
case AXA_P_OP_JOIN:
case AXA_P_OP_PAUSE:
case AXA_P_OP_GO:
case AXA_P_OP_WATCH:
case AXA_P_OP_WGET:
case AXA_P_OP_STOP:
case AXA_P_OP_ALL_STOP:
case AXA_P_OP_CHANNEL:
case AXA_P_OP_CGET:
case AXA_P_OP_ACCT:
case _AXA_P_OP_KILL_REQ:
case _AXA_P_OP_STATS_REQ:
dir = AXA_P_TO_SRA;
break;
case AXA_P_OP_ANOM:
case AXA_P_OP_AGET:
case AXA_P_OP_RADU:
dir = AXA_P_TO_RAD;
break;
default:
dir = AXA_P_FROM_SRA;
break;
} /* switch */
if (axa_ck_hdr(emsg, hdr, "json", dir) == false)
return (AXA_JSON_RES_FAILURE);
if (AXA_P2H32(hdr->len) - sizeof(axa_p_hdr_t) != body_len) {
axa_pemsg(emsg, "body length mismatch %zu != %zu",
AXA_P2H32(hdr->len) - sizeof(axa_p_hdr_t),
body_len);
return (AXA_JSON_RES_FAILURE);
}
if (axa_ck_body(emsg, hdr->op, body, body_len) == false)
return (AXA_JSON_RES_FAILURE);
sb = axa_strbuf_init();
if (sb == NULL) {
axa_pemsg(emsg, "could not allocate axa_strbuf");
return (AXA_JSON_RES_MEMFAIL);
}
sb_tmp = axa_strbuf_init();
if (sb_tmp == NULL) {
axa_pemsg(emsg, "could not allocate axa_strbuf");
axa_strbuf_destroy(&sb);
res = AXA_JSON_RES_MEMFAIL;
goto err;
}
g = yajl_gen_alloc(NULL);
AXA_ASSERT (g != NULL);
yajl_rc = yajl_gen_config(g,
yajl_gen_print_callback,
_callback_print_yajl_axa_strbuf,
sb);
AXA_ASSERT(yajl_rc != 0);
add_yajl_map(g);
add_yajl_string(g, "tag");
if (AXA_P2H16(hdr->tag) == AXA_TAG_NONE)
add_yajl_string(g, "*");
else
add_yajl_integer(g, AXA_P2H16(hdr->tag));
add_yajl_string(g, "op");
axa_op_to_str(op_str, sizeof(op_str), hdr->op);
add_yajl_string(g, op_str);
switch ((axa_p_op_t)hdr->op) {
case AXA_P_OP_NOP:
break;
case AXA_P_OP_HELLO:
add_yajl_string(g, "id");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->hello.id));
add_yajl_string(g, "pvers_min");
add_yajl_integer(g, body->hello.pvers_min);
add_yajl_string(g, "pvers_max");
add_yajl_integer(g, body->hello.pvers_max);
add_yajl_string(g, "str");
add_yajl_string(g, body->hello.str);
break;
case AXA_P_OP_OK:
case AXA_P_OP_ERROR:
add_yajl_string(g, "orig_op");
axa_op_to_str(op_str, sizeof(op_str), body->result.orig_op);
add_yajl_string(g, op_str);
add_yajl_string(g, "str");
add_yajl_string(g, body->result.str);
break;
case AXA_P_OP_MISSED:
add_yajl_string(g, "missed");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.missed));
add_yajl_string(g, "dropped");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.dropped));
add_yajl_string(g, "rlimit");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.rlimit));
add_yajl_string(g, "filtered");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed.filtered));
add_yajl_string(g, "last_report");
add_yajl_integer(g, AXA_P2H32(body->missed.last_report));
break;
case AXA_P_OP_MISSED_RAD:
add_yajl_string(g, "sra_missed");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_missed));
add_yajl_string(g, "sra_dropped");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_dropped));
add_yajl_string(g, "sra_rlimit");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_rlimit));
add_yajl_string(g, "sra_filtered");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.sra_filtered));
add_yajl_string(g, "dropped");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.dropped));
add_yajl_string(g, "rlimit");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.rlimit));
add_yajl_string(g, "filtered");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->missed_rad.filtered));
add_yajl_string(g, "last_report");
add_yajl_integer(g, AXA_P2H32(body->missed_rad.last_report));
break;
case AXA_P_OP_WHIT:
res = add_whit(emsg, g, sb, nmsg_input, &(body->whit), body_len);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
break;
case AXA_P_OP_WATCH:
add_watch(g, &(body->watch), body_len);
break;
case AXA_P_OP_ANOM: {
bool print_parms;
print_parms = body_len > offsetof(axa_p_anom_t, parms) && body->anom.parms[0] != '\0';
add_anom(g, body->anom, print_parms);
break;
}
case AXA_P_OP_CHANNEL:
res = add_channel(emsg, g, body->channel.ch);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
add_yajl_string(g, "on");
add_yajl_bool(g, body->channel.on != 0);
break;
case AXA_P_OP_WLIST:
add_yajl_string(g, "cur_tag");
add_yajl_integer(g, AXA_P2H16(body->wlist.cur_tag));
add_watch(g, &(body->wlist.w), body_len - offsetof(axa_p_wlist_t, w));
break;
case AXA_P_OP_AHIT:
add_yajl_string(g, "an");
add_yajl_string(g, body->ahit.an.c);
res = add_whit(emsg, g, sb, nmsg_input, &(body->ahit.whit), body_len - offsetof(axa_p_ahit_t, whit));
if (res != AXA_JSON_RES_SUCCESS)
goto err;
break;
case AXA_P_OP_ALIST: {
bool print_parms;
add_yajl_string(g, "cur_tag");
add_yajl_integer(g, AXA_P2H16(body->alist.cur_tag));
print_parms = body_len > offsetof(axa_p_alist_t, anom) + offsetof(axa_p_anom_t, parms) && body->alist.anom.parms[0] != '\0';
add_anom(g, body->alist.anom, print_parms);
break;
}
case AXA_P_OP_CLIST:
res = add_channel(emsg, g, body->clist.ch);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
add_yajl_string(g, "on");
add_yajl_bool(g, body->clist.on != 0);
add_yajl_string(g, "spec");
add_yajl_string(g, body->clist.spec.c);
break;
case AXA_P_OP_USER:
add_yajl_string(g, "name");
add_yajl_string(g, body->user.name);
break;
case AXA_P_OP_OPT: {
char buf[AXA_P_OP_STRLEN];
add_yajl_string(g, "type");
add_yajl_string(g, axa_opt_to_str(buf, sizeof(buf), AXA_P2H64(body->opt.type)));
switch((axa_p_opt_type_t)body->opt.type) {
case AXA_P_OPT_TRACE: {
add_yajl_string(g, "trace");
if (AXA_P2H64(body->opt.u.trace) != AXA_P_OPT_TRACE_REQ) {
add_yajl_number(g, sb_tmp, AXA_P2H64(body->opt.u.trace));
} else {
add_yajl_string(g, "REQUEST TRACE VALUE");
}
break;
}
case AXA_P_OPT_RLIMIT:
add_yajl_string(g, "max_pkts_per_sec");
res = add_rlimit_count(emsg, g, body->opt.u.rlimit.max_pkts_per_sec);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
add_yajl_string(g, "cur_pkts_per_sec");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->opt.u.rlimit.cur_pkts_per_sec));
add_yajl_string(g, "report_secs");
res = add_rlimit_count(emsg, g, body->opt.u.rlimit.report_secs);
if (res != AXA_JSON_RES_SUCCESS)
goto err;
break;
case AXA_P_OPT_SAMPLE:
add_yajl_string(g, "sample");
if (AXA_P2H64(body->opt.u.sample) == 0) {
add_yajl_string(g, "requested");
} else {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "%0.6f", ((double)AXA_P2H64(body->opt.u.sample)) / AXA_P_OPT_SAMPLE_MAX);
add_yajl_number_sb(g, sb_tmp);
}
break;
case AXA_P_OPT_SNDBUF:
add_yajl_string(g, "bufsize");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->opt.u.bufsize));
break;
} /* switch */
break;
}
case AXA_P_OP_JOIN:
add_yajl_string(g, "id");
add_yajl_number(g, sb_tmp, AXA_P2H64(body->join.id));
break;
case _AXA_P_OP_STATS_REQ:
if (body->stats_req.version != _AXA_STATS_VERSION_ONE) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "version");
add_yajl_integer(g, body->stats_req.version);
add_yajl_string(g, "type");
switch (body->stats_req.type) {
case AXA_P_STATS_M_M_SUM:
add_yajl_string(g, "summary");
break;
case AXA_P_STATS_M_M_ALL:
add_yajl_string(g, "all");
break;
case AXA_P_STATS_M_M_SN:
add_yajl_string(g, "serial number");
break;
case AXA_P_STATS_M_M_U:
add_yajl_string(g, "user name");
break;
default:
add_yajl_string(g, "unknown");
}
if (body->stats_req.type == AXA_P_STATS_M_M_SN) {
add_yajl_string(g, "serial number");
add_yajl_integer(g, body->stats_req.sn);
}
if (body->stats_req.type == AXA_P_STATS_M_M_U) {
add_yajl_string(g, "user name");
add_yajl_string(g, body->stats_req.user.name);
}
break;
case _AXA_P_OP_STATS_RSP:
if (body->stats_rsp.version != _AXA_STATS_VERSION_ONE) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "version");
add_yajl_integer(g, body->stats_rsp.version);
if (body->stats_rsp.sys_objs_cnt > 1) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "result");
switch (body->stats_rsp.result) {
case AXA_P_STATS_R_SUCCESS:
add_yajl_string(g, "success");
break;
case AXA_P_STATS_R_FAIL_NF:
add_yajl_string(g, "failed: user not found");
break;
case AXA_P_STATS_R_FAIL_UNK:
default:
add_yajl_string(g, "failed: unknown reason");
}
if (body->stats_rsp.sys_objs_cnt == 1) {
p = (uint8_t *)&body->stats_rsp;
sys = (_axa_p_stats_sys_t *)(p +
sizeof (_axa_p_stats_rsp_t));
if (sys->type != _AXA_P_STATS_TYPE_SYS) {
res = AXA_JSON_RES_FAILURE;
goto err;
}
add_yajl_string(g, "load");
add_yajl_array(g);
add_yajl_integer(g, AXA_P2H32(sys->load[0]));
add_yajl_integer(g, AXA_P2H32(sys->load[1]));
add_yajl_integer(g, AXA_P2H32(sys->load[2]));
close_yajl_array(g);
add_yajl_string(g, "cpu_usage");
add_yajl_integer(g, AXA_P2H32(sys->cpu_usage));
add_yajl_string(g, "uptime");
add_yajl_integer(g, AXA_P2H32(sys->uptime));
add_yajl_string(g, "starttime");
add_yajl_integer(g, AXA_P2H32(sys->starttime));
add_yajl_string(g, "vmsize");
add_yajl_number(g, sb_tmp, AXA_P2H64(sys->vmsize));
add_yajl_string(g, "vmrss");
add_yajl_number(g, sb_tmp, AXA_P2H64(sys->vmrss));
add_yajl_string(g, "thread_cnt");
add_yajl_integer(g, AXA_P2H32(sys->thread_cnt));
add_yajl_string(g, "user_cnt");
add_yajl_integer(g, AXA_P2H32(sys->user_cnt));
switch (sys->server_type) {
case _AXA_STATS_SRVR_TYPE_SRA:
add_yajl_string(g, "server_type");
add_yajl_string(g, "sra");
add_yajl_string(g, "fd_sockets");
add_yajl_integer(g,
AXA_P2H32(sys->fd_sockets));
add_yajl_string(g, "fd_pipes");
add_yajl_integer(g,
AXA_P2H32(sys->fd_pipes));
add_yajl_string(g, "fd_anon_inodes");
add_yajl_integer(g,
AXA_P2H32(sys->fd_anon_inodes));
add_yajl_string(g, "fd_other");
add_yajl_integer(g,
AXA_P2H32(sys->fd_other));
add_yajl_string(g, "rchar");
add_yajl_number(g, sb_tmp,
AXA_P2H64(sys->rchar));
add_yajl_string(g, "wchar");
add_yajl_number(g, sb_tmp,
AXA_P2H64(sys->wchar));
add_yajl_string(g,
"sra_ipv4_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.ipv4_cnt));
add_yajl_string(g,
"sra_ipv6_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.ipv6_cnt));
add_yajl_string(g,
"sra_dns_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.dns_cnt));
add_yajl_string(g,
"sra_ch_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.ch_cnt));
add_yajl_string(g,
"sra_err_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.sra.watches.err_cnt));
add_yajl_string(g, "sra_channels");
add_yajl_array(g);
for (int j = 0; j <= AXA_NMSG_CH_MAX; j++) {
if (axa_get_bitwords(sys->srvr.sra.ch_mask.m, j)) {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "ch%d", (j));
add_yajl_string(g, (const char*)sb_tmp->data);
}
}
close_yajl_array(g);
break;
case _AXA_STATS_SRVR_TYPE_RAD:
add_yajl_string(g, "server_type");
add_yajl_string(g, "rad");
add_yajl_string(g, "rad_anomaly_cnt");
add_yajl_integer(g,
AXA_P2H32(sys->srvr.rad.an_cnt));
break;
default:
res = AXA_JSON_RES_FAILURE;
goto err;
}
}
user_objs_cnt = body->stats_rsp.user_objs_cnt;
p = (uint8_t *)&body->stats_rsp +
sizeof (_axa_p_stats_rsp_t) +
body->stats_rsp.sys_objs_cnt *
sizeof (_axa_p_stats_sys_t);
if (user_objs_cnt > 0) {
add_yajl_string(g, "users");
add_yajl_array(g);
user_obj = (_axa_p_stats_user_t *)p;
for (; user_objs_cnt; user_objs_cnt--, user_obj++) {
add_yajl_string(g, "user_obj");
add_yajl_map(g);
add_yajl_string(g, "server_type");
switch (user_obj->server_type) {
case _AXA_STATS_SRVR_TYPE_SRA:
add_yajl_string(g, "sra");
break;
case _AXA_STATS_SRVR_TYPE_RAD:
add_yajl_string(g, "rad");
break;
default:
add_yajl_string(g,
"unkwn");
break;
}
add_yajl_string(g, "user");
add_yajl_string(g, user_obj->user.name);
add_yajl_string(g, "is_admin");
add_yajl_bool(g, user_obj->is_admin == 1 ?
true : false);
add_yajl_string(g, "io_type");
switch (user_obj->io_type) {
case AXA_IO_TYPE_UNIX:
add_yajl_string(g,
AXA_IO_TYPE_UNIX_STR);
break;
case AXA_IO_TYPE_TCP:
add_yajl_string(g,
AXA_IO_TYPE_TCP_STR);
break;
case AXA_IO_TYPE_SSH:
add_yajl_string(g,
AXA_IO_TYPE_SSH_STR);
break;
case AXA_IO_TYPE_TLS:
add_yajl_string(g,
AXA_IO_TYPE_TLS_STR);
break;
case AXA_IO_TYPE_APIKEY:
add_yajl_string(g,
AXA_IO_TYPE_APIKEY_STR);
break;
case AXA_IO_TYPE_UNKN:
default:
add_yajl_string(g, "unknown");
break;
}
add_yajl_string(g, "address");
switch (user_obj->addr_type) {
case AXA_AF_INET:
inet_ntop(AF_INET, &user_obj->ip.ipv4,
addr_str, sizeof(addr_str));
break;
case AXA_AF_INET6:
inet_ntop(AF_INET6, &user_obj->ip.ipv6,
addr_str, sizeof(addr_str));
break;
case AXA_AF_UNKNOWN:
strlcpy(addr_str, "unknown",
sizeof(addr_str));
break;
}
add_yajl_string(g, addr_str);
add_yajl_string(g, "sn");
add_yajl_integer(g, user_obj->sn);
add_yajl_string(g, "connected_since");
t = AXA_P2H32(user_obj->connected_since.tv_sec);
tm_info = gmtime(&t);
strftime(time_buf, sizeof (time_buf),
"%Y-%m-%dT%H:%M:%SZ",
tm_info);
add_yajl_string(g, time_buf);
add_yajl_string(g, "ratelimit");
if (AXA_P2H64(user_obj->ratelimit) == AXA_RLIMIT_OFF) {
add_yajl_integer(g, 0);
}
else {
add_yajl_integer(g,
AXA_P2H64(user_obj->ratelimit));
}
add_yajl_string(g, "sample");
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "%0.2f",
((double)AXA_P2H64(user_obj->sample)));
add_yajl_number_sb(g, sb_tmp);
add_yajl_string(g, "last_count_update");
t = AXA_P2H32(user_obj->last_cnt_update.tv_sec);
tm_info = gmtime(&t);
strftime(time_buf, sizeof (time_buf),
"%Y-%m-%dT%H:%M:%SZ",
tm_info);
add_yajl_string(g, time_buf);
add_yajl_string(g, "filtered");
add_yajl_integer(g, user_obj->filtered);
add_yajl_string(g, "missed");
add_yajl_integer(g, user_obj->missed);
add_yajl_string(g, "collected");
add_yajl_integer(g, user_obj->collected);
add_yajl_string(g, "sent");
add_yajl_integer(g, user_obj->sent);
add_yajl_string(g, "rlimit");
add_yajl_integer(g, user_obj->rlimit);
add_yajl_string(g, "congested");
add_yajl_integer(g, user_obj->congested);
switch (user_obj->server_type) {
case _AXA_STATS_SRVR_TYPE_SRA:
add_yajl_string(g,
"ipv4_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.ipv4_cnt));
add_yajl_string(g,
"ipv6_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.ipv6_cnt));
add_yajl_string(g,
"dns_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.dns_cnt));
add_yajl_string(g,
"ch_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.ch_cnt));
add_yajl_string(g,
"err_watch_cnt");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.sra.watches.err_cnt));
add_yajl_string(g, "channels");
add_yajl_array(g);
for (int j = 0; j <= AXA_NMSG_CH_MAX; j++) {
if (axa_get_bitwords(user_obj->srvr.sra.ch_mask.m, j)) {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "ch%d", (j));
add_yajl_string(g, (const char*)sb_tmp->data);
}
}
close_yajl_array(g);
break;
case _AXA_STATS_SRVR_TYPE_RAD:
add_yajl_string(g, "anomaly_count_in_flight");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.rad.an_obj_cnt));
add_yajl_string(g, "anomaly_count_total");
add_yajl_integer(g,
AXA_P2H32(user_obj->srvr.rad.an_obj_cnt_total));
an_objs_cnt = user_obj->srvr.rad.an_obj_cnt;
q = (uint8_t *)&body->stats_rsp +
sizeof (_axa_p_stats_rsp_t) +
body->stats_rsp.sys_objs_cnt *
sizeof (_axa_p_stats_sys_t) +
sizeof (_axa_p_stats_user_t);
if (an_objs_cnt > 0) {
add_yajl_string(g,
"anomalies");
add_yajl_array(g);
an_obj = (_axa_p_stats_user_rad_an_t *)q;
for ( ; an_objs_cnt; an_objs_cnt--, an_obj++) {
add_yajl_string(g, "an_obj");
add_yajl_map(g);
add_yajl_string(g, "name");
add_yajl_string(g,
an_obj->name);
add_yajl_string(g, "options");
add_yajl_string(g,
an_obj->opt);
add_yajl_string(g,
"ru_original");
ru = AXA_P2H32(an_obj->ru_original);
if (ru == INT_MAX)
add_yajl_string(g,
"unlimited");
else
add_yajl_integer(g,
AXA_P2H32(an_obj->ru_original));
add_yajl_string(g,
"ru_current");
ru = AXA_P2H32(an_obj->ru_current);
if (ru == INT_MAX)
add_yajl_string(g,
"unlimited");
else
add_yajl_integer(g,
AXA_P2H32(an_obj->ru_current));
add_yajl_string(g, "ru_cost");
add_yajl_integer(g,
AXA_P2H32(an_obj->ru_cost));
add_yajl_string(g,
"channels");
add_yajl_array(g);
for (int j = 0; j <= AXA_NMSG_CH_MAX; j++) {
if (axa_get_bitwords(an_obj->ch_mask.m, j)) {
axa_strbuf_reset(sb_tmp);
axa_strbuf_append(sb_tmp, "ch%d", (j));
add_yajl_string(g, (const char*)sb_tmp->data);
}
}
close_yajl_array(g);
close_yajl_map(g);
}
close_yajl_array(g);
}
break;
default:
res = AXA_JSON_RES_FAILURE;
goto err;
} /* switch (user_obj->server_type) */
close_yajl_map(g);
} /* for (; user_objs_cnt; user_objs_cnt--, ... */
close_yajl_array(g);
} /* if (user_objs_cnt > 0) */
break;
case _AXA_P_OP_KILL_REQ:
case _AXA_P_OP_KILL_RSP:
add_yajl_string(g, "mode");
add_yajl_integer(g, body->kill.mode);
add_yajl_string(g, "user");
add_yajl_string(g, body->kill.user.name);
add_yajl_string(g, "sn");
add_yajl_integer(g, AXA_P2H32(body->kill.sn));
add_yajl_string(g, "result");
add_yajl_integer(g, body->kill.result);
break;
case AXA_P_OP_PAUSE:
case AXA_P_OP_GO:
case AXA_P_OP_WGET:
case AXA_P_OP_AGET:
case AXA_P_OP_STOP:
case AXA_P_OP_ALL_STOP:
case AXA_P_OP_CGET:
case AXA_P_OP_ACCT:
case AXA_P_OP_RADU:
break;
case AXA_P_OP_MGMT_GETRSP:
case AXA_P_OP_MGMT_GET:
add_yajl_string(g, "mgmt is deprecated; please upgrade and use \"stats\"");
break;
} /* switch */
close_yajl_map(g);
yajl_gen_reset(g, "");
yajl_gen_free(g);
*out = sb->data;
free(sb);
axa_strbuf_destroy(&sb_tmp);
return (AXA_JSON_RES_SUCCESS);
err:
if (g != NULL)
yajl_gen_free(g);
axa_strbuf_destroy(&sb);
axa_strbuf_destroy(&sb_tmp);
return (res);
}
static axa_json_res_t
add_whit(axa_emsg_t *emsg, yajl_gen g, struct axa_strbuf *yajl_sb, nmsg_input_t nmsg_input, axa_p_whit_t *whit, size_t whit_len)
{
axa_json_res_t json_res;
json_res = add_channel(emsg, g, whit->hdr.ch);
if (json_res != AXA_JSON_RES_SUCCESS)
return (json_res);
switch (whit->hdr.type) {
case AXA_P_WHIT_NMSG: {
struct axa_strbuf *sb;
nmsg_message_t msg;
axa_w2n_res_t wres;
nmsg_res nres;
const char *vname, *mname;
char *nmsg_json = NULL;
struct tm tm;
time_t t;
char when[32];
if (whit_len < sizeof(axa_p_whit_nmsg_t)) {
axa_pemsg(emsg, "whit_len %zu < %zu", whit_len, sizeof(axa_p_whit_nmsg_t));
return (AXA_JSON_RES_FAILURE);
}
wres = axa_whit2nmsg(emsg, nmsg_input, &msg, whit, whit_len);
if (wres != AXA_W2N_RES_SUCCESS) {
return (AXA_JSON_RES_FAILURE);
}
sb = axa_strbuf_init();
if (sb == NULL) {
axa_pemsg(emsg, "could not allocate axa_strbuf");
return (AXA_JSON_RES_MEMFAIL);
}
if(AXA_P2H_IDX(whit->nmsg.hdr.field_idx) < AXA_NMSG_IDX_RSVD) {
const char *field_name;
nres = nmsg_message_get_field_name(msg, whit->nmsg.hdr.field_idx, &field_name);
if (nres == nmsg_res_success) {
add_yajl_string(g, "field");
add_yajl_string(g, field_name);
} else {
add_yajl_string(g, "field_idx");
add_yajl_integer(g, AXA_P2H_IDX(whit->nmsg.hdr.field_idx));
}
}
if (AXA_P2H_IDX(whit->nmsg.hdr.val_idx) < AXA_NMSG_IDX_RSVD) {
add_yajl_string(g, "val_idx");
add_yajl_integer(g, AXA_P2H_IDX(whit->nmsg.hdr.val_idx));
}
vname = nmsg_msgmod_vid_to_vname(AXA_P2H_IDX(whit->nmsg.hdr.vid));
if (vname != NULL) {
add_yajl_string(g, "vname");
add_yajl_string(g, vname);
} else {
add_yajl_string(g, "vid");
add_yajl_integer(g, AXA_P2H_IDX(whit->nmsg.hdr.vid));
}
mname = nmsg_msgmod_msgtype_to_mname(
AXA_P2H16(whit->nmsg.hdr.vid),
AXA_P2H16(whit->nmsg.hdr.type));
if (mname != NULL) {
add_yajl_string(g, "mname");
add_yajl_string(g, mname);
} else {
add_yajl_string(g, "msgtype");
add_yajl_integer(g, AXA_P2H_IDX(whit->nmsg.hdr.type));
}
add_yajl_string(g, "time");
t = AXA_P2H32(whit->nmsg.hdr.ts.tv_sec);
gmtime_r(&t, &tm);
strftime(when, sizeof(when), "%Y-%m-%d %T", &tm);
axa_strbuf_reset(sb);
axa_strbuf_append(sb, "%s.%09u", when,
AXA_P2H32(whit->nmsg.hdr.ts.tv_nsec));
add_yajl_string(g, sb->data);
nres = nmsg_message_to_json(msg, &nmsg_json);
if (nres == nmsg_res_success) {
add_yajl_string(g, "nmsg");
add_yajl_integer(g, 0);
yajl_gen_clear(g);
axa_strbuf_clip(yajl_sb, axa_strbuf_len(yajl_sb)-1);
axa_strbuf_append(yajl_sb, "%s", nmsg_json);
free(nmsg_json);
}
axa_strbuf_destroy(&sb);
nmsg_message_destroy(&msg);
return (AXA_JSON_RES_SUCCESS);
}
case AXA_P_WHIT_IP: {
struct axa_strbuf *sb;
struct nmsg_ipdg dg;
nmsg_res res;
struct tm tm;
time_t t;
char when[32];
if (whit_len < sizeof(axa_p_whit_ip_t)) {
axa_pemsg(emsg, "whit_len %zu < %zu",
whit_len, sizeof(axa_p_whit_ip_t));
return (AXA_JSON_RES_FAILURE);
}
add_yajl_string(g, "time");
t = AXA_P2H32(whit->ip.hdr.tv.tv_sec);
gmtime_r(&t, &tm);
strftime(when, sizeof(when), "%Y-%m-%d %T", &tm);
sb = axa_strbuf_init();
if (sb == NULL) {
axa_pemsg(emsg, "could not allocate axa_strbuf");
return (AXA_JSON_RES_MEMFAIL);
}
axa_strbuf_append(sb, "%s.%06u", when,
AXA_P2H32(whit->ip.hdr.tv.tv_usec));
add_yajl_string(g, sb->data);
axa_strbuf_destroy(&sb);
res = nmsg_ipdg_parse_pcap_raw(&dg, DLT_RAW, whit->ip.b, whit_len - offsetof(axa_p_whit_ip_t, b));
if (res != nmsg_res_success || dg.len_network == 0) {
add_yajl_string(g, "parse_error");
add_yajl_bool(g, true);
return (AXA_JSON_RES_SUCCESS);
}
add_yajl_string(g, "af");
switch(dg.proto_network) {
case AF_INET: {
struct ip *ip_hdr;
char addr_str[INET_ADDRSTRLEN];
add_yajl_string(g, "IPv4");
if (dg.network != NULL && dg.len_network >= sizeof(ip_hdr)) {
ip_hdr = (void*)dg.network;
add_yajl_string(g, "src");
add_yajl_string(g, inet_ntop(AF_INET, &ip_hdr->ip_src, addr_str, sizeof(addr_str)));
add_yajl_string(g, "dst");
add_yajl_string(g, inet_ntop(AF_INET, &ip_hdr->ip_dst, addr_str, sizeof(addr_str)));
add_yajl_string(g, "ttl");
add_yajl_integer(g, ip_hdr->ip_ttl);
}
break;
}
case AF_INET6: {
struct ip6_hdr *ip6_hdr;
char addr_str[INET6_ADDRSTRLEN];
add_yajl_string(g, "IPv6");
if (dg.network != NULL && dg.len_network >= sizeof(ip6_hdr)) {
ip6_hdr = (void*)dg.network;
add_yajl_string(g, "src");
add_yajl_string(g, inet_ntop(AF_INET6, &ip6_hdr->ip6_src, addr_str, sizeof(addr_str)));
add_yajl_string(g, "dst");
add_yajl_string(g, inet_ntop(AF_INET6, &ip6_hdr->ip6_dst, addr_str, sizeof(addr_str)));
add_yajl_string(g, "ttl");
add_yajl_integer(g, ip6_hdr->ip6_hlim);
}
break;
}
default:
add_yajl_integer(g, dg.proto_network);
return (AXA_JSON_RES_SUCCESS);
} /* switch */
add_yajl_string(g, "proto");
switch(dg.proto_transport) {
case IPPROTO_ICMP:
add_yajl_string(g, "ICMP");
break;
case IPPROTO_ICMPV6:
add_yajl_string(g, "ICMPv6");
break;
case IPPROTO_TCP:
add_yajl_string(g, "TCP");
if (dg.transport != NULL && dg.len_transport >= sizeof(struct tcphdr)) {
struct tcphdr *tcp_hdr = (void*)dg.transport;
add_yajl_string(g, "src_port");
add_yajl_integer(g, ntohs(tcp_hdr->th_sport));
add_yajl_string(g, "dst_port");
add_yajl_integer(g, ntohs(tcp_hdr->th_dport));
add_yajl_string(g, "flags");
add_yajl_array(g);
if ((tcp_hdr->th_flags & TH_FIN) != 0)
add_yajl_string(g, "FIN");
if ((tcp_hdr->th_flags & TH_SYN) != 0)
add_yajl_string(g, "SYN");
if ((tcp_hdr->th_flags & TH_ACK) != 0)
add_yajl_string(g, "ACK");
if ((tcp_hdr->th_flags & TH_RST) != 0)
add_yajl_string(g, "RST");
close_yajl_array(g);
}
break;
case IPPROTO_UDP:
add_yajl_string(g, "UDP");
if (dg.transport != NULL && dg.len_transport >= sizeof(struct udphdr)) {
struct udphdr *udp_hdr = (void*)dg.transport;
add_yajl_string(g, "src_port");
add_yajl_integer(g, ntohs(udp_hdr->uh_sport));
add_yajl_string(g, "dst_port");
add_yajl_integer(g, ntohs(udp_hdr->uh_dport));
}
break;
default:
add_yajl_integer(g, dg.proto_transport);
break;
} /* switch */
if (dg.payload != NULL) {
base64_encodestate b64;
char *b64_str;
size_t b64_str_len;
base64_init_encodestate(&b64);
b64_str = alloca(2 * dg.len_payload + 1);
AXA_ASSERT(b64_str != NULL);
b64_str_len = base64_encode_block((void*)dg.payload,
dg.len_payload, b64_str, &b64);
b64_str_len += base64_encode_blockend(b64_str + b64_str_len, &b64);
add_yajl_string(g, "payload");
add_yajl_string_len(g, b64_str, b64_str_len);
}
return (AXA_JSON_RES_SUCCESS);
}
default:
axa_pemsg(emsg, "unknown whit hdr type: %d", whit->hdr.type);
return (AXA_JSON_RES_FAILURE);
}
}
int load_config(const char *file)
{
char *description = NULL, *server_host = NULL, *username = NULL, *password = NULL, *nickname = NULL, *user_complete_name = NULL;
int server_index = -1;
int linenr = 0;
int fd = open(file, O_RDONLY);
if (fd == -1)
{
if (errno == ENOENT)
return -1;
error_exit(TRUE, "Cannot open config file %s\n", file);
}
conf_file = strdup(file);
for(;;)
{
char *line = read_line_fd(fd);
char *cmd, *par;
char *is;
if (!line)
break;
linenr++;
if (strlen(line) == 0)
{
myfree(line);
continue;
}
if (line[0] == '#' || line[0] == ';')
{
myfree(line);
continue;
}
is = strchr(line, '=');
if (!is)
error_exit(FALSE, "config: line %d is missing either command or parameter! (%s)", linenr, line);
/* find parameter */
par = is + 1;
while(*par == ' ')
par++;
/* remove spaces around command */
/* spaces at the start */
cmd = line;
while(*cmd == ' ')
cmd++;
/* spaces at the end */
*is = 0x00;
is--;
while(*is == ' ')
{
*is = 0x00;
is--;
}
if (strcmp(cmd, "server") == 0 || strcmp(cmd, "send_after_login") == 0 || strcmp(cmd, "auto_join") == 0 || strcmp(cmd, "channel") == 0 || strcmp(cmd, "rejoin") == 0)
{
/* all stuff already known? */
if (server_host)
{
if (nickname == NULL)
error_exit(FALSE, "nickname must be set for %s", server_host);
server_index = add_server(server_host, username, password, nickname, user_complete_name, description ? description : server_host);
myfree(server_host);
server_host = NULL;
myfree(username);
myfree(password);
myfree(nickname);
myfree(user_complete_name);
myfree(description);
username = password = nickname = user_complete_name = description = NULL;
}
}
if (strcmp(cmd, "server") == 0)
{
/* new server */
server_host = strdup(par);
}
else if (strcmp(cmd, "favorite") == 0)
{
int n = -1;
string_array_t parts;
init_string_array(&parts);
split_string(par, " ", TRUE, &parts);
n = string_array_get_n(&parts);
if (n != 1 && n != 2)
error_exit(FALSE, "favorite needs either be in format \"server channel\" or \"channel\"");
if (n == 2)
add_favorite(string_array_get(&parts, 0), string_array_get(&parts, 1));
else
add_favorite(NULL, string_array_get(&parts, 0));
free_splitted_string(&parts);
}
else if (strcmp(cmd, "username") == 0)
username = strdup(par);
else if (strcmp(cmd, "password") == 0)
password = strdup(par);
else if (strcmp(cmd, "nick") == 0 || strcmp(cmd, "nickname") == 0)
nickname = strdup(par);
else if (strcmp(cmd, "name") == 0)
user_complete_name = strdup(par);
else if (strcmp(cmd, "dictionary_file") == 0)
{
const char *filename = explode_path(par);
if (!filename)
error_exit(TRUE, "Path '%s' is not understood\n", par);
dictionary_file = filename;
if (load_dictionary() == FALSE)
error_exit(TRUE, "Failure loading dictionary file %s (%s)", filename, par);
}
else if (strcmp(cmd, "description") == 0)
description = strdup(par);
else if (strcmp(cmd, "server_exit_message") == 0)
server_exit_message = strdup(par);
else if (strcmp(cmd, "log_dir") == 0)
log_dir = strdup(par);
else if (strcmp(cmd, "part_message") == 0)
part_message = strdup(par);
else if (strcmp(cmd, "notify_nick") == 0)
notify_nick = strdup(par);
else if (strcmp(cmd, "userinfo") == 0)
userinfo = strdup(par);
else if (strcmp(cmd, "finger_str") == 0)
finger_str = strdup(par);
else if (strcmp(cmd, "mark_personal_messages") == 0)
mark_personal_messages = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "meta-colors") == 0)
colors_meta = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "headline_matcher") == 0)
add_headline_matcher(par);
else if (strcmp(cmd, "all-colors") == 0)
colors_all = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "dcc_bind_to") == 0)
dcc_bind_to = strdup(par);
else if (strcmp(cmd, "update_clock_at_data") == 0)
update_clock_at_data = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "nick-color") == 0)
nick_color = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "use_nonbasic_colors") == 0)
use_nonbasic_colors = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "ignore_unknown_irc_protocol_msgs") == 0)
ignore_unknown_irc_protocol_msgs = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "auto_markerline") == 0)
auto_markerline = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "inverse_window_heading") == 0)
inverse_window_heading = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "keep_channels_sorted") == 0)
keep_channels_sorted = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "allow_invite") == 0)
allow_invite = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_headlines") == 0)
show_headlines = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "remember_channels") == 0)
remember_channels = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "allow_userinfo") == 0)
allow_userinfo = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "extra_highlights") == 0)
add_to_string_array(&extra_highlights, par);
else if (strcmp(cmd, "only_one_markerline") == 0)
only_one_markerline = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "auto_rejoin") == 0)
auto_rejoin = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "ignore_mouse") == 0)
ignore_mouse = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "irc_keepalive") == 0)
irc_keepalive = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "space_after_start_marker") == 0)
space_after_start_marker = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "jumpy_navigation") == 0)
jumpy_navigation = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "mark_meta") == 0)
mark_meta = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "user_column") == 0)
user_column = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "full_user") == 0)
full_user = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "grep_filter") == 0)
add_filter(gp, par, linenr);
else if (strcmp(cmd, "headline_filter") == 0)
add_filter(hlgp, par, linenr);
else if (strcmp(cmd, "show_parts") == 0)
show_parts = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_mode_changes") == 0)
show_mode_changes = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_nick_change") == 0)
show_nick_change = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "show_joins") == 0)
show_joins = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "store_config_on_exit") == 0)
store_config_on_exit = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "partial_highlight_match") == 0)
partial_highlight_match = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "topic_scroll") == 0)
topic_scroll = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "notice_in_serverchannel") == 0)
notice_in_server_channel = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "highlight") == 0)
highlight = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "fuzzy_highlight") == 0)
fuzzy_highlight = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "theme") == 0)
{
struct stat status;
const char *filename = explode_path(par);
if (!filename)
error_exit(TRUE, "Path '%s' is not understood\n", par);
if (stat(filename, &status) == -1) /* file doesn't exist, look for it under SYSCONFDIR */
{
int len = strlen(SYSCONFDIR) + strlen(par) + 2;
char *theme_path = malloc(len * sizeof(char));
snprintf(theme_path, len, "%s/%s", SYSCONFDIR, par);
load_theme(theme_path);
theme_file = theme_path;
}
else
{
load_theme(filename);
theme_file = strdup(par);
}
myfree(filename);
}
else if (strcmp(cmd, "ignore_file") == 0)
{
struct stat status;
const char *filename = explode_path(par);
if (!filename)
error_exit(TRUE, "Path '%s' is not understood\n", par);
if (load_ignore_list(par) == TRUE)
{
}
else if (load_ignore_list(filename) == TRUE)
{
}
else if (stat(filename, &status) == -1) /* file doesn't exist, look elsewhere */
{
int len = strlen(SYSCONFDIR) + strlen(par) + 2;
char *ignore_file = malloc(len * sizeof(char));
/* look for it under SYSCONFDIR */
snprintf(ignore_file, len, "%s/%s", SYSCONFDIR, par);
/* look for it under ~/.firc location */
if (stat(ignore_file, &status) == -1)
snprintf(ignore_file, len, "%s/%s", dirname(conf_file), par);
load_ignore_list(ignore_file);
myfree(ignore_file);
}
myfree(filename);
}
else if (strcmp(cmd, "send_after_login") == 0)
{
server *ps = &server_list[server_index];
if (server_index == -1)
error_exit(FALSE, "send_after_login: you need to define a server first\n");
add_to_string_array(&ps -> send_after_login, par);
}
else if (strcmp(cmd, "auto_join") == 0 || strcmp(cmd, "channel") == 0)
{
if (server_index == -1)
error_exit(FALSE, "auto_join: you need to define a server first\n");
add_autojoin(server_index, par);
}
else if (strcmp(cmd, "rejoin") == 0)
{
add_channel(server_index, par);
if (keep_channels_sorted)
sort_channels(server_index);
}
else if (strcmp(cmd, "auto_private_channel") == 0)
auto_private_channel = parse_false_true(par, cmd, linenr);
else if (strcmp(cmd, "dcc_path") == 0)
dcc_path = strdup(par);
else if (strcmp(cmd, "default_colorpair") == 0)
default_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "markerline_colorpair") == 0)
markerline_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "highlight_colorpair") == 0)
highlight_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "meta_colorpair") == 0)
meta_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "error_colorpair") == 0)
error_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "temp_colorpair") == 0)
temp_colorpair = parse_color_spec(par, linenr, cmd);
else if (strcmp(cmd, "check_for_mail") == 0)
check_for_mail = atoi(par);
else if (strcmp(cmd, "user_column_width") == 0)
user_column_width = atoi(par);
else if (strcmp(cmd, "delay_before_reconnect") == 0)
delay_before_reconnect = atoi(par);
else if (strcmp(cmd, "word_cloud_n") == 0)
word_cloud_n = atoi(par);
else if (strcmp(cmd, "word_cloud_refresh") == 0)
{
word_cloud_refresh = atoi(par);
word_cloud_last_refresh = time(NULL);
}
else if (strcmp(cmd, "word_cloud_win_height") == 0)
word_cloud_win_height = atoi(par);
else if (strcmp(cmd, "max_channel_record_lines") == 0)
max_channel_record_lines = atoi(par);
else if (strcmp(cmd, "word_cloud_min_word_size") == 0)
word_cloud_min_word_size = atoi(par);
else
{
error_exit(FALSE, "'%s=%s' is not understood\n", cmd, par);
}
myfree(line);
}
close(fd);
if (server_host)
{
if (nickname == NULL)
error_exit(FALSE, "nickname must be set for %s", server_host);
add_server(server_host, username, password, nickname, user_complete_name, description);
myfree(server_host);
myfree(username);
myfree(password);
myfree(nickname);
myfree(user_complete_name);
myfree(description);
}
return 0;
}
int main(int argc, char **argv)
{
int o;
char *name = "Master";
char *iname = "Capture";
int showinput = 0;
bindtextdomain("tray_mixer", LOCALE_DIR);
textdomain("tray_mixer");
while ((o = getopt(argc, argv, "e:Ii:")) >= 0) {
switch (o) {
case 'e':
name = optarg;
break;
case 'i':
iname = optarg;
/* fall through */
case 'I':
showinput = 1;
break;
}
}
gtk_init(&argc, &argv);
mixer_init(name, iname);
icon = gtk_status_icon_new_from_file(ICON_PATH "speaker.png");
g_signal_connect(G_OBJECT(icon), "activate", G_CALLBACK(click), NULL);
item = gtk_menu_item_new_with_label(_("Quit"));
menu = gtk_menu_new();
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_signal_connect(G_OBJECT(icon), "popup-menu", G_CALLBACK(popup), NULL);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(quit), NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_window_set_skip_taskbar_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_skip_pager_hint(GTK_WINDOW(window), TRUE);
gtk_window_set_type_hint(GTK_WINDOW(window),
GDK_WINDOW_TYPE_HINT_DIALOG);
gtk_window_set_default_size(GTK_WINDOW(window), 60, 140);
hbox = gtk_hbox_new(TRUE, 5);
gtk_container_add(GTK_CONTAINER(window), hbox);
add_channel(&ch[0]);
if (showinput)
add_channel(&ch[1]);
gtk_status_icon_set_visible(GTK_STATUS_ICON(icon), TRUE);
gtk_main();
return 0;
}
static void proc_channels_input(Channel *c, char *buf) {
/* static char infile[256]; */
char *p = NULL;
if(buf[0] != '/' && buf[0] != 0) {
proc_channels_privmsg(c->name, buf);
return;
}
message[0] = '\0';
if(buf[2] == ' ' || buf[2] == '\0') switch (buf[1]) {
case 'j':
p = strchr(&buf[3], ' ');
if(p) *p = 0;
if((buf[3]=='#')||(buf[3]=='&')||(buf[3]=='+')||(buf[3]=='!')){
if(p) snprintf(message, PIPE_BUF, "JOIN %s %s\r\n", &buf[3], p + 1); /* password protected channel */
else snprintf(message, PIPE_BUF, "JOIN %s\r\n", &buf[3]);
add_channel(&buf[3]);
}
else if(p){
add_channel(&buf[3]);
proc_channels_privmsg(&buf[3], p + 1);
return;
}
break;
case 't':
if(strlen(buf)>=3) snprintf(message, PIPE_BUF, "TOPIC %s :%s\r\n", c->name, &buf[3]);
break;
case 'a':
if(strlen(buf)>=3){
snprintf(message, PIPE_BUF, "-!- %s is away \"%s\"", nick, &buf[3]);
print_out(c->name, message);
}
if(buf[2] == 0 || strlen(buf)<3) /* or used to make else part safe */
snprintf(message, PIPE_BUF, "AWAY\r\n");
else
snprintf(message, PIPE_BUF, "AWAY :%s\r\n", &buf[3]);
break;
case 'n':
if(strlen(buf)>=3){
snprintf(nick, sizeof(nick),"%s", &buf[3]);
snprintf(message, PIPE_BUF, "NICK %s\r\n", &buf[3]);
}
break;
case 'l':
if(c->name[0] == 0)
return;
if(buf[2] == ' ' && strlen(buf)>=3)
snprintf(message, PIPE_BUF, "PART %s :%s\r\n", c->name, &buf[3]);
else
snprintf(message, PIPE_BUF,
"PART %s :ii - 500 SLOC are too much\r\n", c->name);
WRITE(irc, message, strlen(message));
close(c->fd);
/*create_filepath(infile, sizeof(infile), c->name, "in");
unlink(infile); */
rm_channel(c);
return;
break;
default:
snprintf(message, PIPE_BUF, "%s\r\n", &buf[1]);
break;
}
else
snprintf(message, PIPE_BUF, "%s\r\n", &buf[1]);
if (message[0] != '\0')
WRITE(irc, message, strlen(message));
}
/**
* Callback for org.bluez.HealthDevice.ChannelConnected signal
* Reused by CreateChannel callback (channel initiation)
*/
static void channel_connected(DBusGProxy *proxy, const char *path, gpointer user_data)
{
int fd;
guint64 handle;
device_object *dev;
const char *device_path;
channel_object *c = get_channel(path);
if (c) {
if (c->initiated_by_us && c->fd >= 0) {
DEBUG("initiated channel already connected: %s", path);
return;
}
}
DEBUG("channel connected: %s", path);
// Need to use non-GLib code here because GLib still does not have
// the UNIX FD type.
DBusMessage *msg, *reply;
DBusError err;
msg = dbus_message_new_method_call("org.bluez", path,
"org.bluez.HealthChannel", "Acquire");
if (!msg) {
ERROR(" network:dbus Can't allocate new method call");
return;
}
dbus_error_init(&err);
reply = dbus_connection_send_with_reply_and_block(
dbus_g_connection_get_connection(conn),
msg, -1, &err);
dbus_message_unref(msg);
if (!reply) {
DEBUG(" network:dbus Can't acquire FD");
if (dbus_error_is_set(&err)) {
ERROR("%s", err.message);
dbus_error_free(&err);
return;
}
}
if (!dbus_message_get_args(reply, &err,
DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_INVALID)) {
DEBUG(" network:dbus Can't get reply arguments");
if (dbus_error_is_set(&err)) {
ERROR("%s", err.message);
dbus_error_free(&err);
dbus_message_unref(reply);
return;
}
}
dbus_message_unref(reply);
// dbus_connection_flush(dbus_g_connection_get_connection(conn));
DEBUG("File descriptor: %d", fd);
device_path = dbus_g_proxy_get_path(proxy);
handle = add_channel(path, device_path, fd, user_data != NULL);
if (!handle) {
// channel already known, reconnected
// or channel is secondary
return;
}
dev = get_device_object(device_path);
if (dev) {
device_connected(handle, dev->addr);
} else {
ERROR("Channel from unknown device: %s", device_path);
device_connected(handle, device_path);
}
}
static void p_channel(char *from, char **ArgList)
{
char *channel;
char *user, *host;
struct channel *chan = NULL;
struct whowas_list *whowas = NULL;
int its_me = 0;
if (!strcmp(ArgList[0], "0")) {
fake();
return;
}
channel = ArgList[0];
message_from(channel, LOG_CRAP);
malloc_strcpy(&joined_nick, from);
if (!my_stricmp(from, get_server_nickname(from_server))) {
int refnum;
Window *old_window = curr_scr_win;
int switched = 0;
if (!in_join_list(channel, from_server))
add_to_join_list(channel, from_server, curr_scr_win->refnum);
else {
if (curr_scr_win->refnum != (refnum = get_win_from_join_list(channel, from_server))) {
switched = 1;
set_current_window(get_window_by_refnum(refnum));
}
}
if (*channel != '+')
send_to_server(SERVER(from_server), "MODE %s\r\nMODE %s b", channel, channel, channel);
(void) do_hook(JOIN_ME_LIST, "%s", channel);
its_me = 1;
chan = add_channel(channel, from_server);
if (*channel == '+') {
got_info(channel, from_server, GOTBANS);
got_info(channel, from_server, GOTMODE);
}
if (switched)
set_current_window(old_window);
} else {
int op = 0, vo = 0;
char *c;
/*
* Workaround for gratuitous protocol change in ef2.9
*/
if ((c = strchr(channel, '\007'))) {
for (*c++ = 0; *c; c++) {
if (*c == 'o')
op = 1;
else if (*c == 'v')
vo = 1;
}
}
chan = add_to_channel(channel, from, from_server, op, vo, FromUserHost, NULL, NULL);
}
flush_mode_all(chan);
user = m_strdup(FromUserHost);
host = strchr(user, '@');
*host++ = '\0';
if (check_ignore(from, FromUserHost, channel, IGNORE_JOINS | IGNORE_CRAP, NULL) != IGNORED && chan) {
irc_server *irc_serv = NULL;
char *tmp2 = NULL;
if (get_int_var(AUTO_NSLOOKUP_VAR) && isdigit(*(host + strlen(host) - 1)))
tmp2 = do_nslookup(host);
message_from(channel, LOG_CRAP);
if ((whowas = check_whosplitin_buffer(from, FromUserHost, channel, 0)) && (irc_serv = check_split_server(whowas->server1))) {
if (do_hook(LLOOK_JOIN_LIST, "%s %s", irc_serv->name, irc_serv->link))
put_it("%s",
convert_output_format(get_format(FORMAT_NETJOIN_FSET), "%s %s %s %d", update_clock(GET_TIME), irc_serv->name,
irc_serv->link, 0));
remove_split_server(whowas->server1);
}
if (do_hook(JOIN_LIST, "%s %s %s", from, channel, tmp2 ? tmp2 : FromUserHost ? FromUserHost : "UnKnown")) {
put_it("%s",
convert_output_format(get_format(FORMAT_JOIN_FSET), "%s %s %s %s", update_clock(GET_TIME), from,
tmp2 ? tmp2 : FromUserHost ? FromUserHost : "UnKnown", channel));
}
message_from(NULL, LOG_CRAP);
}
set_input_prompt(curr_scr_win, get_string_var(INPUT_PROMPT_VAR), 0);
update_all_status(curr_scr_win, NULL, 0);
notify_mark(from, user, host, 1);
new_free(&user);
}
void hBURST(struct server *from, char *chan, time_t *ts, struct manyargs *rest) {
struct manyargs list;
struct channel *c;
struct user *u;
char *tmp, *burstmode = "";
int nextpos, i;
VERIFY_SERVER(from);
if (from->protocol[0] == 'P') {
logtxt(LOG_ERROR, "BURST after END_OF_BURST!");
return;
}
c = get_channel_by_name(chan);
if (!c)
c = add_channel(chan, *ts);
if (!rest->c)
return;
/* handle modes if present */
nextpos = 0;
tmp = rest->v[nextpos];
if (tmp && tmp[0] == '+')
nextpos = 1 + channel_apply_mode((struct entity *)from, c, rest->v[0], rest, 1);
/* rest->v[nextpos] is now the next parameter after the modes */
/* check the last parameter for leading % */
tmp = rest->v[nextpos];
if (rest->c - 1 > nextpos)
tmp = rest->v[rest->c - 1];
if (tmp && tmp[0] == '%') {
split(&list, rest->v[rest->c - 1] + 1, ' ');
for (i = 0; i < list.c; i++)
channel_plsban(c, NULL, list.v[i]);
rest->c--;
}
/* no channel users */
if (!tmp)
return;
assert(nextpos+1 == rest->c);
split(&list, rest->v[nextpos], ',');
/* all that's left from rest->v[i .. rest->c] are user entries with tmps */
for (i = 0; i < list.c; i++) {
tmp = list.v[i];
if ((tmp = strchr(tmp, ':'))) {
*tmp++ = '\0';
burstmode = tmp;
}
u = get_user_by_numericstr(list.v[i]);
if (!u) {
logtxt(LOG_WARNING, "Burst join for non-existant user.");
continue;
}
chanusers_join(u, c);
channel_burstmode(c, u, burstmode);
}
}
int main(int argc, char* argv[])
{
if(argc != 6)
{
printf("Enter the required Parameters.\n");
printf("<Npmr> <Nc> <Chanel Slices> <simulation duration> <zipf parameter>\n");
return 2;
}
FILE *fp = fopen("file.txt","w");
if(fp == NULL)
{
printf("Error in opening file. Exiting...\n");
exit(1);
}
//Time duration in Decisecond
double VIEW_MEAN = 7200;
double FLIP_MEAN = 100;
double CHANNEL_MEAN = 6;
srand(time(NULL));
//Number of peak multicast request
int num_users = atoi(argv[1]);
//Number of channels
int num_channels = atoi(argv[2]);
//Number of channels handled by SDV
int num_slices = atoi(argv[3]);
//The simulation runtime
int simulation_time = atoi(argv[4]);
//Simulation time in decisecond
simulation_time = simulation_time*10;
//The zipf shape parameter
float alpha = atof(argv[5]);
user *userArray = (user *)malloc(num_users * sizeof(user));
channel *channelArray = (channel *)malloc(num_channels * sizeof(channel));
channel_slice *sliceArray = (channel_slice *)malloc(num_slices * sizeof(channel_slice));
int k,m,n;
int num_slice = 0;
//Initializing the Channel struct
for(k = 0; k<num_channels; k++)
{
channelArray[k].assigned = FALSE;
channelArray[k].channel_slice = -1;
channelArray[k].num_viewers = 0;
}
//Initializing the Channel Slice struct
for(k = 0; k<num_slices; k++)
{
sliceArray[k].assigned = FALSE;
sliceArray[k].channel = -1;
sliceArray[k].active_duration = 0;
sliceArray[k].start_time = 0;
}
int channel, time;
int num_flips;
for(k = 0; k <num_users; k++)
{
time = rand()%100;
channel = zipfRN(alpha,num_channels);
userArray[k].total_request = 1;
userArray[k].fail_request = 0;
userArray[k].user_state = FLIP;
while(!add_channel(channel,num_slices,time,channelArray,sliceArray,fp))
{
channel = zipfRN(alpha,num_channels);
userArray[k].fail_request++;
userArray[k].total_request++;
}
userArray[k].current_channel = channel;
userArray[k].nextEvent_time = time + exponentialRN(1/FLIP_MEAN);
num_flips = exponentialRN(1/CHANNEL_MEAN);
while(num_flips == 0)
{
num_flips = exponentialRN(1/CHANNEL_MEAN);
}
userArray[k].num_flips = num_flips;
}
int flag;
for(k = 0; k<simulation_time; k++)
{
for(m = 0; m<num_users; m++)
{
if(userArray[m].nextEvent_time <= k)
{
//User is in the VIEW state
if(userArray[m].user_state == VIEW)
{
//Removing the current channel
channel = userArray[m].current_channel;
if(channel != -1)
{
remove_channel(channel,k,channelArray,sliceArray,fp);
}
//The number of channels the user will flip through
num_flips = exponentialRN(1/CHANNEL_MEAN);
while(num_flips == 0)
{
num_flips = exponentialRN(1/CHANNEL_MEAN);
}
userArray[m].num_flips = num_flips;
//Change to FLIP state
userArray[m].user_state = FLIP;
viewers_count--;
//User moves up to the next channel
channel = rand()%num_channels;
userArray[m].total_request++;
//Adding a new channel
flag = add_channel(channel,num_slices,k,channelArray,sliceArray,fp);
if(flag)
{
userArray[m].nextEvent_time += exponentialRN(1/FLIP_MEAN);
userArray[m].current_channel = channel;
}
else if(!flag)
{
userArray[m].current_channel = -1;
userArray[m].fail_request++;
}
}
//User is in the FLIP state
else if(userArray[m].user_state == FLIP)
{
//Removing the current channel
channel = userArray[m].current_channel;
if(channel != -1)
{
remove_channel(channel,k,channelArray,sliceArray,fp);
//The number of remaining channels the user will flip through
userArray[m].num_flips--;
}
if(userArray[m].num_flips > 0)
{
//User moves up to the next channel (channel+1)
channel = rand()%num_channels;
userArray[m].total_request++;
//Adding a new channel
flag = add_channel(channel,num_slices,k,channelArray,sliceArray,fp);
if(flag)
{
//Viewing Duration (in the Flip State)
userArray[m].nextEvent_time += exponentialRN(1/FLIP_MEAN);
//Adding the next channel
userArray[m].current_channel = channel;
}
else if (!flag)
{
userArray[m].current_channel = -1;
userArray[m].fail_request++;
}
}
else if(userArray[m].num_flips <= 0)
{
//Moves to VIEW State
userArray[m].user_state = VIEW;
viewers_count++;
//The new channel user starts viewing
channel = zipfRN(alpha,num_channels);
userArray[m].total_request++;
//Adding a new channel
flag = add_channel(channel,num_slices,k,channelArray,sliceArray,fp);
if(flag)
{
userArray[m].nextEvent_time += exponentialRN(1/VIEW_MEAN);
userArray[m].current_channel = channel;
}
else if (!flag)
{
userArray[m].current_channel = -1;
userArray[m].fail_request++;
}
}
}
}
}
}
int active_slices = 0;
double avg_streams = 0;
for(k = 0; k<num_slices; k++)
{
if(sliceArray[k].assigned == TRUE && sliceArray[k].active_duration == 0)
{
sliceArray[k].active_duration = simulation_time - sliceArray[k].start_time;
}
if(sliceArray[k].active_duration > 0)
{
active_slices++;
//printf("Slice:%d Active Duration:%d Utilization:%3.2f\n",k,sliceArray[k].active_duration,(float)(sliceArray[k].active_duration)/simulation_time);
avg_streams += (float)(sliceArray[k].active_duration)/simulation_time;
}
}
printf("\n***** SDV Simulation *****\n");
unsigned int total_request = 0;
unsigned int fail_request = 0;
for(k = 0; k< num_users; k++)
{
total_request += userArray[k].total_request;
fail_request += userArray[k].fail_request;
}
printf("Fail request: %u\n",fail_request);
printf("Total request: %u\n",total_request);
printf("Average Number of Streams: %f\n",avg_streams);
printf("Peak Number of Slices: %d\n",peak_slice_count);
printf("Average Blocking Probability: %3.4f\n",(float)(fail_request)/total_request);
fclose(fp);
return 0;
}
