Beispiel #1
0
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 */
Beispiel #2
0
boolean
xmpp_connect (const char *user, const char * passwd, const char * server, unsigned short port)
{

  GError * error = NULL;
  LmMessage * m;
  LmMessage * reply;
  LmMessageNode * query;
  LmMessageNode * item;
  gboolean success;

  lm_connection_set_server (connection, server);
  lm_connection_set_port (connection, port);

  g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Connecting to %s..."), server);
  success = lm_connection_open_and_block (connection, &error);
  if (!success) goto error;

  g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Authenticating with JID %s..."), user);
  success = lm_connection_authenticate_and_block (connection, user, passwd, CONN_XMPP_RESOURCE, &error);
  if (!success) goto error;
  g_log (G_LOG_DOMAIN, G_LOG_LEVEL_INFO, _("Connected successfully."), user);

  /* Fetch roster */
  m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_IQ, LM_MESSAGE_SUB_TYPE_GET);
  query = lm_message_node_add_child (m->node, "query", NULL);
  lm_message_node_set_attributes (query, "xmlns", "jabber:iq:roster", NULL);
  reply = lm_connection_send_with_reply_and_block (connection, m, &error);
  query = lm_message_node_get_child (reply->node, "query");
  item  = lm_message_node_get_child (query, "item");
  while (item)
    {
      xmpp_user_t user;
      const gchar *jid, *name;
      jid = lm_message_node_get_attribute (item, "jid");
      name = lm_message_node_get_attribute (item, "name");
      user = intern_user (jid);
      user->name = g_strdup (name);
      user->status = OFFLINE;
      item = item->next;
    }
  lm_message_unref (reply);
  lm_message_unref (m);

  m = lm_message_new_with_sub_type (NULL, LM_MESSAGE_TYPE_PRESENCE, LM_MESSAGE_SUB_TYPE_AVAILABLE);
  lm_connection_send(connection, m, NULL);
  lm_message_unref (m);

  return TRUE;

  /* Error handling */
 error:
  g_message ("%s", error->message);
  return FALSE;
}
Beispiel #3
0
int
main (int argc, char **argv)
{
    GMainLoop        *main_loop;
    LmConnection     *connection;
    LmMessageHandler *handler;
    gboolean          result;
    UserInfo         *info;
    gchar            *jid;
                                                                                
    if (argc < 6) {
        g_print ("Usage: %s <server> <username> <password> <connectserver> <connectport>\n", argv[0]);
        return 1;
    }
                                                                                
    connection = lm_connection_new (argv[4]);

    jid = g_strdup_printf ("%s@%s", argv[2], argv[1]);
    lm_connection_set_jid (connection, jid);
    g_free (jid);

    lm_connection_set_port (connection, strtol (argv[5], (char **) NULL, 10));

    handler = lm_message_handler_new (handle_messages, NULL, NULL);
    lm_connection_register_message_handler (connection, handler,
                                            LM_MESSAGE_TYPE_MESSAGE,
                                            LM_HANDLER_PRIORITY_NORMAL);
                                                                                
    lm_message_handler_unref (handler);
                                                                                
    info = g_new0 (UserInfo, 1);
    info->name = g_strdup (argv[2]);
    info->passwd = g_strdup (argv[3]);
                                                                                
    result = lm_connection_open (connection,
                                 (LmResultFunction) connection_open_cb,
                                 info, NULL, NULL);
                                                                                
    if (!result) {
        g_print ("Opening connection failed: %d\n", result);
    } else {
        g_print ("Returned from the connection_open\n");
    }
                                                                                
    main_loop = g_main_loop_new (NULL, FALSE);
    g_main_loop_run (main_loop);
                                                                                
    return 0;
}
Beispiel #4
0
static void
start_registration(struct register_data *rd)
{
	LmConnection  *lmconn;
	GError *error = NULL;

	lmconn = lm_connection_new(NULL);
	if (rd->use_ssl) {
		if (!set_ssl(lmconn, &error, NULL, FALSE))
			goto err;
	} else {
		if (!set_ssl(lmconn, &error, NULL, TRUE))
			goto err;
	}
	if (settings_get_bool("xmpp_use_proxy") && !set_proxy(lmconn, &error))
		goto err;
	if (rd->port <= 0)
		rd->port = rd->use_ssl ? LM_CONNECTION_DEFAULT_PORT_SSL
		    : LM_CONNECTION_DEFAULT_PORT;
	lm_connection_set_server(lmconn, rd->address);
	lm_connection_set_port(lmconn, rd->port);
	lm_connection_set_jid(lmconn, NULL);
	rd->id = NULL;
	rd->lmconn = lmconn;
	rd->handler = NULL;
	register_data = g_slist_prepend(register_data, rd);
	lm_connection_set_disconnect_function(lmconn, register_lm_close_cb,
	    rd, NULL);
	if (!lm_connection_open(lmconn, register_lm_open_cb, rd, NULL,
	    &error)) {
		rd_cleanup(rd);
		signal_emit("xmpp register error", 3, rd->username, rd->domain,
		    error != NULL ? error->message : NULL);
		if (error != NULL)
			g_error_free(error);
	}
	return;

err:
	signal_emit("xmpp register error", 3, rd->username, rd->domain,
	    error != NULL ? error->message : NULL);
	if (error != NULL)
		g_error_free(error);
	lm_connection_unref(lmconn);
}
Beispiel #5
0
//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;
}
Beispiel #6
0
void rebuild_connection(MP3tunesHarmony* harmony) {
    gchar* jid; 
    
    /*
    if (harmony->connection != NULL) {
        lm_connection_unref(harmony->connection);
        harmony->connection = NULL;
    }
    if (harmony->harmony_download_message_handler != NULL) {
        lm_message_handler_unref(harmony->harmony_download_message_handler);
        harmony->harmony_download_message_handler = NULL;
    }
    */
    harmony->connection = lm_connection_new(harmony->host);
    harmony->harmony_iq_message_handler = lm_message_handler_new(harmony_iq_callback, harmony, NULL);    

    lm_connection_set_port(harmony->connection, harmony->port);

    jid = mp3tunes_harmony_get_jid(harmony);
    g_debug("Logging in with: %s", jid);
    lm_connection_set_jid(harmony->connection, jid);
    g_free(jid);
    lm_connection_register_message_handler(harmony->connection, harmony->harmony_iq_message_handler, LM_MESSAGE_TYPE_IQ, LM_HANDLER_PRIORITY_LAST);
}
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 ();
}
Beispiel #8
0
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);
}
Beispiel #9
0
SERVER_REC *
xmpp_server_init_connect(SERVER_CONNECT_REC *connrec)
{
	XMPP_SERVER_REC *server;
	XMPP_SERVER_CONNECT_REC *conn = (XMPP_SERVER_CONNECT_REC *)connrec;
	char *recoded;

	if (conn->address == NULL || conn->address[0] == '\0')
		return NULL;
	if (conn->nick == NULL || conn->nick[0] == '\0')
		return NULL;
	g_return_val_if_fail(IS_XMPP_SERVER_CONNECT(conn), NULL);

	server = g_new0(XMPP_SERVER_REC, 1);
	server->chat_type = XMPP_PROTOCOL;
	server->user = xmpp_extract_user(conn->nick);
	server->domain = xmpp_have_domain(conn->nick) ?
	    xmpp_extract_domain(conn->nick) : g_strdup(conn->address);
	server->jid = xmpp_have_domain(conn->nick) ?
	    xmpp_strip_resource(conn->nick)
	    : g_strconcat(server->user, "@", server->domain, (void *)NULL);
	server->resource = xmpp_extract_resource(conn->nick);
	if (server->resource == NULL)
		server->resource = g_strdup("irssi-xmpp");
	server->priority = settings_get_int("xmpp_priority");
	if (xmpp_priority_out_of_bound(server->priority))
		server->priority = 0;
	server->ping_id = NULL;
	server->server_features = NULL;
	server->my_resources = NULL;
	server->roster = NULL;
	server->msg_handlers = NULL;
	server->channels_join = channels_join;
	server->isnickflag = isnickflag_func;
	server->ischannel = ischannel_func;
	server->get_nick_flags = get_nick_flags;
	server->send_message = send_message;
	server->connrec = (XMPP_SERVER_CONNECT_REC *)conn;
	server_connect_ref(connrec);

	/* don't use irssi's sockets */
	server->connrec->no_connect = TRUE;
	server->connect_pid = -1;

	if (server->connrec->port <= 0)
		server->connrec->port = (server->connrec->use_ssl) ?
		    LM_CONNECTION_DEFAULT_PORT_SSL : LM_CONNECTION_DEFAULT_PORT;

	if (conn->real_jid == NULL)
		conn->real_jid = conn->nick;
	else
		g_free(conn->nick);
	conn->nick = g_strdup(settings_get_bool("xmpp_set_nick_as_username") ?
	    server->user : server->jid);

	/* init loudmouth connection structure */
	server->lmconn = lm_connection_new(NULL);
	lm_connection_set_server(server->lmconn, server->connrec->address);
	lm_connection_set_port(server->lmconn, server->connrec->port);
	recoded = xmpp_recode_out(server->jid);
	lm_connection_set_jid(server->lmconn, recoded);
	g_free(recoded);
	lm_connection_set_keep_alive_rate(server->lmconn, 30);

	server->timeout_tag = 0;
	server_connect_init((SERVER_REC *)server);
	server->connect_tag = 1;
	return (SERVER_REC *)server;
}