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; }