static void yahoo_receivefile_connected(gpointer data, gint source, const gchar *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
purple_debug(PURPLE_DEBUG_INFO, "yahoo",
"AAA - in yahoo_receivefile_connected\n");
if (!(xfer = data))
return;
if (!(xd = xfer->data))
return;
if ((source < 0) || (xd->path == NULL) || (xd->host == NULL)) {
purple_xfer_error(PURPLE_XFER_RECEIVE, purple_xfer_get_account(xfer),
xfer->who, _("Unable to connect."));
purple_xfer_cancel_remote(xfer);
return;
}
xfer->fd = source;
/* The first time we get here, assemble the tx buffer */
if (xd->txbuflen == 0) {
xd->txbuf = g_strdup_printf("GET /%s HTTP/1.0\r\nHost: %s\r\n\r\n",
xd->path, xd->host);
xd->txbuflen = strlen(xd->txbuf);
xd->txbuf_written = 0;
}
if (!xd->tx_handler)
{
xd->tx_handler = purple_input_add(source, PURPLE_INPUT_WRITE,
yahoo_receivefile_send_cb, xfer);
yahoo_receivefile_send_cb(xfer, source, PURPLE_INPUT_WRITE);
}
}
static void tgprpl_xfer_recv_on_finished (struct tgl_state *TLS, void *_data, int success, const char *filename) {
debug ("tgprpl_xfer_recv_on_finished()");
struct tgp_xfer_send_data *data = _data;
char *selected = g_strdup (purple_xfer_get_local_filename (data->xfer));
if (success) {
debug ("purple_xfer_set_completed");
// always completed the file transfer to avoid a warning dialogue when closing (Adium)
purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer));
purple_xfer_set_completed (data->xfer, TRUE);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_end (data->xfer);
}
} else {
tgp_notify_on_error_gw (TLS, NULL, success);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_cancel_remote (data->xfer);
}
failure ("recv xfer failed");
}
data->loading = FALSE;
data->xfer->data = NULL;
purple_xfer_unref (data->xfer);
tgprpl_xfer_free_data (data);
debug ("moving transferred file from tgl directory %s to selected target %s", selected, filename);
g_unlink (selected);
g_rename (filename, selected);
g_free (selected);
}
static void yahoo_receivefile_send_cb(gpointer data, gint source, PurpleInputCondition condition)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
int remaining, written;
xfer = data;
xd = xfer->data;
remaining = xd->txbuflen - xd->txbuf_written;
written = write(xfer->fd, xd->txbuf + xd->txbuf_written, remaining);
if (written < 0 && errno == EAGAIN)
written = 0;
else if (written <= 0) {
purple_debug_error("yahoo", "Unable to write in order to start ft errno = %d\n", errno);
purple_xfer_cancel_remote(xfer);
return;
}
if (written < remaining) {
xd->txbuf_written += written;
return;
}
purple_input_remove(xd->tx_handler);
xd->tx_handler = 0;
g_free(xd->txbuf);
xd->txbuf = NULL;
xd->txbuflen = 0;
purple_xfer_start(xfer, source, NULL, 0);
}
void ggp_edisc_xfer_send_ticket_changed(PurpleConnection *gc, PurpleXfer *xfer,
gboolean is_allowed)
{
ggp_edisc_xfer *edisc_xfer = purple_xfer_get_protocol_data(xfer);
if (!edisc_xfer) {
purple_debug_fatal("gg", "ggp_edisc_event_ticket_changed: "
"transfer %p already free'd\n", xfer);
return;
}
if (!is_allowed) {
purple_debug_info("gg", "ggp_edisc_event_ticket_changed: "
"transfer %p rejected\n", xfer);
purple_xfer_cancel_remote(xfer);
ggp_edisc_xfer_free(xfer);
return;
}
if (edisc_xfer->allowed) {
purple_debug_misc("gg", "ggp_edisc_event_ticket_changed: "
"transfer %p already allowed\n", xfer);
return;
}
edisc_xfer->allowed = TRUE;
purple_xfer_start(xfer, -1, NULL, 0);
}
static void tgprpl_xfer_send_on_finished (struct tgl_state *TLS, void *_data, int success, struct tgl_message *M) {
debug ("tgprpl_xfer_on_finished()");
struct tgp_xfer_send_data *data = _data;
if (success) {
if (! purple_xfer_is_canceled (data->xfer)) {
debug ("purple_xfer_set_completed");
purple_xfer_set_bytes_sent (data->xfer, purple_xfer_get_size (data->xfer));
purple_xfer_set_completed (data->xfer, TRUE);
purple_xfer_end (data->xfer);
}
write_secret_chat_file (TLS);
} else {
tgp_notify_on_error_gw (TLS, NULL, success);
if (! purple_xfer_is_canceled (data->xfer)) {
purple_xfer_cancel_remote (data->xfer);
}
failure ("send xfer failed");
}
data->loading = FALSE;
data->xfer->data = NULL;
purple_xfer_unref (data->xfer);
tgprpl_xfer_free_data (data);
}
static void yahoo_xfer_init(PurpleXfer *xfer)
{
struct yahoo_xfer_data *xfer_data;
PurpleConnection *gc;
PurpleAccount *account;
struct yahoo_data *yd;
xfer_data = xfer->data;
gc = xfer_data->gc;
yd = gc->proto_data;
account = purple_connection_get_account(gc);
if (purple_xfer_get_type(xfer) == PURPLE_XFER_SEND) {
if (yd->jp) {
if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xferjp_host", YAHOOJP_XFER_HOST),
purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT),
yahoo_sendfile_connected, xfer) == NULL)
{
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
} else {
if (purple_proxy_connect(NULL, account, purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST),
purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT),
yahoo_sendfile_connected, xfer) == NULL)
{
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
}
} else {
/* TODO: Using xfer->fd like this is probably a bad thing... */
if (purple_proxy_connect(NULL, account, xfer_data->host, xfer_data->port,
yahoo_receivefile_connected, xfer) == NULL)
xfer->fd = -1;
else
xfer->fd = 0;
if (xfer->fd == -1) {
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to establish file descriptor."));
purple_xfer_cancel_remote(xfer);
}
}
}
void
msn_xfer_end_cb(MsnSlpCall *slpcall, MsnSession *session)
{
if ((purple_xfer_get_status(slpcall->xfer) != PURPLE_XFER_STATUS_DONE) &&
(purple_xfer_get_status(slpcall->xfer) != PURPLE_XFER_STATUS_CANCEL_REMOTE) &&
(purple_xfer_get_status(slpcall->xfer) != PURPLE_XFER_STATUS_CANCEL_LOCAL))
{
purple_xfer_cancel_remote(slpcall->xfer);
}
}
static void
xfer_end_cb(struct pn_peer_call *call,
MsnSession *session)
{
if ((purple_xfer_get_status(call->xfer) != PURPLE_XFER_STATUS_DONE) &&
(purple_xfer_get_status(call->xfer) != PURPLE_XFER_STATUS_CANCEL_REMOTE) &&
(purple_xfer_get_status(call->xfer) != PURPLE_XFER_STATUS_CANCEL_LOCAL))
{
purple_xfer_cancel_remote(call->xfer);
}
}
void sipe_backend_ft_deallocate(struct sipe_file_transfer *ft)
{
PurpleXfer *xfer = PURPLE_XFER;
PurpleXferStatusType status = purple_xfer_get_status(xfer);
// If file transfer is not finished, cancel it
if ( status != PURPLE_XFER_STATUS_DONE
&& status != PURPLE_XFER_STATUS_CANCEL_LOCAL
&& status != PURPLE_XFER_STATUS_CANCEL_REMOTE) {
purple_xfer_set_cancel_recv_fnc(xfer, NULL);
purple_xfer_set_cancel_send_fnc(xfer, NULL);
purple_xfer_cancel_remote(xfer);
}
}
static gboolean
peer_connection_destroy_cb(gpointer data)
{
PeerConnection *conn;
conn = data;
purple_request_close_with_handle(conn);
peer_connection_close(conn);
if (conn->checksum_data != NULL)
peer_oft_checksum_destroy(conn->checksum_data);
if (conn->xfer != NULL)
{
PurpleXferStatusType status;
conn->xfer->data = NULL;
status = purple_xfer_get_status(conn->xfer);
if ((status != PURPLE_XFER_STATUS_DONE) &&
(status != PURPLE_XFER_STATUS_CANCEL_LOCAL) &&
(status != PURPLE_XFER_STATUS_CANCEL_REMOTE))
{
if ((conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_CLOSED) ||
(conn->disconnect_reason == OSCAR_DISCONNECT_REMOTE_REFUSED))
purple_xfer_cancel_remote(conn->xfer);
else
purple_xfer_cancel_local(conn->xfer);
}
purple_xfer_unref(conn->xfer);
conn->xfer = NULL;
}
g_free(conn->bn);
g_free(conn->error_message);
g_free(conn->proxyip);
g_free(conn->clientip);
g_free(conn->verifiedip);
g_free(conn->xferdata.name);
purple_circ_buffer_destroy(conn->buffer_outgoing);
conn->od->peer_connections = g_slist_remove(conn->od->peer_connections, conn);
g_free(conn);
return FALSE;
}
static void
yahoo_process_filetrans_info_15_got(PurpleHttpConnection *hc,
PurpleHttpResponse *response, gpointer _xfer)
{
PurpleXfer *xfer = _xfer;
struct yahoo_xfer_data *xd;
YahooData *yd;
xd = purple_xfer_get_protocol_data(xfer);
yd = purple_connection_get_protocol_data(xd->gc);
xd->hc = NULL;
if (!purple_http_response_is_successful(response)) {
purple_notify_error(yd->gc, NULL, _("File Transfer Failed"),
_("Unable to get file header."),
purple_request_cpar_from_connection(yd->gc));
purple_xfer_cancel_remote(xfer);
return;
}
purple_xfer_start(xfer, -1, NULL, 0);
}
void yahoo_process_filetrans_info_15(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *url = NULL;
long val_249 = 0;
long val_66 = 0;
PurpleXfer *xfer;
YahooData *yd;
struct yahoo_xfer_data *xfer_data;
char *xfer_peer_idstring = NULL;
char *xfer_idstring_for_relay = NULL;
GSList *l;
struct yahoo_packet *pkt_to_send;
yd = purple_connection_get_protocol_data(gc);
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 4: /* from */
break;
case 5: /* to */
break;
case 265:
if (g_utf8_validate(pair->value, -1, NULL)) {
xfer_peer_idstring = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 27: /* filename */
break;
case 66:
val_66 = strtol(pair->value, NULL, 10);
break;
case 249:
val_249 = strtol(pair->value, NULL, 10);
/* 249 has value 1 or 2 when doing p2p transfer and value 3 when relaying through yahoo server */
break;
case 250:
if (g_utf8_validate(pair->value, -1, NULL)) {
url = pair->value; /* TODO: rename to host? what about non-relay? */
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 251:
if (g_utf8_validate(pair->value, -1, NULL)) {
xfer_idstring_for_relay = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_info_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
}
}
if(!xfer_peer_idstring)
return;
xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map, xfer_peer_idstring);
if(!xfer) return;
if(val_66==-1)
{
purple_xfer_cancel_remote(xfer);
return;
}
xfer_data = purple_xfer_get_protocol_data(xfer);
xfer_data->info_val_249 = val_249;
xfer_data->xfer_idstring_for_relay = g_strdup(xfer_idstring_for_relay);
if(val_249 == 1 || val_249 == 3) {
PurpleHttpRequest *req;
PurpleAccount *account;
xfer_data->is_relay = (val_249 == 3);
if (!xfer_data->is_relay) {
purple_debug_error("yahoo", "Non-relay FT aren't tested yet.\n");
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unsupported method"),
purple_request_cpar_from_connection(gc));
purple_xfer_cancel_remote(xfer);
}
account = purple_connection_get_account(xfer_data->gc);
xfer_data->url = yahoo_ft_url_gen(xfer, url);
pkt_to_send = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_ACC_15,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt_to_send, "ssssis",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
27, purple_xfer_get_filename(xfer),
249, xfer_data->info_val_249,
251, xfer_data->xfer_idstring_for_relay);
yahoo_packet_send_and_free(pkt_to_send, yd);
req = yahoo_ft_new_req(xfer_data);
purple_http_request_set_method(req, "HEAD");
xfer_data->hc = purple_http_request(gc, req, yahoo_process_filetrans_info_15_got, xfer);
purple_http_request_unref(req);
}
else if (val_249 == 2)
purple_debug_error("yahoo", "p2p file transfers are not supported yet\n");
}
void yahoo_process_filetrans_15(PurpleConnection *gc, struct yahoo_packet *pkt)
{
char *from = NULL;
char *imv = NULL;
long val_222 = 0L;
PurpleXfer *xfer;
YahooData *yd;
struct yahoo_xfer_data *xfer_data;
char *service = NULL;
char *filename = NULL;
char *xfer_peer_idstring = NULL;
char *utf8_filename;
GSList *l;
GSList *filename_list = NULL;
GSList *size_list = NULL;
int nooffiles = 0;
yd = purple_connection_get_protocol_data(gc);
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 4:
if (g_utf8_validate(pair->value, -1, NULL)) {
from = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 5: /* to */
break;
case 265:
if (g_utf8_validate(pair->value, -1, NULL)) {
xfer_peer_idstring = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 27:
filename_list = g_slist_prepend(filename_list, g_strdup(pair->value));
nooffiles++;
break;
case 28:
if (g_utf8_validate(pair->value, -1, NULL)) {
size_list = g_slist_prepend(size_list, g_strdup(pair->value));
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 222:
val_222 = atol(pair->value);
/* 1=send, 2=cancel, 3=accept, 4=reject */
break;
/* check for p2p and imviron .... not sure it comes by this service packet. Since it was bundled with filexfer in old ymsg version, still keeping it. */
case 49:
if (g_utf8_validate(pair->value, -1, NULL)) {
service = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 63:
if (g_utf8_validate(pair->value, -1, NULL)) {
imv = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
/* end check */
}
}
if(!xfer_peer_idstring)
return;
if(val_222 == 2 || val_222 == 4)
{
xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map,
xfer_peer_idstring);
if(!xfer) return;
purple_xfer_cancel_remote(xfer);
return;
}
if(val_222 == 3)
{
PurpleAccount *account;
struct yahoo_xfer_data *xd;
xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map,
xfer_peer_idstring);
if(!xfer)
return;
xd = purple_xfer_get_protocol_data(xfer);
/*
* In the file trans info packet that we must reply with, we are
* supposed to mention the ip address...
* purple connect does not give me a way of finding the ip address...
* so, purple dnsquery is used... but retries, trying with next ip
* address etc. is not implemented..TODO
*/
/* To send through p2p */
if( g_hash_table_lookup(yd->peers, from) ) {
/* send p2p file transfer information */
purple_debug_error("yahoo", "p2p file transfers are not supported yet\n");
/*xd->is_relay = FALSE;*/
}
xd->is_relay = TRUE;
account = purple_connection_get_account(gc);
if (yd->jp)
{
purple_dnsquery_a(account, YAHOOJP_XFER_RELAY_HOST,
YAHOOJP_XFER_RELAY_PORT,
yahoo_xfer_dns_connected_15, xfer);
}
else
{
purple_dnsquery_a(account, YAHOO_XFER_RELAY_HOST,
YAHOO_XFER_RELAY_PORT,
yahoo_xfer_dns_connected_15, xfer);
}
return;
}
/* processing for p2p and imviron .... not sure it comes by this service packet. Since it was bundled with filexfer in old ymsg version, still keeping it. */
/*
* The remote user has changed their IMVironment. We
* record it for later use.
*/
if (from && imv && service && (strcmp("IMVIRONMENT", service) == 0)) {
g_hash_table_replace(yd->imvironments, g_strdup(from), g_strdup(imv));
return;
}
if (pkt->service == YAHOO_SERVICE_P2PFILEXFER) {
if (service && (strcmp("FILEXFER", service) != 0)) {
purple_debug_misc("yahoo", "unhandled service 0x%02x\n", pkt->service);
return;
}
}
/* end processing */
if(!filename_list)
return;
/* have to change list into order in which client at other end sends */
filename_list = g_slist_reverse(filename_list);
size_list = g_slist_reverse(size_list);
filename = filename_list->data;
if(!from) return;
xfer_data = g_new0(struct yahoo_xfer_data, 1);
xfer_data->firstoflist = TRUE;
xfer_data->gc = gc;
xfer_data->xfer_peer_idstring = g_strdup(xfer_peer_idstring);
xfer_data->filename_list = filename_list;
xfer_data->size_list = size_list;
/* Build the file transfer handle. */
xfer = yahoo_ft_new_xfer_struct(gc, PURPLE_XFER_TYPE_RECEIVE, from);
/* Set the info about the incoming file. */
utf8_filename = yahoo_string_decode(gc, filename, TRUE);
purple_xfer_set_filename(xfer, utf8_filename);
g_free(utf8_filename);
purple_xfer_set_protocol_data(xfer, xfer_data);
g_hash_table_insert(yd->xfer_peer_idstring_map,
xfer_data->xfer_peer_idstring,
xfer);
if(nooffiles > 1) {
gchar* message;
message = g_strdup_printf(_("%s is trying to send you a group of %d files.\n"), purple_xfer_get_remote_user(xfer), nooffiles);
purple_xfer_conversation_write(xfer, message, FALSE);
g_free(message);
}
/* Now perform the request */
purple_xfer_request(xfer);
}
static void yahoo_xfer_dns_connected_15(GSList *hosts, gpointer data, const char *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
struct sockaddr_in *addr;
struct yahoo_packet *pkt;
unsigned long actaddr;
unsigned char a,b,c,d;
PurpleConnection *gc;
PurpleAccount *account;
YahooData *yd;
gchar *filename;
if (!(xfer = data))
return;
if (!(xd = purple_xfer_get_protocol_data(xfer)))
return;
gc = xd->gc;
account = purple_connection_get_account(gc);
yd = purple_connection_get_protocol_data(gc);
if(!hosts)
{
purple_debug_error("yahoo", "Unable to find an IP address for relay.msg.yahoo.com\n");
purple_xfer_cancel_remote(xfer);
return;
}
/* Discard the length... */
hosts = g_slist_remove(hosts, hosts->data);
if(!hosts)
{
purple_debug_error("yahoo", "Unable to find an IP address for relay.msg.yahoo.com\n");
purple_xfer_cancel_remote(xfer);
return;
}
/* TODO:actually, u must try with addr no.1 , if its not working addr no.2 ..... */
addr = hosts->data;
actaddr = addr->sin_addr.s_addr;
d = actaddr & 0xff;
actaddr >>= 8;
c = actaddr & 0xff;
actaddr >>= 8;
b = actaddr & 0xff;
actaddr >>= 8;
a = actaddr & 0xff;
xd->host = g_strdup_printf("%u.%u.%u.%u", d, c, b, a);
/* Free the address... */
g_free(hosts->data);
hosts = g_slist_remove(hosts, hosts->data);
addr = NULL;
while (hosts != NULL)
{
/* Discard the length... */
hosts = g_slist_remove(hosts, hosts->data);
/* Free the address... */
g_free(hosts->data);
hosts = g_slist_remove(hosts, hosts->data);
}
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_INFO_15, YAHOO_STATUS_AVAILABLE, yd->session_id);
filename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
yahoo_packet_hash(pkt, "ssssis",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xd->xfer_peer_idstring,
27, filename,
249, 3,
250, xd->host);
g_free(filename);
yahoo_packet_send_and_free(pkt, yd);
}
/* TODO: Check filename etc. No probs till some hacker comes in the way */
void yahoo_process_filetrans_acc_15(PurpleConnection *gc, struct yahoo_packet *pkt)
{
gchar *xfer_peer_idstring = NULL;
gchar *xfer_idstring_for_relay = NULL;
PurpleXfer *xfer;
YahooData *yd;
struct yahoo_xfer_data *xfer_data;
GSList *l;
long val_66 = 0;
gchar *url = NULL;
int val_249 = 0;
yd = purple_connection_get_protocol_data(gc);
for (l = pkt->hash; l; l = l->next) {
struct yahoo_pair *pair = l->data;
switch (pair->key) {
case 251:
if (g_utf8_validate(pair->value, -1, NULL)) {
xfer_idstring_for_relay = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_acc_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 265:
if (g_utf8_validate(pair->value, -1, NULL)) {
xfer_peer_idstring = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_acc_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
case 66:
val_66 = atol(pair->value);
break;
case 249:
val_249 = atol(pair->value);
break;
case 250:
if (g_utf8_validate(pair->value, -1, NULL)) {
/* we get a p2p url here when sending file, connected as client */
url = pair->value;
} else {
purple_debug_warning("yahoo", "yahoo_process_filetrans_acc_15 "
"got non-UTF-8 string for key %d\n", pair->key);
}
break;
}
}
xfer = g_hash_table_lookup(yd->xfer_peer_idstring_map, xfer_peer_idstring);
if(!xfer) return;
if(val_66 == -1 || ( (!(xfer_idstring_for_relay)) && (val_249 != 2) ))
{
purple_xfer_cancel_remote(xfer);
return;
}
if( (val_249 == 2) && (!(url)) )
{
purple_xfer_cancel_remote(xfer);
return;
}
xfer_data = purple_xfer_get_protocol_data(xfer);
if (url)
xfer_data->host = g_strdup(url);
xfer_data->xfer_idstring_for_relay = g_strdup(xfer_idstring_for_relay);
xfer_data->url = yahoo_ft_url_gen(xfer, xfer_data->host);
purple_xfer_start(xfer, -1, NULL, 0);
}
static void
bonjour_sock5_request_cb(gpointer data, gint source, PurpleInputCondition cond)
{
PurpleXfer *xfer = data;
XepXfer *xf = xfer->data;
int acceptfd;
int len = 0;
if(xf == NULL)
return;
purple_debug_info("bonjour", "bonjour_sock5_request_cb - req_state = 0x%x\n", xf->sock5_req_state);
switch(xf->sock5_req_state){
case 0x00:
acceptfd = accept(source, NULL, 0);
if(acceptfd == -1 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
} else if(acceptfd == -1) {
/* This should cancel the ft */
purple_debug_error("bonjour", "Error accepting incoming SOCKS5 connection. (%d)\n", errno);
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
purple_xfer_cancel_remote(xfer);
return;
} else {
purple_debug_info("bonjour", "Accepted SOCKS5 ft connection - fd=%d\n", acceptfd);
_purple_network_set_common_socket_flags(acceptfd);
purple_input_remove(xfer->watcher);
close(source);
xfer->watcher = purple_input_add(acceptfd, PURPLE_INPUT_READ,
bonjour_sock5_request_cb, xfer);
xf->sock5_req_state++;
xf->rxlen = 0;
}
break;
case 0x01:
xfer->fd = source;
len = read(source, xf->rx_buf + xf->rxlen, 3);
if(len < 0 && errno == EAGAIN)
return;
else if(len <= 0){
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
purple_xfer_cancel_remote(xfer);
return;
} else {
purple_input_remove(xfer->watcher);
xfer->watcher = purple_input_add(source, PURPLE_INPUT_WRITE,
bonjour_sock5_request_cb, xfer);
xf->sock5_req_state++;
xf->rxlen = 0;
bonjour_sock5_request_cb(xfer, source, PURPLE_INPUT_WRITE);
}
break;
case 0x02:
xf->tx_buf[0] = 0x05;
xf->tx_buf[1] = 0x00;
len = write(source, xf->tx_buf, 2);
if (len < 0 && errno == EAGAIN)
return;
else if (len < 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
purple_xfer_cancel_remote(xfer);
return;
} else {
purple_input_remove(xfer->watcher);
xfer->watcher = purple_input_add(source, PURPLE_INPUT_READ,
bonjour_sock5_request_cb, xfer);
xf->sock5_req_state++;
xf->rxlen = 0;
}
break;
case 0x03:
len = read(source, xf->rx_buf + xf->rxlen, 20);
if(len<=0){
} else {
purple_input_remove(xfer->watcher);
xfer->watcher = purple_input_add(source, PURPLE_INPUT_WRITE,
bonjour_sock5_request_cb, xfer);
xf->sock5_req_state++;
xf->rxlen = 0;
bonjour_sock5_request_cb(xfer, source, PURPLE_INPUT_WRITE);
}
break;
case 0x04:
xf->tx_buf[0] = 0x05;
xf->tx_buf[1] = 0x00;
xf->tx_buf[2] = 0x00;
xf->tx_buf[3] = 0x03;
xf->tx_buf[4] = strlen(xf->buddy_ip);
memcpy(xf->tx_buf + 5, xf->buddy_ip, strlen(xf->buddy_ip));
xf->tx_buf[5+strlen(xf->buddy_ip)] = 0x00;
xf->tx_buf[6+strlen(xf->buddy_ip)] = 0x00;
len = write(source, xf->tx_buf, 7 + strlen(xf->buddy_ip));
if (len < 0 && errno == EAGAIN) {
return;
} else if (len < 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
close(source);
purple_xfer_cancel_remote(xfer);
return;
} else {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
xf->rxlen = 0;
/*close(source);*/
purple_xfer_start(xfer, source, NULL, -1);
}
break;
default:
break;
}
return;
}
static void yahoo_sendfile_connected(gpointer data, gint source, const gchar *error_message)
{
PurpleXfer *xfer;
struct yahoo_xfer_data *xd;
struct yahoo_packet *pkt;
gchar *size, *filename, *encoded_filename, *header;
guchar *pkt_buf;
const char *host;
int port;
size_t content_length, header_len, pkt_buf_len;
PurpleConnection *gc;
PurpleAccount *account;
struct yahoo_data *yd;
purple_debug(PURPLE_DEBUG_INFO, "yahoo",
"AAA - in yahoo_sendfile_connected\n");
if (!(xfer = data))
return;
if (!(xd = xfer->data))
return;
if (source < 0) {
purple_xfer_error(PURPLE_XFER_RECEIVE, purple_xfer_get_account(xfer),
xfer->who, _("Unable to connect."));
purple_xfer_cancel_remote(xfer);
return;
}
xfer->fd = source;
/* Assemble the tx buffer */
gc = xd->gc;
account = purple_connection_get_account(gc);
yd = gc->proto_data;
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANSFER,
YAHOO_STATUS_AVAILABLE, yd->session_id);
size = g_strdup_printf("%" G_GSIZE_FORMAT, purple_xfer_get_size(xfer));
filename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
encoded_filename = yahoo_string_encode(gc, filename, NULL);
yahoo_packet_hash(pkt, "sssss", 0, purple_connection_get_display_name(gc),
5, xfer->who, 14, "", 27, encoded_filename, 28, size);
g_free(size);
g_free(encoded_filename);
g_free(filename);
content_length = YAHOO_PACKET_HDRLEN + yahoo_packet_length(pkt);
pkt_buf_len = yahoo_packet_build(pkt, 8, FALSE, yd->jp, &pkt_buf);
yahoo_packet_free(pkt);
host = purple_account_get_string(account, "xfer_host", YAHOO_XFER_HOST);
port = purple_account_get_int(account, "xfer_port", YAHOO_XFER_PORT);
header = g_strdup_printf(
"POST http://%s:%d/notifyft HTTP/1.0\r\n"
"Content-length: %" G_GSIZE_FORMAT "\r\n"
"Host: %s:%d\r\n"
"Cookie: Y=%s; T=%s\r\n"
"\r\n",
host, port, content_length + 4 + purple_xfer_get_size(xfer),
host, port, yd->cookie_y, yd->cookie_t);
header_len = strlen(header);
xd->txbuflen = header_len + pkt_buf_len + 4;
xd->txbuf = g_malloc(xd->txbuflen);
memcpy(xd->txbuf, header, header_len);
g_free(header);
memcpy(xd->txbuf + header_len, pkt_buf, pkt_buf_len);
g_free(pkt_buf);
memcpy(xd->txbuf + header_len + pkt_buf_len, "29\xc0\x80", 4);
xd->txbuf_written = 0;
if (xd->tx_handler == 0)
{
xd->tx_handler = purple_input_add(source, PURPLE_INPUT_WRITE,
yahoo_sendfile_send_cb, xfer);
yahoo_sendfile_send_cb(xfer, source, PURPLE_INPUT_WRITE);
}
}
void
xep_si_parse(PurpleConnection *pc, xmlnode *packet, PurpleBuddy *pb)
{
const char *type, *id;
BonjourData *bd;
PurpleXfer *xfer;
const gchar *name = NULL;
g_return_if_fail(pc != NULL);
g_return_if_fail(packet != NULL);
g_return_if_fail(pb != NULL);
bd = (BonjourData*) pc->proto_data;
if(bd == NULL)
return;
purple_debug_info("bonjour", "xep-si-parse.\n");
name = purple_buddy_get_name(pb);
type = xmlnode_get_attrib(packet, "type");
id = xmlnode_get_attrib(packet, "id");
if(!type)
return;
if(purple_strequal(type, "set")) {
xmlnode *si;
gboolean parsed_receive = FALSE;
si = xmlnode_get_child(packet, "si");
purple_debug_info("bonjour", "si offer Message type - SET.\n");
if (si) {
const char *profile;
profile = xmlnode_get_attrib(si, "profile");
if (purple_strequal(profile, "http://jabber.org/protocol/si/profile/file-transfer")) {
const char *filename = NULL, *filesize_str = NULL;
goffset filesize = 0;
xmlnode *file;
const char *sid = xmlnode_get_attrib(si, "id");
if ((file = xmlnode_get_child(si, "file"))) {
filename = xmlnode_get_attrib(file, "name");
if((filesize_str = xmlnode_get_attrib(file, "size")))
filesize = g_ascii_strtoll(filesize_str, NULL, 10);
}
/* TODO: Make sure that it is advertising a bytestreams transfer */
if (filename) {
bonjour_xfer_receive(pc, id, sid, name, filesize, filename, XEP_BYTESTREAMS);
parsed_receive = TRUE;
}
}
}
if (!parsed_receive) {
BonjourData *bd = purple_connection_get_protocol_data(pc);
purple_debug_info("bonjour", "rejecting unrecognized si SET offer.\n");
xep_ft_si_reject(bd, id, name, "403", "cancel");
/*TODO: Send Cancel (501) */
}
} else if(purple_strequal(type, "result")) {
purple_debug_info("bonjour", "si offer Message type - RESULT.\n");
xfer = bonjour_si_xfer_find(bd, id, name);
if(xfer == NULL) {
BonjourData *bd = purple_connection_get_protocol_data(pc);
purple_debug_info("bonjour", "xfer find fail.\n");
xep_ft_si_reject(bd, id, name, "403", "cancel");
} else
bonjour_bytestreams_init(xfer);
} else if(purple_strequal(type, "error")) {
purple_debug_info("bonjour", "si offer Message type - ERROR.\n");
xfer = bonjour_si_xfer_find(bd, id, name);
if(xfer == NULL)
purple_debug_info("bonjour", "xfer find fail.\n");
else
purple_xfer_cancel_remote(xfer);
} else
purple_debug_info("bonjour", "si offer Message type - Unknown-%s.\n", type);
}
static void
do_transfer(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
guchar *buffer = NULL;
gssize r = 0;
ui_ops = purple_xfer_get_ui_ops(xfer);
if (xfer->type == PURPLE_XFER_RECEIVE) {
r = purple_xfer_read(xfer, &buffer);
if (r > 0) {
size_t wc;
if (ui_ops && ui_ops->ui_write)
wc = ui_ops->ui_write(xfer, buffer, r);
else
wc = fwrite(buffer, 1, r, xfer->dest_fp);
if (wc != r) {
purple_debug_error("filetransfer", "Unable to write whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
if ((purple_xfer_get_size(xfer) > 0) &&
((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer)))
purple_xfer_set_completed(xfer, TRUE);
} else if(r < 0) {
purple_xfer_cancel_remote(xfer);
g_free(buffer);
return;
}
} else if (xfer->type == PURPLE_XFER_SEND) {
size_t result;
size_t s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
/* this is so the prpl can keep the connection open
if it needs to for some odd reason. */
if (s == 0) {
if (xfer->watcher) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
return;
}
if (ui_ops && ui_ops->ui_read) {
gssize tmp = ui_ops->ui_read(xfer, &buffer, s);
if (tmp == 0) {
/*
* UI isn't ready to send data. It will call
* purple_xfer_ui_ready when ready, which sets back up this
* watcher.
*/
if (xfer->watcher != 0) {
purple_timeout_remove(xfer->watcher);
xfer->watcher = 0;
}
return;
} else if (tmp < 0) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
return;
}
result = tmp;
} else {
buffer = g_malloc0(s);
result = fread(buffer, 1, s, xfer->dest_fp);
if (result != s) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
}
/* Write as much as we're allowed to. */
r = purple_xfer_write(xfer, buffer, result);
if (r == -1) {
purple_xfer_cancel_remote(xfer);
g_free(buffer);
return;
} else if (r < result) {
if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) {
/* We have to seek back in the file now. */
fseek(xfer->dest_fp, r - s, SEEK_CUR);
}
else {
ui_ops->data_not_sent(xfer, buffer + r, result - r);
}
} else {
/*
* We managed to write the entire buffer. This means our
* network is fast and our buffer is too small, so make it
* bigger.
*/
purple_xfer_increase_buffer_size(xfer);
}
}
if (r > 0) {
if (purple_xfer_get_size(xfer) > 0)
xfer->bytes_remaining -= r;
xfer->bytes_sent += r;
if (xfer->ops.ack != NULL)
xfer->ops.ack(xfer, buffer, r);
g_free(buffer);
if (ui_ops != NULL && ui_ops->update_progress != NULL)
ui_ops->update_progress(xfer,
purple_xfer_get_progress(xfer));
}
if (purple_xfer_is_completed(xfer))
purple_xfer_end(xfer);
}
static void
do_transfer(PurpleXfer *xfer)
{
PurpleXferUiOps *ui_ops;
guchar *buffer = NULL;
gssize r = 0;
ui_ops = purple_xfer_get_ui_ops(xfer);
if (xfer->type == PURPLE_XFER_RECEIVE) {
r = purple_xfer_read(xfer, &buffer);
if (r > 0) {
size_t wc;
if (ui_ops && ui_ops->ui_write)
wc = ui_ops->ui_write(xfer, buffer, r);
else
wc = fwrite(buffer, 1, r, xfer->dest_fp);
if (wc != r) {
purple_debug_error("filetransfer", "Unable to write whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
if ((purple_xfer_get_size(xfer) > 0) &&
((purple_xfer_get_bytes_sent(xfer)+r) >= purple_xfer_get_size(xfer)))
purple_xfer_set_completed(xfer, TRUE);
} else if(r < 0) {
purple_xfer_cancel_remote(xfer);
g_free(buffer);
return;
}
} else if (xfer->type == PURPLE_XFER_SEND) {
size_t result = 0;
size_t s = MIN(purple_xfer_get_bytes_remaining(xfer), xfer->current_buffer_size);
PurpleXferPrivData *priv = g_hash_table_lookup(xfers_data, xfer);
gboolean read = TRUE;
/* this is so the prpl can keep the connection open
if it needs to for some odd reason. */
if (s == 0) {
if (xfer->watcher) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
return;
}
if (priv->buffer) {
if (priv->buffer->len < s) {
s -= priv->buffer->len;
read = TRUE;
} else {
read = FALSE;
}
}
if (read) {
if (ui_ops && ui_ops->ui_read) {
gssize tmp = ui_ops->ui_read(xfer, &buffer, s);
if (tmp == 0) {
/*
* The UI claimed it was ready, but didn't have any data for
* us... It will call purple_xfer_ui_ready when ready, which
* sets back up this watcher.
*/
if (xfer->watcher != 0) {
purple_input_remove(xfer->watcher);
xfer->watcher = 0;
}
/* Need to indicate the prpl is still ready... */
priv->ready |= PURPLE_XFER_READY_PRPL;
g_return_if_reached();
} else if (tmp < 0) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
return;
}
result = tmp;
} else {
buffer = g_malloc(s);
result = fread(buffer, 1, s, xfer->dest_fp);
if (result != s) {
purple_debug_error("filetransfer", "Unable to read whole buffer.\n");
purple_xfer_cancel_local(xfer);
g_free(buffer);
return;
}
}
}
if (priv->buffer) {
g_byte_array_append(priv->buffer, buffer, result);
g_free(buffer);
buffer = priv->buffer->data;
result = priv->buffer->len;
}
r = purple_xfer_write(xfer, buffer, result);
if (r == -1) {
purple_xfer_cancel_remote(xfer);
if (!priv->buffer)
/* We don't free buffer if priv->buffer is set, because in
that case buffer doesn't belong to us. */
g_free(buffer);
return;
} else if (r == result) {
/*
* We managed to write the entire buffer. This means our
* network is fast and our buffer is too small, so make it
* bigger.
*/
purple_xfer_increase_buffer_size(xfer);
} else {
if (ui_ops && ui_ops->data_not_sent)
ui_ops->data_not_sent(xfer, buffer + r, result - r);
}
if (priv->buffer) {
/*
* Remove what we wrote
* If we wrote the whole buffer the byte array will be empty
* Otherwise we'll keep what wasn't sent for next time.
*/
buffer = NULL;
g_byte_array_remove_range(priv->buffer, 0, r);
}
}
if (r > 0) {
if (purple_xfer_get_size(xfer) > 0)
xfer->bytes_remaining -= r;
xfer->bytes_sent += r;
if (xfer->ops.ack != NULL)
xfer->ops.ack(xfer, buffer, r);
g_free(buffer);
if (ui_ops != NULL && ui_ops->update_progress != NULL)
ui_ops->update_progress(xfer,
purple_xfer_get_progress(xfer));
}
if (purple_xfer_is_completed(xfer))
purple_xfer_end(xfer);
}
void sipe_backend_ft_cancel_remote(struct sipe_file_transfer *ft)
{
purple_xfer_cancel_remote(PURPLE_XFER);
}
