trunk/include/client.h

/*
 *  ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
 *
 *  Copyright (c) 1997-2015 ircd-hybrid development team
 *
 *  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 2 of the License, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
 *  USA
 */

/*! \file client.h
 * \brief Header including structures, macros and prototypes for client handling
 * \version $Id$
 */


#ifndef INCLUDED_client_h
#define INCLUDED_client_h

#include "list.h"
#include "fdlist.h"
#include "config.h"
#include "ircd_defs.h"
#include "dbuf.h"
#include "channel.h"
#include "auth.h"

struct MaskItem;

/*
 * status macros.
 */
enum
{
  STAT_CONNECTING = 0x00000001U,
  STAT_HANDSHAKE  = 0x00000002U,
  STAT_ME         = 0x00000004U,
  STAT_UNKNOWN    = 0x00000008U,
  STAT_SERVER     = 0x00000010U,
  STAT_CLIENT     = 0x00000020U
};

enum
{
  REG_NEED_USER = 0x00000001U,  /**< User must send USER command */
  REG_NEED_NICK = 0x00000002U,  /**< User must send NICK command */
  REG_NEED_CAP  = 0x00000004U,  /**< In middle of CAP negotiations */
  REG_INIT      = REG_NEED_USER | REG_NEED_NICK
};

#define ID_or_name(x,client_p)  ((IsServer(client_p->from) && (x)->id[0]) ? (x)->id : (x)->name)

#define IsConnecting(x)         ((x)->status == STAT_CONNECTING)
#define IsHandshake(x)          ((x)->status == STAT_HANDSHAKE)
#define IsMe(x)                 ((x)->status == STAT_ME)
#define IsUnknown(x)            ((x)->status == STAT_UNKNOWN)
#define IsServer(x)             ((x)->status == STAT_SERVER)
#define IsClient(x)             ((x)->status == STAT_CLIENT)

#define SetConnecting(x)        {(x)->status = STAT_CONNECTING; \
                                 (x)->handler = UNREGISTERED_HANDLER; }

#define SetHandshake(x)         {(x)->status = STAT_HANDSHAKE; \
                                 (x)->handler = UNREGISTERED_HANDLER; }

#define SetMe(x)                {(x)->status = STAT_ME; \
                                 (x)->handler = UNREGISTERED_HANDLER; }

#define SetUnknown(x)           {(x)->status = STAT_UNKNOWN; \
                                 (x)->handler = UNREGISTERED_HANDLER; }

#define SetServer(x)            {(x)->status = STAT_SERVER; \
                                 (x)->handler = SERVER_HANDLER; }

#define SetClient(x)            {(x)->status = STAT_CLIENT; \
                                 (x)->handler = CLIENT_HANDLER; }

#define MyConnect(x)            ((x)->connection != NULL)
#define MyClient(x)             (MyConnect(x) && IsClient(x))

/*
 * ts stuff
 */
enum
{
  TS_CURRENT = 6,  /**< Current TS protocol version */
  TS_MIN     = 6   /**< Minimum supported TS protocol version */
};

enum
{
  CAP_MULTI_PREFIX   = 0x00000001U,
  CAP_AWAY_NOTIFY    = 0x00000002U,
  CAP_UHNAMES        = 0x00000004U,
  CAP_EXTENDED_JOIN  = 0x00000008U,
  CAP_ACCOUNT_NOTIFY = 0x00000010U
};

#define HasCap(x, y) ((x)->connection->cap_active & (y))


/* housekeeping flags */
enum
{
  FLAGS_PINGSENT      = 0x00000001U,  /**< Unreplied ping sent */
  FLAGS_DEADSOCKET    = 0x00000002U,  /**< Local socket is dead--Exiting soon */
  FLAGS_KILLED        = 0x00000004U,  /**< Prevents "QUIT" from being sent for this */
  FLAGS_CLOSING       = 0x00000008U,  /**< Set when closing to suppress errors */
  FLAGS_GOTID         = 0x00000010U,  /**< Successful ident lookup achieved */
  FLAGS_SENDQEX       = 0x00000020U,  /**< Sendq exceeded */
  FLAGS_IPHASH        = 0x00000040U,  /**< Iphashed this client */
  FLAGS_MARK          = 0x00000080U,  /**< Marked client */
  FLAGS_CANFLOOD      = 0x00000100U,  /**< Client has the ability to flood */
  FLAGS_EXEMPTKLINE   = 0x00000200U,  /**< Client is exempt from k-lines */
  FLAGS_NOLIMIT       = 0x00000400U,  /**< Client is exempt from limits */
  FLAGS_PING_COOKIE   = 0x00000800U,  /**< PING Cookie */
  FLAGS_FLOODDONE     = 0x00001000U,  /**< Flood grace period has been ended. */
  FLAGS_EOB           = 0x00002000U,  /**< Server has sent us an EOB */
  FLAGS_HIDDEN        = 0x00004000U,  /**< A hidden server. Not shown in /links */
  FLAGS_BLOCKED       = 0x00008000U,  /**< Must wait for COMM_SELECT_WRITE */
  FLAGS_USERHOST      = 0x00010000U,  /**< Client is in userhost hash */
  FLAGS_BURSTED       = 0x00020000U,  /**< User was already bursted */
  FLAGS_EXEMPTRESV    = 0x00040000U,  /**< Client is exempt from RESV */
  FLAGS_GOTUSER       = 0x00080000U,  /**< If we received a USER command */
  FLAGS_FINISHED_AUTH = 0x00100000U,  /**< Client has been released from auth */
  FLAGS_FLOOD_NOTICED = 0x00200000U,  /**< Notice to opers about this flooder has been sent */
  FLAGS_SERVICE       = 0x00400000U,  /**< Client/server is a network service */
  FLAGS_SSL           = 0x00800000U,  /**< User is connected via TLS/SSL */
  FLAGS_SQUIT         = 0x01000000U,
  FLAGS_EXEMPTXLINE   = 0x02000000U   /**< Client is exempt from x-lines */
};

#define HasFlag(x, y) ((x)->flags &   (y))
#define AddFlag(x, y) ((x)->flags |=  (y))
#define DelFlag(x, y) ((x)->flags &= ~(y))


/* umodes, settable flags */
enum
{
  UMODE_SERVNOTICE   = 0x00000001U,  /**< Server notices such as kill */
  UMODE_CCONN        = 0x00000002U,  /**< Can see client connection notices */
  UMODE_REJ          = 0x00000004U,  /**< Bot Rejections */
  UMODE_SKILL        = 0x00000008U,  /**< Server Killed */
  UMODE_FULL         = 0x00000010U,  /**< Full messages */
  UMODE_SPY          = 0x00000020U,  /**< See STATS / LINKS */
  UMODE_DEBUG        = 0x00000040U,  /**< 'debugging' info */
  UMODE_NCHANGE      = 0x00000080U,  /**< Nick change notice */
  UMODE_WALLOP       = 0x00000100U,  /**< Send wallops to them */
  UMODE_INVISIBLE    = 0x00000200U,  /**< Makes user invisible */
  UMODE_BOTS         = 0x00000400U,  /**< Shows bots */
  UMODE_EXTERNAL     = 0x00000800U,  /**< Show servers introduced and splitting */
  UMODE_CALLERID     = 0x00001000U,  /**< Block unless caller id's */
  UMODE_SOFTCALLERID = 0x00002000U,  /**< Block unless on common channel */
  UMODE_UNAUTH       = 0x00004000U,  /**< Show unauth connects here */
  UMODE_LOCOPS       = 0x00008000U,  /**< Can see LOCOPS messages */
  UMODE_DEAF         = 0x00010000U,  /**< Don't receive channel messages */
  UMODE_REGISTERED   = 0x00020000U,  /**< User has identified for that nick. */
  UMODE_REGONLY      = 0x00040000U,  /**< Only registered nicks may PM */
  UMODE_HIDDEN       = 0x00080000U,  /**< IRC operator status is hidden */
  UMODE_OPER         = 0x00100000U,  /**< IRC operator */
  UMODE_ADMIN        = 0x00200000U,  /**< Admin on server */
  UMODE_FARCONNECT   = 0x00400000U,  /**< Can see remote client connects/exits */
  UMODE_HIDDENHOST   = 0x00800000U,  /**< User's host is hidden */
  UMODE_SSL          = 0x01000000U,  /**< User is connected via TLS/SSL */
  UMODE_WEBIRC       = 0x02000000U,  /**< User connected via a webirc gateway */
  UMODE_HIDEIDLE     = 0x04000000U,  /**< Hides idle and signon time in WHOIS */
  UMODE_HIDECHANS    = 0x08000000U   /**< Hides channel list in WHOIS */
};

#define HasUMode(x, y) ((x)->umodes &   (y))
#define AddUMode(x, y) ((x)->umodes |=  (y))
#define DelUMode(x, y) ((x)->umodes &= ~(y))


/* oper priv flags */
enum
{
  OPER_FLAG_KILL_REMOTE    = 0x00000001U,  /**< Oper can KILL remote users */
  OPER_FLAG_KILL           = 0x00000002U,  /**< Oper can KILL local users */
  OPER_FLAG_UNKLINE        = 0x00000004U,  /**< Oper can use UNKLINE command */
  OPER_FLAG_KLINE          = 0x00000008U,  /**< Oper can use KLINE command */
  OPER_FLAG_XLINE          = 0x00000010U,  /**< Oper can use XLINE command */
  OPER_FLAG_DIE            = 0x00000020U,  /**< Oper can use DIE command */
  OPER_FLAG_REHASH         = 0x00000040U,  /**< Oper can use REHASH command */
  OPER_FLAG_ADMIN          = 0x00000080U,  /**< Oper can set user mode +a */
  OPER_FLAG_REMOTEBAN      = 0x00000100U,  /**< Oper can set remote bans */
  OPER_FLAG_GLOBOPS        = 0x00000200U,  /**< Oper can use GLOBOPS command */
  OPER_FLAG_MODULE         = 0x00000400U,  /**< Oper can use MODULE command */
  OPER_FLAG_RESTART        = 0x00000800U,  /**< Oper can use RESTART command */
  OPER_FLAG_DLINE          = 0x00001000U,  /**< Oper can use DLINE command */
  OPER_FLAG_UNDLINE        = 0x00002000U,  /**< Oper can use UNDLINE command */
  OPER_FLAG_SET            = 0x00004000U,  /**< Oper can use SET command */
  OPER_FLAG_SQUIT          = 0x00008000U,  /**< Oper can do local SQUIT */
  OPER_FLAG_SQUIT_REMOTE   = 0x00010000U,  /**< Oper can do remote SQUIT */
  OPER_FLAG_CONNECT        = 0x00020000U,  /**< Oper can do local CONNECT */
  OPER_FLAG_CONNECT_REMOTE = 0x00040000U,  /**< Oper can do remote CONNECT */
  OPER_FLAG_WALLOPS        = 0x00080000U,  /**< Oper can use WALLOPS command */
  OPER_FLAG_LOCOPS         = 0x00100000U,  /**< Oper can use LOCOPS command */
  OPER_FLAG_UNXLINE        = 0x00200000U,  /**< Oper can use UNXLINE command */
  OPER_FLAG_OPME           = 0x00400000U,  /**< Oper can use OPME command */
  OPER_FLAG_JOIN_RESV      = 0x00800000U,  /**< Oper can use JOIN on resv {} channels */
  OPER_FLAG_NICK_RESV      = 0x01000000U,  /**< Oper can use NICK on resv {} nicks */
  OPER_FLAG_RESV           = 0x02000000U,  /**< Oper can use RESV command */
  OPER_FLAG_UNRESV         = 0x04000000U,  /**< Oper can use UNRESV command */
  OPER_FLAG_CLOSE          = 0x08000000U   /**< Oper can use CLOSE command */
};

#define HasOFlag(x, y) ((x)->connection->operflags &   (y))
#define AddOFlag(x, y) ((x)->connection->operflags |=  (y))
#define DelOFlag(x, y) ((x)->connection->operflags &= ~(y))
#define ClrOFlag(x)    ((x)->connection->operflags = 0)


/* flags macros. */
#define IsDead(x)               ((x)->flags & FLAGS_DEADSOCKET)
#define SetDead(x)              ((x)->flags |= FLAGS_DEADSOCKET)
#define IsDefunct(x)            ((x)->flags & (FLAGS_DEADSOCKET|FLAGS_CLOSING|FLAGS_KILLED))

/* oper flags */
#define SetOper(x)              {(x)->umodes |= UMODE_OPER; \
                                 if (MyClient((x))) (x)->handler = OPER_HANDLER;}

#define ClearOper(x)            {(x)->umodes &= ~(UMODE_OPER|UMODE_ADMIN); \
                                 if (MyClient((x))) \
                                  (x)->handler = CLIENT_HANDLER; }

#define IsFloodDone(x)          ((x)->flags &  FLAGS_FLOODDONE)
#define IsHidden(x)             ((x)->flags &  FLAGS_HIDDEN)


/*! \brief addr_mask_type enumeration */
enum addr_mask_type
{
  HIDE_IP, /**< IP is hidden. Resolved hostname is shown instead */
  SHOW_IP, /**< IP is shown. No parts of it are hidden or masked */
  MASK_IP  /**< IP is masked. 255.255.255.255 is shown instead */
};

struct ServicesTag
{
  dlink_node node;
  char *tag;
  unsigned int numeric;
  unsigned int umodes;
};

/*! \brief Server structure */
struct Server
{
  dlink_list server_list; /**< Servers on this server */
  dlink_list client_list; /**< Clients on this server */
  char by[NICKLEN + 1];   /**< Who activated this connection */
};

/*! \brief ListTask structure */
struct ListTask
{
  dlink_node node;  /**< Embedded list node used to link into listing_client_list */
  dlink_list show_mask; /**< Channels to show */
  dlink_list hide_mask; /**< Channels to hide */

  unsigned int hash_index; /**< The hash bucket we are currently in */
  unsigned int users_min;
  unsigned int users_max;
  unsigned int created_min;
  unsigned int created_max;
  unsigned int topicts_min;
  unsigned int topicts_max;
  char topic[TOPICLEN + 1];
};

/*! \brief Connection structure
 *
 * Allocated only for local clients, that are directly connected
 * to \b this server with a socket.
 */
struct Connection
{
  dlink_node   lclient_node;

  unsigned int registration;
  unsigned int cap_client;  /**< Client capabilities (from us) */
  unsigned int cap_active;  /**< Active capabilities (to us) */
  unsigned int       caps;  /**< Capabilities bit-field */

  unsigned int operflags;     /**< IRC Operator privilege flags */
  unsigned int random_ping; /**< Holding a 32bit value used for PING cookies */

  uint64_t serial;     /**< Used to enforce 1 send per nick */

  time_t       lasttime;   /**< ...should be only LOCAL clients? --msa */
  time_t       firsttime;  /**< Time client was created */
  time_t       since;      /**< Last time we parsed something */
  time_t       last_join_time;   /**< When this client last joined a channel */
  time_t       last_leave_time;  /**< When this client last left a channel */
  int          join_leave_count; /**< Count of JOIN/LEAVE in less than
                                         MIN_JOIN_LEAVE_TIME seconds */
  int          oper_warn_count_down; /**< Warn opers of this possible
                                          spambot every time this gets to 0 */
  time_t       last_caller_id_time;
  time_t       first_received_message_time;
  time_t       last_privmsg;  /**< Last time we got a PRIVMSG */

  int          received_number_of_privmsgs;

  struct ListTask  *list_task;

  struct dbuf_queue buf_sendq;
  struct dbuf_queue buf_recvq;

  struct
  {
    unsigned int messages;      /**< Statistics: protocol messages sent/received */
    uint64_t bytes;             /**< Statistics: total bytes sent/received */
  } recv, send;

  struct
  {
    unsigned int count;  /**< How many AWAY/INVITE/KNOCK/NICK requests client has sent */
    time_t last_attempt;  /**< Last time the AWAY/INVITE/KNOCK/NICK request was issued */
  } away, invite, knock, nick;

  struct AuthRequest auth;
  struct Listener *listener;   /**< Listener accepted from */
  dlink_list        acceptlist; /**< Clients I'll allow to talk to me */
  dlink_list        watches;   /**< Chain of Watch pointer blocks */
  dlink_list        confs;     /**< Configuration record associated */
  dlink_list        invited;   /**< Chain of invite pointer blocks */
  struct irc_ssaddr ip;
  int               aftype;    /**< Makes life easier for DNS res in IPV6 */
  int               country_id; /**< ID corresponding to a ISO 3166 country code */

  fde_t             fd;

  /* Anti-flood stuff. We track how many messages were parsed and how
   * many we were allowed in the current second, and apply a simple
   * decay to avoid flooding.
   *   -- adrian
   */
  int allow_read;       /**< How many we're allowed to read in this second */
  int sent_parsed;      /**< How many messages we've parsed in this second */

  char *password;  /**< Password supplied by the client/server */
};

/*! \brief Client structure */
struct Client
{
  dlink_node node;
  dlink_node lnode;             /**< Used for Server->servers/users */

  struct Connection *connection;
  struct Client    *hnext;      /**< For client hash table lookups by name */
  struct Client    *idhnext;    /**< For SID hash table lookups by sid */
  struct Server    *serv;       /**< ...defined, if this is a server */
  struct Client    *servptr;    /**< Points to server this Client is on */
  struct Client    *from;       /**< == self, if Local Client, *NEVER* NULL! */

  time_t            tsinfo;     /**< TS on the nick, SVINFO on server */

  unsigned int      flags;      /**< Client flags */
  unsigned int      umodes;     /**< Opers, normal users subset */
  unsigned int      hopcount;   /**< Number of servers to this 0 = local */
  unsigned int      status;     /**< Client type */
  unsigned int      handler;    /**< Handler index */

  dlink_list        whowas;
  dlink_list        channel;   /**< Chain of channel pointer blocks */
  dlink_list        svstags;   /**< List of ServicesTag items */

  char away[AWAYLEN + 1]; /**< Client's AWAY message. Can be set/unset via AWAY command */
  char name[HOSTLEN + 1]; /**< Unique name for a client nick or host */
  char id[IDLEN + 1];       /**< Client ID, unique ID per client */
  char account[ACCOUNTLEN + 1]; /**< Services account */

  /*
   * client->username is the username from ident or the USER message,
   * If the client is idented the USER message is ignored, otherwise
   * the username part of the USER message is put here prefixed with a
   * tilde depending on the auth{} block. Once a client has registered,
   * this field should be considered read-only.
   */
  char              username[USERLEN + 1]; /* client's username */

  /*
   * client->host contains the resolved name or ip address
   * as a string for the user, it may be fiddled with for oper spoofing etc.
   * once it's changed the *real* address goes away. This should be
   * considered a read-only field after the client has registered.
   */
  char              host[HOSTLEN + 1];     /* client's hostname */

  /*
   * client->info for unix clients will normally contain the info from the
   * gcos field in /etc/passwd but anything can go here.
   */
  char              info[REALLEN + 1]; /* Free form additional client info */

  /*
   * client->sockhost contains the ip address gotten from the socket as a
   * string, this field should be considered read-only once the connection
   * has been made. (set in s_bsd.c only)
   */
  char              sockhost[HOSTIPLEN + 1]; /* This is the host name from the
                                                socket ip address as string */
  char             *certfp;
};


extern struct Client me;
extern dlink_list listing_client_list;
extern dlink_list global_client_list;
extern dlink_list global_server_list;   /* global servers on the network              */
extern dlink_list local_client_list;  /* local clients only ON this server          */
extern dlink_list local_server_list;  /* local servers to this server ONLY          */
extern dlink_list unknown_list;       /* unknown clients ON this server only        */
extern dlink_list oper_list;          /* our opers, duplicated in local_client_list */

extern int accept_message(struct Client *, struct Client *);
extern unsigned int client_get_idle_time(const struct Client *, const struct Client *);
extern struct split_nuh_item *find_accept(const char *, const char *,
                                          const char *, struct Client *,
                                          int (*)(const char *, const char *));
extern void client_attach_svstag(struct Client *, unsigned int, const char *, const char *const);
extern void client_clear_svstags(struct Client *);
extern void del_accept(struct split_nuh_item *, struct Client *);
extern void del_all_accepts(struct Client *);
extern void exit_client(struct Client *, const char *);
extern void conf_try_ban(struct Client *, struct MaskItem *);
extern void check_conf_klines(void);
extern void client_init(void);
extern void dead_link_on_write(struct Client *, int);
extern void dead_link_on_read(struct Client *, int);
extern void exit_aborted_clients(void);
extern void free_exited_clients(void);
extern struct Client *make_client(struct Client *);
extern struct Client *find_chasing(struct Client *, const char *);
extern struct Client *find_person(const struct Client *const, const char *);
extern const char *get_client_name(const struct Client *, enum addr_mask_type);

#endif /* INCLUDED_client_h */
Revision:	6620
Committed:	Sat Oct 24 12:18:13 2015 UTC (9 years, 10 months ago) by michael
Content type:	text/x-chdr
File size:	19618 byte(s)
Log Message:	- client.h: if HasOFlag is being used on remote clients, something is wrong. Let it crash instead of silently ignoring it.
#	User	Rev	Content
1	adx	30	/*
2	michael	2865	* ircd-hybrid: an advanced, lightweight Internet Relay Chat Daemon (ircd)
3	adx	30	*
4	michael	5347	* Copyright (c) 1997-2015 ircd-hybrid development team
5	adx	30	*
6			* This program is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18	michael	4565	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
19	adx	30	* USA
20			*/
21
22	michael	1220	/*! \file client.h
23			* \brief Header including structures, macros and prototypes for client handling
24			* \version $Id$
25			*/
26
27
28	adx	30	#ifndef INCLUDED_client_h
29			#define INCLUDED_client_h
30
31	michael	1011	#include "list.h"
32	adx	30	#include "fdlist.h"
33	michael	912	#include "config.h"
34	adx	30	#include "ircd_defs.h"
35			#include "dbuf.h"
36			#include "channel.h"
37	michael	3324	#include "auth.h"
38	adx	30
39	michael	2811	struct MaskItem;
40
41	adx	30	/*
42			* status macros.
43			*/
44	michael	6315	enum
45			{
46			STAT_CONNECTING = 0x00000001U,
47			STAT_HANDSHAKE = 0x00000002U,
48			STAT_ME = 0x00000004U,
49			STAT_UNKNOWN = 0x00000008U,
50			STAT_SERVER = 0x00000010U,
51			STAT_CLIENT = 0x00000020U
52			};
53	adx	30
54	michael	6315	enum
55			{
56			REG_NEED_USER = 0x00000001U, /*< User must send USER command /
57			REG_NEED_NICK = 0x00000002U, /*< User must send NICK command /
58			REG_NEED_CAP = 0x00000004U, /*< In middle of CAP negotiations /
59			REG_INIT = REG_NEED_USER \| REG_NEED_NICK
60			};
61	michael	503
62	michael	5562	#define ID_or_name(x,client_p) ((IsServer(client_p->from) && (x)->id[0]) ? (x)->id : (x)->name)
63	adx	30
64			#define IsConnecting(x) ((x)->status == STAT_CONNECTING)
65			#define IsHandshake(x) ((x)->status == STAT_HANDSHAKE)
66			#define IsMe(x) ((x)->status == STAT_ME)
67			#define IsUnknown(x) ((x)->status == STAT_UNKNOWN)
68			#define IsServer(x) ((x)->status == STAT_SERVER)
69			#define IsClient(x) ((x)->status == STAT_CLIENT)
70
71			#define SetConnecting(x) {(x)->status = STAT_CONNECTING; \
72	michael	2865	(x)->handler = UNREGISTERED_HANDLER; }
73	adx	30
74			#define SetHandshake(x) {(x)->status = STAT_HANDSHAKE; \
75	michael	2865	(x)->handler = UNREGISTERED_HANDLER; }
76	adx	30
77			#define SetMe(x) {(x)->status = STAT_ME; \
78	michael	2865	(x)->handler = UNREGISTERED_HANDLER; }
79	adx	30
80			#define SetUnknown(x) {(x)->status = STAT_UNKNOWN; \
81	michael	2865	(x)->handler = UNREGISTERED_HANDLER; }
82	adx	30
83			#define SetServer(x) {(x)->status = STAT_SERVER; \
84	michael	2865	(x)->handler = SERVER_HANDLER; }
85	adx	30
86			#define SetClient(x) {(x)->status = STAT_CLIENT; \
87	michael	6617	(x)->handler = CLIENT_HANDLER; }
88	adx	30
89	michael	4588	#define MyConnect(x) ((x)->connection != NULL)
90	michael	1219	#define MyClient(x) (MyConnect(x) && IsClient(x))
91	adx	30
92			/*
93			* ts stuff
94			*/
95	michael	6315	enum
96			{
97			TS_CURRENT = 6, /*< Current TS protocol version /
98			TS_MIN = 6 /*< Minimum supported TS protocol version /
99			};
100	adx	30
101	michael	6315	enum
102			{
103	michael	6400	CAP_MULTI_PREFIX = 0x00000001U,
104			CAP_AWAY_NOTIFY = 0x00000002U,
105			CAP_UHNAMES = 0x00000004U,
106			CAP_EXTENDED_JOIN = 0x00000008U,
107			CAP_ACCOUNT_NOTIFY = 0x00000010U
108	michael	6315	};
109	adx	30
110	michael	4588	#define HasCap(x, y) ((x)->connection->cap_active & (y))
111	michael	1146
112	michael	2910
113	adx	30	/* housekeeping flags */
114	michael	6315	enum
115			{
116			FLAGS_PINGSENT = 0x00000001U, /*< Unreplied ping sent /
117			FLAGS_DEADSOCKET = 0x00000002U, /*< Local socket is dead--Exiting soon /
118			FLAGS_KILLED = 0x00000004U, /*< Prevents "QUIT" from being sent for this /
119			FLAGS_CLOSING = 0x00000008U, /*< Set when closing to suppress errors /
120			FLAGS_GOTID = 0x00000010U, /*< Successful ident lookup achieved /
121			FLAGS_SENDQEX = 0x00000020U, /*< Sendq exceeded /
122			FLAGS_IPHASH = 0x00000040U, /*< Iphashed this client /
123			FLAGS_MARK = 0x00000080U, /*< Marked client /
124			FLAGS_CANFLOOD = 0x00000100U, /*< Client has the ability to flood /
125			FLAGS_EXEMPTKLINE = 0x00000200U, /*< Client is exempt from k-lines /
126			FLAGS_NOLIMIT = 0x00000400U, /*< Client is exempt from limits /
127			FLAGS_PING_COOKIE = 0x00000800U, /*< PING Cookie /
128			FLAGS_FLOODDONE = 0x00001000U, /*< Flood grace period has been ended. /
129			FLAGS_EOB = 0x00002000U, /*< Server has sent us an EOB /
130			FLAGS_HIDDEN = 0x00004000U, /*< A hidden server. Not shown in /links /
131			FLAGS_BLOCKED = 0x00008000U, /*< Must wait for COMM_SELECT_WRITE /
132			FLAGS_USERHOST = 0x00010000U, /*< Client is in userhost hash /
133			FLAGS_BURSTED = 0x00020000U, /*< User was already bursted /
134			FLAGS_EXEMPTRESV = 0x00040000U, /*< Client is exempt from RESV /
135			FLAGS_GOTUSER = 0x00080000U, /*< If we received a USER command /
136			FLAGS_FINISHED_AUTH = 0x00100000U, /*< Client has been released from auth /
137			FLAGS_FLOOD_NOTICED = 0x00200000U, /*< Notice to opers about this flooder has been sent /
138			FLAGS_SERVICE = 0x00400000U, /*< Client/server is a network service /
139			FLAGS_SSL = 0x00800000U, /*< User is connected via TLS/SSL /
140			FLAGS_SQUIT = 0x01000000U,
141			FLAGS_EXEMPTXLINE = 0x02000000U /*< Client is exempt from x-lines /
142			};
143	adx	30
144	michael	1219	#define HasFlag(x, y) ((x)->flags & (y))
145			#define AddFlag(x, y) ((x)->flags \|= (y))
146			#define DelFlag(x, y) ((x)->flags &= ~(y))
147	adx	30
148	michael	1219
149	adx	30	/* umodes, settable flags */
150	michael	6315	enum
151			{
152			UMODE_SERVNOTICE = 0x00000001U, /*< Server notices such as kill /
153			UMODE_CCONN = 0x00000002U, /*< Can see client connection notices /
154			UMODE_REJ = 0x00000004U, /*< Bot Rejections /
155			UMODE_SKILL = 0x00000008U, /*< Server Killed /
156			UMODE_FULL = 0x00000010U, /*< Full messages /
157			UMODE_SPY = 0x00000020U, /*< See STATS / LINKS /
158			UMODE_DEBUG = 0x00000040U, /*< 'debugging' info /
159			UMODE_NCHANGE = 0x00000080U, /*< Nick change notice /
160			UMODE_WALLOP = 0x00000100U, /*< Send wallops to them /
161			UMODE_INVISIBLE = 0x00000200U, /*< Makes user invisible /
162			UMODE_BOTS = 0x00000400U, /*< Shows bots /
163			UMODE_EXTERNAL = 0x00000800U, /*< Show servers introduced and splitting /
164			UMODE_CALLERID = 0x00001000U, /*< Block unless caller id's /
165			UMODE_SOFTCALLERID = 0x00002000U, /*< Block unless on common channel /
166			UMODE_UNAUTH = 0x00004000U, /*< Show unauth connects here /
167			UMODE_LOCOPS = 0x00008000U, /*< Can see LOCOPS messages /
168			UMODE_DEAF = 0x00010000U, /*< Don't receive channel messages /
169			UMODE_REGISTERED = 0x00020000U, /*< User has identified for that nick. /
170			UMODE_REGONLY = 0x00040000U, /*< Only registered nicks may PM /
171			UMODE_HIDDEN = 0x00080000U, /*< IRC operator status is hidden /
172			UMODE_OPER = 0x00100000U, /*< IRC operator /
173			UMODE_ADMIN = 0x00200000U, /*< Admin on server /
174			UMODE_FARCONNECT = 0x00400000U, /*< Can see remote client connects/exits /
175			UMODE_HIDDENHOST = 0x00800000U, /*< User's host is hidden /
176			UMODE_SSL = 0x01000000U, /*< User is connected via TLS/SSL /
177			UMODE_WEBIRC = 0x02000000U, /*< User connected via a webirc gateway /
178			UMODE_HIDEIDLE = 0x04000000U, /*< Hides idle and signon time in WHOIS /
179			UMODE_HIDECHANS = 0x08000000U /*< Hides channel list in WHOIS /
180			};
181	db	849
182	michael	1158	#define HasUMode(x, y) ((x)->umodes & (y))
183			#define AddUMode(x, y) ((x)->umodes \|= (y))
184			#define DelUMode(x, y) ((x)->umodes &= ~(y))
185
186	adx	30
187			/* oper priv flags */
188	michael	6315	enum
189			{
190	michael	6451	OPER_FLAG_KILL_REMOTE = 0x00000001U, /*< Oper can KILL remote users /
191			OPER_FLAG_KILL = 0x00000002U, /*< Oper can KILL local users /
192			OPER_FLAG_UNKLINE = 0x00000004U, /*< Oper can use UNKLINE command /
193			OPER_FLAG_KLINE = 0x00000008U, /*< Oper can use KLINE command /
194			OPER_FLAG_XLINE = 0x00000010U, /*< Oper can use XLINE command /
195			OPER_FLAG_DIE = 0x00000020U, /*< Oper can use DIE command /
196			OPER_FLAG_REHASH = 0x00000040U, /*< Oper can use REHASH command /
197			OPER_FLAG_ADMIN = 0x00000080U, /*< Oper can set user mode +a /
198			OPER_FLAG_REMOTEBAN = 0x00000100U, /*< Oper can set remote bans /
199			OPER_FLAG_GLOBOPS = 0x00000200U, /*< Oper can use GLOBOPS command /
200			OPER_FLAG_MODULE = 0x00000400U, /*< Oper can use MODULE command /
201			OPER_FLAG_RESTART = 0x00000800U, /*< Oper can use RESTART command /
202			OPER_FLAG_DLINE = 0x00001000U, /*< Oper can use DLINE command /
203			OPER_FLAG_UNDLINE = 0x00002000U, /*< Oper can use UNDLINE command /
204			OPER_FLAG_SET = 0x00004000U, /*< Oper can use SET command /
205			OPER_FLAG_SQUIT = 0x00008000U, /*< Oper can do local SQUIT /
206			OPER_FLAG_SQUIT_REMOTE = 0x00010000U, /*< Oper can do remote SQUIT /
207			OPER_FLAG_CONNECT = 0x00020000U, /*< Oper can do local CONNECT /
208			OPER_FLAG_CONNECT_REMOTE = 0x00040000U, /*< Oper can do remote CONNECT /
209			OPER_FLAG_WALLOPS = 0x00080000U, /*< Oper can use WALLOPS command /
210			OPER_FLAG_LOCOPS = 0x00100000U, /*< Oper can use LOCOPS command /
211			OPER_FLAG_UNXLINE = 0x00200000U, /*< Oper can use UNXLINE command /
212			OPER_FLAG_OPME = 0x00400000U, /*< Oper can use OPME command /
213			OPER_FLAG_JOIN_RESV = 0x00800000U, /*< Oper can use JOIN on resv {} channels /
214	michael	6454	OPER_FLAG_NICK_RESV = 0x01000000U, /*< Oper can use NICK on resv {} nicks /
215			OPER_FLAG_RESV = 0x02000000U, /*< Oper can use RESV command /
216	michael	6488	OPER_FLAG_UNRESV = 0x04000000U, /*< Oper can use UNRESV command /
217			OPER_FLAG_CLOSE = 0x08000000U /*< Oper can use CLOSE command /
218	michael	6315	};
219	adx	30
220	michael	6620	#define HasOFlag(x, y) ((x)->connection->operflags & (y))
221	michael	4588	#define AddOFlag(x, y) ((x)->connection->operflags \|= (y))
222			#define DelOFlag(x, y) ((x)->connection->operflags &= ~(y))
223			#define ClrOFlag(x) ((x)->connection->operflags = 0)
224	adx	30
225
226	michael	1219
227	adx	30	/* flags macros. */
228			#define IsDead(x) ((x)->flags & FLAGS_DEADSOCKET)
229			#define SetDead(x) ((x)->flags \|= FLAGS_DEADSOCKET)
230	michael	2865	#define IsDefunct(x) ((x)->flags & (FLAGS_DEADSOCKET\|FLAGS_CLOSING\|FLAGS_KILLED))
231	adx	30
232			/* oper flags */
233			#define SetOper(x) {(x)->umodes \|= UMODE_OPER; \
234	michael	6616	if (MyClient((x))) (x)->handler = OPER_HANDLER;}
235	adx	30
236			#define ClearOper(x) {(x)->umodes &= ~(UMODE_OPER\|UMODE_ADMIN); \
237	michael	6616	if (MyClient((x))) \
238	michael	2865	(x)->handler = CLIENT_HANDLER; }
239	adx	30
240			#define IsFloodDone(x) ((x)->flags & FLAGS_FLOODDONE)
241			#define IsHidden(x) ((x)->flags & FLAGS_HIDDEN)
242
243
244	michael	1798	/! \brief addr_mask_type enumeration /
245			enum addr_mask_type
246			{
247			HIDE_IP, /*< IP is hidden. Resolved hostname is shown instead /
248			SHOW_IP, /*< IP is shown. No parts of it are hidden or masked /
249			MASK_IP /*< IP is masked. 255.255.255.255 is shown instead /
250			};
251
252	michael	5551	struct ServicesTag
253			{
254			dlink_node node;
255			char *tag;
256			unsigned int numeric;
257	michael	5558	unsigned int umodes;
258	michael	5551	};
259
260	michael	1798	/! \brief Server structure /
261			struct Server
262			{
263			dlink_list server_list; /*< Servers on this server /
264			dlink_list client_list; /*< Clients on this server /
265	michael	3266	char by[NICKLEN + 1]; /*< Who activated this connection /
266	michael	1798	};
267
268			/! \brief ListTask structure /
269			struct ListTask
270			{
271	michael	6385	dlink_node node; /*< Embedded list node used to link into listing_client_list /
272	michael	3266	dlink_list show_mask; /*< Channels to show /
273			dlink_list hide_mask; /*< Channels to hide /
274	michael	1798
275	michael	3266	unsigned int hash_index; /*< The hash bucket we are currently in /
276	michael	1798	unsigned int users_min;
277			unsigned int users_max;
278			unsigned int created_min;
279			unsigned int created_max;
280			unsigned int topicts_min;
281			unsigned int topicts_max;
282	michael	4489	char topic[TOPICLEN + 1];
283	michael	1798	};
284
285	michael	4576	/*! \brief Connection structure
286	michael	1798	*
287			* Allocated only for local clients, that are directly connected
288			* to \b this server with a socket.
289			*/
290	michael	4576	struct Connection
291	michael	1798	{
292			dlink_node lclient_node;
293
294			unsigned int registration;
295	michael	3518	unsigned int cap_client; /*< Client capabilities (from us) /
296			unsigned int cap_active; /*< Active capabilities (to us) /
297			unsigned int caps; /*< Capabilities bit-field /
298	michael	1798
299			unsigned int operflags; /*< IRC Operator privilege flags /
300			unsigned int random_ping; /*< Holding a 32bit value used for PING cookies /
301
302	michael	4780	uint64_t serial; /*< Used to enforce 1 send per nick /
303	michael	1798
304			time_t lasttime; /*< ...should be only LOCAL clients? --msa /
305	michael	3518	time_t firsttime; /*< Time client was created /
306			time_t since; /*< Last time we parsed something /
307			time_t last_join_time; /*< When this client last joined a channel /
308			time_t last_leave_time; /*< When this client last left a channel /
309			int join_leave_count; /**< Count of JOIN/LEAVE in less than
310	michael	1798	MIN_JOIN_LEAVE_TIME seconds */
311	michael	3518	int oper_warn_count_down; /**< Warn opers of this possible
312	michael	1798	spambot every time this gets to 0 */
313			time_t last_caller_id_time;
314			time_t first_received_message_time;
315	michael	3518	time_t last_privmsg; /*< Last time we got a PRIVMSG /
316	michael	1798
317			int received_number_of_privmsgs;
318
319			struct ListTask *list_task;
320
321			struct dbuf_queue buf_sendq;
322			struct dbuf_queue buf_recvq;
323
324	michael	3335	struct
325			{
326	michael	1798	unsigned int messages; /*< Statistics: protocol messages sent/received /
327			uint64_t bytes; /*< Statistics: total bytes sent/received /
328			} recv, send;
329
330	michael	3860	struct
331			{
332	michael	4313	unsigned int count; /*< How many AWAY/INVITE/KNOCK/NICK requests client has sent /
333			time_t last_attempt; /*< Last time the AWAY/INVITE/KNOCK/NICK request was issued /
334			} away, invite, knock, nick;
335	michael	3860
336	michael	2181	struct AuthRequest auth;
337	michael	3518	struct Listener listener; /< Listener accepted from /
338			dlink_list acceptlist; /*< Clients I'll allow to talk to me /
339			dlink_list watches; /*< Chain of Watch pointer blocks /
340	michael	1798	dlink_list confs; /*< Configuration record associated /
341	michael	3518	dlink_list invited; /*< Chain of invite pointer blocks /
342	michael	1798	struct irc_ssaddr ip;
343			int aftype; /*< Makes life easier for DNS res in IPV6 /
344	michael	1858	int country_id; /*< ID corresponding to a ISO 3166 country code /
345	michael	1798
346			fde_t fd;
347	michael	4439
348	michael	1798	/* Anti-flood stuff. We track how many messages were parsed and how
349			* many we were allowed in the current second, and apply a simple
350			* decay to avoid flooding.
351			* -- adrian
352			*/
353	michael	3518	int allow_read; /*< How many we're allowed to read in this second /
354			int sent_parsed; /*< How many messages we've parsed in this second /
355	michael	1798
356	michael	4439	char password; /< Password supplied by the client/server /
357	michael	1798	};
358
359			/! \brief Client structure /
360			struct Client
361			{
362			dlink_node node;
363			dlink_node lnode; /*< Used for Server->servers/users /
364
365	michael	4588	struct Connection *connection;
366	michael	1798	struct Client hnext; /< For client hash table lookups by name /
367			struct Client idhnext; /< For SID hash table lookups by sid /
368			struct Server serv; /< ...defined, if this is a server /
369			struct Client servptr; /< Points to server this Client is on /
370			struct Client from; /< == self, if Local Client, NEVER* NULL! */
371
372			time_t tsinfo; /*< TS on the nick, SVINFO on server /
373
374	michael	3518	unsigned int flags; /*< Client flags /
375			unsigned int umodes; /*< Opers, normal users subset /
376			unsigned int hopcount; /*< Number of servers to this 0 = local /
377	michael	1798	unsigned int status; /*< Client type /
378			unsigned int handler; /*< Handler index /
379
380			dlink_list whowas;
381	michael	3518	dlink_list channel; /*< Chain of channel pointer blocks /
382	michael	5551	dlink_list svstags; /*< List of ServicesTag items /
383	michael	1798
384			char away[AWAYLEN + 1]; /*< Client's AWAY message. Can be set/unset via AWAY command /
385	michael	3518	char name[HOSTLEN + 1]; /*< Unique name for a client nick or host /
386			char id[IDLEN + 1]; /*< Client ID, unique ID per client /
387	michael	5573	char account[ACCOUNTLEN + 1]; /*< Services account /
388	michael	3335
389	michael	2865	/*
390	michael	2345	* client->username is the username from ident or the USER message,
391			* If the client is idented the USER message is ignored, otherwise
392			* the username part of the USER message is put here prefixed with a
393	michael	1798	* tilde depending on the auth{} block. Once a client has registered,
394			* this field should be considered read-only.
395			*/
396			char username[USERLEN + 1]; /* client's username */
397	michael	3335
398	michael	1798	/*
399			* client->host contains the resolved name or ip address
400			* as a string for the user, it may be fiddled with for oper spoofing etc.
401			* once it's changed the real address goes away. This should be
402			* considered a read-only field after the client has registered.
403			*/
404			char host[HOSTLEN + 1]; /* client's hostname */
405
406			/*
407	michael	2345	* client->info for unix clients will normally contain the info from the
408	michael	1798	* gcos field in /etc/passwd but anything can go here.
409			*/
410			char info[REALLEN + 1]; /* Free form additional client info */
411
412			/*
413			* client->sockhost contains the ip address gotten from the socket as a
414			* string, this field should be considered read-only once the connection
415			* has been made. (set in s_bsd.c only)
416			*/
417	michael	2345	char sockhost[HOSTIPLEN + 1]; /* This is the host name from the
418	michael	1798	socket ip address as string */
419	michael	2229	char *certfp;
420	michael	1798	};
421
422
423	adx	30	extern struct Client me;
424			extern dlink_list listing_client_list;
425			extern dlink_list global_client_list;
426	michael	4209	extern dlink_list global_server_list; /* global servers on the network */
427	michael	4213	extern dlink_list local_client_list; /* local clients only ON this server */
428			extern dlink_list local_server_list; /* local servers to this server ONLY */
429	michael	1666	extern dlink_list unknown_list; /* unknown clients ON this server only */
430			extern dlink_list oper_list; /* our opers, duplicated in local_client_list */
431	adx	30
432			extern int accept_message(struct Client , struct Client );
433	michael	5544	extern unsigned int client_get_idle_time(const struct Client , const struct Client );
434	michael	887	extern struct split_nuh_item find_accept(const char , const char *,
435	michael	2363	const char , struct Client ,
436			int ()(const char , const char *));
437	michael	5558	extern void client_attach_svstag(struct Client , unsigned int, const char , const char *const);
438	michael	5551	extern void client_clear_svstags(struct Client *);
439	michael	887	extern void del_accept(struct split_nuh_item , struct Client );
440			extern void del_all_accepts(struct Client *);
441	michael	3171	extern void exit_client(struct Client , const char );
442	michael	2813	extern void conf_try_ban(struct Client , struct MaskItem );
443	adx	30	extern void check_conf_klines(void);
444	michael	1798	extern void client_init(void);
445	adx	30	extern void dead_link_on_write(struct Client *, int);
446			extern void dead_link_on_read(struct Client *, int);
447			extern void exit_aborted_clients(void);
448			extern void free_exited_clients(void);
449			extern struct Client make_client(struct Client );
450	michael	3192	extern struct Client find_chasing(struct Client , const char *);
451	adx	30	extern struct Client find_person(const struct Client const, const char *);
452	michael	1328	extern const char get_client_name(const struct Client , enum addr_mask_type);
453	adx	30
454			#endif /* INCLUDED_client_h */