xref: /titanic_44/usr/src/cmd/sendmail/src/ratectrl.c (revision 990b4856d0eaada6f8140335733a1b1771ed2746)
1 /*
2  * Copyright (c) 2003 Sendmail, Inc. and its suppliers.
3  *	All rights reserved.
4  *
5  * By using this file, you agree to the terms and conditions set
6  * forth in the LICENSE file which can be found at the top level of
7  * the sendmail distribution.
8  *
9  * Contributed by Jose Marcio Martins da Cruz - Ecole des Mines de Paris
10  *   Jose-Marcio.Martins@ensmp.fr
11  */
12 
13 /* a part of this code is based on inetd.c for which this copyright applies: */
14 /*
15  * Copyright (c) 1983, 1991, 1993, 1994
16  *      The Regents of the University of California.  All rights reserved.
17  *
18  * Redistribution and use in source and binary forms, with or without
19  * modification, are permitted provided that the following conditions
20  * are met:
21  * 1. Redistributions of source code must retain the above copyright
22  *    notice, this list of conditions and the following disclaimer.
23  * 2. Redistributions in binary form must reproduce the above copyright
24  *    notice, this list of conditions and the following disclaimer in the
25  *    documentation and/or other materials provided with the distribution.
26  * 3. All advertising materials mentioning features or use of this software
27  *    must display the following acknowledgement:
28  *      This product includes software developed by the University of
29  *      California, Berkeley and its contributors.
30  * 4. Neither the name of the University nor the names of its contributors
31  *    may be used to endorse or promote products derived from this software
32  *    without specific prior written permission.
33  *
34  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
35  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
36  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
37  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
38  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
39  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
40  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
41  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
42  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
43  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
44  * SUCH DAMAGE.
45  */
46 
47 #pragma ident	"%Z%%M%	%I%	%E% SMI"
48 
49 #include <sendmail.h>
50 SM_RCSID("@(#)$Id: ratectrl.c,v 8.11 2006/08/15 23:24:57 ca Exp $")
51 
52 /*
53 **  stuff included - given some warnings (inet_ntoa)
54 **	- surely not everything is needed
55 */
56 
57 #if NETINET || NETINET6
58 # include <arpa/inet.h>
59 #endif	/* NETINET || NETINET6 */
60 
61 #include <sm/time.h>
62 
63 #ifndef HASH_ALG
64 # define HASH_ALG	2
65 #endif /* HASH_ALG */
66 
67 #ifndef RATECTL_DEBUG
68 # define RATECTL_DEBUG  0
69 #endif /* RATECTL_DEBUG */
70 
71 /* forward declarations */
72 static int client_rate __P((time_t, SOCKADDR *, bool));
73 static int total_rate __P((time_t, bool));
74 #if 0
75 static int sockaddrcmp __P((SOCKADDR *, SOCKADDR *));
76 #endif /* 0 */
77 
78 /*
79 **  CONNECTION_RATE_CHECK - updates connection history data
80 **      and computes connection rate for the given host
81 **
82 **    Parameters:
83 **      hostaddr -- ip address of smtp client
84 **      e -- envelope
85 **
86 **    Returns:
87 **      true (always)
88 **
89 **    Side Effects:
90 **      updates connection history
91 **
92 **    Warnings:
93 **      For each connection, this call shall be
94 **      done only once with the value true for the
95 **      update parameter.
96 **      Typically, this call is done with the value
97 **      true by the father, and once again with
98 **      the value false by the children.
99 **
100 */
101 
102 bool
103 connection_rate_check(hostaddr, e)
104 	SOCKADDR *hostaddr;
105 	ENVELOPE *e;
106 {
107 	time_t now;
108 	int totalrate, clientrate;
109 	static int clientconn = 0;
110 
111 	now = time(NULL);
112 #if RATECTL_DEBUG
113 	sm_syslog(LOG_INFO, NOQID, "connection_rate_check entering...");
114 #endif /* RATECTL_DEBUG */
115 
116 	/* update server connection rate */
117 	totalrate = total_rate(now, e == NULL);
118 #if RATECTL_DEBUG
119 	sm_syslog(LOG_INFO, NOQID, "global connection rate: %d", globalRate);
120 #endif /* RATECTL_DEBUG */
121 
122 	/* update client connection rate */
123 	clientrate = client_rate(now, hostaddr, e == NULL);
124 
125 	if (e == NULL)
126 		clientconn = count_open_connections(hostaddr);
127 
128 	if (e != NULL)
129 	{
130 		char s[16];
131 
132 		sm_snprintf(s, sizeof(s), "%d", clientrate);
133 		macdefine(&e->e_macro, A_TEMP, macid("{client_rate}"), s);
134 		sm_snprintf(s, sizeof(s), "%d", totalrate);
135 		macdefine(&e->e_macro, A_TEMP, macid("{total_rate}"), s);
136 		sm_snprintf(s, sizeof(s), "%d", clientconn);
137 		macdefine(&e->e_macro, A_TEMP, macid("{client_connections}"),
138 				s);
139 	}
140 	return true;
141 }
142 
143 /*
144 **  Data declarations needed to evaluate connection rate
145 */
146 
147 static int CollTime = 60;
148 
149 /* this should be a power of 2, otherwise CPMHMASK doesn't work well */
150 #ifndef CPMHSIZE
151 # define CPMHSIZE	1024
152 #endif /* CPMHSIZE */
153 
154 #define CPMHMASK	(CPMHSIZE-1)
155 
156 #ifndef MAX_CT_STEPS
157 # define MAX_CT_STEPS	10
158 #endif /* MAX_CT_STEPS */
159 
160 /*
161 **  time granularity: 10s (that's one "tick")
162 **  will be initialised to ConnectionRateWindowSize/CHTSIZE
163 **  before being used the first time
164 */
165 
166 static int ChtGran = -1;
167 
168 #define CHTSIZE		6
169 
170 /* Number of connections for a certain "tick" */
171 typedef struct CTime
172 {
173 	unsigned long	ct_Ticks;
174 	int		ct_Count;
175 }
176 CTime_T;
177 
178 typedef struct CHash
179 {
180 #if NETINET6 && NETINET
181 	union
182 	{
183 		struct in_addr	c4_Addr;
184 		struct in6_addr	c6_Addr;
185 	} cu_Addr;
186 # define ch_Addr4	cu_Addr.c4_Addr
187 # define ch_Addr6	cu_Addr.c6_Addr
188 #else /* NETINET6 && NETINET */
189 # if NETINET6
190 	struct in6_addr	ch_Addr;
191 #  define ch_Addr6	ch_Addr
192 # else /* NETINET6 */
193 	struct in_addr ch_Addr;
194 #  define ch_Addr4	ch_Addr
195 # endif /* NETINET6 */
196 #endif /* NETINET6 && NETINET */
197 
198 	int		ch_Family;
199 	time_t		ch_LTime;
200 	unsigned long	ch_colls;
201 
202 	/* 6 buckets for ticks: 60s */
203 	CTime_T		ch_Times[CHTSIZE];
204 }
205 CHash_T;
206 
207 static CHash_T CHashAry[CPMHSIZE];
208 static bool CHashAryOK = false;
209 
210 /*
211 **  CLIENT_RATE - Evaluate connection rate per smtp client
212 **
213 **	Parameters:
214 **		now - current time in secs
215 **		saddr - client address
216 **		update - update data / check only
217 **
218 **	Returns:
219 **		connection rate (connections / ConnectionRateWindowSize)
220 **
221 **	Side effects:
222 **		update static global data
223 **
224 */
225 
226 static int
227 client_rate(now, saddr, update)
228 	 time_t now;
229 	 SOCKADDR *saddr;
230 	 bool update;
231 {
232 	unsigned int hv;
233 	int i;
234 	int cnt;
235 	bool coll;
236 	CHash_T *chBest = NULL;
237 	unsigned int ticks;
238 
239 	cnt = 0;
240 	hv = 0xABC3D20F;
241 	if (ChtGran < 0)
242 		ChtGran = ConnectionRateWindowSize / CHTSIZE;
243 	if (ChtGran <= 0)
244 		ChtGran = 10;
245 
246 	ticks = now / ChtGran;
247 
248 	if (!CHashAryOK)
249 	{
250 		memset(CHashAry, 0, sizeof(CHashAry));
251 		CHashAryOK = true;
252 	}
253 
254 	{
255 		char *p;
256 		int addrlen;
257 #if HASH_ALG != 1
258 		int c, d;
259 #endif /* HASH_ALG != 1 */
260 
261 		switch (saddr->sa.sa_family)
262 		{
263 #if NETINET
264 		  case AF_INET:
265 			p = (char *)&saddr->sin.sin_addr;
266 			addrlen = sizeof(struct in_addr);
267 			break;
268 #endif /* NETINET */
269 #if NETINET6
270 		  case AF_INET6:
271 			p = (char *)&saddr->sin6.sin6_addr;
272 			addrlen = sizeof(struct in6_addr);
273 			break;
274 #endif /* NETINET6 */
275 		  default:
276 			/* should not happen */
277 			return -1;
278 		}
279 
280 		/* compute hash value */
281 		for (i = 0; i < addrlen; ++i, ++p)
282 #if HASH_ALG == 1
283 			hv = (hv << 5) ^ (hv >> 23) ^ *p;
284 		hv = (hv ^ (hv >> 16));
285 #elif HASH_ALG == 2
286 		{
287 			d = *p;
288 			c = d;
289 			c ^= c<<6;
290 			hv += (c<<11) ^ (c>>1);
291 			hv ^= (d<<14) + (d<<7) + (d<<4) + d;
292 		}
293 #elif HASH_ALG == 3
294 		{
295 			hv = (hv << 4) + *p;
296 			d = hv & 0xf0000000;
297 			if (d != 0)
298 			{
299 				hv ^= (d >> 24);
300 				hv ^= d;
301 			}
302 		}
303 #else /* HASH_ALG == 1 */
304 			hv = ((hv << 1) ^ (*p & 0377)) % cctx->cc_size;
305 #endif /* HASH_ALG == 1 */
306 	}
307 
308 	coll = true;
309 	for (i = 0; i < MAX_CT_STEPS; ++i)
310 	{
311 		CHash_T *ch = &CHashAry[(hv + i) & CPMHMASK];
312 
313 #if NETINET
314 		if (saddr->sa.sa_family == AF_INET &&
315 		    ch->ch_Family == AF_INET &&
316 		    (saddr->sin.sin_addr.s_addr == ch->ch_Addr4.s_addr ||
317 		     ch->ch_Addr4.s_addr == 0))
318 		{
319 			chBest = ch;
320 			coll = false;
321 			break;
322 		}
323 #endif /* NETINET */
324 #if NETINET6
325 		if (saddr->sa.sa_family == AF_INET6 &&
326 		    ch->ch_Family == AF_INET6 &&
327 		    (IN6_ARE_ADDR_EQUAL(&saddr->sin6.sin6_addr,
328 				       &ch->ch_Addr6) != 0 ||
329 		     IN6_IS_ADDR_UNSPECIFIED(&ch->ch_Addr6)))
330 		{
331 			chBest = ch;
332 			coll = false;
333 			break;
334 		}
335 #endif /* NETINET6 */
336 		if (chBest == NULL || ch->ch_LTime == 0 ||
337 		    ch->ch_LTime < chBest->ch_LTime)
338 			chBest = ch;
339 	}
340 
341 	/* Let's update data... */
342 	if (update)
343 	{
344 		if (coll && (now - chBest->ch_LTime < CollTime))
345 		{
346 			/*
347 			**  increment the number of collisions last
348 			**  CollTime for this client
349 			*/
350 
351 			chBest->ch_colls++;
352 
353 			/*
354 			**  Maybe shall log if collision rate is too high...
355 			**  and take measures to resize tables
356 			**  if this is the case
357 			*/
358 		}
359 
360 		/*
361 		**  If it's not a match, then replace the data.
362 		**  Note: this purges the history of a colliding entry,
363 		**  which may cause "overruns", i.e., if two entries are
364 		**  "cancelling" each other out, then they may exceed
365 		**  the limits that are set. This might be mitigated a bit
366 		**  by the above "best of 5" function however.
367 		**
368 		**  Alternative approach: just use the old data, which may
369 		**  cause false positives however.
370 		**  To activate this, change deactivate following memset call.
371 		*/
372 
373 		if (coll)
374 		{
375 #if NETINET
376 			if (saddr->sa.sa_family == AF_INET)
377 			{
378 				chBest->ch_Family = AF_INET;
379 				chBest->ch_Addr4 = saddr->sin.sin_addr;
380 			}
381 #endif /* NETINET */
382 #if NETINET6
383 			if (saddr->sa.sa_family == AF_INET6)
384 			{
385 				chBest->ch_Family = AF_INET6;
386 				chBest->ch_Addr6 = saddr->sin6.sin6_addr;
387 			}
388 #endif /* NETINET6 */
389 #if 1
390 			memset(chBest->ch_Times, '\0',
391 			       sizeof(chBest->ch_Times));
392 #endif /* 1 */
393 		}
394 
395 		chBest->ch_LTime = now;
396 		{
397 			CTime_T *ct = &chBest->ch_Times[ticks % CHTSIZE];
398 
399 			if (ct->ct_Ticks != ticks)
400 			{
401 				ct->ct_Ticks = ticks;
402 				ct->ct_Count = 0;
403 			}
404 			++ct->ct_Count;
405 		}
406 	}
407 
408 	/* Now let's count connections on the window */
409 	for (i = 0; i < CHTSIZE; ++i)
410 	{
411 		CTime_T *ct = &chBest->ch_Times[i];
412 
413 		if (ct->ct_Ticks <= ticks && ct->ct_Ticks >= ticks - CHTSIZE)
414 			cnt += ct->ct_Count;
415 	}
416 
417 #if RATECTL_DEBUG
418 	sm_syslog(LOG_WARNING, NOQID,
419 		"cln: cnt=(%d), CHTSIZE=(%d), ChtGran=(%d)",
420 		cnt, CHTSIZE, ChtGran);
421 #endif /* RATECTL_DEBUG */
422 	return cnt;
423 }
424 
425 /*
426 **  TOTAL_RATE - Evaluate global connection rate
427 **
428 **	Parameters:
429 **		now - current time in secs
430 **		update - update data / check only
431 **
432 **	Returns:
433 **		connection rate (connections / ConnectionRateWindowSize)
434 */
435 
436 static CTime_T srv_Times[CHTSIZE];
437 static bool srv_Times_OK = false;
438 
439 static int
440 total_rate(now, update)
441 	 time_t now;
442 	 bool update;
443 {
444 	int i;
445 	int cnt = 0;
446 	CTime_T *ct;
447 	unsigned int ticks;
448 
449 	if (ChtGran < 0)
450 		ChtGran = ConnectionRateWindowSize / CHTSIZE;
451 	if (ChtGran == 0)
452 		ChtGran = 10;
453 	ticks = now / ChtGran;
454 	if (!srv_Times_OK)
455 	{
456 		memset(srv_Times, 0, sizeof(srv_Times));
457 		srv_Times_OK = true;
458 	}
459 
460 	/* Let's update data */
461 	if (update)
462 	{
463 		ct = &srv_Times[ticks % CHTSIZE];
464 
465 		if (ct->ct_Ticks != ticks)
466 		{
467 			ct->ct_Ticks = ticks;
468 			ct->ct_Count = 0;
469 		}
470 		++ct->ct_Count;
471 	}
472 
473 	/* Let's count connections on the window */
474 	for (i = 0; i < CHTSIZE; ++i)
475 	{
476 		ct = &srv_Times[i];
477 
478 		if (ct->ct_Ticks <= ticks && ct->ct_Ticks >= ticks - CHTSIZE)
479 			cnt += ct->ct_Count;
480 	}
481 
482 #if RATECTL_DEBUG
483 	sm_syslog(LOG_WARNING, NOQID,
484 		"srv: cnt=(%d), CHTSIZE=(%d), ChtGran=(%d)",
485 		 cnt, CHTSIZE, ChtGran);
486 #endif /* RATECTL_DEBUG */
487 
488 	return cnt;
489 }
490 
491 #if 0
492 /*
493 ** SOCKADDRCMP - compare two SOCKADDR structures
494 **   this function may be used to compare SOCKADDR
495 **   structures when using bsearch and qsort functions
496 **   in the same way we do with strcmp
497 **
498 ** Parameters:
499 **   a, b - addresses
500 **
501 ** Returns:
502 **   1 if a > b
503 **  -1 if a < b
504 **   0 if a = b
505 **
506 ** OBS: This call isn't used at the moment, it will
507 ** be used when code will be extended to work with IPV6
508 */
509 
510 static int
511 sockaddrcmp(a, b)
512 	 SOCKADDR *a;
513 	 SOCKADDR *b;
514 {
515 	if (a->sa.sa_family > b->sa.sa_family)
516 		return 1;
517 	if (a->sa.sa_family < b->sa.sa_family)
518 		return -1;
519 
520 	switch (a->sa.sa_family)
521 	{
522 	  case AF_INET:
523 		if (a->sin.sin_addr.s_addr > b->sin.sin_addr.s_addr)
524 			return 1;
525 		if (a->sin.sin_addr.s_addr < b->sin.sin_addr.s_addr)
526 			return -1;
527 		return 0;
528 		break;
529 
530 	  case AF_INET6:
531 		/* TO BE DONE */
532 		break;
533 	}
534 	return 0;
535 }
536 #endif /* 0 */
537