int
Union(set **sets, element **elements, char *set1, char *set2)
{
int index1,index2;
set *prev,*iter;
index1 = find_in_list(*sets, set1);
if(index1 == -1) return -1; //error:not found
index2 = find_in_list(*sets, set2);
if(index2 == -1) return -1; //error:not found
if(elements[index1]->size > elements[index2]->size)
{
elements[index2]->belongs = elements[index1];
elements[index1]->size += elements[index2]->size;
//remove from sets list
iter = *sets;
prev = iter;
while(iter != NULL)
{
if(strcmp(iter->name,set2)==0)
{
if(prev == iter) *sets = iter->next;
else
{
prev->next = iter->next;
free(iter);
return 0;
}
}
prev = iter;
iter = iter->next;
}
}
else
{
elements[index1]->belongs = elements[index2];
elements[index2]->size += elements[index1]->size;
//remove from sets list
iter = *sets;
prev = iter;
while(iter != NULL)
{
if(strcmp(iter->name,set1)==0)
{
if(prev == iter) *sets = iter->next;
else
{
prev->next = iter->next;
free(iter);
return 0;
}
}
prev = iter;
iter = iter->next;
}
}
return 0; //successfull operation
}
char *remove_dups(char *inlist, int inlist_size)
{
char name[256], *next = NULL;
char *outlist;
if (!inlist_size) return NULL;
if (!inlist) return NULL;
outlist = (char *) malloc(inlist_size);
if (!outlist) return NULL;
memset(outlist, 0, inlist_size);
foreach(name, inlist, next) {
if (!find_in_list(outlist, name)) {
if (strlen(outlist) == 0) {
snprintf(outlist, inlist_size, "%s", name);
} else {
strncat(outlist, " ", inlist_size - strlen(outlist));
strncat(outlist, name, inlist_size - strlen(outlist));
}
}
}
strncpy(inlist, outlist, inlist_size);
free(outlist);
return inlist;
}
CSetList *check_cset_queue(char *channel, int add)
{
CSetList *c = NULL;
int found = 0;
if (!strchr(channel, '*') && !(c = (CSetList *)find_in_list((List **)&cset_queue, channel, 0)))
{
if (!add)
{
for (c = cset_queue; c; c = c->next)
if (!my_stricmp(c->channel, channel) || wild_match(c->channel, channel))
return c;
return NULL;
}
c = create_csets_for_channel(channel);
add_to_list((List **)&cset_queue, (List *)c);
found++;
}
if (c)
return c;
if (add && !found)
{
for (c = cset_queue; c; c = c->next)
if (!my_stricmp(c->channel, channel))
return c;
c = create_csets_for_channel(channel);
c->next = cset_queue;
cset_queue = c;
return c;
}
return NULL;
}
static void mark(lisp_data_t *start, lisp_ctx_t *context) {
alloclist_t *list_entry;
lisp_data_t *head, *tail;
if(!start)
return;
list_entry = find_in_list(start, context);
if(!list_entry) {
fprintf(stderr, "ERROR: %p not found in memory list.\n", start);
return;
}
if(list_entry->mark == 0) {
list_entry->mark = 1;
if(start->type == lisp_type_pair) {
head = lisp_car(start);
tail = lisp_cdr(start);
mark(head, context);
mark(tail, context);
}
}
}
static void mark(data_t *start) {
alloclist_t *list_entry;
data_t *head, *tail;
if(!start)
return;
list_entry = find_in_list(start);
if(!list_entry) {
fprintf(stderr, "ERROR: %p not found in memory list.\n", start);
return;
}
if(list_entry->mark == 0) {
list_entry->mark = 1;
if(start->type == pair) {
head = car(start);
tail = cdr(start);
mark(head);
mark(tail);
}
}
}
/**
* remove_from_list
* Remove the specified word from the list.
* @param name word to be removed from the list
* @param list Space separated list to modify
* @param listsize Max size the list can occupy
* @return error code
*/
int remove_from_list(const char *name, char *list, int listsize)
{
int listlen = 0;
int namelen = 0;
char *occurrence = list;
if (!list || !name || (listsize <= 0))
return EINVAL;
listlen = strlen(list);
namelen = strlen(name);
occurrence = find_in_list(occurrence, name);
if (!occurrence)
return EINVAL;
/* last item in list? */
if (occurrence[namelen] == 0)
{
/* only item in list? */
if (occurrence != list)
occurrence--;
occurrence[0] = 0;
}
else if (occurrence[namelen] == ' ')
{
strncpy(occurrence, &occurrence[namelen+1 /* space */],
strlen(&occurrence[namelen+1 /* space */]) +1 /* terminate */);
}
return 0;
}
/**
* add_to_list
* Add the specified interface(string) to the list as long as
* it will fit in the space left in the list.
* NOTE: If item is already in list, it won't be added again.
* @param name Name of interface to be added to the list
* @param list List to modify
* @param listsize Max size the list can occupy
* @return error code
*/
int add_to_list(const char *name, char *list, int listsize)
{
int listlen = 0;
int namelen = 0;
if (!list || !name || (listsize <= 0))
return EINVAL;
listlen = strlen(list);
namelen = strlen(name);
/* is the item already in the list? */
if (find_in_list(list, name))
return 0;
if (listsize <= listlen + namelen + 1 /* space */ + 1 /* NULL */)
return EMSGSIZE;
/* add a space if the list isn't empty and it doesn't already have space */
if (list[0] != 0 && list[listlen-1] != ' ')
{
list[listlen++] = 0x20;
}
strncpy(&list[listlen], name, namelen + 1 /* terminate */);
return 0;
}
int main(int argc, const char *argv[])
{
TContact_list contact_list = {contact_list.first = NULL, contact_list.last = NULL};
get_dir();
switch(get_mode(argc, argv)){
case DEL:
get_data(&contact_list);
remove_from_list(&contact_list, atoi(argv[2]));
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
break;
case ADD:
get_data(&contact_list);
add_to_list(argv, &contact_list);
sort_list(&contact_list);
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
break;
case LIST:
get_data(&contact_list);
sort_list(&contact_list);
print_list(&contact_list);
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
break;
case SIN:
get_data(&contact_list);
print_single(&contact_list, atoi(argv[2]));
free_list(&contact_list);
break;
case FIND:
get_data(&contact_list);
find_in_list(&contact_list, (char *)argv[2]);
generate_html(&contact_list);
free_list(&contact_list);
break;
case PLIST:
get_data(&contact_list);
sort_list(&contact_list);
generate_plist(&contact_list);
free_list(&contact_list);
break;
case DELN:
get_data(&contact_list);
delete_by_name(&contact_list, (char *)argv[2], (char *)argv[3]);
save_csv(&contact_list);
generate_html(&contact_list);
free_list(&contact_list);
default:
handle_errors();
return EXIT_FAILURE;
}
if(handle_errors() != EXIT_SUCCESS) return EXIT_FAILURE;
else return EXIT_SUCCESS;
}
/*
* list_lookup: this routine just consolidates remove_from_list and
* find_in_list. I did this cause it fit better with some alread existing
* code
*/
List *list_lookup (List **list, const char *name, int wild, int rem)
{
List *tmp;
if (rem)
tmp = remove_from_list(list, name);
else
tmp = find_in_list(list, name, wild);
return (tmp);
}
void add_to_logs (long winref, int servref, const char *target, int level, const char *orig_str)
{
Logfile *log;
int i;
for (log = logfiles; log; log = log->next)
{
if (log->type == LOG_WINDOWS)
{
for (i = 0; i < MAX_TARGETS; i++) {
if (log->refnums[i] == winref) {
if (!mask_isset(&log->mask, level))
continue;
time(&log->activity);
add_to_log(log->refnum, log->log, winref, orig_str, log->mangler, log->rewrite);
}
}
}
if (log->type == LOG_SERVERS)
{
for (i = 0; i < MAX_TARGETS; i++) {
if (log->refnums[i] == NOSERV ||
log->refnums[i] == servref)
{
if (!mask_isset(&log->mask, level))
continue;
time(&log->activity);
add_to_log(log->refnum, log->log, winref, orig_str, log->mangler, log->rewrite);
}
}
}
else if (log->type == LOG_TARGETS)
{
if (log->servref != NOSERV && (log->servref != servref))
continue;
if (!mask_isset(&log->mask, level))
continue;
if (log->targets && !target)
continue;
if (target && !find_in_list((List **)&log->targets, target, USE_WILDCARDS))
continue;
/* OK! We want to log it now! */
time(&log->activity);
add_to_log(log->refnum, log->log, winref, orig_str, log->mangler, log->rewrite);
}
}
}
/*
* Get LAN or WAN ifname by wl mac
* NOTE: We pass ifname in case of same mac in vifs (like URE TR mode)
*/
char *
get_ifname_by_wlmac(unsigned char *mac, char *name)
{
char nv_name[16], os_name[16], if_name[16];
char tmptr[] = "lanXX_ifnames";
char *ifnames, *ifname;
int i;
/*
* In case of URE mode, wl0.1 and wl0 have same mac,
* we need extra identity (name).
*/
if (name && !strncmp(name, "wl", 2))
snprintf(nv_name, sizeof(nv_name), "%s", name);
else if (get_wlname_by_mac(mac, nv_name))
return 0;
if (nvifname_to_osifname(nv_name, os_name, sizeof(os_name)) < 0)
return 0;
if (osifname_to_nvifname(os_name, nv_name, sizeof(nv_name)) < 0)
return 0;
/* find for lan */
for (i = 0; i < WLIFU_MAX_NO_BRIDGE; i++) {
if (i == 0) {
ifnames = nvram_get("lan_ifnames");
ifname = nvram_get("lan_ifname");
if (ifname) {
/* the name in ifnames may nvifname or osifname */
if (find_in_list(ifnames, nv_name) ||
find_in_list(ifnames, os_name))
return ifname;
}
}
else {
sprintf(if_name, "lan%d_ifnames", i);
sprintf(tmptr, "lan%d_ifname", i);
ifnames = nvram_get(if_name);
ifname = nvram_get(tmptr);
if (ifname) {
/* the name in ifnames may nvifname or osifname */
if (find_in_list(ifnames, nv_name) ||
find_in_list(ifnames, os_name))
return ifname;
}
}
}
/* find for wan */
ifnames = nvram_get("wan_ifnames");
ifname = nvram_get("wan0_ifname");
/* the name in ifnames may nvifname or osifname */
if (find_in_list(ifnames, nv_name) ||
find_in_list(ifnames, os_name))
return ifname;
return 0;
}
/* Remove any entries from list which match values in disabled. */
static void
remove_disabled_modules(struct plugin_mapping **list, char **disable)
{
struct plugin_mapping **in, **out;
out = list;
for (in = list; *in != NULL; in++) {
if (find_in_list(disable, (*in)->modname))
free_plugin_mapping(*in);
else
*out++ = *in;
}
*out = NULL;
}
void remove_neighbor(struct ospf_neighbor *nbr) {
struct replay_list *item;
remove_object_events((void *)nbr);
item = find_in_list(ospf0->nbrlist,(void *)nbr);
if(item) {
ospf0->nbrlist = remove_from_list(ospf0->nbrlist,item);
ospf0->nbrcount--;
}
item = find_in_list(nbr->ospf_if->nbrlist,(void *)nbr);
if(item) nbr->ospf_if->nbrlist = remove_from_list(ospf0->nbrlist,item);
if(nbr->lsa_need_list) {
nbr->lsa_need_list = delete_list(nbr->lsa_need_list);
}
if(nbr->lsa_send_list) {
nbr->lsa_send_list = delete_list(nbr->lsa_send_list);
}
if(nbr->lsu_lsa_list) {
nbr->lsu_lsa_list = remove_all_from_nlist(nbr->lsu_lsa_list);
}
// what about LSAs from this neighbor?
// change interface from transit to stub
if(nbr->ospf_if) {
if(!nbr->ospf_if->nbrlist) {
toggle_stub(nbr->ospf_if);
}
}
free(nbr);
set_router_lsa();
}
int check_nignore(char *nick)
{
if (ignores && find_in_list((List **)&ignores, nick, 0))
return 1;
return 0;
}
CSetList *create_csets_for_channel(char *channel)
{
CSetList *tmp;
#ifdef VAR_DEBUG
int i;
for (i = 1; i < NUMBER_OF_CSETS - 1; i++)
if (strcmp(cset_array[i-1].name, cset_array[i].name) >= 0)
ircpanic("Variable [%d] (%s) is out of order.", i, cset_array[i].name);
#endif
if (check_cset_queue(channel, 0))
{
if ((tmp = (CSetList *)find_in_list((List **)&cset_queue, channel, 0)))
return tmp;
for (tmp = cset_queue; tmp; tmp = tmp->next)
if (!my_stricmp(tmp->channel, channel) || wild_match(tmp->channel, channel))
return tmp;
}
tmp = (CSetList *) new_malloc(sizeof(CSetList));
/* use default settings. */
tmp->set_aop = get_int_var(AOP_VAR);
tmp->set_annoy_kick = get_int_var(ANNOY_KICK_VAR);
tmp->set_ainv = get_int_var(AINV_VAR);
tmp->set_auto_join_on_invite = get_int_var(AUTO_JOIN_ON_INVITE_VAR);
tmp->set_auto_rejoin = get_int_var(AUTO_REJOIN_VAR);
tmp->set_bantime = get_int_var(BANTIME_VAR);
tmp->compress_modes = get_int_var(COMPRESS_MODES_VAR);
tmp->bitch_mode = get_int_var(BITCH_VAR);
tmp->channel_log = 0;
tmp->log_level = m_strdup("ALL");
set_msglog_channel_level(cset_array, tmp);
#if defined(WINNT) || defined(__EMX__)
tmp->channel_log_file = m_sprintf("~/bx-conf/%s.log", channel+1);
#else
tmp->channel_log_file = m_sprintf("~/.BitchX/%s.log", channel+1);
#endif
tmp->set_joinflood = get_int_var(JOINFLOOD_VAR);
tmp->set_joinflood_time = get_int_var(JOINFLOOD_TIME_VAR);
tmp->set_ctcp_flood_ban = get_int_var(CTCP_FLOOD_BAN_VAR);
tmp->set_deop_on_deopflood = get_int_var(DEOP_ON_DEOPFLOOD_VAR);
tmp->set_deop_on_kickflood = get_int_var(DEOP_ON_KICKFLOOD_VAR);
tmp->set_deopflood = get_int_var(DEOPFLOOD_VAR);
tmp->set_deopflood_time = get_int_var(DEOPFLOOD_TIME_VAR);
tmp->set_hacking = get_int_var(HACKING_VAR);
tmp->set_kick_on_deopflood = get_int_var(KICK_ON_DEOPFLOOD_VAR);
tmp->set_kick_on_joinflood = get_int_var(KICK_ON_JOINFLOOD_VAR);
tmp->set_kick_on_kickflood = get_int_var(KICK_ON_KICKFLOOD_VAR);
tmp->set_kick_on_nickflood = get_int_var(KICK_ON_NICKFLOOD_VAR);
tmp->set_kick_on_pubflood = get_int_var(KICK_ON_PUBFLOOD_VAR);
tmp->set_kickflood = get_int_var(KICKFLOOD_VAR);
tmp->set_kickflood_time = get_int_var(KICKFLOOD_TIME_VAR);
tmp->set_kick_ops = get_int_var(KICK_OPS_VAR);
tmp->set_nickflood = get_int_var(NICKFLOOD_VAR);
tmp->set_nickflood_time = get_int_var(NICKFLOOD_TIME_VAR);
tmp->set_pubflood = get_int_var(PUBFLOOD_VAR);
tmp->set_pubflood_time = get_int_var(PUBFLOOD_TIME_VAR);
tmp->set_pubflood_ignore = 60;
tmp->set_userlist = get_int_var(USERLIST_VAR);
tmp->set_shitlist = get_int_var(SHITLIST_VAR);
tmp->set_lamelist = get_int_var(LAMELIST_VAR);
tmp->set_lame_ident = get_int_var(LAMEIDENT_VAR);
tmp->set_kick_if_banned = get_int_var(KICK_IF_BANNED_VAR);
tmp->set_auto_limit = get_int_var(AUTO_LIMIT_VAR);
malloc_strcpy(&tmp->chanmode, get_string_var(CHANMODE_VAR));
malloc_strcpy(&tmp->channel, channel);
return tmp;
}
NickList *check_auto(char *channel, NickList *nicklist, ChannelList *chan)
{
ShitList *shitptr = NULL;
UserList *userptr = NULL;
ChannelList *chan_ptr = NULL;
char *ban;
if (!channel || !*channel || !nicklist)
return NULL;
if (!chan)
{
ChannelList *chan2;
chan2 = get_server_channels(from_server);
chan_ptr = (ChannelList *) find_in_list((List **)&chan2, channel, 0);
}
else
chan_ptr = chan;
if (!chan_ptr)
return NULL;
if (!chan_ptr->chop)
return nicklist;
userptr = nicklist->userlist;
shitptr = nicklist->shitlist;
if (userptr && !check_channel_match(userptr->channels, channel))
userptr = NULL;
if (shitptr && (!check_channel_match(shitptr->channels, channel) || isme(nicklist->nick)))
shitptr = NULL;
if (get_cset_int_var(chan_ptr->csets, SHITLIST_CSET) && shitptr != NULL && userptr == NULL)
{
char *theshit;
time_t current = now;
theshit = get_string_var(SHITLIST_REASON_VAR);
switch(shitptr->level)
{
case 0:
return nicklist;
break;
case 1:/* never give opz */
if (nicklist->sent_deop < 4 && nick_isop(nicklist))
{
add_mode(chan_ptr, "o", 0, nicklist->nick, NULL, get_int_var(NUM_OPMODES_VAR));
nicklist->sent_deop++;
nicklist->sent_deop_time = current;
}
break;
case 2: /* Auto Kick offender */
add_mode(chan_ptr, NULL, 0, nicklist->nick, shitptr->reason?shitptr->reason:theshit, 0);
break;
case 3: /* kick ban the offender */
case 4: /* perm ban on offender */
if (nicklist->sent_deop < 4 || (nicklist->sent_deop < 4 && shitptr->level == 4))
{
send_to_server("MODE %s -o+b %s %s", channel, nicklist->nick, shitptr->filter);
nicklist->sent_deop++;
nicklist->sent_deop_time = current;
if (get_int_var(AUTO_UNBAN_VAR) && shitptr->level != 4)
add_timer(0, empty_string, get_int_var(AUTO_UNBAN_VAR) * 1000, 1, timer_unban, m_sprintf("%d %s %s", from_server, channel, shitptr->filter), NULL, -1, "auto-unban");
}
if (get_cset_int_var(chan_ptr->csets, KICK_IF_BANNED_CSET))
send_to_server("KICK %s %s :%s", channel,
nicklist->nick, (shitptr->reason && *shitptr->reason) ? shitptr->reason : theshit);
default:
break;
}
return nicklist;
}
if (userptr && get_cset_int_var(chan_ptr->csets, USERLIST_CSET))
{
char *buffer = NULL;
time_t current = now;
int done = 0;
char *p = NULL;
if (get_cset_int_var(chan_ptr->csets, AOP_CSET))
{
if ((userptr->flags & ADD_OPS))
{
done++;
if (!userptr->password && !nicklist->sent_reop && !nick_isop(nicklist))
{
nicklist->sent_reop++;
nicklist->sent_reop_time = current;
if (!(userptr->flags & ADD_IOPS))
{
malloc_sprintf(&buffer, "%s %s %s %s %d", channel, nicklist->nick, nicklist->host, "o", from_server);
add_timer(0, empty_string, 10 * 1000, 1, delay_opz, buffer, NULL, -1, "delay-ops");
}
else
send_to_server("MODE %s +o %s", chan_ptr->channel, nicklist->nick);
}
}
else if ((userptr->flags & ADD_VOICE))
{
done++;
if (!nicklist->sent_voice && !nick_isvoice(nicklist))
{
nicklist->sent_voice++;
nicklist->sent_voice_time = current;
if (!(userptr->flags & ADD_IOPS))
{
malloc_sprintf(&buffer, "%s %s %s %s %d", channel, nicklist->nick, nicklist->host, "v", from_server);
add_timer(0, empty_string, 10 * 1000, 1, delay_opz, buffer, NULL, -1, "delay-ops");
}
else
send_to_server("MODE %s +v %s", chan_ptr->channel, nicklist->nick);
}
}
}
if ((userptr->flags & USER_FLAG_OPS) && (p = get_string_var(USER_FLAG_OPS_VAR)))
{
done++;
run_user_flag("USER_FLAG_OPS", p, nicklist, NULL);
}
if (done)
return nicklist;
}
if (get_cset_int_var(chan_ptr->csets, KICK_IF_BANNED_CSET) && check_channel_match(get_string_var(PROTECT_CHANNELS_VAR), chan_ptr->channel))
{
char *ipban = NULL;
char *u = NULL;
if (!nicklist->host)
return nicklist;
ban = m_3dup(nicklist->nick, "!", nicklist->host);
if (nicklist->ip && nicklist->host)
{
char *user = alloca(strlen(nicklist->host)+1);
strcpy(user, nicklist->host);
if ((u = strchr(user, '@')))
*u = 0;
ipban = m_opendup(nicklist->nick, "!", user, "@", nicklist->ip, NULL);
}
if (!isme(nicklist->nick) && (!eban_is_on_channel(ban, chan_ptr) && (ban_is_on_channel(ban, chan_ptr) || (ipban && ban_is_on_channel(ipban, chan_ptr)))) )
{
new_free(&ban);
new_free(&ipban);
if (nick_isop(nicklist) && !get_cset_int_var(chan_ptr->csets, KICK_OPS_CSET))
return nicklist;
my_send_to_server(from_server, "KICK %s %s :Banned", chan_ptr->channel, nicklist->nick);
}
new_free(&ban);
new_free(&ipban);
}
return nicklist;
}
static Logfile * logfile_add (Logfile *log, char **args)
{
char *ptr;
WNickList *new_w;
char *arg = next_arg(*args, args);
int i;
if (!log)
{
say("ADD: You need to specify a logfile first");
return NULL;
}
if (!arg)
say("ADD: Add nicknames/channels to be logged to this file");
else while (arg)
{
if ((ptr = strchr(arg, ',')))
*ptr++ = 0;
if (log->type == LOG_TARGETS)
{
if (!find_in_list((List **)&log->targets, arg, !USE_WILDCARDS))
{
say("Added %s to log name list", arg);
new_w = (WNickList *)new_malloc(sizeof(WNickList));
new_w->nick = malloc_strdup(arg);
add_to_list((List **)&(log->targets), (List *)new_w);
}
else
say("%s already on log name list", arg);
}
else if (log->type == LOG_SERVERS || log->type == LOG_WINDOWS)
{
int refnum;
if (log->type == LOG_SERVERS && !my_strnicmp("ALL", arg, 1))
refnum = NOSERV;
else
refnum = my_atol(arg);
for (i = 0; i < MAX_TARGETS; i++)
{
if (log->refnums[i] == refnum)
{
say("%s already on log refnum list", arg);
break;
}
}
for (i = 0; i < MAX_TARGETS; i++)
{
if (log->refnums[i] == -1)
{
say("Added %d to log name list", refnum);
log->refnums[i] = refnum;
break;
}
}
if (i >= MAX_TARGETS)
say("Could not add %d to log name list!", refnum);
}
arg = ptr;
}
return log;
}
static void p_mode(char *from, char **ArgList)
{
char *channel;
char *line;
int flag;
struct channel *chan = NULL;
char buffer[BIG_BUFFER_SIZE + 1];
char *smode;
#ifdef COMPRESS_MODES
char *tmpbuf = NULL;
#endif
PasteArgs(ArgList, 1);
channel = ArgList[0];
line = ArgList[1];
smode = strchr(from, '.');
flag = check_ignore(from, FromUserHost, channel, (smode ? IGNORE_SMODES : IGNORE_MODES) | IGNORE_CRAP, NULL);
message_from(channel, LOG_CRAP);
if (channel && line) {
strcpy(buffer, line);
if (get_int_var(MODE_STRIPPER_VAR))
strip_modes(from, channel, line);
if (is_channel(channel)) {
#ifdef COMPRESS_MODES
chan = (struct channel *) find_in_list((struct list **) &server_list[from_server].chan_list, channel, 0);
if (get_int_var(COMPRESS_MODES_VAR)) {
tmpbuf = compress_modes(from_server, channel, line);
if (tmpbuf)
strcpy(line, tmpbuf);
else
goto end_p_mode;
}
#endif
/* CDE handle mode protection here instead of later */
update_channel_mode(from, channel, from_server, buffer, chan);
if (flag != IGNORED && do_hook(MODE_LIST, "%s %s %s", from, channel, line))
put_it("%s",
convert_output_format(get_format(smode ? FORMAT_SMODE_FSET : FORMAT_MODE_FSET), "%s %s %s %s %s",
update_clock(GET_TIME), from, smode ? "*" : FromUserHost, channel, line));
} else {
if (flag != IGNORED && do_hook(MODE_LIST, "%s %s %s", from, channel, line)) {
if (!my_stricmp(from, channel)) {
if (!my_stricmp(from, get_server_nickname(from_server)))
put_it("%s",
convert_output_format(get_format(FORMAT_USERMODE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
"*", channel, line));
else
put_it("%s",
convert_output_format(get_format(FORMAT_USERMODE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
smode ? "*" : FromUserHost, channel, line));
} else
put_it("%s",
convert_output_format(get_format(FORMAT_MODE_FSET), "%s %s %s %s %s", update_clock(GET_TIME), from,
smode ? "*" : FromUserHost, channel, line));
}
update_user_mode(line);
}
#ifdef COMPRESS_MODES
end_p_mode:
#endif
update_all_status(curr_scr_win, NULL, 0);
}
message_from(NULL, LOG_CRAP);
}
/*!
\brief sets up and populates the MS2-Extra combo for output choice
\param widget is the pointer to the combo to initialize
*/
G_MODULE_EXPORT void ms2_output_combo_setup(GtkWidget *widget)
{
guint i = 0;
GtkWidget *parent = NULL;
gchar * lower = NULL;
gchar * upper = NULL;
gfloat * multiplier = NULL;
gfloat * adder = NULL;
gfloat * testmult = NULL;
gchar * range = NULL;
gint bitval = 0;
gint width = 0;
DataSize size = MTX_U08;
gint precision = 0;
gconstpointer * object = NULL;
gint raw_lower = 0;
gint raw_upper = 0;
gboolean freelower = FALSE;
gboolean freeupper = FALSE;
gchar *raw_lower_str = NULL;
gchar *raw_upper_str = NULL;
gfloat real_lower = 0.0;
gfloat real_upper = 0.0;
gfloat tmpf = 0.0;
gchar * name = NULL;
gchar *internal_names = NULL;
GtkWidget *entry = NULL;
GtkEntryCompletion *completion = NULL;
GtkListStore *store = NULL;
GtkTreeIter iter;
ENTER();
Rtv_Map *rtv_map = NULL;
rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map");
if (!rtv_map)
{
EXIT();
return;
}
/* Create the store for the combo, with severla hidden values
*/
store = gtk_list_store_new(UO_COMBO_COLS,G_TYPE_STRING,G_TYPE_UCHAR,G_TYPE_POINTER,G_TYPE_POINTER,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_STRING,G_TYPE_UCHAR,G_TYPE_UCHAR);
/* Iterate across valid variables */
for (i=0;i<rtv_map->rtv_list->len;i++)
{
freelower = FALSE;
freeupper = FALSE;
object = NULL;
name = NULL;
object = (gconstpointer *)g_ptr_array_index(rtv_map->rtv_list,i);
if (!object)
continue;
name = (gchar *) DATA_GET(object,"dlog_gui_name");
if (!name)
continue;
if (DATA_GET(object,"fromecu_complex"))
continue;
if (DATA_GET(object,"special"))
continue;
internal_names = (gchar *) DATA_GET(object,"internal_names");
if (!find_in_list(rtv_map->raw_list,internal_names))
continue;
size = (DataSize)(GINT)DATA_GET(object,"size");
multiplier = (gfloat *)DATA_GET(object,"fromecu_mult");
adder = (gfloat *)DATA_GET(object,"fromecu_add");
precision = (GINT) DATA_GET(object,"precision");
bitval = (GINT) DATA_GET(object,"offset");
if (DATA_GET(object,"real_lower"))
{
lower = (gchar *)DATA_GET(object,"real_lower");
real_lower = g_strtod(lower,NULL);
raw_lower = calc_value_f(real_lower,multiplier,adder,TOECU);
}
else
{
raw_lower = get_extreme_from_size_f(size,LOWER);
tmpf = calc_value_f(raw_lower,multiplier,adder,FROMECU);
lower = g_strdup_printf("%i",(gint)tmpf);
freelower = TRUE;
}
if (DATA_GET(object,"real_upper"))
{
upper = (gchar *)DATA_GET(object,"real_upper");
real_upper = g_strtod(upper,NULL);
raw_upper = calc_value_f(real_upper,multiplier,adder,TOECU);
}
else
{
raw_upper = get_extreme_from_size_f(size,UPPER);
tmpf = calc_value_f(raw_upper,multiplier,adder,FROMECU);
upper = g_strdup_printf("%i",(gint)tmpf);
freeupper = TRUE;
}
range = g_strdup_printf("Valid Range: %s <-> %s",lower,upper);
if (freelower)
g_free(lower);
if (freeupper)
g_free(upper);
if ((multiplier) && (adder))
{
raw_lower = (GINT)((real_lower - (*adder))/(*multiplier));
raw_upper = (GINT)((real_upper - (*adder))/(*multiplier));
}
else if (multiplier)
{
raw_lower = (GINT)(real_lower/(*multiplier));
raw_upper = (GINT)(real_upper/(*multiplier));
}
else
{
raw_lower = (GINT)real_lower;
raw_upper = (GINT)real_upper;
}
raw_lower_str = g_strdup_printf("%i",raw_lower);
raw_upper_str = g_strdup_printf("%i",raw_upper);
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,
UO_CHOICE_COL,name,
UO_BITVAL_COL,bitval,
UO_FROMECU_MULT_COL,multiplier,
UO_FROMECU_ADD_COL,adder,
UO_RAW_LOWER_COL,raw_lower_str,
UO_RAW_UPPER_COL,raw_upper_str,
UO_RANGE_COL,range,
UO_SIZE_COL,size,
UO_PRECISION_COL,precision,
-1);
g_free(raw_lower_str);
g_free(raw_upper_str);
g_free(range);
}
/*#if GTK_MINOR_VERSION < 24 */
if (GTK_IS_COMBO_BOX_ENTRY(widget))
{
gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(widget),UO_CHOICE_COL);
/*
#else
if (GTK_IS_COMBO_BOX(widget))
{
gtk_combo_box_set_entry_text_column(GTK_COMBO_BOX(widget),UO_CHOICE_COL);
#endif
*/
gtk_combo_box_set_model(GTK_COMBO_BOX(widget),GTK_TREE_MODEL(store));
g_object_unref(store);
entry = gtk_bin_get_child(GTK_BIN(widget));
/* Nasty hack, but otherwise the entry is an obnoxious size.. */
if ((width = (GINT)OBJ_GET((GtkWidget *)widget,"max_chars")) > 0)
gtk_entry_set_width_chars(GTK_ENTRY(entry),width);
else
gtk_entry_set_width_chars(GTK_ENTRY(entry),12);
gtk_widget_set_size_request(GTK_WIDGET(widget),-1,(3*(GINT)DATA_GET(global_data,"font_size")));
// gtk_container_remove (GTK_CONTAINER (widget), gtk_bin_get_child(GTK_BIN(widget)));
// gtk_container_add (GTK_CONTAINER (widget), entry);
completion = gtk_entry_completion_new();
gtk_entry_set_completion(GTK_ENTRY(entry),completion);
g_object_unref(completion);
gtk_entry_completion_set_model(completion,GTK_TREE_MODEL(store));
gtk_entry_completion_set_text_column(completion,UO_CHOICE_COL);
gtk_entry_completion_set_inline_completion(completion,TRUE);
gtk_entry_completion_set_inline_selection(completion,TRUE);
gtk_entry_completion_set_popup_single_match(completion,FALSE);
OBJ_SET(widget,"arrow-size",GINT_TO_POINTER(1));
}
EXIT();
return;
}
static int handle_line(char *line)
{
int i, len = strlen(line);
unsigned char *sha1;
char *src, *origin;
struct src_data *src_data;
int pulling_head = 0;
if (len < 43 || line[40] != '\t')
return 1;
if (!prefixcmp(line + 41, "not-for-merge"))
return 0;
if (line[41] != '\t')
return 2;
line[40] = 0;
sha1 = xmalloc(20);
i = get_sha1(line, sha1);
line[40] = '\t';
if (i)
return 3;
if (line[len - 1] == '\n')
line[len - 1] = 0;
line += 42;
src = strstr(line, " of ");
if (src) {
*src = 0;
src += 4;
pulling_head = 0;
} else {
src = line;
pulling_head = 1;
}
i = find_in_list(&srcs, src);
if (i < 0) {
i = srcs.nr;
append_to_list(&srcs, xstrdup(src),
xcalloc(1, sizeof(struct src_data)));
}
src_data = srcs.payload[i];
if (pulling_head) {
origin = xstrdup(src);
src_data->head_status |= 1;
} else if (!prefixcmp(line, "branch ")) {
origin = xstrdup(line + 7);
append_to_list(&src_data->branch, origin, NULL);
src_data->head_status |= 2;
} else if (!prefixcmp(line, "tag ")) {
origin = line;
append_to_list(&src_data->tag, xstrdup(origin + 4), NULL);
src_data->head_status |= 2;
} else if (!prefixcmp(line, "remote branch ")) {
origin = xstrdup(line + 14);
append_to_list(&src_data->r_branch, origin, NULL);
src_data->head_status |= 2;
} else {
origin = xstrdup(src);
append_to_list(&src_data->generic, xstrdup(line), NULL);
src_data->head_status |= 2;
}
if (!strcmp(".", src) || !strcmp(src, origin)) {
int len = strlen(origin);
if (origin[0] == '\'' && origin[len - 1] == '\'') {
origin = xmemdupz(origin + 1, len - 2);
} else {
origin = xstrdup(origin);
}
} else {
char *new_origin = xmalloc(strlen(origin) + strlen(src) + 5);
sprintf(new_origin, "%s of %s", origin, src);
origin = new_origin;
}
append_to_list(&origins, origin, sha1);
return 0;
}
/*!
\brief sets up and populates the MS2-Extra combo for output choice
\param widget is the pointer to the combo to initialize
*/
G_MODULE_EXPORT void ms2_output_combo_setup(GtkWidget *widget)
{
guint i = 0;
GtkWidget *parent = NULL;
gchar * lower = NULL;
gchar * upper = NULL;
gfloat * multiplier = NULL;
gfloat * adder = NULL;
gfloat * testmult = NULL;
gchar * range = NULL;
gint bitval = 0;
gint width = 0;
DataSize size = MTX_U08;
gint precision = 0;
gconstpointer * object = NULL;
gint raw_lower = 0;
gint raw_upper = 0;
gboolean temp_dep = FALSE;
gchar *raw_lower_str = NULL;
gchar *raw_upper_str = NULL;
gchar *tempc_range = NULL;
gchar *tempf_range = NULL;
gchar *tempk_range = NULL;
gfloat real_lower = 0.0;
gfloat real_upper = 0.0;
gfloat tmpf = 0.0;
gchar * name = NULL;
gchar *internal_names = NULL;
GtkWidget *entry = NULL;
GtkEntryCompletion *completion = NULL;
GtkListStore *store = NULL;
GtkTreeIter iter;
ENTER();
Rtv_Map *rtv_map = NULL;
rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map");
if (!rtv_map)
{
EXIT();
return;
}
/* Create the store for the combo, with severla hidden values
*/
store = gtk_list_store_new(UO_COMBO_COLS,
G_TYPE_STRING, /* Choice */
G_TYPE_UCHAR, /* BITval */
G_TYPE_POINTER, /* FromECU Multiplier (gfloat *) */
G_TYPE_POINTER, /* FromECU Adder (gfloat *) */
G_TYPE_STRING, /* Raw Lower clamp limit */
G_TYPE_STRING, /* Raw Upper clamp limit */
G_TYPE_STRING, /* Range widget string (non temp ctrls) */
G_TYPE_STRING, /* Range widget string (Celsius) */
G_TYPE_STRING, /* Range widget string (Fahrenheit) */
G_TYPE_STRING, /* Range widget string (Kelvin) */
G_TYPE_INT, /* Size enumeration (_U08_, _U16_, etc.) */
G_TYPE_UCHAR, /* Precision (floating point precision) */
G_TYPE_BOOLEAN);/* Temp dependent flag */
/* Iterate across valid variables */
for (i=0;i<rtv_map->rtv_list->len;i++)
{
object = NULL;
name = NULL;
object = (gconstpointer *)g_ptr_array_index(rtv_map->rtv_list,i);
if (!object)
continue;
name = (gchar *) DATA_GET(object,"dlog_gui_name");
if (!name)
continue;
if (DATA_GET(object,"fromecu_complex"))
continue;
if (DATA_GET(object,"special"))
continue;
internal_names = (gchar *) DATA_GET(object,"internal_names");
if (!find_in_list(rtv_map->raw_list,internal_names))
continue;
temp_dep = (GBOOLEAN)DATA_GET(object,"temp_dep");
size = (DataSize)(GINT)DATA_GET(object,"size");
multiplier = (gfloat *)DATA_GET(object,"fromecu_mult");
adder = (gfloat *)DATA_GET(object,"fromecu_add");
precision = (GINT) DATA_GET(object,"precision");
bitval = (GINT) DATA_GET(object,"offset");
if (DATA_GET(object,"real_lower"))
{
lower = (gchar *)DATA_GET(object,"real_lower");
real_lower = g_strtod(lower,NULL);
raw_lower = calc_value_f(real_lower,multiplier,adder,TOECU);
}
else
raw_lower = get_extreme_from_size_f(size,LOWER);
if (DATA_GET(object,"real_upper"))
{
upper = (gchar *)DATA_GET(object,"real_upper");
real_upper = g_strtod(upper,NULL);
raw_upper = calc_value_f(real_upper,multiplier,adder,TOECU);
}
else
raw_upper = get_extreme_from_size_f(size,UPPER);
range = g_strdup_printf("Valid Range: %.1f <-> %.1f",real_lower,real_upper);
if (temp_dep)
{
tempc_range = g_strdup_printf("Valid Range: %.1f\302\260C <-> %.1f\302\260C",f_to_c_f(real_lower),f_to_c_f(real_upper));
tempf_range = g_strdup_printf("Valid Range: %.1f\302\260F <-> %.1f\302\260F",real_lower,real_upper);
tempk_range = g_strdup_printf("Valid Range: %.1f\302\260K <-> %.1f\302\260K",f_to_k_f(real_lower),f_to_k_f(real_upper));
}
else
{
tempc_range = g_strdup(range);
tempf_range = g_strdup(range);
tempk_range = g_strdup(range);
}
raw_lower_str = g_strdup_printf("%i",raw_lower);
raw_upper_str = g_strdup_printf("%i",raw_upper);
gtk_list_store_append(store,&iter);
gtk_list_store_set(store,&iter,
UO_CHOICE_COL,name,
UO_BITVAL_COL,bitval,
UO_FROMECU_MULT_COL,multiplier,
UO_FROMECU_ADD_COL,adder,
UO_RAW_LOWER_COL,raw_lower_str,
UO_RAW_UPPER_COL,raw_upper_str,
UO_RANGE_COL,range,
UO_RANGE_TEMPC_COL,tempc_range,
UO_RANGE_TEMPF_COL,tempf_range,
UO_RANGE_TEMPK_COL,tempk_range,
UO_SIZE_COL,size,
UO_PRECISION_COL,precision,
UO_TEMP_DEP_COL,temp_dep,
-1);
g_free(raw_lower_str);
g_free(raw_upper_str);
g_free(range);
g_free(tempc_range);
g_free(tempf_range);
g_free(tempk_range);
}
if (GTK_IS_COMBO_BOX_ENTRY(widget))
{
gtk_combo_box_entry_set_text_column(GTK_COMBO_BOX_ENTRY(widget),UO_CHOICE_COL);
gtk_combo_box_set_model(GTK_COMBO_BOX(widget),GTK_TREE_MODEL(store));
g_object_unref(store);
entry = gtk_bin_get_child(GTK_BIN(widget));
/* Nasty hack, but otherwise the entry is an obnoxious size.. */
if ((width = (GINT)OBJ_GET((GtkWidget *)widget,"max_chars")) > 0)
gtk_entry_set_width_chars(GTK_ENTRY(entry),width);
else
gtk_entry_set_width_chars(GTK_ENTRY(entry),12);
gtk_widget_set_size_request(GTK_WIDGET(widget),-1,(3*(GINT)DATA_GET(global_data,"font_size")));
// gtk_container_remove (GTK_CONTAINER (widget), gtk_bin_get_child(GTK_BIN(widget)));
// gtk_container_add (GTK_CONTAINER (widget), entry);
completion = gtk_entry_completion_new();
gtk_entry_set_completion(GTK_ENTRY(entry),completion);
g_object_unref(completion);
gtk_entry_completion_set_model(completion,GTK_TREE_MODEL(store));
gtk_entry_completion_set_text_column(completion,UO_CHOICE_COL);
gtk_entry_completion_set_inline_completion(completion,TRUE);
gtk_entry_completion_set_inline_selection(completion,TRUE);
gtk_entry_completion_set_popup_single_match(completion,FALSE);
OBJ_SET(widget,"arrow-size",GINT_TO_POINTER(1));
}
EXIT();
return;
}
