?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
implement update interval of list; can be disabled / changed by user
[kdenetwork.git] / kopete / protocols / gadu / libgadu / dcc.c
blobb346ccc9600e4f177e84fc3ef5fad98d1a383e3d
1 /* $Id$ */
2
3 /*
4 * (C) Copyright 2001-2006 Wojtek Kaniewski <wojtekka@irc.pl>
5 * Tomasz Chiliński <chilek@chilan.com>
6 * Adam Wysocki <gophi@ekg.apcoh.org>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU Lesser General Public License Version
10 * 2.1 as published by the Free Software Foundation.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
20 * USA.
21 */
22
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <sys/ioctl.h>
26 #include <sys/socket.h>
27 #include <netinet/in.h>
28 #include <arpa/inet.h>
29 #ifdef sun
30 # include <sys/filio.h>
31 #endif
32
33 #include <ctype.h>
34 #include <errno.h>
35 #include <fcntl.h>
36 #include <stdarg.h>
37 #include <string.h>
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <unistd.h>
41
42 #include "compat.h"
43 #include "libgadu.h"
44
45 #ifndef GG_DEBUG_DISABLE
46 /*
47 * gg_dcc_debug_data() // funkcja wewnętrzna
48 *
49 * wyświetla zrzut pakietu w hexie.
50 *
51 * - prefix - prefiks zrzutu pakietu
52 * - fd - deskryptor gniazda
53 * - buf - bufor z danymi
54 * - size - rozmiar danych
55 */
56 static void gg_dcc_debug_data(const char *prefix, int fd, const void *buf, unsigned int size)
57 {
58 unsigned int i;
59
60 gg_debug(GG_DEBUG_MISC, "++ gg_dcc %s (fd=%d,len=%d)", prefix, fd, size);
61
62 for (i = 0; i < size; i++)
63 gg_debug(GG_DEBUG_MISC, " %.2x", ((unsigned char*) buf)[i]);
64
65 gg_debug(GG_DEBUG_MISC, "\n");
66 }
67 #else
68 #define gg_dcc_debug_data(a,b,c,d) do { } while (0)
69 #endif
70
71 /*
72 * gg_dcc_request()
73 *
74 * wysyła informację o tym, że dany klient powinien się z nami połączyć.
75 * wykorzystywane, kiedy druga strona, której chcemy coś wysłać jest za
76 * maskaradą.
77 *
78 * - sess - struktura opisująca sesję GG
79 * - uin - numerek odbiorcy
80 *
81 * patrz gg_send_message_ctcp().
82 */
83 int gg_dcc_request(struct gg_session *sess, uin_t uin)
84 {
85 return gg_send_message_ctcp(sess, GG_CLASS_CTCP, uin, "\002", 1);
86 }
87
88 /*
89 * gg_dcc_fill_filetime() // funkcja wewnętrzna
90 *
91 * zamienia czas w postaci unixowej na windowsowy.
92 *
93 * - unix - czas w postaci unixowej
94 * - filetime - czas w postaci windowsowej
95 */
96 static void gg_dcc_fill_filetime(uint32_t ut, uint32_t *ft)
97 {
98 #ifdef __GG_LIBGADU_HAVE_LONG_LONG
99 unsigned long long tmp;
100
101 tmp = ut;
102 tmp += 11644473600LL;
103 tmp *= 10000000LL;
104
105 #ifndef __GG_LIBGADU_BIGENDIAN
106 ft[0] = (uint32_t) tmp;
107 ft[1] = (uint32_t) (tmp >> 32);
108 #else
109 ft[0] = gg_fix32((uint32_t) (tmp >> 32));
110 ft[1] = gg_fix32((uint32_t) tmp);
111 #endif
112
113 #endif
114 }
115
116 /*
117 * gg_dcc_fill_file_info()
118 *
119 * wypełnia pola struct gg_dcc niezbędne do wysłania pliku.
120 *
121 * - d - struktura opisująca połączenie DCC
122 * - filename - nazwa pliku
123 *
124 * 0, -1.
125 */
126 int gg_dcc_fill_file_info(struct gg_dcc *d, const char *filename)
127 {
128 return gg_dcc_fill_file_info2(d, filename, filename);
129 }
130
131 /*
132 * gg_dcc_fill_file_info2()
133 *
134 * wypełnia pola struct gg_dcc niezbędne do wysłania pliku.
135 *
136 * - d - struktura opisująca połączenie DCC
137 * - filename - nazwa pliku
138 * - local_filename - nazwa na lokalnym systemie plików
139 *
140 * 0, -1.
141 */
142 int gg_dcc_fill_file_info2(struct gg_dcc *d, const char *filename, const char *local_filename)
143 {
144 struct stat st;
145 const char *name, *ext, *p;
146 unsigned char *q;
147 int i, j;
148
149 gg_debug(GG_DEBUG_FUNCTION, "** gg_dcc_fill_file_info2(%p, \"%s\", \"%s\");\n", d, filename, local_filename);
150
151 if (!d || d->type != GG_SESSION_DCC_SEND) {
152 gg_debug(GG_DEBUG_MISC, "// gg_dcc_fill_file_info2() invalid arguments\n");
153 errno = EINVAL;
154 return -1;
155 }
156
157 if (stat(local_filename, &st) == -1) {
158 gg_debug(GG_DEBUG_MISC, "// gg_dcc_fill_file_info2() stat() failed (%s)\n", strerror(errno));
159 return -1;
160 }
161
162 if ((st.st_mode & S_IFDIR)) {
163 gg_debug(GG_DEBUG_MISC, "// gg_dcc_fill_file_info2() that's a directory\n");
164 errno = EINVAL;
165 return -1;
166 }
167
168 if ((d->file_fd = open(local_filename, O_RDONLY)) == -1) {
169 gg_debug(GG_DEBUG_MISC, "// gg_dcc_fill_file_info2() open() failed (%s)\n", strerror(errno));
170 return -1;
171 }
172
173 memset(&d->file_info, 0, sizeof(d->file_info));
174
175 if (!(st.st_mode & S_IWUSR))
176 d->file_info.mode |= gg_fix32(GG_DCC_FILEATTR_READONLY);
177
178 gg_dcc_fill_filetime(st.st_atime, d->file_info.atime);
179 gg_dcc_fill_filetime(st.st_mtime, d->file_info.mtime);
180 gg_dcc_fill_filetime(st.st_ctime, d->file_info.ctime);
181
182 d->file_info.size = gg_fix32(st.st_size);
183 d->file_info.mode = gg_fix32(0x20); /* FILE_ATTRIBUTE_ARCHIVE */
184
185 if (!(name = strrchr(filename, '/')))
186 name = filename;
187 else
188 name++;
189
190 if (!(ext = strrchr(name, '.')))
191 ext = name + strlen(name);
192
193 for (i = 0, p = name; i < 8 && p < ext; i++, p++)
194 d->file_info.short_filename[i] = toupper(name[i]);
195
196 if (i == 8 && p < ext) {
197 d->file_info.short_filename[6] = '~';
198 d->file_info.short_filename[7] = '1';
199 }
200
201 if (strlen(ext) > 0) {
202 for (j = 0; *ext && j < 4; j++, p++)
203 d->file_info.short_filename[i + j] = toupper(ext[j]);
204 }
205
206 for (q = d->file_info.short_filename; *q; q++) {
207 if (*q == 185) {
208 *q = 165;
209 } else if (*q == 230) {
210 *q = 198;
211 } else if (*q == 234) {
212 *q = 202;
213 } else if (*q == 179) {
214 *q = 163;
215 } else if (*q == 241) {
216 *q = 209;
217 } else if (*q == 243) {
218 *q = 211;
219 } else if (*q == 156) {
220 *q = 140;
221 } else if (*q == 159) {
222 *q = 143;
223 } else if (*q == 191) {
224 *q = 175;
225 }
226 }
227
228 gg_debug(GG_DEBUG_MISC, "// gg_dcc_fill_file_info2() short name \"%s\", dos name \"%s\"\n", name, d->file_info.short_filename);
229 strncpy(d->file_info.filename, name, sizeof(d->file_info.filename) - 1);
230
231 return 0;
232 }
233
234 /*
235 * gg_dcc_transfer() // funkcja wewnętrzna
236 *
237 * inicjuje proces wymiany pliku z danym klientem.
238 *
239 * - ip - adres ip odbiorcy
240 * - port - port odbiorcy
241 * - my_uin - własny numer
242 * - peer_uin - numer obiorcy
243 * - type - rodzaj wymiany (GG_SESSION_DCC_SEND lub GG_SESSION_DCC_GET)
244 *
245 * zaalokowana struct gg_dcc lub NULL jeśli wystąpił błąd.
246 */
247 static struct gg_dcc *gg_dcc_transfer(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin, int type)
248 {
249 struct gg_dcc *d = NULL;
250 struct in_addr addr;
251
252 addr.s_addr = ip;
253
254 gg_debug(GG_DEBUG_FUNCTION, "** gg_dcc_transfer(%s, %d, %ld, %ld, %s);\n", inet_ntoa(addr), port, my_uin, peer_uin, (type == GG_SESSION_DCC_SEND) ? "SEND" : "GET");
255
256 if (!ip || ip == INADDR_NONE || !port || !my_uin || !peer_uin) {
257 gg_debug(GG_DEBUG_MISC, "// gg_dcc_transfer() invalid arguments\n");
258 errno = EINVAL;
259 return NULL;
260 }
261
262 if (!(d = (void*) calloc(1, sizeof(*d)))) {
263 gg_debug(GG_DEBUG_MISC, "// gg_dcc_transfer() not enough memory\n");
264 return NULL;
265 }
266
267 d->check = GG_CHECK_WRITE;
268 d->state = GG_STATE_CONNECTING;
269 d->type = type;
270 d->timeout = GG_DEFAULT_TIMEOUT;
271 d->file_fd = -1;
272 d->active = 1;
273 d->fd = -1;
274 d->uin = my_uin;
275 d->peer_uin = peer_uin;
276
277 if ((d->fd = gg_connect(&addr, port, 1)) == -1) {
278 gg_debug(GG_DEBUG_MISC, "// gg_dcc_transfer() connection failed\n");
279 free(d);
280 return NULL;
281 }
282
283 return d;
284 }
285
286 /*
287 * gg_dcc_get_file()
288 *
289 * inicjuje proces odbierania pliku od danego klienta, gdy ten wysłał do
290 * nas żądanie połączenia.
291 *
292 * - ip - adres ip odbiorcy
293 * - port - port odbiorcy
294 * - my_uin - własny numer
295 * - peer_uin - numer obiorcy
296 *
297 * zaalokowana struct gg_dcc lub NULL jeśli wystąpił błąd.
298 */
299 struct gg_dcc *gg_dcc_get_file(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin)
300 {
301 gg_debug(GG_DEBUG_MISC, "// gg_dcc_get_file() handing over to gg_dcc_transfer()\n");
302
303 return gg_dcc_transfer(ip, port, my_uin, peer_uin, GG_SESSION_DCC_GET);
304 }
305
306 /*
307 * gg_dcc_send_file()
308 *
309 * inicjuje proces wysyłania pliku do danego klienta.
310 *
311 * - ip - adres ip odbiorcy
312 * - port - port odbiorcy
313 * - my_uin - własny numer
314 * - peer_uin - numer obiorcy
315 *
316 * zaalokowana struct gg_dcc lub NULL jeśli wystąpił błąd.
317 */
318 struct gg_dcc *gg_dcc_send_file(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin)
319 {
320 gg_debug(GG_DEBUG_MISC, "// gg_dcc_send_file() handing over to gg_dcc_transfer()\n");
321
322 return gg_dcc_transfer(ip, port, my_uin, peer_uin, GG_SESSION_DCC_SEND);
323 }
324
325 /*
326 * gg_dcc_voice_chat()
327 *
328 * próbuje nawiązać połączenie głosowe.
329 *
330 * - ip - adres ip odbiorcy
331 * - port - port odbiorcy
332 * - my_uin - własny numer
333 * - peer_uin - numer obiorcy
334 *
335 * zaalokowana struct gg_dcc lub NULL jeśli wystąpił błąd.
336 */
337 struct gg_dcc *gg_dcc_voice_chat(uint32_t ip, uint16_t port, uin_t my_uin, uin_t peer_uin)
338 {
339 gg_debug(GG_DEBUG_MISC, "// gg_dcc_voice_chat() handing over to gg_dcc_transfer()\n");
340
341 return gg_dcc_transfer(ip, port, my_uin, peer_uin, GG_SESSION_DCC_VOICE);
342 }
343
344 /*
345 * gg_dcc_set_type()
346 *
347 * po zdarzeniu GG_EVENT_DCC_CALLBACK należy ustawić typ połączenia za
348 * pomocą tej funkcji.
349 *
350 * - d - struktura opisująca połączenie
351 * - type - typ połączenia (GG_SESSION_DCC_SEND lub GG_SESSION_DCC_VOICE)
352 */
353 void gg_dcc_set_type(struct gg_dcc *d, int type)
354 {
355 d->type = type;
356 d->state = (type == GG_SESSION_DCC_SEND) ? GG_STATE_SENDING_FILE_INFO : GG_STATE_SENDING_VOICE_REQUEST;
357 }
358
359 /*
360 * gg_dcc_callback() // funkcja wewnętrzna
361 *
362 * wywoływana z struct gg_dcc->callback, odpala gg_dcc_watch_fd i umieszcza
363 * rezultat w struct gg_dcc->event.
364 *
365 * - d - structura opisująca połączenie
366 *
367 * 0, -1.
368 */
369 static int gg_dcc_callback(struct gg_dcc *d)
370 {
371 struct gg_event *e = gg_dcc_watch_fd(d);
372
373 d->event = e;
374
375 return (e != NULL) ? 0 : -1;
376 }
377
378 /*
379 * gg_dcc_socket_create()
380 *
381 * tworzy gniazdo dla bezpośredniej komunikacji między klientami.
382 *
383 * - uin - własny numer
384 * - port - preferowany port, jeśli równy 0 lub -1, próbuje domyślnego
385 *
386 * zaalokowana struct gg_dcc, którą poźniej należy zwolnić funkcją
387 * gg_dcc_free(), albo NULL jeśli wystąpił błąd.
388 */
389 struct gg_dcc *gg_dcc_socket_create(uin_t uin, uint16_t port)
390 {
391 struct gg_dcc *c;
392 struct sockaddr_in sin;
393 int sock, bound = 0, errno2;
394
395 gg_debug(GG_DEBUG_FUNCTION, "** gg_create_dcc_socket(%d, %d);\n", uin, port);
396
397 if (!uin) {
398 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() invalid arguments\n");
399 errno = EINVAL;
400 return NULL;
401 }
402
403 if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
404 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() can't create socket (%s)\n", strerror(errno));
405 return NULL;
406 }
407
408 if (!port)
409 port = GG_DEFAULT_DCC_PORT;
410
411 while (!bound) {
412 sin.sin_family = AF_INET;
413 sin.sin_addr.s_addr = INADDR_ANY;
414 sin.sin_port = htons(port);
415
416 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() trying port %d\n", port);
417 if (!bind(sock, (struct sockaddr*) &sin, sizeof(sin)))
418 bound = 1;
419 else {
420 if (++port == 65535) {
421 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() no free port found\n");
422 close(sock);
423 return NULL;
424 }
425 }
426 }
427
428 if (listen(sock, 10)) {
429 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() unable to listen (%s)\n", strerror(errno));
430 errno2 = errno;
431 close(sock);
432 errno = errno2;
433 return NULL;
434 }
435
436 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() bound to port %d\n", port);
437
438 if (!(c = malloc(sizeof(*c)))) {
439 gg_debug(GG_DEBUG_MISC, "// gg_create_dcc_socket() not enough memory for struct\n");
440 close(sock);
441 return NULL;
442 }
443 memset(c, 0, sizeof(*c));
444
445 c->port = c->id = port;
446 c->fd = sock;
447 c->type = GG_SESSION_DCC_SOCKET;
448 c->uin = uin;
449 c->timeout = -1;
450 c->state = GG_STATE_LISTENING;
451 c->check = GG_CHECK_READ;
452 c->callback = gg_dcc_callback;
453 c->destroy = gg_dcc_free;
454
455 return c;
456 }
457
458 /*
459 * gg_dcc_voice_send()
460 *
461 * wysyła ramkę danych dla rozmowy głosowej.
462 *
463 * - d - struktura opisująca połączenie dcc
464 * - buf - bufor z danymi
465 * - length - rozmiar ramki
466 *
467 * 0, -1.
468 */
469 int gg_dcc_voice_send(struct gg_dcc *d, char *buf, int length)
470 {
471 struct packet_s {
472 uint8_t type;
473 uint32_t length;
474 } GG_PACKED;
475 struct packet_s packet;
476
477 gg_debug(GG_DEBUG_FUNCTION, "++ gg_dcc_voice_send(%p, %p, %d);\n", d, buf, length);
478 if (!d || !buf || length < 0 || d->type != GG_SESSION_DCC_VOICE) {
479 gg_debug(GG_DEBUG_MISC, "// gg_dcc_voice_send() invalid argument\n");
480 errno = EINVAL;
481 return -1;
482 }
483
484 packet.type = 0x03; /* XXX */
485 packet.length = gg_fix32(length);
486
487 if (write(d->fd, &packet, sizeof(packet)) < (signed)sizeof(packet)) {
488 gg_debug(GG_DEBUG_MISC, "// gg_dcc_voice_send() write() failed\n");
489 return -1;
490 }
491 gg_dcc_debug_data("write", d->fd, &packet, sizeof(packet));
492
493 if (write(d->fd, buf, length) < length) {
494 gg_debug(GG_DEBUG_MISC, "// gg_dcc_voice_send() write() failed\n");
495 return -1;
496 }
497 gg_dcc_debug_data("write", d->fd, buf, length);
498
499 return 0;
500 }
501
502 #define gg_read(fd, buf, size) \
503 { \
504 int tmp = read(fd, buf, size); \
505 \
506 if (tmp < (int) size) { \
507 if (tmp == -1) { \
508 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed (errno=%d, %s)\n", errno, strerror(errno)); \
509 } else if (tmp == 0) { \
510 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed, connection broken\n"); \
511 } else { \
512 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed (%d bytes, %d needed)\n", tmp, size); \
513 } \
514 e->type = GG_EVENT_DCC_ERROR; \
515 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE; \
516 return e; \
517 } \
518 gg_dcc_debug_data("read", fd, buf, size); \
519 }
520
521 #define gg_write(fd, buf, size) \
522 { \
523 int tmp; \
524 gg_dcc_debug_data("write", fd, buf, size); \
525 tmp = write(fd, buf, size); \
526 if (tmp < (int) size) { \
527 if (tmp == -1) { \
528 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() write() failed (errno=%d, %s)\n", errno, strerror(errno)); \
529 } else { \
530 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() write() failed (%d needed, %d done)\n", size, tmp); \
531 } \
532 e->type = GG_EVENT_DCC_ERROR; \
533 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE; \
534 return e; \
535 } \
536 }
537
538 /*
539 * gg_dcc_watch_fd()
540 *
541 * funkcja, którą należy wywołać, gdy coś się zmieni na gg_dcc->fd.
542 *
543 * - h - struktura zwrócona przez gg_create_dcc_socket()
544 *
545 * zaalokowana struct gg_event lub NULL, jeśli zabrakło pamięci na nią.
546 */
547 struct gg_event *gg_dcc_watch_fd(struct gg_dcc *h)
548 {
549 struct gg_event *e;
550 int foo;
551
552 gg_debug(GG_DEBUG_FUNCTION, "** gg_dcc_watch_fd(%p);\n", h);
553
554 if (!h || (h->type != GG_SESSION_DCC && h->type != GG_SESSION_DCC_SOCKET && h->type != GG_SESSION_DCC_SEND && h->type != GG_SESSION_DCC_GET && h->type != GG_SESSION_DCC_VOICE)) {
555 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() invalid argument\n");
556 errno = EINVAL;
557 return NULL;
558 }
559
560 if (!(e = (void*) calloc(1, sizeof(*e)))) {
561 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() not enough memory\n");
562 return NULL;
563 }
564
565 e->type = GG_EVENT_NONE;
566
567 if (h->type == GG_SESSION_DCC_SOCKET) {
568 struct sockaddr_in sin;
569 struct gg_dcc *c;
570 int fd, sin_len = sizeof(sin), one = 1;
571
572 if ((fd = accept(h->fd, (struct sockaddr*) &sin, &sin_len)) == -1) {
573 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() can't accept() new connection (errno=%d, %s)\n", errno, strerror(errno));
574 return e;
575 }
576
577 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() new direct connection from %s:%d\n", inet_ntoa(sin.sin_addr), htons(sin.sin_port));
578
579 #ifdef FIONBIO
580 if (ioctl(fd, FIONBIO, &one) == -1) {
581 #else
582 if (fcntl(fd, F_SETFL, O_NONBLOCK) == -1) {
583 #endif
584 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() can't set nonblocking (errno=%d, %s)\n", errno, strerror(errno));
585 close(fd);
586 e->type = GG_EVENT_DCC_ERROR;
587 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
588 return e;
589 }
590
591 if (!(c = (void*) calloc(1, sizeof(*c)))) {
592 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() not enough memory for client data\n");
593
594 free(e);
595 close(fd);
596 return NULL;
597 }
598
599 c->fd = fd;
600 c->check = GG_CHECK_READ;
601 c->state = GG_STATE_READING_UIN_1;
602 c->type = GG_SESSION_DCC;
603 c->timeout = GG_DEFAULT_TIMEOUT;
604 c->file_fd = -1;
605 c->remote_addr = sin.sin_addr.s_addr;
606 c->remote_port = ntohs(sin.sin_port);
607
608 e->type = GG_EVENT_DCC_NEW;
609 e->event.dcc_new = c;
610
611 return e;
612 } else {
613 struct gg_dcc_tiny_packet tiny;
614 struct gg_dcc_small_packet small;
615 struct gg_dcc_big_packet big;
616 int size, tmp, res, res_size = sizeof(res);
617 unsigned int utmp;
618 char buf[1024], ack[] = "UDAG";
619
620 struct gg_dcc_file_info_packet {
621 struct gg_dcc_big_packet big;
622 struct gg_file_info file_info;
623 } GG_PACKED;
624 struct gg_dcc_file_info_packet file_info_packet;
625
626 switch (h->state) {
627 case GG_STATE_READING_UIN_1:
628 case GG_STATE_READING_UIN_2:
629 {
630 uin_t uin;
631
632 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_READING_UIN_%d\n", (h->state == GG_STATE_READING_UIN_1) ? 1 : 2);
633
634 gg_read(h->fd, &uin, sizeof(uin));
635
636 if (h->state == GG_STATE_READING_UIN_1) {
637 h->state = GG_STATE_READING_UIN_2;
638 h->check = GG_CHECK_READ;
639 h->timeout = GG_DEFAULT_TIMEOUT;
640 h->peer_uin = gg_fix32(uin);
641 } else {
642 h->state = GG_STATE_SENDING_ACK;
643 h->check = GG_CHECK_WRITE;
644 h->timeout = GG_DEFAULT_TIMEOUT;
645 h->uin = gg_fix32(uin);
646 e->type = GG_EVENT_DCC_CLIENT_ACCEPT;
647 }
648
649 return e;
650 }
651
652 case GG_STATE_SENDING_ACK:
653 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_SENDING_ACK\n");
654
655 gg_write(h->fd, ack, 4);
656
657 h->state = GG_STATE_READING_TYPE;
658 h->check = GG_CHECK_READ;
659 h->timeout = GG_DEFAULT_TIMEOUT;
660
661 return e;
662
663 case GG_STATE_READING_TYPE:
664 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_TYPE\n");
665
666 gg_read(h->fd, &small, sizeof(small));
667
668 small.type = gg_fix32(small.type);
669
670 switch (small.type) {
671 case 0x0003: /* XXX */
672 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() callback\n");
673 h->type = GG_SESSION_DCC_SEND;
674 h->state = GG_STATE_SENDING_FILE_INFO;
675 h->check = GG_CHECK_WRITE;
676 h->timeout = GG_DEFAULT_TIMEOUT;
677
678 e->type = GG_EVENT_DCC_CALLBACK;
679
680 break;
681
682 case 0x0002: /* XXX */
683 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() dialin\n");
684 h->type = GG_SESSION_DCC_GET;
685 h->state = GG_STATE_READING_REQUEST;
686 h->check = GG_CHECK_READ;
687 h->timeout = GG_DEFAULT_TIMEOUT;
688 h->incoming = 1;
689
690 break;
691
692 default:
693 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() unknown dcc type (%.4x) from %ld\n", small.type, h->peer_uin);
694 e->type = GG_EVENT_DCC_ERROR;
695 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
696 }
697
698 return e;
699
700 case GG_STATE_READING_REQUEST:
701 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_REQUEST\n");
702
703 gg_read(h->fd, &small, sizeof(small));
704
705 small.type = gg_fix32(small.type);
706
707 switch (small.type) {
708 case 0x0001: /* XXX */
709 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() file transfer request\n");
710 h->state = GG_STATE_READING_FILE_INFO;
711 h->check = GG_CHECK_READ;
712 h->timeout = GG_DEFAULT_TIMEOUT;
713 break;
714
715 case 0x0003: /* XXX */
716 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() voice chat request\n");
717 h->state = GG_STATE_SENDING_VOICE_ACK;
718 h->check = GG_CHECK_WRITE;
719 h->timeout = GG_DCC_TIMEOUT_VOICE_ACK;
720 h->type = GG_SESSION_DCC_VOICE;
721 e->type = GG_EVENT_DCC_NEED_VOICE_ACK;
722
723 break;
724
725 default:
726 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() unknown dcc request (%.4x) from %ld\n", small.type, h->peer_uin);
727 e->type = GG_EVENT_DCC_ERROR;
728 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
729 }
730
731 return e;
732
733 case GG_STATE_READING_FILE_INFO:
734 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_FILE_INFO\n");
735
736 gg_read(h->fd, &file_info_packet, sizeof(file_info_packet));
737
738 memcpy(&h->file_info, &file_info_packet.file_info, sizeof(h->file_info));
739
740 h->file_info.mode = gg_fix32(h->file_info.mode);
741 h->file_info.size = gg_fix32(h->file_info.size);
742
743 h->state = GG_STATE_SENDING_FILE_ACK;
744 h->check = GG_CHECK_WRITE;
745 h->timeout = GG_DCC_TIMEOUT_FILE_ACK;
746
747 e->type = GG_EVENT_DCC_NEED_FILE_ACK;
748
749 return e;
750
751 case GG_STATE_SENDING_FILE_ACK:
752 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_FILE_ACK\n");
753
754 big.type = gg_fix32(0x0006); /* XXX */
755 big.dunno1 = gg_fix32(h->offset);
756 big.dunno2 = 0;
757
758 gg_write(h->fd, &big, sizeof(big));
759
760 h->state = GG_STATE_READING_FILE_HEADER;
761 h->chunk_size = sizeof(big);
762 h->chunk_offset = 0;
763 if (!(h->chunk_buf = malloc(sizeof(big)))) {
764 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() out of memory\n");
765 free(e);
766 return NULL;
767 }
768 h->check = GG_CHECK_READ;
769 h->timeout = GG_DEFAULT_TIMEOUT;
770
771 return e;
772
773 case GG_STATE_SENDING_VOICE_ACK:
774 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_VOICE_ACK\n");
775
776 tiny.type = 0x01; /* XXX */
777
778 gg_write(h->fd, &tiny, sizeof(tiny));
779
780 h->state = GG_STATE_READING_VOICE_HEADER;
781 h->check = GG_CHECK_READ;
782 h->timeout = GG_DEFAULT_TIMEOUT;
783
784 h->offset = 0;
785
786 return e;
787
788 case GG_STATE_READING_FILE_HEADER:
789 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_FILE_HEADER\n");
790
791 tmp = read(h->fd, h->chunk_buf + h->chunk_offset, h->chunk_size - h->chunk_offset);
792
793 if (tmp == -1) {
794 gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() read() failed (errno=%d, %s)\n", errno, strerror(errno));
795 e->type = GG_EVENT_DCC_ERROR;
796 e->event.dcc_error = GG_ERROR_DCC_NET;
797 return e;
798 }
799
800 gg_dcc_debug_data("read", h->fd, h->chunk_buf + h->chunk_offset, h->chunk_size - h->chunk_offset);
801
802 h->chunk_offset += tmp;
803
804 if (h->chunk_offset < h->chunk_size)
805 return e;
806
807 memcpy(&big, h->chunk_buf, sizeof(big));
808 free(h->chunk_buf);
809 h->chunk_buf = NULL;
810
811 big.type = gg_fix32(big.type);
812 h->chunk_size = gg_fix32(big.dunno1);
813 h->chunk_offset = 0;
814
815 if (big.type == 0x0005) { /* XXX */
816 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() transfer refused\n");
817 e->type = GG_EVENT_DCC_ERROR;
818 e->event.dcc_error = GG_ERROR_DCC_REFUSED;
819 return e;
820 }
821
822 if (h->chunk_size == 0) {
823 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() empty chunk, EOF\n");
824 e->type = GG_EVENT_DCC_DONE;
825 return e;
826 }
827
828 h->state = GG_STATE_GETTING_FILE;
829 h->check = GG_CHECK_READ;
830 h->timeout = GG_DEFAULT_TIMEOUT;
831 h->established = 1;
832
833 return e;
834
835 case GG_STATE_READING_VOICE_HEADER:
836 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_VOICE_HEADER\n");
837
838 gg_read(h->fd, &tiny, sizeof(tiny));
839
840 switch (tiny.type) {
841 case 0x03: /* XXX */
842 h->state = GG_STATE_READING_VOICE_SIZE;
843 h->check = GG_CHECK_READ;
844 h->timeout = GG_DEFAULT_TIMEOUT;
845 h->established = 1;
846 break;
847 case 0x04: /* XXX */
848 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() peer breaking connection\n");
849 /* XXX zwracać odpowiedni event */
850 default:
851 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() unknown request (%.2x)\n", tiny.type);
852 e->type = GG_EVENT_DCC_ERROR;
853 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
854 }
855
856 return e;
857
858 case GG_STATE_READING_VOICE_SIZE:
859 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_VOICE_SIZE\n");
860
861 gg_read(h->fd, &small, sizeof(small));
862
863 small.type = gg_fix32(small.type);
864
865 if (small.type < 16 || small.type > sizeof(buf)) {
866 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() invalid voice frame size (%d)\n", small.type);
867 e->type = GG_EVENT_DCC_ERROR;
868 e->event.dcc_error = GG_ERROR_DCC_NET;
869
870 return e;
871 }
872
873 h->chunk_size = small.type;
874 h->chunk_offset = 0;
875
876 if (!(h->voice_buf = malloc(h->chunk_size))) {
877 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() out of memory for voice frame\n");
878 free(e);
879 return NULL;
880 }
881
882 h->state = GG_STATE_READING_VOICE_DATA;
883 h->check = GG_CHECK_READ;
884 h->timeout = GG_DEFAULT_TIMEOUT;
885
886 return e;
887
888 case GG_STATE_READING_VOICE_DATA:
889 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_VOICE_DATA\n");
890
891 tmp = read(h->fd, h->voice_buf + h->chunk_offset, h->chunk_size - h->chunk_offset);
892 if (tmp < 1) {
893 if (tmp == -1) {
894 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed (errno=%d, %s)\n", errno, strerror(errno));
895 } else {
896 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed, connection broken\n");
897 }
898 e->type = GG_EVENT_DCC_ERROR;
899 e->event.dcc_error = GG_ERROR_DCC_NET;
900 return e;
901 }
902
903 gg_dcc_debug_data("read", h->fd, h->voice_buf + h->chunk_offset, tmp);
904
905 h->chunk_offset += tmp;
906
907 if (h->chunk_offset >= h->chunk_size) {
908 e->type = GG_EVENT_DCC_VOICE_DATA;
909 e->event.dcc_voice_data.data = h->voice_buf;
910 e->event.dcc_voice_data.length = h->chunk_size;
911 h->state = GG_STATE_READING_VOICE_HEADER;
912 h->voice_buf = NULL;
913 }
914
915 h->check = GG_CHECK_READ;
916 h->timeout = GG_DEFAULT_TIMEOUT;
917
918 return e;
919
920 case GG_STATE_CONNECTING:
921 {
922 uin_t uins[2];
923
924 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_CONNECTING\n");
925
926 res = 0;
927 if ((foo = getsockopt(h->fd, SOL_SOCKET, SO_ERROR, &res, &res_size)) || res) {
928 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() connection failed (fd=%d,errno=%d(%s),foo=%d,res=%d(%s))\n", h->fd, errno, strerror(errno), foo, res, strerror(res));
929 e->type = GG_EVENT_DCC_ERROR;
930 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
931 return e;
932 }
933
934 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() connected, sending uins\n");
935
936 uins[0] = gg_fix32(h->uin);
937 uins[1] = gg_fix32(h->peer_uin);
938
939 gg_write(h->fd, uins, sizeof(uins));
940
941 h->state = GG_STATE_READING_ACK;
942 h->check = GG_CHECK_READ;
943 h->timeout = GG_DEFAULT_TIMEOUT;
944
945 return e;
946 }
947
948 case GG_STATE_READING_ACK:
949 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_ACK\n");
950
951 gg_read(h->fd, buf, 4);
952
953 if (strncmp(buf, ack, 4)) {
954 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() did't get ack\n");
955
956 e->type = GG_EVENT_DCC_ERROR;
957 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
958 return e;
959 }
960
961 h->check = GG_CHECK_WRITE;
962 h->timeout = GG_DEFAULT_TIMEOUT;
963 h->state = GG_STATE_SENDING_REQUEST;
964
965 return e;
966
967 case GG_STATE_SENDING_VOICE_REQUEST:
968 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_VOICE_REQUEST\n");
969
970 small.type = gg_fix32(0x0003);
971
972 gg_write(h->fd, &small, sizeof(small));
973
974 h->state = GG_STATE_READING_VOICE_ACK;
975 h->check = GG_CHECK_READ;
976 h->timeout = GG_DEFAULT_TIMEOUT;
977
978 return e;
979
980 case GG_STATE_SENDING_REQUEST:
981 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_REQUEST\n");
982
983 small.type = (h->type == GG_SESSION_DCC_GET) ? gg_fix32(0x0003) : gg_fix32(0x0002); /* XXX */
984
985 gg_write(h->fd, &small, sizeof(small));
986
987 switch (h->type) {
988 case GG_SESSION_DCC_GET:
989 h->state = GG_STATE_READING_REQUEST;
990 h->check = GG_CHECK_READ;
991 h->timeout = GG_DEFAULT_TIMEOUT;
992 break;
993
994 case GG_SESSION_DCC_SEND:
995 h->state = GG_STATE_SENDING_FILE_INFO;
996 h->check = GG_CHECK_WRITE;
997 h->timeout = GG_DEFAULT_TIMEOUT;
998
999 if (h->file_fd == -1)
1000 e->type = GG_EVENT_DCC_NEED_FILE_INFO;
1001 break;
1002
1003 case GG_SESSION_DCC_VOICE:
1004 h->state = GG_STATE_SENDING_VOICE_REQUEST;
1005 h->check = GG_CHECK_WRITE;
1006 h->timeout = GG_DEFAULT_TIMEOUT;
1007 break;
1008 }
1009
1010 return e;
1011
1012 case GG_STATE_SENDING_FILE_INFO:
1013 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_FILE_INFO\n");
1014
1015 if (h->file_fd == -1) {
1016 e->type = GG_EVENT_DCC_NEED_FILE_INFO;
1017 return e;
1018 }
1019
1020 small.type = gg_fix32(0x0001); /* XXX */
1021
1022 gg_write(h->fd, &small, sizeof(small));
1023
1024 file_info_packet.big.type = gg_fix32(0x0003); /* XXX */
1025 file_info_packet.big.dunno1 = 0;
1026 file_info_packet.big.dunno2 = 0;
1027
1028 memcpy(&file_info_packet.file_info, &h->file_info, sizeof(h->file_info));
1029
1030 /* zostają teraz u nas, więc odwracamy z powrotem */
1031 h->file_info.size = gg_fix32(h->file_info.size);
1032 h->file_info.mode = gg_fix32(h->file_info.mode);
1033
1034 gg_write(h->fd, &file_info_packet, sizeof(file_info_packet));
1035
1036 h->state = GG_STATE_READING_FILE_ACK;
1037 h->check = GG_CHECK_READ;
1038 h->timeout = GG_DCC_TIMEOUT_FILE_ACK;
1039
1040 return e;
1041
1042 case GG_STATE_READING_FILE_ACK:
1043 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_FILE_ACK\n");
1044
1045 gg_read(h->fd, &big, sizeof(big));
1046
1047 /* XXX sprawdzać wynik */
1048 h->offset = gg_fix32(big.dunno1);
1049
1050 h->state = GG_STATE_SENDING_FILE_HEADER;
1051 h->check = GG_CHECK_WRITE;
1052 h->timeout = GG_DEFAULT_TIMEOUT;
1053
1054 e->type = GG_EVENT_DCC_ACK;
1055
1056 return e;
1057
1058 case GG_STATE_READING_VOICE_ACK:
1059 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_READING_VOICE_ACK\n");
1060
1061 gg_read(h->fd, &tiny, sizeof(tiny));
1062
1063 if (tiny.type != 0x01) {
1064 gg_debug(GG_DEBUG_MISC, "// invalid reply (%.2x), connection refused\n", tiny.type);
1065 e->type = GG_EVENT_DCC_ERROR;
1066 e->event.dcc_error = GG_ERROR_DCC_REFUSED;
1067 return e;
1068 }
1069
1070 h->state = GG_STATE_READING_VOICE_HEADER;
1071 h->check = GG_CHECK_READ;
1072 h->timeout = GG_DEFAULT_TIMEOUT;
1073
1074 e->type = GG_EVENT_DCC_ACK;
1075
1076 return e;
1077
1078 case GG_STATE_SENDING_FILE_HEADER:
1079 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_FILE_HEADER\n");
1080
1081 h->chunk_offset = 0;
1082
1083 if ((h->chunk_size = h->file_info.size - h->offset) > 4096) {
1084 h->chunk_size = 4096;
1085 big.type = gg_fix32(0x0003); /* XXX */
1086 } else
1087 big.type = gg_fix32(0x0002); /* XXX */
1088
1089 big.dunno1 = gg_fix32(h->chunk_size);
1090 big.dunno2 = 0;
1091
1092 gg_write(h->fd, &big, sizeof(big));
1093
1094 h->state = GG_STATE_SENDING_FILE;
1095 h->check = GG_CHECK_WRITE;
1096 h->timeout = GG_DEFAULT_TIMEOUT;
1097 h->established = 1;
1098
1099 return e;
1100
1101 case GG_STATE_SENDING_FILE:
1102 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_SENDING_FILE\n");
1103
1104 if ((utmp = h->chunk_size - h->chunk_offset) > sizeof(buf))
1105 utmp = sizeof(buf);
1106
1107 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() offset=%d, size=%d\n", h->offset, h->file_info.size);
1108
1109 /* koniec pliku? */
1110 if (h->file_info.size == 0) {
1111 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() reached eof on empty file\n");
1112 e->type = GG_EVENT_DCC_DONE;
1113
1114 return e;
1115 }
1116
1117 lseek(h->file_fd, h->offset, SEEK_SET);
1118
1119 size = read(h->file_fd, buf, utmp);
1120
1121 /* błąd */
1122 if (size == -1) {
1123 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed. (errno=%d, %s)\n", errno, strerror(errno));
1124
1125 e->type = GG_EVENT_DCC_ERROR;
1126 e->event.dcc_error = GG_ERROR_DCC_FILE;
1127
1128 return e;
1129 }
1130
1131 /* koniec pliku? */
1132 if (size == 0) {
1133 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() reached eof\n");
1134 e->type = GG_EVENT_DCC_ERROR;
1135 e->event.dcc_error = GG_ERROR_DCC_EOF;
1136
1137 return e;
1138 }
1139
1140 /* jeśli wczytaliśmy więcej, utnijmy. */
1141 if (h->offset + size > h->file_info.size) {
1142 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() too much (read=%d, ofs=%d, size=%d)\n", size, h->offset, h->file_info.size);
1143 size = h->file_info.size - h->offset;
1144
1145 if (size < 1) {
1146 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() reached EOF after cutting\n");
1147 e->type = GG_EVENT_DCC_DONE;
1148 return e;
1149 }
1150 }
1151
1152 tmp = write(h->fd, buf, size);
1153
1154 if (tmp == -1) {
1155 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() write() failed (%s)\n", strerror(errno));
1156 e->type = GG_EVENT_DCC_ERROR;
1157 e->event.dcc_error = GG_ERROR_DCC_NET;
1158 return e;
1159 }
1160
1161 h->offset += size;
1162
1163 if (h->offset >= h->file_info.size) {
1164 e->type = GG_EVENT_DCC_DONE;
1165 return e;
1166 }
1167
1168 h->chunk_offset += size;
1169
1170 if (h->chunk_offset >= h->chunk_size) {
1171 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() chunk finished\n");
1172 h->state = GG_STATE_SENDING_FILE_HEADER;
1173 h->timeout = GG_DEFAULT_TIMEOUT;
1174 } else {
1175 h->state = GG_STATE_SENDING_FILE;
1176 h->timeout = GG_DCC_TIMEOUT_SEND;
1177 }
1178
1179 h->check = GG_CHECK_WRITE;
1180
1181 return e;
1182
1183 case GG_STATE_GETTING_FILE:
1184 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_GETTING_FILE\n");
1185
1186 if ((utmp = h->chunk_size - h->chunk_offset) > sizeof(buf))
1187 utmp = sizeof(buf);
1188
1189 size = read(h->fd, buf, utmp);
1190
1191 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() ofs=%d, size=%d, read()=%d\n", h->offset, h->file_info.size, size);
1192
1193 /* błąd */
1194 if (size == -1) {
1195 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() failed. (errno=%d, %s)\n", errno, strerror(errno));
1196
1197 e->type = GG_EVENT_DCC_ERROR;
1198 e->event.dcc_error = GG_ERROR_DCC_NET;
1199
1200 return e;
1201 }
1202
1203 /* koniec? */
1204 if (size == 0) {
1205 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() read() reached eof\n");
1206 e->type = GG_EVENT_DCC_ERROR;
1207 e->event.dcc_error = GG_ERROR_DCC_EOF;
1208
1209 return e;
1210 }
1211
1212 tmp = write(h->file_fd, buf, size);
1213
1214 if (tmp == -1 || tmp < size) {
1215 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() write() failed (%d:fd=%d:res=%d:%s)\n", tmp, h->file_fd, size, strerror(errno));
1216 e->type = GG_EVENT_DCC_ERROR;
1217 e->event.dcc_error = GG_ERROR_DCC_NET;
1218 return e;
1219 }
1220
1221 h->offset += size;
1222
1223 if (h->offset >= h->file_info.size) {
1224 e->type = GG_EVENT_DCC_DONE;
1225 return e;
1226 }
1227
1228 h->chunk_offset += size;
1229
1230 if (h->chunk_offset >= h->chunk_size) {
1231 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() chunk finished\n");
1232 h->state = GG_STATE_READING_FILE_HEADER;
1233 h->timeout = GG_DEFAULT_TIMEOUT;
1234 h->chunk_offset = 0;
1235 h->chunk_size = sizeof(big);
1236 if (!(h->chunk_buf = malloc(sizeof(big)))) {
1237 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() out of memory\n");
1238 free(e);
1239 return NULL;
1240 }
1241 } else {
1242 h->state = GG_STATE_GETTING_FILE;
1243 h->timeout = GG_DCC_TIMEOUT_GET;
1244 }
1245
1246 h->check = GG_CHECK_READ;
1247
1248 return e;
1249
1250 default:
1251 gg_debug(GG_DEBUG_MISC, "// gg_dcc_watch_fd() GG_STATE_???\n");
1252 e->type = GG_EVENT_DCC_ERROR;
1253 e->event.dcc_error = GG_ERROR_DCC_HANDSHAKE;
1254
1255 return e;
1256 }
1257 }
1258
1259 return e;
1260 }
1261
1262 #undef gg_read
1263 #undef gg_write
1264
1265 /*
1266 * gg_dcc_free()
1267 *
1268 * zwalnia pamięć po strukturze połączenia dcc.
1269 *
1270 * - d - zwalniana struktura
1271 */
1272 void gg_dcc_free(struct gg_dcc *d)
1273 {
1274 gg_debug(GG_DEBUG_FUNCTION, "** gg_dcc_free(%p);\n", d);
1275
1276 if (!d)
1277 return;
1278
1279 if (d->fd != -1)
1280 close(d->fd);
1281
1282 if (d->chunk_buf) {
1283 free(d->chunk_buf);
1284 d->chunk_buf = NULL;
1285 }
1286
1287 free(d);
1288 }
1289
1290 /*
1291 * Local variables:
1292 * c-indentation-style: k&r
1293 * c-basic-offset: 8
1294 * indent-tabs-mode: notnil
1295 * End:
1296 *
1297 * vim: shiftwidth=8:
1298 */
kdenetwork experimental stuff