services.h

Go to the documentation of this file.

/*
 *
 * (C) 2003-2007 Anope Team
 * Contact us at info@anope.org
 *
 * Please read COPYING and README for furhter details.
 *
 * Based on the original code of Epona by Lara.
 * Based on the original code of Services by Andy Church. 
 * 
 *
 */

#ifndef SERVICES_H
#define SERVICES_H

/*************************************************************************/

#include "sysconf.h"
#include "config.h"

#ifndef MAX_CMD_HASH
#define MAX_CMD_HASH 1024
#endif

/* Some Linux boxes (or maybe glibc includes) require this for the
 * prototype of strsignal(). */
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif

/* Some SUN fixs */
#ifdef __sun
/* Solaris specific code, types that do not exist in Solaris'
 * sys/types.h
 **/
#undef u_int8_t
#undef u_int16_t
#undef u_int32_t
#undef u_int_64_t
#define u_int8_t uint8_t
#define u_int16_t uint16_t
#define u_int32_t uint32_t
#define u_int64_t uint64_t

#ifndef INADDR_NONE
#define INADDR_NONE (-1)
#endif

#endif


#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Windows does not have:
 * unistd.h, grp.h,
 * netdb.h, netinet/in.h,
 * sys/socket.h, sys/time.h
 * Windows requires:
 * winsock.h
 * -- codemastr
 */

#ifndef _WIN32
#include <unistd.h>
#endif

#include <signal.h>
#include <time.h>
#include <errno.h>

#ifndef _WIN32
#include <grp.h>
#endif

#include <limits.h>

#ifndef _WIN32
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#else
#include <winsock.h>
#include <windows.h>
#endif

#include <sys/stat.h>   /* for umask() on some systems */
#include <sys/types.h>

#ifndef _WIN32
#include <sys/time.h>
#endif

#ifdef _WIN32
#include <sys/timeb.h>
#include <direct.h>
#include <io.h>
#endif

#include <fcntl.h>

#ifndef _WIN32
#ifdef HAVE_BACKTRACE
#include <execinfo.h>
#endif
#endif

#ifndef _WIN32
#include <dirent.h>
#endif

#ifdef _WIN32
/* VS2008 hates having this define before its own */
#define vsnprintf               _vsnprintf
#endif

#ifdef USE_RDB
# define MAX_SQL_BUF   4096
#endif

#ifdef USE_MYSQL
# define MYSQL_WARNING 2
# define MYSQL_ERROR   4
# define MYSQL_DEFAULT_PORT 3306
#ifdef MYSQL_HEADER_PREFIX
# include <mysql/mysql.h>
# include <mysql/errmsg.h>
#else
# include <mysql.h>
# include <errmsg.h>
#endif
#endif

#if HAVE_STRINGS_H
# include <strings.h>
#endif

#if HAVE_SYS_SELECT_H
# include <sys/select.h>
#endif

#include "sockets.h"

#ifndef va_copy
# ifdef __va_copy
#  define VA_COPY(DEST,SRC) __va_copy((DEST),(SRC))
# else
#  define VA_COPY(DEST, SRC) memcpy ((&DEST), (&SRC), sizeof(va_list))
# endif
#else
# ifdef HAVE_VA_LIST_AS_ARRAY
#   define VA_COPY(DEST,SRC) (*(DEST) = *(SRC))
# else
#   define VA_COPY(DEST, SRC) va_copy(DEST, SRC)
# endif
#endif 

#ifdef _AIX
/* Some AIX boxes seem to have bogus includes that don't have these
 * prototypes. */
extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, size_t);
# if 0  /* These break on some AIX boxes (4.3.1 reported). */
extern int gettimeofday(struct timeval *, struct timezone *);
extern int socket(int, int, int);
extern int bind(int, struct sockaddr *, int);
extern int connect(int, struct sockaddr *, int);
extern int shutdown(int, int);
# endif
# undef FD_ZERO
# define FD_ZERO(p) memset((p), 0, sizeof(*(p)))
#endif /* _AIX */

/* Alias stricmp/strnicmp to strcasecmp/strncasecmp if we have the latter
 * but not the former. */
#if !HAVE_STRICMP && HAVE_STRCASECMP
# define stricmp strcasecmp
# define strnicmp strncasecmp
#endif

/* We have our own versions of toupper()/tolower(). */
#include <ctype.h>
#undef tolower
#undef toupper
#define tolower tolower_
#define toupper toupper_

/* We also have our own encrypt(). */
#define encrypt encrypt_


#ifdef __WINS__
#ifndef BKCHECK
#define BKCHECK
  extern "C" void __pfnBkCheck() {}
#endif
#endif


#if INTTYPE_WORKAROUND
# undef int16
# undef int32
#endif


/* Miscellaneous definitions. */
#include "defs.h"
#include "slist.h"
#include "events.h"

/*************************************************************************/

typedef struct server_ Server;
typedef struct user_ User;
typedef struct channel_ Channel;
typedef struct ModuleData_ ModuleData;          /* ModuleData struct */
typedef struct memo_ Memo;
typedef struct nickrequest_ NickRequest;
typedef struct nickalias_ NickAlias;
typedef struct nickcore_ NickCore;
typedef struct botinfo_ BotInfo;
typedef struct chaninfo_ ChannelInfo;
typedef struct badword_ BadWord;
typedef struct bandata_ BanData;
typedef struct userdata_ UserData;
typedef struct mailinfo_ MailInfo;
typedef struct akill_ Akill;
typedef struct sxline_ SXLine;
typedef struct hostcore_ HostCore;
typedef struct newsitem_ NewsItem;
typedef struct exception_ Exception;
typedef struct cbmode_ CBMode;
typedef struct cbmodeinfo_ CBModeInfo;
typedef struct cmmode_ CMMode;
typedef struct csmode_ CSMode;
typedef struct cumode_ CUMode;
typedef struct csmodeutil_ CSModeUtil;
typedef struct session_ Session;
typedef struct uid_ Uid;

/*************************************************************************/

/* Windows defines a boolean type as an 
 * unsigned char. It does however need
 * true/false. -- codemastr
 */
#ifndef _WIN32
typedef enum { false, true } boolean;
#else
 #ifndef true
  #define true 1
 #endif
 #ifndef false
  #define false 0
 #endif
#endif /* _WIN32 */

/*************************************************************************/

/* Protocol tweaks */

typedef struct ircdvars_ IRCDVar;
typedef struct ircdcapab_ IRCDCAPAB;

struct ircdvars_ {
    char *name;             /* Name of the ChanServ command */
    char *nickservmode;         /* Mode used by NickServ    */
    char *chanservmode;         /* Mode used by ChanServ    */
    char *memoservmode;         /* Mode used by MemoServ    */
    char *hostservmode;         /* Mode used by HostServ    */
    char *operservmode;         /* Mode used by OperServ    */
    char *botservmode;          /* Mode used by BotServ     */
    char *helpservmode;         /* Mode used by HelpServ    */
    char *devnullmode;          /* Mode used by Dev/Null    */
    char *globalmode;           /* Mode used by Global      */
    char *nickservaliasmode;        /* Mode used by NickServ Alias  */
    char *chanservaliasmode;        /* Mode used by ChanServ Alias  */
    char *memoservaliasmode;        /* Mode used by MemoServ Alias  */
    char *hostservaliasmode;        /* Mode used by HostServ Alias  */
    char *operservaliasmode;        /* Mode used by OperServ Alias  */
    char *botservaliasmode;         /* Mode used by BotServ  Alias  */
    char *helpservaliasmode;        /* Mode used by HelpServ Alias  */
    char *devnullvaliasmode;        /* Mode used by Dev/Null Alias  */
    char *globalaliasmode;          /* Mode used by Global   Alias  */
    char *botserv_bot_mode;         /* Mode used by BotServ Bots    */
    int max_symbols;            /* Chan Max Symbols     */
    char *modestoremove;            /* Channel Modes to remove  */
    char *botchanumode;         /* Modes set when botserv joins a channel */
    int svsnick;                /* Supports SVSNICK     */
    int vhost;              /* Supports vhost       */
    int owner;              /* Supports Owner       */
    char *ownerset;             /* Mode to set for owner    */
    char *ownerunset;           /* Mode to unset for a owner    */
    char *adminset;             /* Mode to set for admin    */
    char *adminunset;           /* Mode to unset for admin  */
    char *modeonreg;            /* Mode on Register     */
    char *rootmodeonid;                     /* Mode on ID for ROOTS         */
    char *adminmodeonid;                    /* Mode on ID for ADMINS        */
    char *opermodeonid;                     /* Mode on ID for OPERS         */
    char *modeonunreg;          /* Mode on Unregister       */
    char *modeonnick;           /* Mode on nick change      */
    int sgline;             /* Supports SGline      */
    int sqline;             /* Supports SQline      */
    int szline;             /* Supports SZline      */
    int halfop;             /* Supports HalfOp      */
    int numservargs;            /* Number of Server Args    */
    int join2set;               /* Join 2 Set Modes     */
    int join2msg;               /* Join 2 Message       */
    int except;             /* exception +e         */
    int topictsforward;         /* TS on Topics Forward     */
    int topictsbackward;            /* TS on Topics Backward    */
    uint32 protectedumode;          /* What is the Protected Umode  */
    int admin;              /* Has Admin            */
    int chansqline;             /* Supports Channel Sqlines */
    int quitonkill;             /* IRCD sends QUIT when kill    */
    int svsmode_unban;          /* svsmode can be used to unban */
    int protect;                /* Has protect modes        */
    int reversekickcheck;           /* Can reverse ban check    */
    int chanreg;                /* channel mode +r for register */
    uint32 regmode;             /* Mode to use for +r       */
    int vident;             /* Supports vidents     */
    int svshold;                /* Supports svshold     */
    int tsonmode;               /* Timestamp on mode changes    */
    int nickip;                 /* Sends IP on NICK     */
    int omode;                  /* On the fly o:lines       */
    int umode;                  /* change user modes        */
    int nickvhost;              /* Users vhost sent during NICK */
    int chgreal;                /* Change RealName      */
    uint32 noknock;             /* Channel Mode for no knock    */
    uint32 adminmode;           /* Admin Only Channel Mode  */
    uint32 defmlock;            /* Default mlock modes      */
    uint32 vhostmode;           /* Vhost mode           */
    int fmode;                  /* +f               */
    int Lmode;                  /* +L               */
    uint32 chan_fmode;          /* Mode             */
    uint32 chan_lmode;          /* Mode             */
    int check_nick_id;          /* On nick change check if they could be identified */
    int knock_needs_i;          /* Check if we needed +i when setting NOKNOCK */
    char *chanmodes;            /* If the ircd sends CHANMODE in CAPAB this is where we store it */
    int token;                  /* Does Anope support the tokens for the ircd */
    int tokencaseless;          /* TOKEN are not case senstive - most its Unreal that is case senstive */
    int sjb64;                  /* Base 64 encode TIMESTAMP */
    int invitemode;             /* +I  */
    int sjoinbanchar;           /* use single quotes to define it */
    int sjoinexchar;            /* use single quotes to define it */
    int sjoininvchar;           /* use single quotes to define it */
    int svsmode_ucmode;         /* Can remove User Channel Modes with SVSMODE */
    int sglineenforce;
    char *vhostchar;            /* char used for vhosting */
    int ts6;                    /* ircd is TS6 */
    int supporthelper;          /* +h helper umodes */
    int p10;                    /* ircd is P10  */
    char *nickchars;            /* character set */
    int sync;                   /* reports sync state */
};

struct ircdcapab_ {
  uint32 noquit;
  uint32 tsmode;
  uint32 unconnect;  
  uint32 nickip;
  uint32 nsjoin;
  uint32 zip;
  uint32 burst;
  uint32 ts5;
  uint32 ts3;
  uint32 dkey;
  uint32 pt4;
  uint32 scs;
  uint32 qs;
  uint32 uid;
  uint32 knock;
  uint32 client;
  uint32 ipv6;
  uint32 ssj5;
  uint32 sn2;
  uint32 token;
  uint32 vhost;
  uint32 ssj3;
  uint32 nick2;
  uint32 umode2;
  uint32 vl;
  uint32 tlkext;
  uint32 dodkey;
  uint32 dozip;
  uint32 chanmodes;
  uint32 sjb64;
  uint32 nickchars;
};

/* tiny struct needed for P10 and other UID servers so we can track 
   services UID
*/
struct uid_ {
    Uid *next, *prev;
    char nick[NICKMAX];
    char *uid;
};

/*************************************************************************/
/* Config Details */
/*************************************************************************/

#define MAXPARAMS   8

/* Configuration directives */

typedef struct {
    char *name;
    struct {
        int type;               /* PARAM_* below */
        int flags;              /* Same */
        void *ptr;              /* Pointer to where to store the value */
    } params[MAXPARAMS];
} Directive;

#define PARAM_NONE  0
#define PARAM_INT   1
#define PARAM_POSINT    2       /* Positive integer only */
#define PARAM_PORT  3       /* 1..65535 only */
#define PARAM_STRING    4
#define PARAM_TIME  5
#define PARAM_STRING_ARRAY 6    /* Array of string */
#define PARAM_SET   -1      /* Not a real parameter; just set the
                                 *    given integer variable to 1 */
#define PARAM_DEPRECATED -2     /* Set for deprecated directives; `ptr'
                                 *    is a function pointer to call */

/* Flags: */
#define PARAM_OPTIONAL  0x01
#define PARAM_FULLONLY  0x02    /* Directive only allowed if !STREAMLINED */
#define PARAM_RELOAD    0x04    /* Directive is reloadable */

/*************************************************************************/

/* File version for each database. Was one version for all before but was
   changed so they are now easier to maintain. =) */

#define BOT_VERSION         10
#define CHAN_VERSION        16
#define EXCEPTION_VERSION   9
#define NEWS_VERSION        9
#define NICK_VERSION        13
#define PRE_NICK_VERSION    1
#define OPER_VERSION        13
#define HELP_VERSION        1
#define HOST_VERSION        3

/*************************************************************************/


struct ModuleData_ {
    char *moduleName;                       /* Which module we belong to */
    char *key;                              /* The key */
    char *value;                            /* The Value */
    ModuleData *next;                       /* The next ModuleData record */
};
 
 /*************************************************************************/

/* Memo info structures.  Since both nicknames and channels can have memos,
 * we encapsulate memo data in a MemoList to make it easier to handle. */

struct memo_ {
    uint32 number;  /* Index number -- not necessarily array position! */
    uint16 flags;
    time_t time;    /* When it was sent */
    char sender[NICKMAX];
    char *text;
    ModuleData *moduleData;     /* Module saved data attached to the Memo */
#ifdef USE_MYSQL
    uint32 id;      /* Database ID; see mysql.c */
#endif
};

typedef struct {
    int16 memocount, memomax;
    Memo *memos;
} MemoInfo;

/*************************************************************************/

/* NickServ nickname structures. */


struct nickrequest_ {
    NickRequest *next, *prev;
    char *nick;
    char *passcode;
    char *password;
    char *email;
    time_t requested;
    time_t lastmail;            /* Unsaved */
};

struct nickalias_ {
    NickAlias *next, *prev;
    char *nick;             /* Nickname */
    char *last_quit;            /* Last quit message */
    char *last_realname;            /* Last realname */
    char *last_usermask;            /* Last usermask */
        time_t time_registered;         /* When the nick was registered */
        time_t last_seen;           /* When it was seen online for the last time */
        uint16 status;              /* See NS_* below */
        NickCore *nc;               /* I'm an alias of this */
        /* Not saved */
        ModuleData *moduleData;         /* Module saved data attached to the nick alias */
        User *u;                /* Current online user that has me */
};

struct nickcore_ {
    NickCore *next, *prev;

    char *display;              /* How the nick is displayed */
    char *pass;             /* Password of the nicks */
    char *email;                /* E-mail associated to the nick */
    char *greet;                /* Greet associated to the nick */
    uint32 icq;             /* ICQ # associated to the nick */
    char *url;              /* URL associated to the nick */
    uint32 flags;               /* See NI_* below */
    uint16 language;            /* Language selected by nickname owner (LANG_*) */
        uint16 accesscount;         /* # of entries */
        char **access;              /* Array of strings */
        MemoInfo memos;
        uint16 channelcount;            /* Number of channels currently registered */
        uint16 channelmax;          /* Maximum number of channels allowed */

        /* Unsaved data */
        ModuleData *moduleData;     /* Module saved data attached to the NickCore */
        time_t lastmail;            /* Last time this nick record got a mail */
        SList aliases;              /* List of aliases */
};


/*************************************************************************/

/* Bot info structures. Note that since there won't be many bots,
 * they're not in a hash list.
 *  --lara
 */

struct botinfo_ {
    BotInfo *next, *prev;

    char *nick;             /* Nickname of the bot */
    char *user;             /* Its user name */
    char *host;             /* Its hostname */
    char *real;             /* Its real name */
    int16 flags;            /* Bot flags -- see BI_* below */
    time_t created;         /* Birth date ;) */
    int16 chancount;        /* Number of channels that use the bot. */
    /* Dynamic data */
    time_t lastmsg;         /* Last time we said something */
};



/* Channel info structures.  Stored similarly to the nicks, except that
 * the second character of the channel name, not the first, is used to
 * determine the list.  (Hashing based on the first character of the name
 * wouldn't get very far. ;) ) */

/* Access levels for users. */
typedef struct {
    uint16 in_use;  /* 1 if this entry is in use, else 0 */
    int16 level;
    NickCore *nc;   /* Guaranteed to be non-NULL if in use, NULL if not */
    time_t last_seen;
} ChanAccess;

/* Note that these two levels also serve as exclusive boundaries for valid
 * access levels.  ACCESS_FOUNDER may be assumed to be strictly greater
 * than any valid access level, and ACCESS_INVALID may be assumed to be
 * strictly less than any valid access level. Also read below.
 */
#define ACCESS_FOUNDER  10000   /* Numeric level indicating founder access */
#define ACCESS_INVALID  -10000  /* Used in levels[] for disabled settings */
/* There is one exception to the above access levels: SuperAdmins will have
 * access level 10001. This level is never stored, however; it is only used
 * in comparison and to let SuperAdmins win from founders where needed
 */
#define ACCESS_SUPERADMIN 10001

/* Levels for xOP */

#define ACCESS_VOP      3
#define ACCESS_HOP          4
#define ACCESS_AOP      5
#define ACCESS_SOP      10

/* AutoKick data. */
typedef struct {
    int16 in_use;   /* Always 0 if not in use */
    int16 is_nick;  /* 1 if a regged nickname, 0 if a nick!user@host mask */
    uint16 flags;
    union {
        char *mask;     /* Guaranteed to be non-NULL if in use, NULL if not */
        NickCore *nc;   /* Same */
    } u;
    char *reason;

    char *creator;
    time_t addtime;
} AutoKick;

#define AK_USED     0x0001
#define AK_ISNICK   0x0002
#define AK_STUCK        0x0004

/* Structure used to contain bad words. */

struct badword_ {
    uint16 in_use;
    char *word;
    uint16 type;        /* BW_* below */
};

#define BW_ANY      0
#define BW_SINGLE   1
#define BW_START    2
#define BW_END      3


struct chaninfo_ {
    ChannelInfo *next, *prev;
    char name[CHANMAX];
    NickCore *founder;
    NickCore *successor;        /* Who gets the channel if the founder
                                 * nick is dropped or expires */
    char founderpass[PASSMAX];
    char *desc;
    char *url;
    char *email;

    time_t time_registered;
    time_t last_used;
    char *last_topic;           /* Last topic on the channel */
    char last_topic_setter[NICKMAX];    /* Who set the last topic */
    time_t last_topic_time;     /* When the last topic was set */

    uint32 flags;               /* See below */
    char *forbidby;
    char *forbidreason;

    int16 bantype;
    int16 *levels;              /* Access levels for commands */

    uint16 accesscount;
    ChanAccess *access;         /* List of authorized users */
    uint16 akickcount;
    AutoKick *akick;            /* List of users to kickban */

    uint32 mlock_on, mlock_off;     /* See channel modes below */
    uint32 mlock_limit;         /* 0 if no limit */
    char *mlock_key;            /* NULL if no key */
    char *mlock_flood;          /* NULL if no +f */
    char *mlock_redirect;       /* NULL if no +L */

    char *entry_message;        /* Notice sent on entering channel */

    MemoInfo memos;

    struct channel_ *c;         /* Pointer to channel record (if   *
                                 *    channel is currently in use) */
                                 
    ModuleData *moduleData;     /* Module saved data attached to the ChannelInfo */

    /* For BotServ */

    BotInfo *bi;                    /* Bot used on this channel */
    uint32 botflags;                /* BS_* below */
    int16 *ttb;                     /* Times to ban for each kicker */

    uint16 bwcount;
    BadWord *badwords;              /* For BADWORDS kicker */
    int16 capsmin, capspercent;     /* For CAPS kicker */
    int16 floodlines, floodsecs;    /* For FLOOD kicker */
    int16 repeattimes;              /* For REPEAT kicker */
};

/* Retain topic even after last person leaves channel */
#define CI_KEEPTOPIC    0x00000001
/* Don't allow non-authorized users to be opped */
#define CI_SECUREOPS    0x00000002
/* Hide channel from ChanServ LIST command */
#define CI_PRIVATE  0x00000004
/* Topic can only be changed by SET TOPIC */
#define CI_TOPICLOCK    0x00000008
/* Those not allowed ops are kickbanned */
#define CI_RESTRICTED   0x00000010
/* Don't allow ChanServ and BotServ commands to do bad things to bigger levels */
#define CI_PEACE  0x00000020
/* Don't allow any privileges unless a user is IDENTIFY'd with NickServ */
#define CI_SECURE   0x00000040
/* Don't allow the channel to be registered or used */
#define CI_VERBOTEN 0x00000080
/* Channel password is encrypted */
#define CI_ENCRYPTEDPW  0x00000100
/* Channel does not expire */
#define CI_NO_EXPIRE    0x00000200
/* Channel memo limit may not be changed */
#define CI_MEMO_HARDMAX 0x00000400
/* Send notice to channel on use of OP/DEOP */
#define CI_OPNOTICE 0x00000800
/* Stricter control of channel founder status */
#define CI_SECUREFOUNDER 0x00001000
/* Always sign kicks */
#define CI_SIGNKICK 0x00002000
/* Sign kicks if level is < than the one defined by the SIGNKICK level */
#define CI_SIGNKICK_LEVEL 0x00004000
/* Use the xOP lists */
#define CI_XOP 0x00008000
/* Channel is suspended */
#define CI_SUSPENDED 0x00010000

/* TEMPORARY - ChanServ is on the channel. */
#define CI_INHABIT 0x80000000

/* Indices for cmd_access[]: */
#define CA_INVITE           0