Mercurial > pidgin.yaz
annotate src/protocols/oscar/ft.c @ 5414:2d9f7d2e3558
[gaim-migrate @ 5790]
Removed faim_shortfunc, which was supposed to make 2 functions be
declared as inline. There was a patch saying this caused problems
with systems where inline was redefined to be something else in
config.h, and I would rather not have config.h included in libfaim
files.
I'm also think the speed difference between having inline and not
having it for these 2 functions is negligible, especially when not
compiling with -Oanything.
committer: Tailor Script <tailor@pidgin.im>
author | Mark Doliner <mark@kingant.net> |
---|---|
date | Sat, 17 May 2003 18:41:02 +0000 |
parents | ac9ca88d4b25 |
children | 2141e33513ef |
rev | line source |
---|---|
2086 | 1 /* |
4617 | 2 * Oscar File transfer (OFT) and Oscar Direct Connect (ODC). |
3 * (ODC is also referred to as DirectIM and IM Image.) | |
4 * | |
5 * There are a few static helper functions at the top, then | |
6 * ODC stuff, then ft stuff. | |
7 * | |
8 * I feel like this is a good place to explain OFT, so I'm going to | |
9 * do just that. Each OFT packet has a header type. I guess this | |
10 * is pretty similar to the subtype of a SNAC packet. The type | |
11 * basically tells the other client the meaning of the OFT packet. | |
12 * There are two distinct types of file transfer, which I usually | |
13 * call "sendfile" and "getfile." Sendfile is when you send a file | |
14 * to another AIM user. Getfile is when you share a group of files, | |
15 * and other users request that you send them the files. | |
16 * | |
17 * A typical sendfile file transfer goes like this: | |
18 * 1) Sender sends a channel 2 ICBM telling the other user that | |
19 * we want to send them a file. At the same time, we open a | |
20 * listener socket (this should be done before sending the | |
21 * ICBM) on some port, and wait for them to connect to us. | |
22 * The ICBM we sent should contain our IP address and the port | |
23 * number that we're listening on. | |
24 * 2) The receiver connects to the sender on the given IP address | |
25 * and port. After the connection is established, the receiver | |
5146 | 26 * sends an ICBM signifying that we are ready and waiting. |
4617 | 27 * 3) The sender sends an OFT PROMPT message over the OFT |
28 * connection. | |
29 * 4) The receiver of the file sends back an exact copy of this | |
30 * OFT packet, except the cookie is filled in with the cookie | |
31 * from the ICBM. I think this might be an attempt to verify | |
32 * that the user that is connected is actually the guy that | |
33 * we sent the ICBM to. Oh, I've been calling this the ACK. | |
34 * 5) The sender starts sending raw data across the connection | |
35 * until the entire file has been sent. | |
36 * 6) The receiver knows the file is finished because the sender | |
37 * sent the file size in an earlier OFT packet. So then the | |
5146 | 38 * receiver sends the DONE thingy (after filling in the |
39 * "received" checksum and size) and closes the connection. | |
2086 | 40 */ |
41 | |
42 #define FAIM_INTERNAL | |
43 #include <aim.h> | |
44 | |
45 #ifndef _WIN32 | |
46 #include <netdb.h> | |
47 #include <sys/socket.h> | |
48 #include <netinet/in.h> | |
4617 | 49 #include <sys/utsname.h> /* for aim_odc_initiate */ |
3630 | 50 #include <arpa/inet.h> /* for inet_ntoa */ |
3960 | 51 #define G_DIR_SEPARATOR '/' |
3646
bfd8df165f32
[gaim-migrate @ 3770]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
3630
diff
changeset
|
52 #endif |
bfd8df165f32
[gaim-migrate @ 3770]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
3630
diff
changeset
|
53 |
bfd8df165f32
[gaim-migrate @ 3770]
Herman Bloggs <hermanator12002@yahoo.com>
parents:
3630
diff
changeset
|
54 #ifdef _WIN32 |
3630 | 55 #include "win32dep.h" |
56 #endif | |
2086 | 57 |
4617 | 58 struct aim_odc_intdata { |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
59 fu8_t cookie[8]; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
60 char sn[MAXSNLEN+1]; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
61 char ip[22]; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
62 }; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
63 |
4617 | 64 /** |
65 * Convert the directory separator from / (0x2f) to ^A (0x01) | |
66 * | |
67 * @param name The filename to convert. | |
68 */ | |
69 static void aim_oft_dirconvert_tostupid(char *name) | |
70 { | |
71 while (name[0]) { | |
72 if (name[0] == 0x01) | |
73 name[0] = G_DIR_SEPARATOR; | |
74 name++; | |
75 } | |
76 } | |
77 | |
78 /** | |
79 * Convert the directory separator from ^A (0x01) to / (0x2f) | |
80 * | |
81 * @param name The filename to convert. | |
82 */ | |
83 static void aim_oft_dirconvert_fromstupid(char *name) | |
84 { | |
85 while (name[0]) { | |
86 if (name[0] == G_DIR_SEPARATOR) | |
87 name[0] = 0x01; | |
88 name++; | |
89 } | |
90 } | |
91 | |
92 /** | |
93 * Calculate oft checksum of buffer | |
94 * | |
95 * Prevcheck should be 0xFFFF0000 when starting a checksum of a file. The | |
96 * checksum is kind of a rolling checksum thing, so each time you get bytes | |
97 * of a file you just call this puppy and it updates the checksum. You can | |
98 * calculate the checksum of an entire file by calling this in a while or a | |
99 * for loop, or something. | |
100 * | |
101 * Thanks to Graham Booker for providing this improved checksum routine, | |
102 * which is simpler and should be more accurate than Josh Myer's original | |
103 * code. -- wtm | |
104 * | |
105 * This algorithim works every time I have tried it. The other fails | |
106 * sometimes. So, AOL who thought this up? It has got to be the weirdest | |
107 * checksum I have ever seen. | |
108 * | |
109 * @param buffer Buffer of data to checksum. Man I'd like to buff her... | |
110 * @param bufsize Size of buffer. | |
111 * @param prevcheck Previous checksum. | |
112 */ | |
4763 | 113 faim_export fu32_t aim_oft_checksum_chunk(const fu8_t *buffer, int bufferlen, fu32_t prevcheck) |
4617 | 114 { |
115 fu32_t check = (prevcheck >> 16) & 0xffff, oldcheck; | |
116 int i; | |
117 unsigned short val; | |
118 | |
119 for (i=0; i<bufferlen; i++) { | |
120 oldcheck = check; | |
121 if (i&1) | |
122 val = buffer[i]; | |
123 else | |
124 val = buffer[i] << 8; | |
125 check -= val; | |
126 /* | |
127 * The following appears to be necessary.... It happens | |
128 * every once in a while and the checksum doesn't fail. | |
129 */ | |
130 if (check > oldcheck) | |
131 check--; | |
132 } | |
133 check = ((check & 0x0000ffff) + (check >> 16)); | |
134 check = ((check & 0x0000ffff) + (check >> 16)); | |
135 return check << 16; | |
136 } | |
137 | |
4650 | 138 faim_export fu32_t aim_oft_checksum_file(char *filename) { |
139 FILE *fd; | |
140 fu32_t checksum = 0xffff0000; | |
141 | |
142 if ((fd = fopen(filename, "rb"))) { | |
143 int bytes; | |
4763 | 144 fu8_t buffer[1024]; |
4650 | 145 |
146 while ((bytes = fread(buffer, 1, 1024, fd))) | |
147 checksum = aim_oft_checksum_chunk(buffer, bytes, checksum); | |
148 fclose(fd); | |
149 } | |
150 | |
151 return checksum; | |
152 } | |
153 | |
2086 | 154 /** |
4617 | 155 * Create a listening socket on a given port. |
156 * | |
157 * XXX - Give the client author the responsibility of setting up a | |
158 * listener, then we no longer have a libfaim problem with broken | |
159 * solaris *innocent smile* -- jbm | |
2086 | 160 * |
4617 | 161 * @param portnum The port number to bind to. |
162 * @return The file descriptor of the listening socket. | |
163 */ | |
164 static int listenestablish(fu16_t portnum) | |
165 { | |
166 #if HAVE_GETADDRINFO | |
167 int listenfd; | |
168 const int on = 1; | |
169 struct addrinfo hints, *res, *ressave; | |
170 char serv[5]; | |
171 | |
172 snprintf(serv, sizeof(serv), "%d", portnum); | |
173 memset(&hints, 0, sizeof(struct addrinfo)); | |
174 hints.ai_flags = AI_PASSIVE; | |
175 hints.ai_family = AF_UNSPEC; | |
176 hints.ai_socktype = SOCK_STREAM; | |
177 if (getaddrinfo(NULL /* any IP */, serv, &hints, &res) != 0) { | |
178 perror("getaddrinfo"); | |
179 return -1; | |
180 } | |
181 ressave = res; | |
182 do { | |
183 listenfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol); | |
184 if (listenfd < 0) | |
185 continue; | |
186 setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)); | |
187 if (bind(listenfd, res->ai_addr, res->ai_addrlen) == 0) | |
188 break; /* success */ | |
189 close(listenfd); | |
190 } while ( (res = res->ai_next) ); | |
191 | |
192 if (!res) | |
193 return -1; | |
194 | |
195 freeaddrinfo(ressave); | |
196 #else | |
197 int listenfd; | |
198 const int on = 1; | |
199 struct sockaddr_in sockin; | |
200 | |
201 if ((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { | |
202 perror("socket"); | |
203 return -1; | |
204 } | |
205 | |
206 if (setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, (char *)&on, sizeof(on)) != 0) { | |
207 perror("setsockopt"); | |
208 close(listenfd); | |
209 return -1; | |
210 } | |
211 | |
212 memset(&sockin, 0, sizeof(struct sockaddr_in)); | |
213 sockin.sin_family = AF_INET; | |
214 sockin.sin_port = htons(portnum); | |
215 | |
216 if (bind(listenfd, (struct sockaddr *)&sockin, sizeof(struct sockaddr_in)) != 0) { | |
217 perror("bind"); | |
218 close(listenfd); | |
219 return -1; | |
220 } | |
221 #endif | |
222 | |
223 if (listen(listenfd, 4) != 0) { | |
224 perror("listen"); | |
225 close(listenfd); | |
226 return -1; | |
227 } | |
228 fcntl(listenfd, F_SETFL, O_NONBLOCK); | |
229 | |
230 return listenfd; | |
231 } | |
232 | |
233 /** | |
234 * After establishing a listening socket, this is called to accept a connection. It | |
235 * clones the conn used by the listener, and passes both of these to a signal handler. | |
236 * The signal handler should close the listener conn and keep track of the new conn, | |
237 * since this is what is used for file transfers and what not. | |
238 * | |
239 * @param sess The session. | |
240 * @param cur The conn the incoming connection is on. | |
241 * @return Return 0 if no errors, otherwise return the error number. | |
2086 | 242 */ |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
243 faim_export int aim_handlerendconnect(aim_session_t *sess, aim_conn_t *cur) |
4617 | 244 { |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
245 int acceptfd = 0; |
4617 | 246 struct sockaddr addr; |
247 socklen_t addrlen = sizeof(addr); | |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
248 int ret = 0; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
249 aim_conn_t *newconn; |
4617 | 250 char ip[20]; |
251 int port; | |
2086 | 252 |
4617 | 253 if ((acceptfd = accept(cur->fd, &addr, &addrlen)) == -1) |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
254 return 0; /* not an error */ |
2086 | 255 |
4617 | 256 if (addr.sa_family != AF_INET) { /* just in case IPv6 really is happening */ |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
257 close(acceptfd); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
258 aim_conn_close(cur); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
259 return -1; |
4617 | 260 } |
261 | |
262 strncpy(ip, inet_ntoa(((struct sockaddr_in *)&addr)->sin_addr), sizeof(ip)); | |
263 port = ntohs(((struct sockaddr_in *)&addr)->sin_port); | |
2086 | 264 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
265 if (!(newconn = aim_cloneconn(sess, cur))) { |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
266 close(acceptfd); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
267 aim_conn_close(cur); |
4617 | 268 return -ENOMEM; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
269 } |
2086 | 270 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
271 newconn->type = AIM_CONN_TYPE_RENDEZVOUS; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
272 newconn->fd = acceptfd; |
2086 | 273 |
4617 | 274 if (newconn->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM) { |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
275 aim_rxcallback_t userfunc; |
4617 | 276 struct aim_odc_intdata *priv; |
2086 | 277 |
4617 | 278 priv = (struct aim_odc_intdata *)(newconn->internal = cur->internal); |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
279 cur->internal = NULL; |
4617 | 280 snprintf(priv->ip, sizeof(priv->ip), "%s:%u", ip, port); |
2086 | 281 |
4617 | 282 if ((userfunc = aim_callhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIM_ESTABLISHED))) |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
283 ret = userfunc(sess, NULL, newconn, cur); |
2086 | 284 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
285 } else if (newconn->subtype == AIM_CONN_SUBTYPE_OFT_GETFILE) { |
4617 | 286 } else if (newconn->subtype == AIM_CONN_SUBTYPE_OFT_SENDFILE) { |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
287 aim_rxcallback_t userfunc; |
2086 | 288 |
4617 | 289 if ((userfunc = aim_callhandler(sess, newconn, AIM_CB_FAM_OFT, AIM_CB_OFT_ESTABLISHED))) |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
290 ret = userfunc(sess, NULL, newconn, cur); |
3630 | 291 |
4617 | 292 } else { |
293 faimdprintf(sess, 1,"Got a connection on a listener that's not rendezvous. Closing connection.\n"); | |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
294 aim_conn_close(newconn); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
295 ret = -1; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
296 } |
2086 | 297 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
298 return ret; |
2086 | 299 } |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
300 |
2086 | 301 /** |
4617 | 302 * Send client-to-client typing notification over an established direct connection. |
2086 | 303 * |
4617 | 304 * @param sess The session. |
305 * @param conn The already-connected ODC connection. | |
4870 | 306 * @param typing If 0x0002, sends a "typing" message, 0x0001 sends "typed," and |
307 * 0x0000 sends "stopped." | |
4617 | 308 * @return Return 0 if no errors, otherwise return the error number. |
2086 | 309 */ |
4617 | 310 faim_export int aim_odc_send_typing(aim_session_t *sess, aim_conn_t *conn, int typing) |
2086 | 311 { |
4617 | 312 struct aim_odc_intdata *intdata = (struct aim_odc_intdata *)conn->internal; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
313 aim_frame_t *fr; |
3952 | 314 aim_bstream_t *hdrbs; |
315 fu8_t *hdr; | |
316 int hdrlen = 0x44; | |
2086 | 317 |
3952 | 318 if (!sess || !conn || (conn->type != AIM_CONN_TYPE_RENDEZVOUS)) |
319 return -EINVAL; | |
2086 | 320 |
4870 | 321 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_OFT, 0x0001, 0))) |
3952 | 322 return -ENOMEM; |
323 memcpy(fr->hdr.rend.magic, "ODC2", 4); | |
324 fr->hdr.rend.hdrlen = hdrlen; | |
2086 | 325 |
3952 | 326 if (!(hdr = calloc(1, hdrlen))) { |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
327 aim_frame_destroy(fr); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
328 return -ENOMEM; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
329 } |
3952 | 330 |
331 hdrbs = &(fr->data); | |
332 aim_bstream_init(hdrbs, hdr, hdrlen); | |
2086 | 333 |
3952 | 334 aimbs_put16(hdrbs, 0x0006); |
335 aimbs_put16(hdrbs, 0x0000); | |
336 aimbs_putraw(hdrbs, intdata->cookie, 8); | |
337 aimbs_put16(hdrbs, 0x0000); | |
338 aimbs_put16(hdrbs, 0x0000); | |
339 aimbs_put16(hdrbs, 0x0000); | |
340 aimbs_put16(hdrbs, 0x0000); | |
341 aimbs_put32(hdrbs, 0x00000000); | |
342 aimbs_put16(hdrbs, 0x0000); | |
343 aimbs_put16(hdrbs, 0x0000); | |
344 aimbs_put16(hdrbs, 0x0000); | |
2086 | 345 |
4870 | 346 if (typing == 0x0002) |
347 aimbs_put16(hdrbs, 0x0002 | 0x0008); | |
348 else if (typing == 0x0001) | |
349 aimbs_put16(hdrbs, 0x0002 | 0x0004); | |
350 else | |
351 aimbs_put16(hdrbs, 0x0002); | |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
352 |
3952 | 353 aimbs_put16(hdrbs, 0x0000); |
354 aimbs_put16(hdrbs, 0x0000); | |
355 aimbs_putraw(hdrbs, sess->sn, strlen(sess->sn)); | |
4617 | 356 |
3952 | 357 aim_bstream_setpos(hdrbs, 52); /* bleeehh */ |
2086 | 358 |
3952 | 359 aimbs_put8(hdrbs, 0x00); |
360 aimbs_put16(hdrbs, 0x0000); | |
361 aimbs_put16(hdrbs, 0x0000); | |
362 aimbs_put16(hdrbs, 0x0000); | |
363 aimbs_put16(hdrbs, 0x0000); | |
364 aimbs_put16(hdrbs, 0x0000); | |
365 aimbs_put16(hdrbs, 0x0000); | |
366 aimbs_put16(hdrbs, 0x0000); | |
367 aimbs_put8(hdrbs, 0x00); | |
2086 | 368 |
3952 | 369 /* end of hdr */ |
2086 | 370 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
371 aim_tx_enqueue(sess, fr); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
372 |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
373 return 0; |
4617 | 374 } |
2086 | 375 |
2993 | 376 /** |
4617 | 377 * Send client-to-client IM over an established direct connection. |
378 * Call this just like you would aim_send_im, to send a directim. | |
2993 | 379 * |
4617 | 380 * @param sess The session. |
381 * @param conn The already-connected ODC connection. | |
382 * @param msg Null-terminated string to send. | |
383 * @param len The length of the message to send, including binary data. | |
384 * @param encoding 0 for ascii, 2 for Unicode, 3 for ISO 8859-1. | |
4870 | 385 * @param isawaymsg 0 if this is not an auto-response, 1 if it is. |
4617 | 386 * @return Return 0 if no errors, otherwise return the error number. |
2993 | 387 */ |
4870 | 388 faim_export int aim_odc_send_im(aim_session_t *sess, aim_conn_t *conn, const char *msg, int len, int encoding, int isawaymsg) |
2993 | 389 { |
390 aim_frame_t *fr; | |
3952 | 391 aim_bstream_t *hdrbs; |
4617 | 392 struct aim_odc_intdata *intdata = (struct aim_odc_intdata *)conn->internal; |
3952 | 393 int hdrlen = 0x44; |
394 fu8_t *hdr; | |
2993 | 395 |
4617 | 396 if (!sess || !conn || (conn->type != AIM_CONN_TYPE_RENDEZVOUS) || !msg) |
397 return -EINVAL; | |
2993 | 398 |
4875 | 399 if (!(fr = aim_tx_new(sess, conn, AIM_FRAMETYPE_OFT, 0x01, 0))) |
4617 | 400 return -ENOMEM; |
2993 | 401 |
3952 | 402 memcpy(fr->hdr.rend.magic, "ODC2", 4); |
403 fr->hdr.rend.hdrlen = hdrlen; | |
4617 | 404 |
3952 | 405 if (!(hdr = calloc(1, hdrlen + len))) { |
2993 | 406 aim_frame_destroy(fr); |
407 return -ENOMEM; | |
408 } | |
3952 | 409 |
410 hdrbs = &(fr->data); | |
411 aim_bstream_init(hdrbs, hdr, hdrlen + len); | |
412 | |
413 aimbs_put16(hdrbs, 0x0006); | |
414 aimbs_put16(hdrbs, 0x0000); | |
415 aimbs_putraw(hdrbs, intdata->cookie, 8); | |
416 aimbs_put16(hdrbs, 0x0000); | |
417 aimbs_put16(hdrbs, 0x0000); | |
418 aimbs_put16(hdrbs, 0x0000); | |
419 aimbs_put16(hdrbs, 0x0000); | |
420 aimbs_put32(hdrbs, len); | |
421 aimbs_put16(hdrbs, encoding); | |
422 aimbs_put16(hdrbs, 0x0000); | |
423 aimbs_put16(hdrbs, 0x0000); | |
4617 | 424 |
4870 | 425 /* flags - used for typing notification and to mark if this is an away message */ |
426 aimbs_put16(hdrbs, 0x0000 | isawaymsg); | |
3952 | 427 |
428 aimbs_put16(hdrbs, 0x0000); | |
429 aimbs_put16(hdrbs, 0x0000); | |
430 aimbs_putraw(hdrbs, sess->sn, strlen(sess->sn)); | |
431 | |
432 aim_bstream_setpos(hdrbs, 52); /* bleeehh */ | |
433 | |
434 aimbs_put8(hdrbs, 0x00); | |
435 aimbs_put16(hdrbs, 0x0000); | |
436 aimbs_put16(hdrbs, 0x0000); | |
437 aimbs_put16(hdrbs, 0x0000); | |
438 aimbs_put16(hdrbs, 0x0000); | |
439 aimbs_put16(hdrbs, 0x0000); | |
440 aimbs_put16(hdrbs, 0x0000); | |
441 aimbs_put16(hdrbs, 0x0000); | |
442 aimbs_put8(hdrbs, 0x00); | |
4617 | 443 |
2993 | 444 /* end of hdr2 */ |
4617 | 445 |
446 #if 0 /* XXX - this is how you send buddy icon info... */ | |
447 aimbs_put16(hdrbs, 0x0008); | |
448 aimbs_put16(hdrbs, 0x000c); | |
449 aimbs_put16(hdrbs, 0x0000); | |
450 aimbs_put16(hdrbs, 0x1466); | |
451 aimbs_put16(hdrbs, 0x0001); | |
452 aimbs_put16(hdrbs, 0x2e0f); | |
453 aimbs_put16(hdrbs, 0x393e); | |
454 aimbs_put16(hdrbs, 0xcac8); | |
2993 | 455 #endif |
3952 | 456 aimbs_putraw(hdrbs, msg, len); |
4617 | 457 |
2993 | 458 aim_tx_enqueue(sess, fr); |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
459 |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
460 return 0; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
461 } |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
462 |
2086 | 463 /** |
4617 | 464 * Get the screen name of the peer of a direct connection. |
465 * | |
466 * @param conn The ODC connection. | |
467 * @return The screen name of the dude, or NULL if there was an anomaly. | |
2086 | 468 */ |
4617 | 469 faim_export const char *aim_odc_getsn(aim_conn_t *conn) |
470 { | |
471 struct aim_odc_intdata *intdata; | |
3630 | 472 |
4617 | 473 if (!conn || !conn->internal) |
3952 | 474 return NULL; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
475 |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
476 if ((conn->type != AIM_CONN_TYPE_RENDEZVOUS) || |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
477 (conn->subtype != AIM_CONN_SUBTYPE_OFT_DIRECTIM)) |
3952 | 478 return NULL; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
479 |
4617 | 480 intdata = (struct aim_odc_intdata *)conn->internal; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
481 |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
482 return intdata->sn; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
483 } |
2086 | 484 |
485 /** | |
4617 | 486 * Find the conn of a direct connection with the given buddy. |
487 * | |
488 * @param sess The session. | |
489 * @param sn The screen name of the buddy whose direct connection you want to find. | |
490 * @return The conn for the direct connection with the given buddy, or NULL if no | |
491 * connection was found. | |
492 */ | |
493 faim_export aim_conn_t *aim_odc_getconn(aim_session_t *sess, const char *sn) | |
494 { | |
495 aim_conn_t *cur; | |
496 struct aim_odc_intdata *intdata; | |
497 | |
498 if (!sess || !sn || !strlen(sn)) | |
499 return NULL; | |
500 | |
501 for (cur = sess->connlist; cur; cur = cur->next) { | |
502 if ((cur->type == AIM_CONN_TYPE_RENDEZVOUS) && (cur->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM)) { | |
503 intdata = cur->internal; | |
504 if (!aim_sncmp(intdata->sn, sn)) | |
505 return cur; | |
506 } | |
507 } | |
508 | |
509 return NULL; | |
510 } | |
511 | |
512 /** | |
513 * For those times when we want to open up the direct connection channel ourselves. | |
514 * | |
515 * You'll want to set up some kind of watcher on this socket. | |
516 * When the state changes, call aim_handlerendconnection with | |
517 * the connection returned by this. aim_handlerendconnection | |
518 * will accept the pending connection and stop listening. | |
519 * | |
520 * @param sess The session | |
521 * @param sn The screen name to connect to. | |
522 * @return The new connection. | |
523 */ | |
524 faim_export aim_conn_t *aim_odc_initiate(aim_session_t *sess, const char *sn) | |
525 { | |
526 aim_conn_t *newconn; | |
527 aim_msgcookie_t *cookie; | |
528 struct aim_odc_intdata *priv; | |
529 int listenfd; | |
530 fu16_t port = 4443; | |
531 fu8_t localip[4]; | |
532 fu8_t ck[8]; | |
533 | |
534 if (aim_util_getlocalip(localip) == -1) | |
535 return NULL; | |
536 | |
537 if ((listenfd = listenestablish(port)) == -1) | |
538 return NULL; | |
539 | |
540 aim_im_sendch2_odcrequest(sess, ck, sn, localip, port); | |
541 | |
542 cookie = (aim_msgcookie_t *)calloc(1, sizeof(aim_msgcookie_t)); | |
543 memcpy(cookie->cookie, ck, 8); | |
544 cookie->type = AIM_COOKIETYPE_OFTIM; | |
545 | |
546 /* this one is for the cookie */ | |
547 priv = (struct aim_odc_intdata *)calloc(1, sizeof(struct aim_odc_intdata)); | |
548 | |
549 memcpy(priv->cookie, ck, 8); | |
550 strncpy(priv->sn, sn, sizeof(priv->sn)); | |
551 cookie->data = priv; | |
552 aim_cachecookie(sess, cookie); | |
553 | |
554 /* XXX - switch to aim_cloneconn()? */ | |
555 if (!(newconn = aim_newconn(sess, AIM_CONN_TYPE_LISTENER, NULL))) { | |
556 close(listenfd); | |
557 return NULL; | |
558 } | |
559 | |
560 /* this one is for the conn */ | |
561 priv = (struct aim_odc_intdata *)calloc(1, sizeof(struct aim_odc_intdata)); | |
562 | |
563 memcpy(priv->cookie, ck, 8); | |
564 strncpy(priv->sn, sn, sizeof(priv->sn)); | |
565 | |
566 newconn->fd = listenfd; | |
567 newconn->subtype = AIM_CONN_SUBTYPE_OFT_DIRECTIM; | |
568 newconn->internal = priv; | |
569 newconn->lastactivity = time(NULL); | |
570 | |
571 return newconn; | |
572 } | |
573 | |
574 /** | |
575 * Connect directly to the given buddy for directim. | |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
576 * |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
577 * This is a wrapper for aim_newconn. |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
578 * |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
579 * If addr is NULL, the socket is not created, but the connection is |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
580 * allocated and setup to connect. |
2086 | 581 * |
4617 | 582 * @param sess The Godly session. |
583 * @param sn The screen name we're connecting to. I hope it's a girl... | |
584 * @param addr Address to connect to. | |
585 * @return The new connection. | |
2086 | 586 */ |
4617 | 587 faim_export aim_conn_t *aim_odc_connect(aim_session_t *sess, const char *sn, const char *addr, const fu8_t *cookie) |
588 { | |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
589 aim_conn_t *newconn; |
4617 | 590 struct aim_odc_intdata *intdata; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
591 |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
592 if (!sess || !sn) |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
593 return NULL; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
594 |
5146 | 595 if (!(intdata = calloc(1, sizeof(struct aim_odc_intdata)))) |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
596 return NULL; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
597 memcpy(intdata->cookie, cookie, 8); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
598 strncpy(intdata->sn, sn, sizeof(intdata->sn)); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
599 if (addr) |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
600 strncpy(intdata->ip, addr, sizeof(intdata->ip)); |
2086 | 601 |
4617 | 602 /* XXX - verify that non-blocking connects actually work */ |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
603 if (!(newconn = aim_newconn(sess, AIM_CONN_TYPE_RENDEZVOUS, addr))) { |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
604 free(intdata); |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
605 return NULL; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
606 } |
2086 | 607 |
4617 | 608 newconn->internal = intdata; |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
609 newconn->subtype = AIM_CONN_SUBTYPE_OFT_DIRECTIM; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
610 |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
611 return newconn; |
4617 | 612 } |
2086 | 613 |
614 /** | |
4826 | 615 * Sometimes you just don't know with these kinds of people. |
616 * | |
617 * @param sess The session. | |
618 * @param conn The ODC connection of the incoming data. | |
619 * @param frr The frame allocated for the incoming data. | |
620 * @param bs It stands for "bologna sandwich." | |
621 * @return Return 0 if no errors, otherwise return the error number. | |
622 */ | |
623 static int handlehdr_odc(aim_session_t *sess, aim_conn_t *conn, aim_frame_t *frr, aim_bstream_t *bs) | |
624 { | |
625 aim_frame_t fr; | |
4870 | 626 int ret = 0; |
4826 | 627 aim_rxcallback_t userfunc; |
628 fu32_t payloadlength; | |
629 fu16_t flags, encoding; | |
630 char *snptr = NULL; | |
631 | |
632 fr.conn = conn; | |
633 | |
634 /* AAA - ugly */ | |
635 aim_bstream_setpos(bs, 20); | |
636 payloadlength = aimbs_get32(bs); | |
637 | |
638 aim_bstream_setpos(bs, 24); | |
639 encoding = aimbs_get16(bs); | |
640 | |
641 aim_bstream_setpos(bs, 30); | |
642 flags = aimbs_get16(bs); | |
643 | |
644 aim_bstream_setpos(bs, 36); | |
645 /* XXX - create an aimbs_getnullstr function? */ | |
4913 | 646 snptr = aimbs_getstr(bs, 32); /* Next 32 bytes contain the sn, padded with null chars */ |
4826 | 647 |
648 faimdprintf(sess, 2, "faim: OFT frame: handlehdr_odc: %04x / %04x / %s\n", payloadlength, flags, snptr); | |
649 | |
4870 | 650 if (flags & 0x0008) { |
651 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING))) | |
652 ret = userfunc(sess, &fr, snptr, 2); | |
653 } else if (flags & 0x0004) { | |
654 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING))) | |
655 ret = userfunc(sess, &fr, snptr, 1); | |
656 } else { | |
4826 | 657 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMTYPING))) |
658 ret = userfunc(sess, &fr, snptr, 0); | |
4870 | 659 } |
4826 | 660 |
4870 | 661 if (payloadlength) { |
662 char *msg; | |
4826 | 663 int recvd = 0; |
4870 | 664 int i, isawaymsg; |
665 | |
666 isawaymsg = flags & 0x0001; | |
4826 | 667 |
4895 | 668 if (!(msg = calloc(1, payloadlength+1))) { |
669 free(snptr); | |
4870 | 670 return -ENOMEM; |
4895 | 671 } |
4870 | 672 |
4826 | 673 while (payloadlength - recvd) { |
674 if (payloadlength - recvd >= 1024) | |
4870 | 675 i = aim_recv(conn->fd, &msg[recvd], 1024); |
4826 | 676 else |
4870 | 677 i = aim_recv(conn->fd, &msg[recvd], payloadlength - recvd); |
4826 | 678 if (i <= 0) { |
679 free(msg); | |
4895 | 680 free(snptr); |
4826 | 681 return -1; |
682 } | |
683 recvd = recvd + i; | |
684 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_SPECIAL, AIM_CB_SPECIAL_IMAGETRANSFER))) | |
4870 | 685 ret = userfunc(sess, &fr, snptr, (double)recvd / payloadlength); |
4826 | 686 } |
687 | |
4870 | 688 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_OFT, AIM_CB_OFT_DIRECTIMINCOMING))) |
689 ret = userfunc(sess, &fr, snptr, msg, payloadlength, encoding, isawaymsg); | |
4826 | 690 |
691 free(msg); | |
692 } | |
693 | |
4895 | 694 free(snptr); |
695 | |
4870 | 696 return ret; |
4826 | 697 } |
698 | |
5146 | 699 faim_export struct aim_oft_info *aim_oft_createinfo(aim_session_t *sess, const fu8_t *cookie, const char *sn, const char *ip, fu16_t port, fu32_t size, fu32_t modtime, char *filename) |
700 { | |
701 struct aim_oft_info *new; | |
702 | |
703 if (!sess) | |
704 return NULL; | |
705 | |
706 if (!(new = (struct aim_oft_info *)calloc(1, sizeof(struct aim_oft_info)))) | |
707 return NULL; | |
708 | |
709 new->sess = sess; | |
710 if (cookie) | |
711 memcpy(new->cookie, cookie, 8); | |
712 if (ip) | |
713 new->clientip = strdup(ip); | |
714 if (sn) | |
715 new->sn = strdup(sn); | |
716 new->port = port; | |
717 new->fh.totfiles = 1; | |
718 new->fh.filesleft = 1; | |
719 new->fh.totparts = 1; | |
720 new->fh.partsleft = 1; | |
721 new->fh.totsize = size; | |
722 new->fh.size = size; | |
723 new->fh.modtime = modtime; | |
724 new->fh.checksum = 0xffff0000; | |
725 new->fh.rfrcsum = 0xffff0000; | |
726 new->fh.rfcsum = 0xffff0000; | |
727 new->fh.recvcsum = 0xffff0000; | |
728 strncpy(new->fh.idstring, "OFT_Windows ICBMFT V1.1 32", 31); | |
729 if (filename) | |
730 strncpy(new->fh.name, filename, 63); | |
731 | |
732 new->next = sess->oft_info; | |
733 sess->oft_info = new; | |
734 | |
735 return new; | |
736 } | |
737 | |
738 /** | |
739 * Remove the given oft_info struct from the oft_info linked list, and | |
740 * then free its memory. | |
741 * | |
742 * @param sess The session. | |
743 * @param oft_info The aim_oft_info struct that we're destroying. | |
744 * @return Return 0 if no errors, otherwise return the error number. | |
745 */ | |
746 faim_export int aim_oft_destroyinfo(struct aim_oft_info *oft_info) | |
747 { | |
748 aim_session_t *sess; | |
749 | |
750 if (!oft_info || !(sess = oft_info->sess)) | |
751 return -EINVAL; | |
752 | |
753 if (sess->oft_info && (sess->oft_info == oft_info)) { | |
754 sess->oft_info = sess->oft_info->next; | |
755 } else { | |
756 struct aim_oft_info *cur; | |
757 for (cur=sess->oft_info; (cur->next && (cur->next!=oft_info)); cur=cur->next); | |
758 if (cur->next) | |
759 cur->next = cur->next->next; | |
760 } | |
761 | |
762 free(oft_info->sn); | |
763 free(oft_info->proxyip); | |
764 free(oft_info->clientip); | |
765 free(oft_info->verifiedip); | |
766 free(oft_info); | |
767 | |
768 return 0; | |
769 } | |
770 | |
4826 | 771 /** |
4617 | 772 * Creates a listener socket so the other dude can connect to us. |
2086 | 773 * |
4617 | 774 * You'll want to set up some kind of watcher on this socket. |
775 * When the state changes, call aim_handlerendconnection with | |
776 * the connection returned by this. aim_handlerendconnection | |
777 * will accept the pending connection and stop listening. | |
2086 | 778 * |
4617 | 779 * @param sess The session. |
5146 | 780 * @param oft_info File transfer information associated with this |
781 * connection. | |
782 * @return Return 0 if no errors, otherwise return the error number. | |
2086 | 783 */ |
5146 | 784 faim_export int aim_sendfile_listen(aim_session_t *sess, struct aim_oft_info *oft_info) |
2086 | 785 { |
4617 | 786 int listenfd; |
2086 | 787 |
5146 | 788 if (!oft_info) |
789 return -EINVAL; | |
2086 | 790 |
5146 | 791 if ((listenfd = listenestablish(oft_info->port)) == -1) |
792 return 1; | |
793 | |
794 if (!(oft_info->conn = aim_newconn(sess, AIM_CONN_TYPE_LISTENER, NULL))) { | |
4617 | 795 close(listenfd); |
5146 | 796 return -ENOMEM; |
3952 | 797 } |
3630 | 798 |
5146 | 799 oft_info->conn->fd = listenfd; |
800 oft_info->conn->subtype = AIM_CONN_SUBTYPE_OFT_SENDFILE; | |
801 oft_info->conn->lastactivity = time(NULL); | |
3952 | 802 |
5146 | 803 return 0; |
4617 | 804 } |
3630 | 805 |
4617 | 806 /** |
807 * Extract an &aim_fileheader_t from the given buffer. | |
808 * | |
809 * @param bs The should be from an incoming rendezvous packet. | |
810 * @return A pointer to new struct on success, or NULL on error. | |
811 */ | |
812 static struct aim_fileheader_t *aim_oft_getheader(aim_bstream_t *bs) | |
813 { | |
814 struct aim_fileheader_t *fh; | |
3630 | 815 |
4617 | 816 if (!(fh = calloc(1, sizeof(struct aim_fileheader_t)))) |
817 return NULL; | |
3630 | 818 |
4617 | 819 /* The bstream should be positioned after the hdrtype. */ |
820 aimbs_getrawbuf(bs, fh->bcookie, 8); | |
821 fh->encrypt = aimbs_get16(bs); | |
822 fh->compress = aimbs_get16(bs); | |
823 fh->totfiles = aimbs_get16(bs); | |
824 fh->filesleft = aimbs_get16(bs); | |
825 fh->totparts = aimbs_get16(bs); | |
826 fh->partsleft = aimbs_get16(bs); | |
827 fh->totsize = aimbs_get32(bs); | |
828 fh->size = aimbs_get32(bs); | |
829 fh->modtime = aimbs_get32(bs); | |
830 fh->checksum = aimbs_get32(bs); | |
831 fh->rfrcsum = aimbs_get32(bs); | |
832 fh->rfsize = aimbs_get32(bs); | |
833 fh->cretime = aimbs_get32(bs); | |
834 fh->rfcsum = aimbs_get32(bs); | |
835 fh->nrecvd = aimbs_get32(bs); | |
836 fh->recvcsum = aimbs_get32(bs); | |
837 aimbs_getrawbuf(bs, fh->idstring, 32); | |
838 fh->flags = aimbs_get8(bs); | |
839 fh->lnameoffset = aimbs_get8(bs); | |
840 fh->lsizeoffset = aimbs_get8(bs); | |
841 aimbs_getrawbuf(bs, fh->dummy, 69); | |
842 aimbs_getrawbuf(bs, fh->macfileinfo, 16); | |
843 fh->nencode = aimbs_get16(bs); | |
844 fh->nlanguage = aimbs_get16(bs); | |
845 aimbs_getrawbuf(bs, fh->name, 64); /* XXX - filenames longer than 64B */ | |
2086 | 846 |
4617 | 847 return fh; |
848 } | |
3630 | 849 |
4617 | 850 /** |
851 * Fills a buffer with network-order fh data | |
852 * | |
853 * @param bs A bstream to fill -- automatically initialized | |
854 * @param fh A struct aim_fileheader_t to get data from. | |
855 * @return Return non-zero on error. | |
856 */ | |
857 static int aim_oft_buildheader(aim_bstream_t *bs, struct aim_fileheader_t *fh) | |
858 { | |
859 fu8_t *hdr; | |
3630 | 860 |
4617 | 861 if (!bs || !fh) |
862 return -EINVAL; | |
3952 | 863 |
4617 | 864 if (!(hdr = (unsigned char *)calloc(1, 0x100 - 8))) |
865 return -ENOMEM; | |
3630 | 866 |
4617 | 867 aim_bstream_init(bs, hdr, 0x100 - 8); |
868 aimbs_putraw(bs, fh->bcookie, 8); | |
869 aimbs_put16(bs, fh->encrypt); | |
870 aimbs_put16(bs, fh->compress); | |
871 aimbs_put16(bs, fh->totfiles); | |
872 aimbs_put16(bs, fh->filesleft); | |
873 aimbs_put16(bs, fh->totparts); | |
874 aimbs_put16(bs, fh->partsleft); | |
875 aimbs_put32(bs, fh->totsize); | |
876 aimbs_put32(bs, fh->size); | |
877 aimbs_put32(bs, fh->modtime); | |
878 aimbs_put32(bs, fh->checksum); | |
879 aimbs_put32(bs, fh->rfrcsum); | |
880 aimbs_put32(bs, fh->rfsize); | |
881 aimbs_put32(bs, fh->cretime); | |
882 aimbs_put32(bs, fh->rfcsum); | |
883 aimbs_put32(bs, fh->nrecvd); | |
884 aimbs_put32(bs, fh->recvcsum); | |
885 aimbs_putraw(bs, fh->idstring, 32); | |
886 aimbs_put8(bs, fh->flags); | |
887 aimbs_put8(bs, fh->lnameoffset); | |
888 aimbs_put8(bs, fh->lsizeoffset); | |
889 aimbs_putraw(bs, fh->dummy, 69); | |
890 aimbs_putraw(bs, fh->macfileinfo, 16); | |
891 aimbs_put16(bs, fh->nencode); | |
892 aimbs_put16(bs, fh->nlanguage); | |
893 aimbs_putraw(bs, fh->name, 64); /* XXX - filenames longer than 64B */ | |
3952 | 894 |
4617 | 895 return 0; |
896 } | |
2086 | 897 |
4617 | 898 /** |
899 * Create an OFT packet based on the given information, and send it on its merry way. | |
900 * | |
901 * @param sess The session. | |
5146 | 902 * @param type The subtype of the OFT packet we're sending. |
903 * @param oft_info The aim_oft_info struct with the connection and OFT | |
904 * info we're sending. | |
4617 | 905 * @return Return 0 if no errors, otherwise return the error number. |
906 */ | |
5146 | 907 faim_export int aim_oft_sendheader(aim_session_t *sess, fu16_t type, struct aim_oft_info *oft_info) |
4617 | 908 { |
5146 | 909 aim_frame_t *fr; |
2086 | 910 |
5146 | 911 if (!sess || !oft_info || !oft_info->conn || (oft_info->conn->type != AIM_CONN_TYPE_RENDEZVOUS)) |
4617 | 912 return -EINVAL; |
913 | |
5146 | 914 #if 0 |
4617 | 915 /* |
916 * If you are receiving a file, the cookie should be null, if you are sending a | |
917 * file, the cookie should be the same as the one used in the ICBM negotiation | |
918 * SNACs. | |
919 */ | |
3952 | 920 fh->lnameoffset = 0x1a; |
921 fh->lsizeoffset = 0x10; | |
2086 | 922 |
4617 | 923 /* apparently 0 is ASCII, 2 is UCS-2 */ |
924 /* it is likely that 3 is ISO 8859-1 */ | |
4826 | 925 /* I think "nlanguage" might be the same thing as "subenc" in im.c */ |
3952 | 926 fh->nencode = 0x0000; |
927 fh->nlanguage = 0x0000; | |
5146 | 928 #endif |
4617 | 929 |
5146 | 930 aim_oft_dirconvert_tostupid(oft_info->fh.name); |
2086 | 931 |
5146 | 932 if (!(fr = aim_tx_new(sess, oft_info->conn, AIM_FRAMETYPE_OFT, type, 0))) |
933 return -ENOMEM; | |
934 | |
935 if (aim_oft_buildheader(&fr->data, &oft_info->fh) == -1) { | |
936 aim_frame_destroy(fr); | |
4617 | 937 return -ENOMEM; |
3952 | 938 } |
2086 | 939 |
5146 | 940 memcpy(fr->hdr.rend.magic, "OFT2", 4); |
941 fr->hdr.rend.hdrlen = aim_bstream_curpos(&fr->data); | |
2086 | 942 |
5146 | 943 aim_tx_enqueue(sess, fr); |
3952 | 944 |
945 return 0; | |
2086 | 946 } |
947 | |
948 /** | |
4617 | 949 * Handle incoming data on a rendezvous connection. This is analogous to the |
950 * consumesnac function in rxhandlers.c, and I really think this should probably | |
951 * be in rxhandlers.c as well, but I haven't finished cleaning everything up yet. | |
952 * | |
953 * @param sess The session. | |
954 * @param fr The frame allocated for the incoming data. | |
955 * @return Return 0 if the packet was handled correctly, otherwise return the | |
956 * error number. | |
3771 | 957 */ |
3952 | 958 faim_internal int aim_rxdispatch_rendezvous(aim_session_t *sess, aim_frame_t *fr) |
2086 | 959 { |
3952 | 960 aim_conn_t *conn = fr->conn; |
4617 | 961 int ret = 1; |
2086 | 962 |
4617 | 963 if (conn->subtype == AIM_CONN_SUBTYPE_OFT_DIRECTIM) { |
964 if (fr->hdr.rend.type == 0x0001) | |
965 ret = handlehdr_odc(sess, conn, fr, &fr->data); | |
966 else | |
967 faimdprintf(sess, 0, "faim: ODC directim frame unknown, type is %04x\n", fr->hdr.rend.type); | |
2086 | 968 |
4826 | 969 } else { |
4617 | 970 aim_rxcallback_t userfunc; |
971 struct aim_fileheader_t *header = aim_oft_getheader(&fr->data); | |
972 aim_oft_dirconvert_fromstupid(header->name); /* XXX - This should be client-side */ | |
3771 | 973 |
4617 | 974 if ((userfunc = aim_callhandler(sess, conn, AIM_CB_FAM_OFT, fr->hdr.rend.type))) |
975 ret = userfunc(sess, fr, conn, header->bcookie, header); | |
976 | |
977 free(header); | |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
978 } |
4617 | 979 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
980 if (ret == -1) |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
981 aim_conn_close(conn); |
2086 | 982 |
2246
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
983 return ret; |
933346315b9b
[gaim-migrate @ 2256]
Eric Warmenhoven <eric@warmenhoven.org>
parents:
2086
diff
changeset
|
984 } |