]>
Commit | Line | Data |
---|---|---|
212380e3 | 1 | /* |
2 | * charybdis: A useful ircd. | |
3 | * client.h: The ircd client header. | |
4 | * | |
5 | * Copyright (C) 1990 Jarkko Oikarinen and University of Oulu, Co Center | |
6 | * Copyright (C) 1996-2002 Hybrid Development Team | |
7 | * Copyright (C) 2002-2004 ircd-ratbox development team | |
8 | * Copyright (C) 2005 William Pitcock and Jilles Tjoelker | |
9 | * | |
10 | * This program is free software; you can redistribute it and/or modify | |
11 | * it under the terms of the GNU General Public License as published by | |
12 | * the Free Software Foundation; either version 2 of the License, or | |
13 | * (at your option) any later version. | |
14 | * | |
15 | * This program is distributed in the hope that it will be useful, | |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
18 | * GNU General Public License for more details. | |
19 | * | |
20 | * You should have received a copy of the GNU General Public License | |
21 | * along with this program; if not, write to the Free Software | |
22 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 | |
23 | * USA | |
24 | * | |
54015b5f | 25 | * $Id: client.h 3446 2007-05-14 22:21:16Z jilles $ |
212380e3 | 26 | */ |
27 | ||
28 | #ifndef INCLUDED_client_h | |
29 | #define INCLUDED_client_h | |
30 | ||
31 | #include "config.h" | |
32 | ||
33 | #if !defined(CONFIG_RATBOX_LEVEL_1) | |
34 | #error Incorrect config.h for this revision of ircd. | |
35 | #endif | |
36 | ||
37 | #include "ircd_defs.h" | |
212380e3 | 38 | #include "channel.h" |
39 | #include "res.h" | |
40 | #include "snomask.h" | |
41 | #include "irc_string.h" | |
42 | #include "sprintf_irc.h" | |
43 | #include "ircd.h" | |
212380e3 | 44 | |
45 | /* other structs */ | |
46 | struct Blacklist; | |
47 | ||
48 | /* we store ipv6 ips for remote clients, so this needs to be v6 always */ | |
49 | #define HOSTIPLEN 53 /* sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255.ipv6") */ | |
50 | #define PASSWDLEN 128 | |
51 | #define CIPHERKEYLEN 64 /* 512bit */ | |
52 | #define CLIENT_BUFSIZE 512 /* must be at least 512 bytes */ | |
53 | ||
54 | #define IDLEN 10 | |
55 | ||
56 | /* | |
57 | * pre declare structs | |
58 | */ | |
59 | struct ConfItem; | |
60 | struct Whowas; | |
61 | struct DNSReply; | |
62 | struct Listener; | |
63 | struct Client; | |
64 | struct User; | |
65 | struct Server; | |
66 | struct LocalUser; | |
67 | struct AuthRequest; | |
68 | struct PreClient; | |
69 | struct ListClient; | |
994544c2 | 70 | struct scache_entry; |
212380e3 | 71 | |
72 | /* | |
73 | * Atheme's coding standards require that we use BSD-style user-defined types | |
74 | * for stuff. Fun! --nenolod | |
75 | */ | |
76 | typedef struct User user_t; | |
77 | typedef struct Server server_t; | |
78 | typedef struct Client client_t; | |
79 | typedef struct LocalUser local_user_t; | |
80 | typedef struct Listener listener_t; | |
81 | typedef struct DNSReply dns_reply_t; | |
82 | typedef struct Whowas whowas_entry_t; | |
83 | typedef struct ConfItem conf_item_t; | |
84 | typedef struct AuthRequest auth_request_t; | |
85 | typedef struct PreClient pre_client_t; | |
86 | typedef struct ListClient list_client_t; | |
87 | ||
88 | /* | |
89 | * Client structures | |
90 | */ | |
91 | struct User | |
92 | { | |
08d11e34 WP |
93 | rb_dlink_list channel; /* chain of channel pointer blocks */ |
94 | rb_dlink_list invited; /* chain of invite pointer blocks */ | |
212380e3 | 95 | char *away; /* pointer to away message */ |
96 | int refcnt; /* Number of times this block is referenced */ | |
212380e3 | 97 | |
98 | char suser[NICKLEN+1]; | |
99 | }; | |
100 | ||
101 | struct Server | |
102 | { | |
103 | user_t *user; /* who activated this connection */ | |
212380e3 | 104 | char by[NICKLEN]; |
08d11e34 WP |
105 | rb_dlink_list servers; |
106 | rb_dlink_list users; | |
212380e3 | 107 | int caps; /* capabilities bit-field */ |
108 | char *fullcaps; | |
994544c2 | 109 | struct scache_entry *nameinfo; |
212380e3 | 110 | }; |
111 | ||
112 | struct SlinkRpl | |
113 | { | |
114 | int command; | |
115 | int datalen; | |
116 | int gotdatalen; | |
117 | int readdata; | |
118 | unsigned char *data; | |
119 | }; | |
120 | ||
121 | struct ZipStats | |
122 | { | |
123 | unsigned long in; | |
124 | unsigned long in_wire; | |
125 | unsigned long out; | |
126 | unsigned long out_wire; | |
127 | unsigned long inK; | |
128 | unsigned long inK_wire; | |
129 | unsigned long outK; | |
130 | unsigned long outK_wire; | |
131 | double in_ratio; | |
132 | double out_ratio; | |
133 | }; | |
134 | ||
135 | struct Client | |
136 | { | |
08d11e34 WP |
137 | rb_dlink_node node; |
138 | rb_dlink_node lnode; | |
212380e3 | 139 | user_t *user; /* ...defined, if this is a User */ |
140 | server_t *serv; /* ...defined, if this is a server */ | |
141 | client_t *servptr; /* Points to server this Client is on */ | |
142 | client_t *from; /* == self, if Local Client, *NEVER* NULL! */ | |
143 | ||
144 | whowas_entry_t *whowas; /* Pointers to whowas structs */ | |
145 | time_t tsinfo; /* TS on the nick, SVINFO on server */ | |
146 | unsigned int umodes; /* opers, normal users subset */ | |
147 | unsigned int flags; /* client flags */ | |
148 | unsigned int flags2; /* ugh. overflow */ | |
149 | ||
150 | unsigned int snomask; /* server notice mask */ | |
151 | ||
152 | int hopcount; /* number of servers to this 0 = local */ | |
153 | unsigned short status; /* Client type */ | |
154 | unsigned char handler; /* Handler index */ | |
155 | unsigned long serial; /* used to enforce 1 send per nick */ | |
156 | ||
157 | /* client->name is the unique name for a client nick or host */ | |
158 | char name[HOSTLEN + 1]; | |
159 | ||
160 | /* | |
161 | * client->username is the username from ident or the USER message, | |
162 | * If the client is idented the USER message is ignored, otherwise | |
163 | * the username part of the USER message is put here prefixed with a | |
164 | * tilde depending on the I:line, Once a client has registered, this | |
165 | * field should be considered read-only. | |
166 | */ | |
167 | char username[USERLEN + 1]; /* client's username */ | |
168 | ||
169 | /* | |
170 | * client->host contains the resolved name or ip address | |
171 | * as a string for the user, it may be fiddled with for oper spoofing etc. | |
172 | */ | |
173 | char host[HOSTLEN + 1]; /* client's hostname */ | |
174 | char orighost[HOSTLEN + 1]; /* original hostname (before dynamic spoofing) */ | |
175 | char sockhost[HOSTIPLEN + 1]; /* clients ip */ | |
176 | char info[REALLEN + 1]; /* Free form additional client info */ | |
177 | ||
178 | char id[IDLEN]; /* UID/SID, unique on the network */ | |
179 | ||
180 | /* list of who has this client on their allow list, its counterpart | |
181 | * is in LocalUser | |
182 | */ | |
08d11e34 | 183 | rb_dlink_list on_allow_list; |
212380e3 | 184 | |
185 | local_user_t *localClient; | |
186 | pre_client_t *preClient; | |
187 | }; | |
188 | ||
189 | struct LocalUser | |
190 | { | |
08d11e34 | 191 | rb_dlink_node tnode; /* This is the node for the local list type the client is on*/ |
212380e3 | 192 | /* |
193 | * The following fields are allocated only for local clients | |
194 | * (directly connected to *this* server with a socket. | |
195 | */ | |
196 | /* Anti flooding part, all because of lamers... */ | |
197 | time_t last_join_time; /* when this client last | |
198 | joined a channel */ | |
199 | time_t last_leave_time; /* when this client last | |
200 | * left a channel */ | |
201 | int join_leave_count; /* count of JOIN/LEAVE in less than | |
202 | MIN_JOIN_LEAVE_TIME seconds */ | |
203 | int oper_warn_count_down; /* warn opers of this possible | |
204 | spambot every time this gets to 0 */ | |
205 | time_t last_caller_id_time; | |
206 | time_t first_received_message_time; | |
207 | int received_number_of_privmsgs; | |
208 | int flood_noticed; | |
209 | ||
210 | time_t lasttime; /* last time we parsed something */ | |
211 | time_t firsttime; /* time client was created */ | |
212 | ||
213 | /* Send and receive linebuf queues .. */ | |
214 | buf_head_t buf_sendq; | |
215 | buf_head_t buf_recvq; | |
216 | /* | |
217 | * we want to use unsigned int here so the sizes have a better chance of | |
218 | * staying the same on 64 bit machines. The current trend is to use | |
219 | * I32LP64, (32 bit ints, 64 bit longs and pointers) and since ircd | |
220 | * will NEVER run on an operating system where ints are less than 32 bits, | |
221 | * it's a relatively safe bet to use ints. Since right shift operations are | |
222 | * performed on these, it's not safe to allow them to become negative, | |
223 | * which is possible for long running server connections. Unsigned values | |
224 | * generally overflow gracefully. --Bleep | |
225 | */ | |
226 | unsigned int sendM; /* Statistics: protocol messages send */ | |
227 | unsigned int sendK; /* Statistics: total k-bytes send */ | |
228 | unsigned int receiveM; /* Statistics: protocol messages received */ | |
229 | unsigned int receiveK; /* Statistics: total k-bytes received */ | |
230 | unsigned short sendB; /* counters to count upto 1-k lots of bytes */ | |
231 | unsigned short receiveB; /* sent and received. */ | |
232 | listener_t *listener; /* listener accepted from */ | |
233 | conf_item_t *att_conf; /* attached conf */ | |
234 | struct server_conf *att_sconf; | |
235 | ||
79edef09 | 236 | struct rb_sockaddr_storage ip; |
212380e3 | 237 | time_t last_nick_change; |
238 | int number_of_nick_changes; | |
239 | ||
240 | /* | |
241 | * XXX - there is no reason to save this, it should be checked when it's | |
242 | * received and not stored, this is not used after registration | |
243 | * | |
244 | * agreed. lets get rid of it someday! --nenolod | |
245 | */ | |
246 | char *passwd; | |
247 | char *opername; /* name of operator{} block being used or tried (challenge) */ | |
248 | char *challenge; | |
249 | char *fullcaps; | |
250 | ||
251 | int caps; /* capabilities bit-field */ | |
08d11e34 | 252 | rb_fde_t *F; /* >= 0, for local clients */ |
212380e3 | 253 | |
254 | /* time challenge response is valid for */ | |
255 | time_t chal_time; | |
256 | ||
257 | int ctrlfd; /* For servers: | |
258 | control fd used for sending commands | |
259 | to servlink */ | |
260 | ||
261 | struct SlinkRpl slinkrpl; /* slink reply being parsed */ | |
262 | unsigned char *slinkq; /* sendq for control data */ | |
263 | int slinkq_ofs; /* ofset into slinkq */ | |
264 | int slinkq_len; /* length remaining after slinkq_ofs */ | |
265 | ||
266 | struct ZipStats zipstats; | |
267 | ||
268 | time_t last_away; /* Away since... */ | |
269 | time_t last; | |
270 | ||
271 | /* clients allowed to talk through +g */ | |
08d11e34 | 272 | rb_dlink_list allow_list; |
212380e3 | 273 | |
274 | /* nicknames theyre monitoring */ | |
08d11e34 | 275 | rb_dlink_list monitor_list; |
212380e3 | 276 | |
277 | /* | |
278 | * Anti-flood stuff. We track how many messages were parsed and how | |
279 | * many we were allowed in the current second, and apply a simple decay | |
280 | * to avoid flooding. | |
281 | * -- adrian | |
282 | */ | |
283 | int allow_read; /* how many we're allowed to read in this second */ | |
284 | int actually_read; /* how many we've actually read in this second */ | |
285 | int sent_parsed; /* how many messages we've parsed in this second */ | |
286 | time_t last_knock; /* time of last knock */ | |
287 | unsigned long random_ping; | |
288 | auth_request_t *auth_request; | |
289 | ||
58e8319c VY |
290 | /* target change stuff */ |
291 | uint32_t targets[10]; /* targets were aware of (fnv32(use_id(target_p))) */ | |
292 | unsigned int targinfo[2]; /* cyclic array, no in use */ | |
212380e3 | 293 | time_t target_last; /* last time we cleared a slot */ |
294 | ||
295 | list_client_t *safelist_data; | |
296 | ||
297 | char *mangledhost; /* non-NULL if host mangling module loaded and | |
298 | applicable to this client */ | |
dbb537ba | 299 | |
bc475bf0 VY |
300 | struct rb_sockaddr_storage *lip; /* alloc before auth/freed after auth */\r |
301 | struct _ssl_ctl *ssl_ctl; /* which ssl daemon we're associate with */ | |
cd7082fb | 302 | rb_uint32_t localflags; |
212380e3 | 303 | }; |
304 | ||
305 | struct PreClient | |
306 | { | |
307 | char spoofnick[NICKLEN + 1]; | |
308 | char spoofuser[USERLEN + 1]; | |
309 | char spoofhost[HOSTLEN + 1]; | |
310 | ||
311 | char sasl_agent[IDLEN]; | |
312 | unsigned char sasl_out; | |
313 | unsigned char sasl_complete; | |
314 | ||
08d11e34 | 315 | rb_dlink_list dnsbl_queries; /* list of struct BlacklistClient * */ |
212380e3 | 316 | struct Blacklist *dnsbl_listed; /* first dnsbl where it's listed */ |
317 | }; | |
318 | ||
319 | struct ListClient | |
320 | { | |
321 | unsigned int hash_indice; | |
322 | unsigned int users_min, users_max; | |
323 | ||
324 | /* It would be nice to add other modifiers, | |
325 | * but not for 1.1 --nenolod | |
326 | */ | |
327 | }; | |
328 | ||
329 | struct exit_client_hook | |
330 | { | |
331 | struct Client *client_p; | |
332 | char exit_message[TOPICLEN]; | |
333 | }; | |
334 | ||
335 | /* | |
336 | * status macros. | |
337 | */ | |
338 | #define STAT_CONNECTING 0x01 | |
339 | #define STAT_HANDSHAKE 0x02 | |
340 | #define STAT_ME 0x04 | |
341 | #define STAT_UNKNOWN 0x08 | |
342 | #define STAT_REJECT 0x10 | |
343 | #define STAT_SERVER 0x20 | |
344 | #define STAT_CLIENT 0x40 | |
345 | ||
346 | ||
347 | #define IsRegisteredUser(x) ((x)->status == STAT_CLIENT) | |
348 | #define IsRegistered(x) (((x)->status > STAT_UNKNOWN) && ((x)->status != STAT_REJECT)) | |
349 | #define IsConnecting(x) ((x)->status == STAT_CONNECTING) | |
350 | #define IsHandshake(x) ((x)->status == STAT_HANDSHAKE) | |
351 | #define IsMe(x) ((x)->status == STAT_ME) | |
352 | #define IsUnknown(x) ((x)->status == STAT_UNKNOWN) | |
353 | #define IsServer(x) ((x)->status == STAT_SERVER) | |
354 | #define IsClient(x) ((x)->status == STAT_CLIENT) | |
355 | #define IsReject(x) ((x)->status == STAT_REJECT) | |
356 | ||
357 | #define IsAnyServer(x) (IsServer(x) || IsHandshake(x) || IsConnecting(x)) | |
358 | ||
359 | #define IsOper(x) ((x)->umodes & UMODE_OPER) | |
360 | #define IsAdmin(x) ((x)->umodes & UMODE_ADMIN) | |
361 | ||
362 | #define SetReject(x) {(x)->status = STAT_REJECT; \ | |
363 | (x)->handler = UNREGISTERED_HANDLER; } | |
364 | ||
365 | #define SetConnecting(x) {(x)->status = STAT_CONNECTING; \ | |
366 | (x)->handler = UNREGISTERED_HANDLER; } | |
367 | ||
368 | #define SetHandshake(x) {(x)->status = STAT_HANDSHAKE; \ | |
369 | (x)->handler = UNREGISTERED_HANDLER; } | |
370 | ||
371 | #define SetMe(x) {(x)->status = STAT_ME; \ | |
372 | (x)->handler = UNREGISTERED_HANDLER; } | |
373 | ||
374 | #define SetUnknown(x) {(x)->status = STAT_UNKNOWN; \ | |
375 | (x)->handler = UNREGISTERED_HANDLER; } | |
376 | ||
377 | #define SetServer(x) {(x)->status = STAT_SERVER; \ | |
378 | (x)->handler = SERVER_HANDLER; } | |
379 | ||
380 | #define SetClient(x) {(x)->status = STAT_CLIENT; \ | |
381 | (x)->handler = IsOper((x)) ? \ | |
382 | OPER_HANDLER : CLIENT_HANDLER; } | |
383 | #define SetRemoteClient(x) {(x)->status = STAT_CLIENT; \ | |
384 | (x)->handler = RCLIENT_HANDLER; } | |
385 | ||
386 | #define STAT_CLIENT_PARSE (STAT_UNKNOWN | STAT_CLIENT) | |
387 | #define STAT_SERVER_PARSE (STAT_CONNECTING | STAT_HANDSHAKE | STAT_SERVER) | |
388 | ||
389 | #define PARSE_AS_CLIENT(x) ((x)->status & STAT_CLIENT_PARSE) | |
390 | #define PARSE_AS_SERVER(x) ((x)->status & STAT_SERVER_PARSE) | |
391 | ||
392 | ||
393 | /* | |
394 | * ts stuff | |
395 | */ | |
396 | #define TS_CURRENT 6 | |
397 | ||
398 | #ifdef TS6_ONLY | |
399 | #define TS_MIN 6 | |
400 | #else | |
401 | #define TS_MIN 3 | |
402 | #endif | |
403 | ||
404 | #define TS_DOESTS 0x10000000 | |
405 | #define DoesTS(x) ((x)->tsinfo & TS_DOESTS) | |
406 | ||
407 | #define has_id(source) ((source)->id[0] != '\0') | |
408 | #define use_id(source) ((source)->id[0] != '\0' ? (source)->id : (source)->name) | |
409 | ||
410 | /* if target is TS6, use id if it has one, else name */ | |
411 | #define get_id(source, target) ((IsServer(target->from) && has_id(target->from)) ? \ | |
412 | use_id(source) : (source)->name) | |
413 | ||
414 | /* housekeeping flags */ | |
415 | ||
416 | #define FLAGS_PINGSENT 0x0001 /* Unreplied ping sent */ | |
417 | #define FLAGS_DEAD 0x0002 /* Local socket is dead--Exiting soon */ | |
418 | #define FLAGS_KILLED 0x0004 /* Prevents "QUIT" from being sent for this */ | |
419 | #define FLAGS_SENTUSER 0x0008 /* Client sent a USER command. */ | |
2d2c402d | 420 | #define FLAGS_CLICAP 0x0010 /* In CAP negotiation, wait for CAP END */ |
212380e3 | 421 | #define FLAGS_CLOSING 0x0020 /* set when closing to suppress errors */ |
2d2c402d | 422 | #define FLAGS_PING_COOKIE 0x0040 /* has sent ping cookie */ |
212380e3 | 423 | #define FLAGS_GOTID 0x0080 /* successful ident lookup achieved */ |
2d2c402d | 424 | #define FLAGS_FLOODDONE 0x0100 /* flood grace period over / reported */ |
212380e3 | 425 | #define FLAGS_NORMALEX 0x0400 /* Client exited normally */ |
426 | #define FLAGS_SENDQEX 0x0800 /* Sendq exceeded */ | |
427 | #define FLAGS_SERVLINK 0x10000 /* servlink has servlink process */ | |
428 | #define FLAGS_MARK 0x20000 /* marked client */ | |
429 | #define FLAGS_HIDDEN 0x40000 /* hidden server */ | |
430 | #define FLAGS_EOB 0x80000 /* EOB */ | |
431 | #define FLAGS_MYCONNECT 0x100000 /* MyConnect */ | |
432 | #define FLAGS_IOERROR 0x200000 /* IO error */ | |
433 | #define FLAGS_SERVICE 0x400000 /* network service */ | |
434 | #define FLAGS_TGCHANGE 0x800000 /* we're allowed to clear something */ | |
435 | #define FLAGS_DYNSPOOF 0x1000000 /* dynamic spoof, only opers see ip */ | |
54015b5f | 436 | #define FLAGS_EXUNKNOWN 0x2000000 /* too many unknowns exit.. */ |
212380e3 | 437 | |
438 | /* umodes, settable flags */ | |
439 | /* lots of this moved to snomask -- jilles */ | |
440 | #define UMODE_SERVNOTICE 0x0001 /* server notices */ | |
441 | #define UMODE_WALLOP 0x0100 /* send wallops to them */ | |
442 | #define UMODE_OPERWALL 0x0200 /* Operwalls */ | |
443 | #define UMODE_INVISIBLE 0x0400 /* makes user invisible */ | |
444 | #define UMODE_CALLERID 0x2000 /* block unless caller id's */ | |
445 | #define UMODE_LOCOPS 0x8000 /* show locops */ | |
446 | #define UMODE_SERVICE 0x40000 | |
447 | #define UMODE_DEAF 0x80000 | |
448 | #define UMODE_NOFORWARD 0x400000 /* don't forward */ | |
449 | #define UMODE_REGONLYMSG 0x800000 /* only allow logged in users to msg */ | |
450 | ||
451 | /* user information flags, only settable by remote mode or local oper */ | |
452 | #define UMODE_OPER 0x100000 /* Operator */ | |
453 | #define UMODE_ADMIN 0x200000 /* Admin on server */ | |
454 | ||
455 | #define UMODE_ALL UMODE_SERVNOTICE | |
456 | ||
457 | /* overflow flags */ | |
458 | /* EARLIER FLAGS ARE IN s_newconf.h */ | |
333d73ff JT |
459 | #define FLAGS2_EXEMPTRESV 0x00400000 |
460 | #define FLAGS2_EXEMPTGLINE 0x00800000 | |
461 | #define FLAGS2_EXEMPTKLINE 0x01000000 | |
462 | #define FLAGS2_EXEMPTFLOOD 0x02000000 | |
333d73ff | 463 | #define FLAGS2_IP_SPOOFING 0x10000000 |
212380e3 | 464 | #define FLAGS2_EXEMPTSPAMBOT 0x20000000 |
465 | #define FLAGS2_EXEMPTSHIDE 0x40000000 | |
466 | #define FLAGS2_EXEMPTJUPE 0x80000000 | |
467 | ||
cd7082fb VY |
468 | /* flags for local clients, this needs stuff moved from above to here at some point */\r |
469 | #define LFLAGS_SSL 0x00000001\r | |
470 | #define LFLAGS_FLUSH 0x00000002 | |
471 | ||
212380e3 | 472 | #define DEFAULT_OPER_UMODES (UMODE_SERVNOTICE | UMODE_OPERWALL | \ |
473 | UMODE_WALLOP | UMODE_LOCOPS) | |
474 | #define DEFAULT_OPER_SNOMASK SNO_GENERAL | |
475 | ||
212380e3 | 476 | #define CLICAP_MULTI_PREFIX 0x0001 |
477 | #define CLICAP_SASL 0x0002 | |
478 | ||
479 | /* | |
480 | * flags macros. | |
481 | */ | |
482 | #define IsPerson(x) (IsClient(x) && (x)->user != NULL) | |
212380e3 | 483 | #define HasServlink(x) ((x)->flags & FLAGS_SERVLINK) |
484 | #define SetServlink(x) ((x)->flags |= FLAGS_SERVLINK) | |
485 | #define MyConnect(x) ((x)->flags & FLAGS_MYCONNECT) | |
486 | #define SetMyConnect(x) ((x)->flags |= FLAGS_MYCONNECT) | |
487 | #define ClearMyConnect(x) ((x)->flags &= ~FLAGS_MYCONNECT) | |
488 | ||
489 | #define MyClient(x) (MyConnect(x) && IsClient(x)) | |
490 | #define SetMark(x) ((x)->flags |= FLAGS_MARK) | |
491 | #define ClearMark(x) ((x)->flags &= ~FLAGS_MARK) | |
492 | #define IsMarked(x) ((x)->flags & FLAGS_MARK) | |
493 | #define SetHidden(x) ((x)->flags |= FLAGS_HIDDEN) | |
494 | #define ClearHidden(x) ((x)->flags &= ~FLAGS_HIDDEN) | |
495 | #define IsHidden(x) ((x)->flags & FLAGS_HIDDEN) | |
496 | #define ClearEob(x) ((x)->flags &= ~FLAGS_EOB) | |
497 | #define SetEob(x) ((x)->flags |= FLAGS_EOB) | |
498 | #define HasSentEob(x) ((x)->flags & FLAGS_EOB) | |
499 | #define IsDead(x) ((x)->flags & FLAGS_DEAD) | |
500 | #define SetDead(x) ((x)->flags |= FLAGS_DEAD) | |
501 | #define IsClosing(x) ((x)->flags & FLAGS_CLOSING) | |
502 | #define SetClosing(x) ((x)->flags |= FLAGS_CLOSING) | |
503 | #define IsIOError(x) ((x)->flags & FLAGS_IOERROR) | |
504 | #define SetIOError(x) ((x)->flags |= FLAGS_IOERROR) | |
505 | #define IsAnyDead(x) (IsIOError(x) || IsDead(x) || IsClosing(x)) | |
506 | #define IsTGChange(x) ((x)->flags & FLAGS_TGCHANGE) | |
507 | #define SetTGChange(x) ((x)->flags |= FLAGS_TGCHANGE) | |
508 | #define ClearTGChange(x) ((x)->flags &= ~FLAGS_TGCHANGE) | |
509 | #define IsDynSpoof(x) ((x)->flags & FLAGS_DYNSPOOF) | |
510 | #define SetDynSpoof(x) ((x)->flags |= FLAGS_DYNSPOOF) | |
511 | #define ClearDynSpoof(x) ((x)->flags &= ~FLAGS_DYNSPOOF) | |
54015b5f | 512 | #define IsExUnknown(x) ((x)->flags & FLAGS_EXUNKNOWN) |
513 | #define SetExUnknown(x) ((x)->flags |= FLAGS_EXUNKNOWN) | |
cd7082fb VY |
514 | \r |
515 | /* local flags */\r | |
516 | \r | |
517 | #define IsSSL(x) ((x)->localClient->localflags & LFLAGS_SSL)\r | |
518 | #define SetSSL(x) ((x)->localClient->localflags |= LFLAGS_SSL)\r | |
519 | #define ClearSSL(x) ((x)->localClient->localflags &= ~LFLAGS_SSL)\r | |
520 | \r | |
521 | #define IsFlush(x) ((x)->localClient->localflags & LFLAGS_FLUSH)\r | |
522 | #define SetFlush(x) ((x)->localClient->localflags |= LFLAGS_FLUSH)\r | |
523 | #define ClearFlush(x) ((x)->localClient->localflags &= ~LFLAGS_FLUSH) | |
212380e3 | 524 | |
525 | /* oper flags */ | |
526 | #define MyOper(x) (MyConnect(x) && IsOper(x)) | |
527 | ||
528 | #define SetOper(x) {(x)->umodes |= UMODE_OPER; \ | |
529 | if (MyClient((x))) (x)->handler = OPER_HANDLER;} | |
530 | ||
531 | #define ClearOper(x) {(x)->umodes &= ~(UMODE_OPER|UMODE_ADMIN); \ | |
532 | if (MyClient((x)) && !IsOper((x)) && !IsServer((x))) \ | |
533 | (x)->handler = CLIENT_HANDLER; } | |
534 | ||
212380e3 | 535 | /* umode flags */ |
536 | #define IsInvisible(x) ((x)->umodes & UMODE_INVISIBLE) | |
537 | #define SetInvisible(x) ((x)->umodes |= UMODE_INVISIBLE) | |
538 | #define ClearInvisible(x) ((x)->umodes &= ~UMODE_INVISIBLE) | |
539 | #define SendWallops(x) ((x)->umodes & UMODE_WALLOP) | |
212380e3 | 540 | #define SendLocops(x) ((x)->umodes & UMODE_LOCOPS) |
541 | #define SendServNotice(x) ((x)->umodes & UMODE_SERVNOTICE) | |
542 | #define SendOperwall(x) ((x)->umodes & UMODE_OPERWALL) | |
212380e3 | 543 | #define IsSetCallerId(x) ((x)->umodes & UMODE_CALLERID) |
544 | #define IsService(x) ((x)->umodes & UMODE_SERVICE) | |
545 | #define IsDeaf(x) ((x)->umodes & UMODE_DEAF) | |
546 | #define IsNoForward(x) ((x)->umodes & UMODE_NOFORWARD) | |
547 | #define IsSetRegOnlyMsg(x) ((x)->umodes & UMODE_REGONLYMSG) | |
548 | ||
212380e3 | 549 | #define SetGotId(x) ((x)->flags |= FLAGS_GOTID) |
550 | #define IsGotId(x) (((x)->flags & FLAGS_GOTID) != 0) | |
551 | ||
552 | /* | |
553 | * flags2 macros. | |
554 | */ | |
555 | #define IsExemptKline(x) ((x)->flags2 & FLAGS2_EXEMPTKLINE) | |
556 | #define SetExemptKline(x) ((x)->flags2 |= FLAGS2_EXEMPTKLINE) | |
212380e3 | 557 | #define IsExemptGline(x) ((x)->flags2 & FLAGS2_EXEMPTGLINE) |
558 | #define SetExemptGline(x) ((x)->flags2 |= FLAGS2_EXEMPTGLINE) | |
559 | #define IsExemptFlood(x) ((x)->flags2 & FLAGS2_EXEMPTFLOOD) | |
560 | #define SetExemptFlood(x) ((x)->flags2 |= FLAGS2_EXEMPTFLOOD) | |
561 | #define IsExemptSpambot(x) ((x)->flags2 & FLAGS2_EXEMPTSPAMBOT) | |
562 | #define SetExemptSpambot(x) ((x)->flags2 |= FLAGS2_EXEMPTSPAMBOT) | |
563 | #define IsExemptShide(x) ((x)->flags2 & FLAGS2_EXEMPTSHIDE) | |
564 | #define SetExemptShide(x) ((x)->flags2 |= FLAGS2_EXEMPTSHIDE) | |
565 | #define IsExemptJupe(x) ((x)->flags2 & FLAGS2_EXEMPTJUPE) | |
566 | #define SetExemptJupe(x) ((x)->flags2 |= FLAGS2_EXEMPTJUPE) | |
567 | #define IsExemptResv(x) ((x)->flags2 & FLAGS2_EXEMPTRESV) | |
568 | #define SetExemptResv(x) ((x)->flags2 |= FLAGS2_EXEMPTRESV) | |
569 | #define IsIPSpoof(x) ((x)->flags2 & FLAGS2_IP_SPOOFING) | |
570 | #define SetIPSpoof(x) ((x)->flags2 |= FLAGS2_IP_SPOOFING) | |
571 | ||
212380e3 | 572 | /* for local users: flood grace period is over |
573 | * for servers: mentioned in networknotice.c notice | |
574 | */ | |
2d2c402d JT |
575 | #define IsFloodDone(x) ((x)->flags & FLAGS_FLOODDONE) |
576 | #define SetFloodDone(x) ((x)->flags |= FLAGS_FLOODDONE) | |
212380e3 | 577 | |
578 | /* | |
579 | * definitions for get_client_name | |
580 | */ | |
581 | #define HIDE_IP 0 | |
582 | #define SHOW_IP 1 | |
583 | #define MASK_IP 2 | |
584 | ||
585 | extern void check_banned_lines(void); | |
586 | extern void check_klines_event(void *unused); | |
587 | extern void check_klines(void); | |
588 | extern void check_glines(void); | |
589 | extern void check_dlines(void); | |
590 | extern void check_xlines(void); | |
591 | ||
592 | extern const char *get_client_name(struct Client *client, int show_ip); | |
593 | extern const char *get_server_name(struct Client *client, int show_ip); | |
594 | extern const char *log_client_name(struct Client *, int); | |
595 | extern int is_remote_connect(struct Client *); | |
596 | extern void init_client(void); | |
597 | extern client_t *make_client(struct Client *from); | |
598 | extern void free_pre_client(struct Client *client); | |
599 | extern void free_client(struct Client *client); | |
600 | ||
601 | extern int exit_client(struct Client *, struct Client *, struct Client *, const char *); | |
602 | ||
603 | extern void error_exit_client(struct Client *, int); | |
604 | ||
605 | ||
606 | ||
607 | extern void count_local_client_memory(size_t * count, size_t * memory); | |
608 | extern void count_remote_client_memory(size_t * count, size_t * memory); | |
609 | ||
610 | extern client_t *find_chasing(struct Client *, const char *, int *); | |
611 | extern client_t *find_person(const char *); | |
612 | extern client_t *find_named_person(const char *); | |
613 | extern client_t *next_client(struct Client *, const char *); | |
614 | ||
bfccb2c0 | 615 | #define accept_message(s, t) ((s) == (t) || (rb_dlinkFind((s), &((t)->localClient->allow_list)))) |
212380e3 | 616 | extern void del_all_accepts(struct Client *client_p); |
617 | ||
618 | extern void dead_link(struct Client *client_p); | |
619 | extern int show_ip(struct Client *source_p, struct Client *target_p); | |
620 | extern int show_ip_conf(struct ConfItem *aconf, struct Client *target_p); | |
621 | ||
622 | extern void initUser(void); | |
623 | extern void free_user(struct User *, struct Client *); | |
624 | extern user_t *make_user(struct Client *); | |
625 | extern server_t *make_server(struct Client *); | |
626 | extern void close_connection(struct Client *); | |
627 | extern void init_uid(void); | |
628 | extern char *generate_uid(void); | |
629 | ||
55eeaea1 | 630 | void allocate_away(struct Client *);\r |
ece36b7b VY |
631 | void free_away(struct Client *); |
632 | ||
212380e3 | 633 | #endif /* INCLUDED_client_h */ |