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