static void server_real_connect(SERVER_REC *server, IPADDR *ip, const char *unix_socket) { GIOChannel *handle; IPADDR *own_ip = NULL; const char *errmsg; char *errmsg2; char ipaddr[MAX_IP_LEN]; int port, protonum; g_return_if_fail(ip != NULL || unix_socket != NULL); signal_emit("server connecting", 2, server, ip); if (server->connrec->no_connect) return; if (ip != NULL) { own_ip = IPADDR_IS_V6(ip) ? server->connrec->own_ip6 : server->connrec->own_ip4; port = server->connrec->proxy != NULL ? server->connrec->proxy_port : server->connrec->port; protonum = server->connrec->use_sctp ? 132 : 0; handle = server->connrec->use_ssl ? net_connect_ip_ssl(ip, port, own_ip, server, protonum) : net_connect_ip(ip, port, own_ip, protonum); } else { handle = net_connect_unix(unix_socket); } if (handle == NULL) { /* failed */ errmsg = g_strerror(errno); errmsg2 = NULL; if (errno == EADDRNOTAVAIL) { if (own_ip != NULL) { /* show the IP which is causing the error */ net_ip2host(own_ip, ipaddr); errmsg2 = g_strconcat(errmsg, ": ", ipaddr, NULL); } server->no_reconnect = TRUE; } if (server->connrec->use_ssl && errno == ENOSYS) server->no_reconnect = TRUE; server->connection_lost = TRUE; server_connect_failed(server, errmsg2 ? errmsg2 : errmsg); g_free(errmsg2); } else { server->handle = net_sendbuffer_create(handle, 0); #ifdef HAVE_OPENSSL if (server->connrec->use_ssl) server_connect_callback_init_ssl(server, handle); else #endif server->connect_tag = g_input_add(handle, G_INPUT_WRITE | G_INPUT_READ, (GInputFunction) server_connect_callback_init, server); } }
/* input function: DCC SERVER - someone tried to connect to our socket */ static void dcc_server_listen(SERVER_DCC_REC *dcc) { SERVER_DCC_REC *newdcc; IPADDR ip; GIOChannel *handle; int port; g_return_if_fail(IS_DCC_SERVER(dcc)); /* accept connection */ handle = net_accept(dcc->handle, &ip, &port); if (handle == NULL) return; /* Create a new DCC SERVER to handle this connection */ newdcc = dcc_server_clone(dcc); newdcc->starttime = time(NULL); newdcc->handle = handle; newdcc->sendbuf = net_sendbuffer_create(handle, 0); memcpy(&newdcc->addr, &ip, sizeof(IPADDR)); net_ip2host(&newdcc->addr, newdcc->addrstr); newdcc->port = port; newdcc->tagread = g_input_add(handle, G_INPUT_READ, (GInputFunction) dcc_server_input, newdcc); signal_emit("dcc connected", 1, newdcc); }
/* input function: DCC CHAT - someone tried to connect to our socket */ static void dcc_chat_listen(CHAT_DCC_REC *dcc) { IPADDR ip; GIOChannel *handle; int port; g_return_if_fail(IS_DCC_CHAT(dcc)); /* accept connection */ handle = net_accept(dcc->handle, &ip, &port); if (handle == NULL) return; /* TODO: add paranoia check - see dcc-files.c */ net_disconnect(dcc->handle); g_source_remove(dcc->tagconn); dcc->tagconn = -1; dcc->starttime = time(NULL); dcc->handle = handle; dcc->sendbuf = net_sendbuffer_create(handle, 0); memcpy(&dcc->addr, &ip, sizeof(IPADDR)); net_ip2host(&dcc->addr, dcc->addrstr); dcc->port = port; dcc->tagread = g_input_add(handle, G_INPUT_READ, (GInputFunction) dcc_chat_input, dcc); signal_emit("dcc connected", 1, dcc); }
/* starts connecting to server */ int server_start_connect(SERVER_REC *server) { const char *connect_address; int fd[2]; g_return_val_if_fail(server != NULL, FALSE); if (!server->connrec->unix_socket && server->connrec->port <= 0) return FALSE; server->rawlog = rawlog_create(); if (server->connrec->connect_handle != NULL) { /* already connected */ GIOChannel *handle = server->connrec->connect_handle; server->connrec->connect_handle = NULL; server->handle = net_sendbuffer_create(handle, 0); server_connect_finished(server); } else if (server->connrec->unix_socket) { /* connect with unix socket */ server_real_connect(server, NULL, server->connrec->address); } else { /* resolve host name */ if (pipe(fd) != 0) { g_warning("server_connect(): pipe() failed."); g_free(server->tag); g_free(server->nick); return FALSE; } server->connect_pipe[0] = g_io_channel_unix_new(fd[0]); server->connect_pipe[1] = g_io_channel_unix_new(fd[1]); connect_address = server->connrec->proxy != NULL ? server->connrec->proxy : server->connrec->address; server->connect_pid = net_gethostbyname_nonblock(connect_address, server->connect_pipe[1], settings_get_bool("resolve_reverse_lookup")); server->connect_tag = g_input_add(server->connect_pipe[0], G_INPUT_READ, (GInputFunction) server_connect_callback_readpipe, server); lookup_servers = g_slist_append(lookup_servers, server); signal_emit("server looking", 1, server); } return TRUE; }
static void server_real_connect(SERVER_REC *server, IPADDR *ip, const char *unix_socket) { GIOChannel *handle; IPADDR *own_ip; int port; g_return_if_fail(ip != NULL || unix_socket != NULL); signal_emit("server connecting", 2, server, ip); if (server->connrec->no_connect) return; if (ip != NULL) { own_ip = ip == NULL ? NULL : (IPADDR_IS_V6(ip) ? server->connrec->own_ip6 : server->connrec->own_ip4); port = server->connrec->proxy != NULL ? server->connrec->proxy_port : server->connrec->port; handle = server->connrec->use_ssl ? net_connect_ip_ssl(ip, port, own_ip, server->connrec->ssl_cert, server->connrec->ssl_pkey, server->connrec->ssl_cafile, server->connrec->ssl_capath, server->connrec->ssl_verify) : net_connect_ip(ip, port, own_ip); } else { handle = net_connect_unix(unix_socket); } if (handle == NULL) { /* failed */ if (errno == EADDRNOTAVAIL || (server->connrec->use_ssl && errno == ENOSYS)) server->no_reconnect = TRUE; server->connection_lost = TRUE; server_connect_failed(server, g_strerror(errno)); } else { server->handle = net_sendbuffer_create(handle, 0); server->connect_tag = g_input_add(handle, G_INPUT_WRITE | G_INPUT_READ, (GInputFunction) server_connect_callback_init, server); } }
SERVER_REC *robustirc_server_init_connect(SERVER_CONNECT_REC *connrec) { SERVER_REC *server; printtext(NULL, NULL, MSGLEVEL_CRAP, "robustirc_server_init_connect"); connrec->chat_type = IRC_PROTOCOL; server = irc_server_init_connect(connrec); GIOChannel *handle = robust_io_channel_new(server); RobustIOChannel *io = (RobustIOChannel *)handle; io->robustsession = robustsession_connect(server); server->handle = net_sendbuffer_create(handle, 0); // TODO: how many of these are necessary? server->connrec->no_connect = TRUE; server->connect_pid = -1; server->connect_tag = 1; g_hash_table_insert(connrecs, connrec, server); return server; }
static void sig_listen(LISTEN_REC *listen) { CLIENT_REC *rec; IPADDR ip; NET_SENDBUF_REC *sendbuf; GIOChannel *handle; char host[MAX_IP_LEN]; int port; g_return_if_fail(listen != NULL); /* accept connection */ handle = net_accept(listen->handle, &ip, &port); if (handle == NULL) return; net_ip2host(&ip, host); sendbuf = net_sendbuffer_create(handle, 0); rec = g_new0(CLIENT_REC, 1); rec->listen = listen; rec->handle = sendbuf; rec->host = g_strdup(host); rec->port = port; if (g_strcmp0(listen->ircnet, "*") == 0) { rec->proxy_address = g_strdup("irc.proxy"); rec->server = servers == NULL ? NULL : IRC_SERVER(servers->data); } else { rec->proxy_address = g_strdup_printf("%s.proxy", listen->ircnet); rec->server = servers == NULL ? NULL : IRC_SERVER(server_find_chatnet(listen->ircnet)); } rec->recv_tag = g_input_add(handle, G_INPUT_READ, (GInputFunction) sig_listen_client, rec); proxy_clients = g_slist_prepend(proxy_clients, rec); rec->listen->clients = g_slist_prepend(rec->listen->clients, rec); signal_emit("proxy client connecting", 1, rec); printtext(rec->server, NULL, MSGLEVEL_CLIENTNOTICE, "Proxy: New client %s:%d on port %d (%s)", rec->host, rec->port, listen->port, listen->ircnet); }
/* callback: DCC CHAT - connect finished */ static void sig_chat_connected(CHAT_DCC_REC *dcc) { g_return_if_fail(IS_DCC_CHAT(dcc)); if (net_geterror(dcc->handle) != 0) { /* error connecting */ signal_emit("dcc error connect", 1, dcc); dcc_destroy(DCC(dcc)); return; } /* connect ok. */ g_source_remove(dcc->tagconn); dcc->tagconn = -1; dcc->starttime = time(NULL); dcc->sendbuf = net_sendbuffer_create(dcc->handle, 0); dcc->tagread = g_input_add(dcc->handle, G_INPUT_READ, (GInputFunction) dcc_chat_input, dcc); signal_emit("dcc connected", 1, dcc); }
/* DCC SERVER: text received */ static void dcc_server_msg(SERVER_DCC_REC *dcc, const char *msg) { g_return_if_fail(IS_DCC_SERVER(dcc)); g_return_if_fail(msg != NULL); /* Check for CHAT protocol */ if (g_strncasecmp(msg, "100 ", 4) == 0) { msg += 4; /* Check if this server is accepting chat requests.*/ if (dcc->accept_chat) { /* Connect and start DCC Chat */ char *str; CHAT_DCC_REC *dccchat = dcc_chat_create(dcc->server, NULL, msg, "chat"); dccchat->starttime = time(NULL); dccchat->handle = dcc->handle; dccchat->sendbuf = net_sendbuffer_create(dccchat->handle, 0); memcpy(&dccchat->addr, &dcc->addr, sizeof(IPADDR)); net_ip2host(&dccchat->addr, dccchat->addrstr); dccchat->port = dcc->port; dccchat->tagread = g_input_add(dccchat->handle, G_INPUT_READ, (GInputFunction) dcc_chat_input, dccchat); dcc->connection_established = 1; signal_emit("dcc connected", 1, dccchat); str = g_strdup_printf("101 %s\n", (dccchat->server) ? dccchat->server->nick : "??"); net_sendbuffer_send(dccchat->sendbuf, str, strlen(str)); g_free(str); } } /* Check for FSERVE protocol */ if (g_strncasecmp(msg, "110 ", 4) == 0) { msg += 4; /* Check if this server is accepting fserve requests.*/ if (dcc->accept_fserve) { /* TODO - Connect and start DCC Fserve */ } } /* Check for SEND protocol */ if (g_strncasecmp(msg, "120 ", 4) == 0) { msg += 4; /* Check if this server is accepting send requests.*/ if (dcc->accept_send) { /* Connect and start DCC Send */ GET_DCC_REC *dccget; char **params, *fname, *nick; int paramcount, len, quoted = FALSE; uoff_t size; /* 120 clientnickname filesize filename */ params = g_strsplit(msg, " ", -1); paramcount = strarray_length(params); if (paramcount < 3) { g_strfreev(params); signal_stop(); return; } nick = params[0]; size = str_to_uofft(params[1]); fname = g_strjoinv(" ", ¶ms[2]); len = strlen(fname); if (len > 1 && *fname == '"' && fname[len-1] == '"') { /* "file name" - MIRC sends filenames with spaces like this */ fname[len-1] = '\0'; g_memmove(fname, fname+1, len); quoted = TRUE; } dccget = dcc_get_create(dcc->server, NULL, nick, fname); dccget->handle = dcc->handle; dccget->target = g_strdup(dcc->server ? dcc->server->nick : "??"); memcpy(&dccget->addr, &dcc->addr, sizeof(dcc->addr)); if (dccget->addr.family == AF_INET) { net_ip2host(&dccget->addr, dccget->addrstr); } else { /* with IPv6, show it to us as it was sent */ memcpy(dccget->addrstr, dcc->addrstr, sizeof(dccget->addrstr)); } dccget->port = dcc->port; dccget->size = size; dccget->file_quoted = quoted; dccget->from_dccserver = 1; dcc->connection_established = 1; signal_emit("dcc request", 2, dccget, dccget->addrstr); g_strfreev(params); g_free(fname); } } signal_stop(); }
static void process_exec(PROCESS_REC *rec, const char *cmd) { const char *shell_args[4] = { "/bin/sh", "-c", NULL, NULL }; char **args; int in[2], out[2]; int n; if (pipe(in) == -1) return; if (pipe(out) == -1) return; shell_args[2] = cmd; rec->pid = fork(); if (rec->pid == -1) { /* error */ close(in[0]); close(in[1]); close(out[0]); close(out[1]); return; } if (rec->pid != 0) { /* parent process */ GIOChannel *outio = g_io_channel_unix_new(in[1]); rec->in = g_io_channel_unix_new(out[0]); rec->out = net_sendbuffer_create(outio, 0); close(out[1]); close(in[0]); pidwait_add(rec->pid); return; } /* child process, try to clean up everything */ setsid(); setuid(getuid()); setgid(getgid()); signal(SIGINT, SIG_IGN); signal(SIGQUIT, SIG_DFL); putenv("TERM=tty"); /* set stdin, stdout and stderr */ dup2(in[0], STDIN_FILENO); dup2(out[1], STDOUT_FILENO); dup2(out[1], STDERR_FILENO); /* don't let child see our files */ for (n = 3; n < 256; n++) close(n); if (rec->shell) { execvp(shell_args[0], (char **) shell_args); fprintf(stderr, "Exec: /bin/sh: %s\n", g_strerror(errno)); } else { args = g_strsplit(cmd, " ", -1); execvp(args[0], args); fprintf(stderr, "Exec: %s: %s\n", args[0], g_strerror(errno)); } _exit(-1); }