]>
Commit | Line | Data |
---|---|---|
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(struct aim_session_t *sess, | |
31 | struct aim_msgcookie_t *cookie) | |
32 | { | |
33 | struct aim_msgcookie_t *newcook; | |
34 | ||
35 | if (!sess || !cookie) | |
36 | return -1; | |
37 | ||
38 | if( (newcook = aim_checkcookie(sess, cookie->cookie, cookie->type)) ) { | |
39 | if(newcook != cookie) { | |
40 | aim_cookie_free(sess, newcook); | |
41 | } else { | |
42 | newcook->addtime = time(NULL); | |
43 | return 1; | |
44 | } | |
45 | } | |
46 | ||
47 | cookie->addtime = time(NULL); | |
48 | ||
49 | cookie->next = sess->msgcookies; | |
50 | sess->msgcookies = cookie; | |
51 | ||
52 | return 0; | |
53 | } | |
54 | ||
55 | /** | |
56 | * aim_uncachecookie - grabs a cookie from the cookie cache (removes it from the list) | |
57 | * @sess: session to grab cookie from | |
58 | * @cookie: cookie string to look for | |
59 | * @type: cookie type to look for | |
60 | * | |
61 | * 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. | |
62 | * | |
63 | * if found, returns the struct; if none found (or on error), returns NULL: | |
64 | */ | |
65 | faim_internal struct aim_msgcookie_t *aim_uncachecookie(struct aim_session_t *sess, unsigned char *cookie, int type) | |
66 | { | |
67 | struct aim_msgcookie_t *cur, **prev; | |
68 | ||
69 | if (!cookie || !sess->msgcookies) | |
70 | return NULL; | |
71 | ||
72 | for (prev = &sess->msgcookies; (cur = *prev); ) { | |
73 | if ((cur->type == type) && | |
74 | (memcmp(cur->cookie, cookie, 8) == 0)) { | |
75 | *prev = cur->next; | |
76 | return cur; | |
77 | } | |
78 | prev = &cur->next; | |
79 | } | |
80 | ||
81 | return NULL; | |
82 | } | |
83 | ||
84 | /** | |
85 | * aim_mkcookie - generate an aim_msgcookie_t *struct from a cookie string, a type, and a data pointer. | |
86 | * @c: pointer to the cookie string array | |
87 | * @type: cookie type to use | |
88 | * @data: data to be cached with the cookie | |
89 | * | |
90 | * returns NULL on error, a pointer to the newly-allocated cookie on | |
91 | * success. | |
92 | * | |
93 | */ | |
94 | faim_internal struct aim_msgcookie_t *aim_mkcookie(unsigned char *c, int type, void *data) | |
95 | { | |
96 | struct aim_msgcookie_t *cookie; | |
97 | ||
98 | if (!c) | |
99 | return NULL; | |
100 | ||
101 | if (!(cookie = calloc(1, sizeof(struct aim_msgcookie_t)))) | |
102 | return NULL; | |
103 | ||
104 | cookie->data = data; | |
105 | cookie->type = type; | |
106 | memcpy(cookie->cookie, c, 8); | |
107 | ||
108 | return cookie; | |
109 | } | |
110 | ||
111 | /** | |
112 | * aim_checkcookie - check to see if a cookietuple has been cached | |
113 | * @sess: session to check for the cookie in | |
114 | * @cookie: pointer to the cookie string array | |
115 | * @type: type of the cookie to look for | |
116 | * | |
117 | * this returns a pointer to the cookie struct (still in the list) on | |
118 | * success; returns NULL on error/not found | |
119 | * | |
120 | */ | |
121 | ||
122 | faim_internal struct aim_msgcookie_t *aim_checkcookie(struct aim_session_t *sess, | |
123 | const unsigned char *cookie, | |
124 | const int type) | |
125 | { | |
126 | struct aim_msgcookie_t *cur; | |
127 | ||
128 | for (cur = sess->msgcookies; cur; cur = cur->next) { | |
129 | if ((cur->type == type) && | |
130 | (memcmp(cur->cookie, cookie, 8) == 0)) | |
131 | return cur; | |
132 | } | |
133 | ||
134 | return NULL; | |
135 | } | |
136 | ||
137 | #if 0 /* debugging feature */ | |
138 | faim_internal int aim_dumpcookie(struct aim_msgcookie_t *cookie) | |
139 | { | |
140 | if(!cookie) | |
141 | return -1; | |
142 | printf("\tCookie at %p: %d/%s with %p, next %p\n", cookie, cookie->type, cookie->cookie, cookie->data, cookie->next); | |
143 | return 0; | |
144 | } | |
145 | #endif | |
146 | ||
147 | /** | |
148 | * aim_cookie_free - free an aim_msgcookie_t struct | |
149 | * @sess: session to remove the cookie from | |
150 | * @cookiep: the address of a pointer to the cookie struct to remove | |
151 | * | |
152 | * this function removes the cookie *cookie from teh list of cookies | |
153 | * in sess, and then frees all memory associated with it. including | |
154 | * its data! if you want to use the private data after calling this, | |
155 | * make sure you copy it first. | |
156 | * | |
157 | * returns -1 on error, 0 on success. | |
158 | * | |
159 | */ | |
160 | ||
161 | faim_internal int aim_cookie_free(struct aim_session_t *sess, | |
162 | struct aim_msgcookie_t *cookie) | |
163 | { | |
164 | struct aim_msgcookie_t *cur, **prev; | |
165 | ||
166 | if (!sess || !cookie) | |
167 | return -1; | |
168 | ||
169 | if(!cookie) | |
170 | return 0; | |
171 | ||
172 | for (prev = &sess->msgcookies; (cur = *prev); ) { | |
173 | if (cur == cookie) { | |
174 | *prev = cur->next; | |
175 | } else | |
176 | prev = &cur->next; | |
177 | } | |
178 | ||
179 | if(cookie->data) | |
180 | free(cookie->data); | |
181 | ||
182 | free(cookie); | |
183 | ||
184 | return 0; | |
185 | } | |
186 | ||
187 | faim_internal int aim_msgcookie_gettype(int reqclass) { | |
188 | /* XXX: hokey-assed. needs fixed. */ | |
189 | switch(reqclass) { | |
190 | case AIM_CAPS_BUDDYICON: | |
191 | return AIM_COOKIETYPE_OFTICON; | |
192 | break; | |
193 | case AIM_CAPS_VOICE: | |
194 | return AIM_COOKIETYPE_OFTVOICE; | |
195 | break; | |
196 | case AIM_CAPS_IMIMAGE: | |
197 | return AIM_COOKIETYPE_OFTIMAGE; | |
198 | break; | |
199 | case AIM_CAPS_CHAT: | |
200 | return AIM_COOKIETYPE_CHAT; | |
201 | break; | |
202 | case AIM_CAPS_GETFILE: | |
203 | return AIM_COOKIETYPE_OFTGET; | |
204 | break; | |
205 | case AIM_CAPS_SENDFILE: | |
206 | return AIM_COOKIETYPE_OFTSEND; | |
207 | break; | |
208 | default: | |
209 | return AIM_COOKIETYPE_UNKNOWN; | |
210 | break; | |
211 | } | |
212 | } |