/* * Unreal Internet Relay Chat Daemon, src/s_misc.c * Copyright (C) 1990 Jarkko Oikarinen and * University of Oulu, Computing Center * * See file AUTHORS in IRC package for additional names of * the programmers. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 1, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #ifndef CLEAN_COMPILE static char sccsid[] = "@(#)s_misc.c 2.42 3/1/94 (C) 1988 University of Oulu, \ Computing Center and Jarkko Oikarinen"; #endif #ifndef _WIN32 #include #endif #include "struct.h" #include "common.h" #include "sys.h" #include "numeric.h" #include #include #if !defined(ULTRIX) && !defined(SGI) && \ !defined(__convex__) && !defined(_WIN32) # include #endif #if defined(PCS) || defined(AIX) || defined(SVR3) # include #endif #ifdef HPUX #include #endif #ifdef _WIN32 # include #endif #include "h.h" #include "proto.h" #include "channel.h" #include #ifndef NO_FDLIST extern fdlist serv_fdlist; extern fdlist oper_fdlist; extern float currentrate; extern float currentrate2; #endif extern ircstats IRCstats; extern char *me_hash; static void exit_one_client(aClient *, aClient *, aClient *, char *, int); extern void exit_one_client_in_split(aClient *, aClient *, aClient *, char *); static char *months[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" }; static char *weekdays[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" }; /* * stats stuff */ struct stats ircst, *ircstp = &ircst; char *date(time_t clock) { static char buf[80], plus; struct tm *lt, *gm; struct tm gmbuf; int minswest; if (!clock) time(&clock); gm = gmtime(&clock); bcopy((char *)gm, (char *)&gmbuf, sizeof(gmbuf)); gm = &gmbuf; lt = localtime(&clock); #ifndef _WIN32 if (lt->tm_yday == gm->tm_yday) minswest = (gm->tm_hour - lt->tm_hour) * 60 + (gm->tm_min - lt->tm_min); else if (lt->tm_yday > gm->tm_yday) minswest = (gm->tm_hour - (lt->tm_hour + 24)) * 60; else minswest = ((gm->tm_hour + 24) - lt->tm_hour) * 60; #else minswest = (_timezone / 60); #endif plus = (minswest > 0) ? '-' : '+'; if (minswest < 0) minswest = -minswest; (void)ircsprintf(buf, "%s %s %d %d -- %02d:%02d %c%02d:%02d", weekdays[lt->tm_wday], months[lt->tm_mon], lt->tm_mday, 1900 + lt->tm_year, lt->tm_hour, lt->tm_min, plus, minswest / 60, minswest % 60); return buf; } char *convert_time (time_t ltime) { unsigned long days = 0,hours = 0,minutes = 0,seconds = 0; static char buffer[40]; *buffer = '\0'; seconds = ltime % 60; ltime = (ltime - seconds) / 60; minutes = ltime%60; ltime = (ltime - minutes) / 60; hours = ltime % 24; days = (ltime - hours) / 24; ircsprintf(buffer, "%ludays %luhours %luminutes %lusecs", days, hours, minutes, seconds); return(*buffer ? buffer : ""); } /* * Fixes a string so that the first white space found becomes an end of * string marker (`\-`). returns the 'fixed' string or "*" if the string * was NULL length or a NULL pointer. */ char *check_string(char *s) { static char star[2] = "*"; char *str = s; if (BadPtr(s)) return star; for (; *s; s++) if (isspace(*s)) { *s = '\0'; break; } return (BadPtr(str)) ? star : str; } char *make_user_host(char *name, char *host) { static char namebuf[USERLEN + HOSTLEN + 6]; char *s = namebuf; bzero(namebuf, sizeof(namebuf)); name = check_string(name); strncpyzt(s, name, USERLEN + 1); s += strlen(s); *s++ = '@'; host = check_string(host); strncpyzt(s, host, HOSTLEN + 1); s += strlen(s); *s = '\0'; return (namebuf); } /* * create a string of form "foo!bar@fubar" given foo, bar and fubar * as the parameters. If NULL, they become "*". */ char *make_nick_user_host(char *nick, char *name, char *host) { static char namebuf[NICKLEN + USERLEN + HOSTLEN + 6]; char *s = namebuf; bzero(namebuf, sizeof(namebuf)); nick = check_string(nick); strncpyzt(namebuf, nick, NICKLEN + 1); s += strlen(s); *s++ = '!'; name = check_string(name); strncpyzt(s, name, USERLEN + 1); s += strlen(s); *s++ = '@'; host = check_string(host); strncpyzt(s, host, HOSTLEN + 1); s += strlen(s); *s = '\0'; return (namebuf); } /** ** myctime() ** This is like standard ctime()-function, but it zaps away ** the newline from the end of that string. Also, it takes ** the time value as parameter, instead of pointer to it. ** Note that it is necessary to copy the string to alternate ** buffer (who knows how ctime() implements it, maybe it statically ** has newline there and never 'refreshes' it -- zapping that ** might break things in other places...) ** **/ char *myctime(time_t value) { static char buf[28]; char *p; (void)strlcpy(buf, ctime(&value), sizeof buf); if ((p = (char *)index(buf, '\n')) != NULL) *p = '\0'; return buf; } /* ** check_registered_user is used to cancel message, if the ** originator is a server or not registered yet. In other ** words, passing this test, *MUST* guarantee that the ** sptr->user exists (not checked after this--let there ** be coredumps to catch bugs... this is intentional --msa ;) ** ** There is this nagging feeling... should this NOT_REGISTERED ** error really be sent to remote users? This happening means ** that remote servers have this user registered, althout this ** one has it not... Not really users fault... Perhaps this ** error message should be restricted to local clients and some ** other thing generated for remotes... */ int check_registered_user(aClient *sptr) { if (!IsRegisteredUser(sptr)) { sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "*"); return -1; } return 0; } /* ** check_registered user cancels message, if 'x' is not ** registered (e.g. we don't know yet whether a server ** or user) */ int check_registered(aClient *sptr) { if (!IsRegistered(sptr)) { sendto_one(sptr, err_str(ERR_NOTREGISTERED), me.name, "*"); return -1; } return 0; } /* ** get_client_name ** Return the name of the client for various tracking and ** admin purposes. The main purpose of this function is to ** return the "socket host" name of the client, if that ** differs from the advertised name (other than case). ** But, this can be used to any client structure. ** ** Returns: ** "name[user@ip#.port]" if 'showip' is true; ** "name[sockethost]", if name and sockhost are different and ** showip is false; else ** "name". ** ** NOTE 1: ** Watch out the allocation of "nbuf", if either sptr->name ** or sptr->sockhost gets changed into pointers instead of ** directly allocated within the structure... ** ** NOTE 2: ** Function return either a pointer to the structure (sptr) or ** to internal buffer (nbuf). *NEVER* use the returned pointer ** to modify what it points!!! */ char *get_client_name(aClient *sptr, int showip) { static char nbuf[HOSTLEN * 2 + USERLEN + 5]; if (MyConnect(sptr)) { if (showip) (void)ircsprintf(nbuf, "%s[%s@%s.%u]", sptr->name, (!(sptr->flags & FLAGS_GOTID)) ? "" : sptr->username, #ifdef INET6 inetntop(AF_INET6, (char *)&sptr->ip, mydummy, MYDUMMY_SIZE), #else inetntoa((char *)&sptr->ip), #endif (unsigned int)sptr->port); else { if (mycmp(sptr->name, sptr->sockhost)) (void)ircsprintf(nbuf, "%s[%s]", sptr->name, sptr->sockhost); else return sptr->name; } return nbuf; } return sptr->name; } char *get_client_host(aClient *cptr) { static char nbuf[HOSTLEN * 2 + USERLEN + 5]; if (!MyConnect(cptr)) return cptr->name; if (!cptr->hostp) return get_client_name(cptr, FALSE); (void)ircsprintf(nbuf, "%s[%-.*s@%-.*s]", cptr->name, USERLEN, (!(cptr->flags & FLAGS_GOTID)) ? "" : cptr->username, HOSTLEN, cptr->hostp->h_name); return nbuf; } /* * Form sockhost such that if the host is of form user@host, only the host * portion is copied. */ void get_sockhost(aClient *cptr, char *host) { char *s; if ((s = (char *)index(host, '@'))) s++; else s = host; strncpyzt(cptr->sockhost, s, sizeof(cptr->sockhost)); } void remove_dcc_references(aClient *sptr) { aClient *acptr; Link *lp, *nextlp; Link **lpp, *tmp; int found; lp = sptr->user->dccallow; while(lp) { nextlp = lp->next; acptr = lp->value.cptr; for(found = 0, lpp = &(acptr->user->dccallow); *lpp; lpp=&((*lpp)->next)) { if(lp->flags == (*lpp)->flags) continue; /* match only opposite types for sanity */ if((*lpp)->value.cptr == sptr) { if((*lpp)->flags == DCC_LINK_ME) { sendto_one(acptr, ":%s %d %s :%s has been removed from " "your DCC allow list for signing off", me.name, RPL_DCCINFO, acptr->name, sptr->name); } tmp = *lpp; *lpp = tmp->next; free_link(tmp); found++; break; } } if(!found) sendto_realops("[BUG] remove_dcc_references: %s was in dccallowme " "list[%d] of %s but not in dccallowrem list!", acptr->name, lp->flags, sptr->name); free_link(lp); lp = nextlp; } } /* ** exit_client ** This is old "m_bye". Name changed, because this is not a ** protocol function, but a general server utility function. ** ** This function exits a client of *any* type (user, server, etc) ** from this server. Also, this generates all necessary prototol ** messages that this exit may cause. ** ** 1) If the client is a local client, then this implicitly ** exits all other clients depending on this connection (e.g. ** remote clients having 'from'-field that points to this. ** ** 2) If the client is a remote client, then only this is exited. ** ** For convenience, this function returns a suitable value for ** m_funtion return value: ** ** FLUSH_BUFFER if (cptr == sptr) ** 0 if (cptr != sptr) */ int exit_client(aClient *cptr, aClient *sptr, aClient *from, char *comment) { aClient *acptr; aClient *next; time_t on_for; ConfigItem_listen *listen_conf; static char comment1[HOSTLEN + HOSTLEN + 2]; static int recurse = 0; if (MyConnect(sptr)) { #ifndef NO_FDLIST #define FDLIST_DEBUG #ifdef FDLIST_DEBUG { int i; if (!IsAnOper(sptr)) { for (i = oper_fdlist.last_entry; i; i--) { if (oper_fdlist.entry[i] == sptr->slot) { sendto_realops("[BUG] exit_client: oper_fdlist entry while not oper, fd=%d, user='%s'", sptr->slot, sptr->name); ircd_log(LOG_ERROR, "[BUG] exit_client: oper_fdlist entry while not oper, fd=%d, user='%s'", sptr->slot, sptr->name); delfrom_fdlist(sptr->slot, &oper_fdlist); /* be kind of enough to fix the problem.. */ break; /* MUST break here */ } } } } #endif if (IsAnOper(sptr)) delfrom_fdlist(sptr->slot, &oper_fdlist); if (IsServer(sptr)) delfrom_fdlist(sptr->slot, &serv_fdlist); #endif if (sptr->class) { sptr->class->clients--; if ((sptr->class->flag.temporary) && !sptr->class->clients && !sptr->class->xrefcount) { delete_classblock(sptr->class); sptr->class = NULL; } } if (IsClient(sptr)) IRCstats.me_clients--; if (sptr->serv && sptr->serv->conf) { sptr->serv->conf->refcount--; Debug((DEBUG_ERROR, "reference count for %s (%s) is now %d", sptr->name, sptr->serv->conf->servername, sptr->serv->conf->refcount)); if (!sptr->serv->conf->refcount && sptr->serv->conf->flag.temporary) { Debug((DEBUG_ERROR, "deleting temporary block %s", sptr->serv->conf->servername)); delete_linkblock(sptr->serv->conf); } } if (IsServer(sptr)) { IRCstats.me_servers--; ircd_log(LOG_SERVER, "SQUIT %s (%s)", sptr->name, comment); } if (sptr->listener) if (sptr->listener->class && !IsOutgoing(sptr)) { listen_conf = (ConfigItem_listen *) sptr->listener->class; listen_conf->clients--; if (listen_conf->flag.temporary && (listen_conf->clients == 0)) { /* Call listen cleanup */ listen_cleanup(); } } sptr->flags |= FLAGS_CLOSING; if (IsPerson(sptr)) { RunHook2(HOOKTYPE_LOCAL_QUIT, sptr, comment); sendto_connectnotice(sptr->name, sptr->user, sptr, 1, comment); /* Clean out list and watch structures -Donwulff */ hash_del_watch_list(sptr); if (sptr->user && sptr->user->lopt) { free_str_list(sptr->user->lopt->yeslist); free_str_list(sptr->user->lopt->nolist); MyFree(sptr->user->lopt); } on_for = TStime() - sptr->firsttime; if (IsHidden(sptr)) ircd_log(LOG_CLIENT, "Disconnect - (%ld:%ld:%ld) %s!%s@%s [VHOST %s]", on_for / 3600, (on_for % 3600) / 60, on_for % 60, sptr->name, sptr->user->username, sptr->user->realhost, sptr->user->virthost); else ircd_log(LOG_CLIENT, "Disconnect - (%ld:%ld:%ld) %s!%s@%s", on_for / 3600, (on_for % 3600) / 60, on_for % 60, sptr->name, sptr->user->username, sptr->user->realhost); } else if (IsUnknown(sptr)) { RunHook2(HOOKTYPE_UNKUSER_QUIT, sptr, comment); } if (sptr->fd >= 0 && !IsConnecting(sptr)) { if (cptr != NULL && sptr != cptr) sendto_one(sptr, "ERROR :Closing Link: %s %s (%s)", get_client_name(sptr, FALSE), cptr->name, comment); else sendto_one(sptr, "ERROR :Closing Link: %s (%s)", get_client_name(sptr, FALSE), comment); } /* ** Currently only server connections can have ** depending remote clients here, but it does no ** harm to check for all local clients. In ** future some other clients than servers might ** have remotes too... ** ** Close the Client connection first and mark it ** so that no messages are attempted to send to it. ** (The following *must* make MyConnect(sptr) == FALSE!). ** It also makes sptr->from == NULL, thus it's unnecessary ** to test whether "sptr != acptr" in the following loops. */ close_connection(sptr); } /* * Recurse down the client list and get rid of clients who are no * longer connected to the network (from my point of view) * Only do this expensive stuff if exited==server -Donwulff */ if (IsServer(sptr)) { /* * Is this right? Not recreateing the split message if * we have been called recursivly? I hope so, cuz thats * the only way I could make this give the right servers * in the quit msg. -Cabal95 */ if (cptr && !recurse) { /* * We are sure as we RELY on sptr->srvptr->name and * sptr->name to be less or equal to HOSTLEN * Waste of strlcpy/strlcat here */ (void)strcpy(comment1, sptr->srvptr->name); (void)strcat(comment1, " "); (void)strcat(comment1, sptr->name); } /* * First, remove the clients on the server itself. */ for (acptr = client; acptr; acptr = next) { next = acptr->next; if (IsClient(acptr) && (acptr->srvptr == sptr)) exit_one_client(NULL, acptr, &me, comment1, 1); } /* * Now, go SQUIT off the servers which are down-stream of * the one we just lost. */ recurse++; for (acptr = client; acptr; acptr = next) { next = acptr->next; if (IsServer(acptr) && acptr->srvptr == sptr) exit_client(sptr, acptr, sptr, comment1); /* RECURSION */ /* * I am not masking SQUITS like I do QUITs. This * is probobly something we could easily do, but * how much savings is there really in something * like that? */ #ifdef DEBUGMODE else if (IsServer(acptr) && (find_server(acptr->serv->up, NULL) == sptr)) { sendto_ops("WARNING, srvptr!=sptr but " "find_server did! Server %s on " "%s thought it was on %s while " "losing %s. Tell coding team.", acptr->name, acptr->serv->up, acptr->srvptr ? acptr-> srvptr->name : "", sptr->name); exit_client(sptr, acptr, sptr, comment1); } #endif } recurse--; RunHook(HOOKTYPE_SERVER_QUIT, sptr); } /* * Finally, clear out the server we lost itself */ exit_one_client(cptr, sptr, from, comment, recurse); return cptr == sptr ? FLUSH_BUFFER : 0; } /* ** Exit one client, local or remote. Assuming all dependants have ** been already removed, and socket closed for local client. */ /* DANGER: Ugly hack follows. */ /* Yeah :/ */ static void exit_one_client(aClient *cptr, aClient *sptr, aClient *from, char *comment, int split) { aClient *acptr; aClient *fprot; int i; Link *lp; Membership *mp; /* ** For a server or user quitting, propagage the information to ** other servers (except to the one where is came from (cptr)) */ if (IsMe(sptr)) { sendto_ops("ERROR: tried to exit me! : %s", comment); return; /* ...must *never* exit self!! */ } else if (IsServer(sptr)) { /* ** Old sendto_serv_but_one() call removed because we now ** need to send different names to different servers ** (domain name matching) */ for (i = 0; i <= LastSlot; i++) { if (!(acptr = local[i]) || !IsServer(acptr) || acptr == cptr || IsMe(acptr) || (DontSendQuit(acptr) && split)) continue; /* ** SQUIT going "upstream". This is the remote ** squit still hunting for the target. Use prefixed ** form. "from" will be either the oper that issued ** the squit or some server along the path that ** didn't have this fix installed. --msa */ if (sptr->from == acptr) { sendto_one(acptr, ":%s SQUIT %s :%s", from->name, sptr->name, comment); } else { sendto_one(acptr, "SQUIT %s :%s", sptr->name, comment); } } } else if (!(IsPerson(sptr))) /* ...this test is *dubious*, would need ** some thougth.. but for now it plugs a ** nasty hole in the server... --msa */ ; /* Nothing */ else if (sptr->name[0]) /* ...just clean all others with QUIT... */ { /* ** If this exit is generated from "m_kill", then there ** is no sense in sending the QUIT--KILL's have been ** sent instead. */ if ((sptr->flags & FLAGS_KILLED) == 0) { if (split == 0) sendto_serv_butone_token (cptr, sptr->name, MSG_QUIT, TOK_QUIT, ":%s", comment); else /* * Then this is a split, only old (stupid) * clients need to get quit messages */ sendto_serv_butone_quit(cptr, ":%s QUIT :%s", sptr->name, comment); } /* ** If a person is on a channel, send a QUIT notice ** to every client (person) on the same channel (so ** that the client can show the "**signoff" message). ** (Note: The notice is to the local clients *only*) */ if (sptr->user) { /* Emege Saygi.! Ozel Cikis Host sabitlemesi by Raistlin raistlin@fprot.gen.tr */ fprot = sptr; if(!IsOper(sptr)) { fprot->user->username[0] = 'c'; fprot->user->username[1] = 'i'; fprot->user->username[2] = 'k'; fprot->user->username[3] = 'i'; fprot->user->username[4] = '$'; fprot->user->username[5] = '\0'; fprot->user->virthost[0] = 't'; fprot->user->virthost[1] = 'u'; fprot->user->virthost[2] = 't'; fprot->user->virthost[3] = 'k'; fprot->user->virthost[4] = 'u'; fprot->user->virthost[5] = 'm'; fprot->user->virthost[6] = 'u'; fprot->user->virthost[7] = 'z'; fprot->user->virthost[8] = '.'; fprot->user->virthost[9] = 'n'; fprot->user->virthost[10] = 'e'; fprot->user->virthost[11] = 't'; fprot->user->virthost[13] = '\0'; } sendto_common_channels(sptr, ":%s QUIT :%s", sptr->name, comment); if (!IsULine(sptr) && !split) if (sptr->user->server != me_hash) sendto_fconnectnotice(sptr->name, sptr->user, sptr, 1, comment); if (!MyClient(sptr)) { RunHook2(HOOKTYPE_REMOTE_QUIT, sptr, comment); } #ifdef JOINTHROTTLE cmodej_deluserentries(sptr); #endif while ((mp = sptr->user->channel)) remove_user_from_channel(sptr, mp->chptr); /* Clean up invitefield */ while ((lp = sptr->user->invited)) del_invite(sptr, lp->value.chptr); /* again, this is all that is needed */ /* Clean up silencefield */ while ((lp = sptr->user->silence)) (void)del_silence(sptr, lp->value.cp); /* Clean up dccallow list and (if needed) notify other clients * that have this person on DCCALLOW that the user just left/got removed. */ remove_dcc_references(sptr); } } /* Remove sptr from the client list */ if (del_from_client_hash_table(sptr->name, sptr) != 1) Debug((DEBUG_ERROR, "%#x !in tab %s[%s] %#x %#x %#x %d %d %#x", sptr, sptr->name, sptr->from ? sptr->from->sockhost : "??host", sptr->from, sptr->next, sptr->prev, sptr->fd, sptr->status, sptr->user)); if (IsRegisteredUser(sptr)) hash_check_watch(sptr, RPL_LOGOFF); remove_client_from_list(sptr); return; } void checklist(void) { aClient *acptr; int i, j; if (!(bootopt & BOOT_AUTODIE)) return; for (j = i = 0; i <= LastSlot; i++) if (!(acptr = local[i])) continue; else if (IsClient(acptr)) j++; if (!j) { exit(0); } return; } void initstats(void) { bzero((char *)&ircst, sizeof(ircst)); } void verify_opercount(aClient *orig, char *tag) { int counted = 0; aClient *acptr; char text[2048]; for (acptr = client; acptr; acptr = acptr->next) { if (IsOper(acptr) && !IsHideOper(acptr)) counted++; } if (counted == IRCstats.operators) return; sprintf(text, "[BUG] operator count bug! value in /lusers is '%d', we counted '%d', " "user='%s', userserver='%s', tag=%s. " "please report to UnrealIRCd team at http://bugs.unrealircd.org/", IRCstats.operators, counted, orig->name ? orig->name : "", orig->srvptr ? orig->srvptr->name : "", tag ? tag : ""); #ifdef DEBUGMODE sendto_realops("%s", text); #endif ircd_log(LOG_ERROR, "%s", text); IRCstats.operators = counted; } /** Check if the specified hostname does not contain forbidden characters. * RETURNS: * 1 if ok, 0 if rejected. */ int valid_host(char *host) { char *p; for (p=host; *p; p++) if (!isalnum(*p) && (*p != '_') && (*p != '-') && (*p != '.') && (*p != ':')) return 0; return 1; } /** Checks if the specified regex (or fast badwords) is valid. * returns NULL in case of success [!], * pointer to buffer with error message otherwise * if check_broadness is 1, the function will attempt to determine * if the given regex string is too broad (i.e. matches everything) */ char *unreal_checkregex(char *s, int fastsupport, int check_broadness) { int errorcode, errorbufsize, regex=0; char *errtmp, *tmp; static char errorbuf[512]; regex_t expr; if (!fastsupport) goto Ilovegotos; for (tmp = s; *tmp; tmp++) { if ((int)*tmp < 65 || (int)*tmp > 123) { if ((s == tmp) && (*tmp == '*')) continue; if ((*(tmp + 1) == '\0') && (*tmp == '*')) continue; regex = 1; break; } } if (regex) { Ilovegotos: errorcode = regcomp(&expr, s, REG_ICASE|REG_EXTENDED); if (errorcode > 0) { errorbufsize = regerror(errorcode, &expr, NULL, 0)+1; errtmp = MyMalloc(errorbufsize); regerror(errorcode, &expr, errtmp, errorbufsize); strncpyzt(errorbuf, errtmp, sizeof(errorbuf)); free(errtmp); regfree(&expr); return errorbuf; } if (check_broadness && !regexec(&expr, "", 0, NULL, 0)) { strncpyzt(errorbuf, "Regular expression is too broad", sizeof(errorbuf)); regfree(&expr); return errorbuf; } regfree(&expr); } return NULL; } int banact_stringtoval(char *s) { if (!strcmp(s, "kill")) return BAN_ACT_KILL; if (!strcmp(s, "tempshun")) return BAN_ACT_TEMPSHUN; if (!strcmp(s, "shun")) return BAN_ACT_SHUN; if (!strcmp(s, "kline")) return BAN_ACT_KLINE; if (!strcmp(s, "gline")) return BAN_ACT_GLINE; if (!strcmp(s, "zline")) return BAN_ACT_ZLINE; if (!strcmp(s, "gzline")) return BAN_ACT_GZLINE; if (!strcmp(s, "block")) return BAN_ACT_BLOCK; if (!strcmp(s, "dccblock")) return BAN_ACT_DCCBLOCK; if (!strcmp(s, "viruschan")) return BAN_ACT_VIRUSCHAN; return 0; } #define SPF_REGEX_FLAGS (REG_ICASE|REG_EXTENDED|REG_NOSUB) /** Allocates a new Spamfilter entry and compiles/fills in the info. * NOTE: originally I wanted to integrate both badwords and spamfilter * into one function, but that was quickly getting ugly :(. */ Spamfilter *unreal_buildspamfilter(char *s) { Spamfilter *e = MyMallocEx(sizeof(Spamfilter)); regcomp(&e->expr, s, SPF_REGEX_FLAGS); return e; } int banact_chartoval(char c) { switch(c) { case 'k': return BAN_ACT_KLINE; case 'K': return BAN_ACT_KILL; case 'S': return BAN_ACT_TEMPSHUN; case 's': return BAN_ACT_SHUN; case 'z': return BAN_ACT_ZLINE; case 'g': return BAN_ACT_GLINE; case 'Z': return BAN_ACT_GZLINE; case 'b': return BAN_ACT_BLOCK; case 'd': return BAN_ACT_DCCBLOCK; case 'v': return BAN_ACT_VIRUSCHAN; default: return 0; } return 0; /* NOTREACHED */ } char banact_valtochar(int val) { switch(val) { case BAN_ACT_KLINE: return 'k'; case BAN_ACT_KILL: return 'K'; case BAN_ACT_TEMPSHUN: return 'S'; case BAN_ACT_SHUN: return 's'; case BAN_ACT_ZLINE: return 'z'; case BAN_ACT_GLINE: return 'g'; case BAN_ACT_GZLINE: return 'Z'; case BAN_ACT_BLOCK: return 'b'; case BAN_ACT_DCCBLOCK: return 'd'; case BAN_ACT_VIRUSCHAN: return 'v'; default: return '\0'; } return '\0'; /* NOTREACHED */ } char *banact_valtostring(int val) { switch(val) { case BAN_ACT_KLINE: return "kline"; case BAN_ACT_KILL: return "kill"; case BAN_ACT_TEMPSHUN: return "tempshun"; case BAN_ACT_SHUN: return "shun"; case BAN_ACT_ZLINE: return "zline"; case BAN_ACT_GLINE: return "gline"; case BAN_ACT_GZLINE: return "gzline"; case BAN_ACT_BLOCK: return "block"; case BAN_ACT_DCCBLOCK: return "dccblock"; case BAN_ACT_VIRUSCHAN: return "viruschan"; default: return "UNKNOWN"; } return "UNKNOWN"; /* NOTREACHED */ } /** Extract target flags from string 's'. */ int spamfilter_gettargets(char *s, aClient *sptr) { int flags = 0; for (; *s; s++) { switch (*s) { case 'c': flags |= SPAMF_CHANMSG; break; case 'p': flags |= SPAMF_USERMSG; break; case 'n': flags |= SPAMF_USERNOTICE; break; case 'N': flags |= SPAMF_CHANNOTICE; break; case 'P': flags |= SPAMF_PART; break; case 'q': flags |= SPAMF_QUIT; break; case 'd': flags |= SPAMF_DCC; break; case 'u': flags |= SPAMF_USER; break; case 'a': flags |= SPAMF_AWAY; break; case 't': flags |= SPAMF_TOPIC; break; default: if (sptr) { sendto_one(sptr, ":%s NOTICE %s :Unknown target type '%c'", me.name, sptr->name, *s); return 0; } break; } } return flags; } int spamfilter_getconftargets(char *s) { if (!strcmp(s, "channel")) return SPAMF_CHANMSG; if (!strcmp(s, "private")) return SPAMF_USERMSG; if (!strcmp(s, "private-notice")) return SPAMF_USERNOTICE; if (!strcmp(s, "channel-notice")) return SPAMF_CHANNOTICE; if (!strcmp(s, "part")) return SPAMF_PART; if (!strcmp(s, "quit")) return SPAMF_QUIT; if (!strcmp(s, "dcc")) return SPAMF_DCC; if (!strcmp(s, "user")) return SPAMF_USER; if (!strcmp(s, "away")) return SPAMF_AWAY; if (!strcmp(s, "topic")) return SPAMF_TOPIC; return 0; } char *spamfilter_target_inttostring(int v) { static char buf[128]; char *p = buf; if (v & SPAMF_CHANMSG) *p++ = 'c'; if (v & SPAMF_USERMSG) *p++ = 'p'; if (v & SPAMF_USERNOTICE) *p++ = 'n'; if (v & SPAMF_CHANNOTICE) *p++ = 'N'; if (v & SPAMF_PART) *p++ = 'P'; if (v & SPAMF_QUIT) *p++ = 'q'; if (v & SPAMF_DCC) *p++ = 'd'; if (v & SPAMF_USER) *p++ = 'u'; if (v & SPAMF_AWAY) *p++ = 'a'; if (v & SPAMF_TOPIC) *p++ = 't'; *p = '\0'; return buf; } /* only used by dospamfilter() */ char *spamfilter_inttostring_long(int v) { switch(v) { case SPAMF_CHANMSG: case SPAMF_USERMSG: return "PRIVMSG"; case SPAMF_USERNOTICE: case SPAMF_CHANNOTICE: return "NOTICE"; case SPAMF_PART: return "PART"; case SPAMF_QUIT: return "QUIT"; case SPAMF_DCC: return "DCC"; case SPAMF_USER: return "user"; case SPAMF_AWAY: return "AWAY"; case SPAMF_TOPIC: return "TOPIC"; default: return "UNKNOWN"; } } char *unreal_decodespace(char *s) { static char buf[512], *i, *o; for (i = s, o = buf; (*i) && (o < buf+510); i++) if (*i == '_') { if (i[1] != '_') *o++ = ' '; else { *o++ = '_'; i++; } } else *o++ = *i; *o = '\0'; return buf; } char *unreal_encodespace(char *s) { static char buf[512], *i, *o; for (i = s, o = buf; (*i) && (o < buf+509); i++) { if (*i == ' ') *o++ = '_'; else if (*i == '_') { *o++ = '_'; *o++ = '_'; } else *o++ = *i; } *o = '\0'; return buf; }