gboolean connect_to_server(PurpleConnection *gc, gchar *server, gint port) { PurpleAccount *account ; qq_data *qd; g_return_val_if_fail(gc != NULL && gc->proto_data != NULL, FALSE); account = purple_connection_get_account(gc); qd = (qq_data *) gc->proto_data; if (server == NULL || server[0] == '\0' || port == 0) { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Invalid server or port")); return FALSE; } purple_connection_update_progress(gc, _("Connecting to server"), 1, QQ_CONNECT_STEPS); purple_debug_info("QQ", "Connect to %s:%d\n", server, port); if (qd->conn_data != NULL) { purple_proxy_connect_cancel(qd->conn_data); qd->conn_data = NULL; } #ifdef purple_proxy_connect_udp if (qd->use_tcp) { qd->conn_data = purple_proxy_connect(gc, account, server, port, connect_cb, gc); } else { qd->conn_data = purple_proxy_connect_udp(gc, account, server, port, connect_cb, gc); } if ( qd->conn_data == NULL ) { purple_debug_error("QQ", "Couldn't create socket\n"); return FALSE; } #else /* QQ connection via UDP/TCP. * Now use Purple proxy function to provide TCP proxy support, * and qq_udp_proxy.c to add UDP proxy support (thanks henry) */ if(qd->use_tcp) { qd->conn_data = purple_proxy_connect(gc, account, server, port, connect_cb, gc); if ( qd->conn_data == NULL ) { purple_debug_error("QQ", "Unable to connect.\n"); return FALSE; } return TRUE; } purple_debug_info("QQ", "UDP Connect to %s:%d\n", server, port); qd->udp_query_data = purple_dnsquery_a(server, port, udp_host_resolved, gc); if ( qd->udp_query_data == NULL ) { purple_debug_error("QQ", "Could not resolve hostname\n"); return FALSE; } #endif return TRUE; }
static void om_attempt_connection(OmegleConnection *omconn) { OmegleAccount *oma = omconn->oma; #if 0 /* Connection to attempt retries. This code doesn't work perfectly, but * remains here for future reference if needed */ if (time(NULL) - omconn->request_time > 5) { /* We've continuously tried to remake this connection for a * bit now. It isn't happening, sadly. Time to die. */ purple_debug_error("omegle", "could not connect after retries\n"); om_fatal_connection_cb(omconn); return; } purple_debug_info("omegle", "making connection attempt\n"); /* TODO: If we're retrying the connection, consider clearing the cached * DNS value. This will require some juggling with the hostname param */ /* TODO/FIXME: This retries almost instantenously, which in some cases * runs at blinding speed. Slow it down. */ /* TODO/FIXME: this doesn't retry properly on non-ssl connections */ #endif if (omconn->method & OM_METHOD_SSL) { omconn->ssl_conn = purple_ssl_connect(oma->account, omconn->hostname, 443, om_post_or_get_ssl_connect_cb, om_ssl_connection_error, omconn); } else { omconn->connect_data = purple_proxy_connect(NULL, oma->account, omconn->hostname, 80, om_post_or_get_connect_cb, omconn); } return; }
void GetPortrait(struct fetion_account_data *sip, struct fetion_buddy *buddy, const gchar * fullURL) { PurpleProxyConnectData *conn; gchar *server_ip; g_return_if_fail(buddy != NULL); buddy->sip = sip; if (fullURL != NULL) { gchar *tp = strchr(fullURL, '/'); server_ip = g_strndup(fullURL, tp-fullURL); buddy->host = g_strdup(server_ip); buddy->portrait_url = g_strdup(tp); } else server_ip = g_strdup(sip->PortraitServer); purple_debug_info("fetion:", "GetPortrait:buddy[%s]\n", buddy->name); if ((conn = purple_proxy_connect(sip->gc, sip->account, server_ip, 80, GetPortrait_cb, buddy)) == NULL) { purple_connection_error_reason(sip->gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Couldn't create socket")); } g_free(server_ip); }
static void lookup_internal_ip() { gchar* addressOfControl; int port = 0; if(!purple_url_parse(control_info.control_url, &addressOfControl, &port, NULL, NULL, NULL)) { purple_debug_error("upnp", "lookup_internal_ip(): Failed In Parse URL\n"); return; } if(port == 0 || port == -1) { port = DEFAULT_HTTP_PORT; } if(purple_proxy_connect(NULL, NULL, addressOfControl, port, looked_up_internal_ip_cb, NULL) == NULL) { purple_debug_error("upnp", "Get Local IP Connect Failed: Address: %s @@@ Port %d\n", addressOfControl, port); } g_free(addressOfControl); }
static void http_connection_connect(PurpleHTTPConnection *conn) { PurpleBOSHConnection *bosh = conn->bosh; PurpleConnection *gc = bosh->js->gc; PurpleAccount *account = purple_connection_get_account(gc); conn->state = HTTP_CONN_CONNECTING; if (bosh->ssl) { if (purple_ssl_is_supported()) { conn->psc = purple_ssl_connect(account, bosh->host, bosh->port, ssl_connection_established_cb, ssl_connection_error_cb, conn); if (!conn->psc) { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT, _("Unable to establish SSL connection")); } } else { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT, _("SSL support unavailable")); } } else if (purple_proxy_connect(conn, account, bosh->host, bosh->port, connection_established_cb, conn) == NULL) { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Unable to connect")); } }
/*------------------------------------------------------------------------ * Attempt to establish a connection to the MXit server. * * @param session The MXit session object */ static void mxit_login_connect( struct MXitSession* session ) { PurpleProxyConnectData* data = NULL; purple_debug_info( MXIT_PLUGIN_ID, "mxit_login_connect\n" ); purple_connection_update_progress( session->con, _( "Connecting..." ), 1, 4 ); /* * at this stage we have all the user's information we require * for logging into MXit. we will now create a new connection to * a MXit server. */ if ( !session->http ) { /* socket connection */ data = purple_proxy_connect( session->con, session->acc, session->server, session->port, mxit_cb_connect, session ); if ( !data ) { purple_connection_error( session->con, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _( "Unable to connect to the MXit server. Please check your server settings." ) ); return; } } else { /* http connection */ mxit_connected( session ); } }
static void sendlater(PurpleConnection * gc, const char *buf) { struct fetion_account_data *sip = gc->proto_data; if (!sip->connecting) { purple_debug_info("fetion", "connecting to %s port %d\n", sip-> realhostname ? sip->realhostname : "{NULL}", sip->realport); if (purple_proxy_connect (gc, sip->account, sip->realhostname, sip->realport, send_later_cb, gc) == NULL) { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _ ("Couldn't create socket")); } sip->connecting = TRUE; } if (purple_circ_buffer_get_max_read(sip->txbuf) > 0) purple_circ_buffer_append(sip->txbuf, "\r\n", 2); purple_circ_buffer_append(sip->txbuf, buf, strlen(buf)); }
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); } } }
static void irc_login(PurpleAccount *account) { PurpleConnection *gc; struct irc_conn *irc; char **userparts; const char *username = purple_account_get_username(account); gc = purple_account_get_connection(account); gc->flags |= PURPLE_CONNECTION_NO_NEWLINES; if (strpbrk(username, " \t\v\r\n") != NULL) { purple_connection_error(gc, _("IRC nicks may not contain whitespace")); return; } gc->proto_data = irc = g_new0(struct irc_conn, 1); irc->fd = -1; irc->account = account; irc->outbuf = purple_circ_buffer_new(512); userparts = g_strsplit(username, "@", 2); purple_connection_set_display_name(gc, userparts[0]); irc->server = g_strdup(userparts[1]); g_strfreev(userparts); irc->buddies = g_hash_table_new_full((GHashFunc)irc_nick_hash, (GEqualFunc)irc_nick_equal, NULL, (GDestroyNotify)irc_buddy_free); irc->cmds = g_hash_table_new(g_str_hash, g_str_equal); irc_cmd_table_build(irc); irc->msgs = g_hash_table_new(g_str_hash, g_str_equal); irc_msg_table_build(irc); purple_connection_update_progress(gc, _("Connecting"), 1, 2); if (purple_account_get_bool(account, "ssl", FALSE)) { if (purple_ssl_is_supported()) { irc->gsc = purple_ssl_connect(account, irc->server, purple_account_get_int(account, "port", IRC_DEFAULT_SSL_PORT), irc_login_cb_ssl, irc_ssl_connect_failure, gc); } else { purple_connection_error(gc, _("SSL support unavailable")); return; } } if (!irc->gsc) { if (purple_proxy_connect(gc, account, irc->server, purple_account_get_int(account, "port", IRC_DEFAULT_PORT), irc_login_cb, gc) == NULL) { purple_connection_error(gc, _("Couldn't create socket")); return; } } }
/* * This callback will be called when we're unable to connect to * the remote host in DC_OUTGOING_TIMEOUT seconds. */ gboolean msn_dc_outgoing_connection_timeout_cb(gpointer data) { MsnDirectConn *dc = data; purple_debug_info("msn", "msn_dc_outgoing_connection_timeout_cb %p\n", dc); g_return_val_if_fail(dc != NULL, FALSE); dc->connect_timeout_handle = 0; if (dc->connect_data != NULL) { purple_proxy_connect_cancel(dc->connect_data); dc->connect_data = NULL; } if (dc->ext_ip && dc->ext_port) { /* Try external IP/port if available. */ dc->connect_data = purple_proxy_connect( NULL, dc->slpcall->slplink->session->account, dc->ext_ip, dc->ext_port, msn_dc_connected_to_peer_cb, dc ); g_free(dc->ext_ip); dc->ext_ip = NULL; if (dc->connect_data) { dc->connect_timeout_handle = purple_timeout_add_seconds( DC_OUTGOING_TIMEOUT, msn_dc_outgoing_connection_timeout_cb, dc ); } else { /* * Connection failed * Fall back to SB transfer */ msn_dc_outgoing_connection_timeout_cb(dc); } } else { /* * Both internal and external connection attempts failed. * Fall back to SB transfer. */ msn_dc_fallback_to_sb(dc); } return FALSE; }
static gboolean exec_skype() { if (!connected && !in_progress) { in_progress = TRUE; PurpleAccount *acct = skype_get_account(NULL); purple_proxy_connect(acct->gc, acct, purple_account_get_string(acct, "host", "skype.robbmob.com"), purple_account_get_int(acct, "port", 5000), connect_function, acct); g_thread_create((GThreadFunc)skype_read_thread, acct, FALSE, NULL); purple_timeout_add_seconds(10, connection_timeout, acct); } return TRUE; }
static void nap_login(PurpleAccount *account) { PurpleConnection *gc = purple_account_get_connection(account); purple_connection_update_progress(gc, _("Connecting"), 0, NAPSTER_CONNECT_STEPS); gc->proto_data = g_new0(struct nap_data, 1); if (purple_proxy_connect(gc, account, purple_account_get_string(account, "server", NAP_SERVER), purple_account_get_int(account, "port", NAP_PORT), nap_login_connect, gc) != 0) { purple_connection_error(gc, _("Unable to connect.")); } }
gboolean purple_socket_connect(PurpleSocket *ps, PurpleSocketConnectCb cb, gpointer user_data) { PurpleAccount *account = NULL; g_return_val_if_fail(ps != NULL, FALSE); if (ps->gc && purple_connection_is_disconnecting(ps->gc)) { purple_debug_error("socket", "connection is being destroyed"); ps->state = PURPLE_SOCKET_STATE_ERROR; return FALSE; } if (!purple_socket_check_state(ps, PURPLE_SOCKET_STATE_DISCONNECTED)) return FALSE; ps->state = PURPLE_SOCKET_STATE_CONNECTING; if (ps->host == NULL || ps->port < 0) { purple_debug_error("socket", "Host or port is not specified"); ps->state = PURPLE_SOCKET_STATE_ERROR; return FALSE; } if (ps->gc != NULL) account = purple_connection_get_account(ps->gc); ps->cb = cb; ps->cb_data = user_data; if (ps->is_tls) { ps->tls_connection = purple_ssl_connect(account, ps->host, ps->port, _purple_socket_connected_tls, _purple_socket_connected_tls_error, ps); } else { ps->raw_connection = purple_proxy_connect(ps->gc, account, ps->host, ps->port, _purple_socket_connected_raw, ps); } if (ps->tls_connection == NULL && ps->raw_connection == NULL) { ps->state = PURPLE_SOCKET_STATE_ERROR; return FALSE; } return TRUE; }
static void waprpl_login(PurpleAccount * acct) { PurpleConnection *gc = purple_account_get_connection(acct); purple_debug_info(WHATSAPP_ID, "logging in %s\n", purple_account_get_username(acct)); purple_connection_update_progress(gc, "Connecting", 0, 4); whatsapp_connection *wconn = g_new0(whatsapp_connection, 1); wconn->fd = -1; wconn->sslfd = -1; wconn->account = acct; wconn->rh = 0; wconn->wh = 0; wconn->timer = 0; wconn->connected = 0; wconn->conv_id = 1; wconn->gsc = 0; wconn->sslrh = 0; wconn->sslwh = 0; const char *username = purple_account_get_username(acct); const char *password = purple_account_get_password(acct); const char *nickname = purple_account_get_string(acct, "nick", ""); wconn->waAPI = waAPI_create(username, password, nickname); purple_connection_set_protocol_data(gc, wconn); const char *hostname = purple_account_get_string(acct, "server", ""); int port = purple_account_get_int(acct, "port", WHATSAPP_DEFAULT_PORT); char hn[256]; if (strlen(hostname) == 0) { sprintf(hn, "e%d.whatsapp.net", rand() % 9 + 1); hostname = hn; } if (purple_proxy_connect(gc, acct, hostname, port, waprpl_connect_cb, gc) == NULL) { purple_connection_error_reason(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, "Unable to connect"); } static int sig_con = 0; if (!sig_con) { sig_con = 1; purple_signal_connect(purple_blist_get_handle(), "blist-node-removed", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_removed), NULL); purple_signal_connect(purple_blist_get_handle(), "blist-node-added", _whatsapp_protocol, PURPLE_CALLBACK(waprpl_blist_node_added), NULL); } }
void sipe_backend_ft_start(struct sipe_file_transfer *ft, struct sipe_backend_fd *fd, const char* ip, unsigned port) { if (ip && port && !sipe_backend_ft_is_incoming(ft)) { /* Purple accepts ip & port only for incoming file transfers. * If we want to send file with Sender-Connect = TRUE negotiated, * we have to open the connection ourselves and pass the file * descriptor to purple_xfer_start. */ purple_proxy_connect(NULL, PURPLE_XFER->account, ip, port, connect_cb, ft); return; } purple_xfer_start(PURPLE_XFER, fd ? fd->fd : -1, ip, port); }
static void okc_attempt_connection(OkCupidConnection *okconn) { OkCupidAccount *oca = okconn->oca; oca->conns = g_slist_prepend(oca->conns, okconn); if (okconn->method & OKC_METHOD_SSL) { okconn->ssl_conn = purple_ssl_connect(oca->account, okconn->hostname, 443, okc_post_or_get_ssl_connect_cb, okc_ssl_connection_error, okconn); } else { okconn->connect_data = purple_proxy_connect(NULL, oca->account, okconn->hostname, 80, okc_post_or_get_connect_cb, okconn); } return; }
void purple_xfer_start(PurpleXfer *xfer, int fd, const char *ip, unsigned int port) { PurpleInputCondition cond; PurpleXferType type; g_return_if_fail(xfer != NULL); g_return_if_fail(purple_xfer_get_type(xfer) != PURPLE_XFER_UNKNOWN); type = purple_xfer_get_type(xfer); purple_xfer_set_status(xfer, PURPLE_XFER_STATUS_STARTED); /* * FIXME 3.0.0 -- there's too much broken code depending on fd == 0 * meaning "don't use a real fd" */ if (fd == 0) fd = -1; if (type == PURPLE_XFER_RECEIVE) { cond = PURPLE_INPUT_READ; if (ip != NULL) { xfer->remote_ip = g_strdup(ip); xfer->remote_port = port; /* Establish a file descriptor. */ purple_proxy_connect(NULL, xfer->account, xfer->remote_ip, xfer->remote_port, connect_cb, xfer); return; } else { xfer->fd = fd; } } else { cond = PURPLE_INPUT_WRITE; xfer->fd = fd; } begin_transfer(xfer, cond); }
/*------------------------------------------------------------------------ * Create HTTP connection for sending a HTTP request * * @param session The MXit session object * @param host The server name to connect to * @param port The port number to connect to * @param data The HTTP request data (including HTTP headers etc.) * @param datalen The HTTP request data length */ void mxit_http_send_request( struct MXitSession* session, char* host, int port, const char* data, int datalen ) { PurpleProxyConnectData* con = NULL; struct http_request* req; /* build the http request */ req = g_new0( struct http_request, 1 ); req->session = session; req->host = host; req->port = port; req->data = g_malloc0( datalen ); memcpy( req->data, data, datalen ); req->datalen = datalen; /* open connection to the HTTP server */ con = purple_proxy_connect( NULL, session->acc, host, port, mxit_cb_http_connect, req ); }
void mrim_xfer_proxy_ack(MrimPackage *pack, MrimData *mrim) { guint status = mrim_package_read_UL(pack); gchar *user_name = mrim_package_read_LPSA(pack); guint32 id = mrim_package_read_UL(pack); guint32 data_type = mrim_package_read_UL(pack); gchar *file_list = mrim_package_read_LPSA(pack); gchar *remote_ip = mrim_package_read_LPSA(pack); // В пакете есть ещё и другие поля, но они нам не нужны (*кроме proxy_id) g_return_if_fail(data_type != MRIM_PROXY_TYPE_FILES); PurpleXfer *xfer = g_hash_table_lookup(mrim->transfers, GUINT_TO_POINTER(id)); if (xfer) { if (status == PROXY_STATUS_OK) { MrimFT *ft = xfer->data; purple_debug_info("mrim-prpl", "[%s] Proxy accepted! Address list = '%s'\n", __func__, remote_ip); gchar **addrs = g_strsplit(remote_ip, ";", 0); gchar **addr = addrs; gchar *ip = NULL; guint16 port; while (*addr) { gchar **parts = g_strsplit(*addr, ":", 2); ip = g_strdup(parts[0]); port = atoi(parts[1]); g_strfreev(parts); if (port != 443) { // Мы не умеем SSL ;D break; } else { g_free(ip); } addr++; } g_strfreev(addrs); purple_debug_info("mrim-prpl", "[%s] Proxy host = '%s', port = %u\n", __func__, ip, port); ft->proxy_id[0] = mrim_package_read_UL(pack); ft->proxy_id[1] = mrim_package_read_UL(pack); ft->proxy_id[2] = mrim_package_read_UL(pack); ft->proxy_id[3] = mrim_package_read_UL(pack); ft->proxy_conn = purple_proxy_connect(NULL, mrim->account, ip, port, mrim_send_xfer_connect_cb, ft); } else { purple_debug_info("mrim-prpl", "[%s] Proxy request failed!\n", __func__); purple_xfer_unref(xfer); } } }
gboolean msn_servconn_connect(MsnServConn *servconn, const char *host, int port) { MsnSession *session; g_return_val_if_fail(servconn != NULL, FALSE); g_return_val_if_fail(host != NULL, FALSE); g_return_val_if_fail(port > 0, FALSE); session = servconn->session; if (servconn->connected) msn_servconn_disconnect(servconn); g_free(servconn->host); servconn->host = g_strdup(host); if (session->http_method) { /* HTTP Connection. */ if (!servconn->httpconn->connected) if (!msn_httpconn_connect(servconn->httpconn, host, port)) return FALSE;; servconn->connected = TRUE; servconn->httpconn->virgin = TRUE; /* Someone wants to know we connected. */ servconn->connect_cb(servconn); return TRUE; } servconn->connect_data = purple_proxy_connect(NULL, session->account, host, port, connect_cb, servconn); if (servconn->connect_data != NULL) { servconn->processing = TRUE; return TRUE; } else return FALSE; }
static void connect_impl (PnNode *conn, const gchar *hostname, gint port) { g_return_if_fail (conn); pn_log ("begin"); pn_debug ("conn=%p,name=%s", conn, conn->name); pn_debug ("hostname=%s,port=%d", hostname, port); pn_debug ("next=%p", conn->next); g_free (conn->hostname); conn->hostname = g_strdup (hostname); conn->port = port; if (conn->next) { conn->status = PN_NODE_STATUS_CONNECTING; conn->next->prev = conn; pn_node_connect (conn->next, hostname, port); conn->next->prev = NULL; } else { pn_node_close (conn); conn->status = PN_NODE_STATUS_CONNECTING; #if defined(USE_GIO) GSocketClient *client; client = g_socket_client_new(); conn->socket_cancel = g_cancellable_new(); g_socket_client_connect_to_host_async(client, hostname, port, conn->socket_cancel, connect_cb, conn); #elif defined(HAVE_LIBPURPLE) conn->connect_data = purple_proxy_connect (NULL, msn_session_get_user_data (conn->session), hostname, port, connect_cb, conn); #endif } pn_log ("end"); }
PurpleSslConnection * purple_ssl_connect_with_ssl_cn(PurpleAccount *account, const char *host, int port, PurpleSslInputFunction func, PurpleSslErrorFunction error_func, const char *ssl_cn, void *data) { PurpleSslConnection *gsc; g_return_val_if_fail(host != NULL, NULL); g_return_val_if_fail(port != 0 && port != -1, NULL); g_return_val_if_fail(func != NULL, NULL); g_return_val_if_fail(purple_ssl_is_supported(), NULL); if (!_ssl_initialized) { if (!ssl_init()) return NULL; } gsc = g_new0(PurpleSslConnection, 1); gsc->fd = -1; gsc->host = ssl_cn ? g_strdup(ssl_cn) : g_strdup(host); gsc->port = port; gsc->connect_cb_data = data; gsc->connect_cb = func; gsc->error_cb = error_func; /* TODO: Move this elsewhere */ gsc->verifier = purple_certificate_find_verifier("x509","tls_cached"); gsc->connect_data = purple_proxy_connect(NULL, account, host, port, purple_ssl_connect_cb, gsc); if (gsc->connect_data == NULL) { g_free(gsc->host); g_free(gsc); return NULL; } return (PurpleSslConnection *)gsc; }
/*------------------------------------------------------------------------ * Create HTTP connection for sending a HTTP request * * @param session The MXit session object * @param host The server name to connect to * @param port The port number to connect to * @param data The HTTP request data (including HTTP headers etc.) * @param datalen The HTTP request data length */ void mxit_http_send_request( struct MXitSession* session, char* host, int port, const char* data, int datalen ) { PurpleProxyConnectData* con = NULL; struct http_request* req; /* build the http request */ req = g_new0( struct http_request, 1 ); req->session = session; req->host = host; req->port = port; req->data = g_malloc0( datalen ); memcpy( req->data, data, datalen ); req->datalen = datalen; /* open connection to the HTTP server */ con = purple_proxy_connect( NULL, session->acc, host, port, mxit_cb_http_connect, req ); if ( !con ) { purple_connection_error_reason( session->con, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _( "Unable to connect" ) ); } }
void ycht_connection_open(PurpleConnection *gc) { YchtConn *ycht; YahooData *yd = purple_connection_get_protocol_data(gc); PurpleAccount *account = purple_connection_get_account(gc); ycht = g_new0(YchtConn, 1); ycht->gc = gc; ycht->fd = -1; yd->ycht = ycht; if (purple_proxy_connect(gc, account, purple_account_get_string(account, "ycht-server", YAHOO_YCHT_HOST), purple_account_get_int(account, "ycht-port", YAHOO_YCHT_PORT), ycht_got_connected, ycht) == NULL) { ycht_connection_error(ycht, _("Unable to connect")); return; } }
gboolean msn_httpconn_connect(MsnHttpConn *httpconn, const char *host, int port) { g_return_val_if_fail(httpconn != NULL, FALSE); g_return_val_if_fail(host != NULL, FALSE); g_return_val_if_fail(port > 0, FALSE); if (httpconn->connected) msn_httpconn_disconnect(httpconn); httpconn->connect_data = purple_proxy_connect(NULL, httpconn->session->account, host, 80, connect_cb, httpconn); if (httpconn->connect_data != NULL) { httpconn->waiting_response = TRUE; httpconn->connected = TRUE; } return httpconn->connected; }
void fetion_set_buddy_icon(PurpleConnection * gc, PurpleStoredImage * img) { size_t size = purple_imgstore_get_size(img); PurpleProxyConnectData *conn; struct fetion_account_data *sip = gc->proto_data; g_return_if_fail(img != NULL); if (size > 0x32000) return; sip->icon = img; purple_debug_info("fetion:", "set_buddy_icon:len[%d]\n", size); if ((conn = purple_proxy_connect(sip->gc, sip->account, sip->UploadServer, 80, UploadPortrait, sip)) == NULL) { purple_connection_error_reason(sip->gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Couldn't create socket")); } purple_imgstore_ref(img); }
void fetion_login(PurpleAccount * account) { PurpleConnection *gc; struct fetion_account_data *sip; gchar **userserver; gint ret; const char *username = purple_account_get_username(account); gc = purple_account_get_connection(account); gc->proto_data = sip = g_new0(struct fetion_account_data, 1); sip->gc = gc; sip->tg = 0; //temp group chat id sip->cseq = 0; sip->account = account; sip->registerexpire = 400; sip->reregister = time(NULL) + 100; sip->txbuf = purple_circ_buffer_new(0); sip->impresa = NULL; sip->icon_buf = purple_circ_buffer_new(0); sip->GetContactFlag = 0; purple_debug_info("Fetion:", "shit\n"); userserver = g_strsplit(username, "@", 2); purple_connection_set_display_name(gc, userserver[0]); if (IsCMccNo(userserver[0])) { sip->username = NULL; sip->mobileno = g_strdup(userserver[0]); } else { sip->mobileno = NULL; sip->username = g_strdup(userserver[0]); } // sip->servername = g_strdup(userserver[1]); sip->SysCfgServer = g_strdup("nav.fetion.com.cn"); sip->password = g_strdup(purple_connection_get_password(gc)); g_strfreev(userserver); sip->buddies = g_hash_table_new((GHashFunc) fetion_ht_hash_nick, (GEqualFunc) fetion_ht_equals_nick); sip->tempgroup = g_hash_table_new((GHashFunc) fetion_ht_hash_nick, (GEqualFunc) fetion_ht_equals_nick); sip->group = g_hash_table_new((GHashFunc) fetion_ht_hash_nick, (GEqualFunc) fetion_ht_equals_nick); sip->group2id = g_hash_table_new((GHashFunc) fetion_ht_hash_nick, (GEqualFunc) fetion_ht_equals_nick); purple_connection_update_progress(gc, _("Connecting"), 1, 2); /* TODO: Set the status correctly. */ sip->status = g_strdup("available"); sip->registertimeout = purple_timeout_add(60000, (GSourceFunc) LoginToSsiPortal, sip); //Try to get systemconfig sip->ServerVersion = NULL; sip->ServiceNoVersion = NULL; sip->ParaVersion = NULL; sip->HttpAppVersion = NULL; sip->ClientCfgVersion = NULL; sip->HintsVersion = NULL; ret = ParseCfg(sip); //if(ret!=0) sip->SysCfg.conn = purple_proxy_connect(NULL, sip->account, sip->SysCfgServer, 80, (PurpleProxyConnectFunction) RetriveSysCfg, sip); }
static void sevencup_attempt_connection(SevenCupConnection *scon) { gboolean is_proxy = FALSE; SevenCupAccount *sa = scon->sa; PurpleProxyInfo *proxy_info = NULL; if (sa && sa->account && !(scon->method & STEAM_METHOD_SSL)) { proxy_info = purple_proxy_get_setup(sa->account); if (purple_proxy_info_get_type(proxy_info) == PURPLE_PROXY_USE_GLOBAL) proxy_info = purple_global_proxy_get_info(); if (purple_proxy_info_get_type(proxy_info) == PURPLE_PROXY_HTTP) { is_proxy = TRUE; } } #if 0 /* Connection to attempt retries. This code doesn't work perfectly, but * remains here for future reference if needed */ if (time(NULL) - scon->request_time > 5) { /* We've continuously tried to remake this connection for a * bit now. It isn't happening, sadly. Time to die. */ purple_debug_error("7cups", "could not connect after retries\n"); sevencup_fatal_connection_cb(scon); return; } purple_debug_info("7cups", "making connection attempt\n"); /* TODO: If we're retrying the connection, consider clearing the cached * DNS value. This will require some juggling with the hostname param */ /* TODO/FIXME: This retries almost instantenously, which in some cases * runs at blinding speed. Slow it down. */ /* TODO/FIXME: this doesn't retry properly on non-ssl connections */ #endif sa->conns = g_slist_prepend(sa->conns, scon); /* * Do a separate DNS lookup for the given host name and cache it * for next time. * * TODO: It would be better if we did this before we call * purple_proxy_connect(), so we could re-use the result. * Or even better: Use persistent HTTP connections for servers * that we access continually. * * TODO: This cache of the hostname<-->IP address does not respect * the TTL returned by the DNS server. We should expire things * from the cache after some amount of time. */ if (!is_proxy && !(scon->method & STEAM_METHOD_SSL) && !g_hostname_is_ip_address(scon->hostname)) { /* Don't do this for proxy connections, since proxies do the DNS lookup */ gchar *host_ip; host_ip = g_hash_table_lookup(sa->hostname_ip_cache, scon->hostname); if (host_ip != NULL) { g_free(scon->hostname); scon->hostname = g_strdup(host_ip); } else if (sa->account && !sa->account->disconnecting) { GSList *host_lookup_list = NULL; PurpleDnsQueryData *query; host_lookup_list = g_slist_prepend( host_lookup_list, g_strdup(scon->hostname)); host_lookup_list = g_slist_prepend( host_lookup_list, sa); query = purple_dnsquery_a( #if PURPLE_VERSION_CHECK(3, 0, 0) scon->sa->account, #endif scon->hostname, 80, sevencup_host_lookup_cb, host_lookup_list); sa->dns_queries = g_slist_prepend(sa->dns_queries, query); host_lookup_list = g_slist_append(host_lookup_list, query); } } if (scon->method & STEAM_METHOD_SSL) { scon->ssl_conn = purple_ssl_connect(sa->account, scon->hostname, 443, sevencup_post_or_get_ssl_connect_cb, sevencup_ssl_connection_error, scon); } else { scon->connect_data = purple_proxy_connect(NULL, sa->account, scon->hostname, 80, sevencup_post_or_get_connect_cb, scon); } scon->timeout_watcher = purple_timeout_add_seconds(120, sevencup_connection_timedout, scon); 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); }