gboolean gfire_server_query_start(gfire_server_query *p_query, const gchar *p_type, gboolean p_full,
gfire_server_query_callback p_callback, gpointer p_data)
{
if(!p_query || !p_type || !p_callback || p_query->prpl_data || p_query->prpl_inpa)
return FALSE;
int i = 0;
for(; registeredDrivers[i].proto; i++)
{
if(g_strcmp0(registeredDrivers[i].proto, p_type) == 0)
{
p_query->driver = registeredDrivers[i].driver;
p_query->query_port = registeredDrivers[i].query_port;
p_query->port_offset = registeredDrivers[i].port_offset;
break;
}
}
if(!p_query->driver)
return FALSE;
p_query->full_query = p_full;
p_query->callback = p_callback;
p_query->callback_data = p_data;
p_query->prpl_data = purple_network_listen_range(0, 0, SOCK_DGRAM, gfire_server_query_listen, p_query);
return TRUE;
}
static void
hbn_cb(GObject *sender, GAsyncResult *res, gpointer data) {
StunHBNListenData *ld = NULL;
GError *error = NULL;
ld = g_new0(StunHBNListenData, 1);
ld->addresses = g_resolver_lookup_by_name_finish(G_RESOLVER(sender),
res, &error);
if(error != NULL) {
nattype.status = PURPLE_STUN_STATUS_UNDISCOVERED;
nattype.lookup_time = time(NULL);
do_callbacks();
return;
}
ld->port = GPOINTER_TO_INT(data);
if (!purple_network_listen_range(12108, 12208, AF_UNSPEC, SOCK_DGRAM, TRUE, hbn_listen_cb, ld)) {
nattype.status = PURPLE_STUN_STATUS_UNKNOWN;
nattype.lookup_time = time(NULL);
do_callbacks();
return;
}
}
static void
bonjour_bytestreams_init(PurpleXfer *xfer)
{
XepXfer *xf;
if(xfer == NULL)
return;
purple_debug_info("bonjour", "Bonjour-bytestreams-init.\n");
xf = purple_xfer_get_protocol_data(xfer);
xf->listen_data = purple_network_listen_range(0, 0, AF_UNSPEC, SOCK_STREAM, FALSE,
bonjour_bytestreams_listen, xfer);
if (xf->listen_data == NULL)
purple_xfer_cancel_local(xfer);
return;
}
static void
bonjour_bytestreams_init(PurpleXfer *xfer)
{
XepXfer *xf;
if(xfer == NULL)
return;
purple_debug_info("bonjour", "Bonjour-bytestreams-init.\n");
xf = xfer->data;
purple_network_listen_map_external(FALSE);
xf->listen_data = purple_network_listen_range(0, 0, SOCK_STREAM,
bonjour_bytestreams_listen, xfer);
purple_network_listen_map_external(TRUE);
if (xf->listen_data == NULL)
purple_xfer_cancel_local(xfer);
return;
}
/*
* This function is called after the user has selected a file to send.
*/
static void irc_dccsend_send_init(PurpleXfer *xfer) {
PurpleConnection *gc = purple_account_get_connection(purple_xfer_get_account(xfer));
struct irc_xfer_send_data *xd = xfer->data;
xfer->filename = g_path_get_basename(xfer->local_filename);
purple_xfer_ref(xfer);
/* Create a listening socket */
xd->listen_data = purple_network_listen_range(0, 0, SOCK_STREAM,
irc_dccsend_network_listen_cb, xfer);
if (xd->listen_data == NULL) {
purple_xfer_unref(xfer);
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Could not open a listening port."));
purple_xfer_cancel_local(xfer);
}
}
/*
* This function is called after the user has selected a file to send.
*/
static void irc_dccsend_send_init(PurpleXfer *xfer) {
PurpleConnection *gc = purple_account_get_connection(purple_xfer_get_account(xfer));
struct irc_xfer_send_data *xd = purple_xfer_get_protocol_data(xfer);
purple_xfer_set_filename(xfer, g_path_get_basename(purple_xfer_get_local_filename(xfer)));
g_object_ref(xfer);
/* Create a listening socket */
xd->listen_data = purple_network_listen_range(0, 0, AF_UNSPEC, SOCK_STREAM, TRUE,
irc_dccsend_network_listen_cb, xfer);
if (xd->listen_data == NULL) {
g_object_unref(xfer);
purple_notify_error(gc, NULL, _("File Transfer Failed"),
_("Unable to open a listening port."),
purple_request_cpar_from_connection(gc));
purple_xfer_cancel_local(xfer);
}
}
static void hbn_cb(GSList *hosts, gpointer data, const char *error_message) {
if(!hosts || !hosts->data) {
nattype.status = PURPLE_STUN_STATUS_UNDISCOVERED;
nattype.lookup_time = time(NULL);
do_callbacks();
return;
}
if (!purple_network_listen_range(12108, 12208, SOCK_DGRAM, hbn_listen_cb, hosts)) {
while (hosts) {
hosts = g_slist_delete_link(hosts, hosts);
g_free(hosts->data);
hosts = g_slist_delete_link(hosts, hosts);
}
nattype.status = PURPLE_STUN_STATUS_UNKNOWN;
nattype.lookup_time = time(NULL);
do_callbacks();
return;
}
}
/**
* Try to establish the given PeerConnection using a defined
* sequence of steps.
*/
void
peer_connection_trynext(PeerConnection *conn)
{
PurpleAccount *account;
account = purple_connection_get_account(conn->od->gc);
/*
* Close any remnants of a previous failed connection attempt.
*/
peer_connection_close(conn);
/*
* 1. Attempt to connect to the remote user using their verifiedip and clientip.
* We try these at the same time and use whichever succeeds first, so we don't
* have to wait for a timeout.
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_TRIED_DIRECT) &&
(conn->verifiedip != NULL) && (conn->port != 0) && (!conn->use_proxy))
{
conn->flags |= PEER_CONNECTION_FLAG_TRIED_DIRECT;
if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
{
gchar *tmp;
PurpleConversation *conv;
tmp = g_strdup_printf(_("Attempting to connect to %s:%hu."),
conn->verifiedip, conn->port);
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
purple_conversation_write(conv, NULL, tmp,
PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(tmp);
}
conn->verified_connect_data = purple_proxy_connect(NULL, account,
conn->verifiedip, conn->port,
peer_connection_verified_established_cb, conn);
if ((conn->verifiedip == NULL) ||
strcmp(conn->verifiedip, conn->clientip))
{
conn->client_connect_data = purple_proxy_connect(NULL, account,
conn->clientip, conn->port,
peer_connection_client_established_cb, conn);
}
if ((conn->verified_connect_data != NULL) ||
(conn->client_connect_data != NULL))
{
/* Connecting... */
conn->connect_timeout_timer = purple_timeout_add_seconds(5,
peer_connection_tooktoolong, conn);
return;
}
}
/*
* 2. Attempt to have the remote user connect to us (using both
* our verifiedip and our clientip).
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_TRIED_INCOMING) &&
(!conn->use_proxy))
{
conn->flags |= PEER_CONNECTION_FLAG_TRIED_INCOMING;
/*
* Remote user is connecting to us, so we'll need to verify
* that the user who connected is our friend.
*/
conn->flags |= PEER_CONNECTION_FLAG_IS_INCOMING;
conn->listen_data = purple_network_listen_range(5190, 5290, SOCK_STREAM,
peer_connection_establish_listener_cb, conn);
if (conn->listen_data != NULL)
{
/* Opening listener socket... */
return;
}
}
/*
* 3. Attempt to have both users connect to an intermediate proxy
* server.
*/
if (!(conn->flags & PEER_CONNECTION_FLAG_TRIED_PROXY))
{
conn->flags |= PEER_CONNECTION_FLAG_TRIED_PROXY;
/*
* If we initiate the proxy connection, then the remote user
* could be anyone, so we need to verify that the user who
* connected is our friend.
*/
if (!conn->use_proxy)
conn->flags |= PEER_CONNECTION_FLAG_IS_INCOMING;
if (conn->type == OSCAR_CAPABILITY_DIRECTIM)
{
gchar *tmp;
PurpleConversation *conv;
tmp = g_strdup(_("Attempting to connect via proxy server."));
conv = purple_conversation_new(PURPLE_CONV_TYPE_IM, account, conn->bn);
purple_conversation_write(conv, NULL, tmp,
PURPLE_MESSAGE_SYSTEM, time(NULL));
g_free(tmp);
}
conn->verified_connect_data = purple_proxy_connect(NULL, account,
(conn->proxyip != NULL)
? conn->proxyip
: (conn->od->icq ? ICQ_PEER_PROXY_SERVER : AIM_PEER_PROXY_SERVER),
PEER_PROXY_PORT,
peer_proxy_connection_established_cb, conn);
if (conn->verified_connect_data != NULL)
{
/* Connecting... */
return;
}
}
/* Give up! */
peer_connection_destroy(conn, OSCAR_DISCONNECT_COULD_NOT_CONNECT, NULL);
}
