src/msgcookie.c

   1 /*
   2  * Cookie Caching stuff. Adam wrote this, apparently just some
   3  * derivatives of n's SNAC work. I cleaned it up, added comments.
   4  *
   5  */
   6
   7 /*
   8  * I'm assuming that cookies are type-specific. that is, we can have
   9  * "1234578" for type 1 and type 2 concurrently. if i'm wrong, then we
  10  * lose some error checking. if we assume cookies are not type-specific and are
  11  * wrong, we get quirky behavior when cookies step on each others' toes.
  12  */
  13
  14 #define FAIM_INTERNAL
  15 #include <aim.h>
  16
  17 /**
  18  * aim_cachecookie - appends a cookie to the cookie list
  19  * @sess: session to add to
  20  * @cookie: pointer to struct to append
  21  *
  22  * if cookie->cookie for type cookie->type is found, updates the
  23  * ->addtime of the found structure; otherwise adds the given cookie
  24  * to the cache
  25  *
  26  * returns -1 on error, 0 on append, 1 on update.  the cookie you pass
  27  * in may be free'd, so don't count on its value after calling this!
  28  *
  29  */
  30 faim_internal int aim_cachecookie(aim_session_t *sess, aim_msgcookie_t *cookie)
  31 {
  32         aim_msgcookie_t *newcook;
  33
  34         if (!sess || !cookie)
  35                 return -EINVAL;
  36
  37         newcook = aim_checkcookie(sess, cookie->cookie, cookie->type);
  38
  39         if (newcook == cookie) {
  40                 newcook->addtime = time(NULL);
  41                 return 1;
  42         } else if (newcook)
  43                 aim_cookie_free(sess, newcook);
  44
  45         cookie->addtime = time(NULL);
  46
  47         cookie->next = sess->msgcookies;
  48         sess->msgcookies = cookie;
  49
  50         return 0;
  51 }
  52
  53 /**
  54  * aim_uncachecookie - grabs a cookie from the cookie cache (removes it from the list)
  55  * @sess: session to grab cookie from
  56  * @cookie: cookie string to look for
  57  * @type: cookie type to look for
  58  *
  59  * takes a cookie string and a cookie type and finds the cookie struct associated with that duple, removing it from the cookie list ikn the process.
  60  *
  61  * if found, returns the struct; if none found (or on error), returns NULL:
  62  */
  63 faim_internal aim_msgcookie_t *aim_uncachecookie(aim_session_t *sess, fu8_t *cookie, int type)
  64 {
  65         aim_msgcookie_t *cur, **prev;
  66
  67         if (!cookie || !sess->msgcookies)
  68                 return NULL;
  69
  70         for (prev = &sess->msgcookies; (cur = *prev); ) {
  71                 if ((cur->type == type) &&
  72                                 (memcmp(cur->cookie, cookie, 8) == 0)) {
  73                         *prev = cur->next;
  74                         return cur;
  75                 }
  76                 prev = &cur->next;
  77         }
  78
  79         return NULL;
  80 }
  81
  82 /**
  83  * aim_mkcookie - generate an aim_msgcookie_t *struct from a cookie string, a type, and a data pointer.
  84  * @c: pointer to the cookie string array
  85  * @type: cookie type to use
  86  * @data: data to be cached with the cookie
  87  *
  88  * returns NULL on error, a pointer to the newly-allocated cookie on
  89  * success.
  90  *
  91  */
  92 faim_internal aim_msgcookie_t *aim_mkcookie(fu8_t *c, int type, void *data)
  93 {
  94         aim_msgcookie_t *cookie;
  95
  96         if (!c)
  97                 return NULL;
  98
  99         if (!(cookie = calloc(1, sizeof(aim_msgcookie_t))))
 100                 return NULL;
 101
 102         cookie->data = data;
 103         cookie->type = type;
 104         memcpy(cookie->cookie, c, 8);
 105
 106         return cookie;
 107 }
 108
 109 /**
 110  * aim_checkcookie - check to see if a cookietuple has been cached
 111  * @sess: session to check for the cookie in
 112  * @cookie: pointer to the cookie string array
 113  * @type: type of the cookie to look for
 114  *
 115  * this returns a pointer to the cookie struct (still in the list) on
 116  * success; returns NULL on error/not found
 117  *
 118  */
 119
 120 faim_internal aim_msgcookie_t *aim_checkcookie(aim_session_t *sess, const fu8_t *cookie, int type)
 121 {
 122         aim_msgcookie_t *cur;
 123
 124         for (cur = sess->msgcookies; cur; cur = cur->next) {
 125                 if ((cur->type == type) &&
 126                                 (memcmp(cur->cookie, cookie, 8) == 0))
 127                         return cur;
 128         }
 129
 130         return NULL;
 131 }
 132
 133 #if 0 /* debugging feature */
 134 faim_internal int aim_dumpcookie(aim_msgcookie_t *cookie)
 135 {
 136
 137         if (!cookie)
 138                 return -EINVAL;
 139
 140         printf("\tCookie at %p: %d/%s with %p, next %p\n",
 141                         cookie, cookie->type, cookie->cookie,
 142                         cookie->data, cookie->next);
 143
 144         return 0;
 145 }
 146 #endif
 147
 148 /**
 149  * aim_cookie_free - free an aim_msgcookie_t struct
 150  * @sess: session to remove the cookie from
 151  * @cookiep: the address of a pointer to the cookie struct to remove
 152  *
 153  * this function removes the cookie *cookie from teh list of cookies
 154  * in sess, and then frees all memory associated with it. including
 155  * its data! if you want to use the private data after calling this,
 156  * make sure you copy it first.
 157  *
 158  * returns -1 on error, 0 on success.
 159  *
 160  */
 161 faim_internal int aim_cookie_free(aim_session_t *sess, aim_msgcookie_t *cookie)
 162 {
 163         aim_msgcookie_t *cur, **prev;
 164
 165         if (!sess || !cookie)
 166                 return -EINVAL;
 167
 168         for (prev = &sess->msgcookies; (cur = *prev); ) {
 169                 if (cur == cookie)
 170                         *prev = cur->next;
 171                 else
 172                         prev = &cur->next;
 173         }
 174
 175         free(cookie->data);
 176         free(cookie);
 177
 178         return 0;
 179 }
 180
 181 /* XXX I hate switch */
 182 faim_internal int aim_msgcookie_gettype(int reqclass)
 183 {
 184         /* XXX: hokey-assed. needs fixed. */
 185         switch(reqclass) {
 186         case AIM_CAPS_BUDDYICON: return AIM_COOKIETYPE_OFTICON;
 187         case AIM_CAPS_VOICE: return AIM_COOKIETYPE_OFTVOICE;
 188         case AIM_CAPS_IMIMAGE: return AIM_COOKIETYPE_OFTIMAGE;
 189         case AIM_CAPS_CHAT: return AIM_COOKIETYPE_CHAT;
 190         case AIM_CAPS_GETFILE: return AIM_COOKIETYPE_OFTGET;
 191         case AIM_CAPS_SENDFILE: return AIM_COOKIETYPE_OFTSEND;
 192         default: return AIM_COOKIETYPE_UNKNOWN;
 193         }
 194 }
 195
 196