int anope_event_mode (char *source, int ac, char **av) { if (ac < 2) return MOD_CONT; if (*av[0] == '#' || *av[0] == '&') { do_cmode (source, ac, av); } else { Server *s; s = findserver (servlist, source); if (s && *av[0]) { do_umode (av[0], ac, av); } else { do_umode (source, ac, av); } } return MOD_CONT; }
int conect() { //Connects to a server using "Winsock" // Start up Winsock i=WSAStartup(version, &wsaData); if (i!=0) {return(0);} // Store information about the server LPHOSTENT lpHostEntry; lpHostEntry = gethostbyname(server); if (lpHostEntry == NULL) { WSACleanup(); connected=0; return(0); } else connected=1; //This means we're connected //Get important data if (err==0) { //If we didn't run this allready and got an error findserver(); findfiles(); } // Create the socket theSocket = socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); if (theSocket == INVALID_SOCKET) { WSACleanup(); connected=0; return(0); } SOCKADDR_IN saServer; saServer.sin_family = AF_INET; saServer.sin_addr = *((LPIN_ADDR)*lpHostEntry->h_addr_list); saServer.sin_port = htons(25); // Connect to the server nRet = connect(theSocket,(LPSOCKADDR)&saServer,sizeof(struct sockaddr)); if (nRet == SOCKET_ERROR) { WSACleanup(); connected=0; return(0); } nRet = recv(theSocket,Buf,sizeof(Buf),0); if (nRet == SOCKET_ERROR) { WSACleanup(); connected=0; return(0); } if (Buf[0]=='4' || Buf[0]=='5') err=1; if (Buf[0]=='2' && Buf[1]=='2' && Buf[2]=='0') { sendmail(); } //Close the connection closesocket(theSocket); // Shutdown Winsock WSACleanup(); }
void viagra_cmd_jupe(char *jserver, char *who, char *reason) { char rbuf[256]; snprintf(rbuf, sizeof(rbuf), "Juped by %s%s%s", who, reason ? ": " : "", reason ? reason : ""); if (findserver(servlist, jserver)) viagra_cmd_squit(jserver, rbuf); viagra_cmd_server(jserver, 2, rbuf); new_server(me_server, jserver, rbuf, SERVER_JUPED, NULL); }
int anope_event_eob (char *source, int ac, char **av) { Server *s; s = findserver (servlist, source); /* If we found a server with the given source, that one just * finished bursting. If there was no source, then our uplink * server finished bursting. -GD */ if (!s && serv_uplink) s = serv_uplink; finish_sync (s, 1); return MOD_CONT; }
int xanadu_event_burst(char *source, int ac, char **av) { Server *s; s = findserver(servlist, source); if (!ac) { /* for future use - start burst */ } else { /* If we found a server with the given source, that one just * finished bursting. If there was no source, then our uplink * server finished bursting. -GD */ if (!s && serv_uplink) s = serv_uplink; finish_sync(s, 1); } return MOD_CONT; }
/** * Adds a new user to anopes internal userlist. * * If the SVID passed is 2, the user will not be marked registered or requested to ID. * This is an addition to accomodate IRCds where we cannot determine this based on the NICK * or UID command. Some IRCd's keep +r on when changing nicks and do not use SVID (ex. InspIRCd 1.2). * Instead we get a METADATA command containing the accountname the user was last identified to. * Since this is received after the user is introduced to us we should not yet mark the user * as identified or ask him to identify. We will mark him as recognized for the time being and let * him keep his +r if he has it. * It is the responsibility of the protocol module to make sure that this is either invalidated, * or changed to identified. ~ Viper **/ User *do_nick(const char *source, char *nick, char *username, char *host, char *server, char *realname, time_t ts, uint32 svid, uint32 ip, char *vhost, char *uid) { User *user = NULL; char *tmp = NULL; NickAlias *old_na; /* Old nick rec */ int nc_changed = 1; /* Did nick core change? */ int status = 0; /* Status to apply */ char mask[USERMAX + HOSTMAX + 2]; char *logrealname; char *oldnick; if (!*source) { char ipbuf[16]; struct in_addr addr; if (ircd->nickvhost) { if (vhost) { if (!strcmp(vhost, "*")) { vhost = NULL; if (debug) alog("debug: new user�with no vhost in NICK command: %s", nick); } } } /* This is a new user; create a User structure for it. */ if (debug) alog("debug: new user: %s", nick); if (ircd->nickip) { addr.s_addr = htonl(ip); ntoa(addr, ipbuf, sizeof(ipbuf)); } if (LogUsers) { /** * Ugly swap routine for Flop's bug :) **/ if (realname) { tmp = strchr(realname, '%'); while (tmp) { *tmp = '-'; tmp = strchr(realname, '%'); } } logrealname = normalizeBuffer(realname); /** * End of ugly swap **/ if (ircd->nickvhost) { if (ircd->nickip) { alog("LOGUSERS: %s (%s@%s => %s) (%s) [%s] connected to the network (%s).", nick, username, host, (vhost ? vhost : "none"), logrealname, ipbuf, server); } else { alog("LOGUSERS: %s (%s@%s => %s) (%s) connected to the network (%s).", nick, username, host, (vhost ? vhost : "none"), logrealname, server); } } else { if (ircd->nickip) { alog("LOGUSERS: %s (%s@%s) (%s) [%s] connected to the network (%s).", nick, username, host, logrealname, ipbuf, server); } else { alog("LOGUSERS: %s (%s@%s) (%s) connected to the network (%s).", nick, username, host, logrealname, server); } } Anope_Free(logrealname); } /* We used to ignore the ~ which a lot of ircd's use to indicate no * identd response. That caused channel bans to break, so now we * just take what the server gives us. People are still encouraged * to read the RFCs and stop doing anything to usernames depending * on the result of an identd lookup. */ /* First check for AKILLs. */ /* DONT just return null if its an akill match anymore - yes its more efficent to, however, now that ircd's are * starting to use things like E/F lines, we cant be 100% sure the client will be removed from the network :/ * as such, create a user_struct, and if the client is removed, we'll delete it again when the QUIT notice * comes in from the ircd. **/ if (check_akill(nick, username, host, vhost, ipbuf)) { /* return NULL; */ } /** * DefCon AKILL system, if we want to akill all connecting user's here's where to do it * then force check_akill again on them... **/ /* don't akill on netmerges -Certus */ /* don't akill clients introduced by ulines. -Viper */ if (is_sync(findserver(servlist, server)) && checkDefCon(DEFCON_AKILL_NEW_CLIENTS) && !is_ulined(server)) { strncpy(mask, "*@", 3); strncat(mask, host, HOSTMAX); alog("DEFCON: adding akill for %s", mask); add_akill(NULL, mask, s_OperServ, time(NULL) + dotime(DefConAKILL), DefConAkillReason ? DefConAkillReason : "DEFCON AKILL"); if (check_akill(nick, username, host, vhost, ipbuf)) { /* return NULL; */ } } /* SGLINE */ if (ircd->sgline) { if (check_sgline(nick, realname)) return NULL; } /* SQLINE */ if (ircd->sqline) { if (check_sqline(nick, 0)) return NULL; } /* SZLINE */ if (ircd->szline && ircd->nickip) { if (check_szline(nick, ipbuf)) return NULL; } /* Now check for session limits */ if (LimitSessions && !is_ulined(server) && !add_session(nick, host, ipbuf)) return NULL; /* Allocate User structure and fill it in. */ user = new_user(nick); user->username = sstrdup(username); user->host = sstrdup(host); user->server = findserver(servlist, server); user->realname = sstrdup(realname); user->timestamp = ts; user->my_signon = time(NULL); user->chost = vhost ? sstrdup(vhost) : sstrdup(host); user->vhost = vhost ? sstrdup(vhost) : sstrdup(host); if (uid) { user->uid = sstrdup(uid); /* p10/ts6 stuff */ } else { user->uid = NULL; } user->vident = sstrdup(username); /* We now store the user's ip in the user_ struct, * because we will use it in serveral places -- DrStein */ if (ircd->nickip) { user->hostip = sstrdup(ipbuf); } else { user->hostip = NULL; } if (svid == 0) { display_news(user, NEWS_LOGON); display_news(user, NEWS_RANDOM); } if (svid == 2 && user->na) { /* We do not yet know if the user should be identified or not. * mark him as recognized for now. * It s up to the protocol module to make sure this either becomes ID'd or * is invalidated. ~ Viper */ if (debug) alog("debug: Marking %s as recognized..", user->nick); user->svid = 1; user->na->status |= NS_RECOGNIZED; nc_changed = 0; } else if (svid == ts && user->na) { /* Timestamp and svid match, and nick is registered; automagically identify the nick */ user->svid = svid; user->na->status |= NS_IDENTIFIED; check_memos(user); nc_changed = 0; /* Start nick tracking if available */ if (NSNickTracking) nsStartNickTracking(user); } else if (svid != 1) { /* Resets the svid because it doesn't match */ user->svid = 1; anope_cmd_svid_umode(user->nick, user->timestamp); } else { user->svid = 1; } send_event(EVENT_NEWNICK, 1, nick); } else { /* An old user changing nicks. */ if (UseTS6 && ircd->ts6) user = find_byuid(source); if (!user) user = finduser(source); if (!user) { alog("user: NICK from nonexistent nick %s", source); return NULL; } user->isSuperAdmin = 0; /* Dont let people nick change and stay SuperAdmins */ if (debug) alog("debug: %s changes nick to %s", source, nick); if (LogUsers) { logrealname = normalizeBuffer(user->realname); if (ircd->vhost) { alog("LOGUSERS: %s (%s@%s => %s) (%s) changed nick to %s (%s).", user->nick, user->username, user->host, (user->vhost ? user->vhost : "(none)"), logrealname, nick, user->server->name); } else { alog("LOGUSERS: %s (%s@%s) (%s) changed nick to %s (%s).", user->nick, user->username, user->host, logrealname, nick, user->server->name); } if (logrealname) { free(logrealname); } } user->timestamp = ts; if (stricmp(nick, user->nick) == 0) { /* No need to redo things */ change_user_nick(user, nick); nc_changed = 0; } else { /* Update this only if nicks aren't the same */ user->my_signon = time(NULL); old_na = user->na; if (old_na) { if (nick_recognized(user)) user->na->last_seen = time(NULL); status = old_na->status & NS_TRANSGROUP; cancel_user(user); } oldnick = sstrdup(user->nick); change_user_nick(user, nick); if ((old_na ? old_na->nc : NULL) == (user->na ? user->na->nc : NULL)) nc_changed = 0; if (!nc_changed && (user->na)) user->na->status |= status; else { anope_cmd_nc_change(user); } send_event(EVENT_CHANGE_NICK, 2, nick, oldnick); free(oldnick); } if (ircd->sqline) { if (!is_oper(user) && check_sqline(user->nick, 1)) return NULL; } } /* if (!*source) */ /* Check for nick tracking to bypass identification */ if (NSNickTracking && nsCheckNickTracking(user)) { user->na->status |= NS_IDENTIFIED; nc_changed = 0; } if (nc_changed || !nick_recognized(user)) { if (validate_user(user)) check_memos(user); } else { if (nick_identified(user)) { char tsbuf[16]; user->na->last_seen = time(NULL); if (user->na->last_usermask) free(user->na->last_usermask); user->na->last_usermask = smalloc(strlen(common_get_vident(user)) + strlen(common_get_vhost(user)) + 2); sprintf(user->na->last_usermask, "%s@%s", common_get_vident(user), common_get_vhost(user)); snprintf(tsbuf, sizeof(tsbuf), "%lu", (unsigned long int) user->timestamp); anope_cmd_svid_umode2(user, tsbuf); alog("%s: %s!%s@%s automatically identified for nick %s", s_NickServ, user->nick, user->username, user->host, user->nick); } } /* Bahamut sets -r on every nick changes, so we must test it even if nc_changed == 0 */ if (ircd->check_nick_id) { if (nick_identified(user)) { char tsbuf[16]; snprintf(tsbuf, sizeof(tsbuf), "%lu", (unsigned long int) user->timestamp); anope_cmd_svid_umode3(user, tsbuf); } } return user; }
void* connthread(void* arg) { const struct Mapping* map; struct sockaddr_in addr; int ssock = 0; int csock = (long)arg; char* buffer; int rc; char* tok; char* host = NULL; fd_set fds; fd_set rfds; int tries = 0; running++; buffer = (char*)malloc(BUFFERSIZE); tryagain: rc = recv(csock, buffer, BUFFERSIZE-1, MSG_PEEK); if (rc == 0) { warn("[%d] Client closed connection before sending headers.\n", csock); goto end; } if (rc < 0) { warn("[%d] Error reading request headers: %m\n", csock); goto end; } buffer[rc] = 0; /* Technically it's case-insensitive, but these should cover almost all cases. */ if (!strstr(buffer, "Host: ") && !strstr(buffer, "host: ")) { usleep(10000); tries++; if (tries > 1000) { warn("[%d] Waiting for Host: header timed out.\n", csock); goto end; } if (rc >= BUFFERSIZE-1) { warn("[%d] Host: header not found within first %d bytes.\n", csock, rc); goto end; } goto tryagain; } strtok(buffer, "\r\n"); /* First token should be "GET /foo HTTP/1.1" so we can skip that safely. */ while ((tok = strtok(NULL, "\r\n"))) { if (!strncasecmp(tok, "Host: ", 6)) { host = strdup(tok + 6); break; } } if (host == NULL) { warn("[%d] Client did not provide Host: header.\n", csock); goto end; } /* Establish SOCKS connection. */ map = findserver(host); ssock = socket(AF_INET, SOCK_STREAM, 0); switch (map->proto) { case INVALID: goto end; case DIRECT: if (!directconnect(csock, ssock, host, "80", map)) goto end; break; case SOCKS4: rc = connect(ssock, (struct sockaddr*)&addr, sizeof(addr)); if (rc) { warn("[%d] Could not connect to server: %m\n", csock); return 0; } if (!socks4connect(csock, ssock, host, 80)) goto end; break; case SOCKS4A: rc = connect(ssock, (struct sockaddr*)&addr, sizeof(addr)); if (rc) { warn("[%d] Could not connect to server: %m\n", csock); return 0; } if (!socks4aconnect(csock, ssock, host, 80)) goto end; break; case SOCKS5: rc = connect(ssock, (struct sockaddr*)&addr, sizeof(addr)); if (rc) { warn("[%d] Could not connect to server: %m\n", csock); return 0; } if (!socks5connect(csock, ssock, host, 80)) goto end; break; } /* Relay data. */ FD_ZERO(&fds); FD_SET(csock, &fds); FD_SET(ssock, &fds); do { rfds = fds; rc = select(FD_SETSIZE, &rfds, NULL, NULL, NULL); if (rc < 0) break; if (FD_ISSET(csock, &rfds)) { rc = read(csock, buffer, BUFFERSIZE); if (rc == 0) break; if (rc < 0) { warn("[%d] Error reading from client: %m\n", csock); break; } rc = writeall(ssock, buffer, rc); if (rc <= 0) { warn("[%d] Error sending to server: %m\n", csock); break; } } if (FD_ISSET(ssock, &rfds)) { rc = read(ssock, buffer, BUFFERSIZE); if (rc == 0) break; if (rc <= 0) { warn("[%d] Error reading from server: %m\n", csock); break; } rc = writeall(csock, buffer, rc); if (rc <= 0) { warn("[%d] Error sending to client: %m\n", csock); break; } } } while (exitflag == 0); end: if (csock > 0) close(csock); if (ssock > 0) close(ssock); if (host) free(host); if (buffer) free(buffer); running--; log("[%d] Relay finished.\n", csock); return NULL; }
int main(int argc, char *argv[]) { dns_client_t *client = NULL; isc_result_t result; dns_fixedname_t qfn; dns_name_t *query_name, *response_name; dns_rdataset_t *rdataset; dns_namelist_t namelist; unsigned int resopt, clopt; isc_appctx_t *actx = NULL; isc_taskmgr_t *taskmgr = NULL; isc_socketmgr_t *socketmgr = NULL; isc_timermgr_t *timermgr = NULL; dns_master_style_t *style = NULL; #ifndef WIN32 struct sigaction sa; #endif progname = argv[0]; preparse_args(argc, argv); argc--; argv++; isc_lib_register(); result = dns_lib_init(); if (result != ISC_R_SUCCESS) fatal("dns_lib_init failed: %d", result); result = isc_mem_create(0, 0, &mctx); if (result != ISC_R_SUCCESS) fatal("failed to create mctx"); CHECK(isc_appctx_create(mctx, &actx)); CHECK(isc_taskmgr_createinctx(mctx, actx, 1, 0, &taskmgr)); CHECK(isc_socketmgr_createinctx(mctx, actx, &socketmgr)); CHECK(isc_timermgr_createinctx(mctx, actx, &timermgr)); parse_args(argc, argv); CHECK(setup_style(&style)); setup_logging(stderr); CHECK(isc_app_ctxstart(actx)); #ifndef WIN32 /* Unblock SIGINT if it's been blocked by isc_app_ctxstart() */ memset(&sa, 0, sizeof(sa)); sa.sa_handler = SIG_DFL; if (sigfillset(&sa.sa_mask) != 0 || sigaction(SIGINT, &sa, NULL) < 0) fatal("Couldn't set up signal handler"); #endif /* Create client */ clopt = DNS_CLIENTCREATEOPT_USECACHE; result = dns_client_createx2(mctx, actx, taskmgr, socketmgr, timermgr, clopt, &client, srcaddr4, srcaddr6); if (result != ISC_R_SUCCESS) { delv_log(ISC_LOG_ERROR, "dns_client_create: %s", isc_result_totext(result)); goto cleanup; } /* Set the nameserver */ if (server != NULL) addserver(client); else findserver(client); CHECK(setup_dnsseckeys(client)); /* Construct QNAME */ CHECK(convert_name(&qfn, &query_name, qname)); /* Set up resolution options */ resopt = DNS_CLIENTRESOPT_ALLOWRUN | DNS_CLIENTRESOPT_NOCDFLAG; if (no_sigs) resopt |= DNS_CLIENTRESOPT_NODNSSEC; if (!root_validation && !dlv_validation) resopt |= DNS_CLIENTRESOPT_NOVALIDATE; if (cdflag) resopt &= ~DNS_CLIENTRESOPT_NOCDFLAG; /* Perform resolution */ ISC_LIST_INIT(namelist); result = dns_client_resolve(client, query_name, dns_rdataclass_in, qtype, resopt, &namelist); if (result != ISC_R_SUCCESS) delv_log(ISC_LOG_ERROR, "resolution failed: %s", isc_result_totext(result)); for (response_name = ISC_LIST_HEAD(namelist); response_name != NULL; response_name = ISC_LIST_NEXT(response_name, link)) { for (rdataset = ISC_LIST_HEAD(response_name->list); rdataset != NULL; rdataset = ISC_LIST_NEXT(rdataset, link)) { result = printdata(rdataset, response_name, style); if (result != ISC_R_SUCCESS) delv_log(ISC_LOG_ERROR, "print data failed"); } } dns_client_freeresanswer(client, &namelist); cleanup: if (dlv_anchor != NULL) isc_mem_free(mctx, dlv_anchor); if (trust_anchor != NULL) isc_mem_free(mctx, trust_anchor); if (anchorfile != NULL) isc_mem_free(mctx, anchorfile); if (qname != NULL) isc_mem_free(mctx, qname); if (style != NULL) dns_master_styledestroy(&style, mctx); if (client != NULL) dns_client_destroy(&client); if (taskmgr != NULL) isc_taskmgr_destroy(&taskmgr); if (timermgr != NULL) isc_timermgr_destroy(&timermgr); if (socketmgr != NULL) isc_socketmgr_destroy(&socketmgr); if (actx != NULL) isc_appctx_destroy(&actx); if (lctx != NULL) isc_log_destroy(&lctx); isc_mem_detach(&mctx); dns_lib_shutdown(); return (0); }
int spcmd_splitadd(void *source, int cargc, char **cargv) { nick *np = (nick*)source; unsigned long long num; char *end; flag_t servertype = 0; char *servername; size_t servernamelen; time_t splittime; server fake; if (cargc < 1) { controlreply(np, "Usage: splitadd <servername> [+flags] [split time as unix timestamp]"); return CMD_ERROR; } servername = cargv[0]; servernamelen = strlen(servername); if (findserver(servername) != -1) { controlreply(np, "Server %s is linked right now, refusing to add split.", servername); return CMD_ERROR; } if (doessplitalreadyexist(servername)) { controlreply(np, "There is a split for %s already.", servername); return CMD_ERROR; } if (servernamelen > SERVERLEN) { controlreply(np, "Server name %s is too long (max: %d characters)", servername, SERVERLEN); return CMD_ERROR; } /* Handle flags */ if (cargc > 1) { if (setflags(&servertype, (flag_t)-1, cargv[1], servertypeflags, REJECT_UNKNOWN) != REJECT_NONE) { controlreply(np, "Flag string %s contained invalid flags.", cargv[1]); return CMD_ERROR; } } else { /* Set up a fake server for getservertype. */ memset(&fake, 0, sizeof(fake)); fake.name = getsstring(servername, servernamelen); servertype = getservertype(&fake); freesstring(fake.name); } /* Handle timestamp */ if (cargc < 3) { splittime = getnettime(); } else { errno = 0; num = strtoull(cargv[2], &end, 10); if (errno == ERANGE) { controlreply(np, "%s is out of range for a timestamp.", cargv[2]); return CMD_ERROR; } /* Truncation may happen here. * However, there's no way to get the max time_t value, so we'll just try to * find out after the fact. */ splittime = (time_t)num; if ((unsigned long long)splittime < num) { controlreply(np, "Tried to use %llu as split time value, but it's too " "large for the system to handle", num); return CMD_ERROR; } } sp_addsplit(servername, splittime, servertype); controlreply(np, "Added split for %s (%s ago) with flags %s.", servername, longtoduration(getnettime() - splittime, 1), printflags(servertype, servertypeflags)); return CMD_OK; }