ConnectResult XMPPAccountHandler::connect() { UT_DEBUGMSG(("XMPPAccountHandler::connect()\n")); if (m_bLoggedIn) return CONNECT_ALREADY_CONNECTED; if (m_pConnection) return CONNECT_IN_PROGRESS; // try to request a frame here; note that this might return 0, for example on application startup XAP_Frame *pFrame = XAP_App::getApp()->getLastFocussedFrame(); const std::string server = getProperty("server"); const std::string username = getProperty("username"); const std::string port = getProperty("port"); // TODO: unused atm const std::string resource = getProperty("resource"); const std::string encryption = getProperty("encryption"); std::string jid = username + "@" + server; UT_DEBUGMSG(("Connecting to server: |%s|, username: |%s|, resource: |%s|\n", server.c_str(), username.c_str(), resource.c_str())); // NULL means perform SRV record lookup based on JID (Loudmouth 1.3.2+) m_pConnection = lm_connection_new(NULL); UT_return_val_if_fail(m_pConnection, CONNECT_INTERNAL_ERROR); lm_connection_set_jid(m_pConnection, jid.c_str()); // setup SSL if (lm_ssl_is_supported() && encryption == "true") { LmSSL* pSSL = lm_ssl_new(NULL, NULL, NULL, NULL); // TODO: free this lm_ssl_use_starttls(pSSL, TRUE, TRUE); lm_connection_set_ssl(m_pConnection, pSSL); lm_ssl_unref(pSSL); } GError* error = NULL; if (!lm_connection_open(m_pConnection, lm_connection_open_async_cb, this, NULL, &error)) { UT_DEBUGMSG(("Failed to open: %s\n", error ? error->message : "")); lm_connection_unref(m_pConnection); m_pConnection = NULL; if (pFrame) { // inform the user of the connection failure // TODO: this shouldn't be here, the caller should handle this UT_UTF8String msg; // TODO: make this localizable UT_UTF8String_sprintf(msg, "Error while connecting to %s: %s\n", server.c_str(), (error ? error->message : "")); pFrame->showMessageBox(msg.utf8_str(), XAP_Dialog_MessageBox::b_O, XAP_Dialog_MessageBox::a_OK); } return CONNECT_FAILED; } return CONNECT_IN_PROGRESS; }
void xmpp_connect() { GError *err = NULL; const gchar *conf_server; LmSSL *ssl; int use_ssl, use_tls, port; const gchar *jid; wantconnection = 1; if (connection && lm_connection_is_open(connection)) { ui_print("connect: connection alredy opened, aborting\n"); return; } if (connection == NULL) connection = lm_connection_new(NULL); use_ssl = get_settings_int(USE_SSL); use_tls = get_settings_int(USE_TLS); jid = get_settings_str(JID); port = get_settings_int(PORT); if (use_ssl || use_tls) { if (!lm_ssl_is_supported()) { ui_print("Error: SSL not available\n"); } else if (use_ssl && use_tls) { ui_print("Error: You can't use ssl and tls at the same time"); } else { ssl = lm_ssl_new(NULL, ssl_cb, NULL, NULL); lm_ssl_use_starttls(ssl, !use_ssl, use_tls); lm_connection_set_ssl(connection, ssl); lm_ssl_unref(ssl); } } if (!port) { port = (use_ssl) ? LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT; } lm_connection_set_port(connection, port); lm_connection_set_jid(connection, jid); lm_connection_set_keep_alive_rate(connection, 30); lm_connection_set_disconnect_function(connection, connection_disconnect_cb, NULL, NULL); conf_server = get_settings_str(SERVER); if (!conf_server) { ui_print("ERROR: Insufficient configuration, " "connecting aborted (server not set)\n"); return; } else { if(!lm_connection_get_server(connection)) lm_connection_set_server(connection, conf_server); } ui_print("Opening connection to %s\n", conf_server); if(!lm_connection_open(connection, (LmResultFunction)connection_open_cb, NULL, NULL, &err)) { ui_print("Error opening connection: %s\n", err->message); g_error_free(err); } } /* xmpp_connect */
int main (int argc, char **argv) { LmConnection *conn; gchar *jid; LmSSL *ssl; Arguments arguments; GError *error = NULL; if (argc != 5) { print_usage (); return EXIT_FAILURE; } arguments.username = argv[1]; arguments.password = argv[2]; arguments.test_contact = argv[3]; arguments.test_message = argv[4]; /* Create a new mainloop to handle the default context */ main_loop = g_main_loop_new (NULL, FALSE); /* Create a new connection, don't set a specific host */ conn = lm_connection_new (NULL); ssl = lm_ssl_new (NULL, NULL, NULL, NULL); /* Require the use of STARTTLS */ lm_ssl_use_starttls (ssl, TRUE, TRUE); /* Use SSL for the connection */ lm_connection_set_ssl (conn, ssl); /* conn holds a ref now so we can safely remove the initial one */ lm_ssl_unref (ssl); jid = ensure_full_jid (argv[1]); /* Set the connection jid, this will implicitely lookup the host to * * connect to. */ lm_connection_set_jid (conn, jid); g_free (jid); if (!lm_connection_open (conn, open_cb, &arguments, NULL, &error)) { g_print ("Failed to open connection: %s\n", error->message); g_clear_error (&error); return EXIT_FAILURE; } /* Starting the mainloop with get Loudmouth to start process incoming * * events. This call will not return until g_main_loop_quit is called */ g_main_loop_run (main_loop); return EXIT_SUCCESS; }
gboolean set_ssl(LmConnection *lmconn, GError **error, gpointer user_data, gboolean use_starttls) { LmSSL *ssl; if (!lm_ssl_is_supported() && error != NULL) { *error = g_new(GError, 1); (*error)->message = g_strdup("SSL is not supported in this build"); return FALSE; } ssl = lm_ssl_new(NULL, lm_ssl_cb, user_data, NULL); lm_connection_set_ssl(lmconn, ssl); if (use_starttls) lm_ssl_use_starttls(ssl, TRUE, TRUE); lm_ssl_unref(ssl); return TRUE; }
//doc Loudmouth connect Connects to the server. Returns <code>self</code>. IoObject *IoLoudmouth_connect(IoLoudmouth *self, IoObject *locals, IoMessage *m) { // Q: Should we io_free() these? IoSeq* username = IoObject_getSlot_(self, IOSYMBOL("username")); IoSeq* password = IoObject_getSlot_(self, IOSYMBOL("password")); IoSeq* resource = IoObject_getSlot_(self, IOSYMBOL("resource")); IoSeq* host = IoObject_getSlot_(self, IOSYMBOL("host")); IoNumber* port = IoObject_getSlot_(self, IOSYMBOL("port")); IoObject* use_ssl = IoObject_getSlot_(self, IOSYMBOL("useSsl")); IOASSERT(ISSEQ(username), "Loudmouth: username should be a Sequence"); IOASSERT(ISSEQ(password), "Loudmouth: password should be a Sequence"); IOASSERT(ISSEQ(resource), "Loudmouth: resource should be a Sequence"); IOASSERT(ISSEQ(host), "Loudmouth: host should be a Sequence"); IOASSERT(ISNUMBER(port), "Loudmouth: port should be a Number"); if(LMCONN(self) == NULL) { LmConnection *connection = lm_connection_new_with_context(CSTRING(host), main_context); IoObject_setDataPointer_(self, connection); lm_connection_set_jid(connection, CSTRING(IoObject_getSlot_(self, IOSYMBOL("jid")))); lm_connection_set_port(connection, CNUMBER(port)); if(ISTRUE(use_ssl) && lm_ssl_is_supported()) { LmSSL *ssl = lm_ssl_new(NULL, onSslError, NULL, NULL); lm_connection_set_ssl(connection, ssl); lm_ssl_unref(ssl); } LmMessageHandler* handler = lm_message_handler_new(onXmppMessage, self, NULL); lm_connection_register_message_handler( connection, handler, LM_MESSAGE_TYPE_MESSAGE, LM_HANDLER_PRIORITY_NORMAL ); lm_message_handler_unref(handler); lm_connection_set_disconnect_function(connection, onXmppDisconnect, NULL, NULL); } lm_connection_open(LMCONN(self), onXmppConnect, self, NULL, NULL); return self; }
void LM::Account::enable () { GError *error = NULL; xmlChar* server = NULL; unsigned port = LM_CONNECTION_DEFAULT_PORT; LmSSL* ssl = NULL; server = xmlGetProp (node, BAD_CAST "server"); { xmlChar* port_str = xmlGetProp (node, BAD_CAST "port"); port = atoi ((const char*)port_str); xmlFree (port_str); } { gchar* jid = NULL; xmlChar* user = NULL; xmlChar* resource = NULL; user = xmlGetProp (node, BAD_CAST "user"); resource = xmlGetProp (node, BAD_CAST "resource"); jid = g_strdup_printf ("%s@%s/%s", user, server, resource); lm_connection_set_jid (connection, jid); g_free (jid); xmlFree (user); xmlFree (resource); } /* FIXME: this is an ugly workaround */ if (g_strcmp0 ("gmail.com", (const char*)server) == 0) lm_connection_set_server (connection, "xmpp.l.google.com"); else lm_connection_set_server (connection, (const char*)server); lm_connection_set_port (connection, port); ssl = lm_ssl_new (NULL, NULL, NULL, NULL); lm_ssl_use_starttls (ssl, TRUE, TRUE); lm_connection_set_ssl(connection, ssl); lm_ssl_unref (ssl); if ( !lm_connection_open (connection, (LmResultFunction)on_connection_opened_c, this, NULL, &error)) { gchar* message = NULL; message = g_strdup_printf (_("error connecting (%s)"), error->message); status = message; g_free (message); g_error_free (error); } else { status = _("connecting"); } xmlFree (server); xmlSetProp (node, BAD_CAST "startup", BAD_CAST "true"); trigger_saving (); updated (); }
int main (int argc, char **argv) { GMainContext *main_context; GOptionContext *context; LmConnection *connection; context = g_option_context_new ("- test send message asynchronously"); g_option_context_add_main_entries (context, entries, NULL); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free (context); if (!username || !password || !recipient) { g_printerr ("For usage, try %s --help\n", argv[0]); return EXIT_FAILURE; } if (username && strchr (username, '@') == NULL) { g_printerr ("LmSendAsync: Username must have an '@' included\n"); return EXIT_FAILURE; } main_context = g_main_context_new (); connection = lm_connection_new_with_context (server, main_context); lm_connection_set_port (connection, port); lm_connection_set_jid (connection, username); if (fingerprint) { LmSSL *ssl; char *p; int i; if (port == LM_CONNECTION_DEFAULT_PORT) { lm_connection_set_port (connection, LM_CONNECTION_DEFAULT_PORT_SSL); } for (i = 0, p = fingerprint; *p && *(p+1); i++, p += 3) { expected_fingerprint[i] = (unsigned char) g_ascii_strtoull (p, NULL, 16); } ssl = lm_ssl_new (expected_fingerprint, (LmSSLFunction) ssl_cb, NULL, NULL); lm_ssl_use_starttls (ssl, TRUE, FALSE); lm_connection_set_ssl (connection, ssl); lm_ssl_unref (ssl); } if (!lm_connection_open (connection, (LmResultFunction) connection_open_cb, NULL, NULL, NULL)) { g_printerr ("LmSendAsync: Could not open a connection\n"); return EXIT_FAILURE; } main_loop = g_main_loop_new (main_context, FALSE); g_main_loop_run (main_loop); return (test_success ? EXIT_SUCCESS : EXIT_FAILURE); }