chanserv/chanservalloc.c

   1 /*
   2  * chanservalloc.c:
   3  *  Handles allocation of the various chanserv structures.
   4  */
   5
   6 #include "chanserv.h"
   7 #include <stdlib.h>
   8
   9 #define ALLOCUNIT 100
  10
  11 regchan     *csfreechans;
  12 reguser     *csfreeusers;
  13 regchanuser *csfreechanusers;
  14 nicklist    *csfreenicklists;
  15 regban      *csfreeregbans;
  16 activeuser  *csfreeactiveusers;
  17
  18 void *csmallocs;
  19
  20 void chanservallocinit() {
  21   csfreechans=NULL;
  22   csfreeusers=NULL;
  23   csfreechanusers=NULL;
  24   csfreenicklists=NULL;
  25   csfreeregbans=NULL;
  26   csfreeactiveusers=NULL;
  27   csmallocs=NULL;
  28 }
  29
  30 void *csmalloc(size_t size) {
  31   void **mem;
  32
  33   /* Get the requested memory, with one extra pointer at the beginning */
  34   mem=(void **)malloc(size+sizeof(void *));
  35
  36   /* Set the first word to point at the last thing we got */
  37   *mem=csmallocs;
  38
  39   /* Now set the "last chunk" pointer to the address of this one */
  40   csmallocs=(void *)mem;
  41
  42   /* return the rest of the memory to the caller */
  43   return (void *)(mem+1);
  44 }
  45
  46 /*
  47  * csfreeall():
  48  *  Free all the memory we allocated for chanserv structures.
  49  */
  50
  51 void csfreeall() {
  52   void *vp,**vh;
  53
  54   vp=csmallocs;
  55
  56   while (vp!=NULL) {
  57     vh=(void **)vp;
  58     vp=*vh;
  59     free ((void *)vh);
  60   }
  61 }
  62
  63 regchan *getregchan() {
  64   int i;
  65   regchan *rcp;
  66
  67   if (csfreechans==NULL) {
  68     csfreechans=(regchan *)csmalloc(ALLOCUNIT*sizeof(regchan));
  69     for (i=0;i<(ALLOCUNIT-1);i++) {
  70       csfreechans[i].index=(chanindex *)&(csfreechans[i+1]);
  71     }
  72     csfreechans[ALLOCUNIT-1].index=NULL;
  73   }
  74
  75   rcp=csfreechans;
  76   csfreechans=(regchan *)rcp->index;
  77
  78   tagregchan(rcp);
  79
  80   return rcp;
  81 }
  82
  83 void freeregchan(regchan *rcp) {
  84   verifyregchan(rcp);
  85   rcp->index=(chanindex *)csfreechans;
  86   csfreechans=rcp;
  87 }
  88
  89 reguser *getreguser() {
  90   int i;
  91   reguser *rup;
  92
  93   if (csfreeusers==NULL) {
  94     csfreeusers=(reguser *)csmalloc(ALLOCUNIT*sizeof(reguser));
  95     for (i=0;i<(ALLOCUNIT-1);i++) {
  96       csfreeusers[i].nextbyname=&(csfreeusers[i+1]);
  97     }
  98     csfreeusers[ALLOCUNIT-1].nextbyname=NULL;
  99   }
 100
 101   rup=csfreeusers;
 102   csfreeusers=rup->nextbyname;
 103
 104   tagreguser(rup);
 105
 106   return rup;
 107 }
 108
 109 void freereguser(reguser *rup) {
 110   verifyreguser(rup);
 111   rup->nextbyname=csfreeusers;
 112   csfreeusers=rup;
 113 }
 114
 115 regchanuser *getregchanuser() {
 116   int i;
 117   regchanuser *rcup;
 118
 119   if (csfreechanusers==NULL) {
 120     csfreechanusers=(regchanuser *)csmalloc(ALLOCUNIT*sizeof(regchanuser));
 121     for (i=0;i<(ALLOCUNIT-1);i++) {
 122       csfreechanusers[i].nextbyuser=&(csfreechanusers[i+1]);
 123     }
 124     csfreechanusers[ALLOCUNIT-1].nextbyuser=NULL;
 125   }
 126
 127   rcup=csfreechanusers;
 128   csfreechanusers=rcup->nextbyuser;
 129
 130   tagregchanuser(rcup);
 131
 132   return rcup;
 133 }
 134
 135 void freeregchanuser(regchanuser *rcup) {
 136   verifyregchanuser(rcup);
 137   rcup->nextbyuser=csfreechanusers;
 138   csfreechanusers=rcup;
 139 }
 140
 141 nicklist *getnicklist() {
 142   int i;
 143   nicklist *nlp;
 144
 145   if (csfreenicklists==NULL) {
 146     csfreenicklists=(nicklist *)csmalloc(ALLOCUNIT*sizeof(nicklist));
 147     for (i=0;i<(ALLOCUNIT-1);i++) {
 148       csfreenicklists[i].next=&(csfreenicklists[i+1]);
 149     }
 150     csfreenicklists[ALLOCUNIT-1].next=NULL;
 151   }
 152
 153   nlp=csfreenicklists;
 154   csfreenicklists=nlp->next;
 155
 156   return nlp;
 157 }
 158
 159 void freenicklist(nicklist *nlp) {
 160   nlp->next=csfreenicklists;
 161   csfreenicklists=nlp;
 162 }
 163
 164 regban *getregban() {
 165   int i;
 166   regban *rbp;
 167
 168   if (csfreeregbans==NULL) {
 169     csfreeregbans=(regban *)csmalloc(ALLOCUNIT*sizeof(regban));
 170     for (i=0;i<(ALLOCUNIT-1);i++) {
 171       csfreeregbans[i].next=&(csfreeregbans[i+1]);
 172     }
 173     csfreeregbans[ALLOCUNIT-1].next=NULL;
 174   }
 175
 176   rbp=csfreeregbans;
 177   csfreeregbans=rbp->next;
 178
 179   tagregchanban(rbp);
 180
 181   return rbp;
 182 }
 183
 184 void freeregban(regban *rbp) {
 185   verifyregchanban(rbp);
 186   rbp->next=csfreeregbans;
 187   csfreeregbans=rbp;
 188 }
 189
 190 activeuser *getactiveuser() {
 191   int i;
 192   activeuser *aup;
 193
 194   if (csfreeactiveusers==NULL) {
 195     csfreeactiveusers=(activeuser *)csmalloc(ALLOCUNIT*sizeof(activeuser));
 196     for (i=0;i<(ALLOCUNIT-1);i++) {
 197       csfreeactiveusers[i].next=&(csfreeactiveusers[i+1]);
 198     }
 199     csfreeactiveusers[ALLOCUNIT-1].next=NULL;
 200   }
 201
 202   aup=csfreeactiveusers;
 203   csfreeactiveusers=aup->next;
 204
 205   tagactiveuser(aup);
 206
 207   aup->rup=NULL;
 208   aup->authattempts=0;
 209
 210   return aup;
 211 }
 212
 213 void freeactiveuser(activeuser *aup) {
 214   verifyactiveuser(aup);
 215   aup->next=csfreeactiveusers;
 216   csfreeactiveusers=aup;
 217 }