/**
* Rejestruje nowego użytkownika.
*
* Wymaga wcześniejszego pobrania tokenu za pomocą \c gg_token().
*
* \param email Adres e-mail
* \param password Hasło
* \param tokenid Identyfikator tokenu
* \param tokenval Zawartość tokenu
* \param async Flaga połączenia asynchronicznego
*
* \return Struktura \c gg_http lub \c NULL w przypadku błędu
*
* \ingroup register
*/
struct gg_http *gg_register3(const char *email, const char *password, const char *tokenid, const char *tokenval, int async)
{
struct gg_http *h;
char *__pwd, *__email, *__tokenid, *__tokenval, *form, *query;
if (!email || !password || !tokenid || !tokenval) {
gg_debug(GG_DEBUG_MISC, "=> register, NULL parameter\n");
errno = EFAULT;
return NULL;
}
__pwd = gg_urlencode(password);
__email = gg_urlencode(email);
__tokenid = gg_urlencode(tokenid);
__tokenval = gg_urlencode(tokenval);
if (!__pwd || !__email || !__tokenid || !__tokenval) {
gg_debug(GG_DEBUG_MISC, "=> register, not enough memory for form fields\n");
free(__pwd);
free(__email);
free(__tokenid);
free(__tokenval);
return NULL;
}
form = gg_saprintf("pwd=%s&email=%s&tokenid=%s&tokenval=%s&code=%u",
__pwd, __email, __tokenid, __tokenval,
gg_http_hash("ss", email, password));
free(__pwd);
free(__email);
free(__tokenid);
free(__tokenval);
if (!form) {
gg_debug(GG_DEBUG_MISC, "=> register, not enough memory for form query\n");
return NULL;
}
gg_debug(GG_DEBUG_MISC, "=> register, %s\n", form);
query = gg_saprintf(
"Host: " GG_REGISTER_HOST "\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"User-Agent: " GG_HTTP_USERAGENT "\r\n"
"Content-Length: %d\r\n"
"Pragma: no-cache\r\n"
"\r\n"
"%s",
(int) strlen(form), form);
free(form);
if (!query) {
gg_debug(GG_DEBUG_MISC, "=> register, not enough memory for query\n");
return NULL;
}
if (!(h = gg_http_connect(GG_REGISTER_HOST, GG_REGISTER_PORT, async, "POST", "/appsvc/fmregister3.asp", query))) {
gg_debug(GG_DEBUG_MISC, "=> register, gg_http_connect() failed mysteriously\n");
free(query);
return NULL;
}
h->type = GG_SESSION_REGISTER;
free(query);
h->callback = gg_pubdir_watch_fd;
h->destroy = gg_pubdir_free;
if (!async)
gg_pubdir_watch_fd(h);
return h;
}
/**
* Wysyła hasło użytkownika na e-mail.
*
* Wymaga wcześniejszego pobrania tokenu za pomocą \c gg_token().
*
* \param uin Numer Gadu-Gadu
* \param email Adres e-mail (podany przy rejestracji)
* \param tokenid Identyfikator tokenu
* \param tokenval Zawartość tokenu
* \param async Flaga połączenia asynchronicznego
*
* \return Struktura \c gg_http lub \c NULL w przypadku błędu
*
* \ingroup remind
*/
struct gg_http *gg_remind_passwd3(uin_t uin, const char *email, const char *tokenid, const char *tokenval, int async)
{
struct gg_http *h;
char *form, *query, *__tokenid, *__tokenval, *__email;
if (!tokenid || !tokenval || !email) {
gg_debug(GG_DEBUG_MISC, "=> remind, NULL parameter\n");
errno = EFAULT;
return NULL;
}
__tokenid = gg_urlencode(tokenid);
__tokenval = gg_urlencode(tokenval);
__email = gg_urlencode(email);
if (!__tokenid || !__tokenval || !__email) {
gg_debug(GG_DEBUG_MISC, "=> remind, not enough memory for form fields\n");
free(__tokenid);
free(__tokenval);
free(__email);
return NULL;
}
if (!(form = gg_saprintf("userid=%d&code=%u&tokenid=%s&tokenval=%s&email=%s", uin, gg_http_hash("u", uin), __tokenid, __tokenval, __email))) {
gg_debug(GG_DEBUG_MISC, "=> remind, not enough memory for form fields\n");
free(__tokenid);
free(__tokenval);
free(__email);
return NULL;
}
free(__tokenid);
free(__tokenval);
free(__email);
gg_debug(GG_DEBUG_MISC, "=> remind, %s\n", form);
query = gg_saprintf(
"Host: " GG_REMIND_HOST "\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"User-Agent: " GG_HTTP_USERAGENT "\r\n"
"Content-Length: %d\r\n"
"Pragma: no-cache\r\n"
"\r\n"
"%s",
(int) strlen(form), form);
free(form);
if (!query) {
gg_debug(GG_DEBUG_MISC, "=> remind, not enough memory for query\n");
return NULL;
}
if (!(h = gg_http_connect(GG_REMIND_HOST, GG_REMIND_PORT, async, "POST", "/appsvc/fmsendpwd3.asp", query))) {
gg_debug(GG_DEBUG_MISC, "=> remind, gg_http_connect() failed mysteriously\n");
free(query);
return NULL;
}
h->type = GG_SESSION_REMIND;
free(query);
h->callback = gg_pubdir_watch_fd;
h->destroy = gg_pubdir_free;
if (!async)
gg_pubdir_watch_fd(h);
return h;
}
/*
* gg_change_passwd4()
*
* wysy³a ¿±danie zmiany has³a zgodnie z protoko³em GG 6.0. wymaga
* wcze¶niejszego pobrania tokenu za pomoc± funkcji gg_token().
*
* - uin - numer
* - email - adres e-mail
* - passwd - stare has³o
* - newpasswd - nowe has³o
* - tokenid - identyfikator tokenu
* - tokenval - warto¶æ tokenu
* - async - po³±czenie asynchroniczne
*
* zaalokowana struct gg_http, któr± po¼niej nale¿y zwolniæ
* funkcj± gg_change_passwd_free(), albo NULL je¶li wyst±pi³ b³±d.
*/
struct gg_http *gg_change_passwd4(uin_t uin, const char *email, const char *passwd, const char *newpasswd, const char *tokenid, const char *tokenval, int async)
{
struct gg_http *h;
char *form, *query, *__email, *__fmpwd, *__pwd, *__tokenid, *__tokenval;
if (!uin || !email || !passwd || !newpasswd || !tokenid || !tokenval) {
gg_debug(GG_DEBUG_MISC, "=> change, NULL parameter\n");
errno = EINVAL;
return NULL;
}
__fmpwd = gg_urlencode(passwd);
__pwd = gg_urlencode(newpasswd);
__email = gg_urlencode(email);
__tokenid = gg_urlencode(tokenid);
__tokenval = gg_urlencode(tokenval);
if (!__fmpwd || !__pwd || !__email || !__tokenid || !__tokenval) {
gg_debug(GG_DEBUG_MISC, "=> change, not enough memory for form fields\n");
free(__fmpwd);
free(__pwd);
free(__email);
free(__tokenid);
free(__tokenval);
errno = ENOMEM;
return NULL;
}
if (!(form = gg_saprintf("fmnumber=%d&fmpwd=%s&pwd=%s&email=%s&tokenid=%s&tokenval=%s&code=%u", uin, __fmpwd, __pwd, __email, __tokenid, __tokenval, gg_http_hash("ss", email, newpasswd)))) {
gg_debug(GG_DEBUG_MISC, "=> change, not enough memory for form fields\n");
free(__fmpwd);
free(__pwd);
free(__email);
free(__tokenid);
free(__tokenval);
errno = ENOMEM;
return NULL;
}
free(__fmpwd);
free(__pwd);
free(__email);
free(__tokenid);
free(__tokenval);
gg_debug(GG_DEBUG_MISC, "=> change, %s\n", form);
query = gg_saprintf(
"Host: " GG_REGISTER_HOST "\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"User-Agent: " GG_HTTP_USERAGENT "\r\n"
"Content-Length: %d\r\n"
"Pragma: no-cache\r\n"
"\r\n"
"%s",
(int) strlen(form), form);
free(form);
if (!(h = gg_http_connect(GG_REGISTER_HOST, GG_REGISTER_PORT, async, "POST", "/appsvc/fmregister3.asp", query))) {
gg_debug(GG_DEBUG_MISC, "=> change, gg_http_connect() failed mysteriously\n");
free(query);
return NULL;
}
h->type = GG_SESSION_PASSWD;
free(query);
h->callback = gg_pubdir_watch_fd;
h->destroy = gg_pubdir_free;
if (!async)
gg_pubdir_watch_fd(h);
return h;
}
/*
* 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;
}
/*
* gg_unregister3()
*
* usuwa konto u¿ytkownika z serwera protoko³em GG 6.0
*
* - uin - numerek GG
* - password - has³o klienta
* - tokenid - identyfikator tokenu
* - tokenval - warto¶æ tokenu
* - async - po³±czenie asynchroniczne
*
* zaalokowana struct gg_http, któr± po¼niej nale¿y zwolniæ
* funkcj± gg_unregister_free(), albo NULL je¶li wyst±pi³ b³±d.
*/
struct gg_http *gg_unregister3(uin_t uin, const char *password, const char *tokenid, const char *tokenval, int async)
{
struct gg_http *h;
char *__fmpwd, *__pwd, *__tokenid, *__tokenval, *form, *query;
if (!password || !tokenid || !tokenval) {
gg_debug(GG_DEBUG_MISC, "=> unregister, NULL parameter\n");
errno = EINVAL;
return NULL;
}
__pwd = gg_saprintf("%ld", random());
__fmpwd = gg_urlencode(password);
__tokenid = gg_urlencode(tokenid);
__tokenval = gg_urlencode(tokenval);
if (!__fmpwd || !__pwd || !__tokenid || !__tokenval) {
gg_debug(GG_DEBUG_MISC, "=> unregister, not enough memory for form fields\n");
free(__pwd);
free(__fmpwd);
free(__tokenid);
free(__tokenval);
errno = ENOMEM;
return NULL;
}
form = gg_saprintf("fmnumber=%d&fmpwd=%s&delete=1&pwd=%s&[email protected]&tokenid=%s&tokenval=%s&code=%u", uin, __fmpwd, __pwd, __tokenid, __tokenval, gg_http_hash("ss", "*****@*****.**", __pwd));
free(__fmpwd);
free(__pwd);
free(__tokenid);
free(__tokenval);
if (!form) {
gg_debug(GG_DEBUG_MISC, "=> unregister, not enough memory for form query\n");
errno = ENOMEM;
return NULL;
}
gg_debug(GG_DEBUG_MISC, "=> unregister, %s\n", form);
query = gg_saprintf(
"Host: " GG_REGISTER_HOST "\r\n"
"Content-Type: application/x-www-form-urlencoded\r\n"
"User-Agent: " GG_HTTP_USERAGENT "\r\n"
"Content-Length: %d\r\n"
"Pragma: no-cache\r\n"
"\r\n"
"%s",
(int) strlen(form), form);
free(form);
if (!(h = gg_http_connect(GG_REGISTER_HOST, GG_REGISTER_PORT, async, "POST", "/appsvc/fmregister3.asp", query))) {
gg_debug(GG_DEBUG_MISC, "=> unregister, gg_http_connect() failed mysteriously\n");
free(query);
return NULL;
}
h->type = GG_SESSION_UNREGISTER;
free(query);
h->callback = gg_pubdir_watch_fd;
h->destroy = gg_pubdir_free;
if (!async)
gg_pubdir_watch_fd(h);
return h;
}
