static void
connect_cb(gpointer data, gint source, const gchar *error_message)
{
MsnServConn *servconn;
servconn = data;
servconn->connect_data = NULL;
servconn->processing = FALSE;
if (servconn->wasted)
{
if (source >= 0)
close(source);
msn_servconn_destroy(servconn);
return;
}
servconn->fd = source;
if (source >= 0)
{
servconn->connected = TRUE;
/* Someone wants to know we connected. */
servconn->connect_cb(servconn);
servconn->inpa = gaim_input_add(servconn->fd, GAIM_INPUT_READ,
read_cb, data);
}
else
{
msn_servconn_got_error(servconn, MSN_SERVCONN_ERROR_CONNECT);
}
}
static void
begin_transfer(GaimXfer *xfer, GaimInputCondition cond)
{
GaimXferUiOps *ui_ops;
GaimXferType type = gaim_xfer_get_type(xfer);
ui_ops = gaim_xfer_get_ui_ops(xfer);
/*
* We'll have already tried to open this earlier to make sure we can
* read/write here. Should be safe.
*/
xfer->dest_fp = fopen(gaim_xfer_get_local_filename(xfer),
type == GAIM_XFER_RECEIVE ? "wb" : "rb");
/* Just in case, though. */
if (xfer->dest_fp == NULL) {
gaim_xfer_cancel_local(xfer); /* ? */
return;
}
xfer->watcher = gaim_input_add(xfer->fd, cond, transfer_cb, xfer);
if (ui_ops != NULL && ui_ops->add_xfer != NULL)
ui_ops->add_xfer(xfer);
if (xfer->ops.start != NULL)
xfer->ops.start(xfer);
}
gint qq_proxy_socks5(struct PHB *phb, struct sockaddr *addr, socklen_t addrlen)
{
gint fd;
gaim_debug(GAIM_DEBUG_INFO, "QQ",
"Connecting to %s:%d via %s:%d using SOCKS5\n",
phb->host, phb->port, gaim_proxy_info_get_host(phb->gpi), gaim_proxy_info_get_port(phb->gpi));
if ((fd = socket(addr->sa_family, SOCK_STREAM, 0)) < 0)
return -1;
gaim_debug(GAIM_DEBUG_INFO, "QQ", "proxy_sock5 return fd=%d\n", fd);
fcntl(fd, F_SETFL, O_NONBLOCK);
if (connect(fd, addr, addrlen) < 0) {
if ((errno == EINPROGRESS) || (errno == EINTR)) {
gaim_debug(GAIM_DEBUG_WARNING, "QQ", "Connect in asynchronous mode.\n");
phb->inpa = gaim_input_add(fd, GAIM_INPUT_WRITE, _qq_s5_canwrite, phb);
} else {
close(fd);
return -1;
}
} else {
gaim_debug(GAIM_DEBUG_MISC, "QQ", "Connect in blocking mode.\n");
fcntl(fd, F_SETFL, 0);
_qq_s5_canwrite(phb, fd, GAIM_INPUT_WRITE);
}
return fd;
}
static void _qq_s5_canwrite(gpointer data, gint source, GaimInputCondition cond)
{
unsigned char buf[512];
int i;
struct PHB *phb = data;
unsigned int len;
int error = ETIMEDOUT;
gaim_debug(GAIM_DEBUG_INFO, "socks5 proxy", "Connected.\n");
if (phb->inpa > 0)
gaim_input_remove(phb->inpa);
len = sizeof(error);
if (getsockopt(source, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
gaim_debug(GAIM_DEBUG_INFO, "getsockopt", "%s\n", strerror(errno));
close(source);
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
fcntl(source, F_SETFL, 0);
i = 0;
buf[0] = 0x05; /* SOCKS version 5 */
if (gaim_proxy_info_get_username(phb->gpi) != NULL) {
buf[1] = 0x02; /* two methods */
buf[2] = 0x00; /* no authentication */
buf[3] = 0x02; /* username/password authentication */
i = 4;
} else {
buf[1] = 0x01;
buf[2] = 0x00;
i = 3;
}
if (write(source, buf, i) < i) {
gaim_debug(GAIM_DEBUG_INFO, "write", "%s\n", strerror(errno));
gaim_debug(GAIM_DEBUG_ERROR, "socks5 proxy", "Unable to write\n");
close(source);
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, _qq_s5_canread, phb);
}
static void
jabber_si_xfer_bytestreams_listen_cb(int sock, gpointer data)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx;
JabberIq *iq;
xmlnode *query, *streamhost;
char *jid, *port;
jsx = xfer->data;
jsx->listen_data = NULL;
if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL) {
gaim_xfer_unref(xfer);
return;
}
gaim_xfer_unref(xfer);
if (sock < 0) {
gaim_xfer_cancel_local(xfer);
return;
}
iq = jabber_iq_new_query(jsx->js, JABBER_IQ_SET,
"http://jabber.org/protocol/bytestreams");
xmlnode_set_attrib(iq->node, "to", xfer->who);
query = xmlnode_get_child(iq->node, "query");
xmlnode_set_attrib(query, "sid", jsx->stream_id);
streamhost = xmlnode_new_child(query, "streamhost");
jid = g_strdup_printf("%s@%s/%s", jsx->js->user->node,
jsx->js->user->domain, jsx->js->user->resource);
xmlnode_set_attrib(streamhost, "jid", jid);
g_free(jid);
/* XXX: shouldn't we use the public IP or something? here */
xmlnode_set_attrib(streamhost, "host",
gaim_network_get_my_ip(jsx->js->fd));
xfer->local_port = gaim_network_get_port_from_fd(sock);
port = g_strdup_printf("%hu", xfer->local_port);
xmlnode_set_attrib(streamhost, "port", port);
g_free(port);
xfer->watcher = gaim_input_add(sock, GAIM_INPUT_READ,
jabber_si_xfer_bytestreams_send_connected_cb, xfer);
/* XXX: insert proxies here */
/* XXX: callback to find out which streamhost they used, or see if they
* screwed it up */
jabber_iq_send(iq);
}
ssize_t
msn_servconn_write(MsnServConn *servconn, const char *buf, size_t len)
{
ssize_t ret = 0;
g_return_val_if_fail(servconn != NULL, 0);
if (!servconn->session->http_method)
{
if (servconn->tx_handler == -1) {
switch (servconn->type)
{
case MSN_SERVCONN_NS:
case MSN_SERVCONN_SB:
ret = write(servconn->fd, buf, len);
break;
#if 0
case MSN_SERVCONN_DC:
ret = write(servconn->fd, &buf, sizeof(len));
ret = write(servconn->fd, buf, len);
break;
#endif
default:
ret = write(servconn->fd, buf, len);
break;
}
} else {
ret = -1;
errno = EAGAIN;
}
if (ret < 0 && errno == EAGAIN)
ret = 0;
if (ret < len) {
if (servconn->tx_handler == -1)
servconn->tx_handler = gaim_input_add(
servconn->fd, GAIM_INPUT_WRITE,
servconn_write_cb, servconn);
gaim_circ_buffer_append(servconn->tx_buf, buf + ret,
len - ret);
}
}
else
{
ret = msn_httpconn_write(servconn->httpconn, buf, len);
}
if (ret == -1)
{
msn_servconn_got_error(servconn, MSN_SERVCONN_ERROR_WRITE);
}
return ret;
}
void
gaim_ssl_input_add(GaimSslConnection *gsc, GaimSslInputFunction func,
void *data)
{
g_return_if_fail(func != NULL);
g_return_if_fail(gaim_ssl_is_supported());
gsc->recv_cb_data = data;
gsc->recv_cb = func;
gsc->inpa = gaim_input_add(gsc->fd, GAIM_INPUT_READ, recv_cb, gsc);
}
static void
connect_cb(gpointer data, gint source, const gchar *error_message)
{
MsnDirectConn* directconn;
int fd;
gaim_debug_misc("msn", "directconn: connect_cb: %d\n", source);
directconn = data;
directconn->connect_data = NULL;
if (TRUE)
{
fd = source;
}
else
{
struct sockaddr_in client_addr;
unsigned int client;
fd = accept (source, (struct sockaddr *)&client_addr, &client);
}
directconn->fd = fd;
if (fd > 0)
{
directconn->inpa = gaim_input_add(fd, GAIM_INPUT_READ, read_cb,
directconn);
if (TRUE)
{
/* Send foo. */
msn_directconn_write(directconn, "foo", strlen("foo") + 1);
/* Send Handshake */
msn_directconn_send_handshake(directconn);
}
else
{
}
}
else
{
/* ERROR */
gaim_debug_error("msn", "could not add input\n");
if (directconn->inpa)
gaim_input_remove(directconn->inpa);
close(directconn->fd);
}
}
static void
irc_dccsend_network_listen_cb(int sock, gpointer data)
{
GaimXfer *xfer = data;
struct irc_xfer_send_data *xd;
GaimConnection *gc;
struct irc_conn *irc;
const char *arg[2];
char *tmp;
struct in_addr addr;
unsigned short int port;
xd = xfer->data;
xd->listen_data = NULL;
if (gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_LOCAL
|| gaim_xfer_get_status(xfer) == GAIM_XFER_STATUS_CANCEL_REMOTE) {
gaim_xfer_unref(xfer);
return;
}
xd = xfer->data;
gc = gaim_account_get_connection(gaim_xfer_get_account(xfer));
irc = gc->proto_data;
gaim_xfer_unref(xfer);
if (sock < 0) {
gaim_notify_error(gc, NULL, _("File Transfer Failed"),
_("Gaim could not open a listening port."));
gaim_xfer_cancel_local(xfer);
return;
}
xd->fd = sock;
port = gaim_network_get_port_from_fd(sock);
gaim_debug_misc("irc", "port is %hu\n", port);
/* Monitor the listening socket */
xfer->watcher = gaim_input_add(sock, GAIM_INPUT_READ,
irc_dccsend_send_connected, xfer);
/* Send the intended recipient the DCC request */
arg[0] = xfer->who;
inet_aton(gaim_network_get_my_ip(irc->fd), &addr);
arg[1] = tmp = g_strdup_printf("\001DCC SEND \"%s\" %u %hu %" G_GSIZE_FORMAT "\001",
xfer->filename, ntohl(addr.s_addr),
port, xfer->size);
irc_cmd_privmsg(gc->proto_data, "msg", NULL, arg);
g_free(tmp);
}
static void irc_login_cb(gpointer data, gint source, const gchar *error_message)
{
GaimConnection *gc = data;
struct irc_conn *irc = gc->proto_data;
if (source < 0) {
gaim_connection_error(gc, _("Couldn't connect to host"));
return;
}
irc->fd = source;
if (do_login(gc)) {
gc->inpa = gaim_input_add(irc->fd, GAIM_INPUT_READ, irc_input_cb, gc);
}
}
static void ice_connection_watch(IceConn connection, IcePointer client_data,
Bool opening, IcePointer *watch_data) {
struct ice_connection_info *conninfo = NULL;
if (opening) {
gaim_debug(GAIM_DEBUG_INFO, "Session Management",
"Handling new ICE connection... ");
/* ensure ICE connection is not passed to child processes */
fcntl(IceConnectionNumber(connection), F_SETFD, FD_CLOEXEC);
conninfo = g_new(struct ice_connection_info, 1);
conninfo->connection = connection;
/* watch the connection */
conninfo->input_id = gaim_input_add(IceConnectionNumber(connection), GAIM_INPUT_READ,
ice_process_messages, conninfo);
*watch_data = conninfo;
} else {
void
msn_directconn_listen(MsnDirectConn *directconn)
{
int port;
int fd;
port = 7000;
for (fd = -1; fd < 0;)
fd = create_listener(++port);
directconn->fd = fd;
directconn->inpa = gaim_input_add(fd, GAIM_INPUT_READ, connect_cb,
directconn);
directconn->port = port;
directconn->c = 0;
}
/*
* This function is called after the user has selected a file to send.
*/
static void gaym_dccsend_send_init(GaimXfer *xfer) {
struct gaym_xfer_send_data *xd = xfer->data;
GaimConnection *gc = gaim_account_get_connection(gaim_xfer_get_account(xfer));
struct gaym_conn *gaym = gc->proto_data;
int sock;
const char *arg[2];
char *tmp;
struct in_addr addr;
unsigned short int port;
xfer->filename = g_path_get_basename(xfer->local_filename);
/* Create a listening socket */
sock = gaim_network_listen_range(0, 0);
if (sock < 0) {
gaim_notify_error(gc, NULL, _("File Transfer Aborted"),
_("Gaim could not open a listening port."));
gaim_xfer_cancel_local(xfer);
return;
}
xd->fd = sock;
port = gaim_network_get_port_from_fd(sock);
gaim_debug_misc("gaym", "port is %hu\n", port);
/* Monitor the listening socket */
xfer->watcher = gaim_input_add(sock, GAIM_INPUT_READ,
gaym_dccsend_send_connected, xfer);
/* Send the intended recipient the DCC request */
arg[0] = xfer->who;
inet_aton(gaim_network_get_my_ip(gaym->fd), &addr);
arg[1] = tmp = g_strdup_printf("\001DCC SEND \"%s\" %u %hu %zu\001",
xfer->filename, ntohl(addr.s_addr),
port, xfer->size);
gaym_cmd_privmsg(xfer->account->gc->proto_data, "msg", NULL, arg);
g_free(tmp);
}
static void
jabber_si_xfer_bytestreams_send_read_response_cb(gpointer data, gint source,
GaimInputCondition cond)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx = xfer->data;
int len;
len = write(source, jsx->rxqueue + jsx->rxlen, jsx->rxmaxlen - jsx->rxlen);
if (len < 0 && errno == EAGAIN)
return;
else if (len < 0) {
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
g_free(jsx->rxqueue);
jsx->rxqueue = NULL;
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
jsx->rxlen += len;
if (jsx->rxlen < jsx->rxmaxlen)
return;
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
if (jsx->rxqueue[1] == 0x00) {
xfer->watcher = gaim_input_add(source, GAIM_INPUT_READ,
jabber_si_xfer_bytestreams_send_read_again_cb, xfer);
g_free(jsx->rxqueue);
jsx->rxqueue = NULL;
} else {
close(source);
gaim_xfer_cancel_remote(xfer);
}
}
int yahoo_packet_send(struct yahoo_packet *pkt, struct yahoo_data *yd)
{
size_t len;
int ret;
guchar *data;
if (yd->fd < 0)
return -1;
len = yahoo_packet_build(pkt, 0, yd->wm, yd->jp, &data);
yahoo_packet_dump(data, len);
if (yd->txhandler == -1)
ret = write(yd->fd, data, len);
else {
ret = -1;
errno = EAGAIN;
}
if (ret < 0 && errno == EAGAIN)
ret = 0;
else if (ret <= 0) {
gaim_debug_warning("yahoo", "Only wrote %d of %d bytes!", ret, len);
g_free(data);
return ret;
}
if (ret < len) {
if (yd->txhandler == -1)
yd->txhandler = gaim_input_add(yd->fd, GAIM_INPUT_WRITE,
yahoo_packet_send_can_write, yd);
gaim_circ_buffer_append(yd->txbuf, data + ret, len - ret);
}
g_free(data);
return ret;
}
int irc_send(struct irc_conn *irc, const char *buf)
{
int ret, buflen;
char *tosend= g_strdup(buf);
gaim_signal_emit(_irc_plugin, "irc-sending-text", gaim_account_get_connection(irc->account), &tosend);
if (tosend == NULL)
return 0;
buflen = strlen(tosend);
/* If we're not buffering writes, try to send immediately */
if (!irc->writeh)
ret = do_send(irc, tosend, buflen);
else {
ret = -1;
errno = EAGAIN;
}
/* gaim_debug(GAIM_DEBUG_MISC, "irc", "sent%s: %s",
irc->gsc ? " (ssl)" : "", tosend); */
if (ret <= 0 && errno != EAGAIN) {
gaim_connection_error(gaim_account_get_connection(irc->account),
_("Server has disconnected"));
} else if (ret < buflen) {
if (ret < 0)
ret = 0;
if (!irc->writeh)
irc->writeh = gaim_input_add(
irc->gsc ? irc->gsc->fd : irc->fd,
GAIM_INPUT_WRITE, irc_send_cb, irc);
gaim_circ_buffer_append(irc->outbuf, tosend + ret,
buflen - ret);
}
g_free(tosend);
return ret;
}
static void
jabber_si_xfer_bytestreams_send_connected_cb(gpointer data, gint source,
GaimInputCondition cond)
{
GaimXfer *xfer = data;
int acceptfd;
gaim_debug_info("jabber", "in jabber_si_xfer_bytestreams_send_connected_cb\n");
acceptfd = accept(source, NULL, 0);
if(acceptfd == -1 && (errno == EAGAIN || errno == EWOULDBLOCK))
return;
else if(acceptfd == -1) {
gaim_debug_warning("jabber", "accept: %s\n", strerror(errno));
return;
}
gaim_input_remove(xfer->watcher);
close(source);
xfer->watcher = gaim_input_add(acceptfd, GAIM_INPUT_READ,
jabber_si_xfer_bytestreams_send_read_cb, xfer);
}
static void irc_dccsend_send_connected(gpointer data, int source, GaimInputCondition cond) {
GaimXfer *xfer = (GaimXfer *) data;
struct irc_xfer_send_data *xd = xfer->data;
int conn;
conn = accept(xd->fd, NULL, 0);
if (conn == -1) {
/* Accepting the connection failed. This could just be related
* to the nonblocking nature of the listening socket, so we'll
* just try again next time */
/* Let's print an error message anyway */
gaim_debug_warning("irc", "accept: %s\n", strerror(errno));
return;
}
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
close(xd->fd);
xd->fd = -1;
xd->inpa = gaim_input_add(conn, GAIM_INPUT_READ, irc_dccsend_send_read, xfer);
/* Start the transfer */
gaim_xfer_start(xfer, conn, NULL, 0);
}
// This is a modified version of gaim's url_fetched_cb function. It has
// been
// modified to pass cookies during requests. The cookies are set in
// user_data,
// cast as a GaimUrlSession item. Any cookies in the response are added to
//
//
//
//
// this
// structure, as well.
static void
session_fetched_cb(gpointer url_data, gint sock, GaimInputCondition cond)
{
GaimFetchUrlData *gfud = url_data;
char data;
gboolean got_eof = FALSE;
if (sock == -1) {
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
return;
}
if (!gfud->sentreq) {
char buf[2048];
if (gfud->session->cookies == NULL)
gfud->session->cookies = g_strdup("");
if (gfud->user_agent) {
/* Host header is not forbidden in HTTP/1.0 requests, and
HTTP/1.1 clients must know how to handle the "chunked"
transfer encoding. Gaim doesn't know how to handle
"chunked", so should always send the Host header
regardless, to get around some observed problems */
g_snprintf(buf, sizeof(buf), "GET %s%s HTTP/%s\r\n" "User-Agent: %s\r\n" "Host: %s\r\n" "Cookie: %s\r\n", // (1)
//
//
//
//
// (see
// above)
(gfud->full ? "" : "/"),
(gfud->full ? gfud->url : gfud->website.page),
(gfud->http11 ? "1.1" : "1.0"),
gfud->user_agent, gfud->website.address,
gfud->session->cookies);
} else {
g_snprintf(buf, sizeof(buf), "GET %s%s HTTP/%s\r\n" "Host: %s\r\n" "Accept-Encoding: identity\r\n" "Cookie: %s\r\n", // (1)
//
//
//
//
// See
// above
(gfud->full ? "" : "/"),
(gfud->full ? gfud->url : gfud->website.page),
(gfud->http11 ? "1.1" : "1.0"),
gfud->website.address, gfud->session->cookies);
}
if (gfud->session->hasFormData)
strcat(buf,
"Content-Type: application/x-www-form-urlencoded\r\n\r\n");
else
strcat(buf, "\r\n");
gaim_debug_misc("gaim_url_fetch", "Request: %s\n", buf);
write(sock, buf, strlen(buf));
fcntl(sock, F_SETFL, O_NONBLOCK);
gfud->sentreq = TRUE;
gfud->inpa = gaim_input_add(sock, GAIM_INPUT_READ,
session_fetched_cb, url_data);
gfud->data_len = 4096;
gfud->webdata = g_malloc(gfud->data_len);
return;
}
if (read(sock, &data, 1) > 0 || errno == EWOULDBLOCK) {
if (errno == EWOULDBLOCK) {
errno = 0;
return;
}
gfud->len++;
if (gfud->len == gfud->data_len + 1) {
gfud->data_len += (gfud->data_len) / 2;
gfud->webdata = g_realloc(gfud->webdata, gfud->data_len);
}
gfud->webdata[gfud->len - 1] = data;
if (!gfud->startsaving) {
if (data == '\r')
return;
if (data == '\n') {
if (gfud->newline) {
size_t content_len;
gfud->startsaving = TRUE;
gaim_debug_misc("gaim_url_fetch",
"Response headers: '%*.*s'\n",
gfud->len, gfud->len, gfud->webdata);
// JBL 10-16-2004: Put cookies into session
gaim_debug(GAIM_DEBUG_MISC, "gaym",
"Parsing cookies...");
parse_cookies(gfud->webdata, gfud->session, gfud->len);
gaim_debug(GAIM_DEBUG_MISC, "gaym",
"Found cookies: %s\n",
(gfud->session->cookies));
gaim_debug_misc("gaim_url_fetch",
"Parsing of cookies successful\n");
/* See if we can find a redirect. */
if (parse_redirect
(gfud->webdata, gfud->len, sock, gfud))
return;
/* No redirect. See if we can find a content length. */
content_len =
parse_content_len(gfud->webdata, gfud->len);
if (content_len == 0) {
/* We'll stick with an initial 8192 */
content_len = 8192;
} else {
gfud->has_explicit_data_len = TRUE;
}
/* Out with the old... */
gfud->len = 0;
g_free(gfud->webdata);
gfud->webdata = NULL;
/* In with the new. */
gfud->data_len = content_len;
gfud->webdata = g_try_malloc(gfud->data_len);
if (gfud->webdata == NULL) {
gaim_debug_error("gaim_url_fetch",
"Failed to allocate %u bytes: %s\n",
gfud->data_len, strerror(errno));
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
}
} else
gfud->newline = TRUE;
return;
}
gfud->newline = FALSE;
} else if (gfud->has_explicit_data_len
&& gfud->len == gfud->data_len) {
got_eof = TRUE;
}
} else if (errno != ETIMEDOUT) {
got_eof = TRUE;
} else {
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, NULL, 0);
destroy_fetch_url_data(gfud);
}
if (got_eof) {
gfud->webdata = g_realloc(gfud->webdata, gfud->len + 1);
gfud->webdata[gfud->len] = 0;
/* gaim_debug_misc("gaim_url_fetch", "Received: '%s'\n",
gfud->webdata); */
gaim_input_remove(gfud->inpa);
close(sock);
gfud->callback(gfud->user_data, gfud->webdata, gfud->len);
destroy_fetch_url_data(gfud);
}
}
static void gaym_login_cb(gpointer data, gint source,
GaimInputCondition cond)
{
GaimConnection *gc = data;
struct gaym_conn *gaym = gc->proto_data;
char hostname[256];
char *buf;
const char *username;
const char *user_bioline = NULL;
char *bioline;
char *login_name;
if (GAIM_CONNECTION_IS_VALID(gc)) {
GList *connections = gaim_connections_get_all();
if (source < 0) {
gaim_connection_error(gc, _("Couldn't connect to host"));
return;
}
if (!g_list_find(connections, gc)) {
close(source);
return;
}
gaym->fd = source;
gaim_debug_misc("gaym", "In login_cb with chat_key=%s\n",
gaym->chat_key);
if (gaym->chat_key) {
buf = gaym_format(gaym, "vv", "PASS", gaym->chat_key);
if (gaym_send(gaym, buf) < 0) {
gaim_connection_error(gc, "Error sending password");
return;
}
g_free(buf);
} else {
gaim_connection_error(gc,
_
("Password wasn't recorded. Report bug."));
return;
}
gethostname(hostname, sizeof(hostname));
hostname[sizeof(hostname) - 1] = '\0';
username = gaim_account_get_string(gaym->account, "username", "");
user_bioline =
g_strdup(gaim_account_get_string
(gaym->account, "bioline", ""));
gaim_debug_info("gaym", "USER BIOLINE=%x\n", user_bioline);
gaim_account_set_user_info(gc->account, user_bioline);
gaim_debug_misc("gaym",
"In login_cb, user_bioline: %x, gc->account=%x\n",
user_bioline, gc->account);
login_name =
gaym_nick_to_gcom_strdup(gaim_connection_get_display_name(gc));
bioline = g_strdup_printf("%s#%s\xC2\xA0 \xC2\xA0\001%s",
gaym->thumbnail,
user_bioline ? user_bioline : "",
gaym->server_stats ? gaym->
server_stats : "");
buf = gaym_format(gaym, "vn", "NICK", login_name);
gaim_debug_misc("gaym", "Command: %s\n", buf);
if (gaym_send(gaym, buf) < 0) {
gaim_connection_error(gc, "Error sending nickname");
return;
}
g_free(buf);
buf =
gaym_format(gaym, "vvvv:", "USER", login_name, hostname,
gaym->server, bioline);
gaim_debug_misc("gaym", "Command: %s\n", buf);
if (gaym_send(gaym, buf) < 0) {
gaim_connection_error(gc, "Error registering with server");
return;
}
g_free(login_name);
g_free(buf);
const char *server = gaim_account_get_string(gc->account, "server",
IRC_DEFAULT_SERVER);
char *url =
g_strdup_printf
("http://%s/messenger/config.txt?%s", server, gaym->chat_key);
char *user_agent = "Mozilla/4.0";
get_spamlist_from_web();
gaim_url_fetch(url, FALSE, user_agent, FALSE,
gaym_get_configtxt_cb, gaym);
g_free(url);
gc->inpa =
gaim_input_add(gaym->fd, GAIM_INPUT_READ, gaym_input_cb, gc);
}
}
static void
jabber_si_xfer_bytestreams_send_read_again_cb(gpointer data, gint source,
GaimInputCondition cond)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx = xfer->data;
int i;
char buffer[256];
int len;
char *dstaddr, *p;
unsigned char hashval[20];
const char *host;
gaim_debug_info("jabber", "in jabber_si_xfer_bytestreams_send_read_again_cb\n");
if(jsx->rxlen < 5) {
gaim_debug_info("jabber", "reading the first 5 bytes\n");
len = read(source, buffer, 5 - jsx->rxlen);
if(len < 0 && errno == EAGAIN)
return;
else if(len <= 0) {
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen);
memcpy(jsx->rxqueue + jsx->rxlen, buffer, len);
jsx->rxlen += len;
return;
} else if(jsx->rxqueue[0] != 0x05 || jsx->rxqueue[1] != 0x01 ||
jsx->rxqueue[3] != 0x03) {
gaim_debug_info("jabber", "invalid socks5 stuff\n");
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
gaim_xfer_cancel_remote(xfer);
return;
} else if(jsx->rxlen - 5 < jsx->rxqueue[4] + 2) {
gaim_debug_info("jabber", "reading umpteen more bytes\n");
len = read(source, buffer, jsx->rxqueue[4] + 5 + 2 - jsx->rxlen);
if(len < 0 && errno == EAGAIN)
return;
else if(len <= 0) {
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen);
memcpy(jsx->rxqueue + jsx->rxlen, buffer, len);
jsx->rxlen += len;
}
if(jsx->rxlen - 5 < jsx->rxqueue[4] + 2)
return;
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
dstaddr = g_strdup_printf("%s%s@%s/%s%s", jsx->stream_id,
jsx->js->user->node, jsx->js->user->domain,
jsx->js->user->resource, xfer->who);
gaim_cipher_digest_region("sha1", (guchar *)dstaddr, strlen(dstaddr),
sizeof(hashval), hashval, NULL);
g_free(dstaddr);
dstaddr = g_malloc(41);
p = dstaddr;
for(i=0; i<20; i++, p+=2)
snprintf(p, 3, "%02x", hashval[i]);
if(jsx->rxqueue[4] != 40 || strncmp(dstaddr, jsx->rxqueue+5, 40) ||
jsx->rxqueue[45] != 0x00 || jsx->rxqueue[46] != 0x00) {
gaim_debug_error("jabber", "someone connected with the wrong info!\n");
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
g_free(jsx->rxqueue);
host = gaim_network_get_my_ip(jsx->js->fd);
jsx->rxmaxlen = 5 + strlen(host) + 2;
jsx->rxqueue = g_malloc(jsx->rxmaxlen);
jsx->rxlen = 0;
jsx->rxqueue[0] = 0x05;
jsx->rxqueue[1] = 0x00;
jsx->rxqueue[2] = 0x00;
jsx->rxqueue[3] = 0x03;
jsx->rxqueue[4] = strlen(host);
memcpy(jsx->rxqueue + 5, host, strlen(host));
jsx->rxqueue[5+strlen(host)] = 0x00;
jsx->rxqueue[6+strlen(host)] = 0x00;
xfer->watcher = gaim_input_add(source, GAIM_INPUT_WRITE,
jabber_si_xfer_bytestreams_send_read_again_resp_cb, xfer);
jabber_si_xfer_bytestreams_send_read_again_resp_cb(xfer, source,
GAIM_INPUT_WRITE);
}
GaimSrvQueryData *
gaim_srv_resolve(const char *protocol, const char *transport, const char *domain, GaimSrvCallback cb, gpointer extradata)
{
char *query;
GaimSrvQueryData *query_data;
#ifndef _WIN32
int in[2], out[2];
int pid;
#else
GError* err = NULL;
static gboolean initialized = FALSE;
#endif
query = g_strdup_printf("_%s._%s.%s", protocol, transport, domain);
gaim_debug_info("dnssrv","querying SRV record for %s\n", query);
#ifndef _WIN32
if(pipe(in) || pipe(out)) {
gaim_debug_error("dnssrv", "Could not create pipe\n");
g_free(query);
cb(NULL, 0, extradata);
return NULL;
}
pid = fork();
if (pid == -1) {
gaim_debug_error("dnssrv", "Could not create process!\n");
cb(NULL, 0, extradata);
g_free(query);
return NULL;
}
/* Child */
if (pid == 0)
{
close(out[0]);
close(in[1]);
resolve(in[0], out[1]);
}
close(out[1]);
close(in[0]);
if (write(in[1], query, strlen(query)+1) < 0)
gaim_debug_error("dnssrv", "Could not write to SRV resolver\n");
query_data = g_new0(GaimSrvQueryData, 1);
query_data->cb = cb;
query_data->extradata = extradata;
query_data->handle = gaim_input_add(out[0], GAIM_INPUT_READ, resolved, query_data);
g_free(query);
return query_data;
#else
if (!initialized) {
MyDnsQuery_UTF8 = (void*) wgaim_find_and_loadproc("dnsapi.dll", "DnsQuery_UTF8");
MyDnsRecordListFree = (void*) wgaim_find_and_loadproc(
"dnsapi.dll", "DnsRecordListFree");
initialized = TRUE;
}
query_data = g_new0(GaimSrvQueryData, 1);
query_data->cb = cb;
query_data->query = query;
query_data->extradata = extradata;
if (!MyDnsQuery_UTF8 || !MyDnsRecordListFree) {
query_data->error_message = g_strdup_printf("System missing DNS API (Requires W2K+)\n");
/* Asynchronously call the callback since stuff may not expect
* the callback to be called before this returns */
query_data->handle = g_idle_add(res_main_thread_cb, query_data);
return query_data;
}
query_data->resolver = g_thread_create(res_thread, query_data, FALSE, &err);
if (query_data->resolver == NULL)
{
query_data->error_message = g_strdup_printf("SRV thread create failure: %s\n", err ? err->message : "");
g_error_free(err);
/* Asynchronously call the callback since stuff may not expect
* the callback to be called before this returns */
query_data->handle = g_idle_add(res_main_thread_cb, query_data);
return query_data;
}
return query_data;
#endif
}
static void
jabber_si_xfer_bytestreams_send_read_cb(gpointer data, gint source,
GaimInputCondition cond)
{
GaimXfer *xfer = data;
JabberSIXfer *jsx = xfer->data;
int i;
int len;
char buffer[256];
gaim_debug_info("jabber", "in jabber_si_xfer_bytestreams_send_read_cb\n");
xfer->fd = source;
if(jsx->rxlen < 2) {
gaim_debug_info("jabber", "reading those first two bytes\n");
len = read(source, buffer, 2 - jsx->rxlen);
if(len < 0 && errno == EAGAIN)
return;
else if(len <= 0) {
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen);
memcpy(jsx->rxqueue + jsx->rxlen, buffer, len);
jsx->rxlen += len;
return;
} else if(jsx->rxlen - 2 < jsx->rxqueue[1]) {
gaim_debug_info("jabber", "reading the next umpteen bytes\n");
len = read(source, buffer, jsx->rxqueue[1] + 2 - jsx->rxlen);
if(len < 0 && errno == EAGAIN)
return;
else if(len <= 0) {
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
jsx->rxqueue = g_realloc(jsx->rxqueue, len + jsx->rxlen);
memcpy(jsx->rxqueue + jsx->rxlen, buffer, len);
jsx->rxlen += len;
}
if(jsx->rxlen -2 < jsx->rxqueue[1])
return;
gaim_input_remove(xfer->watcher);
xfer->watcher = 0;
gaim_debug_info("jabber", "checking to make sure we're socks FIVE\n");
if(jsx->rxqueue[0] != 0x05) {
close(source);
gaim_xfer_cancel_remote(xfer);
return;
}
gaim_debug_info("jabber", "going to test %hhu different methods\n", jsx->rxqueue[1]);
for(i=0; i<jsx->rxqueue[1]; i++) {
gaim_debug_info("jabber", "testing %hhu\n", jsx->rxqueue[i+2]);
if(jsx->rxqueue[i+2] == 0x00) {
g_free(jsx->rxqueue);
jsx->rxlen = 0;
jsx->rxmaxlen = 2;
jsx->rxqueue = g_malloc(jsx->rxmaxlen);
jsx->rxqueue[0] = 0x05;
jsx->rxqueue[1] = 0x00;
xfer->watcher = gaim_input_add(source, GAIM_INPUT_WRITE,
jabber_si_xfer_bytestreams_send_read_response_cb,
xfer);
jabber_si_xfer_bytestreams_send_read_response_cb(xfer,
source, GAIM_INPUT_WRITE);
jsx->rxqueue = NULL;
jsx->rxlen = 0;
return;
}
}
g_free(jsx->rxqueue);
jsx->rxlen = 0;
jsx->rxmaxlen = 2;
jsx->rxqueue = g_malloc(jsx->rxmaxlen);
jsx->rxqueue[0] = 0x05;
jsx->rxqueue[1] = 0xFF;
xfer->watcher = gaim_input_add(source, GAIM_INPUT_WRITE,
jabber_si_xfer_bytestreams_send_read_response_cb, xfer);
jabber_si_xfer_bytestreams_send_read_response_cb(xfer,
source, GAIM_INPUT_WRITE);
}
static void _qq_s5_canread(gpointer data, gint source, GaimInputCondition cond)
{
unsigned char buf[512];
struct PHB *phb;
int ret;
phb = data;
gaim_input_remove(phb->inpa);
gaim_debug(GAIM_DEBUG_INFO, "socks5 proxy", "Able to read.\n");
ret = read(source, buf, 2);
if (ret < 2) {
gaim_debug(GAIM_DEBUG_INFO, "s5_canread", "packet smaller than 2 octet\n");
close(source);
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
if ((buf[0] != 0x05) || (buf[1] == 0xff)) {
gaim_debug(GAIM_DEBUG_INFO, "s5_canread", "unsupport\n");
close(source);
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
if (buf[1] == 0x02) {
unsigned int i, j;
i = strlen(gaim_proxy_info_get_username(phb->gpi));
j = strlen(gaim_proxy_info_get_password(phb->gpi));
buf[0] = 0x01; /* version 1 */
buf[1] = i;
memcpy(buf + 2, gaim_proxy_info_get_username(phb->gpi), i);
buf[2 + i] = j;
memcpy(buf + 2 + i + 1, gaim_proxy_info_get_password(phb->gpi), j);
if (write(source, buf, 3 + i + j) < 3 + i + j) {
close(source);
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, _qq_s5_readauth, phb);
} else {
gaim_debug(GAIM_DEBUG_INFO, "s5_canread", "calling s5_sendconnect\n");
_qq_s5_sendconnect(phb, source);
}
}
static void _qq_s5_sendconnect(gpointer data, gint source)
{
unsigned char buf[512];
struct PHB *phb = data;
struct sockaddr_in sin, ctlsin;
int port;
socklen_t ctllen;
gaim_debug(GAIM_DEBUG_INFO, "s5_sendconnect", "remote host is %s:%d\n", phb->host, phb->port);
buf[0] = 0x05;
buf[1] = 0x03; /* udp relay */
buf[2] = 0x00; /* reserved */
buf[3] = 0x01; /* address type -- ipv4 */
memset(buf + 4, 0, 0x04);
ctllen = sizeof(ctlsin);
if (getsockname(source, (struct sockaddr *) &ctlsin, &ctllen) < 0) {
gaim_debug(GAIM_DEBUG_INFO, "QQ", "getsockname: %s\n", strerror(errno));
close(source);
g_free(phb->host);
g_free(phb);
return;
}
phb->udpsock = socket(PF_INET, SOCK_DGRAM, 0);
gaim_debug(GAIM_DEBUG_INFO, "s5_sendconnect", "UDP socket=%d\n", phb->udpsock);
if (phb->udpsock < 0) {
close(source);
g_free(phb->host);
g_free(phb);
return;
}
fcntl(phb->udpsock, F_SETFL, O_NONBLOCK);
port = g_ntohs(ctlsin.sin_port) + 1;
while (1) {
inet_aton("0.0.0.0", &(sin.sin_addr));
sin.sin_family = AF_INET;
sin.sin_port = g_htons(port);
if (bind(phb->udpsock, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
port++;
if (port > 65500) {
close(source);
g_free(phb->host);
g_free(phb);
return;
}
} else
break;
}
memset(buf + 4, 0, 0x04);
memcpy(buf + 8, &(sin.sin_port), 0x02);
if (write(source, buf, 10) < 10) {
close(source);
gaim_debug(GAIM_DEBUG_INFO, "s5_sendconnect", "packet too small\n");
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, _qq_s5_canread_again, phb);
}
