/** * \internal Wysyła do serwera żądanie nadania identyfikatora sesji * * \param sess Struktura sesji * \param type Rodzaj połączenia (\c GG_DCC7_TYPE_FILE lub \c GG_DCC7_TYPE_VOICE) * * \return 0 jeśli się powiodło, -1 w przypadku błędu */ static int gg_dcc7_request_id(struct gg_session *sess, uint32_t type) { struct gg_dcc7_id_request pkt; gg_debug_session(sess, GG_DEBUG_FUNCTION, "** gg_dcc7_request_id(%p, %d)\n", sess, type); if (!sess) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_request_id() invalid parameters\n"); errno = EFAULT; return -1; } if (sess->state != GG_STATE_CONNECTED) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_request_id() not connected\n"); errno = ENOTCONN; return -1; } if (type != GG_DCC7_TYPE_VOICE && type != GG_DCC7_TYPE_FILE) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_request_id() invalid transfer type (%d)\n", type); errno = EINVAL; return -1; } memset(&pkt, 0, sizeof(pkt)); pkt.type = gg_fix32(type); return gg_send_packet(sess, GG_DCC7_ID_REQUEST, &pkt, sizeof(pkt), NULL); }
/** * \internal Tworzy gniazdo nasłuchujące i wysyła jego parametry * * \param dcc Struktura połączenia * * \return 0 jeśli się powiodło, -1 w przypadku błędu */ static int gg_dcc7_listen_and_send_info(struct gg_dcc7 *dcc) { struct gg_dcc7_info pkt; uint16_t external_port; uint32_t external_addr; struct in_addr addr; gg_debug_dcc(dcc, GG_DEBUG_FUNCTION, "** gg_dcc7_listen_and_send_info(%p)\n", dcc); if (gg_dcc7_listen(dcc, dcc->sess->client_addr, dcc->sess->client_port) == -1) return -1; if (dcc->sess->external_port != 0) external_port = dcc->sess->external_port; else external_port = dcc->local_port; if (dcc->sess->external_addr != 0) external_addr = dcc->sess->external_addr; else external_addr = dcc->local_addr; addr.s_addr = external_addr; gg_debug_dcc(dcc, GG_DEBUG_MISC, "// dcc7_listen_and_send_info() sending IP address %s and port %d\n", inet_ntoa(addr), external_port); memset(&pkt, 0, sizeof(pkt)); pkt.uin = gg_fix32(dcc->peer_uin); pkt.type = GG_DCC7_TYPE_P2P; pkt.id = dcc->cid; snprintf((char*) pkt.info, sizeof(pkt.info), "%s %d", inet_ntoa(addr), external_port); snprintf((char*) pkt.hash, sizeof(pkt.hash), "%u", external_addr + external_port * rand()); return gg_send_packet(dcc->sess, GG_DCC7_INFO, &pkt, sizeof(pkt), NULL); }
/* * gg_pubdir50() * * wysy³a zapytanie katalogu publicznego do serwera. * * - sess - sesja, * - req - zapytanie. * * numer sekwencyjny wyszukiwania lub 0 w przypadku b³êdu. */ uint32_t gg_pubdir50(struct gg_session *sess, gg_pubdir50_t req) { int i, size = 5; uint32_t res; char *buf, *p; struct gg_pubdir50_request *r; gg_debug(GG_DEBUG_FUNCTION, "** gg_pubdir50(%p, %p);\n", sess, req); if (!sess || !req) { gg_debug(GG_DEBUG_MISC, "// gg_pubdir50() invalid arguments\n"); errno = EFAULT; return 0; } if (sess->state != GG_STATE_CONNECTED) { gg_debug(GG_DEBUG_MISC, "// gg_pubdir50() not connected\n"); errno = ENOTCONN; return 0; } for (i = 0; i < req->entries_count; i++) { /* wyszukiwanie bierze tylko pierwszy wpis */ if (req->entries[i].num) continue; size += strlen(req->entries[i].field) + 1; size += strlen(req->entries[i].value) + 1; } if (!(buf = malloc(size))) { gg_debug(GG_DEBUG_MISC, "// gg_pubdir50() out of memory (%d bytes)\n", size); return 0; } r = (struct gg_pubdir50_request*) buf; res = time(NULL); r->type = req->type; r->seq = (req->seq) ? gg_fix32(req->seq) : gg_fix32(time(NULL)); req->seq = gg_fix32(r->seq); for (i = 0, p = buf + 5; i < req->entries_count; i++) { if (req->entries[i].num) continue; strcpy(p, req->entries[i].field); p += strlen(p) + 1; strcpy(p, req->entries[i].value); p += strlen(p) + 1; } if (gg_send_packet(sess, GG_PUBDIR50_REQUEST, buf, size, NULL, 0) == -1) res = 0; free(buf); return res; }
/** * Przerwanie żądania przesłania pliku. * * \param dcc Struktura połączenia * * \return 0 jeśli się powiodło, -1 w przypadku błędu * * \ingroup dcc7 */ int gg_dcc7_abort(struct gg_dcc7 *dcc) { struct gg_dcc7_abort pkt; gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_FUNCTION, "** gg_dcc7_abort(%p)\n", dcc); if (!dcc || !dcc->sess) { gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_MISC, "// gg_dcc7_abort() invalid parameters\n"); errno = EFAULT; return -1; } memset(&pkt, 0, sizeof(pkt)); pkt.id = dcc->cid; pkt.uin_from = gg_fix32(dcc->uin); pkt.uin_to = gg_fix32(dcc->peer_uin); return gg_send_packet(dcc->sess, GG_DCC7_ABORT, &pkt, sizeof(pkt), NULL); }
/** * Odrzuca próbę przesłania pliku. * * \param dcc Struktura połączenia * \param reason Powód odrzucenia * * \return 0 jeśli się powiodło, -1 w przypadku błędu * * \ingroup dcc7 */ int gg_dcc7_reject(struct gg_dcc7 *dcc, int reason) { struct gg_dcc7_reject pkt; gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_FUNCTION, "** gg_dcc7_reject(%p, %d)\n", dcc, reason); if (!dcc || !dcc->sess) { gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_MISC, "// gg_dcc7_reject() invalid parameters\n"); errno = EFAULT; return -1; } memset(&pkt, 0, sizeof(pkt)); pkt.uin = gg_fix32(dcc->peer_uin); pkt.id = dcc->cid; pkt.reason = gg_fix32(reason); return gg_send_packet(dcc->sess, GG_DCC7_REJECT, &pkt, sizeof(pkt), NULL); }
/** * \internal Tworzy gniazdo nasłuchujące i wysyła jego parametry * * \param dcc Struktura połączenia * * \return 0 jeśli się powiodło, -1 w przypadku błędu */ static int gg_dcc7_listen_and_send_info(struct gg_dcc7 *dcc) { struct gg_dcc7_info pkt; uint16_t external_port; uint16_t local_port; uint32_t count; gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_FUNCTION, "** gg_dcc7_listen_and_send_info(%p)\n", dcc); if (!dcc->sess->client_port) local_port = dcc->sess->external_port; else local_port = dcc->sess->client_port; if (gg_dcc7_listen(dcc, local_port) == -1) return -1; if (!dcc->sess->external_port || dcc->local_port != local_port) external_port = dcc->local_port; else external_port = dcc->sess->external_port; if (!dcc->sess->external_addr || dcc->local_port != local_port) dcc->local_addr = dcc->sess->client_addr; else dcc->local_addr = dcc->sess->external_addr; gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_MISC, "// dcc7_listen_and_send_info() sending IP address %s and port %d\n", inet_ntoa(*((struct in_addr*) &dcc->local_addr)), external_port); memset(&pkt, 0, sizeof(pkt)); pkt.uin = gg_fix32(dcc->peer_uin); pkt.type = GG_DCC7_TYPE_P2P; pkt.id = dcc->cid; snprintf((char*) pkt.info, sizeof(pkt.info), "%s %d", inet_ntoa(*((struct in_addr*) &dcc->local_addr)), external_port); // TODO: implement hash count // we MUST fill hash to recive from server request for server connection //snprintf((char*) pkt.hash, sizeof(pkt.hash), "0"); count = dcc->local_addr + external_port * rand(); mir_snprintf(pkt.hash, sizeof(pkt.hash), "%d", count); return gg_send_packet(dcc->sess, GG_DCC7_INFO, &pkt, sizeof(pkt), NULL); }
/** * \internal Tworzy gniazdo nasłuchujące i wysyła jego parametry * * \param dcc Struktura połączenia * * \return 0 jeśli się powiodło, -1 w przypadku błędu */ static int gg_dcc7_listen_and_send_info(struct gg_dcc7 *dcc) { struct gg_dcc7_info pkt; gg_debug_dcc(dcc, GG_DEBUG_FUNCTION, "** gg_dcc7_listen_and_send_info(%p)\n", dcc); // XXX dać możliwość konfiguracji? dcc->local_addr = dcc->sess->client_addr; if (gg_dcc7_listen(dcc, 0) == -1) return -1; memset(&pkt, 0, sizeof(pkt)); pkt.uin = gg_fix32(dcc->peer_uin); pkt.type = GG_DCC7_TYPE_P2P; pkt.id = dcc->cid; snprintf((char*) pkt.info, sizeof(pkt.info), "%s %d", inet_ntoa(*((struct in_addr*) &dcc->local_addr)), dcc->local_port); return gg_send_packet(dcc->sess, GG_DCC7_INFO, &pkt, sizeof(pkt), NULL); }
/** * \internal Obsługuje pakiet identyfikatora połączenia bezpośredniego. * * \param sess Struktura sesji * \param e Struktura zdarzenia * \param payload Treść pakietu * \param len Długość pakietu * * \return 0 jeśli się powiodło, -1 w przypadku błędu */ int gg_dcc7_handle_id(struct gg_session *sess, struct gg_event *e, void *payload, int len) { struct gg_dcc7_id_reply *p = payload; struct gg_dcc7 *tmp; gg_debug_session(sess, GG_DEBUG_FUNCTION, "** gg_dcc7_handle_id(%p, %p, %p, %d)\n", sess, e, payload, len); for (tmp = sess->dcc7_list; tmp; tmp = tmp->next) { gg_debug_session(sess, GG_DEBUG_MISC, "// checking dcc %p, state %d, type %d\n", tmp, tmp->state, tmp->dcc_type); if (tmp->state != GG_STATE_REQUESTING_ID || tmp->dcc_type != (int)gg_fix32(p->type)) continue; tmp->cid = p->id; switch (tmp->dcc_type) { case GG_DCC7_TYPE_FILE: { struct gg_dcc7_new s; memset(&s, 0, sizeof(s)); s.id = tmp->cid; s.type = gg_fix32(GG_DCC7_TYPE_FILE); s.uin_from = gg_fix32(tmp->uin); s.uin_to = gg_fix32(tmp->peer_uin); s.size = gg_fix32(tmp->size); strncpy((char*) s.filename, (char*) tmp->filename, GG_DCC7_FILENAME_LEN); tmp->state = GG_STATE_WAITING_FOR_ACCEPT; tmp->timeout = GG_DCC7_TIMEOUT_FILE_ACK; return gg_send_packet(sess, GG_DCC7_NEW, &s, sizeof(s), NULL); } } } return 0; }
/** * Potwierdza chęć odebrania pliku. * * \param dcc Struktura połączenia * \param offset Początkowy offset przy wznawianiu przesyłania pliku * * \note Biblioteka nie zmienia położenia w odbieranych plikach. Jeśli offset * początkowy jest różny od zera, należy ustawić go funkcją \c lseek() lub * podobną. * * \return 0 jeśli się powiodło, -1 w przypadku błędu * * \ingroup dcc7 */ int gg_dcc7_accept(struct gg_dcc7 *dcc, unsigned int offset) { struct gg_dcc7_accept pkt; gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_FUNCTION, "** gg_dcc7_accept(%p, %d)\n", dcc, offset); if (!dcc || !dcc->sess) { gg_debug_session((dcc) ? (dcc)->sess : NULL, GG_DEBUG_MISC, "// gg_dcc7_accept() invalid parameters\n"); errno = EFAULT; return -1; } memset(&pkt, 0, sizeof(pkt)); pkt.uin = gg_fix32(dcc->peer_uin); pkt.id = dcc->cid; pkt.offset = gg_fix32(offset); if (gg_send_packet(dcc->sess, GG_DCC7_ACCEPT, &pkt, sizeof(pkt), NULL) == -1) return -1; dcc->offset = offset; return gg_dcc7_listen_and_send_info(dcc); }
/** * Wysyła zapytanie katalogu publicznego do serwera. * * \param sess Struktura sesji * \param req Zapytanie * * \return Numer sekwencyjny zapytania lub 0 w przypadku błędu * * \ingroup pubdir50 */ uint32_t gg_pubdir50(struct gg_session *sess, gg_pubdir50_t req) { size_t size = 5; int i; uint32_t res; char *buf, *p; struct gg_pubdir50_request *r; gg_debug_session(sess, GG_DEBUG_FUNCTION, "** gg_pubdir50(%p, %p);\n", sess, req); if (!sess || !req) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_pubdir50() invalid arguments\n"); errno = EFAULT; return 0; } if (sess->state != GG_STATE_CONNECTED) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_pubdir50() not connected\n"); errno = ENOTCONN; return 0; } for (i = 0; i < req->entries_count; i++) { /* wyszukiwanie bierze tylko pierwszy wpis */ if (req->entries[i].num) continue; if (sess->encoding == GG_ENCODING_CP1250) { size += strlen(req->entries[i].field) + 1; size += strlen(req->entries[i].value) + 1; } else { char *tmp; tmp = gg_utf8_to_cp(req->entries[i].field); if (tmp == NULL) return -1; size += strlen(tmp) + 1; free(tmp); tmp = gg_utf8_to_cp(req->entries[i].value); if (tmp == NULL) return -1; size += strlen(tmp) + 1; free(tmp); } } if (!(buf = (char*)malloc(size))) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_pubdir50() out of memory (%d bytes)\n", size); return 0; } if (!req->seq) req->seq = (uint32_t)time(NULL); res = req->seq; r = (struct gg_pubdir50_request*) buf; r->type = req->type; r->seq = gg_fix32(req->seq); for (i = 0, p = buf + 5; i < req->entries_count; i++) { if (req->entries[i].num) continue; if (sess->encoding == GG_ENCODING_CP1250) { strcpy(p, req->entries[i].field); p += strlen(p) + 1; strcpy(p, req->entries[i].value); p += strlen(p) + 1; } else { char *tmp; tmp = gg_utf8_to_cp(req->entries[i].field); if (tmp == NULL) { free(buf); return -1; } strcpy(p, tmp); p += strlen(tmp) + 1; free(tmp); tmp = gg_utf8_to_cp(req->entries[i].value); if (tmp == NULL) { free(buf); return -1; } strcpy(p, tmp); p += strlen(tmp) + 1; free(tmp); } } if (gg_send_packet(sess, GG_PUBDIR50_REQUEST, buf, size, NULL, 0) == -1) res = 0; free(buf); return res; }
static void test_send_packet(void) { struct gg_session gs; struct gg_session_private gsp; gs_init(&gs, &gsp, 1); /* Poprawne wysyłanie */ if (gg_send_packet(&gs, 0x1234, "ABC", 3, "DEF", 3, NULL) != 0) { if (!send_called) fprintf(stderr, "send hook not called\n"); else fprintf(stderr, "Expected success\n"); exit(1); } if (gs.send_buf != NULL || gs.send_left != 0) { fprintf(stderr, "Unexpected queue\n"); exit(1); } /* Błąd wysyłania */ if (gg_send_packet(&gs, 0x2345, "GHI", 3, NULL) != -1) { fprintf(stderr, "Expected failure\n"); exit(1); } if (gs.send_buf != NULL || gs.send_left != 0) { fprintf(stderr, "Unexpected queue\n"); exit(1); } /* EINTR na początek, niech wznowi i potem niekompletna transmisja */ if (gg_send_packet(&gs, 0x3456, "JKLMNO", 6, NULL) != 0) { fprintf(stderr, "Expected success\n"); exit(1); } if (gs.send_buf == NULL || gs.send_left != 6 || memcmp(gs.send_buf, "JKLMNO", 6) != 0) { fprintf(stderr, "Not queued properly\n"); exit(1); } free(gs.send_buf); /* EAGAIN na początek */ gs_init(&gs, &gsp, 1); if (gg_send_packet(&gs, 0x4567, "PQRSTU", 6, NULL) != 0) { fprintf(stderr, "Expected success\n"); exit(1); } if (gs.send_buf == NULL || gs.send_left != 14 || memcmp(gs.send_buf, "\x67\x45\x00\x00\x06\x00\x00\x00""PQRSTU", 14) != 0) { fprintf(stderr, "Not queued properly\n"); exit(1); } /* Wyślij jeszcze trochę, żeby dodało do kolejki */ if (gg_send_packet(&gs, 0x5678, "VWX", 3, NULL) != 0) { fprintf(stderr, "Expected success\n"); exit(1); } if (gs.send_buf == NULL || gs.send_left != 25 || memcmp(gs.send_buf, "\x67\x45\x00\x00\x06\x00\x00\x00""PQRSTU""\x78\x56\x00\x00\x03" "\x00\x00\x00""VWX", 25) != 0) { fprintf(stderr, "Not queued properly\n"); exit(1); } free(gs.send_buf); /* Sprawdź, czy wszystko już sprawdzone */ if (send_state != sizeof(send_list) / sizeof(send_list[0])) { fprintf(stderr, "More sends expected\n"); exit(1); } fprintf(stderr, "Test succeeded.\n"); }
/* * gg_watch_fd() * * funkcja, któr± nale¿y wywo³aæ, gdy co¶ siê stanie z obserwowanym * deskryptorem. zwraca klientowi informacjê o tym, co siê dzieje. * * - sess - opis sesji * * wska¼nik do struktury gg_event, któr± trzeba zwolniæ pó¼niej * za pomoc± gg_event_free(). jesli rodzaj zdarzenia jest równy * GG_EVENT_NONE, nale¿y je zignorowaæ. je¶li zwróci³o NULL, * sta³o siê co¶ niedobrego -- albo zabrak³o pamiêci albo zerwa³o * po³±czenie. */ struct gg_event *gg_watch_fd(struct gg_session *sess) { struct gg_event *e; int res = 0; int port = 0; int errno2 = 0; gg_debug(GG_DEBUG_FUNCTION, "** gg_watch_fd(%p);\n", sess); if (!sess) { errno = EFAULT; return NULL; } if (!(e = (void*) calloc(1, sizeof(*e)))) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() not enough memory for event data\n"); return NULL; } e->type = GG_EVENT_NONE; switch (sess->state) { case GG_STATE_RESOLVING: { struct in_addr addr; int failed = 0; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_RESOLVING\n"); if (read(sess->fd, &addr, sizeof(addr)) < (signed)sizeof(addr) || addr.s_addr == INADDR_NONE) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() resolving failed\n"); failed = 1; errno2 = errno; } close(sess->fd); sess->fd = -1; #ifndef __GG_LIBGADU_HAVE_PTHREAD waitpid(sess->pid, NULL, 0); sess->pid = -1; #else if (sess->resolver) { gg_resolve_pthread_cleanup(sess->resolver, 0); sess->resolver = NULL; } #endif if (failed) { errno = errno2; goto fail_resolving; } /* je¶li jeste¶my w resolverze i mamy ustawiony port * proxy, znaczy, ¿e resolvowali¶my proxy. zatem * wpiszmy jego adres. */ if (sess->proxy_port) sess->proxy_addr = addr.s_addr; /* zapiszmy sobie adres huba i adres serwera (do * bezpo¶redniego po³±czenia, je¶li hub le¿y) * z resolvera. */ if (sess->proxy_addr && sess->proxy_port) port = sess->proxy_port; else { sess->server_addr = sess->hub_addr = addr.s_addr; port = GG_APPMSG_PORT; } gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() resolved, connecting to %s:%d\n", inet_ntoa(addr), port); /* ³±czymy siê albo z hubem, albo z proxy, zale¿nie * od tego, co resolvowali¶my. */ if ((sess->fd = gg_connect(&addr, port, sess->async)) == -1) { /* je¶li w trybie asynchronicznym gg_connect() * zwróci b³±d, nie ma sensu próbowaæ dalej. */ gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), critical\n", errno, strerror(errno)); goto fail_connecting; } /* je¶li podano serwer i ³±czmy siê przez proxy, * jest to bezpo¶rednie po³±czenie, inaczej jest * do huba. */ sess->state = (sess->proxy_addr && sess->proxy_port && sess->server_addr) ? GG_STATE_CONNECTING_GG : GG_STATE_CONNECTING_HUB; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } case GG_STATE_CONNECTING_HUB: { char buf[1024], *client, *auth; int res = 0, res_size = sizeof(res); const char *host, *appmsg; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_CONNECTING_HUB\n"); /* je¶li asynchroniczne, sprawdzamy, czy nie wyst±pi³ * przypadkiem jaki¶ b³±d. */ if (sess->async && (getsockopt(sess->fd, SOL_SOCKET, SO_ERROR, &res, &res_size) || res)) { /* no tak, nie uda³o siê po³±czyæ z proxy. nawet * nie próbujemy dalej. */ if (sess->proxy_addr && sess->proxy_port) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection to proxy failed (errno=%d, %s)\n", res, strerror(res)); goto fail_connecting; } gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection to hub failed (errno=%d, %s), trying direct connection\n", res, strerror(res)); close(sess->fd); if ((sess->fd = gg_connect(&sess->hub_addr, GG_DEFAULT_PORT, sess->async)) == -1) { /* przy asynchronicznych, gg_connect() * zwraca -1 przy b³êdach socket(), * ioctl(), braku routingu itd. dlatego * nawet nie próbujemy dalej. */ gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() direct connection failed (errno=%d, %s), critical\n", errno, strerror(errno)); goto fail_connecting; } sess->state = GG_STATE_CONNECTING_GG; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connected to hub, sending query\n"); if (!(client = gg_urlencode((sess->client_version) ? sess->client_version : GG_DEFAULT_CLIENT_VERSION))) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() out of memory for client version\n"); goto fail_connecting; } if (!gg_proxy_http_only && sess->proxy_addr && sess->proxy_port) host = "http://" GG_APPMSG_HOST; else host = ""; #ifdef __GG_LIBGADU_HAVE_OPENSSL if (sess->ssl) appmsg = "appmsg3.asp"; else #endif appmsg = "appmsg2.asp"; auth = gg_proxy_auth(); snprintf(buf, sizeof(buf) - 1, "GET %s/appsvc/%s?fmnumber=%u&version=%s&lastmsg=%d HTTP/1.0\r\n" "Host: " GG_APPMSG_HOST "\r\n" "User-Agent: " GG_HTTP_USERAGENT "\r\n" "Pragma: no-cache\r\n" "%s" "\r\n", host, appmsg, sess->uin, client, sess->last_sysmsg, (auth) ? auth : ""); if (auth) free(auth); free(client); /* zwolnij pamiêæ po wersji klienta. */ if (sess->client_version) { free(sess->client_version); sess->client_version = NULL; } gg_debug(GG_DEBUG_MISC, "=> -----BEGIN-HTTP-QUERY-----\n%s\n=> -----END-HTTP-QUERY-----\n", buf); /* zapytanie jest krótkie, wiêc zawsze zmie¶ci siê * do bufora gniazda. je¶li write() zwróci mniej, * sta³o siê co¶ z³ego. */ if (write(sess->fd, buf, strlen(buf)) < (signed)strlen(buf)) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() sending query failed\n"); e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_WRITING; sess->state = GG_STATE_IDLE; close(sess->fd); sess->fd = -1; break; } sess->state = GG_STATE_READING_DATA; sess->check = GG_CHECK_READ; sess->timeout = GG_DEFAULT_TIMEOUT; break; } case GG_STATE_READING_DATA: { char buf[1024], *tmp, *host; int port = GG_DEFAULT_PORT; struct in_addr addr; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_READING_DATA\n"); /* czytamy liniê z gniazda i obcinamy \r\n. */ gg_read_line(sess->fd, buf, sizeof(buf) - 1); gg_chomp(buf); gg_debug(GG_DEBUG_TRAFFIC, "// gg_watch_fd() received http header (%s)\n", buf); /* sprawdzamy, czy wszystko w porz±dku. */ if (strncmp(buf, "HTTP/1.", 7) || strncmp(buf + 9, "200", 3)) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() that's not what we've expected, trying direct connection\n"); close(sess->fd); /* je¶li otrzymali¶my jakie¶ dziwne informacje, * próbujemy siê ³±czyæ z pominiêciem huba. */ if (sess->proxy_addr && sess->proxy_port) { if ((sess->fd = gg_connect(&sess->proxy_addr, sess->proxy_port, sess->async)) == -1) { /* trudno. nie wysz³o. */ gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection to proxy failed (errno=%d, %s)\n", errno, strerror(errno)); goto fail_connecting; } sess->state = GG_STATE_CONNECTING_GG; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } sess->port = GG_DEFAULT_PORT; /* ³±czymy siê na port 8074 huba. */ if ((sess->fd = gg_connect(&sess->hub_addr, sess->port, sess->async)) == -1) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), trying https\n", errno, strerror(errno)); sess->port = GG_HTTPS_PORT; /* ³±czymy siê na port 443. */ if ((sess->fd = gg_connect(&sess->hub_addr, sess->port, sess->async)) == -1) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno)); goto fail_connecting; } } sess->state = GG_STATE_CONNECTING_GG; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } /* ignorujemy resztê nag³ówka. */ while (strcmp(buf, "\r\n") && strcmp(buf, "")) gg_read_line(sess->fd, buf, sizeof(buf) - 1); /* czytamy pierwsz± liniê danych. */ gg_read_line(sess->fd, buf, sizeof(buf) - 1); gg_chomp(buf); /* je¶li pierwsza liczba w linii nie jest równa zeru, * oznacza to, ¿e mamy wiadomo¶æ systemow±. */ if (atoi(buf)) { char tmp[1024], *foo, *sysmsg_buf = NULL; int len = 0; while (gg_read_line(sess->fd, tmp, sizeof(tmp) - 1)) { if (!(foo = realloc(sysmsg_buf, len + strlen(tmp) + 2))) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() out of memory for system message, ignoring\n"); break; } sysmsg_buf = foo; if (!len) strcpy(sysmsg_buf, tmp); else strcat(sysmsg_buf, tmp); len += strlen(tmp); } e->type = GG_EVENT_MSG; e->event.msg.msgclass = atoi(buf); e->event.msg.sender = 0; e->event.msg.message = sysmsg_buf; } close(sess->fd); gg_debug(GG_DEBUG_TRAFFIC, "// gg_watch_fd() received http data (%s)\n", buf); /* analizujemy otrzymane dane. */ tmp = buf; while (*tmp && *tmp != ' ') tmp++; while (*tmp && *tmp == ' ') tmp++; host = tmp; while (*tmp && *tmp != ' ') tmp++; *tmp = 0; if ((tmp = strchr(host, ':'))) { *tmp = 0; port = atoi(tmp + 1); } if (!strcmp(host, "notoperating")) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() service unavailable\n", errno, strerror(errno)); sess->fd = -1; goto fail_unavailable; } addr.s_addr = inet_addr(host); sess->server_addr = addr.s_addr; if (!gg_proxy_http_only && sess->proxy_addr && sess->proxy_port) { /* je¶li mamy proxy, ³±czymy siê z nim. */ if ((sess->fd = gg_connect(&sess->proxy_addr, sess->proxy_port, sess->async)) == -1) { /* nie wysz³o? trudno. */ gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection to proxy failed (errno=%d, %s)\n", errno, strerror(errno)); goto fail_connecting; } sess->state = GG_STATE_CONNECTING_GG; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } sess->port = port; /* ³±czymy siê z w³a¶ciwym serwerem. */ if ((sess->fd = gg_connect(&addr, sess->port, sess->async)) == -1) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), trying https\n", errno, strerror(errno)); sess->port = GG_HTTPS_PORT; /* nie wysz³o? próbujemy portu 443. */ if ((sess->fd = gg_connect(&addr, GG_HTTPS_PORT, sess->async)) == -1) { /* ostatnia deska ratunku zawiod³a? * w takim razie zwijamy manatki. */ gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno)); goto fail_connecting; } } sess->state = GG_STATE_CONNECTING_GG; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } case GG_STATE_CONNECTING_GG: { int res = 0, res_size = sizeof(res); gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_CONNECTING_GG\n"); /* je¶li wyst±pi³ b³±d podczas ³±czenia siê... */ if (sess->async && (sess->timeout == 0 || getsockopt(sess->fd, SOL_SOCKET, SO_ERROR, &res, &res_size) || res)) { /* je¶li nie uda³o siê po³±czenie z proxy, * nie mamy czego próbowaæ wiêcej. */ if (sess->proxy_addr && sess->proxy_port) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection to proxy failed (errno=%d, %s)\n", res, strerror(res)); goto fail_connecting; } close(sess->fd); sess->fd = -1; #ifdef ETIMEDOUT if (sess->timeout == 0) errno = ETIMEDOUT; #endif #ifdef __GG_LIBGADU_HAVE_OPENSSL /* je¶li logujemy siê po TLS, nie próbujemy * siê ³±czyæ ju¿ z niczym innym w przypadku * b³êdu. nie do¶æ, ¿e nie ma sensu, to i * trzeba by siê bawiæ w tworzenie na nowo * SSL i SSL_CTX. */ if (sess->ssl) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", res, strerror(res)); goto fail_connecting; } #endif gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s), trying https\n", res, strerror(res)); sess->port = GG_HTTPS_PORT; /* próbujemy na port 443. */ if ((sess->fd = gg_connect(&sess->server_addr, sess->port, sess->async)) == -1) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connection failed (errno=%d, %s)\n", errno, strerror(errno)); goto fail_connecting; } } gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() connected\n"); if (gg_proxy_http_only) sess->proxy_port = 0; /* je¶li mamy proxy, wy¶lijmy zapytanie. */ if (sess->proxy_addr && sess->proxy_port) { char buf[100], *auth = gg_proxy_auth(); struct in_addr addr; if (sess->server_addr) addr.s_addr = sess->server_addr; else addr.s_addr = sess->hub_addr; snprintf(buf, sizeof(buf), "CONNECT %s:%d HTTP/1.0\r\n", inet_ntoa(addr), sess->port); gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() proxy request:\n// %s", buf); /* wysy³amy zapytanie. jest ono na tyle krótkie, * ¿e musi siê zmie¶ciæ w buforze gniazda. je¶li * write() zawiedzie, sta³o siê co¶ z³ego. */ if (write(sess->fd, buf, strlen(buf)) < (signed)strlen(buf)) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() can't send proxy request\n"); if (auth) free(auth); goto fail_connecting; } if (auth) { gg_debug(GG_DEBUG_MISC, "// %s", auth); if (write(sess->fd, auth, strlen(auth)) < (signed)strlen(auth)) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() can't send proxy request\n"); free(auth); goto fail_connecting; } free(auth); } if (write(sess->fd, "\r\n", 2) < 2) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() can't send proxy request\n"); goto fail_connecting; } } #ifdef __GG_LIBGADU_HAVE_OPENSSL if (sess->ssl) { SSL_set_fd(sess->ssl, sess->fd); sess->state = GG_STATE_TLS_NEGOTIATION; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } #endif sess->state = GG_STATE_READING_KEY; sess->check = GG_CHECK_READ; sess->timeout = GG_DEFAULT_TIMEOUT; break; } #ifdef __GG_LIBGADU_HAVE_OPENSSL case GG_STATE_TLS_NEGOTIATION: { int res; X509 *peer; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_TLS_NEGOTIATION\n"); if ((res = SSL_connect(sess->ssl)) <= 0) { int err = SSL_get_error(sess->ssl, res); if (res == 0) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() disconnected during TLS negotiation\n"); e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_TLS; sess->state = GG_STATE_IDLE; close(sess->fd); sess->fd = -1; break; } if (err == SSL_ERROR_WANT_READ) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() wants to read\n"); sess->state = GG_STATE_TLS_NEGOTIATION; sess->check = GG_CHECK_READ; sess->timeout = GG_DEFAULT_TIMEOUT; break; } else if (err == SSL_ERROR_WANT_WRITE) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() wants to write\n"); sess->state = GG_STATE_TLS_NEGOTIATION; sess->check = GG_CHECK_WRITE; sess->timeout = GG_DEFAULT_TIMEOUT; break; } else { char buf[1024]; ERR_error_string_n(ERR_get_error(), buf, sizeof(buf)); gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() SSL_connect() bailed out: %s\n", buf); e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_TLS; sess->state = GG_STATE_IDLE; close(sess->fd); sess->fd = -1; break; } } gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() TLS negotiation succeded:\n// cipher: %s\n", SSL_get_cipher_name(sess->ssl)); peer = SSL_get_peer_certificate(sess->ssl); if (!peer) gg_debug(GG_DEBUG_MISC, "// WARNING! unable to get peer certificate!\n"); else { char buf[1024]; X509_NAME_oneline(X509_get_subject_name(peer), buf, sizeof(buf)); gg_debug(GG_DEBUG_MISC, "// cert subject: %s\n", buf); X509_NAME_oneline(X509_get_issuer_name(peer), buf, sizeof(buf)); gg_debug(GG_DEBUG_MISC, "// cert issuer: %s\n", buf); } sess->state = GG_STATE_READING_KEY; sess->check = GG_CHECK_READ; sess->timeout = GG_DEFAULT_TIMEOUT; break; } #endif case GG_STATE_READING_KEY: { struct gg_header *h; struct gg_welcome *w; struct gg_login60 l; unsigned int hash; unsigned char *password = sess->password; int ret; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_READING_KEY\n"); memset(&l, 0, sizeof(l)); l.dunno2 = 0xbe; /* XXX bardzo, bardzo, bardzo g³upi pomys³ na pozbycie * siê tekstu wrzucanego przez proxy. */ if (sess->proxy_addr && sess->proxy_port) { char buf[100]; strcpy(buf, ""); gg_read_line(sess->fd, buf, sizeof(buf) - 1); gg_chomp(buf); gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() proxy response:\n// %s\n", buf); while (strcmp(buf, "")) { gg_read_line(sess->fd, buf, sizeof(buf) - 1); gg_chomp(buf); if (strcmp(buf, "")) gg_debug(GG_DEBUG_MISC, "// %s\n", buf); } /* XXX niech czeka jeszcze raz w tej samej * fazie. g³upio, ale dzia³a. */ sess->proxy_port = 0; break; } /* czytaj pierwszy pakiet. */ if (!(h = gg_recv_packet(sess))) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() didn't receive packet (errno=%d, %s)\n", errno, strerror(errno)); e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_READING; sess->state = GG_STATE_IDLE; errno2 = errno; close(sess->fd); errno = errno2; sess->fd = -1; break; } if (h->type != GG_WELCOME) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() invalid packet received\n"); free(h); close(sess->fd); sess->fd = -1; errno = EINVAL; e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_INVALID; sess->state = GG_STATE_IDLE; break; } w = (struct gg_welcome*) ((char*) h + sizeof(struct gg_header)); w->key = gg_fix32(w->key); hash = gg_login_hash(password, w->key); gg_debug(GG_DEBUG_DUMP, "// gg_watch_fd() challenge %.4x --> hash %.8x\n", w->key, hash); free(h); free(sess->password); sess->password = NULL; { struct in_addr dcc_ip; dcc_ip.s_addr = gg_dcc_ip; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() gg_dcc_ip = %s\n", inet_ntoa(dcc_ip)); } if (gg_dcc_ip == (unsigned long) inet_addr("255.255.255.255")) { struct sockaddr_in sin; int sin_len = sizeof(sin); gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() detecting address\n"); if (!getsockname(sess->fd, (struct sockaddr*) &sin, &sin_len)) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() detected address to %s\n", inet_ntoa(sin.sin_addr)); l.local_ip = sin.sin_addr.s_addr; } else { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() unable to detect address\n"); l.local_ip = 0; } } else l.local_ip = gg_dcc_ip; l.uin = gg_fix32(sess->uin); l.hash = gg_fix32(hash); l.status = gg_fix32(sess->initial_status ? sess->initial_status : GG_STATUS_AVAIL); l.version = gg_fix32(sess->protocol_version); l.local_port = gg_fix16(gg_dcc_port); l.image_size = sess->image_size; if (sess->external_addr && sess->external_port > 1023) { l.external_ip = sess->external_addr; l.external_port = gg_fix16(sess->external_port); } gg_debug(GG_DEBUG_TRAFFIC, "// gg_watch_fd() sending GG_LOGIN60 packet\n"); ret = gg_send_packet(sess, GG_LOGIN60, &l, sizeof(l), sess->initial_descr, (sess->initial_descr) ? strlen(sess->initial_descr) : 0, NULL); free(sess->initial_descr); sess->initial_descr = NULL; if (ret == -1) { gg_debug(GG_DEBUG_TRAFFIC, "// gg_watch_fd() sending packet failed. (errno=%d, %s)\n", errno, strerror(errno)); errno2 = errno; close(sess->fd); errno = errno2; sess->fd = -1; e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_WRITING; sess->state = GG_STATE_IDLE; break; } sess->state = GG_STATE_READING_REPLY; break; } case GG_STATE_READING_REPLY: { struct gg_header *h; gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_READING_REPLY\n"); if (!(h = gg_recv_packet(sess))) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() didn't receive packet (errno=%d, %s)\n", errno, strerror(errno)); e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_READING; sess->state = GG_STATE_IDLE; errno2 = errno; close(sess->fd); errno = errno2; sess->fd = -1; break; } if (h->type == GG_LOGIN_OK || h->type == GG_NEED_EMAIL) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() login succeded\n"); e->type = GG_EVENT_CONN_SUCCESS; sess->state = GG_STATE_CONNECTED; sess->timeout = -1; sess->status = (sess->initial_status) ? sess->initial_status : GG_STATUS_AVAIL; free(h); break; } if (h->type == GG_LOGIN_FAILED) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() login failed\n"); e->event.failure = GG_FAILURE_PASSWORD; errno = EACCES; } else if (h->type == GG_DISCONNECTING) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() too many incorrect password attempts\n"); e->event.failure = GG_FAILURE_INTRUDER; errno = EACCES; } else { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() invalid packet\n"); e->event.failure = GG_FAILURE_INVALID; errno = EINVAL; } e->type = GG_EVENT_CONN_FAILED; sess->state = GG_STATE_IDLE; errno2 = errno; close(sess->fd); errno = errno2; sess->fd = -1; free(h); break; } case GG_STATE_CONNECTED: { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() GG_STATE_CONNECTED\n"); sess->last_event = time(NULL); if ((res = gg_watch_fd_connected(sess, e)) == -1) { gg_debug(GG_DEBUG_MISC, "// gg_watch_fd() watch_fd_connected failed (errno=%d, %s)\n", errno, strerror(errno)); if (errno == EAGAIN) { e->type = GG_EVENT_NONE; res = 0; } else res = -1; } break; } } done: if (res == -1) { free(e); e = NULL; } return e; fail_connecting: if (sess->fd != -1) { errno2 = errno; close(sess->fd); errno = errno2; sess->fd = -1; } e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_CONNECTING; sess->state = GG_STATE_IDLE; goto done; fail_resolving: e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_RESOLVING; sess->state = GG_STATE_IDLE; goto done; fail_unavailable: e->type = GG_EVENT_CONN_FAILED; e->event.failure = GG_FAILURE_UNAVAILABLE; sess->state = GG_STATE_IDLE; goto done; }
/** * \internal Obsługuje pakiet informacji o połączeniu bezpośrednim. * * \param sess Struktura sesji * \param e Struktura zdarzenia * \param payload Treść pakietu * \param len Długość pakietu * * \return 0 jeśli się powiodło, -1 w przypadku błędu */ int gg_dcc7_handle_info(struct gg_session *sess, struct gg_event *e, void *payload, int len) { struct gg_dcc7_info *p = payload; struct gg_dcc7 *dcc; char *tmp; gg_debug_session(sess, GG_DEBUG_FUNCTION, "** gg_dcc7_handle_info(%p, %p, %p, %d)\n", sess, e, payload, len); gg_debug_session(sess, GG_DEBUG_FUNCTION, "// gg_dcc7_handle_info() received address: %s, hash: %s\n", p->info, p->hash); if (!(dcc = gg_dcc7_session_find(sess, p->id, gg_fix32(p->uin)))) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() unknown dcc session\n"); return 0; } if (dcc->state == GG_STATE_CONNECTED) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() state is already connected\n"); return 0; } switch (p->type) { case GG_DCC7_TYPE_P2P: if ((dcc->remote_addr = inet_addr(p->info)) == INADDR_NONE) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() invalid IP address\n"); e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_HANDSHAKE; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } if (!(tmp = strchr(p->info, ' ')) || !(dcc->remote_port = atoi(tmp + 1))) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() invalid IP port\n"); e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_HANDSHAKE; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } if (dcc->state == GG_STATE_WAITING_FOR_INFO) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() wainting for info so send one\n"); gg_dcc7_listen_and_send_info(dcc); return 0; } break; case GG_DCC7_TYPE_SERVER: if (!(tmp = strstr(p->info, "GG"))) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() unknown info packet\n"); e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_HANDSHAKE; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } #if defined(GG_CONFIG_HAVE_UINT64_T) && defined(GG_CONFIG_HAVE_STRTOULL) { uint64_t cid; cid = strtoull(tmp + 2, NULL, 0); gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() info.str=%s, info.id=%llu, sess.id=%llu\n", tmp + 2, cid, *((unsigned long long*) &dcc->cid)); cid = gg_fix64(cid); if (memcmp(&dcc->cid, &cid, sizeof(cid)) != 0) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() invalid session id\n"); e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_HANDSHAKE; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } } #endif if (gg_dcc7_get_relay_addr(dcc) == -1) { gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() unable to retrieve relay address\n"); e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_RELAY; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } // XXX wysyłać dopiero jeśli uda się połączyć z serwerem? gg_send_packet(dcc->sess, GG_DCC7_INFO, payload, len, NULL); break; default: gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() unhandled transfer type (%d)\n", p->type); e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_HANDSHAKE; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } // jeśli nadal czekamy na połączenie przychodzące, a druga strona nie // daje rady i oferuje namiary na siebie, bierzemy co dają. // if (dcc->state != GG_STATE_WAITING_FOR_INFO && (dcc->state != GG_STATE_LISTENING || dcc->reverse)) { // gg_debug_session(sess, GG_DEBUG_MISC, "// gg_dcc7_handle_info() invalid state\n"); // e->type = GG_EVENT_DCC7_ERROR; // e->event.dcc7_error = GG_ERROR_DCC7_HANDSHAKE; // e->event.dcc7_error_ex.dcc7 = dcc; // return 0; // } if (dcc->state == GG_STATE_LISTENING) { gg_sock_close(dcc->fd); dcc->fd = -1; dcc->reverse = 1; } if (dcc->type == GG_SESSION_DCC7_SEND) { e->type = GG_EVENT_DCC7_ACCEPT; e->event.dcc7_accept.dcc7 = dcc; e->event.dcc7_accept.type = gg_fix32(p->type); e->event.dcc7_accept.remote_ip = dcc->remote_addr; e->event.dcc7_accept.remote_port = dcc->remote_port; } else { e->type = GG_EVENT_DCC7_PENDING; e->event.dcc7_pending.dcc7 = dcc; } if (dcc->state == GG_STATE_RESOLVING_RELAY) return 0; if (gg_dcc7_connect(dcc) == -1) { if (gg_dcc7_reverse_connect(dcc) == -1) { e->type = GG_EVENT_DCC7_ERROR; e->event.dcc7_error = GG_ERROR_DCC7_NET; e->event.dcc7_error_ex.dcc7 = dcc; return 0; } } return 0; }