int autoconnect(fd_set *master, int *fdmax, servlist *serv) // XXX broken in the face of asynch nl [I have forgotten what was meant by this; I'm not aware of anything broken about this function] { servlist *curr=serv; if(!curr) return(0); #if ASYNCH_NL char cstr[36+strlen(serv->name)+strlen(serv->portno)]; sprintf(cstr, "Connecting to %s on port %s...", serv->name, serv->portno); nl_list *list=irc_connect(serv->name, serv->portno); if(!list) return(autoconnect(master, fdmax, serv->next)); add_to_buffer(0, STA, QUIET, 0, false, cstr, "auto: "); list->reconn_b=0; list->autoent=serv; #else /* ASYNCH_NL */ char cstr[36+strlen(serv->name)+strlen(serv->portno)]; sprintf(cstr, "Connecting to %s on port %s...", serv->name, serv->portno); add_to_buffer(0, STA, QUIET, 0, false, cstr, "auto: "); int serverhandle=irc_connect(serv->name, serv->portno, master, fdmax); if(serverhandle) { bufs=(buffer *)realloc(bufs, ++nbufs*sizeof(buffer)); cbuf=nbufs-1; init_buffer(cbuf, SERVER, serv->name, buflines); bufs[cbuf].handle=serverhandle; bufs[cbuf].nick=strdup(serv->nick); bufs[cbuf].autoent=serv; if(serv) bufs[cbuf].ilist=n_dup(serv->igns); bufs[cbuf].server=cbuf; bufs[cbuf].conninpr=true; add_to_buffer(cbuf, STA, QUIET, 0, false, cstr, "auto: "); redraw_buffer(); } #endif /* ASYNCH_NL */ autoconnect(master, fdmax, serv->next); return(1); }
void *ircbot_connect() { char *list[] = { "IRC Host", "IRC Port", "IRC Bot Nick" }; ConfigArrayPtr settings; if( ircbot_prepare() ) { sysconfig.irc_enabled = false; sysconfig.irc_session = NULL; goto EXIT; } // Initiate the IRC server connection settings = ListSettings( list ); if ( irc_connect( sysconfig.irc_session, settings[0].string_value, (int)settings[1].num_value, 0, settings[2].string_value, settings[2].string_value, settings[2].string_value ) ) { sysconfig.irc_enabled = false; sysconfig.irc_session = NULL; error("Connecting to IRC Network"); free( settings ); goto EXIT; } free( settings ); #if MULTI_THREAD_SUPPORT irc_run( sysconfig.irc_session ); #endif EXIT: return NULL; }
/* ==================== IRC_ConnectSession Connects a session handle created by IRC_CreateSession to an IRC server. Returns 0 on success, -1 on invalid handle, error code on libircclient error. ==================== */ int IRC_ConnectSession(int handle, const char *server, unsigned short port, const char *server_password, const char *nick, const char *username, const char *realname) { irc_session_t *s; int err; if(!IS_VALID_IRC_SESSION(handle)) { IRC_Printf("Attempted to connect an invalid session %i\n", handle); return -1; } if(IRC_SessionIsConnected(handle)) IRC_DisconnectSession(handle, "Changing server"); s = &irc_sessions[handle]; strlcpy(s->server, server, sizeof(s->server)); strlcpy(s->nick, nick, sizeof(s->nick)); strlcpy(s->username, username, sizeof(s->username)); strlcpy(s->realname, realname, sizeof(s->realname)); if(server_password) strlcpy(s->password, server_password, sizeof(s->password)); else memset(s->password, 0, sizeof(s->password)); irc_disconnect(s->session); if(irc_connect(s->session, server, port, server_password, nick, username, realname)) { err = irc_errno(s->session); IRC_Printf("Connection error on session %i: %s\n", handle, irc_strerror(err)); return err; } return 0; }
int main(int argc, char **argv) { char* server, *port; if (argc != 3) { printf("Usage: %s <server> <port>\n", argv[0]); exit(EXIT_FAILURE); } server = argv[1]; /* The IRC server */ port = argv[2]; /* The IRC server port */ /* Bind message commands to custom functions */ irc_bind_command("!op", (Callback) give_op); irc_bind_command("!deop", (Callback) take_op); irc_bind_command("!voice", (Callback) give_voice); irc_bind_command("!devoice", (Callback) take_voice); /* Connect, login and join the configured channel */ irc_connect(server, port); irc_login(CONF_NICK, "Circus", "Circus IRC bot"); irc_join(CONF_CHAN); /* Start listening to events. * This method blocks until a quit signal is received */ irc_listen(); /* Send quit message and close connection */ irc_quit("Bye"); irc_disconnect(); return 0; }
bool ServerState::connect(Server &server) { const ServerInfo &info = server.info(); const ServerIdentity &identity = server.identity(); const char *password = info.password.empty() ? nullptr : info.password.c_str(); std::string host = info.host; int code; // libircclient requires # for SSL connection if (info.ssl) { host.insert(0, 1, '#'); } if (info.ipv6) { code = irc_connect6(server.session(), host.c_str(), info.port, password, identity.nickname.c_str(), identity.username.c_str(), identity.realname.c_str()); } else { code = irc_connect(server.session(), host.c_str(), info.port, password, identity.nickname.c_str(), identity.username.c_str(), identity.realname.c_str()); } return code == 0; }
int main(int argc, char **argv) { char* server, *port; if (argc != 3) { printf("Usage: %s <server> <port>\n", argv[0]); exit(EXIT_FAILURE); } server = argv[1]; /* The IRC server */ port = argv[2]; /* The IRC server port */ /* Bind IRC event to custom functions. * All bindable events are defined in codes.h */ irc_bind_event(ERR_NICKNAMEINUSE, (Callback) on_nick_in_use); irc_bind_event(ERROR, (Callback) on_error); irc_bind_event(JOIN, (Callback) on_join); irc_bind_event(ALL, (Callback) on_message); /* Connect, login and join the configured channel */ irc_connect(server, port); irc_login(CONF_NICK, "Circus", "Circus IRC bot"); irc_join(CONF_CHAN); /* Start listening to events. * This method blocks until a quit signal is received */ irc_listen(); /* Send quit message and close connection */ irc_quit("Bye"); irc_disconnect(); return 0; }
int wxLIRCCSession::Connect( const wxString& server, unsigned short port, const wxString& server_password, const wxString& nickname, const wxString& username, const wxString& realname ) { m_port = port; m_nick = nickname.mb_str(); m_server = server.mb_str(); username.IsEmpty() ? m_user = 0 : m_user = username.mb_str(); realname.IsEmpty() ? m_name = 0 : m_user = realname.mb_str(); server_password.IsEmpty() ? m_svrpwd = 0 : m_svrpwd = server_password.mb_str(); m_eState = CONNECTING; wxLogDebug("<wxLIRCCSession::Connect> Connecting"); int retcode = irc_connect( this->handle, m_server, port, m_svrpwd, m_nick, m_user, m_name ); if ( retcode == 0 ) { m_eState = CONNECTED; wxLogDebug("<wxLIRCCSession::Connect> Connected"); } else { m_eState = DISCONNECTED; wxLogDebug("<wxLIRCCSession::Connect> Disconnected (retcode = %i)", retcode ); } return retcode; }
int main(int argc, char *argv[]) { Irc freenode; struct pollfd pfd[4]; int i, ready, murm_listenfd = -1; initialize(argc, argv); for (i = 0; i < SIZE(pfd); i++) { pfd[i].fd = -1; pfd[i].events = POLLIN; } if (add_murmur_callbacks(cfg.murmur_port)) pfd[MURM_LISTEN].fd = murm_listenfd = sock_listen(LOCALHOST, CB_LISTEN_PORT_S); else fprintf(stderr, "Could not connect to Murmur\n"); if ((pfd[MPD].fd = mpdfd = mpd_connect(cfg.mpd_port)) < 0) fprintf(stderr, "Could not connect to MPD\n"); // Connect to server and set IRC details if (!(freenode = irc_connect(cfg.server, cfg.port))) exit_msg("Irc connection failed"); pfd[IRC].fd = get_socket(freenode); set_nick(freenode, cfg.nick); set_user(freenode, cfg.user); for (i = 0; i < cfg.channels_set; i++) join_channel(freenode, cfg.channels[i]); while ((ready = poll(pfd, SIZE(pfd), TIMEOUT)) > 0) { // Keep reading & parsing lines as long the connection is active and act on any registered actions found if (pfd[IRC].revents & POLLIN) while (parse_irc_line(freenode) > 0); if (pfd[MURM_LISTEN].revents & POLLIN) if ((pfd[MURM_ACCEPT].fd = accept_murmur_connection(murm_listenfd)) > 0) pfd[MURM_LISTEN].fd = -1; // Stop listening for connections if (pfd[MURM_ACCEPT].revents & POLLIN) { if (!listen_murmur_callbacks(freenode, pfd[MURM_ACCEPT].fd)) { pfd[MURM_ACCEPT].fd = -1; pfd[MURM_LISTEN].fd = murm_listenfd; // Start listening again for Murmur connections } } if (pfd[MPD].revents & POLLIN) if (!print_song(freenode, default_channel(freenode))) pfd[MPD].fd = mpdfd = mpd_connect(cfg.mpd_port); } // If we reach here, it means we got disconnected from server. Exit with error (1) if (ready == -1) perror("poll"); else fprintf(stderr, "%d minutes passed without getting a message, exiting...\n", TIMEOUT / 1000 / 60); quit_server(freenode, cfg.quit_msg); cleanup(); return 1; }
static void irc_disconnect(void) { close(irc_fd); fprintf(stderr, "fifoirc: disconnection from %s\n", server); if(reconnect) irc_connect(); else exit(EXIT_FAILURE); }
int main (int argc, char **argv) { irc_callbacks_t callbacks; irc_ctx_t ctx; irc_session_t * s; if ( argc != 4 ) { printf ("Usage: %s <server> <nick> <channel>\n", argv[0]); return 1; } memset (&callbacks, 0, sizeof(callbacks)); callbacks.event_connect = event_connect; callbacks.event_join = event_join; callbacks.event_nick = dump_event; callbacks.event_quit = dump_event; callbacks.event_part = dump_event; callbacks.event_mode = dump_event; callbacks.event_topic = dump_event; callbacks.event_kick = dump_event; callbacks.event_channel = event_channel; callbacks.event_privmsg = event_privmsg; callbacks.event_notice = dump_event; callbacks.event_invite = dump_event; callbacks.event_umode = dump_event; callbacks.event_ctcp_rep = dump_event; callbacks.event_ctcp_action = dump_event; callbacks.event_unknown = dump_event; callbacks.event_numeric = event_numeric; callbacks.event_dcc_chat_req = irc_event_dcc_chat; callbacks.event_dcc_send_req = irc_event_dcc_send; s = irc_create_session (&callbacks); if ( !s ) { printf ("Could not create session\n"); return 1; } ctx.channel = argv[3]; ctx.nick = argv[2]; irc_set_ctx (s, &ctx); if ( irc_connect (s, argv[1], 6667, 0, argv[2], 0, 0) ) { printf ("Could not connect: %s\n", irc_strerror (irc_errno(s))); return 1; } irc_run (s); return 1; }
void dazeus::Server::connectToServer() { printf("Connecting to server: %s\n", toString(this).c_str()); assert( !config_->network->nickName.length() == 0 ); irc_callbacks_t callbacks; memset(&callbacks, 0, sizeof(irc_callbacks_t)); callbacks.event_connect = irc_callback; callbacks.event_nick = irc_callback; callbacks.event_quit = irc_callback; callbacks.event_join = irc_callback; callbacks.event_part = irc_callback; callbacks.event_mode = irc_callback; callbacks.event_umode = irc_callback; callbacks.event_topic = irc_callback; callbacks.event_kick = irc_callback; callbacks.event_channel = irc_callback; #if LIBIRC_VERSION_HIGH > 1 || LIBIRC_VERSION_LOW >= 6 callbacks.event_channel_notice = irc_callback; #endif callbacks.event_privmsg = irc_callback; callbacks.event_notice = irc_callback; callbacks.event_invite = irc_callback; callbacks.event_ctcp_req = irc_callback; callbacks.event_ctcp_rep = irc_callback; callbacks.event_ctcp_action = irc_callback; callbacks.event_unknown = irc_callback; callbacks.event_numeric = irc_eventcode_callback; irc_ = (void*)irc_create_session(&callbacks); if(!irc_) { std::cerr << "Couldn't create IRC session in Server."; abort(); } irc_set_ctx(IRC, this); assert( config_->network->nickName.length() != 0 ); std::string host = config_->host; if(config_->ssl) { #if defined(LIBIRC_OPTION_SSL_NO_VERIFY) host = "#" + host; if(!config_->ssl_verify) { std::cerr << "Warning: connecting without SSL certificate verification." << std::endl; irc_option_set(IRC, LIBIRC_OPTION_SSL_NO_VERIFY); } #else std::cerr << "Error: Your version of libircclient does not support SSL. Failing connection." << std::endl; slotDisconnected(); return; #endif } irc_connect(IRC, host.c_str(), config_->port, config_->network->password.c_str(), config_->network->nickName.c_str(), config_->network->userName.c_str(), config_->network->fullName.c_str()); }
void* irc_thread_net(void *data) { irc_thread_data *self = (irc_thread_data*)data; irc_callbacks_t callbacks; irc_ctx_t ctx; irc_session_t *irc_s; void *socket = zmq_socket(self->d.context, ZMQ_PUSH); // "server" from irc -> tun int ret = zmq_connect(socket, "inproc://#irc_to_#tun"); if (ret) { irc_debug(self, "(irc_thread_net) error when creating IPC socket - %s", zmq_strerror(errno)); goto exit; } memset (&callbacks, 0, sizeof(callbacks)); callbacks.event_connect = event_connect; callbacks.event_join = event_join; callbacks.event_privmsg = event_message; callbacks.event_channel = event_message; ctx.channel = strdup(self->chan); ctx.nick = malloc(sizeof(char)*512); snprintf(ctx.nick, 511, self->nick, rand()); ctx.self = self; ctx.buffer = malloc(sizeof(char)*MTU*4); ctx.data = socket; // WE ARE PASSING A NON-THREAD-SAFE SOCKET HERE! </redwarning> irc_s = irc_create_session(&callbacks); if (!irc_s) { irc_debug(self, "error when creating irc_session"); goto exit; } self->irc_s = irc_s; irc_debug(self, "created irc_session!"); irc_set_ctx(self->irc_s, &ctx); if (irc_connect (self->irc_s, self->server, 6667, self->pass, ctx.nick, "ipoirc", "IP over IRC - http://github.com/EXio4/IPoIRC")) { irc_debug(self, "error when connecting to irc (%s)", irc_strerror(irc_errno(self->irc_s))); goto exit; } sleep(1); // wait for the network to answer THIS SHOULD BE DONE IN A RIGHT WAY! int rc = irc_run(self->irc_s); (void) rc; exit: if (self->irc_s) { irc_destroy_session(self->irc_s); } if (socket) { zmq_close(socket); } pthread_exit(NULL); }
int main(int argc, const char **argv) { base_eventloop = mowgli_eventloop_create (); irc_connect(argv[1], argv[2]); mowgli_eventloop_run (base_eventloop); return EXIT_SUCCESS; }
int main(int argc, char **argv) { int socketfd, n; char in[BUF+1], out[BUF+1], c[512]; char *pos, *action; if(argc != 5) { printf("Usage: %s <address> <port> <nick> <owner>\n", argv[0]); exit(1); } else if(atoi(argv[2]) < 1 || atoi(argv[2]) > 50000) { printf("Invalid port specified.\n"); exit(1); } else if(irc_connect(argv[1], atoi(argv[2]), &socketfd) == 0) { printf("Failed to connect to %s.\n", argv[1]); exit(1); } nick = argv[3]; owner = argv[4]; if(strlen(nick)>48) { printf("Error: irc bot nickname too long\n"); exit(1); } if(strlen(owner)>48) { printf("Error: bot owner nickname too long\n"); exit(1); } /* write to buffer */ sprintf(c, "NICK %s\r\n", nick); irc_send(socketfd, c); sprintf(c, "USER %s %s %s :%s\r\n", nick, nick, nick, nick); irc_send(socketfd, c); /* do the service jobs */ if(join_channels(socketfd, "./owners.log") == 2) { return 1; } while(1) { in[0] = 0; n = irc_read(socketfd, in); if (n > 0) { char *str = process_string(in, n); if(strncmp(str, "0", 1)!=0) { irc_send(socketfd, str); } if(strncmp(str, "QUIT", 4)==0) { break; } } // if(n > 0) } // while(1) return 0; }
static int sslconnect_hook(int argc, char *argv[]) { int buf; if (argc == 1) { cio_out("current server is: %s\n", server_name != NULL ? server_name : "(none)"); return 0; } if (argc < 3) { irc_connect(6697, argv[1], 1); } else { buf = atoi(argv[2]); irc_connect(buf, argv[1], 1); } return 0; }
bool IRC::start() { if(IRC::_sessionServerMap.size() == 0) { std::cout << "IRC::start() empty server list - skipping" << std::endl; return true; } _run = true; irc_session_t* session; ConfigHandler::IRCOptions_Server* options; int32_t rc; uint_fast8_t failCounter = 0; // 255 should be enough std::thread t; std::map<irc_session_t*, ConfigHandler::IRCOptions_Server>::iterator it; for(it = IRC::_sessionServerMap.begin(); it !=IRC::_sessionServerMap.end(); it++) { session = it->first; options = &it->second; std::cout << "IRC: connecting to " << options->address << std::endl; // add # for ssl connection // todo add option std::string addr = "#" + options->address; //rc = irc_connect(session, addr.c_str(), options->port, options->password.c_str(), options->nickName.c_str(), options->userName.c_str(), options->realName.c_str()); rc = irc_connect(session, options->address.c_str(), options->port, /*options->password.c_str()*/ NULL, options->nickName.c_str(), options->userName.c_str(), options->realName.c_str()); if(rc) // rc != 0 { std::cerr << "IRC::start() connecting to " << options->address << " failed - code: " << rc << std::endl; failCounter++; } else { //std::cerr << "IRC::start() connecting to " << options->address << " seems ok - code: " << rc << std::endl; _ircEventThread = std::thread( &IRC::ircEventLoop, this, session); // for now only one server! break; } } // check if every server failed to connect if( failCounter == IRC::_sessionServerMap.size()) return false; return true; }
int main(int argc, char *argv[]) { // Compile some regexes. if (regcomp(&new_pr_regex, NEW_PR_PATTERN, REG_EXTENDED)) { fprintf(stderr, "Failed to compile regex.\n"); return 1; } // Initialize SQLite gunk. int retval; retval = sqlite3_open(DATABASE_NAME, &db); if (retval) { fprintf(stderr, "Failed to open database: %s\n", sqlite3_errmsg(db)); return 1; } retval = sqlite3_exec(db, INITIALIZE_DB, 0, 0, 0); if (retval) { fprintf(stderr, "Failed to initialize database: %s\n", sqlite3_errmsg(db)); return 1; } // Kick off the IRC connection. char buf[BUF_LEN]; struct ircbuf ircbuf; ircbuf_init(&ircbuf, buf, BUF_LEN); int fd = irc_connect(IRC_HOST, IRC_PORT); if (fd < 0) { fprintf(stderr, "Failed to open connection.\n"); return 1; } irc_nick(fd, IRC_NICK, NULL); irc_join(fd, IRC_CHANNEL); char *line; while ((line = irc_getline(fd, &ircbuf))) { printf("%s\n", line); struct ircmsg msg; irc_parseline(line, &msg); if (!dispatch_handler(fd, &msg)) return 2; } return 0; }
void Kommunikater::commitServer() { callbacks.event_connect = event_connect; callbacks.event_channel = event_channel; session = irc_create_session (&callbacks); irc_set_ctx (session, &ctx); irc_option_set (session, LIBIRC_OPTION_STRIPNICKS); irc_connect (session, iam.server, 6667, 0, iam.nick, 0, 0); state.session = session; if(irc_run (session) && !state.stop) printf ("Could not connect or I/O error"); }
void init_conf (irc_t * irc, FILE * conf) { char *servname = NULL, *servport = NULL, *line = NULL, *tok = NULL, ch = 0; int state = 0; do { line = getln(conf); ch = 0; tok = NULL; if (line != NULL) tok = strtok(line, " :"); if (tok != NULL) { if (strcmp(tok, "") == 0) tok = NULL; if (tok != NULL) ch = tok[0]; } if (ch == '{') { state = 1; } else if (ch == '}') { state = 0; } else if (state == 0 && tok != NULL) { servname = tok; servport = strtok(NULL, " :"); if ( irc_connect(irc, servname, servport) < 0 ) { fprintf(stderr, "Connection to %s:%sfailed.\n", servname, servport); } else { if ( irc_login(irc, BOTNAME) < 0 ) { fprintf(stderr, "Couldn't log in.\n"); } } } else if (state == 1 && ch == '#') { char *chan = malloc(strlen(tok)+1); strcpy(chan, tok); irc_join(irc, chan); } if (line != NULL) { free(line); } } while (line != NULL); }
int main(int argc, char *argv[]) { struct sigaction sa; g_type_init(); notify_info.argv = argv; init_preferences(argc, argv); /* Fork when wanted */ if (prefs.fork) daemonize(); log_init(); g_log_set_default_handler(notify_log, NULL); loop = g_main_loop_new(NULL, FALSE); g_message(PACKAGE_STRING " started"); /* Fire up listening sockets */ if (!start_listener()) { cleanup(); exit(EXIT_FAILURE); } /* Connect to IRC */ irc_connect(NULL); /* Signal handler */ ns_open_signal_pipe(); sa.sa_handler = ns_sighandler; sigfillset(&sa.sa_mask); sa.sa_flags = SA_RESTART; sigaction(SIGINT, &sa, NULL); sigaction(SIGTERM, &sa, NULL); sigaction(SIGQUIT, &sa, NULL); sigaction(SIGHUP, &sa, NULL); g_main_loop_run(loop); cleanup(); }
void network_connect(struct network *net) { struct channel *tmp; irc_connect(net); if (net->close_network) return ; irc_nick(net); network_write_nick(net); irc_user(net); network_write_realname(net); if (net->password) irc_pass(net); network_foreach_channel(net, tmp) irc_join(net, tmp->name); network_write_joined(net); }
int main (int argc, char **argv) { irc_callbacks_t callbacks; irc_ctx_t ctx; irc_session_t * s; if ( argc != 4 ) { printf ("Usage: %s <server> <nick> <channel>\n", argv[0]); return 1; } memset (&callbacks, 0, sizeof(callbacks)); callbacks.event_connect = event_connect; callbacks.event_join = event_join; callbacks.event_channel = event_channel; callbacks.event_numeric = event_numeric; s = irc_create_session (&callbacks); if ( !s ) { printf ("Could not create session\n"); return 1; } ctx.channel = argv[3]; ctx.nick = argv[2]; irc_set_ctx (s, &ctx); if ( irc_connect (s, argv[1], 6667, 0, argv[2], 0, 0) ) { printf ("Could not connect: %s\n", irc_strerror (irc_errno(s))); return 1; } irc_run (s); return 1; }
IRCSession::IRCSession(char const* servername, unsigned int port, char const* password, const char* nick, const char* username, const char* realname) : session{nullptr} { session = irc_create_session(&IRC::callbacks); if (session == nullptr) throw std::runtime_error{"Could not create IRC session."}; irc_option_set( session, LIBIRC_OPTION_STRIPNICKS ); if (irc_connect(session, servername, port, password, nick, username, realname)) throw std::runtime_error{"Could not initiate connection to server."}; IRC::session_map[session] = this; }
static bool tryconnect(void) { struct srvlist_s *s = g_srvlist; while (s) { irc_set_server(g_irc, s->host, s->port); D("trying '%s:%"PRIu16"'", irc_get_host(g_irc), irc_get_port(g_irc)); if (!irc_set_ssl(g_irc, s->ssl) && s->ssl) C("failed to enable SSL"); if (irc_connect(g_irc)) return true; s = s->next; } return false; }
int irc_exec(char *hostname, int port, char *channel) { int fd; int nb; char *buff; pthread_t tid; fd = irc_connect(hostname, port); if (fd == -1) return 0; nb = pthread_create(&tid, NULL, irc_handle_activity, &fd); if (nb != 0) { sock_close(fd); return 0; } /* join channel */ usleep(IRC_JOINDELAY * 1000000); nb = strlen(channel) + 8; buff = calloc(nb, sizeof(char)); sprintf(buff, "JOIN %s\r\n", channel); send(fd, buff, strlen(buff), 0); free(buff); /* terminal input to IRC server */ buff = calloc(IRC_TERMWIDTH, sizeof(char)); while (fgets(buff, IRC_TERMWIDTH, stdin) != NULL) { send(fd, buff, strlen(buff) - 1, 0); send(fd, "\r\n", 2, 0); } free(buff); /* IRC disconnect */ irc_close(fd); pthread_join(tid, NULL); return 1; }
/* ==================== IRC_ReconnectSession Reconnects the session to the last server it connected to. Returns 0 on success, -1 on invalid handle, error code on libircclient error. ==================== */ int IRC_ReconnectSession(int handle) { irc_session_t *s; int err; if(!IS_VALID_IRC_SESSION(handle)) { IRC_Printf("Attempted to reconnect an invalid session %i\n", handle); return -1; } if(IRC_SessionIsConnected(handle)) IRC_DisconnectSession(handle, "Reconnecting"); s = &irc_sessions[handle]; irc_disconnect(s->session); if(irc_connect(s->session, s->server, s->port, s->password, s->nick, s->username, s->realname)) { err = irc_errno(s->session); IRC_Printf("Connection error on session %i: %s\n", handle, irc_strerror(err)); return err; } return 0; }
std::thread Twitch::Connect( const std::string &user, const std::string &password ) { return std::thread( [this, user, password] { this->user = user; this->channel = "#" + user; irc_callbacks_t callbacks; memset( &callbacks, 0, sizeof( callbacks ) ); callbacks.event_connect = event_connect; callbacks.event_channel = event_channel; callbacks.event_numeric = event_numeric; session = irc_create_session( &callbacks ); if ( !session ) { OnError( -1, "Failed to create IRC session" ); return; } TwitchContext *ctx = new TwitchContext(); ctx->twitch = this; irc_set_ctx( session, ctx ); irc_option_set( session, LIBIRC_OPTION_STRIPNICKS ); status = TWITCH_CONNECTING; if ( irc_connect( session, "irc.chat.twitch.tv", 6667, password.c_str(), user.c_str(), user.c_str(), user.c_str() ) ) { OnError( irc_errno( session ), irc_strerror( irc_errno( session ) ) ); status = TWITCH_DISCONNECTED; return; } if ( irc_run( session ) ) { OnError( irc_errno( session ), irc_strerror( irc_errno( session ) ) ); status = TWITCH_DISCONNECTED; return; } } ); }
int establish_connection() { /* For connecting */ char *hostname, *port; /* For introduction purposes */ char *nickname, *username, *realname; hostname = getconf("server", NULL); port = getconf("port", "6667"); nickname = getconf("nickname", NULL); username = getconf("username", NULL); realname = getconf("realname", NULL); if (!hostname || !nickname || !username || !realname) { printlog("You are missing some variables from the configuration file, " "please check the configuration file for the missing values of: %s%s%s%s%s%s%s", !hostname ? "server" : "", !hostname ? " " : "", !nickname ? "nickname" : "", !nickname ? " " : "", !username ? "username" : "", !username ? " " : "", !realname ? "realname" : ""); exit(1); } if (irc_connect(hostname, atoi(port))) { /* If we connected, lets introduce ourselves to the server */ /* Only copy the nickname until we use USERHOST on the server to find out our real host */ bi.botuser = addtouser(NULL, nickname, NULL, NULL); irc_write(QUEUE_SERVER, "USER %s 127.0.0.1 localhost :%s", username, realname); irc_write(QUEUE_SERVER, "NICK %s", nickname); return 1; } return 0; }
int main (int argc, char **argv) { irc_callbacks_t callbacks; irc_ctx_t ctx; irc_session_t * s; unsigned short port = 6667; if ( argc != 4 ) { printf ("Usage: %s <server> <nick> <channel>\n", argv[0]); return 1; } memset (&callbacks, 0, sizeof(callbacks)); callbacks.event_connect = event_connect; callbacks.event_join = event_join; callbacks.event_channel = event_channel; callbacks.event_numeric = event_numeric; s = irc_create_session (&callbacks); if ( !s ) { printf ("Could not create session\n"); return 1; } ctx.channel = argv[3]; ctx.nick = argv[2]; printf("nick:%s and channel:%s\n",ctx.nick,ctx.channel); irc_set_ctx (s, &ctx); // If the port number is specified in the server string, use the port 0 so it gets parsed if ( strchr( argv[1], ':' ) != 0 ) port = 0; // To handle the "SSL certificate verify failed" from command line we allow passing ## in front // of the server name, and in this case tell libircclient not to verify the cert if ( argv[1][0] == '#' && argv[1][1] == '#' ) { // Skip the first character as libircclient needs only one # for SSL support, i.e. #irc.freenode.net argv[1]++; irc_option_set( s, LIBIRC_OPTION_SSL_NO_VERIFY ); } // Initiate the IRC server connection if ( irc_connect (s, argv[1], port, 0, argv[2], 0, 0) ) { printf ("Could not connect: %s\n", irc_strerror (irc_errno(s))); return 1; } // and run into forever loop, generating events if ( irc_run (s) ) { printf ("Could not connect or I/O error: %s\n", irc_strerror (irc_errno(s))); return 1; } return 1; }
int main(int argc, char *argv[]) { int err; int max_descr; fd_set sock_set; struct timeval select_timeout; int running = 1; irc_connection con; unsigned irc_port; char *irc_server; conf = config_from_filename("ircb.conf"); assert(conf); if (argc == 3) { irc_server = argv[1]; irc_port = atoi(argv[2]); } if (argc == 2) { irc_server = argv[1]; irc_port = 6667; } else if (argc == 1) { config_group *g = config_get_group(conf, "irc"); irc_server = Conf("server", "INVALID"); if (!strcmp(irc_server, "INVALID")) { Printerr("No IRC server address given!\n"); return 1; } char *portstr = Conf("port", "6667"); assert(irc_server && portstr); irc_port = atoi(portstr); } else return 1; err = irc_connect(&con, irc_server, irc_port); if (err) { Printerr("Got no connection to IRC server!\n"); return 1; } module_load_module_dir(&con, conf); config_group *g = config_get_group(conf, "bot"); irc_set_nick(&con, Conf("nickname", "cbot")); irc_set_user(&con, Conf("username", "cbot_user"), Conf("hostname", "cbot_host"), Conf("servername", "cbot_server"), Conf("realname", "The CBot!")); max_descr = MAX(STDIN_FILENO, con.sockfd) + 1; while (running) { FD_ZERO(&sock_set); FD_SET(STDIN_FILENO, &sock_set); FD_SET(con.sockfd, &sock_set); select_timeout.tv_sec = 120; select_timeout.tv_usec = 0; err = select(max_descr, &sock_set, NULL, NULL, &select_timeout); if (!err) { /* Handle timeout */ } if (FD_ISSET(con.sockfd, &sock_set)) /* Incoming data from IRC network */ running = !handle_irc_messages(&con); if (FD_ISSET(STDIN_FILENO, &sock_set)) /* Local user input */ running = handle_keyboard_input(&con) != -2; } module_unload_all(&con); irc_close(&con, "bye."); return 0; }