14192
|
1 /*
|
|
2 * gaim
|
|
3 *
|
|
4 * Gaim is the legal property of its developers, whose names are too numerous
|
|
5 * to list here. Please refer to the COPYRIGHT file distributed with this
|
|
6 * source distribution.
|
|
7 *
|
|
8 * This program is free software; you can redistribute it and/or modify
|
|
9 * it under the terms of the GNU General Public License as published by
|
|
10 * the Free Software Foundation; either version 2 of the License, or
|
|
11 * (at your option) any later version.
|
|
12 *
|
|
13 * This program is distributed in the hope that it will be useful,
|
|
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
16 * GNU General Public License for more details.
|
|
17 *
|
|
18 * You should have received a copy of the GNU General Public License
|
|
19 * along with this program; if not, write to the Free Software
|
|
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
21 *
|
|
22 */
|
|
23
|
|
24 #include "internal.h"
|
|
25 #include "debug.h"
|
|
26
|
|
27 #include "yahoo.h"
|
|
28 #include "yahoo_packet.h"
|
|
29
|
|
30 struct yahoo_packet *yahoo_packet_new(enum yahoo_service service, enum yahoo_status status, int id)
|
|
31 {
|
|
32 struct yahoo_packet *pkt = g_new0(struct yahoo_packet, 1);
|
|
33
|
|
34 pkt->service = service;
|
|
35 pkt->status = status;
|
|
36 pkt->id = id;
|
|
37
|
|
38 return pkt;
|
|
39 }
|
|
40
|
|
41 void yahoo_packet_hash_str(struct yahoo_packet *pkt, int key, const char *value)
|
|
42 {
|
|
43 struct yahoo_pair *pair;
|
|
44
|
|
45 g_return_if_fail(value != NULL);
|
|
46
|
|
47 pair = g_new0(struct yahoo_pair, 1);
|
|
48 pair->key = key;
|
|
49 pair->value = g_strdup(value);
|
|
50 pkt->hash = g_slist_prepend(pkt->hash, pair);
|
|
51 }
|
|
52
|
|
53 void yahoo_packet_hash_int(struct yahoo_packet *pkt, int key, int value)
|
|
54 {
|
|
55 struct yahoo_pair *pair;
|
|
56
|
|
57 pair = g_new0(struct yahoo_pair, 1);
|
|
58 pair->key = key;
|
|
59 pair->value = g_strdup_printf("%d", value);
|
|
60 pkt->hash = g_slist_prepend(pkt->hash, pair);
|
|
61 }
|
|
62
|
|
63 void yahoo_packet_hash(struct yahoo_packet *pkt, const char *fmt, ...)
|
|
64 {
|
|
65 char *strval;
|
|
66 int key, intval;
|
|
67 const char *cur;
|
|
68 va_list ap;
|
|
69
|
|
70 va_start(ap, fmt);
|
|
71 for (cur = fmt; *cur; cur++) {
|
|
72 key = va_arg(ap, int);
|
|
73 switch (*cur) {
|
|
74 case 'i':
|
|
75 intval = va_arg(ap, int);
|
|
76 yahoo_packet_hash_int(pkt, key, intval);
|
|
77 break;
|
|
78 case 's':
|
|
79 strval = va_arg(ap, char *);
|
|
80 yahoo_packet_hash_str(pkt, key, strval);
|
|
81 break;
|
|
82 default:
|
|
83 gaim_debug_error("yahoo", "Invalid format character '%c'\n", *cur);
|
|
84 break;
|
|
85 }
|
|
86 }
|
|
87 va_end(ap);
|
|
88 }
|
|
89
|
|
90 size_t yahoo_packet_length(struct yahoo_packet *pkt)
|
|
91 {
|
|
92 GSList *l;
|
|
93
|
|
94 size_t len = 0;
|
|
95
|
|
96 l = pkt->hash;
|
|
97 while (l) {
|
|
98 struct yahoo_pair *pair = l->data;
|
|
99 int tmp = pair->key;
|
|
100 do {
|
|
101 tmp /= 10;
|
|
102 len++;
|
|
103 } while (tmp);
|
|
104 len += 2;
|
|
105 len += strlen(pair->value);
|
|
106 len += 2;
|
|
107 l = l->next;
|
|
108 }
|
|
109
|
|
110 return len;
|
|
111 }
|
|
112
|
|
113 void yahoo_packet_read(struct yahoo_packet *pkt, const guchar *data, int len)
|
|
114 {
|
|
115 int pos = 0;
|
14259
|
116 char key[64], *delimiter;
|
14192
|
117 gboolean accept;
|
|
118 int x;
|
|
119 struct yahoo_pair *pair;
|
|
120
|
|
121 while (pos + 1 < len)
|
|
122 {
|
|
123 /* this is weird, and in one of the chat packets, and causes us to
|
|
124 * think all the values are keys and all the keys are values after
|
|
125 * this point if we don't handle it */
|
|
126 if (data[pos] == '\0') {
|
|
127 while (pos + 1 < len) {
|
|
128 if (data[pos] == 0xc0 && data[pos + 1] == 0x80)
|
|
129 break;
|
|
130 pos++;
|
|
131 }
|
|
132 pos += 2;
|
|
133 continue;
|
|
134 }
|
|
135
|
|
136 pair = g_new0(struct yahoo_pair, 1);
|
|
137
|
|
138 x = 0;
|
|
139 while (pos + 1 < len) {
|
|
140 if (data[pos] == 0xc0 && data[pos + 1] == 0x80)
|
|
141 break;
|
|
142 if (x >= sizeof(key)-1) {
|
|
143 x++;
|
|
144 pos++;
|
|
145 continue;
|
|
146 }
|
|
147 key[x++] = data[pos++];
|
|
148 }
|
|
149 if (x >= sizeof(key)-1) {
|
|
150 x = 0;
|
|
151 }
|
|
152 key[x] = 0;
|
|
153 pos += 2;
|
|
154 pair->key = strtol(key, NULL, 10);
|
|
155 accept = x; /* if x is 0 there was no key, so don't accept it */
|
|
156
|
|
157 if (len - pos + 1 <= 0) {
|
|
158 /* Truncated. Garbage or something. */
|
|
159 accept = FALSE;
|
|
160 }
|
|
161
|
|
162 if (accept) {
|
|
163 delimiter = strstr((char *)&data[pos], "\xc0\x80");
|
|
164 if (delimiter == NULL)
|
|
165 {
|
|
166 /* Malformed packet! (it doesn't end in 0xc0 0x80) */
|
|
167 g_free(pair);
|
|
168 pos = len;
|
|
169 continue;
|
|
170 }
|
|
171 x = (guint64)delimiter - (guint64)data;
|
|
172 pair->value = g_strndup((const gchar *)&data[pos], x - pos);
|
|
173 pos = x;
|
|
174 pkt->hash = g_slist_prepend(pkt->hash, pair);
|
|
175
|
|
176 #ifdef DEBUG
|
14259
|
177 {
|
|
178 char *esc;
|
|
179 esc = g_strescape(pair->value, NULL);
|
|
180 gaim_debug(GAIM_DEBUG_MISC, "yahoo",
|
|
181 "Key: %d \tValue: %s\n", pair->key, esc);
|
|
182 g_free(esc);
|
|
183 }
|
14192
|
184 #endif
|
|
185 } else {
|
|
186 g_free(pair);
|
|
187 }
|
|
188 pos += 2;
|
|
189
|
|
190 /* Skip over garbage we've noticed in the mail notifications */
|
|
191 if (data[0] == '9' && data[pos] == 0x01)
|
|
192 pos++;
|
|
193 }
|
|
194
|
|
195 /*
|
|
196 * Originally this function used g_slist_append(). I changed
|
|
197 * it to use g_slist_prepend() for improved performance.
|
|
198 * Ideally the Yahoo! PRPL code would be indifferent to the
|
|
199 * order of the key/value pairs, but I don't know if this is
|
|
200 * the case for all incoming messages. To be on the safe side
|
|
201 * we reverse the list.
|
|
202 */
|
|
203 pkt->hash = g_slist_reverse(pkt->hash);
|
|
204 }
|
|
205
|
|
206 void yahoo_packet_write(struct yahoo_packet *pkt, guchar *data)
|
|
207 {
|
|
208 GSList *l = pkt->hash;
|
|
209 int pos = 0;
|
|
210
|
|
211 while (l) {
|
|
212 struct yahoo_pair *pair = l->data;
|
|
213 gchar buf[100];
|
|
214
|
|
215 g_snprintf(buf, sizeof(buf), "%d", pair->key);
|
|
216 strcpy((char *)&data[pos], buf);
|
|
217 pos += strlen(buf);
|
|
218 data[pos++] = 0xc0;
|
|
219 data[pos++] = 0x80;
|
|
220
|
|
221 strcpy((char *)&data[pos], pair->value);
|
|
222 pos += strlen(pair->value);
|
|
223 data[pos++] = 0xc0;
|
|
224 data[pos++] = 0x80;
|
|
225
|
|
226 l = l->next;
|
|
227 }
|
|
228 }
|
|
229
|
|
230 void yahoo_packet_dump(guchar *data, int len)
|
|
231 {
|
|
232 #ifdef YAHOO_DEBUG
|
|
233 int i;
|
|
234
|
|
235 gaim_debug(GAIM_DEBUG_MISC, "yahoo", "");
|
|
236
|
|
237 for (i = 0; i + 1 < len; i += 2) {
|
|
238 if ((i % 16 == 0) && i) {
|
|
239 gaim_debug(GAIM_DEBUG_MISC, NULL, "\n");
|
|
240 gaim_debug(GAIM_DEBUG_MISC, "yahoo", "");
|
|
241 }
|
|
242
|
|
243 gaim_debug(GAIM_DEBUG_MISC, NULL, "%02x%02x ", data[i], data[i + 1]);
|
|
244 }
|
|
245 if (i < len)
|
|
246 gaim_debug(GAIM_DEBUG_MISC, NULL, "%02x", data[i]);
|
|
247
|
|
248 gaim_debug(GAIM_DEBUG_MISC, NULL, "\n");
|
|
249 gaim_debug(GAIM_DEBUG_MISC, "yahoo", "");
|
|
250
|
|
251 for (i = 0; i < len; i++) {
|
|
252 if ((i % 16 == 0) && i) {
|
|
253 gaim_debug(GAIM_DEBUG_MISC, NULL, "\n");
|
|
254 gaim_debug(GAIM_DEBUG_MISC, "yahoo", "");
|
|
255 }
|
|
256
|
|
257 if (g_ascii_isprint(data[i]))
|
|
258 gaim_debug(GAIM_DEBUG_MISC, NULL, "%c ", data[i]);
|
|
259 else
|
|
260 gaim_debug(GAIM_DEBUG_MISC, NULL, ". ");
|
|
261 }
|
|
262
|
|
263 gaim_debug(GAIM_DEBUG_MISC, NULL, "\n");
|
|
264 #endif
|
|
265 }
|
|
266
|
|
267 static void
|
|
268 yahoo_packet_send_can_write(gpointer data, gint source, GaimInputCondition cond)
|
|
269 {
|
|
270 struct yahoo_data *yd = data;
|
|
271 int ret, writelen;
|
|
272
|
|
273 writelen = gaim_circ_buffer_get_max_read(yd->txbuf);
|
|
274
|
|
275 if (writelen == 0) {
|
|
276 gaim_input_remove(yd->txhandler);
|
|
277 yd->txhandler = -1;
|
|
278 return;
|
|
279 }
|
|
280
|
|
281 ret = write(yd->fd, yd->txbuf->outptr, writelen);
|
|
282
|
|
283 if (ret < 0 && errno == EAGAIN)
|
|
284 return;
|
|
285 else if (ret < 0) {
|
|
286 /* TODO: what to do here - do we really have to disconnect? */
|
|
287 gaim_connection_error(yd->gc, _("Write Error"));
|
|
288 return;
|
|
289 }
|
|
290
|
|
291 gaim_circ_buffer_mark_read(yd->txbuf, ret);
|
|
292 }
|
|
293
|
|
294
|
|
295 size_t yahoo_packet_build(struct yahoo_packet *pkt, int pad, gboolean wm,
|
|
296 guchar **buf)
|
|
297 {
|
|
298 size_t pktlen = yahoo_packet_length(pkt);
|
|
299 size_t len = YAHOO_PACKET_HDRLEN + pktlen;
|
|
300 guchar *data;
|
|
301 int pos = 0;
|
|
302
|
|
303 data = g_malloc0(len + 1);
|
|
304
|
|
305 memcpy(data + pos, "YMSG", 4); pos += 4;
|
|
306
|
|
307 if (wm)
|
|
308 pos += yahoo_put16(data + pos, YAHOO_WEBMESSENGER_PROTO_VER);
|
|
309 else
|
|
310 pos += yahoo_put16(data + pos, YAHOO_PROTO_VER);
|
|
311 pos += yahoo_put16(data + pos, 0x0000);
|
|
312 pos += yahoo_put16(data + pos, pktlen + pad);
|
|
313 pos += yahoo_put16(data + pos, pkt->service);
|
|
314 pos += yahoo_put32(data + pos, pkt->status);
|
|
315 pos += yahoo_put32(data + pos, pkt->id);
|
|
316
|
|
317 yahoo_packet_write(pkt, data + pos);
|
|
318
|
|
319 *buf = data;
|
|
320
|
|
321 return len;
|
|
322 }
|
|
323
|
|
324 int yahoo_packet_send(struct yahoo_packet *pkt, struct yahoo_data *yd)
|
|
325 {
|
|
326 size_t len;
|
|
327 int ret;
|
|
328 guchar *data;
|
|
329
|
|
330 if (yd->fd < 0)
|
|
331 return -1;
|
|
332
|
|
333 len = yahoo_packet_build(pkt, 0, yd->wm, &data);
|
|
334
|
|
335 yahoo_packet_dump(data, len);
|
|
336 if (yd->txhandler == -1)
|
|
337 ret = write(yd->fd, data, len);
|
|
338 else {
|
|
339 ret = -1;
|
|
340 errno = EAGAIN;
|
|
341 }
|
|
342
|
|
343 if (ret < 0 && errno == EAGAIN)
|
|
344 ret = 0;
|
|
345 else if (ret <= 0) {
|
|
346 gaim_debug_warning("yahoo", "Only wrote %d of %d bytes!", ret, len);
|
|
347 g_free(data);
|
|
348 return ret;
|
|
349 }
|
|
350
|
|
351 if (ret < len) {
|
|
352 if (yd->txhandler == -1)
|
|
353 yd->txhandler = gaim_input_add(yd->fd, GAIM_INPUT_WRITE,
|
|
354 yahoo_packet_send_can_write, yd);
|
|
355 gaim_circ_buffer_append(yd->txbuf, data + ret, len - ret);
|
|
356 }
|
|
357
|
|
358 g_free(data);
|
|
359
|
|
360 return ret;
|
|
361 }
|
|
362
|
|
363 int yahoo_packet_send_and_free(struct yahoo_packet *pkt, struct yahoo_data *yd)
|
|
364 {
|
|
365 int ret;
|
|
366
|
|
367 ret = yahoo_packet_send(pkt, yd);
|
|
368 yahoo_packet_free(pkt);
|
|
369 return ret;
|
|
370 }
|
|
371
|
|
372 void yahoo_packet_free(struct yahoo_packet *pkt)
|
|
373 {
|
|
374 while (pkt->hash) {
|
|
375 struct yahoo_pair *pair = pkt->hash->data;
|
|
376 g_free(pair->value);
|
|
377 g_free(pair);
|
|
378 pkt->hash = g_slist_remove(pkt->hash, pair);
|
|
379 }
|
|
380 g_free(pkt);
|
|
381 }
|