void
peer_connection_finalize_connection(PeerConnection *conn)
{
conn->watcher_incoming = purple_input_add(conn->fd,
PURPLE_INPUT_READ, peer_connection_recv_cb, conn);
if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
{
/*
* If we are connecting to them then send our cookie so they
* can verify who we are. Note: This doesn't seem to be
* necessary, but it also doesn't seem to hurt.
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING))
peer_odc_send_cookie(conn);
}
else if (conn->type == OSCAR_CAPABILITY_SENDFILE)
{
if (purple_xfer_get_xfer_type(conn->xfer) == PURPLE_XFER_TYPE_SEND)
{
peer_oft_send_prompt(conn);
}
}
/*
* Tell the remote user that we're connected (which may also imply
* that we've accepted their request).
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_IS_INCOMING))
aim_im_sendch2_connected(conn);
}
static void
bonjour_xfer_init(PurpleXfer *xfer)
{
PurpleBuddy *buddy;
BonjourBuddy *bb;
XepXfer *xf;
xf = purple_xfer_get_protocol_data(xfer);
if(xf == NULL)
return;
purple_debug_info("bonjour", "Bonjour-xfer-init.\n");
buddy = purple_blist_find_buddy(purple_xfer_get_account(xfer), purple_xfer_get_remote_user(xfer));
/* this buddy is offline. */
if (buddy == NULL || (bb = purple_buddy_get_protocol_data(buddy)) == NULL)
return;
/* Assume it is the first IP. We could do something like keep track of which one is in use or something. */
if (bb->ips)
xf->buddy_ip = g_strdup(bb->ips->data);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND) {
/* initiate file transfer, send SI offer. */
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_TYPE_SEND.\n");
xep_ft_si_offer(xfer, purple_xfer_get_remote_user(xfer));
} else {
/* accept file transfer request, send SI result. */
xep_ft_si_result(xfer, purple_xfer_get_remote_user(xfer));
purple_debug_info("bonjour", "Bonjour xfer type is PURPLE_XFER_TYPE_RECEIVE.\n");
}
}
static void yahoo_xfer_start(PurpleXfer *xfer)
{
PurpleHttpRequest *req;
struct yahoo_xfer_data *xd;
xd = purple_xfer_get_protocol_data(xfer);
req = yahoo_ft_new_req(xd);
purple_http_request_set_timeout(req, -1);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
purple_http_request_set_max_len(req, -1);
purple_http_request_set_response_writer(req,
yahoo_process_filetrans_15_writer, xfer);
xd->hc = purple_http_request(xd->gc, req,
yahoo_process_filetrans_15_downloaded, xfer);
} else {
purple_http_request_set_method(req, "POST");
/* YHttpServer quirk: it sets content-length, but doesn't sends
* any data. */
purple_http_request_set_max_len(req, 0);
purple_http_request_set_contents_reader(req,
yahoo_process_filetrans_15_reader,
purple_xfer_get_size(xfer), xfer);
xd->hc = purple_http_request(xd->gc, req,
yahoo_process_filetrans_15_sent, xfer);
}
purple_http_conn_set_progress_watcher(xd->hc,
yahoo_process_filetrans_15_watcher, xfer, -1);
purple_http_request_unref(req);
}
void ggp_edisc_xfer_ticket_changed(PurpleConnection *gc, const char *data)
{
ggp_edisc_session_data *sdata = ggp_edisc_get_sdata(gc);
PurpleXfer *xfer;
JsonParser *parser;
JsonObject *ticket;
const gchar *ticket_id, *send_status;
ggp_edisc_xfer_ack_status ack_status;
gboolean is_completed;
g_return_if_fail(sdata != NULL);
parser = ggp_json_parse(data);
ticket = json_node_get_object(json_parser_get_root(parser));
ticket_id = json_object_get_string_member(ticket, "id");
ack_status = ggp_edisc_xfer_parse_ack_status(
json_object_get_string_member(ticket, "ack_status"));
send_status = json_object_get_string_member(ticket, "send_status");
if (ticket_id == NULL)
ticket_id = "";
xfer = g_hash_table_lookup(sdata->xfers_initialized, ticket_id);
if (xfer == NULL) {
purple_debug_misc("gg", "ggp_edisc_event_ticket_changed: "
"ticket %s not found, updating it...\n",
purple_debug_is_unsafe() ? ticket_id : "");
ggp_edisc_xfer_recv_ticket_got(gc, ticket_id);
g_object_unref(parser);
return;
}
is_completed = FALSE;
if (g_strcmp0("in_progress", send_status) == 0) {
/* do nothing */
} else if (g_strcmp0("completed", send_status) == 0) {
is_completed = TRUE;
} else if (g_strcmp0("expired", send_status) == 0)
ggp_edisc_xfer_error(xfer, _("File transfer expired."));
else {
purple_debug_warning("gg", "ggp_edisc_event_ticket_changed: "
"unknown send_status=%s\n", send_status);
g_object_unref(parser);
return;
}
g_object_unref(parser);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
if (is_completed)
ggp_edisc_xfer_recv_ticket_completed(xfer);
} else {
if (ack_status != GGP_EDISC_XFER_ACK_STATUS_UNKNOWN)
ggp_edisc_xfer_send_ticket_changed(gc, xfer, ack_status
== GGP_EDISC_XFER_ACK_STATUS_ALLOWED);
}
}
static void
yahoo_xfer_init_15(PurpleXfer *xfer)
{
struct yahoo_xfer_data *xfer_data;
PurpleConnection *gc;
PurpleAccount *account;
YahooData *yd;
struct yahoo_packet *pkt;
xfer_data = purple_xfer_get_protocol_data(xfer);
gc = xfer_data->gc;
yd = purple_connection_get_protocol_data(gc);
account = purple_connection_get_account(gc);
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND) {
gchar *filename;
filename = g_path_get_basename(purple_xfer_get_local_filename(xfer));
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15,
YAHOO_STATUS_AVAILABLE,
yd->session_id);
yahoo_packet_hash(pkt, "sssiiiisiii",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
222, 1,
266, 1,
302, 268,
300, 268,
27, filename,
28, (int)purple_xfer_get_size(xfer),
301, 268,
303, 268);
g_free(filename);
} else {
if(xfer_data->firstoflist == TRUE) {
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_15,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sssi",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
222, 3);
} else {
pkt = yahoo_packet_new(YAHOO_SERVICE_FILETRANS_ACC_15,
YAHOO_STATUS_AVAILABLE, yd->session_id);
yahoo_packet_hash(pkt, "sssi",
1, purple_normalize(account, purple_account_get_username(account)),
5, purple_xfer_get_remote_user(xfer),
265, xfer_data->xfer_peer_idstring,
271, 1);
}
}
yahoo_packet_send_and_free(pkt, yd);
}
static void ggp_edisc_xfer_error(PurpleXfer *xfer, const gchar *msg)
{
if (purple_xfer_is_cancelled(xfer))
g_return_if_reached();
purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_CANCEL_REMOTE);
purple_xfer_conversation_write(xfer, msg, TRUE);
purple_xfer_error(
purple_xfer_get_xfer_type(xfer),
purple_xfer_get_account(xfer),
purple_xfer_get_remote_user(xfer),
msg);
ggp_edisc_xfer_free(xfer);
purple_xfer_end(xfer);
}
static void
yahoo_process_filetrans_15_watcher(PurpleHttpConnection *hc,
gboolean reading_state, int processed, int total, gpointer _xfer)
{
PurpleXfer *xfer = _xfer;
if (reading_state !=
(purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE))
{
return;
}
purple_xfer_set_size(xfer, total);
purple_xfer_update_progress(xfer);
}
static void bonjour_xfer_end(PurpleXfer *xfer)
{
purple_debug_info("bonjour", "Bonjour-xfer-end.\n");
/* We can't allow the server side to close the connection until the client is complete,
* otherwise there is a RST resulting in an error on the client side */
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_SEND && purple_xfer_is_completed(xfer)) {
struct socket_cleanup *sc = g_new0(struct socket_cleanup, 1);
sc->fd = purple_xfer_get_fd(xfer);
purple_xfer_set_fd(xfer, -1);
sc->handle = purple_input_add(sc->fd, PURPLE_INPUT_READ,
_wait_for_socket_close, sc);
}
bonjour_free_xfer(xfer);
}
static void ggp_edisc_xfer_progress_watcher(PurpleHttpConnection *hc,
gboolean reading_state, int processed, int total, gpointer _xfer)
{
PurpleXfer *xfer = _xfer;
gboolean eof;
int total_real;
if (purple_xfer_get_xfer_type(xfer) == PURPLE_XFER_TYPE_RECEIVE) {
if (!reading_state)
return;
} else {
if (reading_state)
return;
}
eof = (processed >= total);
total_real = purple_xfer_get_size(xfer);
if (eof || processed > total_real)
processed = total_real; /* just to be sure */
purple_xfer_set_bytes_sent(xfer, processed);
purple_xfer_update_progress(xfer);
}
static void yahoo_xfer_end(PurpleXfer *xfer_old)
{
struct yahoo_xfer_data *xfer_data;
PurpleXfer *xfer = NULL;
PurpleConnection *gc;
YahooData *yd;
xfer_data = purple_xfer_get_protocol_data(xfer_old);
if(xfer_data
&& purple_xfer_get_xfer_type(xfer_old) == PURPLE_XFER_TYPE_RECEIVE
&& xfer_data->filename_list) {
/* removing top of filename & size list completely */
g_free( xfer_data->filename_list->data );
g_free( xfer_data->size_list->data );
xfer_data->filename_list->data = NULL;
xfer_data->size_list->data = NULL;
xfer_data->filename_list = g_slist_delete_link(xfer_data->filename_list, xfer_data->filename_list);
xfer_data->size_list = g_slist_delete_link(xfer_data->size_list, xfer_data->size_list);
/* if there are still more files */
if(xfer_data->filename_list)
{
gchar* filename;
char *utf8_filename;
filename = xfer_data->filename_list->data;
gc = xfer_data->gc;
yd = purple_connection_get_protocol_data(gc);
/* setting up xfer_data for next file's tranfer */
g_free(xfer_data->host);
g_free(xfer_data->path);
g_free(xfer_data->xfer_idstring_for_relay);
xfer_data->host = NULL;
xfer_data->host = NULL;
xfer_data->xfer_idstring_for_relay = NULL;
xfer_data->info_val_249 = 0;
xfer_data->firstoflist = FALSE;
/* Dereference xfer_data from old xfer */
purple_xfer_set_protocol_data(xfer_old, NULL);
/* Build the file transfer handle. */
xfer = yahoo_ft_new_xfer_struct(gc, PURPLE_XFER_TYPE_RECEIVE, purple_xfer_get_remote_user(xfer_old));
g_return_if_fail(xfer != NULL);
/* 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);
/* update map to current xfer */
g_hash_table_remove(yd->xfer_peer_idstring_map, xfer_data->xfer_peer_idstring);
g_hash_table_insert(yd->xfer_peer_idstring_map, xfer_data->xfer_peer_idstring, xfer);
/* Now perform the request */
purple_xfer_request(xfer);
return;
}
}
if (xfer_data)
yahoo_xfer_data_free(xfer_data);
purple_xfer_set_protocol_data(xfer_old, NULL);
}
void* IMInvoker::purpeNotifyMessage(PurpleNotifyMsgType type, const char *title, const char *primary, const char *secondary, PurpleRequestCommonParameters *cpar) {
#else
void* IMInvoker::purpeNotifyMessage(PurpleNotifyMsgType type, const char *title, const char *primary, const char *secondary) {
#endif
return NULL;
}
void* IMInvoker::purpeNotifyEmail(PurpleConnection *gc, const char *subject, const char *from, const char *to, const char *url) {
return NULL;
}
void* IMInvoker::purpeNotifyEmails(PurpleConnection *gc, size_t count, gboolean detailed, const char **subjects, const char **froms, const char **tos, const char **urls) {
return NULL;
}
void* IMInvoker::purpeNotifyFormatted(const char *title, const char *primary, const char *secondary, const char *text) {
return NULL;
}
void* IMInvoker::purpeNotifySearchResults(PurpleConnection *gc, const char *title, const char *primary, const char *secondary, PurpleNotifySearchResults *results, gpointer user_data) {
return NULL;
}
void IMInvoker::purpeNotifySearchResultsNewRows(PurpleConnection *gc, PurpleNotifySearchResults *results, void *data) {}
void* IMInvoker::purpeNotifyUserInfo(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info) {
return NULL;
}
void* IMInvoker::purpeNotifyURI(const char *uri) {
return NULL;
}
void IMInvoker::purpeNotifyClose(PurpleNotifyType type, void *ui_handle) {}
// privacy ui operations
void IMInvoker::purplePermitAdded(PurpleAccount *account, const char *name) {}
void IMInvoker::purplePermitRemoved(PurpleAccount *account, const char *name) {}
void IMInvoker::purpleDebyAdded(PurpleAccount *account, const char *name) {}
void IMInvoker::purpleDenyRemoved(PurpleAccount *account, const char *name) {}
// request ui operations
#if LIBPURPLE_VERSION_MAJOR >= 3
void* IMInvoker::purpleRequestInput(const char *title, const char *primary,
const char *secondary, const char *default_value,
gboolean multiline, gboolean masked, gchar *hint,
const char *ok_text, GCallback ok_cb,
const char *cancel_text, GCallback cancel_cb,
PurpleRequestCommonParameters *cpar, void *user_data) {
return NULL;
}
void* IMInvoker::purpleRequestChoice(const char *title, const char *primary,
const char *secondary, gpointer default_value,
const char *ok_text, GCallback ok_cb, const char *cancel_text,
GCallback cancel_cb , PurpleRequestCommonParameters *cpar,
void *user_data, va_list choices) {
return NULL;
}
void* IMInvoker::purpleRequestAction(const char *title, const char *primary,
const char *secondary, int default_action,
PurpleRequestCommonParameters *cpar, void *user_data,
size_t action_count, va_list actions) {
return NULL;
}
void* IMInvoker::purpleRequestWait(const char *title, const char *primary,
const char *secondary, gboolean with_progress,
PurpleRequestCancelCb cancel_cb,
PurpleRequestCommonParameters *cpar, void *user_data) {
return NULL;
}
void IMInvoker::purpleRequestWaitUpdate(void *ui_handle, gboolean pulse, gfloat fraction) {
}
void* IMInvoker::purpleRequestFields(const char *title, const char *primary,
const char *secondary, PurpleRequestFields *fields,
const char *ok_text, GCallback ok_cb,
const char *cancel_text, GCallback cancel_cb,
PurpleRequestCommonParameters *cpar, void *user_data) {
return NULL;
}
void* IMInvoker::purpleRequestFile(const char *title, const char *filename,
gboolean savedialog, GCallback ok_cb, GCallback cancel_cb,
PurpleRequestCommonParameters *cpar, void *user_data) {
// click ok
PurpleXfer *xfer = (PurpleXfer *)user_data;
PurpleXferType xferType = purple_xfer_get_xfer_type(xfer);
if (xferType == PURPLE_XFER_TYPE_RECEIVE) {
((PurpleRequestFileCb)ok_cb)(user_data, filename);
} else if (xferType == PURPLE_XFER_TYPE_SEND) {
if (purple_xfer_get_local_filename(xfer) != NULL && purple_xfer_get_filename(xfer) != NULL) {
((PurpleRequestFileCb)ok_cb)(user_data, purple_xfer_get_local_filename(xfer));
} else {
((PurpleRequestFileCb)cancel_cb)(user_data, purple_xfer_get_local_filename(xfer));
}
}
return NULL;
}
