void noui_init(void)
{
static struct poptOption options[] = {
POPT_AUTOHELP
{ "load", 'l', POPT_ARG_STRING, &autoload_module, 0, "Module to load (default = bot)", "MODULE" },
{ NULL, '\0', 0, NULL }
};
autoload_module = NULL;
args_register(options);
irssi_gui = IRSSI_GUI_NONE;
core_init();
irc_init();
signal_add("reload", (SIGNAL_FUNC) sig_reload);
signal_add("gui exit", (SIGNAL_FUNC) sig_exit);
#ifdef HAVE_STATIC_PERL
perl_core_init();
#endif
signal_emit("irssi init finished", 0);
}
void keyboard_init(void)
{
keys = g_hash_table_new((GHashFunc) g_str_hash,
(GCompareFunc) g_str_equal);
default_keys = g_hash_table_new((GHashFunc) g_str_hash,
(GCompareFunc) g_str_equal);
keyinfos = NULL;
key_states = g_tree_new((GCompareFunc) strcmp);
key_config_frozen = 0;
memset(used_keys, 0, sizeof(used_keys));
key_bind("command", "Run any IRC command", NULL, NULL, (SIGNAL_FUNC) sig_command);
key_bind("key", "Specify name for key binding", NULL, NULL, (SIGNAL_FUNC) sig_key);
key_bind("multi", "Run multiple commands", NULL, NULL, (SIGNAL_FUNC) sig_multi);
/* read the keyboard config when all key binds are known */
signal_add("irssi init read settings", (SIGNAL_FUNC) read_keyboard_config);
signal_add("setup reread", (SIGNAL_FUNC) read_keyboard_config);
signal_add("complete command bind", (SIGNAL_FUNC) sig_complete_bind);
command_bind("bind", NULL, (SIGNAL_FUNC) cmd_bind);
command_set_options("bind", "delete");
}
void themes_init(void)
{
settings_add_str("lookandfeel", "theme", "default");
default_formats = g_hash_table_new((GHashFunc) g_str_hash,
(GCompareFunc) g_str_equal);
internal_theme = read_internal_theme();
init_finished = FALSE;
init_errors = NULL;
themes_reload();
command_bind("format", NULL, (SIGNAL_FUNC) cmd_format);
command_bind("save", NULL, (SIGNAL_FUNC) cmd_save);
signal_add("complete command format", (SIGNAL_FUNC) sig_complete_format);
signal_add("irssi init finished", (SIGNAL_FUNC) sig_print_errors);
signal_add("setup changed", (SIGNAL_FUNC) read_settings);
signal_add("setup reread", (SIGNAL_FUNC) themes_reload);
command_set_options("format", "delete reset");
command_set_options("save", "formats");
}
void chat_commands_init(void)
{
settings_add_str("misc", "quit_message", "leaving");
command_bind("server", NULL, (SIGNAL_FUNC) cmd_server);
command_bind("server connect", NULL, (SIGNAL_FUNC) cmd_server_connect);
command_bind("connect", NULL, (SIGNAL_FUNC) cmd_connect);
command_bind("disconnect", NULL, (SIGNAL_FUNC) cmd_disconnect);
command_bind("quit", NULL, (SIGNAL_FUNC) cmd_quit);
command_bind("join", NULL, (SIGNAL_FUNC) cmd_join);
command_bind("msg", NULL, (SIGNAL_FUNC) cmd_msg);
command_bind("foreach", NULL, (SIGNAL_FUNC) cmd_foreach);
command_bind("foreach server", NULL, (SIGNAL_FUNC) cmd_foreach_server);
command_bind("foreach channel", NULL, (SIGNAL_FUNC) cmd_foreach_channel);
command_bind("foreach query", NULL, (SIGNAL_FUNC) cmd_foreach_query);
signal_add("default command server", (SIGNAL_FUNC) sig_default_command_server);
signal_add("server sendmsg", (SIGNAL_FUNC) sig_server_sendmsg);
command_set_options("connect", "4 6 !! -network ssl +ssl_cert +ssl_pkey ssl_verify +ssl_cafile +ssl_capath +host noproxy -rawlog");
command_set_options("join", "invite");
command_set_options("msg", "channel nick");
}
void
muc_init(void)
{
CHAT_PROTOCOL_REC *chat;
if ((chat = chat_protocol_find(XMPP_PROTOCOL_NAME)) != NULL)
chat->channel_create = (CHANNEL_REC *(*)
(SERVER_REC *, const char *, const char *, int))muc_create;
disco_add_feature(XMLNS_MUC);
muc_commands_init();
muc_events_init();
muc_nicklist_init();
muc_reconnect_init();
signal_add("xmpp features", sig_features);
signal_add("channel created", sig_channel_created);
signal_add("channel destroyed", sig_channel_destroyed);
signal_add("server connected", sig_connected);
signal_add("xmpp set presence", sig_set_presence);
settings_add_int("xmpp_lookandfeel", "xmpp_history_maxstanzas", 30);
}
void channel_rejoin_init(void)
{
settings_add_bool("servers", "channels_rejoin_unavailable", TRUE);
rejoin_tag = g_timeout_add(REJOIN_TIMEOUT,
(GSourceFunc) sig_rejoin, NULL);
command_bind_irc("rmrejoins", NULL, (SIGNAL_FUNC) cmd_rmrejoins);
signal_add_first("event 407", (SIGNAL_FUNC) event_duplicate_channel);
signal_add_first("event 437", (SIGNAL_FUNC) event_target_unavailable);
signal_add_first("channel joined", (SIGNAL_FUNC) sig_remove_rejoin);
signal_add_first("channel destroyed", (SIGNAL_FUNC) sig_remove_rejoin);
signal_add("server disconnected", (SIGNAL_FUNC) sig_disconnected);
}
void fe_server_init(void)
{
command_bind("server", NULL, (SIGNAL_FUNC) cmd_server);
command_bind("server connect", NULL, (SIGNAL_FUNC) cmd_server_connect);
command_bind("server add", NULL, (SIGNAL_FUNC) cmd_server_add);
command_bind("server remove", NULL, (SIGNAL_FUNC) cmd_server_remove);
command_bind_first("server", NULL, (SIGNAL_FUNC) server_command);
command_bind_first("disconnect", NULL, (SIGNAL_FUNC) server_command);
command_set_options("server add", "4 6 ssl +ssl_cert +ssl_pkey ssl_verify +ssl_cafile +ssl_capath auto noauto proxy noproxy -host -port");
signal_add("server looking", (SIGNAL_FUNC) sig_server_looking);
signal_add("server connecting", (SIGNAL_FUNC) sig_server_connecting);
signal_add("server connected", (SIGNAL_FUNC) sig_server_connected);
signal_add("server connect failed", (SIGNAL_FUNC) sig_connect_failed);
signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
signal_add("server quit", (SIGNAL_FUNC) sig_server_quit);
signal_add("server lag disconnect", (SIGNAL_FUNC) sig_server_lag_disconnected);
signal_add("server reconnect remove", (SIGNAL_FUNC) sig_server_reconnect_removed);
signal_add("server reconnect not found", (SIGNAL_FUNC) sig_server_reconnect_not_found);
signal_add("chat protocol unknown", (SIGNAL_FUNC) sig_chat_protocol_unknown);
}
/** Register all necessary signal handlers. */
void setup_signals(void)
{
struct sigaction act;
act.sa_handler = SIG_IGN;
act.sa_flags = 0;
sigemptyset(&act.sa_mask);
sigaddset(&act.sa_mask, SIGPIPE);
sigaddset(&act.sa_mask, SIGALRM);
#ifdef SIGWINCH
sigaddset(&act.sa_mask, SIGWINCH);
sigaction(SIGWINCH, &act, 0);
#endif
sigaction(SIGPIPE, &act, 0);
act.sa_handler = sigalrm_handler;
sigaction(SIGALRM, &act, 0);
signal_add(&sig_hup, sighup_callback, 0, SIGHUP);
signal_add(&sig_int, sigint_callback, 0, SIGINT);
signal_add(&sig_term, sigterm_callback, 0, SIGTERM);
signal_add(&sig_chld, sigchld_callback, 0, SIGCHLD);
}
/* Add a signal to an object.
* `oud` is the object index on the stack.
* `name` is the name of the signal.
* `ud` is the index of function to call when signal is emitted. */
void
luaH_object_add_signal(lua_State *L, gint oud,
const gchar *name, gint ud) {
luaH_checkfunction(L, ud);
lua_object_t *obj = lua_touserdata(L, oud);
gchar *origin = luaH_callerinfo(L);
debug("add " ANSI_COLOR_BLUE "\"%s\"" ANSI_COLOR_RESET
" on %p from " ANSI_COLOR_GREEN "%s" ANSI_COLOR_RESET,
name, obj, origin);
g_free(origin);
signal_add(obj->signals, name, luaH_object_ref_item(L, oud, ud));
}
void channels_query_init(void)
{
settings_add_bool("misc", "channel_sync", TRUE);
settings_add_int("misc", "channel_max_who_sync", 1000);
signal_add("server connected", (SIGNAL_FUNC) sig_connected);
signal_add("server disconnected", (SIGNAL_FUNC) sig_disconnected);
signal_add("channel joined", (SIGNAL_FUNC) sig_channel_joined);
signal_add("channel destroyed", (SIGNAL_FUNC) sig_channel_destroyed);
signal_add("chanquery mode", (SIGNAL_FUNC) event_channel_mode);
signal_add("chanquery who end", (SIGNAL_FUNC) event_end_of_who);
signal_add("chanquery ban end", (SIGNAL_FUNC) event_end_of_banlist);
signal_add("chanquery abort", (SIGNAL_FUNC) query_current_error);
}
int main(int argc,char **argv)
{
if(argc<3)
{
printf("usage:server [SERVER_IP] [SERVER_PORT]\n");
exit(0);
}
int port=atoi(argv[2]);
char *ip=argv[1];
struct sockaddr_in ser;
ser.sin_addr.s_addr=inet_addr(ip);
ser.sin_family=AF_INET;
ser.sin_port=htons(port);
int sockfd;
sockfd=socket(AF_INET,SOCK_STREAM,0);
int i=bind(sockfd,(struct sockaddr*)&ser,sizeof(ser));
if(i!=0)
{
printf("#BIND PORT ERROR#\n");
exit(0);
}
signal_add(SIGCHLD);
set_non_block(sockfd);
server_static_init(sockfd);
listen(sockfd,5);
int t;
for(i=0;i<PROCESS_NUM;i++)
{
t=fork();
if(t==0)
{
process();
exit(0);
}
else if(t<0)
{
printf("#fork error#");
exit(0);
}
else
{
fork_mark[fork_id]=t;
fork_id++;
}
}
while(1)
{
server_running_update();
}
}
void rawlog_init(void)
{
signal_rawlog = signal_get_uniq_id("rawlog");
settings_add_int("history", "rawlog_lines", 200);
read_settings();
signal_add("setup changed", (SIGNAL_FUNC) read_settings);
command_bind("rawlog", NULL, (SIGNAL_FUNC) cmd_rawlog);
command_bind("rawlog save", NULL, (SIGNAL_FUNC) cmd_rawlog_save);
command_bind("rawlog open", NULL, (SIGNAL_FUNC) cmd_rawlog_open);
command_bind("rawlog close", NULL, (SIGNAL_FUNC) cmd_rawlog_close);
}
void fe_ctcp_init(void)
{
signal_add("default ctcp msg", (SIGNAL_FUNC) ctcp_default_msg);
signal_add("ctcp msg ping", (SIGNAL_FUNC) ctcp_ping_msg);
signal_add("ctcp msg version", (SIGNAL_FUNC) ctcp_version_msg);
signal_add("ctcp msg time", (SIGNAL_FUNC) ctcp_time_msg);
signal_add("default ctcp reply", (SIGNAL_FUNC) ctcp_default_reply);
signal_add("ctcp reply ping", (SIGNAL_FUNC) ctcp_ping_reply);
}
void gui_context_nick_init(void)
{
signal_add("gui window context word", (SIGNAL_FUNC) sig_window_word);
signal_add("gui window context enter", (SIGNAL_FUNC) sig_window_enter);
signal_add("gui window context leave", (SIGNAL_FUNC) sig_window_leave);
signal_add("gui window context press", (SIGNAL_FUNC) sig_window_press);
signal_add("gui nicklist enter", (SIGNAL_FUNC) sig_nicklist_enter);
signal_add("gui nicklist leave", (SIGNAL_FUNC) sig_nicklist_leave);
}
void fe_server_init(void)
{
signal_add("server looking", (SIGNAL_FUNC) sig_server_looking);
signal_add("server connecting", (SIGNAL_FUNC) sig_server_connecting);
signal_add("server connected", (SIGNAL_FUNC) sig_server_connected);
signal_add("server connect failed", (SIGNAL_FUNC) sig_connect_failed);
signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
signal_add("server quit", (SIGNAL_FUNC) sig_server_quit);
}
void term_common_init(void)
{
const char *dummy;
#ifdef SIGWINCH
struct sigaction act;
#endif
settings_add_bool("lookandfeel", "colors", TRUE);
settings_add_bool("lookandfeel", "term_force_colors", FALSE);
settings_add_bool("lookandfeel", "mirc_blink_fix", FALSE);
force_colors = FALSE;
term_use_colors = term_has_colors() && settings_get_bool("colors");
#ifdef TERM_TRUECOLOR
settings_add_bool("lookandfeel", "colors_ansi_24bit", FALSE);
term_use_colors24 = term_has_colors() && settings_get_bool("colors_ansi_24bit");
#else
term_use_colors24 = FALSE;
#endif
read_settings();
if (g_get_charset(&dummy)) {
term_type = TERM_TYPE_UTF8;
term_set_input_type(TERM_TYPE_UTF8);
}
signal_add("beep", (SIGNAL_FUNC) term_beep);
signal_add("setup changed", (SIGNAL_FUNC) read_settings);
command_bind("resize", NULL, (SIGNAL_FUNC) cmd_resize);
command_bind("redraw", NULL, (SIGNAL_FUNC) cmd_redraw);
#ifdef SIGWINCH
sigemptyset (&act.sa_mask);
act.sa_flags = 0;
act.sa_handler = sig_winch;
sigaction(SIGWINCH, &act, NULL);
#endif
}
/* Bind a key for function */
void key_bind(gchar *id, gchar *data, gchar *description, gchar *key_default, SIGNAL_FUNC func)
{
KEYINFO_REC *info;
KEY_REC *rec;
g_return_if_fail(id != NULL);
g_return_if_fail(func != NULL);
/* create key info record */
info = key_info_find(id);
if (info == NULL)
{
g_return_if_fail(description != NULL);
info = g_new0(KEYINFO_REC, 1);
info->id = g_strdup(id);
info->description = g_strdup(description);
keyinfos = g_slist_append(keyinfos, info);
/* add the signal */
id = g_strconcat("key ", id, NULL);
signal_add(id, func);
g_free(id);
signal_emit("keyinfo created", 1, info);
}
if (key_default == NULL || *key_default == '\0')
{
/* just create a possible key command, don't bind it to any key yet */
return;
}
/* create/replace key record */
rec = g_hash_table_lookup(keys, key_default);
if (rec != NULL)
{
if (rec->data != NULL)
g_free(rec->data);
}
else
{
rec = g_new0(KEY_REC, 1);
info->keys = g_slist_append(info->keys, rec);
rec->key = g_strdup(key_default);
g_hash_table_insert(keys, rec->key, rec);
}
rec->info = info;
rec->data = data == NULL ? NULL : g_strdup(data);
}
void proxy_listen_init(void)
{
next_line = g_string_new(NULL);
proxy_clients = NULL;
proxy_listens = NULL;
read_settings();
signal_add("server incoming", (SIGNAL_FUNC) sig_incoming);
signal_add("server event", (SIGNAL_FUNC) sig_server_event);
signal_add("event connected", (SIGNAL_FUNC) event_connected);
signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
signal_add_first("event nick", (SIGNAL_FUNC) event_nick);
signal_add("message own_public", (SIGNAL_FUNC) sig_message_own_public);
signal_add("message own_private", (SIGNAL_FUNC) sig_message_own_private);
signal_add("message irc own_action", (SIGNAL_FUNC) sig_message_own_action);
signal_add("setup changed", (SIGNAL_FUNC) read_settings);
signal_add("proxy client dump", (SIGNAL_FUNC) sig_dump);
}
void servers_setup_init(void)
{
settings_add_str("server", "hostname", "");
settings_add_str("server", "nick", NULL);
settings_add_str("server", "user_name", NULL);
settings_add_str("server", "real_name", NULL);
settings_add_bool("proxy", "use_proxy", FALSE);
settings_add_str("proxy", "proxy_address", "");
settings_add_int("proxy", "proxy_port", 6667);
settings_add_str("proxy", "proxy_string", "CONNECT %s %d");
settings_add_str("proxy", "proxy_string_after", "");
settings_add_str("proxy", "proxy_password", "");
setupservers = NULL;
source_host_ip4 = source_host_ip6 = NULL;
old_source_host = NULL;
read_settings();
signal_add("setup changed", (SIGNAL_FUNC) read_settings);
signal_add("setup reread", (SIGNAL_FUNC) read_servers);
signal_add("irssi init read settings", (SIGNAL_FUNC) read_servers);
}
void fe_messages_init(void)
{
printnicks = g_hash_table_new((GHashFunc) g_direct_hash,
(GCompareFunc) g_direct_equal);
settings_add_bool("lookandfeel", "hilight_nick_matches", TRUE);
settings_add_bool("lookandfeel", "hilight_nick_matches_everywhere", FALSE);
settings_add_bool("lookandfeel", "emphasis", TRUE);
settings_add_bool("lookandfeel", "emphasis_replace", FALSE);
settings_add_bool("lookandfeel", "emphasis_multiword", FALSE);
settings_add_bool("lookandfeel", "emphasis_italics", FALSE);
settings_add_bool("lookandfeel", "show_nickmode", TRUE);
settings_add_bool("lookandfeel", "show_nickmode_empty", TRUE);
settings_add_bool("lookandfeel", "print_active_channel", FALSE);
settings_add_bool("lookandfeel", "show_quit_once", FALSE);
settings_add_bool("lookandfeel", "show_own_nickchange_once", FALSE);
signal_add_last("message public", (SIGNAL_FUNC) sig_message_public);
signal_add_last("message private", (SIGNAL_FUNC) sig_message_private);
signal_add_last("message own_public", (SIGNAL_FUNC) sig_message_own_public);
signal_add_last("message own_private", (SIGNAL_FUNC) sig_message_own_private);
signal_add_last("message join", (SIGNAL_FUNC) sig_message_join);
signal_add_last("message part", (SIGNAL_FUNC) sig_message_part);
signal_add_last("message quit", (SIGNAL_FUNC) sig_message_quit);
signal_add_last("message kick", (SIGNAL_FUNC) sig_message_kick);
signal_add_last("message nick", (SIGNAL_FUNC) sig_message_nick);
signal_add_last("message own_nick", (SIGNAL_FUNC) sig_message_own_nick);
signal_add_last("message invite", (SIGNAL_FUNC) sig_message_invite);
signal_add_last("message topic", (SIGNAL_FUNC) sig_message_topic);
signal_add("nicklist new", (SIGNAL_FUNC) sig_nicklist_new);
signal_add("nicklist remove", (SIGNAL_FUNC) sig_nicklist_remove);
signal_add("nicklist changed", (SIGNAL_FUNC) sig_nicklist_changed);
signal_add("nicklist host changed", (SIGNAL_FUNC) sig_nicklist_new);
signal_add("channel joined", (SIGNAL_FUNC) sig_channel_joined);
}
void statusbar_items_init(void)
{
settings_add_time("misc", "lag_min_show", "1sec");
settings_add_str("lookandfeel", "actlist_sort", "refnum");
settings_add_bool("lookandfeel", "actlist_names", FALSE);
settings_add_bool("lookandfeel", "actlist_prefer_window_name", FALSE);
statusbar_item_register("window", NULL, item_window_active);
statusbar_item_register("window_empty", NULL, item_window_empty);
statusbar_item_register("prompt", NULL, item_window_active);
statusbar_item_register("prompt_empty", NULL, item_window_empty);
statusbar_item_register("topic", NULL, item_window_active);
statusbar_item_register("topic_empty", NULL, item_window_empty);
statusbar_item_register("lag", NULL, item_lag);
statusbar_item_register("act", NULL, item_act);
statusbar_item_register("more", NULL, item_more);
statusbar_item_register("input", NULL, item_input);
/* activity */
activity_list = NULL;
signal_add("window activity", (SIGNAL_FUNC) sig_statusbar_activity_hilight);
signal_add("window destroyed", (SIGNAL_FUNC) sig_statusbar_activity_window_destroyed);
signal_add("window refnum changed", (SIGNAL_FUNC) sig_statusbar_activity_updated);
/* more */
more_visible = NULL;
signal_add("gui page scrolled", (SIGNAL_FUNC) sig_statusbar_more_updated);
signal_add("window changed", (SIGNAL_FUNC) sig_statusbar_more_updated);
signal_add_last("gui print text finished", (SIGNAL_FUNC) sig_statusbar_more_updated);
signal_add_last("command clear", (SIGNAL_FUNC) sig_statusbar_more_updated);
signal_add_last("command scrollback", (SIGNAL_FUNC) sig_statusbar_more_updated);
/* lag */
last_lag = 0; last_lag_unknown = FALSE;
signal_add("server lag", (SIGNAL_FUNC) sig_server_lag_updated);
signal_add("window changed", (SIGNAL_FUNC) lag_check_update);
signal_add("window server changed", (SIGNAL_FUNC) lag_check_update);
lag_timeout_tag = g_timeout_add(5000, (GSourceFunc) sig_lag_timeout, NULL);
/* input */
input_entries = g_hash_table_new((GHashFunc) g_str_hash,
(GCompareFunc) g_str_equal);
read_settings();
signal_add_last("setup changed", (SIGNAL_FUNC) read_settings);
}
void
timer_class_setup(lua_State *L)
{
static const struct luaL_Reg timer_methods[] =
{
LUA_CLASS_METHODS(timer)
{ "__call", luaA_timer_new },
{ NULL, NULL }
};
static const struct luaL_Reg timer_meta[] =
{
LUA_OBJECT_META(timer)
LUA_CLASS_META
{ "start", luaA_timer_start },
{ "stop", luaA_timer_stop },
{ "again", luaA_timer_again },
{ NULL, NULL },
};
luaA_class_setup(L, &timer_class, "timer", NULL,
(lua_class_allocator_t) timer_new, NULL, NULL,
luaA_class_index_miss_property, luaA_class_newindex_miss_property,
timer_methods, timer_meta);
luaA_class_add_property(&timer_class, "timeout",
(lua_class_propfunc_t) luaA_timer_set_timeout,
(lua_class_propfunc_t) luaA_timer_get_timeout,
(lua_class_propfunc_t) luaA_timer_set_timeout);
luaA_class_add_property(&timer_class, "started",
NULL,
(lua_class_propfunc_t) luaA_timer_get_started,
NULL);
signal_add(&timer_class.signals, "property::timeout");
signal_add(&timer_class.signals, "timeout");
}
void plugin_proxy_listen_init(PLUGIN_DATA *data)
{
proxy_data = data;
g_return_if_fail(proxy_data != NULL);
next_line = g_string_new(NULL);
/* start listening */
proxy_data->listen_handle = net_listen(&proxy_data->ip, &proxy_data->port);
if (proxy_data->listen_handle == -1)
{
printtext(NULL, NULL, MSGLEVEL_CLIENTERROR, "Listen failed");
return;
}
proxy_data->clients = NULL;
proxy_data->listen_tag = g_input_add(proxy_data->listen_handle, G_INPUT_READ,
(GInputFunction) sig_listen, proxy_data);
signal_add("server incoming", (SIGNAL_FUNC) sig_incoming);
signal_add("server event", (SIGNAL_FUNC) sig_server_event);
signal_add("server connected", (SIGNAL_FUNC) sig_server_connected);
signal_add("server disconnected", (SIGNAL_FUNC) sig_server_disconnected);
}
void irc_completion_init(void)
{
settings_add_str("completion", "completion_char", ":");
settings_add_bool("completion", "completion_auto", FALSE);
settings_add_int("completion", "completion_keep_publics", 180);
settings_add_int("completion", "completion_keep_ownpublics", 360);
settings_add_int("completion", "completion_keep_privates", 10);
settings_add_bool("completion", "expand_escapes", FALSE);
complete_tag = g_timeout_add(1000, (GSourceFunc) nick_completion_timeout, NULL);
signal_add("complete word", (SIGNAL_FUNC) sig_complete_word);
signal_add("complete command msg", (SIGNAL_FUNC) sig_complete_msg);
signal_add("event privmsg", (SIGNAL_FUNC) event_privmsg);
signal_add("command msg", (SIGNAL_FUNC) cmd_msg);
signal_add("nicklist remove", (SIGNAL_FUNC) sig_nick_removed);
signal_add("nicklist changed", (SIGNAL_FUNC) sig_nick_changed);
signal_add("send text", (SIGNAL_FUNC) event_text);
signal_add("server disconnected", (SIGNAL_FUNC) completion_deinit_server);
signal_add("channel destroyed", (SIGNAL_FUNC) completion_deinit_channel);
}
void textbuffer_commands_init(void)
{
command_bind("clear", NULL, (SIGNAL_FUNC) cmd_clear);
command_bind("window scroll", NULL, (SIGNAL_FUNC) cmd_window_scroll);
command_bind("scrollback", NULL, (SIGNAL_FUNC) cmd_scrollback);
command_bind("scrollback clear", NULL, (SIGNAL_FUNC) cmd_scrollback_clear);
command_bind("scrollback goto", NULL, (SIGNAL_FUNC) cmd_scrollback_goto);
command_bind("scrollback home", NULL, (SIGNAL_FUNC) cmd_scrollback_home);
command_bind("scrollback end", NULL, (SIGNAL_FUNC) cmd_scrollback_end);
command_bind("scrollback redraw", NULL, (SIGNAL_FUNC) cmd_scrollback_redraw);
command_bind("scrollback status", NULL, (SIGNAL_FUNC) cmd_scrollback_status);
command_set_options("clear", "all");
signal_add("away mode changed", (SIGNAL_FUNC) sig_away_changed);
}
EVQ_API int
evq_add (struct event_queue *evq, struct event *ev)
{
const unsigned int ev_flags = ev->flags;
struct win32thr *wth = &evq->head;
ev->wth = wth;
if (ev_flags & EVENT_SIGNAL)
return signal_add(evq, ev);
if (ev_flags & EVENT_WINMSG) {
evq->win_msg = ev;
evq->nevents++;
return 0;
}
if ((ev_flags & (EVENT_SOCKET | EVENT_SOCKET_ACC_CONN)) == EVENT_SOCKET
&& evq->iocp.h) {
if (!CreateIoCompletionPort((HANDLE) ev->fd, evq->iocp.h, 0, 0)
&& GetLastError() != ERROR_INVALID_PARAMETER) /* already assosiated */
return -1;
ev->flags |= EVENT_AIO;
evq->iocp.n++;
evq->nevents++;
if (pSetFileCompletionNotificationModes
&& pSetFileCompletionNotificationModes((HANDLE) ev->fd, 3))
ev->flags |= EVENT_AIO_SKIP;
win32iocp_set(ev, ev_flags);
return 0;
}
while (wth->n >= NEVENT - 1)
if (!(wth = wth->next)) break;
if (wth)
win32thr_sleep(wth);
else {
wth = win32thr_init(evq);
if (!wth) return -1;
}
return win32thr_add(wth, ev);
}
EVQ_API int
evq_add (struct event_queue *evq, struct event *ev)
{
unsigned int npolls;
ev->evq = evq;
if (ev->flags & EVENT_SIGNAL)
return signal_add(evq, ev);
npolls = evq->npolls;
if (npolls >= evq->max_polls) {
const unsigned int n = 2 * evq->max_polls;
void *p;
if (!(p = realloc(evq->events, n * sizeof(void *))))
return -1;
evq->events = p;
if (!(p = realloc(evq->fdset, n * sizeof(struct pollfd))))
return -1;
evq->fdset = p;
evq->max_polls = n;
}
{
struct pollfd *fdp = &evq->fdset[npolls];
int event = 0;
if (ev->flags & EVENT_READ)
event = POLLIN;
if (ev->flags & EVENT_WRITE)
event |= POLLOUT;
fdp->fd = ev->fd;
fdp->events = event;
fdp->revents = 0;
}
evq->npolls++;
evq->events[npolls] = ev;
ev->index = npolls;
evq->nevents++;
return 0;
}
static void cmd_wjoin_pre(const char *data)
{
GHashTable *optlist;
char *nick;
void *free_arg;
if (!cmd_get_params(data, &free_arg, 1 | PARAM_FLAG_OPTIONS |
PARAM_FLAG_UNKNOWN_OPTIONS | PARAM_FLAG_GETREST,
"join", &optlist, &nick))
return;
if (g_hash_table_lookup(optlist, "window") != NULL) {
signal_add("channel created",
(SIGNAL_FUNC) signal_channel_created_curwin);
}
cmd_params_free(free_arg);
}
int main (int argc, char *argv[])
{
int socketDesc;
int clientSock = -1;
unsigned int *rfidData;
LOGMESSAGE("This is rfidaemon\n");
rfidInit();
//Handler für das Beenden des Prozesses anmelden
signal_add(SIGTERM, shutdownProcess);
signal(SIGPIPE, SIG_IGN);
//socketDesc = createSocket();
while (1)
{
/*
//Warten, bis Verbindung mit Socket aufgebaut wurde
if (clientSock < 0){
clientSock = waitForConnection(socketDesc);
}
*/
//Prüfen, ob ein gültiges Paket empfangen wurde
if (rfidCheck(&rfidData) == 0) {
char dataString[13*2+2] = "";
int i;
//Daten ausleses
for (i=0; i<13; i++){
char tmp[10];
sprintf(tmp, "%02x", rfidData[i]);
strcat(dataString, tmp);
}
strcat(dataString, "\n");
/*
if (write(clientSock, dataString, strlen(dataString))< 0){
LOGMESSAGE("Client disconnected\n");
close(clientSock);
clientSock = -1;
}
*/
sendPostRequest(SOURCENAME, dataString);
}
sleep(200000);
}
}
void
master_mode(const char *master_port, const char *start_script)
{
struct sockaddr_in dst;
int fd;
LIST_INIT(&active_peers);
LIST_INIT(&inactive_peers);
event_init();
if (parse_sockaddr_in(master_port, &dst))
errx(1, "Could not parse addr/port");
fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (fd == -1)
err(1, "Could not create socket");
#ifdef FIOCLEX
if (ioctl(fd, FIOCLEX, NULL) == -1)
err(1, "Could not set close-on-exec flag");
#endif
if (bind(fd, (struct sockaddr *)&dst, sizeof(dst)) == -1)
err(1, "Could not bind socket");
if (listen(fd, 5) == -1)
err(1, "Could not listen on socket");
event_add(&listen_event, fd, 0, 1, listen_handler, NULL);
listen_event_socket = fd;
if (start_script) {
signal_add(&child_event, SIGCHLD, child_handler);
if ((child_pid = vfork()) == 0) {
execlp(start_script, start_script, (char *)NULL);
_exit(255);
}
if (child_pid == -1)
err(1, "Could not fork start script");
} else {
clients_started = 1;
}
event_dispatch();
(void)close(fd);
}
