2 * IRC - Internet Relay Chat, ircd/msgq.c
3 * Copyright (C) 2000 Kevin L. Mitchell <klmitch@mit.edu>
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.
22 #include "ircd_alloc.h"
23 #include "ircd_defs.h"
24 #include "ircd_snprintf.h"
29 #include <sys/types.h>
30 #include <sys/uio.h> /* struct iovec */
33 struct MsgBuf *next; /* next msg in global queue */
34 struct MsgBuf **prev_p; /* what points to us in linked list */
35 unsigned int ref; /* reference count */
36 unsigned int length; /* length of message */
37 char msg[BUFSIZE + 1]; /* the message */
41 struct Msg *next; /* next msg */
42 unsigned int sent; /* bytes in msg that have already been sent */
43 struct MsgBuf *msg; /* actual message in queue */
48 struct MsgBuf *free_mbs;
49 struct Msg *free_msgs;
50 } MQData = { 0, 0, 0 };
52 struct MsgCounts msgBufCounts = { 0, 0 };
53 struct MsgCounts msgCounts = { 0, 0 };
55 /* XXX HACK HACK HACK XXX */
57 /* First, force assertion checking */
61 /* This routine is TEMPORARY and is intended to track down a problem we're
62 * having with apparent buffer overflows in this file.
70 for (mb = MQData.msgs; mb; mb = mb->next)
71 assert(((unsigned long)mb) != 0x8000a0d);
72 for (mb = MQData.free_mbs; mb; mb = mb->next)
73 assert(((unsigned long)mb) != 0x8000a0d);
74 for (msg = MQData.free_msgs; msg; msg = msg->next)
75 assert(((unsigned long)msg) != 0x8000a0d);
78 #define msgq_integrity() ((void)0)
79 #endif /* XXX HACK HACK HACK XXX */
82 * This routine is used to remove a certain amount of data from a given
83 * queue and release the Msg (and MsgBuf) structure if needed
86 msgq_delmsg(struct MsgQ *mq, struct MsgQList *qlist, unsigned int *length_p)
95 assert(0 != qlist->head);
96 assert(0 != length_p);
98 m = qlist->head; /* find the msg we're deleting from */
100 msglen = m->msg->length - m->sent; /* calculate how much is left */
102 if (*length_p >= msglen) { /* deleted it all? */
103 mq->length -= msglen; /* decrement length */
104 mq->count--; /* decrement the message count */
107 msgq_clean(m->msg); /* free up the struct MsgBuf */
108 m->msg = 0; /* don't let it point anywhere nasty, please */
110 if (qlist->head == qlist->tail) /* figure out if we emptied the queue */
111 qlist->head = qlist->tail = 0;
113 qlist->head = m->next; /* just shift the list down some */
115 msgCounts.used--; /* struct Msg is not in use anymore */
117 m->next = MQData.free_msgs; /* throw it onto the free list */
118 MQData.free_msgs = m;
120 mq->length -= *length_p; /* decrement queue length */
121 m->sent += *length_p; /* this much of the message has been sent */
122 *length_p = 0; /* we've dealt with it all */
129 * This just initializes a struct MsgQ.
132 msgq_init(struct MsgQ *mq)
149 * This routine is used to delete the specified number of bytes off
150 * of the queue. We only really need to worry about one struct Msg*,
151 * but this allows us to retain the flexibility to deal with more,
152 * which means we could do something fancy involving writev...
155 msgq_delete(struct MsgQ *mq, unsigned int length)
162 if (mq->queue.head && mq->queue.head->sent > 0) /* partial msg on norm q */
163 msgq_delmsg(mq, &mq->queue, &length);
164 else if (mq->prio.head) /* message (partial or complete) on prio queue */
165 msgq_delmsg(mq, &mq->prio, &length);
166 else if (mq->queue.head) /* message on normal queue */
167 msgq_delmsg(mq, &mq->queue, &length);
176 * This is the more intelligent routine that can fill in an array of
180 msgq_mapiov(const struct MsgQ *mq, struct iovec *iov, int count,
194 if (mq->length <= 0) { /* no data to map */
199 if (mq->queue.head && mq->queue.head->sent > 0) { /* partial msg on norm q */
200 iov[i].iov_base = mq->queue.head->msg->msg + mq->queue.head->sent;
201 iov[i].iov_len = mq->queue.head->msg->length - mq->queue.head->sent;
202 *len += iov[i].iov_len;
204 queue = mq->queue.head->next; /* where we start later... */
206 i++; /* filled an iovec... */
207 if (!--count) { /* check for space */
212 queue = mq->queue.head; /* start at head of queue */
214 if (mq->prio.head && mq->prio.head->sent > 0) { /* partial msg on prio q */
215 iov[i].iov_base = mq->prio.head->msg->msg + mq->prio.head->sent;
216 iov[i].iov_len = mq->prio.head->msg->length - mq->prio.head->sent;
217 *len += iov[i].iov_len;
219 prio = mq->prio.head->next; /* where we start later... */
221 i++; /* filled an iovec... */
222 if (!--count) { /* check for space */
227 prio = mq->prio.head; /* start at head of prio */
229 for (; prio; prio = prio->next) { /* go through prio queue */
230 iov[i].iov_base = prio->msg->msg; /* store message */
231 iov[i].iov_len = prio->msg->length;
232 *len += iov[i].iov_len;
234 i++; /* filled an iovec... */
235 if (!--count) { /* check for space */
241 for (; queue; queue = queue->next) { /* go through normal queue */
242 iov[i].iov_base = queue->msg->msg;
243 iov[i].iov_len = queue->msg->length;
244 *len += iov[i].iov_len;
246 i++; /* filled an iovec... */
247 if (!--count) { /* check for space */
259 * This routine builds a struct MsgBuf with the appropriate contents
260 * and returns it; this saves us from having to worry about the contents
261 * of struct MsgBuf in anything other than this module
264 msgq_vmake(struct Client *dest, const char *format, va_list vl)
272 if (!(mb = MQData.free_mbs)) { /* do I need to allocate one? */
273 mb = (struct MsgBuf *)MyMalloc(sizeof(struct MsgBuf));
274 msgBufCounts.alloc++; /* we allocated another */
275 } else /* shift the free list */
276 MQData.free_mbs = MQData.free_mbs->next;
278 msgBufCounts.used++; /* we're using another */
280 mb->next = MQData.msgs; /* initialize the msgbuf */
281 mb->prev_p = &MQData.msgs;
284 /* fill the buffer */
285 mb->length = ircd_vsnprintf(dest, mb->msg, sizeof(mb->msg) - 3, format, vl);
287 mb->msg[mb->length++] = '\r'; /* add \r\n to buffer */
288 mb->msg[mb->length++] = '\n';
289 mb->msg[mb->length] = '\0'; /* not strictly necessary */
291 assert(mb->length < sizeof(mb->msg));
293 if (MQData.msgs) /* link it into the list */
294 MQData.msgs->prev_p = &mb->next;
303 msgq_make(struct Client *dest, const char *format, ...)
308 va_start(vl, format);
309 mb = msgq_vmake(dest, format, vl);
316 * This routine is used to append a formatted string to a struct MsgBuf.
319 msgq_append(struct Client *dest, struct MsgBuf *mb, const char *format, ...)
328 assert(2 < mb->length);
329 assert(sizeof(mb->msg) > mb->length);
331 mb->length -= 2; /* back up to before \r\n */
333 va_start(vl, format); /* append to the buffer */
334 mb->length += ircd_vsnprintf(dest, mb->msg + mb->length,
335 sizeof(mb->msg) - 3 - mb->length, format, vl);
338 mb->msg[mb->length++] = '\r'; /* add \r\n to buffer */
339 mb->msg[mb->length++] = '\n';
340 mb->msg[mb->length] = '\0'; /* not strictly necessary */
342 assert(mb->length < sizeof(mb->msg));
348 * This routine is called to decrement the reference count on a
349 * struct MsgBuf and delete it if necessary.
352 msgq_clean(struct MsgBuf *mb)
358 assert(0 != mb->prev_p);
360 if (!--mb->ref) { /* deallocate the message */
361 *mb->prev_p = mb->next; /* clip it out of active MsgBuf's list */
363 mb->next->prev_p = mb->prev_p;
365 mb->next = MQData.free_mbs; /* add it to free list */
366 MQData.free_mbs = mb;
370 msgBufCounts.used--; /* decrement the usage count */
377 * This routine simply adds a struct Msg to the end of a user's MsgQ.
380 msgq_add(struct MsgQ *mq, struct MsgBuf *mb, int prio)
382 struct MsgQList *qlist;
391 Debug((DEBUG_SEND, "Adding buffer %p [%.*s] to %s queue", mb,
392 mb->length - 2, mb->msg, prio ? "priority" : "normal"));
394 qlist = prio ? &mq->prio : &mq->queue;
396 if (!(msg = MQData.free_msgs)) { /* do I need to allocate one? */
397 msg = (struct Msg *)MyMalloc(sizeof(struct Msg));
398 msgCounts.alloc++; /* we allocated another */
399 } else /* shift the free list */
400 MQData.free_msgs = MQData.free_msgs->next;
402 msgCounts.used++; /* we're using another */
404 msg->next = 0; /* initialize the msg */
408 mb->ref++; /* increment the ref count on the buffer */
410 if (!qlist->head) /* queue list was empty; head and tail point to msg */
411 qlist->head = qlist->tail = msg;
413 assert(0 != qlist->tail);
415 qlist->tail->next = msg; /* queue had something in it; add to end */
419 mq->length += mb->length; /* update the queue length */
420 mq->count++; /* and the queue count */
426 * This is for reporting memory usage by the msgq system.
429 msgq_count_memory(size_t *msg_alloc, size_t *msg_used, size_t *msgbuf_alloc,
434 assert(0 != msg_alloc);
435 assert(0 != msg_used);
436 assert(0 != msgbuf_alloc);
437 assert(0 != msgbuf_used);
439 *msg_alloc = msgCounts.alloc * sizeof(struct Msg);
440 *msg_used = msgCounts.used * sizeof(struct Msg);
441 *msgbuf_alloc = msgCounts.alloc * sizeof(struct MsgBuf);
442 *msgbuf_used = msgCounts.used * sizeof(struct MsgBuf);
448 * This routine is used simply to report how much bufferspace is left.
451 msgq_bufleft(struct MsgBuf *mb)
455 return sizeof(mb->msg) - mb->length - 1; /* \r\n counted in mb->length */