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 |
< |
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 |
18 |
> |
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 |
19 |
|
* USA |
20 |
|
*/ |
21 |
|
|
27 |
|
#include "stdinc.h" |
28 |
|
#include "list.h" |
29 |
|
#include "client.h" |
30 |
– |
#include "channel_mode.h" |
30 |
|
#include "event.h" |
32 |
– |
#include "fdlist.h" |
31 |
|
#include "hash.h" |
32 |
|
#include "irc_string.h" |
33 |
|
#include "ircd.h" |
36 |
– |
#include "s_gline.h" |
34 |
|
#include "numeric.h" |
35 |
< |
#include "packet.h" |
39 |
< |
#include "s_auth.h" |
35 |
> |
#include "auth.h" |
36 |
|
#include "s_bsd.h" |
37 |
|
#include "conf.h" |
38 |
|
#include "log.h" |
39 |
< |
#include "s_misc.h" |
40 |
< |
#include "s_serv.h" |
39 |
> |
#include "misc.h" |
40 |
> |
#include "server.h" |
41 |
|
#include "send.h" |
42 |
|
#include "whowas.h" |
43 |
< |
#include "s_user.h" |
48 |
< |
#include "dbuf.h" |
43 |
> |
#include "user.h" |
44 |
|
#include "memory.h" |
45 |
|
#include "mempool.h" |
46 |
|
#include "hostmask.h" |
47 |
|
#include "listener.h" |
53 |
– |
#include "irc_res.h" |
48 |
|
#include "userhost.h" |
49 |
|
#include "watch.h" |
50 |
|
#include "rng_mt.h" |
51 |
|
#include "parse.h" |
52 |
+ |
#include "ipcache.h" |
53 |
|
|
59 |
– |
dlink_list listing_client_list = { NULL, NULL, 0 }; |
60 |
– |
/* Pointer to beginning of Client list */ |
61 |
– |
dlink_list global_client_list = {NULL, NULL, 0}; |
62 |
– |
/* unknown/client pointer lists */ |
63 |
– |
dlink_list unknown_list = {NULL, NULL, 0}; |
64 |
– |
dlink_list local_client_list = {NULL, NULL, 0}; |
65 |
– |
dlink_list serv_list = {NULL, NULL, 0}; |
66 |
– |
dlink_list global_serv_list = {NULL, NULL, 0}; |
67 |
– |
dlink_list oper_list = {NULL, NULL, 0}; |
54 |
|
|
55 |
< |
static EVH check_pings; |
56 |
< |
|
57 |
< |
static mp_pool_t *client_pool = NULL; |
58 |
< |
static mp_pool_t *lclient_pool = NULL; |
59 |
< |
|
60 |
< |
static dlink_list dead_list = { NULL, NULL, 0}; |
61 |
< |
static dlink_list abort_list = { NULL, NULL, 0}; |
55 |
> |
dlink_list listing_client_list; |
56 |
> |
dlink_list unknown_list; |
57 |
> |
dlink_list local_client_list; |
58 |
> |
dlink_list local_server_list; |
59 |
> |
dlink_list global_client_list; |
60 |
> |
dlink_list global_server_list; |
61 |
> |
dlink_list oper_list; |
62 |
|
|
63 |
+ |
static mp_pool_t *client_pool, *connection_pool; |
64 |
+ |
static dlink_list dead_list, abort_list; |
65 |
|
static dlink_node *eac_next; /* next aborted client to exit */ |
66 |
|
|
79 |
– |
static void check_pings_list(dlink_list *); |
80 |
– |
static void check_unknowns_list(void); |
81 |
– |
|
82 |
– |
|
83 |
– |
/* client_init() |
84 |
– |
* |
85 |
– |
* inputs - NONE |
86 |
– |
* output - NONE |
87 |
– |
* side effects - initialize client free memory |
88 |
– |
*/ |
89 |
– |
void |
90 |
– |
client_init(void) |
91 |
– |
{ |
92 |
– |
/* start off the check ping event .. -- adrian |
93 |
– |
* Every 30 seconds is plenty -- db |
94 |
– |
*/ |
95 |
– |
client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT); |
96 |
– |
lclient_pool = mp_pool_new(sizeof(struct LocalUser), MP_CHUNK_SIZE_LCLIENT); |
97 |
– |
eventAdd("check_pings", check_pings, NULL, 5); |
98 |
– |
} |
67 |
|
|
68 |
|
/* |
69 |
|
* make_client - create a new Client struct and set it to initial state. |
85 |
|
{ |
86 |
|
struct Client *client_p = mp_pool_get(client_pool); |
87 |
|
|
120 |
– |
memset(client_p, 0, sizeof(*client_p)); |
121 |
– |
|
88 |
|
if (!from) |
89 |
|
{ |
90 |
|
client_p->from = client_p; /* 'from' of local client is self! */ |
91 |
< |
client_p->localClient = mp_pool_get(lclient_pool); |
92 |
< |
|
93 |
< |
memset(client_p->localClient, 0, sizeof(*client_p->localClient)); |
94 |
< |
|
95 |
< |
client_p->localClient->since = CurrentTime; |
130 |
< |
client_p->localClient->lasttime = CurrentTime; |
131 |
< |
client_p->localClient->firsttime = CurrentTime; |
132 |
< |
client_p->localClient->registration = REG_INIT; |
91 |
> |
client_p->connection = mp_pool_get(connection_pool); |
92 |
> |
client_p->connection->since = CurrentTime; |
93 |
> |
client_p->connection->lasttime = CurrentTime; |
94 |
> |
client_p->connection->firsttime = CurrentTime; |
95 |
> |
client_p->connection->registration = REG_INIT; |
96 |
|
|
97 |
|
/* as good a place as any... */ |
98 |
< |
dlinkAdd(client_p, &client_p->localClient->lclient_node, &unknown_list); |
98 |
> |
dlinkAdd(client_p, &client_p->connection->lclient_node, &unknown_list); |
99 |
|
} |
100 |
|
else |
101 |
|
client_p->from = from; /* 'from' of local client is self! */ |
104 |
|
client_p->hnext = client_p; |
105 |
|
SetUnknown(client_p); |
106 |
|
strcpy(client_p->username, "unknown"); |
107 |
< |
strcpy(client_p->svid, "0"); |
107 |
> |
strcpy(client_p->account, "0"); |
108 |
|
|
109 |
|
return client_p; |
110 |
|
} |
126 |
|
assert(client_p->channel.head == NULL); |
127 |
|
assert(dlink_list_length(&client_p->channel) == 0); |
128 |
|
assert(dlink_list_length(&client_p->whowas) == 0); |
129 |
< |
assert(!IsServer(client_p) || (IsServer(client_p) && client_p->serv)); |
129 |
> |
assert(!IsServer(client_p) || client_p->serv); |
130 |
|
|
131 |
|
MyFree(client_p->serv); |
132 |
|
MyFree(client_p->certfp); |
133 |
|
|
134 |
|
if (MyConnect(client_p)) |
135 |
|
{ |
136 |
< |
assert(client_p->localClient->invited.head == NULL); |
137 |
< |
assert(dlink_list_length(&client_p->localClient->invited) == 0); |
138 |
< |
assert(dlink_list_length(&client_p->localClient->watches) == 0); |
136 |
> |
assert(client_p->connection->invited.head == NULL); |
137 |
> |
assert(dlink_list_length(&client_p->connection->invited) == 0); |
138 |
> |
assert(dlink_list_length(&client_p->connection->watches) == 0); |
139 |
|
assert(IsClosing(client_p) && IsDead(client_p)); |
140 |
|
|
141 |
< |
MyFree(client_p->localClient->response); |
142 |
< |
MyFree(client_p->localClient->auth_oper); |
141 |
> |
MyFree(client_p->connection->challenge_response); |
142 |
> |
MyFree(client_p->connection->challenge_operator); |
143 |
> |
client_p->connection->challenge_response = NULL; |
144 |
> |
client_p->connection->challenge_operator = NULL; |
145 |
|
|
146 |
|
/* |
147 |
|
* clean up extra sockets from P-lines which have been discarded. |
148 |
|
*/ |
149 |
< |
if (client_p->localClient->listener) |
149 |
> |
if (client_p->connection->listener) |
150 |
|
{ |
151 |
< |
assert(0 < client_p->localClient->listener->ref_count); |
152 |
< |
if (0 == --client_p->localClient->listener->ref_count && |
188 |
< |
!client_p->localClient->listener->active) |
189 |
< |
free_listener(client_p->localClient->listener); |
151 |
> |
listener_release(client_p->connection->listener); |
152 |
> |
client_p->connection->listener = NULL; |
153 |
|
} |
154 |
|
|
155 |
< |
dbuf_clear(&client_p->localClient->buf_recvq); |
156 |
< |
dbuf_clear(&client_p->localClient->buf_sendq); |
155 |
> |
dbuf_clear(&client_p->connection->buf_recvq); |
156 |
> |
dbuf_clear(&client_p->connection->buf_sendq); |
157 |
|
|
158 |
< |
mp_pool_release(client_p->localClient); |
158 |
> |
mp_pool_release(client_p->connection); |
159 |
|
} |
160 |
|
|
161 |
|
mp_pool_release(client_p); |
162 |
|
} |
163 |
|
|
201 |
– |
/* |
202 |
– |
* check_pings - go through the local client list and check activity |
203 |
– |
* kill off stuff that should die |
204 |
– |
* |
205 |
– |
* inputs - NOT USED (from event) |
206 |
– |
* output - next time_t when check_pings() should be called again |
207 |
– |
* side effects - |
208 |
– |
* |
209 |
– |
* |
210 |
– |
* A PING can be sent to clients as necessary. |
211 |
– |
* |
212 |
– |
* Client/Server ping outs are handled. |
213 |
– |
*/ |
214 |
– |
|
215 |
– |
/* |
216 |
– |
* Addon from adrian. We used to call this after nextping seconds, |
217 |
– |
* however I've changed it to run once a second. This is only for |
218 |
– |
* PING timeouts, not K/etc-line checks (thanks dianora!). Having it |
219 |
– |
* run once a second makes life a lot easier - when a new client connects |
220 |
– |
* and they need a ping in 4 seconds, if nextping was set to 20 seconds |
221 |
– |
* we end up waiting 20 seconds. This is stupid. :-) |
222 |
– |
* I will optimise (hah!) check_pings() once I've finished working on |
223 |
– |
* tidying up other network IO evilnesses. |
224 |
– |
* -- adrian |
225 |
– |
*/ |
226 |
– |
|
227 |
– |
static void |
228 |
– |
check_pings(void *notused) |
229 |
– |
{ |
230 |
– |
check_pings_list(&local_client_list); |
231 |
– |
check_pings_list(&serv_list); |
232 |
– |
check_unknowns_list(); |
233 |
– |
} |
234 |
– |
|
164 |
|
/* check_pings_list() |
165 |
|
* |
166 |
|
* inputs - pointer to list to check |
170 |
|
static void |
171 |
|
check_pings_list(dlink_list *list) |
172 |
|
{ |
173 |
< |
char scratch[IRCD_BUFSIZE]; |
173 |
> |
char buf[IRCD_BUFSIZE] = ""; |
174 |
|
int ping = 0; /* ping time value from client */ |
175 |
< |
dlink_node *ptr = NULL, *next_ptr = NULL; |
175 |
> |
dlink_node *node = NULL, *node_next = NULL; |
176 |
|
|
177 |
< |
DLINK_FOREACH_SAFE(ptr, next_ptr, list->head) |
177 |
> |
DLINK_FOREACH_SAFE(node, node_next, list->head) |
178 |
|
{ |
179 |
< |
struct Client *client_p = ptr->data; |
179 |
> |
struct Client *client_p = node->data; |
180 |
|
|
252 |
– |
/* |
253 |
– |
** Note: No need to notify opers here. It's |
254 |
– |
** already done when "FLAGS_DEADSOCKET" is set. |
255 |
– |
*/ |
181 |
|
if (IsDead(client_p)) |
182 |
< |
{ |
258 |
< |
/* Ignore it, its been exited already */ |
259 |
< |
continue; |
260 |
< |
} |
182 |
> |
continue; /* Ignore it, its been exited already */ |
183 |
|
|
184 |
|
if (!IsRegistered(client_p)) |
185 |
|
ping = CONNECTTIMEOUT; |
186 |
|
else |
187 |
< |
ping = get_client_ping(&client_p->localClient->confs); |
187 |
> |
ping = get_client_ping(&client_p->connection->confs); |
188 |
|
|
189 |
< |
if (ping < CurrentTime - client_p->localClient->lasttime) |
189 |
> |
if (ping < CurrentTime - client_p->connection->lasttime) |
190 |
|
{ |
191 |
|
if (!IsPingSent(client_p)) |
192 |
|
{ |
193 |
|
/* |
194 |
< |
* if we havent PINGed the connection and we havent |
194 |
> |
* If we haven't PINGed the connection and we haven't |
195 |
|
* heard from it in a while, PING it to make sure |
196 |
|
* it is still alive. |
197 |
|
*/ |
198 |
|
SetPingSent(client_p); |
199 |
< |
client_p->localClient->lasttime = CurrentTime - ping; |
199 |
> |
client_p->connection->lasttime = CurrentTime - ping; |
200 |
|
sendto_one(client_p, "PING :%s", ID_or_name(&me, client_p)); |
201 |
|
} |
202 |
|
else |
203 |
|
{ |
204 |
< |
if (CurrentTime - client_p->localClient->lasttime >= 2 * ping) |
204 |
> |
if (CurrentTime - client_p->connection->lasttime >= 2 * ping) |
205 |
|
{ |
206 |
|
/* |
207 |
|
* If the client/server hasn't talked to us in 2*ping seconds |
219 |
|
get_client_name(client_p, HIDE_IP)); |
220 |
|
} |
221 |
|
|
222 |
< |
snprintf(scratch, sizeof(scratch), "Ping timeout: %d seconds", |
223 |
< |
(int)(CurrentTime - client_p->localClient->lasttime)); |
224 |
< |
exit_client(client_p, scratch); |
222 |
> |
snprintf(buf, sizeof(buf), "Ping timeout: %d seconds", |
223 |
> |
(int)(CurrentTime - client_p->connection->lasttime)); |
224 |
> |
exit_client(client_p, buf); |
225 |
|
} |
226 |
|
} |
227 |
|
} |
237 |
|
static void |
238 |
|
check_unknowns_list(void) |
239 |
|
{ |
240 |
< |
dlink_node *ptr = NULL, *ptr_next = NULL; |
240 |
> |
dlink_node *node = NULL, *node_next = NULL; |
241 |
|
|
242 |
< |
DLINK_FOREACH_SAFE(ptr, ptr_next, unknown_list.head) |
242 |
> |
DLINK_FOREACH_SAFE(node, node_next, unknown_list.head) |
243 |
|
{ |
244 |
< |
struct Client *client_p = ptr->data; |
244 |
> |
struct Client *client_p = node->data; |
245 |
|
|
246 |
|
/* |
247 |
|
* Check UNKNOWN connections - if they have been in this state |
248 |
|
* for > 30s, close them. |
249 |
|
*/ |
250 |
< |
if (IsAuthFinished(client_p) && (CurrentTime - client_p->localClient->firsttime) > 30) |
250 |
> |
if (IsAuthFinished(client_p) && (CurrentTime - client_p->connection->firsttime) > 30) |
251 |
|
exit_client(client_p, "Registration timed out"); |
252 |
|
} |
253 |
|
} |
254 |
|
|
255 |
+ |
/* |
256 |
+ |
* check_pings - go through the local client list and check activity |
257 |
+ |
* kill off stuff that should die |
258 |
+ |
* |
259 |
+ |
* inputs - NOT USED (from event) |
260 |
+ |
* output - next time_t when check_pings() should be called again |
261 |
+ |
* side effects - |
262 |
+ |
* |
263 |
+ |
* |
264 |
+ |
* A PING can be sent to clients as necessary. |
265 |
+ |
* |
266 |
+ |
* Client/Server ping outs are handled. |
267 |
+ |
*/ |
268 |
+ |
|
269 |
+ |
/* |
270 |
+ |
* Addon from adrian. We used to call this after nextping seconds, |
271 |
+ |
* however I've changed it to run once a second. This is only for |
272 |
+ |
* PING timeouts, not K/etc-line checks (thanks dianora!). Having it |
273 |
+ |
* run once a second makes life a lot easier - when a new client connects |
274 |
+ |
* and they need a ping in 4 seconds, if nextping was set to 20 seconds |
275 |
+ |
* we end up waiting 20 seconds. This is stupid. :-) |
276 |
+ |
* I will optimise (hah!) check_pings() once I've finished working on |
277 |
+ |
* tidying up other network IO evilnesses. |
278 |
+ |
* -- adrian |
279 |
+ |
*/ |
280 |
+ |
|
281 |
+ |
static void |
282 |
+ |
check_pings(void *unused) |
283 |
+ |
{ |
284 |
+ |
check_pings_list(&local_client_list); |
285 |
+ |
check_pings_list(&local_server_list); |
286 |
+ |
check_unknowns_list(); |
287 |
+ |
} |
288 |
+ |
|
289 |
|
/* check_conf_klines() |
290 |
|
* |
291 |
|
* inputs - NONE |
296 |
|
void |
297 |
|
check_conf_klines(void) |
298 |
|
{ |
343 |
– |
struct Client *client_p = NULL; /* current local client_p being examined */ |
299 |
|
struct MaskItem *conf = NULL; |
300 |
< |
dlink_node *ptr, *next_ptr; |
300 |
> |
dlink_node *node = NULL, *node_next = NULL; |
301 |
|
|
302 |
< |
DLINK_FOREACH_SAFE(ptr, next_ptr, local_client_list.head) |
302 |
> |
DLINK_FOREACH_SAFE(node, node_next, local_client_list.head) |
303 |
|
{ |
304 |
< |
client_p = ptr->data; |
304 |
> |
struct Client *client_p = node->data; |
305 |
|
|
306 |
|
/* If a client is already being exited |
307 |
|
*/ |
308 |
< |
if (IsDead(client_p) || !IsClient(client_p)) |
308 |
> |
if (IsDead(client_p)) |
309 |
|
continue; |
310 |
|
|
311 |
< |
if ((conf = find_dline_conf(&client_p->localClient->ip, |
312 |
< |
client_p->localClient->aftype))) |
311 |
> |
if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE, |
312 |
> |
client_p->connection->aftype, NULL, NULL, 1))) |
313 |
|
{ |
359 |
– |
if (conf->type == CONF_EXEMPT) |
360 |
– |
continue; |
361 |
– |
|
314 |
|
conf_try_ban(client_p, conf); |
315 |
|
continue; /* and go examine next fd/client_p */ |
316 |
|
} |
317 |
|
|
318 |
< |
if (ConfigFileEntry.glines) |
318 |
> |
if (ConfigGeneral.glines) |
319 |
|
{ |
320 |
< |
if ((conf = find_conf_by_address(client_p->host, &client_p->localClient->ip, |
321 |
< |
CONF_GLINE, client_p->localClient->aftype, |
320 |
> |
if ((conf = find_conf_by_address(client_p->host, &client_p->connection->ip, |
321 |
> |
CONF_GLINE, client_p->connection->aftype, |
322 |
|
client_p->username, NULL, 1))) |
323 |
|
{ |
324 |
|
conf_try_ban(client_p, conf); |
327 |
|
} |
328 |
|
} |
329 |
|
|
330 |
< |
if ((conf = find_conf_by_address(client_p->host, &client_p->localClient->ip, |
331 |
< |
CONF_KLINE, client_p->localClient->aftype, |
330 |
> |
if ((conf = find_conf_by_address(client_p->host, &client_p->connection->ip, |
331 |
> |
CONF_KLINE, client_p->connection->aftype, |
332 |
|
client_p->username, NULL, 1))) |
333 |
|
{ |
334 |
|
conf_try_ban(client_p, conf); |
344 |
|
} |
345 |
|
|
346 |
|
/* also check the unknowns list for new dlines */ |
347 |
< |
DLINK_FOREACH_SAFE(ptr, next_ptr, unknown_list.head) |
347 |
> |
DLINK_FOREACH_SAFE(node, node_next, unknown_list.head) |
348 |
|
{ |
349 |
< |
client_p = ptr->data; |
349 |
> |
struct Client *client_p = node->data; |
350 |
|
|
351 |
< |
if ((conf = find_dline_conf(&client_p->localClient->ip, |
352 |
< |
client_p->localClient->aftype))) |
351 |
> |
if ((conf = find_conf_by_address(NULL, &client_p->connection->ip, CONF_DLINE, |
352 |
> |
client_p->connection->aftype, NULL, NULL, 1))) |
353 |
|
{ |
354 |
< |
if (conf->type == CONF_EXEMPT) |
355 |
< |
continue; |
404 |
< |
|
405 |
< |
exit_client(client_p, "D-lined"); |
354 |
> |
conf_try_ban(client_p, conf); |
355 |
> |
continue; /* and go examine next fd/client_p */ |
356 |
|
} |
357 |
|
} |
358 |
|
} |
389 |
|
type_string = kline_string; |
390 |
|
break; |
391 |
|
case CONF_DLINE: |
392 |
+ |
if (find_conf_by_address(NULL, &client_p->connection->ip, CONF_EXEMPT, |
393 |
+ |
client_p->connection->aftype, NULL, NULL, 1)) |
394 |
+ |
return; |
395 |
|
type_string = dline_string; |
396 |
|
break; |
397 |
|
case CONF_GLINE: |
492 |
|
return NULL; |
493 |
|
|
494 |
|
if ((who = whowas_get_history(name, |
495 |
< |
(time_t)ConfigFileEntry.kill_chase_time_limit)) |
495 |
> |
(time_t)ConfigGeneral.kill_chase_time_limit)) |
496 |
|
== NULL) |
497 |
|
{ |
498 |
|
sendto_one_numeric(source_p, &me, ERR_NOSUCHNICK, name); |
511 |
|
* But, this can be used to any client structure. |
512 |
|
* |
513 |
|
* NOTE 1: |
514 |
< |
* Watch out the allocation of "nbuf", if either source_p->name |
514 |
> |
* Watch out the allocation of "buf", if either source_p->name |
515 |
|
* or source_p->sockhost gets changed into pointers instead of |
516 |
|
* directly allocated within the structure... |
517 |
|
* |
518 |
|
* NOTE 2: |
519 |
|
* Function return either a pointer to the structure (source_p) or |
520 |
< |
* to internal buffer (nbuf). *NEVER* use the returned pointer |
520 |
> |
* to internal buffer (buf). *NEVER* use the returned pointer |
521 |
|
* to modify what it points!!! |
522 |
|
*/ |
523 |
|
const char * |
524 |
|
get_client_name(const struct Client *client_p, enum addr_mask_type type) |
525 |
|
{ |
526 |
< |
static char nbuf[HOSTLEN * 2 + USERLEN + 5]; |
526 |
> |
static char buf[HOSTLEN * 2 + USERLEN + 5]; |
527 |
|
|
528 |
|
assert(client_p); |
529 |
|
|
538 |
|
type = MASK_IP; |
539 |
|
} |
540 |
|
|
541 |
< |
if (ConfigFileEntry.hide_spoof_ips) |
542 |
< |
if (type == SHOW_IP && IsIPSpoof(client_p)) |
541 |
> |
if (ConfigGeneral.hide_spoof_ips) |
542 |
> |
if (IsIPSpoof(client_p) && type == SHOW_IP) |
543 |
|
type = MASK_IP; |
544 |
|
|
545 |
|
/* And finally, let's get the host information, ip or name */ |
546 |
|
switch (type) |
547 |
|
{ |
548 |
|
case SHOW_IP: |
549 |
< |
snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]", |
549 |
> |
snprintf(buf, sizeof(buf), "%s[%s@%s]", |
550 |
|
client_p->name, |
551 |
|
client_p->username, client_p->sockhost); |
552 |
|
break; |
553 |
|
case MASK_IP: |
554 |
< |
if (client_p->localClient->aftype == AF_INET) |
555 |
< |
snprintf(nbuf, sizeof(nbuf), "%s[%s@255.255.255.255]", |
554 |
> |
if (client_p->connection->aftype == AF_INET) |
555 |
> |
snprintf(buf, sizeof(buf), "%s[%s@255.255.255.255]", |
556 |
|
client_p->name, client_p->username); |
557 |
|
else |
558 |
< |
snprintf(nbuf, sizeof(nbuf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]", |
558 |
> |
snprintf(buf, sizeof(buf), "%s[%s@ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff]", |
559 |
|
client_p->name, client_p->username); |
560 |
|
break; |
561 |
|
default: |
562 |
< |
snprintf(nbuf, sizeof(nbuf), "%s[%s@%s]", |
562 |
> |
snprintf(buf, sizeof(buf), "%s[%s@%s]", |
563 |
|
client_p->name, |
564 |
|
client_p->username, client_p->host); |
565 |
|
} |
566 |
|
|
567 |
< |
return nbuf; |
567 |
> |
return buf; |
568 |
|
} |
569 |
|
|
570 |
|
void |
571 |
|
free_exited_clients(void) |
572 |
|
{ |
573 |
< |
dlink_node *ptr = NULL, *next = NULL; |
573 |
> |
dlink_node *node = NULL, *node_next = NULL; |
574 |
|
|
575 |
< |
DLINK_FOREACH_SAFE(ptr, next, dead_list.head) |
575 |
> |
DLINK_FOREACH_SAFE(node, node_next, dead_list.head) |
576 |
|
{ |
577 |
< |
free_client(ptr->data); |
578 |
< |
dlinkDelete(ptr, &dead_list); |
579 |
< |
free_dlink_node(ptr); |
577 |
> |
free_client(node->data); |
578 |
> |
dlinkDelete(node, &dead_list); |
579 |
> |
free_dlink_node(node); |
580 |
|
} |
581 |
|
} |
582 |
|
|
587 |
|
* The only messages generated are QUITs on channels. |
588 |
|
*/ |
589 |
|
static void |
590 |
< |
exit_one_client(struct Client *source_p, const char *quitmsg) |
590 |
> |
exit_one_client(struct Client *source_p, const char *comment) |
591 |
|
{ |
592 |
< |
dlink_node *ptr = NULL, *ptr_next = NULL; |
592 |
> |
dlink_node *node = NULL, *node_next = NULL; |
593 |
|
|
594 |
|
assert(!IsMe(source_p)); |
595 |
+ |
assert(source_p != &me); |
596 |
|
|
597 |
|
if (IsClient(source_p)) |
598 |
|
{ |
599 |
|
dlinkDelete(&source_p->lnode, &source_p->servptr->serv->client_list); |
600 |
+ |
dlinkDelete(&source_p->node, &global_client_list); |
601 |
|
|
602 |
|
/* |
603 |
|
* If a person is on a channel, send a QUIT notice |
607 |
|
*/ |
608 |
|
sendto_common_channels_local(source_p, 0, 0, ":%s!%s@%s QUIT :%s", |
609 |
|
source_p->name, source_p->username, |
610 |
< |
source_p->host, quitmsg); |
611 |
< |
DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->channel.head) |
612 |
< |
remove_user_from_channel(ptr->data); |
610 |
> |
source_p->host, comment); |
611 |
> |
DLINK_FOREACH_SAFE(node, node_next, source_p->channel.head) |
612 |
> |
remove_user_from_channel(node->data); |
613 |
|
|
614 |
|
whowas_add_history(source_p, 0); |
615 |
|
whowas_off_history(source_p); |
619 |
|
if (MyConnect(source_p)) |
620 |
|
{ |
621 |
|
/* Clean up invitefield */ |
622 |
< |
DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->localClient->invited.head) |
623 |
< |
del_invite(ptr->data, source_p); |
622 |
> |
DLINK_FOREACH_SAFE(node, node_next, source_p->connection->invited.head) |
623 |
> |
del_invite(node->data, source_p); |
624 |
|
|
625 |
|
del_all_accepts(source_p); |
626 |
|
} |
628 |
|
else if (IsServer(source_p)) |
629 |
|
{ |
630 |
|
dlinkDelete(&source_p->lnode, &source_p->servptr->serv->server_list); |
631 |
+ |
dlinkDelete(&source_p->node, &global_client_list); |
632 |
|
|
633 |
< |
if ((ptr = dlinkFindDelete(&global_serv_list, source_p))) |
634 |
< |
free_dlink_node(ptr); |
633 |
> |
if ((node = dlinkFindDelete(&global_server_list, source_p))) |
634 |
> |
free_dlink_node(node); |
635 |
|
} |
636 |
|
|
637 |
|
/* Remove source_p from the client lists */ |
643 |
|
if (IsUserHostIp(source_p)) |
644 |
|
delete_user_host(source_p->username, source_p->host, !MyConnect(source_p)); |
645 |
|
|
690 |
– |
/* remove from global client list |
691 |
– |
* NOTE: source_p->node.next cannot be NULL if the client is added |
692 |
– |
* to global_client_list (there is always &me at its end) |
693 |
– |
*/ |
694 |
– |
if (source_p->node.next) /* XXX: not needed? */ |
695 |
– |
dlinkDelete(&source_p->node, &global_client_list); |
696 |
– |
|
646 |
|
update_client_exit_stats(source_p); |
647 |
|
|
648 |
|
/* Check to see if the client isn't already on the dead list */ |
660 |
|
* actually removing things off llists. tweaked from +CSr31 -orabidoo |
661 |
|
*/ |
662 |
|
static void |
663 |
< |
recurse_remove_clients(struct Client *source_p, const char *quitmsg) |
663 |
> |
recurse_remove_clients(struct Client *source_p, const char *comment) |
664 |
|
{ |
665 |
< |
dlink_node *ptr = NULL, *ptr_next = NULL; |
665 |
> |
dlink_node *node = NULL, *node_next = NULL; |
666 |
|
|
667 |
< |
DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->client_list.head) |
668 |
< |
exit_one_client(ptr->data, quitmsg); |
667 |
> |
DLINK_FOREACH_SAFE(node, node_next, source_p->serv->client_list.head) |
668 |
> |
exit_one_client(node->data, comment); |
669 |
|
|
670 |
< |
DLINK_FOREACH_SAFE(ptr, ptr_next, source_p->serv->server_list.head) |
670 |
> |
DLINK_FOREACH_SAFE(node, node_next, source_p->serv->server_list.head) |
671 |
|
{ |
672 |
< |
recurse_remove_clients(ptr->data, quitmsg); |
673 |
< |
exit_one_client(ptr->data, quitmsg); |
672 |
> |
recurse_remove_clients(node->data, comment); |
673 |
> |
exit_one_client(node->data, comment); |
674 |
|
} |
675 |
|
} |
676 |
|
|
694 |
|
void |
695 |
|
exit_client(struct Client *source_p, const char *comment) |
696 |
|
{ |
697 |
< |
dlink_node *m = NULL; |
697 |
> |
dlink_node *node = NULL; |
698 |
> |
|
699 |
> |
assert(!IsMe(source_p)); |
700 |
> |
assert(source_p != &me); |
701 |
|
|
702 |
|
if (MyConnect(source_p)) |
703 |
|
{ |
709 |
|
|
710 |
|
SetClosing(source_p); |
711 |
|
|
712 |
< |
if (IsIpHash(source_p)) |
713 |
< |
remove_one_ip(&source_p->localClient->ip); |
712 |
> |
if (HasFlag(source_p, FLAGS_IPHASH)) |
713 |
> |
{ |
714 |
> |
DelFlag(source_p, FLAGS_IPHASH); |
715 |
> |
ipcache_remove_address(&source_p->connection->ip); |
716 |
> |
} |
717 |
|
|
718 |
< |
delete_auth(&source_p->localClient->auth); |
718 |
> |
delete_auth(&source_p->connection->auth); |
719 |
|
|
720 |
|
/* |
721 |
|
* This source_p could have status of one of STAT_UNKNOWN, STAT_CONNECTING |
728 |
|
{ |
729 |
|
assert(dlinkFind(&unknown_list, source_p)); |
730 |
|
|
731 |
< |
dlinkDelete(&source_p->localClient->lclient_node, &unknown_list); |
731 |
> |
dlinkDelete(&source_p->connection->lclient_node, &unknown_list); |
732 |
|
} |
733 |
|
else if (IsClient(source_p)) |
734 |
|
{ |
735 |
< |
time_t on_for = CurrentTime - source_p->localClient->firsttime; |
735 |
> |
time_t on_for = CurrentTime - source_p->connection->firsttime; |
736 |
|
assert(Count.local > 0); |
737 |
|
Count.local--; |
738 |
|
|
739 |
|
if (HasUMode(source_p, UMODE_OPER)) |
740 |
< |
if ((m = dlinkFindDelete(&oper_list, source_p))) |
741 |
< |
free_dlink_node(m); |
740 |
> |
if ((node = dlinkFindDelete(&oper_list, source_p))) |
741 |
> |
free_dlink_node(node); |
742 |
|
|
743 |
|
assert(dlinkFind(&local_client_list, source_p)); |
744 |
< |
dlinkDelete(&source_p->localClient->lclient_node, &local_client_list); |
744 |
> |
dlinkDelete(&source_p->connection->lclient_node, &local_client_list); |
745 |
|
|
746 |
< |
if (source_p->localClient->list_task) |
747 |
< |
free_list_task(source_p->localClient->list_task, source_p); |
746 |
> |
if (source_p->connection->list_task) |
747 |
> |
free_list_task(source_p); |
748 |
|
|
749 |
|
watch_del_watch_list(source_p); |
750 |
|
sendto_realops_flags(UMODE_CCONN, L_ALL, SEND_NOTICE, |
751 |
|
"Client exiting: %s (%s@%s) [%s] [%s]", |
752 |
|
source_p->name, source_p->username, source_p->host, comment, |
753 |
< |
ConfigFileEntry.hide_spoof_ips && IsIPSpoof(source_p) ? |
753 |
> |
ConfigGeneral.hide_spoof_ips && IsIPSpoof(source_p) ? |
754 |
|
"255.255.255.255" : source_p->sockhost); |
755 |
|
ilog(LOG_TYPE_USER, "%s (%3u:%02u:%02u): %s!%s@%s %llu/%llu", |
756 |
< |
myctime(source_p->localClient->firsttime), (unsigned int)(on_for / 3600), |
756 |
> |
myctime(source_p->connection->firsttime), (unsigned int)(on_for / 3600), |
757 |
|
(unsigned int)((on_for % 3600)/60), (unsigned int)(on_for % 60), |
758 |
|
source_p->name, source_p->username, source_p->host, |
759 |
< |
source_p->localClient->send.bytes>>10, |
760 |
< |
source_p->localClient->recv.bytes>>10); |
759 |
> |
source_p->connection->send.bytes>>10, |
760 |
> |
source_p->connection->recv.bytes>>10); |
761 |
|
} |
762 |
|
else if (IsServer(source_p)) |
763 |
|
{ |
764 |
|
assert(Count.myserver > 0); |
765 |
|
--Count.myserver; |
766 |
|
|
767 |
< |
assert(dlinkFind(&serv_list, source_p)); |
768 |
< |
dlinkDelete(&source_p->localClient->lclient_node, &serv_list); |
767 |
> |
assert(dlinkFind(&local_server_list, source_p)); |
768 |
> |
dlinkDelete(&source_p->connection->lclient_node, &local_server_list); |
769 |
|
} |
770 |
|
|
771 |
|
if (!IsDead(source_p)) |
784 |
|
source_p->host, comment); |
785 |
|
} |
786 |
|
|
832 |
– |
/* |
833 |
– |
** Currently only server connections can have |
834 |
– |
** depending remote clients here, but it does no |
835 |
– |
** harm to check for all local clients. In |
836 |
– |
** future some other clients than servers might |
837 |
– |
** have remotes too... |
838 |
– |
** |
839 |
– |
** Close the Client connection first and mark it |
840 |
– |
** so that no messages are attempted to send to it. |
841 |
– |
** Remember it makes source_p->from == NULL. |
842 |
– |
*/ |
787 |
|
close_connection(source_p); |
788 |
|
} |
789 |
|
else if (IsClient(source_p) && HasFlag(source_p->servptr, FLAGS_EOB)) |
809 |
|
snprintf(splitstr, sizeof(splitstr), "%s %s", |
810 |
|
source_p->servptr->name, source_p->name); |
811 |
|
|
812 |
< |
/* Send SQUIT for source_p in every direction. source_p is already off of serv_list here */ |
812 |
> |
/* Send SQUIT for source_p in every direction. source_p is already off of local_server_list here */ |
813 |
|
if (!HasFlag(source_p, FLAGS_SQUIT)) |
814 |
|
sendto_server(NULL, NOCAPS, NOCAPS, "SQUIT %s :%s", source_p->id, comment); |
815 |
|
|
818 |
|
|
819 |
|
if (MyConnect(source_p)) |
820 |
|
{ |
821 |
+ |
int connected = CurrentTime - source_p->connection->firsttime; |
822 |
|
sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, |
823 |
< |
"%s was connected for %d seconds. %llu/%llu sendK/recvK.", |
824 |
< |
source_p->name, (int)(CurrentTime - source_p->localClient->firsttime), |
825 |
< |
source_p->localClient->send.bytes >> 10, |
826 |
< |
source_p->localClient->recv.bytes >> 10); |
827 |
< |
ilog(LOG_TYPE_IRCD, "%s was connected for %d seconds. %llu/%llu sendK/recvK.", |
828 |
< |
source_p->name, (int)(CurrentTime - source_p->localClient->firsttime), |
829 |
< |
source_p->localClient->send.bytes >> 10, |
830 |
< |
source_p->localClient->recv.bytes >> 10); |
823 |
> |
"%s was connected for %d day%s, %2d:%02d:%02d. %llu/%llu sendK/recvK.", |
824 |
> |
source_p->name, connected/86400, (connected/86400 == 1) ? "" : "s", |
825 |
> |
(connected % 86400) / 3600, (connected % 3600) / 60, connected % 60, |
826 |
> |
source_p->connection->send.bytes >> 10, |
827 |
> |
source_p->connection->recv.bytes >> 10); |
828 |
> |
ilog(LOG_TYPE_IRCD, "%s was connected for %d day%s, %2d:%02d:%02d. %llu/%llu sendK/recvK.", |
829 |
> |
source_p->name, connected/86400, (connected/86400 == 1) ? "" : "s", |
830 |
> |
(connected % 86400) / 3600, (connected % 3600) / 60, connected % 60, |
831 |
> |
source_p->connection->send.bytes >> 10, |
832 |
> |
source_p->connection->recv.bytes >> 10); |
833 |
|
} |
834 |
|
} |
835 |
|
else if (IsClient(source_p) && !HasFlag(source_p, FLAGS_KILLED)) |
839 |
|
/* The client *better* be off all of the lists */ |
840 |
|
assert(dlinkFind(&unknown_list, source_p) == NULL); |
841 |
|
assert(dlinkFind(&local_client_list, source_p) == NULL); |
842 |
< |
assert(dlinkFind(&serv_list, source_p) == NULL); |
842 |
> |
assert(dlinkFind(&local_server_list, source_p) == NULL); |
843 |
|
assert(dlinkFind(&oper_list, source_p) == NULL); |
844 |
|
|
845 |
|
exit_one_client(source_p, comment); |
852 |
|
void |
853 |
|
dead_link_on_write(struct Client *client_p, int ierrno) |
854 |
|
{ |
855 |
< |
dlink_node *ptr; |
855 |
> |
dlink_node *node; |
856 |
|
|
857 |
|
if (IsDefunct(client_p)) |
858 |
|
return; |
859 |
|
|
860 |
< |
dbuf_clear(&client_p->localClient->buf_recvq); |
861 |
< |
dbuf_clear(&client_p->localClient->buf_sendq); |
860 |
> |
dbuf_clear(&client_p->connection->buf_recvq); |
861 |
> |
dbuf_clear(&client_p->connection->buf_sendq); |
862 |
|
|
863 |
|
assert(dlinkFind(&abort_list, client_p) == NULL); |
864 |
< |
ptr = make_dlink_node(); |
864 |
> |
node = make_dlink_node(); |
865 |
|
/* don't let exit_aborted_clients() finish yet */ |
866 |
< |
dlinkAddTail(client_p, ptr, &abort_list); |
866 |
> |
dlinkAddTail(client_p, node, &abort_list); |
867 |
|
|
868 |
|
if (eac_next == NULL) |
869 |
< |
eac_next = ptr; |
869 |
> |
eac_next = node; |
870 |
|
|
871 |
|
SetDead(client_p); /* You are dead my friend */ |
872 |
|
} |
884 |
|
if (IsDefunct(client_p)) |
885 |
|
return; |
886 |
|
|
887 |
< |
dbuf_clear(&client_p->localClient->buf_recvq); |
888 |
< |
dbuf_clear(&client_p->localClient->buf_sendq); |
887 |
> |
dbuf_clear(&client_p->connection->buf_recvq); |
888 |
> |
dbuf_clear(&client_p->connection->buf_sendq); |
889 |
|
|
890 |
< |
current_error = get_sockerr(client_p->localClient->fd.fd); |
890 |
> |
current_error = get_sockerr(client_p->connection->fd.fd); |
891 |
|
|
892 |
|
if (IsServer(client_p) || IsHandshake(client_p)) |
893 |
|
{ |
894 |
< |
int connected = CurrentTime - client_p->localClient->firsttime; |
894 |
> |
int connected = CurrentTime - client_p->connection->firsttime; |
895 |
|
|
896 |
|
if (error == 0) |
897 |
|
{ |
917 |
|
} |
918 |
|
|
919 |
|
sendto_realops_flags(UMODE_ALL, L_ALL, SEND_NOTICE, |
920 |
< |
"%s had been connected for %d day%s, %2d:%02d:%02d", |
920 |
> |
"%s was connected for %d day%s, %2d:%02d:%02d", |
921 |
|
client_p->name, connected/86400, |
922 |
|
(connected/86400 == 1) ? "" : "s", |
923 |
|
(connected % 86400) / 3600, (connected % 3600) / 60, |
980 |
|
void |
981 |
|
del_accept(struct split_nuh_item *accept_p, struct Client *client_p) |
982 |
|
{ |
983 |
< |
dlinkDelete(&accept_p->node, &client_p->localClient->acceptlist); |
983 |
> |
dlinkDelete(&accept_p->node, &client_p->connection->acceptlist); |
984 |
|
|
985 |
|
MyFree(accept_p->nickptr); |
986 |
|
MyFree(accept_p->userptr); |
993 |
|
const char *host, struct Client *client_p, |
994 |
|
int (*cmpfunc)(const char *, const char *)) |
995 |
|
{ |
996 |
< |
dlink_node *ptr = NULL; |
996 |
> |
dlink_node *node = NULL; |
997 |
|
|
998 |
< |
DLINK_FOREACH(ptr, client_p->localClient->acceptlist.head) |
998 |
> |
DLINK_FOREACH(node, client_p->connection->acceptlist.head) |
999 |
|
{ |
1000 |
< |
struct split_nuh_item *accept_p = ptr->data; |
1000 |
> |
struct split_nuh_item *accept_p = node->data; |
1001 |
|
|
1002 |
|
if (!cmpfunc(accept_p->nickptr, nick) && |
1003 |
|
!cmpfunc(accept_p->userptr, user) && |
1019 |
|
accept_message(struct Client *source, |
1020 |
|
struct Client *target) |
1021 |
|
{ |
1022 |
< |
dlink_node *ptr = NULL; |
1022 |
> |
dlink_node *node = NULL; |
1023 |
|
|
1024 |
|
if (source == target || find_accept(source->name, source->username, |
1025 |
|
source->host, target, match)) |
1026 |
|
return 1; |
1027 |
|
|
1028 |
< |
if (HasUMode(target, UMODE_SOFTCALLERID)) |
1029 |
< |
DLINK_FOREACH(ptr, target->channel.head) |
1030 |
< |
if (IsMember(source, ((struct Membership *)ptr->data)->chptr)) |
1028 |
> |
if (!HasUMode(target, UMODE_CALLERID) && HasUMode(target, UMODE_SOFTCALLERID)) |
1029 |
> |
DLINK_FOREACH(node, target->channel.head) |
1030 |
> |
if (IsMember(source, ((struct Membership *)node->data)->chptr)) |
1031 |
|
return 1; |
1032 |
|
|
1033 |
|
return 0; |
1042 |
|
void |
1043 |
|
del_all_accepts(struct Client *client_p) |
1044 |
|
{ |
1045 |
< |
dlink_node *ptr = NULL, *ptr_next = NULL; |
1045 |
> |
dlink_node *node = NULL, *node_next = NULL; |
1046 |
|
|
1047 |
< |
DLINK_FOREACH_SAFE(ptr, ptr_next, client_p->localClient->acceptlist.head) |
1048 |
< |
del_accept(ptr->data, client_p); |
1047 |
> |
DLINK_FOREACH_SAFE(node, node_next, client_p->connection->acceptlist.head) |
1048 |
> |
del_accept(node->data, client_p); |
1049 |
|
} |
1050 |
|
|
1051 |
|
unsigned int |
1054 |
|
unsigned int idle = 0; |
1055 |
|
unsigned int min_idle = 0; |
1056 |
|
unsigned int max_idle = 0; |
1057 |
< |
const struct ClassItem *class = get_class_ptr(&target_p->localClient->confs); |
1057 |
> |
const struct ClassItem *class = get_class_ptr(&target_p->connection->confs); |
1058 |
|
|
1059 |
|
if (!(class->flags & CLASS_FLAGS_FAKE_IDLE) || target_p == source_p) |
1060 |
< |
return CurrentTime - target_p->localClient->last_privmsg; |
1060 |
> |
return CurrentTime - target_p->connection->last_privmsg; |
1061 |
|
if (HasUMode(source_p, UMODE_OPER) && |
1062 |
|
!(class->flags & CLASS_FLAGS_HIDE_IDLE_FROM_OPERS)) |
1063 |
< |
return CurrentTime - target_p->localClient->last_privmsg; |
1063 |
> |
return CurrentTime - target_p->connection->last_privmsg; |
1064 |
|
|
1065 |
|
min_idle = class->min_idle; |
1066 |
|
max_idle = class->max_idle; |
1071 |
|
if (class->flags & CLASS_FLAGS_RANDOM_IDLE) |
1072 |
|
idle = genrand_int32(); |
1073 |
|
else |
1074 |
< |
idle = CurrentTime - target_p->localClient->last_privmsg; |
1074 |
> |
idle = CurrentTime - target_p->connection->last_privmsg; |
1075 |
|
|
1076 |
|
if (!max_idle) |
1077 |
|
idle = 0; |
1083 |
|
|
1084 |
|
return idle; |
1085 |
|
} |
1086 |
+ |
|
1087 |
+ |
/* client_init() |
1088 |
+ |
* |
1089 |
+ |
* inputs - NONE |
1090 |
+ |
* output - NONE |
1091 |
+ |
* side effects - initialize client free memory |
1092 |
+ |
*/ |
1093 |
+ |
void |
1094 |
+ |
client_init(void) |
1095 |
+ |
{ |
1096 |
+ |
static struct event event_ping = |
1097 |
+ |
{ |
1098 |
+ |
.name = "check_pings", |
1099 |
+ |
.handler = check_pings, |
1100 |
+ |
.when = 5 |
1101 |
+ |
}; |
1102 |
+ |
|
1103 |
+ |
client_pool = mp_pool_new(sizeof(struct Client), MP_CHUNK_SIZE_CLIENT); |
1104 |
+ |
connection_pool = mp_pool_new(sizeof(struct Connection), MP_CHUNK_SIZE_CONNECTION); |
1105 |
+ |
event_add(&event_ping, NULL); |
1106 |
+ |
} |