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 = HasUMode(x, UMODE_OPER) ? \
                                 OPER_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) (MyConnect(x) ? (x)->connection->operflags & (y) : 0)
#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 (!IsServer((x))) (x)->handler = OPER_HANDLER;}

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