aim_snac.c

   1
   2 /*
   3  *
   4  * Various SNAC-related dodads...
   5  *
   6  * outstanding_snacs is a list of aim_snac_t structs.  A SNAC should be added
   7  * whenever a new SNAC is sent and it should remain in the list until the
   8  * response for it has been receieved.
   9  *
  10  * cleansnacs() should be called periodically by the client in order
  11  * to facilitate the aging out of unreplied-to SNACs. This can and does
  12  * happen, so it should be handled.
  13  *
  14  */
  15
  16 #include <faim/aim.h>
  17
  18 /*
  19  * Called from aim_session_init() to initialize the hash.
  20  */
  21 faim_internal void aim_initsnachash(struct aim_session_t *sess)
  22 {
  23   int i;
  24
  25   for (i = 0; i < FAIM_SNAC_HASH_SIZE; i++) {
  26     sess->snac_hash[i] = NULL;
  27     faim_mutex_init(&sess->snac_hash_locks[i]);
  28   }
  29
  30   return;
  31 }
  32
  33 /*
  34  * Clones the passed snac structure and caches it in the
  35  * list/hash.
  36  */
  37 faim_internal unsigned long aim_newsnac(struct aim_session_t *sess,
  38                                         struct aim_snac_t *newsnac)
  39 {
  40   struct aim_snac_t *snac = NULL;
  41   int index;
  42
  43   if (!newsnac)
  44     return 0;
  45
  46   if (!(snac = calloc(1, sizeof(struct aim_snac_t))))
  47     return 0;
  48   memcpy(snac, newsnac, sizeof(struct aim_snac_t));
  49   snac->issuetime = time(&snac->issuetime);
  50   snac->next = NULL;
  51
  52   index = snac->id % FAIM_SNAC_HASH_SIZE;
  53
  54   faim_mutex_lock(&sess->snac_hash_locks[index]);
  55   snac->next = sess->snac_hash[index];
  56   sess->snac_hash[index] = snac;
  57   faim_mutex_unlock(&sess->snac_hash_locks[index]);
  58
  59   return(snac->id);
  60 }
  61
  62 /*
  63  * Finds a snac structure with the passed SNAC ID,
  64  * removes it from the list/hash, and returns a pointer to it.
  65  *
  66  * The returned structure must be freed by the caller.
  67  *
  68  */
  69 faim_internal struct aim_snac_t *aim_remsnac(struct aim_session_t *sess,
  70                                              u_long id)
  71 {
  72   struct aim_snac_t *cur = NULL;
  73   int index;
  74
  75   index = id % FAIM_SNAC_HASH_SIZE;
  76
  77   faim_mutex_lock(&sess->snac_hash_locks[index]);
  78   if (!sess->snac_hash[index])
  79     ;
  80   else if (sess->snac_hash[index]->id == id) {
  81     cur = sess->snac_hash[index];
  82     sess->snac_hash[index] = cur->next;
  83   } else {
  84     cur = sess->snac_hash[index];
  85     while (cur->next) {
  86       if (cur->next->id == id) {
  87         struct aim_snac_t *tmp;
  88
  89         tmp = cur->next;
  90         cur->next = cur->next->next;
  91         cur = tmp;
  92         break;
  93       }
  94       cur = cur->next;
  95     }
  96   }
  97   faim_mutex_unlock(&sess->snac_hash_locks[index]);
  98
  99   return cur;
 100 }
 101
 102 /*
 103  * This is for cleaning up old SNACs that either don't get replies or
 104  * a reply was never received for.  Garabage collection. Plain and simple.
 105  *
 106  * maxage is the _minimum_ age in seconds to keep SNACs.
 107  *
 108  */
 109 faim_internal int aim_cleansnacs(struct aim_session_t *sess,
 110                                  int maxage)
 111 {
 112   struct aim_snac_t *cur, *next, *prev = NULL;
 113   time_t curtime;
 114   int i;
 115
 116   for (i = 0; i < FAIM_SNAC_HASH_SIZE; i++) {
 117     faim_mutex_lock(&sess->snac_hash_locks[i]);
 118     if (!sess->snac_hash[i]) {
 119       faim_mutex_unlock(&sess->snac_hash_locks[i]);
 120       continue;
 121     }
 122
 123     curtime = time(NULL); /* done here in case we waited for the lock */
 124
 125     cur = sess->snac_hash[i];
 126     while (cur) {
 127       next = cur->next;
 128       if ((curtime - cur->issuetime) > maxage) {
 129         if (sess->snac_hash[i] == cur)
 130           prev = sess->snac_hash[i] = next;
 131         else
 132           prev->next = next;
 133
 134         /* XXX should we have destructors here? */
 135         if (cur->data)
 136           free(cur->data);
 137         free(cur);
 138
 139       } else {
 140         prev = cur;
 141       }
 142       cur = next;
 143     }
 144
 145     faim_mutex_unlock(&sess->snac_hash_locks[i]);
 146   }
 147
 148   return 0;
 149 }
 150
 151 faim_internal int aim_putsnac(u_char *buf, int family, int subtype, int flags, u_long snacid)
 152 {
 153   int curbyte = 0;
 154   curbyte += aimutil_put16(buf+curbyte, (u_short)(family&0xffff));
 155   curbyte += aimutil_put16(buf+curbyte, (u_short)(subtype&0xffff));
 156   curbyte += aimutil_put16(buf+curbyte, (u_short)(flags&0xffff));
 157   curbyte += aimutil_put32(buf+curbyte, snacid);
 158   return curbyte;
 159 }