2 * IRC - Internet Relay Chat, ircd/class.c
3 * Copyright (C) 1990 Darren Reed
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 1, or (at your option)
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 * @brief Implementation of connection class handling functions.
21 * @version $Id: class.c 1514 2005-10-06 00:37:31Z entrope $
28 #include "ircd_alloc.h"
29 #include "ircd_features.h"
31 #include "ircd_reply.h"
32 #include "ircd_string.h"
39 /* #include <assert.h> -- Now using assert in ircd_log.h */
41 /** List of all connection classes. */
42 static struct ConnectionClass* connClassList;
43 /** Number of allocated connection classes. */
44 static unsigned int connClassAllocCount;
46 /** Get start of connection class linked list. */
47 const struct ConnectionClass* get_class_list(void)
52 /** Allocate a new connection class.
53 * If #connClassList is not null, insert the new class just after it.
54 * @return Newly allocated connection class structure.
56 struct ConnectionClass* make_class(void)
58 struct ConnectionClass *tmp;
60 tmp = (struct ConnectionClass*) MyCalloc(1, sizeof(struct ConnectionClass));
65 tmp->next = connClassList->next;
66 connClassList->next = tmp;
68 ++connClassAllocCount;
72 /** Dereference a connection class.
73 * @param[in] p Connection class to dereference.
75 void free_class(struct ConnectionClass* p)
79 assert(0 == p->valid);
81 MyFree(p->default_umode);
83 --connClassAllocCount;
87 /** Initialize the connection class list.
88 * A connection class named "default" is created, with ping frequency,
89 * connection frequency, maximum links and max SendQ values from the
90 * corresponding configuration features.
95 connClassList = (struct ConnectionClass*) make_class();
96 connClassList->next = 0;
99 /* We had better not try and free this... */
100 ConClass(connClassList) = "default";
101 PingFreq(connClassList) = feature_int(FEAT_PINGFREQUENCY);
102 ConFreq(connClassList) = feature_int(FEAT_CONNECTFREQUENCY);
103 MaxLinks(connClassList) = feature_int(FEAT_MAXIMUM_LINKS);
104 MaxSendq(connClassList) = feature_int(FEAT_DEFAULTMAXSENDQLENGTH);
105 connClassList->max_channels = 0;
106 connClassList->valid = 1;
107 Links(connClassList) = 1;
110 /** Mark current connection classes as invalid.
112 void class_mark_delete(void)
114 struct ConnectionClass* p;
115 assert(0 != connClassList);
117 for (p = connClassList->next; p; p = p->next)
121 /** Unlink (and dereference) invalid connection classes.
122 * This is used in combination with class_mark_delete() during rehash
123 * to get rid of connection classes that are no longer in the
126 void class_delete_marked(void)
128 struct ConnectionClass* cl;
129 struct ConnectionClass* prev;
131 Debug((DEBUG_DEBUG, "Class check:"));
133 for (prev = cl = connClassList; cl; cl = prev->next) {
134 Debug((DEBUG_DEBUG, "Class %s : CF: %d PF: %d ML: %d LI: %d SQ: %d",
135 ConClass(cl), ConFreq(cl), PingFreq(cl), MaxLinks(cl),
136 Links(cl), MaxSendq(cl)));
138 * unlink marked classes, delete unreferenced ones
140 if (cl->valid || Links(cl) > 1)
144 prev->next = cl->next;
150 /** Get connection class name for a configuration item.
151 * @param[in] aconf Configuration item to check.
152 * @return Name of connection class associated with \a aconf.
155 get_conf_class(const struct ConfItem* aconf)
157 if ((aconf) && (aconf->conn_class))
158 return (ConfClass(aconf));
160 Debug((DEBUG_DEBUG, "No Class For %s", (aconf) ? aconf->name : "*No Conf*"));
165 /** Get ping time for a configuration item.
166 * @param[in] aconf Configuration item to check.
167 * @return Ping time for connection class associated with \a aconf.
169 int get_conf_ping(const struct ConfItem* aconf)
172 if (aconf->conn_class)
173 return (ConfPingFreq(aconf));
175 Debug((DEBUG_DEBUG, "No Ping For %s", aconf->name));
180 /** Get connection class name for a particular client.
181 * @param[in] acptr Client to check.
182 * @return Name of connection class to which \a acptr belongs.
185 get_client_class(struct Client *acptr)
188 struct ConnectionClass *cl;
190 /* Return the most recent(first on LL) client class... */
191 if (acptr && !IsMe(acptr) && (cli_confs(acptr)))
192 for (tmp = cli_confs(acptr); tmp; tmp = tmp->next)
194 if (tmp->value.aconf && (cl = tmp->value.aconf->conn_class))
197 return "(null-class)";
200 /** Make sure we have a connection class named \a name.
201 * If one does not exist, create it. Then set its ping frequency,
202 * connection frequency, maximum link count, and max SendQ according
204 * @param[in] name Connection class name.
205 * @param[in] ping Ping frequency for clients in this class.
206 * @param[in] confreq Connection frequency for clients.
207 * @param[in] maxli Maximum link count for class.
208 * @param[in] sendq Max SendQ for clients.
209 * @param[in] max_channels Maximum number of channels.
211 void add_class(char *name, unsigned int ping, unsigned int confreq,
212 unsigned int maxli, unsigned int sendq, unsigned int max_channels)
214 struct ConnectionClass* p;
216 Debug((DEBUG_DEBUG, "Add Class %s: cf: %u pf: %u ml: %u sq: %d mc: %u",
217 name, confreq, ping, maxli, sendq, max_channels));
218 assert(name != NULL);
219 p = do_find_class(name, 1);
225 ConFreq(p) = confreq;
228 p->max_channels = max_channels;
229 MaxSendq(p) = (sendq > 0) ?
230 sendq : feature_int(FEAT_DEFAULTMAXSENDQLENGTH);
234 /** Find a connection class by name.
235 * @param[in] name Name of connection class to search for.
236 * @param[in] extras If non-zero, include unreferenced classes.
237 * @return Pointer to connection class structure (or NULL if none match).
239 struct ConnectionClass* do_find_class(const char *name, int extras)
241 struct ConnectionClass *cltmp;
243 for (cltmp = connClassList; cltmp; cltmp = cltmp->next) {
244 if (!cltmp->valid && !extras)
246 if (!ircd_strcmp(ConClass(cltmp), name))
252 /** Report connection classes to a client.
253 * @param[in] sptr Client requesting statistics.
254 * @param[in] sd Stats descriptor for request (ignored).
255 * @param[in] param Extra parameter from user (ignored).
258 report_classes(struct Client *sptr, const struct StatDesc *sd,
261 struct ConnectionClass *cltmp;
263 for (cltmp = connClassList; cltmp; cltmp = cltmp->next)
264 send_reply(sptr, RPL_STATSYLINE, (cltmp->valid ? 'Y' : 'y'),
265 ConClass(cltmp), PingFreq(cltmp), ConFreq(cltmp),
266 MaxLinks(cltmp), MaxSendq(cltmp), MaxChannels(cltmp), Links(cltmp) - 1);
269 /** Return maximum SendQ length for a client.
270 * @param[in] cptr Local client to check.
271 * @return Number of bytes allowed in SendQ for \a cptr.
274 get_sendq(struct Client *cptr)
277 assert(0 != cli_local(cptr));
279 if (cli_max_sendq(cptr))
280 return cli_max_sendq(cptr);
282 else if (cli_confs(cptr)) {
284 struct ConnectionClass* cl;
286 for (tmp = cli_confs(cptr); tmp; tmp = tmp->next) {
287 if (!tmp->value.aconf || !(cl = tmp->value.aconf->conn_class))
289 if (ConClass(cl) != NULL) {
290 cli_max_sendq(cptr) = MaxSendq(cl);
291 return cli_max_sendq(cptr);
295 return feature_int(FEAT_DEFAULTMAXSENDQLENGTH);
298 /** Report connection class memory statistics to a client.
299 * Send number of classes and number of bytes allocated for them.
300 * @param[in] cptr Client requesting statistics.
302 void class_send_meminfo(struct Client* cptr)
304 send_reply(cptr, SND_EXPLICIT | RPL_STATSDEBUG, ":Classes: inuse: %d(%d)",
306 connClassAllocCount * sizeof(struct ConnectionClass));