git.pond.sub.org Git - empserver/blob - src/client/ioqueue.c

   1 /*
   2  *  Empire - A multi-player, client/server Internet based war game.
   3  *  Copyright (C) 1986-2000, Dave Pare, Jeff Bailey, Thomas Ruschak,
   4  *                           Ken Stevens, Steve McClure
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  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  USA
  19  *
  20  *  ---
  21  *
  22  *  See the "LEGAL", "LICENSE", "CREDITS" and "README" files for all the
  23  *  related information and legal notices. It is expected that any future
  24  *  projects/authors will amend these files as needed.
  25  *
  26  *  ---
  27  *
  28  *  ioqueue.c: Manage an i/o queue
  29  *
  30  *  Known contributors to this file:
  31  *     Steve McClure, 1998
  32  */
  33
  34 #include <stdio.h>
  35 #include <sys/types.h>
  36 #ifndef _WIN32
  37 #include <sys/uio.h>
  38 #include <unistd.h>
  39 #endif
  40 #include "misc.h"
  41 #include "queue.h"
  42 #include "ioqueue.h"
  43
  44 #ifdef _WIN32
  45 typedef struct iovec {
  46     char *iov_base;
  47     int iov_len;
  48 } iovec_t;
  49 #endif
  50
  51
  52 static int ioqtobuf();
  53 static int ioqtoiov();
  54 static void enqueuecc();
  55 static int dequeuecc();
  56
  57 void insque();
  58 void remque();
  59 void initque();
  60 struct qelem *makeqt();
  61 void free();
  62
  63 void
  64 ioq_init(ioq, bsize)
  65 struct ioqueue *ioq;
  66 int bsize;
  67 {
  68     extern s_char num_teles[];
  69
  70     initque(&ioq->queue);
  71     ioq->cc = 0;
  72     ioq->bsize = bsize;
  73     *num_teles = '\0';
  74 }
  75
  76 /*
  77  * copy batch of pointers into the passed
  78  * iovec, but don't actually dequeue the data.
  79  * return # of iovec initialized.
  80  */
  81 int
  82 ioq_peekiov(ioq, iov, max)
  83 struct ioqueue *ioq;
  84 struct iovec *iov;
  85 int max;
  86 {
  87     if (ioq->cc <= 0)
  88         return 0;
  89     return ioqtoiov(ioq, iov, max);
  90 }
  91
  92 /*
  93  * Copy the specified number of characters into the buffer
  94  * provided, without actually dequeueing the data.  Return
  95  * number of bytes actually found.
  96  */
  97 int
  98 ioq_peek(ioq, buf, cc)
  99 struct ioqueue *ioq;
 100 s_char *buf;
 101 int cc;
 102 {
 103     return ioqtobuf(ioq, buf, cc);
 104 }
 105
 106 int
 107 ioq_dequeue(ioq, cc)
 108 struct ioqueue *ioq;
 109 int cc;
 110 {
 111     if (dequeuecc(ioq, cc) != cc)
 112         return 0;
 113     return cc;
 114 }
 115
 116 int
 117 ioq_read(ioq, buf, cc)
 118 struct ioqueue *ioq;
 119 s_char *buf;
 120 int cc;
 121 {
 122     int n;
 123
 124     n = ioqtobuf(ioq, buf, cc);
 125     if (n > 0)
 126         dequeuecc(ioq, n);
 127     return n;
 128 }
 129
 130 void
 131 ioq_write(ioq, buf, cc)
 132 struct ioqueue *ioq;
 133 s_char *buf;
 134 int cc;
 135 {
 136     enqueuecc(ioq, buf, cc);
 137 }
 138
 139 int
 140 ioq_qsize(ioq)
 141 struct ioqueue *ioq;
 142 {
 143     return ioq->cc;
 144 }
 145
 146 void
 147 ioq_drain(ioq)
 148 struct ioqueue *ioq;
 149 {
 150     struct io *io;
 151     struct qelem *qp;
 152
 153     while ((qp = ioq->queue.q_forw) != &ioq->queue) {
 154         io = (struct io *)qp;
 155         free(io->data);
 156         (void)remque(&io->queue);
 157         (void)free(io);
 158     }
 159     ioq->cc = 0;
 160 }
 161
 162 s_char *
 163 ioq_gets(ioq, buf, cc)
 164 struct ioqueue *ioq;
 165 s_char *buf;
 166 int cc;
 167 {
 168     register s_char *p;
 169     register s_char *end;
 170     int nbytes;
 171
 172     nbytes = ioqtobuf(ioq, buf, cc);
 173     if (nbytes < cc)
 174         cc = nbytes;
 175     end = &buf[cc];
 176     for (p = buf; p < end && *p; p++) {
 177         if (*p == '\n') {
 178             *p = '\0';
 179             dequeuecc(ioq, (p - buf) + 1);
 180             return buf;
 181         }
 182     }
 183     return 0;
 184 }
 185
 186 /*
 187  * all the rest are local to this module
 188  */
 189
 190
 191 /*
 192  * copy cc bytes from ioq to buf.
 193  * this routine doesn't free memory; this is
 194  * left for a higher level.
 195  */
 196 static
 197     int
 198 ioqtobuf(ioq, buf, cc)
 199 register struct ioqueue *ioq;
 200 s_char *buf;
 201 int cc;
 202 {
 203     register struct io *io;
 204     struct qelem *qp;
 205     s_char *offset;
 206     int nbytes;
 207     int nleft;
 208
 209     nleft = cc;
 210     offset = buf;
 211     for (qp = ioq->queue.q_forw; qp != &ioq->queue; qp = qp->q_forw) {
 212         io = (struct io *)qp;
 213         if ((nbytes = io->nbytes - io->offset) < 0) {
 214             fprintf(stderr, "ioqtobuf: offset %d nbytes %d\n",
 215                     io->offset, io->nbytes);
 216             continue;
 217         }
 218         if (nbytes > 0) {
 219             if (nleft < nbytes)
 220                 nbytes = nleft;
 221             bcopy(io->data + io->offset, offset, nbytes);
 222             offset += nbytes;
 223             nleft -= nbytes;
 224         }
 225     }
 226     return offset - buf;
 227 }
 228
 229 /*
 230  * translate "around" max bytes to an iovec
 231  * array.  The limit max is only advisory,
 232  * and more may get buffered.  It is an attempt to limit
 233  * really silly sends -- like sending 40k on a socket
 234  * with one writev for example.  This makes the processing
 235  * of a full ioqueue still be quick.
 236  */
 237 static
 238     int
 239 ioqtoiov(ioq, iov, max)
 240 register struct ioqueue *ioq;
 241 register struct iovec *iov;
 242 register int max;
 243 {
 244     register struct io *io;
 245     register int cc;
 246     register int niov;
 247     struct qelem *qp;
 248
 249     cc = 0;
 250     niov = 0;
 251     qp = ioq->queue.q_forw;
 252     for (qp = ioq->queue.q_forw; qp != &ioq->queue; qp = qp->q_forw) {
 253         io = (struct io *)qp;
 254         if (niov >= MAXIOV || cc >= max)
 255             break;
 256         iov->iov_base = io->data + io->offset;
 257         iov->iov_len = io->nbytes - io->offset;
 258         cc += io->nbytes - io->offset;
 259         niov++;
 260         iov++;
 261     }
 262     return niov;
 263 }
 264
 265 /*
 266  * append a buffer to the end of the ioq.
 267  */
 268 static void
 269 enqueuecc(ioq, buf, cc)
 270 struct ioqueue *ioq;
 271 s_char *buf;
 272 int cc;
 273 {
 274     struct io *io;
 275
 276     io = (struct io *)malloc(sizeof(*io));
 277     io->nbytes = cc;
 278     io->offset = 0;
 279     io->data = buf;
 280     insque(&io->queue, ioq->queue.q_back);
 281     ioq->cc += cc;
 282 }
 283
 284 /*
 285  * remove cc bytes from ioqueue ioq
 286  * free memory, dequeue io elements
 287  * which are no longer used.
 288  */
 289 static
 290     int
 291 dequeuecc(ioq, cc)
 292 register struct ioqueue *ioq;
 293 register int cc;
 294 {
 295     register struct io *io;
 296     register struct qelem *qp;
 297     register int nbytes;
 298     register int there;
 299
 300     nbytes = 0;
 301     while ((qp = ioq->queue.q_forw) != &ioq->queue) {
 302         io = (struct io *)qp;
 303         there = io->nbytes - io->offset;
 304         if (there < 0) {
 305             fprintf(stderr, "dequeuecc: nbytes %d, offset %d\n",
 306                     io->nbytes, io->offset);
 307             continue;
 308         }
 309         if (cc > there) {
 310             cc -= there;
 311             nbytes += there;
 312             (void)remque(&io->queue);
 313             free(io->data);
 314         } else {
 315             io->offset += cc;
 316             nbytes += cc;
 317             break;
 318         }
 319     }
 320     ioq->cc -= nbytes;
 321     return nbytes;
 322 }