1129 lines
56 KiB
C
1129 lines
56 KiB
C
/*
|
|
* IRC - Internet Relay Chat, include/client.h
|
|
* Copyright (C) 1990 Jarkko Oikarinen and
|
|
* University of Oulu, Computing Center
|
|
*
|
|
* 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, or (at your option)
|
|
* any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
/** @file
|
|
* @brief Structures and functions for handling local clients.
|
|
* @version $Id: client.h 1907 2009-02-09 04:11:04Z entrope $
|
|
*/
|
|
#ifndef INCLUDED_client_h
|
|
#define INCLUDED_client_h
|
|
#ifndef INCLUDED_ircd_defs_h
|
|
#include "ircd_defs.h"
|
|
#endif
|
|
#ifndef INCLUDED_dbuf_h
|
|
#include "dbuf.h"
|
|
#endif
|
|
#ifndef INCLUDED_msgq_h
|
|
#include "msgq.h"
|
|
#endif
|
|
#ifndef INCLUDED_ircd_events_h
|
|
#include "ircd_events.h"
|
|
#endif
|
|
#ifndef INCLUDED_ircd_handler_h
|
|
#include "ircd_handler.h"
|
|
#endif
|
|
#ifndef INCLUDED_res_h
|
|
#include "res.h"
|
|
#endif
|
|
#ifndef INCLUDED_sys_types_h
|
|
#include <sys/types.h> /* time_t, size_t */
|
|
#define INCLUDED_sys_types_h
|
|
#endif
|
|
#ifdef USE_SSL
|
|
#ifndef INCLUDED_ssl_h
|
|
#include "ssl.h"
|
|
#endif
|
|
#endif /* USE_SSL */
|
|
|
|
struct ConfItem;
|
|
struct Listener;
|
|
struct ListingArgs;
|
|
struct SLink;
|
|
struct Server;
|
|
struct User;
|
|
struct Whowas;
|
|
struct hostent;
|
|
struct Privs;
|
|
struct AuthRequest;
|
|
|
|
/*
|
|
* Structures
|
|
*
|
|
* Only put structures here that are being used in a very large number of
|
|
* source files. Other structures go in the header file of there corresponding
|
|
* source file, or in the source file itself (when only used in that file).
|
|
*/
|
|
|
|
/** Single element in a flag bitset array. */
|
|
typedef unsigned long flagpage_t;
|
|
|
|
/** Number of bits in a flagpage_t. */
|
|
#define FLAGSET_NBITS (8 * sizeof(flagpage_t))
|
|
/** Element number for flag \a flag. */
|
|
#define FLAGSET_INDEX(flag) ((flag) / FLAGSET_NBITS)
|
|
/** Element bit for flag \a flag. */
|
|
#define FLAGSET_MASK(flag) (1ul<<((flag) % FLAGSET_NBITS))
|
|
|
|
/** Declare a flagset structure of a particular size. */
|
|
#define DECLARE_FLAGSET(name,max) \
|
|
struct name \
|
|
{ \
|
|
unsigned long bits[((max + FLAGSET_NBITS - 1) / FLAGSET_NBITS)]; \
|
|
}
|
|
|
|
/** Test whether a flag is set in a flagset. */
|
|
#define FlagHas(set,flag) ((set)->bits[FLAGSET_INDEX(flag)] & FLAGSET_MASK(flag))
|
|
/** Set a flag in a flagset. */
|
|
#define FlagSet(set,flag) ((set)->bits[FLAGSET_INDEX(flag)] |= FLAGSET_MASK(flag))
|
|
/** Clear a flag in a flagset. */
|
|
#define FlagClr(set,flag) ((set)->bits[FLAGSET_INDEX(flag)] &= ~FLAGSET_MASK(flag))
|
|
|
|
/** String containing valid user modes, in no particular order. */
|
|
#define infousermodes "adgiknoqswxzBDHLNORWX"
|
|
|
|
/** Operator privileges. */
|
|
enum Priv
|
|
{
|
|
PRIV_CHAN_LIMIT, /**< no channel limit on oper */
|
|
PRIV_MODE_LCHAN, /**< oper can mode local chans */
|
|
PRIV_WALK_LCHAN, /**< oper can walk through local modes */
|
|
PRIV_DEOP_LCHAN, /**< no deop oper on local chans */
|
|
PRIV_SHOW_INVIS, /**< show local invisible users */
|
|
PRIV_SHOW_ALL_INVIS, /**< show all invisible users */
|
|
PRIV_UNLIMIT_QUERY, /**< unlimit who queries */
|
|
PRIV_KILL, /**< oper can KILL */
|
|
PRIV_LOCAL_KILL, /**< oper can local KILL */
|
|
PRIV_REHASH, /**< oper can REHASH */
|
|
PRIV_RESTART, /**< oper can RESTART */
|
|
PRIV_DIE, /**< oper can DIE */
|
|
PRIV_GLINE, /**< oper can GLINE */
|
|
PRIV_LOCAL_GLINE, /**< oper can local GLINE */
|
|
PRIV_JUPE, /**< oper can JUPE */
|
|
PRIV_LOCAL_JUPE, /**< oper can local JUPE */
|
|
PRIV_OPMODE, /**< oper can OP/CLEARMODE */
|
|
PRIV_LOCAL_OPMODE, /**< oper can local OP/CLEARMODE */
|
|
PRIV_SET, /**< oper can SET */
|
|
PRIV_WHOX, /**< oper can use /who x */
|
|
PRIV_BADCHAN, /**< oper can BADCHAN */
|
|
PRIV_LOCAL_BADCHAN, /**< oper can local BADCHAN */
|
|
PRIV_SEE_CHAN, /**< oper can see in secret chans */
|
|
PRIV_PROPAGATE, /**< propagate oper status */
|
|
PRIV_DISPLAY, /**< "Is an oper" displayed */
|
|
PRIV_SEE_OPERS, /**< display hidden opers */
|
|
PRIV_WIDE_GLINE, /**< oper can set wider G-lines */
|
|
PRIV_LIST_CHAN, /**< oper can list secret channels */
|
|
PRIV_FORCE_OPMODE, /**< can hack modes on quarantined channels */
|
|
PRIV_FORCE_LOCAL_OPMODE, /**< can hack modes on quarantined local channels */
|
|
PRIV_APASS_OPMODE, /**< can hack modes +A/-A/+U/-U */
|
|
PRIV_CHECK, /**< can use /CHECK */
|
|
PRIV_WHOIS_NOTICE, /**< oper can set user mode +W */
|
|
PRIV_HIDE_OPER, /**< oper can set user mode +H */
|
|
PRIV_HIDE_CHANNELS, /**< oper can set user mode +n */
|
|
PRIV_HIDE_IDLE, /**< oper can set user mode +I */
|
|
PRIV_ADMIN, /**< oper is an admin (gets, can set and unset mode +a) */
|
|
PRIV_XTRAOP, /**< oper can set/unset user mode +X */
|
|
PRIV_SERVICE, /**< oper can set/unset user mode +k */
|
|
PRIV_REMOTE, /**< oper can OPER from another server */
|
|
PRIV_SHUN, /**< oper can SHUN */
|
|
PRIV_LOCAL_SHUN, /**< oper can local SHUN */
|
|
PRIV_WIDE_SHUN, /**< oper can set wider Shuns */
|
|
PRIV_FREEFORM, /**< oper can use SETHOST with custom host names */
|
|
PRIV_REMOTEREHASH, /**< oper can REHASH remote servers */
|
|
PRIV_REMOVE, /**< oper can REMOVE glines, zlines and shuns */
|
|
PRIV_LOCAL_ZLINE, /**< oper can local ZLINE */
|
|
PRIV_ZLINE, /**< oper can ZLINE */
|
|
PRIV_WIDE_ZLINE, /**< oper can set wider Z-lines */
|
|
PRIV_TEMPSHUN, /**< oper can use the TEMPSHUN command */
|
|
PRIV_LAST_PRIV /**< number of privileges */
|
|
};
|
|
|
|
/** Client flags and modes.
|
|
* Note that flags at least FLAG_LOCAL_UMODES but less than
|
|
* FLAG_GLOBAL_UMODES are treated as local modes, and flags at least
|
|
* FLAG_GLOBAL_UMODES (but less than FLAG_LAST_FLAG) are treated as
|
|
* global modes.
|
|
*/
|
|
enum Flag
|
|
{
|
|
FLAG_PINGSENT, /**< Unreplied ping sent */
|
|
FLAG_DEADSOCKET, /**< Local socket is dead--Exiting soon */
|
|
FLAG_KILLED, /**< Prevents "QUIT" from being sent for this */
|
|
FLAG_BLOCKED, /**< socket is in a blocked condition */
|
|
FLAG_CLOSING, /**< set when closing to suppress errors */
|
|
FLAG_UPING, /**< has active UDP ping request */
|
|
FLAG_HUB, /**< server is a hub */
|
|
FLAG_IPV6, /**< server understands P10 IPv6 addrs */
|
|
FLAG_SERVICE, /**< server is a service */
|
|
FLAG_OPLEVELS, /**< server has oplevels support */
|
|
FLAG_GOTID, /**< successful ident lookup achieved */
|
|
FLAG_DOID, /**< I-lines say must use ident return */
|
|
FLAG_NONL, /**< No \n in buffer */
|
|
FLAG_TS8, /**< Why do you want to know? */
|
|
FLAG_MAP, /**< Show server on the map */
|
|
FLAG_JUNCTION, /**< Junction causing the net.burst. */
|
|
FLAG_BURST, /**< Server is receiving a net.burst */
|
|
FLAG_BURST_ACK, /**< Server is waiting for eob ack */
|
|
FLAG_IPCHECK, /**< Added or updated IPregistry data */
|
|
FLAG_LOCOP, /**< Local operator -- SRB */
|
|
FLAG_SERVNOTICE, /**< server notices such as kill */
|
|
FLAG_OPER, /**< Operator */
|
|
FLAG_INVISIBLE, /**< makes user invisible */
|
|
FLAG_WALLOP, /**< send wallops to them */
|
|
FLAG_DEAF, /**< Makes user deaf */
|
|
FLAG_CHSERV, /**< Disallow KICK or MODE -o on the user;
|
|
don't display channels in /whois */
|
|
FLAG_DEBUG, /**< send global debug/anti-hack info */
|
|
FLAG_ACCOUNT, /**< account name has been set */
|
|
FLAG_HIDDENHOST, /**< user's host is hidden */
|
|
|
|
FLAG_WHOIS_NOTICE, /**< user can see WHOIS notices */
|
|
FLAG_HIDE_OPER, /**< user's oper status is hidden */
|
|
FLAG_NOCHAN, /**< user's channels are hidden in WHOIS */
|
|
FLAG_NOIDLE, /**< user's idle time is hidden in WHOIS */
|
|
FLAG_NAMESX, /**< Client supports extended NAMES replies */
|
|
FLAG_UHNAMES, /**< Client supports user-host NAMES replies */
|
|
FLAG_WEBIRC, /**< Client is a WEBIRC client */
|
|
FLAG_WEBIRC_USERIDENT, /**< Client should use USER username param as ident */
|
|
FLAG_IPSPOOFED, /**< Client has had his IP/host changed */
|
|
FLAG_ACCOUNTONLY, /**< hide privmsgs/notices if user is
|
|
not authed or opered */
|
|
FLAG_PRIVDEAF, /**< Client is deaf to all private messages */
|
|
FLAG_COMMONCHANSONLY, /**< SNIRCD_q: hide privmsgs/notices if in no
|
|
common channels (with +ok exceptions) */
|
|
FLAG_BOT, /**< Bot */
|
|
FLAG_GEOIP, /**< User has had GeoIP data applied */
|
|
FLAG_ADMIN, /**< User is an admin (user mode +a) */
|
|
FLAG_XTRAOP, /**< User has user mode +X (XtraOp) */
|
|
FLAG_NOLINK, /**< Client will not automatically get redirected if +L is set on a chan */
|
|
|
|
FLAG_CLOAKIP, /**< User has a cloaked IP (+c) */
|
|
FLAG_CLOAKHOST, /**< User has a cloaked host (+C) */
|
|
FLAG_FAKEHOST, /**< User has a fake host (+f) */
|
|
FLAG_SETHOST, /**< User has a set host (+h) */
|
|
FLAG_SSL, /**< User is connected via SSL (+z) */
|
|
FLAG_STARTTLS, /**< User is connecting with StartTLS */
|
|
FLAG_SSLNEEDACCEPT, /**< Client needs SSL_accept() to be called again */
|
|
|
|
FLAG_IPCEXEMPT, /**< User is IPcheck exempt */
|
|
FLAG_IPCNOTEXEMPT, /**< User is not IPcheck exempt */
|
|
|
|
FLAG_SASLCOMPLETE, /**< SASL Complete */
|
|
|
|
FLAG_MARKED, /**< Client is marked */
|
|
|
|
FLAG_RESTRICT_JOIN, /**< Client is in a client class that has the restrict_join option */
|
|
FLAG_RESTRICT_PRIVMSG, /**< Client is in a client class that has the restrict_privmsg option */
|
|
FLAG_RESTRICT_UMODE, /**< Client is in a client class that has the restrict_umode option */
|
|
|
|
FLAG_TEMPSHUN, /**< Client has temporarily been shunned */
|
|
|
|
FLAG_OPERED_LOCAL, /**< Client /OPER'ed using a local O:Line */
|
|
FLAG_OPERED_REMOTE, /**< Client /OPER'ed using a remote O:Line */
|
|
FLAG_SERVER_NOOP, /**< Server has been NOOP'ed */
|
|
FLAG_SENT_CVERSION, /**< Client's CTCP VERSION reply has been sent out */
|
|
|
|
FLAG_LAST_FLAG, /**< number of flags */
|
|
FLAG_LOCAL_UMODES = FLAG_LOCOP, /**< First local mode flag */
|
|
FLAG_GLOBAL_UMODES = FLAG_OPER /**< First global mode flag */
|
|
};
|
|
|
|
/** Declare flagset type for operator privileges. */
|
|
DECLARE_FLAGSET(Privs, PRIV_LAST_PRIV);
|
|
/** Declare flagset type for user flags. */
|
|
DECLARE_FLAGSET(Flags, FLAG_LAST_FLAG);
|
|
|
|
#include "capab.h" /* client capabilities */
|
|
|
|
/** Represents a local connection.
|
|
* This contains a lot of stuff irrelevant to server connections, but
|
|
* those are so rare as to not be worth special-casing.
|
|
*/
|
|
struct Connection
|
|
{
|
|
unsigned long con_magic; /**< magic number */
|
|
struct Connection* con_next; /**< Next connection with queued data */
|
|
struct Connection** con_prev_p; /**< What points to us */
|
|
struct Client* con_client; /**< Client associated with connection */
|
|
unsigned int con_count; /**< Amount of data in buffer */
|
|
int con_freeflag; /**< indicates if connection can be freed */
|
|
int con_error; /**< last socket level error for client */
|
|
int con_sentalong; /**< sentalong marker for connection */
|
|
unsigned int con_snomask; /**< mask for server messages */
|
|
time_t con_nextnick; /**< Next time a nick change is allowed */
|
|
time_t con_nexttarget;/**< Next time a target change is allowed */
|
|
time_t con_lasttime; /**< Last time data read from socket */
|
|
time_t con_since; /**< Last time we accepted a command */
|
|
struct MsgQ con_sendQ; /**< Outgoing message queue */
|
|
struct DBuf con_recvQ; /**< Incoming data yet to be parsed */
|
|
unsigned int con_sendM; /**< Stats: protocol messages sent */
|
|
unsigned int con_receiveM; /**< Stats: protocol messages received */
|
|
uint64_t con_sendB; /**< Bytes sent. */
|
|
uint64_t con_receiveB; /**< Bytes received. */
|
|
struct Listener* con_listener; /**< Listening socket which we accepted
|
|
from. */
|
|
struct SLink* con_confs; /**< Associated configuration records. */
|
|
HandlerType con_handler; /**< Message index into command table
|
|
for parsing. */
|
|
struct ListingArgs* con_listing; /**< Current LIST status. */
|
|
unsigned int con_max_sendq; /**< cached max send queue for client */
|
|
unsigned int con_max_recvq; /**< cached max recv queue for client */
|
|
unsigned int con_ping_freq; /**< cached ping freq */
|
|
int con_lag_min; /**< cached fake lag minimum */
|
|
int con_lag_factor; /**< cached fake lag factor */
|
|
unsigned short con_lastsq; /**< # 2k blocks when sendqueued
|
|
called last. */
|
|
unsigned short con_port; /**< and the remote port# too :-) */
|
|
unsigned char con_targets[MAXTARGETS]; /**< Hash values of
|
|
current targets. */
|
|
char con_sock_ip[SOCKIPLEN + 1]; /**< Remote IP address as a string. */
|
|
char con_sockhost[HOSTLEN + 1]; /**< This is the host name from
|
|
the socket and after which the
|
|
connection was accepted. */
|
|
char con_passwd[PASSWDLEN + 1]; /**< Password given by user. */
|
|
char con_buffer[BUFSIZE]; /**< Incoming message buffer; or
|
|
the error that caused this
|
|
clients socket to close. */
|
|
char* con_sslerror; /**< SSL Error. */
|
|
|
|
struct Socket con_socket; /**< socket descriptor for
|
|
client */
|
|
struct Timer con_proc; /**< process latent messages from
|
|
client */
|
|
struct CapSet con_capab; /**< Client capabilities (from us) */
|
|
struct CapSet con_active; /**< Active capabilities (to us) */
|
|
struct AuthRequest* con_auth; /**< Auth request for client */
|
|
struct LOCInfo* con_loc; /**< Login-on-connect information */
|
|
};
|
|
|
|
/** Magic constant to identify valid Connection structures. */
|
|
#define CONNECTION_MAGIC 0x12f955f3
|
|
|
|
/** Represents a client anywhere on the network. */
|
|
struct Client {
|
|
unsigned long cli_magic; /**< magic number */
|
|
struct Client* cli_next; /**< link in GlobalClientList */
|
|
struct Client* cli_prev; /**< link in GlobalClientList */
|
|
struct Client* cli_hnext; /**< link in hash table bucket or this */
|
|
struct Connection* cli_connect; /**< Connection structure associated with us */
|
|
struct User* cli_user; /**< Defined if this client is a user */
|
|
struct Server* cli_serv; /**< Defined if this client is a server */
|
|
struct Whowas* cli_whowas; /**< Pointer to ww struct to be freed on quit */
|
|
struct Privs cli_privs; /**< Oper privileges */
|
|
char cli_yxx[4]; /**< Numeric Nick: YY if this is a
|
|
server, XXX if this is a user */
|
|
time_t cli_firsttime; /**< time client was created */
|
|
time_t cli_lastnick; /**< TimeStamp on nick */
|
|
int cli_marker; /**< /who processing marker */
|
|
struct Flags cli_flags; /**< client flags */
|
|
unsigned int cli_hopcount; /**< number of servers to this 0 = local */
|
|
struct irc_in_addr cli_ip; /**< Real IP of client */
|
|
short cli_status; /**< Client type */
|
|
char cli_name[HOSTLEN + 1]; /**< Unique name of the client, nick or host */
|
|
char cli_username[USERLEN + 1]; /**< Username determined by ident lookup */
|
|
char cli_info[REALLEN + 1]; /**< Free form additional client information */
|
|
|
|
struct irc_in_addr cli_connectip; /**< Client connection IP address. */
|
|
char cli_connecthost[HOSTLEN + 1]; /**< Client connection host name. */
|
|
|
|
struct SLink* cli_marks; /**< chain of mark pointer blocks */
|
|
|
|
/* GeoIP data */
|
|
char cli_countrycode[3]; /**< GeoIP 2 letter country code. */
|
|
char cli_countryname[256]; /**< GeoIP country name. */
|
|
char cli_continentcode[3]; /**< GeoIP 2 letter continent code. */
|
|
char cli_continentname[256]; /**< GeoIP continent name. */
|
|
|
|
/* MARKs */
|
|
char cli_webirc[BUFSIZE + 1]; /**< webirc description */
|
|
char cli_version[VERSIONLEN + 1]; /**< Free form client version information */
|
|
char cli_sslclifp[BUFSIZE + 1]; /**< SSL client certificate fingerprint if available */
|
|
char cli_killmark[BUFSIZE + 1]; /**< Kill block mark */
|
|
|
|
/* SASL */
|
|
int cli_saslagentref; /**< Number of clients that reference this client as an SASL agent */
|
|
struct Client* cli_saslagent; /**< SASL agent handling SASL exchange */
|
|
char cli_saslaccount[ACCOUNTLEN + 1]; /**< SASL authenticated account name */
|
|
time_t cli_saslacccreate; /**< SASL authenticate account timestamp */
|
|
unsigned int cli_saslcookie; /**< SASL session cookie */
|
|
struct Timer cli_sasltimeout; /**< timeout timer for SASL */
|
|
};
|
|
|
|
/** Magic constant to identify valid Client structures. */
|
|
#define CLIENT_MAGIC 0x4ca08286
|
|
|
|
/** Verify that a client is valid. */
|
|
#define cli_verify(cli) ((cli)->cli_magic == CLIENT_MAGIC)
|
|
/** Get client's magic number. */
|
|
#define cli_magic(cli) ((cli)->cli_magic)
|
|
/** Get global next client. */
|
|
#define cli_next(cli) ((cli)->cli_next)
|
|
/** Get global previous client. */
|
|
#define cli_prev(cli) ((cli)->cli_prev)
|
|
/** Get next client in hash bucket chain. */
|
|
#define cli_hnext(cli) ((cli)->cli_hnext)
|
|
/** Get connection associated with client. */
|
|
#define cli_connect(cli) ((cli)->cli_connect)
|
|
/** Get local client that links us to \a cli. */
|
|
#define cli_from(cli) con_client(cli_connect(cli))
|
|
/** Get User structure for client, if client is a user. */
|
|
#define cli_user(cli) ((cli)->cli_user)
|
|
/** Get Server structure for client, if client is a server. */
|
|
#define cli_serv(cli) ((cli)->cli_serv)
|
|
/** Get Whowas link for client. */
|
|
#define cli_whowas(cli) ((cli)->cli_whowas)
|
|
/** Get client numnick. */
|
|
#define cli_yxx(cli) ((cli)->cli_yxx)
|
|
/** Get time we last read data from the client socket. */
|
|
#define cli_lasttime(cli) con_lasttime(cli_connect(cli))
|
|
/** Get time we last parsed something from the client. */
|
|
#define cli_since(cli) con_since(cli_connect(cli))
|
|
/** Get time client was created. */
|
|
#define cli_firsttime(cli) ((cli)->cli_firsttime)
|
|
/** Get time client last changed nickname. */
|
|
#define cli_lastnick(cli) ((cli)->cli_lastnick)
|
|
/** Get WHO marker for client. */
|
|
#define cli_marker(cli) ((cli)->cli_marker)
|
|
/** Get flags flagset for client. */
|
|
#define cli_flags(cli) ((cli)->cli_flags)
|
|
/** Get hop count to client. */
|
|
#define cli_hopcount(cli) ((cli)->cli_hopcount)
|
|
/** Get client IP address. */
|
|
#define cli_ip(cli) ((cli)->cli_ip)
|
|
/** Get status bitmask for client. */
|
|
#define cli_status(cli) ((cli)->cli_status)
|
|
/** Return non-zero if the client is local. */
|
|
#define cli_local(cli) (cli_from(cli) == cli)
|
|
/** Get oper privileges for client. */
|
|
#define cli_privs(cli) ((cli)->cli_privs)
|
|
/** Get client capabilities for client */
|
|
#define cli_capab(cli) con_capab(cli_connect(cli))
|
|
/** Get active client capabilities for client */
|
|
#define cli_active(cli) con_active(cli_connect(cli))
|
|
/** Get client name. */
|
|
#define cli_name(cli) ((cli)->cli_name)
|
|
/** Get client username (ident). */
|
|
#define cli_username(cli) ((cli)->cli_username)
|
|
/** Get client realname (information field). */
|
|
#define cli_info(cli) ((cli)->cli_info)
|
|
/** Get client account string. */
|
|
#define cli_account(cli) (cli_user(cli) ? cli_user(cli)->account : "0")
|
|
/** Get client connection IP address. */
|
|
#define cli_connectip(cli) ((cli)->cli_connectip)
|
|
/** Get client connection host name. */
|
|
#define cli_connecthost(cli) ((cli)->cli_connecthost)
|
|
/** Get client WEBIRC info line. */
|
|
#define cli_webirc(cli) ((cli)->cli_webirc)
|
|
/** Get a clients CTCP version string. */
|
|
#define cli_version(cli) ((cli)->cli_version)
|
|
/** Get a clients SSL fingerprint string. */
|
|
#define cli_sslclifp(cli) ((cli)->cli_sslclifp)
|
|
/** Get a clients Kill block exemption mark. */
|
|
#define cli_killmark(cli) ((cli)->cli_killmark)
|
|
/** Get all marks set for client. */
|
|
#define cli_marks(cli) ((cli)->cli_marks)
|
|
/** Get client GeoIP country code. */
|
|
#define cli_countrycode(cli) ((cli)->cli_countrycode)
|
|
/** Get client GeoIP country name. */
|
|
#define cli_countryname(cli) ((cli)->cli_countryname)
|
|
/** Get client GeoIP continent code. */
|
|
#define cli_continentcode(cli) ((cli)->cli_continentcode)
|
|
/** Get client GeoIP continent name. */
|
|
#define cli_continentname(cli) ((cli)->cli_continentname)
|
|
/** Get SASL agent ref count. */
|
|
#define cli_saslagentref(cli) ((cli)->cli_saslagentref)
|
|
/** Get SASL agent name. */
|
|
#define cli_saslagent(cli) ((cli)->cli_saslagent)
|
|
/** Get SASL authenticated account name. */
|
|
#define cli_saslaccount(cli) ((cli)->cli_saslaccount)
|
|
/** Get SASL authenticated account timestamp. */
|
|
#define cli_saslacccreate(cli) ((cli)->cli_saslacccreate)
|
|
/** Get SASL session cookie. */
|
|
#define cli_saslcookie(cli) ((cli)->cli_saslcookie)
|
|
/** Get Timer for SASL timeout. */
|
|
#define cli_sasltimeout(cli) ((cli)->cli_sasltimeout)
|
|
|
|
/** Get number of incoming bytes queued for client. */
|
|
#define cli_count(cli) con_count(cli_connect(cli))
|
|
/** Get file descriptor for sending in client's direction. */
|
|
#define cli_fd(cli) con_fd(cli_connect(cli))
|
|
/** Get free flags for the client's connection. */
|
|
#define cli_freeflag(cli) con_freeflag(cli_connect(cli))
|
|
/** Get last error code for the client's connection. */
|
|
#define cli_error(cli) con_error(cli_connect(cli))
|
|
/** Get last SSL error string. */
|
|
#define cli_sslerror(cli) con_sslerror(cli_connect(cli))
|
|
/** Get server notice mask for the client. */
|
|
#define cli_snomask(cli) con_snomask(cli_connect(cli))
|
|
/** Get next time a nick change is allowed for the client. */
|
|
#define cli_nextnick(cli) con_nextnick(cli_connect(cli))
|
|
/** Get next time a target change is allowed for the client. */
|
|
#define cli_nexttarget(cli) con_nexttarget(cli_connect(cli))
|
|
/** Get SendQ for client. */
|
|
#define cli_sendQ(cli) con_sendQ(cli_connect(cli))
|
|
/** Get RecvQ for client. */
|
|
#define cli_recvQ(cli) con_recvQ(cli_connect(cli))
|
|
/** Get count of messages sent to client. */
|
|
#define cli_sendM(cli) con_sendM(cli_connect(cli))
|
|
/** Get number of messages received from client. */
|
|
#define cli_receiveM(cli) con_receiveM(cli_connect(cli))
|
|
/** Get number of bytes (modulo 1024) sent to client. */
|
|
#define cli_sendB(cli) con_sendB(cli_connect(cli))
|
|
/** Get number of bytes (modulo 1024) received from client. */
|
|
#define cli_receiveB(cli) con_receiveB(cli_connect(cli))
|
|
/** Get listener that accepted the client's connection. */
|
|
#define cli_listener(cli) con_listener(cli_connect(cli))
|
|
/** Get list of attached conf lines. */
|
|
#define cli_confs(cli) con_confs(cli_connect(cli))
|
|
/** Get handler type for client. */
|
|
#define cli_handler(cli) con_handler(cli_connect(cli))
|
|
/** Get LIST status for client. */
|
|
#define cli_listing(cli) con_listing(cli_connect(cli))
|
|
/** Get cached max SendQ for client. */
|
|
#define cli_max_sendq(cli) con_max_sendq(cli_connect(cli))
|
|
/** Get cached max RecvQ for client. */
|
|
#define cli_max_recvq(cli) con_max_recvq(cli_connect(cli))
|
|
/** Get ping frequency for client. */
|
|
#define cli_ping_freq(cli) con_ping_freq(cli_connect(cli))
|
|
/** Get cached fake lag minimum for client. */
|
|
#define cli_lag_min(cli) con_lag_min(cli_connect(cli))
|
|
/** Get cached fake lag factor for client. */
|
|
#define cli_lag_factor(cli) con_lag_factor(cli_connect(cli))
|
|
/** Get lastsq for client's connection. */
|
|
#define cli_lastsq(cli) con_lastsq(cli_connect(cli))
|
|
/** Get port that the client is connected to */
|
|
#define cli_port(cli) ((cli)->cli_connect->con_port)
|
|
/** Get the array of current targets for the client. */
|
|
#define cli_targets(cli) con_targets(cli_connect(cli))
|
|
/** Get the string form of the client's IP address. */
|
|
#define cli_sock_ip(cli) con_sock_ip(cli_connect(cli))
|
|
/** Get the resolved hostname for the client. */
|
|
#define cli_sockhost(cli) con_sockhost(cli_connect(cli))
|
|
/** Get the client's password. */
|
|
#define cli_passwd(cli) con_passwd(cli_connect(cli))
|
|
/** Get the unprocessed input buffer for a client's connection. */
|
|
#define cli_buffer(cli) con_buffer(cli_connect(cli))
|
|
/** Get the Socket structure for sending to a client. */
|
|
#define cli_socket(cli) con_socket(cli_connect(cli))
|
|
/** Get Timer for processing waiting messages from the client. */
|
|
#define cli_proc(cli) con_proc(cli_connect(cli))
|
|
/** Get auth request for client. */
|
|
#define cli_auth(cli) con_auth(cli_connect(cli))
|
|
/** Get login on connect request for client. */
|
|
#define cli_loc(cli) ((cli)->cli_connect->con_loc)
|
|
/** Get sentalong marker for client. */
|
|
#define cli_sentalong(cli) con_sentalong(cli_connect(cli))
|
|
|
|
/** Verify that a connection is valid. */
|
|
#define con_verify(con) ((con)->con_magic == CONNECTION_MAGIC)
|
|
/** Get connection's magic number. */
|
|
#define con_magic(con) ((con)->con_magic)
|
|
/** Get global next connection. */
|
|
#define con_next(con) ((con)->con_next)
|
|
/** Get global previous connection. */
|
|
#define con_prev_p(con) ((con)->con_prev_p)
|
|
/** Get locally connected client for connection. */
|
|
#define con_client(con) ((con)->con_client)
|
|
/** Get number of unprocessed data bytes from connection. */
|
|
#define con_count(con) ((con)->con_count)
|
|
/** Get file descriptor for connection. */
|
|
#define con_fd(con) s_fd(&(con)->con_socket)
|
|
/** Get freeable flags for connection. */
|
|
#define con_freeflag(con) ((con)->con_freeflag)
|
|
/** Get last error code on connection. */
|
|
#define con_error(con) ((con)->con_error)
|
|
/** Get last SSL error string. */
|
|
#define con_sslerror(con) ((con)->con_sslerror)
|
|
/** Get sentalong marker for connection. */
|
|
#define con_sentalong(con) ((con)->con_sentalong)
|
|
/** Get server notice mask for connection. */
|
|
#define con_snomask(con) ((con)->con_snomask)
|
|
/** Get next nick change time for connection. */
|
|
#define con_nextnick(con) ((con)->con_nextnick)
|
|
/** Get next new target time for connection. */
|
|
#define con_nexttarget(con) ((con)->con_nexttarget)
|
|
/** Get last time we read from the connection. */
|
|
#define con_lasttime(con) ((con)->con_lasttime)
|
|
/** Get last time we accepted a command from the connection. */
|
|
#define con_since(con) ((con)->con_since)
|
|
/** Get SendQ for connection. */
|
|
#define con_sendQ(con) ((con)->con_sendQ)
|
|
/** Get RecvQ for connection. */
|
|
#define con_recvQ(con) ((con)->con_recvQ)
|
|
/** Get number of messages sent to connection. */
|
|
#define con_sendM(con) ((con)->con_sendM)
|
|
/** Get number of messages received from connection. */
|
|
#define con_receiveM(con) ((con)->con_receiveM)
|
|
/** Get number of bytes (modulo 1024) sent to connection. */
|
|
#define con_sendB(con) ((con)->con_sendB)
|
|
/** Get number of bytes (modulo 1024) received from connection. */
|
|
#define con_receiveB(con) ((con)->con_receiveB)
|
|
/** Get listener that accepted the connection. */
|
|
#define con_listener(con) ((con)->con_listener)
|
|
/** Get list of ConfItems attached to the connection. */
|
|
#define con_confs(con) ((con)->con_confs)
|
|
/** Get command handler for the connection. */
|
|
#define con_handler(con) ((con)->con_handler)
|
|
/** Get the LIST status for the connection. */
|
|
#define con_listing(con) ((con)->con_listing)
|
|
/** Get the maximum permitted SendQ size for the connection. */
|
|
#define con_max_sendq(con) ((con)->con_max_sendq)
|
|
/** Get the maximum permitted RecvQ size for the connection. */
|
|
#define con_max_recvq(con) ((con)->con_max_recvq)
|
|
/** Get the ping frequency for the connection. */
|
|
#define con_ping_freq(con) ((con)->con_ping_freq)
|
|
/** Get the minimum fake lag for the connection. */
|
|
#define con_lag_min(con) ((con)->con_lag_min)
|
|
/** Get the fake lag factor for the connection. */
|
|
#define con_lag_factor(con) ((con)->con_lag_factor)
|
|
/** Get the lastsq for the connection. */
|
|
#define con_lastsq(con) ((con)->con_lastsq)
|
|
/** Get the current targets array for the connection. */
|
|
#define con_targets(con) ((con)->con_targets)
|
|
/** Get the string-formatted IP address for the connection. */
|
|
#define con_sock_ip(con) ((con)->con_sock_ip)
|
|
/** Get the resolved hostname for the connection. */
|
|
#define con_sockhost(con) ((con)->con_sockhost)
|
|
/** Get the password sent by the remote end of the connection. */
|
|
#define con_passwd(con) ((con)->con_passwd)
|
|
/** Get the buffer of unprocessed incoming data from the connection. */
|
|
#define con_buffer(con) ((con)->con_buffer)
|
|
/** Get the Socket for the connection. */
|
|
#define con_socket(con) ((con)->con_socket)
|
|
/** Get the Timer for processing more data from the connection. */
|
|
#define con_proc(con) ((con)->con_proc)
|
|
/** Get the peer's capabilities for the connection. */
|
|
#define con_capab(con) (&(con)->con_capab)
|
|
/** Get the active capabilities for the connection. */
|
|
#define con_active(con) (&(con)->con_active)
|
|
/** Get the auth request for the connection. */
|
|
#define con_auth(con) ((con)->con_auth)
|
|
|
|
#define STAT_CONNECTING 0x001 /**< connecting to another server */
|
|
#define STAT_HANDSHAKE 0x002 /**< pass - server sent */
|
|
#define STAT_ME 0x004 /**< this server */
|
|
#define STAT_UNKNOWN 0x008 /**< unidentified connection */
|
|
#define STAT_UNKNOWN_USER 0x010 /**< connection on a client port */
|
|
#define STAT_UNKNOWN_SERVER 0x020 /**< connection on a server port */
|
|
#define STAT_SERVER 0x040 /**< fully registered server */
|
|
#define STAT_USER 0x080 /**< fully registered user */
|
|
|
|
/*
|
|
* status macros.
|
|
*/
|
|
/** Return non-zero if the client is registered. */
|
|
#define IsRegistered(x) (cli_status(x) & (STAT_SERVER | STAT_USER))
|
|
/** Return non-zero if the client is an outbound connection that is
|
|
* still connecting. */
|
|
#define IsConnecting(x) (cli_status(x) == STAT_CONNECTING)
|
|
/** Return non-zero if the client is an outbound connection that has
|
|
* sent our password. */
|
|
#define IsHandshake(x) (cli_status(x) == STAT_HANDSHAKE)
|
|
/** Return non-zero if the client is this server. */
|
|
#define IsMe(x) (cli_status(x) == STAT_ME)
|
|
/** Return non-zero if the client has not yet registered. */
|
|
#define IsUnknown(x) (cli_status(x) & \
|
|
(STAT_UNKNOWN | STAT_UNKNOWN_USER | STAT_UNKNOWN_SERVER))
|
|
/** Return non-zero if the client is an unregistered connection on a
|
|
* server port. */
|
|
#define IsServerPort(x) (cli_status(x) == STAT_UNKNOWN_SERVER )
|
|
/** Return non-zero if the client is an unregistered connection on a
|
|
* user port. */
|
|
#define IsUserPort(x) (cli_status(x) == STAT_UNKNOWN_USER )
|
|
/** Return non-zero if the client is a real client connection. */
|
|
#define IsClient(x) (cli_status(x) & \
|
|
(STAT_HANDSHAKE | STAT_ME | STAT_UNKNOWN |\
|
|
STAT_UNKNOWN_USER | STAT_UNKNOWN_SERVER | STAT_SERVER | STAT_USER))
|
|
/** Return non-zero if the client ignores flood limits. */
|
|
#define IsTrusted(x) (cli_status(x) & \
|
|
(STAT_CONNECTING | STAT_HANDSHAKE | STAT_ME | STAT_SERVER))
|
|
/** Return non-zero if the client is a registered server. */
|
|
#define IsServer(x) (cli_status(x) == STAT_SERVER)
|
|
/** Return non-zero if the client is a registered user. */
|
|
#define IsUser(x) (cli_status(x) == STAT_USER)
|
|
|
|
|
|
/** Mark a client with STAT_CONNECTING. */
|
|
#define SetConnecting(x) (cli_status(x) = STAT_CONNECTING)
|
|
/** Mark a client with STAT_HANDSHAKE. */
|
|
#define SetHandshake(x) (cli_status(x) = STAT_HANDSHAKE)
|
|
/** Mark a client with STAT_SERVER. */
|
|
#define SetServer(x) (cli_status(x) = STAT_SERVER)
|
|
/** Mark a client with STAT_ME. */
|
|
#define SetMe(x) (cli_status(x) = STAT_ME)
|
|
/** Mark a client with STAT_USER. */
|
|
#define SetUser(x) (cli_status(x) = STAT_USER)
|
|
|
|
/** Return non-zero if a client is directly connected to me. */
|
|
#define MyConnect(x) (cli_from(x) == (x))
|
|
/** Return non-zero if a client is a locally connected user. */
|
|
#define MyUser(x) (MyConnect(x) && IsUser(x))
|
|
/** Return non-zero if a client is a locally connected IRC operator. */
|
|
#define MyOper(x) (MyConnect(x) && IsOper(x))
|
|
/** Return protocol version used by a server. */
|
|
#define Protocol(x) ((cli_serv(x))->prot)
|
|
|
|
/*
|
|
* flags macros
|
|
*/
|
|
/** Set a flag in a client's flags. */
|
|
#define SetFlag(cli, flag) FlagSet(&cli_flags(cli), flag)
|
|
/** Clear a flag from a client's flags. */
|
|
#define ClrFlag(cli, flag) FlagClr(&cli_flags(cli), flag)
|
|
/** Return non-zero if a flag is set in a client's flags. */
|
|
#define HasFlag(cli, flag) FlagHas(&cli_flags(cli), flag)
|
|
|
|
/** Return non-zero if the client is an IRC operator (global or local). */
|
|
#define IsAnOper(x) (IsOper(x) || IsLocOp(x) || IsAdmin(x))
|
|
/** Return non-zero if the client's connection is blocked. */
|
|
#define IsBlocked(x) HasFlag(x, FLAG_BLOCKED)
|
|
/** Return non-zero if the client's connection is still being burst. */
|
|
#define IsBurst(x) HasFlag(x, FLAG_BURST)
|
|
/** Return non-zero if we have received the peer's entire burst but
|
|
* not their EOB ack. */
|
|
#define IsBurstAck(x) HasFlag(x, FLAG_BURST_ACK)
|
|
/** Return non-zero if we are still bursting to the client. */
|
|
#define IsBurstOrBurstAck(x) (HasFlag(x, FLAG_BURST) || HasFlag(x, FLAG_BURST_ACK))
|
|
/** Return non-zero if the client has set mode +k (channel service). */
|
|
#define IsChannelService(x) HasFlag(x, FLAG_CHSERV)
|
|
/** Return non-zero if the client's socket is disconnected. */
|
|
#define IsDead(x) HasFlag(x, FLAG_DEADSOCKET)
|
|
/** Return non-zero if the client has set mode +d (deaf). */
|
|
#define IsDeaf(x) HasFlag(x, FLAG_DEAF)
|
|
/** Return non-zero if the client has been IP-checked for clones. */
|
|
#define IsIPChecked(x) HasFlag(x, FLAG_IPCHECK)
|
|
/** Return non-zero if we have received an ident response for the client. */
|
|
#define IsIdented(x) HasFlag(x, FLAG_GOTID)
|
|
/** Return non-zero if the client has set mode +i (invisible). */
|
|
#define IsInvisible(x) HasFlag(x, FLAG_INVISIBLE)
|
|
/** Return non-zero if the client caused a net.burst. */
|
|
#define IsJunction(x) HasFlag(x, FLAG_JUNCTION)
|
|
/** Return non-zero if the client has set mode +O (local operator) locally. */
|
|
#define IsLocOp(x) (MyConnect(x) && HasFlag(x, FLAG_LOCOP))
|
|
/** Return non-zero if the client has set mode +o (global operator). */
|
|
#define IsOper(x) HasFlag(x, FLAG_OPER)
|
|
/** Return non-zero if the client has an active UDP ping request. */
|
|
#define IsUPing(x) HasFlag(x, FLAG_UPING)
|
|
/** Return non-zero if the client has no '\n' in its buffer. */
|
|
#define NoNewLine(x) HasFlag(x, FLAG_NONL)
|
|
/** Return non-zero if the client has set mode +g (debugging). */
|
|
#define SendDebug(x) HasFlag(x, FLAG_DEBUG)
|
|
/** Return non-zero if the client has set mode +s (server notices). */
|
|
#define SendServNotice(x) HasFlag(x, FLAG_SERVNOTICE)
|
|
/** Return non-zero if the client has set mode +w (wallops). */
|
|
#define SendWallops(x) HasFlag(x, FLAG_WALLOP)
|
|
/** Return non-zero if the client claims to be a hub. */
|
|
#define IsHub(x) HasFlag(x, FLAG_HUB)
|
|
/** Return non-zero if the client understands IPv6 addresses in P10. */
|
|
#define IsIPv6(x) HasFlag(x, FLAG_IPV6)
|
|
/** Return non-zero if the client claims to be a services server. */
|
|
#define IsService(x) HasFlag(x, FLAG_SERVICE)
|
|
/** Return non-zero if the client has oplevels support. */
|
|
#define IsOpLevels(x) HasFlag(x, FLAG_OPLEVELS)
|
|
/** Return non-zero if the client has an account stamp. */
|
|
#define IsAccount(x) HasFlag(x, FLAG_ACCOUNT)
|
|
/** Return non-zero if the client has set mode +x (hidden host). */
|
|
#define IsHiddenHost(x) HasFlag(x, FLAG_HIDDENHOST)
|
|
/** Return non-zero if the client has set mode +W (whois notices). */
|
|
#define IsWhoisNotice(x) HasFlag(x, FLAG_WHOIS_NOTICE)
|
|
/** Return non-zero if the client has set mode +H (hide oper status). */
|
|
#define IsHideOper(x) HasFlag(x, FLAG_HIDE_OPER)
|
|
/** Return non-zero if the client has the channel hiding mode set. */
|
|
#define IsNoChan(x) HasFlag(x, FLAG_NOCHAN)
|
|
/** Return non-zero if the client has the hidden idle time mode set. */
|
|
#define IsNoIdle(x) HasFlag(x, FLAG_NOIDLE)
|
|
/** Return non-zero if the client supports extended NAMES */
|
|
#define IsNamesX(x) HasFlag(x, FLAG_NAMESX)
|
|
/** Return non-zero if the client supports user-host NAMES */
|
|
#define IsUHNames(x) HasFlag(x, FLAG_UHNAMES)
|
|
/** Return non-zero if the client is a WEBIRC client. */
|
|
#define IsWebIRC(x) HasFlag(x, FLAG_WEBIRC)
|
|
/** Return non-zero if the client should use USER username as ident. */
|
|
#define IsWebIRCUserIdent(x) HasFlag(x, FLAG_WEBIRC_USERIDENT)
|
|
/** Return non-zero if the client has had its IP address or host name changed. */
|
|
#define IsIPSpoofed(x) HasFlag(x, FLAG_IPSPOOFED)
|
|
/** Return non-zero if the client only accepts messages from clients with an account. */
|
|
#define IsAccountOnly(x) HasFlag(x, FLAG_ACCOUNTONLY)
|
|
/** Return non-zero if the client is private deaf */
|
|
#define IsPrivDeaf(x) HasFlag(x, FLAG_PRIVDEAF)
|
|
/** Return non-zero if the client has set mode +q (common chans only). */
|
|
#define IsCommonChansOnly(x) HasFlag(x, FLAG_COMMONCHANSONLY)
|
|
/** Return non-zero if the client has set +B. */
|
|
#define IsBot(x) HasFlag(x, FLAG_BOT)
|
|
/** Return non-zero if the client has got GeoIP data. */
|
|
#define IsGeoIP(x) HasFlag(x, FLAG_GEOIP)
|
|
/** Return non-zero if the client is an admin. */
|
|
#define IsAdmin(x) HasFlag(x, FLAG_ADMIN)
|
|
/** Return non-zero if the client has set +X. */
|
|
#define IsXtraOp(x) HasFlag(x, FLAG_XTRAOP)
|
|
/** Return non-zero if the client has set +L. */
|
|
#define IsNoLink(x) HasFlag(x, FLAG_NOLINK)
|
|
/** Return non-zero if the client has a cloaked IP. */
|
|
#define IsCloakIP(x) HasFlag(x, FLAG_CLOAKIP)
|
|
/** Return non-zero if the client has a cloaked host. */
|
|
#define IsCloakHost(x) HasFlag(x, FLAG_CLOAKHOST)
|
|
/** Return non-zero if the client has a fake host. */
|
|
#define IsFakeHost(x) HasFlag(x, FLAG_FAKEHOST)
|
|
/** Return non-zero if the client has a set host. */
|
|
#define IsSetHost(x) HasFlag(x, FLAG_SETHOST)
|
|
/** Return non-zero if the client is connected via SSL. */
|
|
#define IsSSL(x) HasFlag(x, FLAG_SSL)
|
|
/** Return non-zero if the client is connecting using STARTTLS. */
|
|
#define IsStartTLS(x) HasFlag(x, FLAG_STARTTLS)
|
|
/** Return non-zero if the client still needs SSL_accept(). */
|
|
#define IsSSLNeedAccept(x) HasFlag(x, FLAG_SSLNEEDACCEPT)
|
|
/** Return non-zero if the client is IPcheck exempt. */
|
|
#define IsIPCheckExempt(x) HasFlag(x, FLAG_IPCEXEMPT)
|
|
/** Return non-zero if the client is not IPcheck exempt. */
|
|
#define IsNotIPCheckExempt(x) HasFlag(x, FLAG_IPCNOTEXEMPT)
|
|
/** Return non-zero if the client has completed SASL authentication. */
|
|
#define IsSASLComplete(x) HasFlag(x, FLAG_SASLCOMPLETE)
|
|
/** Return non-zero if the client has been marked. */
|
|
#define IsMarked(x) HasFlag(x, FLAG_MARKED)
|
|
/** Return non-zero if the client cannot join channels. */
|
|
#define IsRestrictJoin(x) HasFlag(x, FLAG_RESTRICT_JOIN)
|
|
/** Return non-zero if the client cannot send private PRIVMSG or NOTICE. */
|
|
#define IsRestrictPrivMsg(x) HasFlag(x, FLAG_RESTRICT_PRIVMSG)
|
|
/** Return non-zero if the client cannot change his/her user modes. */
|
|
#define IsRestrictUMode(x) HasFlag(x, FLAG_RESTRICT_UMODE)
|
|
/** Return non-zero if the client is temporarily shunned. */
|
|
#define IsTempShun(x) HasFlag(x, FLAG_TEMPSHUN)
|
|
/** Return non-zero if the client /OPER'ed using a local O:Line. */
|
|
#define IsOperedLocal(x) HasFlag(x, FLAG_OPERED_LOCAL)
|
|
/** Return non-zero if the client /OPER'ed using a remote O:Line. */
|
|
#define IsOperedRemote(x) HasFlag(x, FLAG_OPERED_REMOTE)
|
|
/** Return non-zero if the server is NOOP'ed. */
|
|
#define IsServerNoop(x) HasFlag(x, FLAG_SERVER_NOOP)
|
|
/** Return non-zero if the client's CTCP VERSION reply has been sent out. */
|
|
#define IsCVersionSent(x) HasFlag(x, FLAG_SENT_CVERSION)
|
|
/** Return non-zero if the client has an active PING request. */
|
|
#define IsPingSent(x) HasFlag(x, FLAG_PINGSENT)
|
|
|
|
/** Return non-zero if the client has operator or server privileges. */
|
|
#define IsPrivileged(x) (IsAnOper(x) || IsServer(x))
|
|
/** Return non-zero if the client's host is hidden. */
|
|
#define HasHiddenHost(x) (IsHiddenHost(x) && IsAccount(x))
|
|
|
|
/** Mark a client as having an in-progress net.burst. */
|
|
#define SetBurst(x) SetFlag(x, FLAG_BURST)
|
|
/** Mark a client as being between EOB and EOB ACK. */
|
|
#define SetBurstAck(x) SetFlag(x, FLAG_BURST_ACK)
|
|
/** Mark a client as having mode +k (channel service). */
|
|
#define SetChannelService(x) SetFlag(x, FLAG_CHSERV)
|
|
/** Mark a client as having mode +d (deaf). */
|
|
#define SetDeaf(x) SetFlag(x, FLAG_DEAF)
|
|
/** Mark a client as having mode +g (debugging). */
|
|
#define SetDebug(x) SetFlag(x, FLAG_DEBUG)
|
|
/** Mark a client as having ident looked up. */
|
|
#define SetGotId(x) SetFlag(x, FLAG_GOTID)
|
|
/** Mark a client as being IP-checked. */
|
|
#define SetIPChecked(x) SetFlag(x, FLAG_IPCHECK)
|
|
/** Mark a client as having mode +i (invisible). */
|
|
#define SetInvisible(x) SetFlag(x, FLAG_INVISIBLE)
|
|
/** Mark a client as causing a net.join. */
|
|
#define SetJunction(x) SetFlag(x, FLAG_JUNCTION)
|
|
/** Mark a client as having mode +O (local operator). */
|
|
#define SetLocOp(x) SetFlag(x, FLAG_LOCOP)
|
|
/** Mark a client as having mode +o (global operator). */
|
|
#define SetOper(x) SetFlag(x, FLAG_OPER)
|
|
/** Mark a client as having a pending UDP ping. */
|
|
#define SetUPing(x) SetFlag(x, FLAG_UPING)
|
|
/** Mark a client as having mode +w (wallops). */
|
|
#define SetWallops(x) SetFlag(x, FLAG_WALLOP)
|
|
/** Mark a client as having mode +s (server notices). */
|
|
#define SetServNotice(x) SetFlag(x, FLAG_SERVNOTICE)
|
|
/** Mark a client as being a hub server. */
|
|
#define SetHub(x) SetFlag(x, FLAG_HUB)
|
|
/** Mark a client as being an IPv6-grokking server. */
|
|
#define SetIPv6(x) SetFlag(x, FLAG_IPV6)
|
|
/** Mark a client as being a services server. */
|
|
#define SetService(x) SetFlag(x, FLAG_SERVICE)
|
|
/** Mark a client as having oplevels support. */
|
|
#define SetOpLevels(x) SetFlag(x, FLAG_OPLEVELS)
|
|
/** Mark a client as having an account stamp. */
|
|
#define SetAccount(x) SetFlag(x, FLAG_ACCOUNT)
|
|
/** Mark a client as having mode +x (hidden host). */
|
|
#define SetHiddenHost(x) SetFlag(x, FLAG_HIDDENHOST)
|
|
/** Mark a client as having mode +W (whois notices). */
|
|
#define SetWhoisNotice(x) SetFlag(x, FLAG_WHOIS_NOTICE)
|
|
/** Mark a client as having mode +H (hide oper status). */
|
|
#define SetHideOper(x) SetFlag(x, FLAG_HIDE_OPER)
|
|
/** Mark a client as having the channel hiding mode set. */
|
|
#define SetNoChan(x) SetFlag(x, FLAG_NOCHAN)
|
|
/** Mark a client as having the hidden idle time mode set. */
|
|
#define SetNoIdle(x) SetFlag(x, FLAG_NOIDLE)
|
|
/** Mark a client as supporting extended NAMES. */
|
|
#define SetNamesX(x) SetFlag(x, FLAG_NAMESX)
|
|
/** Mark a client as supporting user-host NAMES. */
|
|
#define SetUHNames(x) SetFlag(x, FLAG_UHNAMES)
|
|
/** Mark a client as a WEBIRC client. */
|
|
#define SetWebIRC(x) SetFlag(x, FLAG_WEBIRC)
|
|
/** Mark a client as having to use USER username as ident. */
|
|
#define SetWebIRCUserIdent(x) SetFlag(x, FLAG_WEBIRC_USERIDENT)
|
|
/** Mark a client as having a spoofed IP or host name. */
|
|
#define SetIPSpoofed(x) SetFlag(x, FLAG_IPSPOOFED)
|
|
/** Mark a client as only accepting messages from users with accounts. */
|
|
#define SetAccountOnly(x) SetFlag(x, FLAG_ACCOUNTONLY)
|
|
/** Mark a client as being private deaf. */
|
|
#define SetPrivDeaf(x) SetFlag(x, FLAG_PRIVDEAF)
|
|
/** Mark a client as having mode +q (common chans only). */
|
|
#define SetCommonChansOnly(x) SetFlag(x, FLAG_COMMONCHANSONLY)
|
|
/** Mark a client as having mode +B (bot). */
|
|
#define SetBot(x) SetFlag(x, FLAG_BOT)
|
|
/** Mark a client as having GeoIP data. */
|
|
#define SetGeoIP(x) SetFlag(x, FLAG_GEOIP)
|
|
/** Mark a client as being an admin. */
|
|
#define SetAdmin(x) SetFlag(x, FLAG_ADMIN)
|
|
/** Mark a client as having mode +X (XtraOp). */
|
|
#define SetXtraOp(x) SetFlag(x, FLAG_XTRAOP)
|
|
/** Mark a client as having mode +L (No Redirect). */
|
|
#define SetNoLink(x) SetFlag(x, FLAG_NOLINK)
|
|
/** Mark a client as having a cloaked IP. */
|
|
#define SetCloakIP(x) SetFlag(x, FLAG_CLOAKIP)
|
|
/** Mark a client as having a cloaked host. */
|
|
#define SetCloakHost(x) SetFlag(x, FLAG_CLOAKHOST)
|
|
/** Mark a client as having a fake host. */
|
|
#define SetFakeHost(x) SetFlag(x, FLAG_FAKEHOST)
|
|
/** Mark a client as having a set host. */
|
|
#define SetSetHost(x) SetFlag(x, FLAG_SETHOST)
|
|
/** Mark a client as having connected via SSL. */
|
|
#define SetSSL(x) SetFlag(x, FLAG_SSL)
|
|
/** Mark a client as using STARTTLS. */
|
|
#define SetStartTLS(x) SetFlag(x, FLAG_STARTTLS)
|
|
/** Mark a client as needing SSL_accept(). */
|
|
#define SetSSLNeedAccept(x) SetFlag(x, FLAG_SSLNEEDACCEPT)
|
|
/** Mark a client as IPcheck exempt. */
|
|
#define SetIPCheckExempt(x) SetFlag(x, FLAG_IPCEXEMPT)
|
|
/** Mark a client as not IPcheck exempt. */
|
|
#define SetNotIPCheckExempt(x) SetFlag(x, FLAG_IPCNOTEXEMPT)
|
|
/** Mark a client as having completed SASL authentication. */
|
|
#define SetSASLComplete(x) SetFlag(x, FLAG_SASLCOMPLETE)
|
|
/** Mark a client as having been marked.. */
|
|
#define SetMarked(x) SetFlag(x, FLAG_MARKED)
|
|
/** Mark a client as not being allowed to join channels. */
|
|
#define SetRestrictJoin(x) SetFlag(x, FLAG_RESTRICT_JOIN)
|
|
/** Mark a client as not being allowed to send private PRIVMSG and NOTICE. */
|
|
#define SetRestrictPrivMsg(x) SetFlag(x, FLAG_RESTRICT_PRIVMSG)
|
|
/** Mark a client as not being allowed to change user modes. */
|
|
#define SetRestrictUMode(x) SetFlag(x, FLAG_RESTRICT_UMODE)
|
|
/** Mark a client as temporarily shunned. */
|
|
#define SetTempShun(x) SetFlag(x, FLAG_TEMPSHUN)
|
|
/** Mark a client as having /OPER'ed using a local O:Line. */
|
|
#define SetOperedLocal(x) SetFlag(x, FLAG_OPERED_LOCAL)
|
|
/** Mark a client as having /OPER'ed using a remote O:Line. */
|
|
#define SetOperedRemote(x) SetFlag(x, FLAG_OPERED_REMOTE)
|
|
/** Mark a server as having been NOOP'ed. */
|
|
#define SetServerNoop(x) SetFlag(x, FLAG_SERVER_NOOP)
|
|
/** Mark a client as having had it's CTCP VERSION sent out. */
|
|
#define SetCVersionSent(x) SetFlag(x, FLAG_SENT_CVERSION)
|
|
/** Mark a client as having a pending PING. */
|
|
#define SetPingSent(x) SetFlag(x, FLAG_PINGSENT)
|
|
|
|
/** Return non-zero if \a sptr sees \a acptr as an operator. */
|
|
#define SeeOper(sptr,acptr) (IsAnOper(acptr) && ((HasPriv(acptr, PRIV_DISPLAY) && \
|
|
!IsHideOper(acptr)) || HasPriv(sptr, PRIV_SEE_OPERS)))
|
|
|
|
/** Clear the client's net.burst in-progress flag. */
|
|
#define ClearBurst(x) ClrFlag(x, FLAG_BURST)
|
|
/** Clear the client's between EOB and EOB ACK flag. */
|
|
#define ClearBurstAck(x) ClrFlag(x, FLAG_BURST_ACK)
|
|
/** Remove mode +k (channel service) from the client. */
|
|
#define ClearChannelService(x) ClrFlag(x, FLAG_CHSERV)
|
|
/** Remove mode +d (deaf) from the client. */
|
|
#define ClearDeaf(x) ClrFlag(x, FLAG_DEAF)
|
|
/** Remove mode +g (debugging) from the client. */
|
|
#define ClearDebug(x) ClrFlag(x, FLAG_DEBUG)
|
|
/** Remove the client's IP-checked flag. */
|
|
#define ClearIPChecked(x) ClrFlag(x, FLAG_IPCHECK)
|
|
/** Remove mode +i (invisible) from the client. */
|
|
#define ClearInvisible(x) ClrFlag(x, FLAG_INVISIBLE)
|
|
/** Remove mode +O (local operator) from the client. */
|
|
#define ClearLocOp(x) ClrFlag(x, FLAG_LOCOP)
|
|
/** Remove mode +o (global operator) from the client. */
|
|
#define ClearOper(x) ClrFlag(x, FLAG_OPER)
|
|
/** Clear the client's pending UDP ping flag. */
|
|
#define ClearUPing(x) ClrFlag(x, FLAG_UPING)
|
|
/** Remove mode +w (wallops) from the client. */
|
|
#define ClearWallops(x) ClrFlag(x, FLAG_WALLOP)
|
|
/** Remove mode +s (server notices) from the client. */
|
|
#define ClearServNotice(x) ClrFlag(x, FLAG_SERVNOTICE)
|
|
/** Remove mode +x (hidden host) from the client. */
|
|
#define ClearHiddenHost(x) ClrFlag(x, FLAG_HIDDENHOST)
|
|
/** Remove mode +W (whois notices) from the client. */
|
|
#define ClearWhoisNotice(x) ClrFlag(x, FLAG_WHOIS_NOTICE)
|
|
/** Remove mode +H (hide oper status) from the client. */
|
|
#define ClearHideOper(x) ClrFlag(x, FLAG_HIDE_OPER)
|
|
/** Remove mode +n (hide channels in whois) from the client. */
|
|
#define ClearNoChan(x) ClrFlag(x, FLAG_NOCHAN)
|
|
/** Remove mode +I (hide idle time in whois) from the client. */
|
|
#define ClearNoIdle(x) ClrFlag(x, FLAG_NOIDLE)
|
|
/** Client no longer supports extended names. */
|
|
#define ClearNamesX(x) ClrFlag(x, FLAG_NAMESX)
|
|
/** Client no longer supports user-host names. */
|
|
#define ClearUHNames(x) ClrFlag(x, FLAG_UHNAMES)
|
|
/** Client is no long a WEBIRC client. */
|
|
#define ClearWebIRC(x) ClrFlag(x, FLAG_WEBIRC)
|
|
/** Client no longer has to use USER username as ident. */
|
|
#define ClearWebIRCUserIdent(x) ClrFlag(x, FLAG_WEBIRC_USERIDENT)
|
|
/** Client no longer has a spoofed IP or host name. */
|
|
#define ClearIPSpoofed(x) ClrFlag(x, FLAG_IPSPOOFED)
|
|
/** Remove mode +R (only accept pms from users with an account) from the client. */
|
|
#define ClearAccountOnly(x) ClrFlag(x, FLAG_ACCOUNTONLY)
|
|
/** Client is no longer private deaf. */
|
|
#define ClearPrivDeaf(x) ClrFlag(x, FLAG_PRIVDEAF)
|
|
/** Remove mode +q (common chans only) from a client */
|
|
#define ClearCommonChansOnly(x) ClrFlag(x, FLAG_COMMONCHANSONLY)
|
|
/** Remove mode +B (bot) flag from the client */
|
|
#define ClearBot(x) ClrFlag(x, FLAG_BOT)
|
|
/** Client no longer has GeoIP data. */
|
|
#define ClearGeoIP(x) ClrFlag(x, FLAG_GEOIP)
|
|
/** Client is no long an admin. */
|
|
#define ClearAdmin(x) ClrFlag(x, FLAG_ADMIN)
|
|
/** Remove mode +X (XtraOp) flag from client */
|
|
#define ClearXtraOp(x) ClrFlag(x, FLAG_XTRAOP)
|
|
/** Remove mode +L (No Redirect) flag from client */
|
|
#define ClearNoLink(x) ClrFlag(x, FLAG_NOLINK)
|
|
/** Client no longer has a cloaked IP. */
|
|
#define ClearCloakIP(x) ClrFlag(x, FLAG_CLOAKIP)
|
|
/** Client no longer has a cloaked host. */
|
|
#define ClearCloakHost(x) ClrFlag(x, FLAG_CLOAKHOST)
|
|
/** Client no longer has a fake host. */
|
|
#define ClearFakeHost(x) ClrFlag(x, FLAG_FAKEHOST)
|
|
/** Client no longer has a set host. */
|
|
#define ClearSetHost(x) ClrFlag(x, FLAG_SETHOST)
|
|
/** Client is no longer connected via SSL (this cannot be possible). */
|
|
#define ClearSSL(x) ClrFlag(x, FLAG_SSL)
|
|
/** Client is no longer using STARTTLS. */
|
|
#define ClearStartTLS(x) ClrFlag(x, FLAG_STARTTLS)
|
|
/** Client no longer needs SSL_accept(). */
|
|
#define ClearSSLNeedAccept(x) ClrFlag(x, FLAG_SSLNEEDACCEPT)
|
|
/** Clear the client's join restriction. */
|
|
#define ClearRestrictJoin(x) ClrFlag(x, FLAG_RESTRICT_JOIN)
|
|
/** Clear the client's PRIVMSG/NOTICE restriction. */
|
|
#define ClearRestrictPrivMsg(x) ClrFlag(x, FLAG_RESTRICT_PRIVMSG)
|
|
/** Clear the client's user mode restriction. */
|
|
#define ClearRestrictUMode(x) ClrFlag(x, FLAG_RESTRICT_UMODE)
|
|
/** Client is no longer temporarily shunned. */
|
|
#define ClearTempShun(x) ClrFlag(x, FLAG_TEMPSHUN)
|
|
/** Client is no longer OPER'ed using a local O:Line. */
|
|
#define ClearOperedLocal(x) ClrFlag(x, FLAG_OPERED_LOCAL)
|
|
/** Client is no longet OPER'ed using a remote O:Line. */
|
|
#define ClearOperedRemote(x) ClrFlag(x, FLAG_OPERED_REMOTE)
|
|
/** Server is no longer NOOP'ed. */
|
|
#define ClearServerNoop(x) ClrFlag(x, FLAG_SERVER_NOOP)
|
|
/** Clear the client's pending PING flag. */
|
|
#define ClearPingSent(x) ClrFlag(x, FLAG_PINGSENT)
|
|
/** Clear the client's HUB flag. */
|
|
#define ClearHub(x) ClrFlag(x, FLAG_HUB)
|
|
/** Clear the client's OPLEVELS flag. */
|
|
#define ClearOpLevels(x) ClrFlag(x, FLAG_OPLEVELS)
|
|
/** Clear the client's account status. */
|
|
#define ClearAccount(x) ClrFlag(x, FLAG_ACCOUNT)
|
|
|
|
/* free flags */
|
|
#define FREEFLAG_SOCKET 0x0001 /**< socket needs to be freed */
|
|
#define FREEFLAG_TIMER 0x0002 /**< timer needs to be freed */
|
|
|
|
/* server notice stuff */
|
|
|
|
#define SNO_ADD 1 /**< Perform "or" on server notice mask. */
|
|
#define SNO_DEL 2 /**< Perform "and ~x" on server notice mask. */
|
|
#define SNO_SET 3 /**< Set server notice mask. */
|
|
/* DON'T CHANGE THESE VALUES ! */
|
|
/* THE CLIENTS DEPEND ON IT ! */
|
|
#define SNO_OLDSNO 0x1 /**< unsorted old messages */
|
|
#define SNO_SERVKILL 0x2 /**< server kills (nick collisions) */
|
|
#define SNO_OPERKILL 0x4 /**< oper kills */
|
|
#define SNO_HACK2 0x8 /**< desyncs */
|
|
#define SNO_HACK3 0x10 /**< temporary desyncs */
|
|
#define SNO_UNAUTH 0x20 /**< unauthorized connections */
|
|
#define SNO_TCPCOMMON 0x40 /**< common TCP or socket errors */
|
|
#define SNO_TOOMANY 0x80 /**< too many connections */
|
|
#define SNO_HACK4 0x100 /**< Uworld actions on channels */
|
|
#define SNO_GLINE 0x200 /**< glines */
|
|
#define SNO_NETWORK 0x400 /**< net join/break, etc */
|
|
#define SNO_IPMISMATCH 0x800 /**< IP mismatches */
|
|
#define SNO_THROTTLE 0x1000 /**< host throttle add/remove notices */
|
|
#define SNO_OLDREALOP 0x2000 /**< old oper-only messages */
|
|
#define SNO_CONNEXIT 0x4000 /**< client connect/exit (ugh) */
|
|
#define SNO_AUTO 0x8000 /**< AUTO G-Lines */
|
|
#define SNO_DEBUG 0x10000 /**< debugging messages (DEBUGMODE only) */
|
|
#define SNO_NICKCHG 0x20000 /**< Nick change notices */
|
|
#define SNO_AUTH 0x40000 /**< IAuth notices */
|
|
#define SNO_WEBIRC 0x80000 /**< WebIRC notices */
|
|
|
|
/** Bitmask of all valid server notice bits. */
|
|
#ifdef DEBUGMODE
|
|
# define SNO_ALL 0xfffff
|
|
#else
|
|
# define SNO_ALL 0xeffff
|
|
#endif
|
|
|
|
/** Server notice bits allowed to normal users. */
|
|
#define SNO_USER (SNO_ALL & ~SNO_OPER)
|
|
|
|
/** Server notice bits enabled by default for normal users. */
|
|
#define SNO_DEFAULT (SNO_NETWORK|SNO_OPERKILL|SNO_GLINE)
|
|
/** Server notice bits enabled by default for IRC operators. */
|
|
#define SNO_OPERDEFAULT (SNO_DEFAULT|SNO_HACK2|SNO_THROTTLE|SNO_OLDSNO)
|
|
/** Server notice bits reserved to IRC operators. */
|
|
#define SNO_OPER (SNO_CONNEXIT|SNO_OLDREALOP|SNO_AUTH)
|
|
/** Noisy server notice bits that cause other bits to be cleared during connect. */
|
|
#define SNO_NOISY (SNO_SERVKILL|SNO_UNAUTH)
|
|
|
|
/** Test whether a privilege has been granted to a client. */
|
|
#define HasPriv(cli, priv) FlagHas(&cli_privs(cli), priv)
|
|
/** Grant a privilege to a client. */
|
|
#define SetPriv(cli, priv) FlagSet(&cli_privs(cli), priv)
|
|
/** Revoke a privilege from a client. */
|
|
#define ClrPriv(cli, priv) FlagClr(&cli_privs(cli), priv)
|
|
|
|
/** Used in setting and unsetting privs. */
|
|
#define PRIV_ADD 1
|
|
/** Used in setting and unsetting privs. */
|
|
#define PRIV_DEL 0
|
|
|
|
/** Test whether a client has a capability */
|
|
#define HasCap(cli, cap) CapHas(cli_capab(cli), (cap))
|
|
/** Test whether a client has the capability active */
|
|
#define CapActive(cli, cap) CapHas(cli_active(cli), (cap))
|
|
|
|
#define HIDE_IP 0 /**< Do not show IP address in get_client_name() */
|
|
#define SHOW_IP 1 /**< Show ident and IP address in get_client_name() */
|
|
|
|
extern const char* get_client_name(const struct Client* sptr, int showip);
|
|
extern const char* client_get_default_umode(const struct Client* sptr);
|
|
extern int client_get_hidehostcomponents(const struct Client* sptr);
|
|
extern int client_get_ping(const struct Client* local_client);
|
|
extern void client_drop_sendq(struct Connection* con);
|
|
extern void client_add_sendq(struct Connection* con,
|
|
struct Connection** con_p);
|
|
extern void client_set_privs(struct Client *client, struct ConfItem *oper);
|
|
extern int client_report_privs(struct Client* to, struct Client* client);
|
|
extern void client_check_privs(struct Client *client, struct Client *replyto);
|
|
extern void client_send_privs(struct Client *from, struct Client *to, struct Client *client);
|
|
extern void client_check_marks(struct Client *client, struct Client *replyto);
|
|
extern void client_sendtoserv_privs(struct Client *client);
|
|
extern char *client_print_privs(struct Client *client);
|
|
|
|
extern int client_modify_priv_by_name(struct Client *who, char *priv, int what);
|
|
extern int clear_privs(struct Client *who);
|
|
|
|
#endif /* INCLUDED_client_h */
|
|
|