/*

 * gabble-connection.c - Source for GabbleConnection

 * Copyright (C) 2005 Collabora Ltd.

 *  and/or its subsidiary/subsidiaries. All rights reserved.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#include "config.h"

#include <dbus/dbus-glib.h>

#include <dbus/dbus-glib-lowlevel.h>

#include <glib-object.h>

#include "loudmouth/loudmouth.h"

#include <stdlib.h>

#include <string.h>

#include <stdio.h>

#include "handles.h"

#include "handle-set.h"

#include "telepathy-constants.h"

#include "telepathy-errors.h"

#include "telepathy-helpers.h"

#include "telepathy-interfaces.h"

#include "loudmouth/lm-connection.h"

#include "tp-channel-iface.h"

#include "tp-channel-factory-iface.h"

#include "gabble-connection.h"

#include "gabble-connection-glue.h"

#include "gabble-connection-signals-marshal.h"

#include "capabilities.h"

#include "debug.h"

#include "disco.h"

#include "gabble-presence-cache.h"

#include "gabble-presence.h"

#include "gabble-register.h"

#include "im-factory.h"

#include "search-factory.h"

#include "jingle-info.h"

#include "media-factory.h"

#include "muc-factory.h"

#include "namespaces.h"

#include "roster.h"

#include "util.h"

#include "vcard-manager.h"

#include "search-keys-info.h"

#include "gabble-media-channel.h"

#include "gabble-roomlist-channel.h"

#include "gabble_enums.h"

#include "sha1.h"

#include "base64.h"

#define DEBUG_FLAG GABBLE_DEBUG_CONNECTION

#define DBUS_API_SUBJECT_TO_CHANGE

#define BUS_NAME        "org.freedesktop.Telepathy.Connection.gabble"

#define OBJECT_PATH     "/org/freedesktop/Telepathy/Connection/gabble"

#define TP_ALIAS_PAIR_TYPE (dbus_g_type_get_struct ("GValueArray", \

      G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID))

#define TP_CAPABILITY_PAIR_TYPE (dbus_g_type_get_struct ("GValueArray", \

      G_TYPE_STRING, G_TYPE_UINT, G_TYPE_INVALID))

#define TP_CAPABILITIES_CHANGED_MONSTER_TYPE (dbus_g_type_get_struct \

    ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, \

                    G_TYPE_UINT, G_TYPE_UINT, G_TYPE_INVALID))

#define TP_GET_CAPABILITIES_MONSTER_TYPE (dbus_g_type_get_struct \

    ("GValueArray", G_TYPE_UINT, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, \

                    G_TYPE_INVALID))

#define TP_CHANNEL_LIST_ENTRY_TYPE (dbus_g_type_get_struct ("GValueArray", \

      DBUS_TYPE_G_OBJECT_PATH, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_UINT, \

      G_TYPE_INVALID))

#define ERROR_IF_NOT_CONNECTED(CONN, ERROR) \

  if ((CONN)->status != TP_CONN_STATUS_CONNECTED) \

    { \

      gabble_debug (DEBUG_FLAG, "rejected request as disconnected"); \

      g_set_error (ERROR, TELEPATHY_ERRORS, NotAvailable, \

          "Connection is disconnected"); \

      return FALSE; \

    }

#define ERROR_IF_NOT_CONNECTED_ASYNC(CONN, ERROR, CONTEXT) \

  if ((CONN)->status != TP_CONN_STATUS_CONNECTED) \

    { \

      gabble_debug (DEBUG_FLAG, "rejected request as disconnected"); \

      (ERROR) = g_error_new (TELEPATHY_ERRORS, NotAvailable, \

          "Connection is disconnected"); \

      dbus_g_method_return_error ((CONTEXT), (ERROR)); \

      g_error_free ((ERROR)); \

      return; \

    }

#ifdef DEBUG_FLAG

//#define DEBUG(format, ...)

#define DEBUGGING 0

#define NODE_DEBUG(n, s)

#endif /* DEBUG_FLAG */

#ifndef EMULATOR

G_DEFINE_TYPE(GabbleConnection, gabble_connection, G_TYPE_OBJECT)

#endif

typedef struct _StatusInfo StatusInfo;

struct _StatusInfo

{

  const gchar *name;

  TpConnectionPresenceType presence_type;

  const gboolean self;

  const gboolean exclusive;

};

/* order must match PresenceId enum in gabble-connection.h */

/* in increasing order of presence */

static const StatusInfo gabble_statuses[LAST_GABBLE_PRESENCE] = {

 { "offline",   TP_CONN_PRESENCE_TYPE_OFFLINE,       TRUE, TRUE },

 { "hidden",    TP_CONN_PRESENCE_TYPE_HIDDEN,        TRUE, TRUE },

 { "xa",        TP_CONN_PRESENCE_TYPE_EXTENDED_AWAY, TRUE, TRUE },

 { "away",      TP_CONN_PRESENCE_TYPE_AWAY,          TRUE, TRUE },

 { "dnd",       TP_CONN_PRESENCE_TYPE_AWAY,          TRUE, TRUE },

 { "available", TP_CONN_PRESENCE_TYPE_AVAILABLE,     TRUE, TRUE },

 { "chat",      TP_CONN_PRESENCE_TYPE_AVAILABLE,     TRUE, TRUE }

};

/* signal enum */

enum

{

    ALIASES_CHANGED,

    CAPABILITIES_CHANGED,

    NEW_CHANNEL,

    PRESENCE_UPDATE,

    STATUS_CHANGED,

    DISCONNECTED,

    LAST_SIGNAL 

#ifdef EMULATOR    

    = LAST_SIGNAL_CON

#endif

};

#ifdef EMULATOR

#include "libgabble_wsd_solution.h"

	GET_STATIC_ARRAY_FROM_TLS(signals,gabble_con,guint)

	#define signals (GET_WSD_VAR_NAME(signals,gabble_con, s)())	

	GET_STATIC_VAR_FROM_TLS(arguments,gabble_con,GHashTable*)

	#define arguments (*GET_WSD_VAR_NAME(arguments,gabble_con, s)())	

	GET_STATIC_VAR_FROM_TLS(gabble_connection_parent_class,gabble_con,gpointer)

	#define gabble_connection_parent_class (*GET_WSD_VAR_NAME(gabble_connection_parent_class,gabble_con,s)())

	GET_STATIC_VAR_FROM_TLS(g_define_type_id,gabble_con,GType)

	#define g_define_type_id (*GET_WSD_VAR_NAME(g_define_type_id,gabble_con,s)())

	//GET_STATIC_ARRAY_FROM_TLS(assumed_caps,gabble_con,gchar*)

	/*gchar** _s_gabble_con_assumed_caps() { return (gchar**)((libgabble_ImpurePtr()->_s_gabble_con_assumed_caps)); }

	#define assumed_caps (GET_WSD_VAR_NAME(assumed_caps,gabble_con, s)())	*/

static void gabble_connection_init (GabbleConnection *self); 

static void gabble_connection_class_init (GabbleConnectionClass *klass); 

static void gabble_connection_class_intern_init (gpointer klass) 

{ 

gabble_connection_parent_class = g_type_class_peek_parent (klass); 

gabble_connection_class_init ((GabbleConnectionClass*) klass); 

} 

EXPORT_C GType gabble_connection_get_type (void) 

{ 

if ((g_define_type_id == 0)) 

{ 

static const GTypeInfo g_define_type_info = 

	{ sizeof (GabbleConnectionClass), (GBaseInitFunc) ((void *)0), (GBaseFinalizeFunc) ((void *)0), (GClassInitFunc) gabble_connection_class_intern_init, (GClassFinalizeFunc) ((void *)0), ((void *)0), sizeof (GabbleConnection), 0, (GInstanceInitFunc) gabble_connection_init, ((void *)0) }; g_define_type_id = g_type_register_static ( ((GType) ((20) << (2))), g_intern_static_string ("GabbleConnection"), &g_define_type_info, (GTypeFlags) 0); { {} ; } } return g_define_type_id; 

	} ;

#else

	static guint signals[LAST_SIGNAL] = {0};

#endif	

/* properties */

enum

{

    PROP_PROTOCOL = 1,

    PROP_CONNECT_SERVER,

    PROP_PORT,

    PROP_OLD_SSL,

    PROP_REGISTER,

    PROP_LOW_BANDWIDTH,

    PROP_STREAM_SERVER,

    PROP_USERNAME,

    PROP_PASSWORD,

    PROP_RESOURCE,

    PROP_PRIORITY,

    PROP_HTTPS_PROXY_SERVER,

    PROP_HTTPS_PROXY_PORT,

    PROP_FALLBACK_CONFERENCE_SERVER,

    PROP_STUN_SERVER,

    PROP_STUN_PORT,

    PROP_STUN_RELAY_MAGIC_COOKIE,

    PROP_STUN_RELAY_SERVER,

    PROP_STUN_RELAY_UDP_PORT,

    PROP_STUN_RELAY_TCP_PORT,

    PROP_STUN_RELAY_SSLTCP_PORT,

    PROP_STUN_RELAY_USERNAME,

    PROP_STUN_RELAY_PASSWORD,

    PROP_IGNORE_SSL_ERRORS,

    PROP_ALIAS,

    LAST_PROPERTY

};

/* TP properties */

enum

{

  CONN_PROP_STUN_SERVER = 0,

  CONN_PROP_STUN_PORT,

  CONN_PROP_STUN_RELAY_MAGIC_COOKIE,

  CONN_PROP_STUN_RELAY_SERVER,

  CONN_PROP_STUN_RELAY_UDP_PORT,

  CONN_PROP_STUN_RELAY_TCP_PORT,

  CONN_PROP_STUN_RELAY_SSLTCP_PORT,

  CONN_PROP_STUN_RELAY_USERNAME,

  CONN_PROP_STUN_RELAY_PASSWORD,

  NUM_CONN_PROPS,

  INVALID_CONN_PROP,

};

const GabblePropertySignature connection_property_signatures[NUM_CONN_PROPS] = {

      { "stun-server",                  G_TYPE_STRING },

      { "stun-port",                    G_TYPE_UINT   },

      { "stun-relay-magic-cookie",      G_TYPE_STRING },

      { "stun-relay-server",            G_TYPE_STRING },

      { "stun-relay-udp-port",          G_TYPE_UINT   },

      { "stun-relay-tcp-port",          G_TYPE_UINT   },

      { "stun-relay-ssltcp-port",       G_TYPE_UINT   },

      { "stun-relay-username",          G_TYPE_STRING },

      { "stun-relay-password",          G_TYPE_STRING },

};

/* private structure */

typedef struct _GabbleConnectionPrivate GabbleConnectionPrivate;

struct _GabbleConnectionPrivate

{

  LmMessageHandler *iq_jingle_info_cb;

  LmMessageHandler *iq_search_keys_cb;

  LmMessageHandler *iq_disco_cb;

  LmMessageHandler *iq_unknown_cb;

  LmMessageHandler *stream_error_cb;

  /* telepathy properties */

  gchar *protocol;

  /* connection properties */

  gchar *connect_server;

  guint port;

  gboolean old_ssl;

  gboolean ignore_ssl_errors;

  TpConnectionStatusReason ssl_error;

  gboolean do_register;

  gboolean low_bandwidth;

  gchar *https_proxy_server;

  guint https_proxy_port;

  gchar *fallback_conference_server;

  /* authentication properties */

  gchar *stream_server;

  gchar *username;

  gchar *password;

  gchar *resource;

  gint8 priority;

  gchar *alias;

  /* reference to conference server name */

  const gchar *conference_server;

  /* channel factories */

  GPtrArray *channel_factories;

  GPtrArray *channel_requests;

  gboolean suppress_next_handler;

  /* serial number of current advertised caps */

  guint caps_serial;

  /* gobject housekeeping */

  gboolean dispose_has_run;

};

#define GABBLE_CONNECTION_GET_PRIVATE(obj) \

    ((GabbleConnectionPrivate *)obj->priv)

typedef struct _ChannelRequest ChannelRequest;

struct _ChannelRequest

{

  DBusGMethodInvocation *context;

  gchar *channel_type;

  guint handle_type;

  guint handle;

  gboolean suppress_handler;

};

static void connection_new_channel_cb (TpChannelFactoryIface *, GObject *, gpointer);

static void connection_channel_error_cb (TpChannelFactoryIface *, GObject *, GError *, gpointer);

static void connection_nickname_update_cb (GObject *, GabbleHandle, gpointer);

static void connection_presence_update_cb (GabblePresenceCache *, GabbleHandle, gpointer);

static void connection_capabilities_update_cb (GabblePresenceCache *, GabbleHandle, GabblePresenceCapabilities, GabblePresenceCapabilities, gpointer);

static void

gabble_connection_init (GabbleConnection *self)

{

  GabbleConnectionPrivate *priv = G_TYPE_INSTANCE_GET_PRIVATE (self,

      GABBLE_TYPE_CONNECTION, GabbleConnectionPrivate);

  guint i;

  GValue val = { 0, };

  self->priv = priv;

  self->lmconn = lm_connection_new (NULL);

  self->status = TP_CONN_STATUS_NEW;

  self->handles = gabble_handle_repo_new ();

  self->disco = gabble_disco_new (self);

  self->vcard_manager = gabble_vcard_manager_new (self);

  self->search_instr = NULL;

  self->search_key_names = NULL;

  self->search_reported_fields = NULL;

  self->search_form = FALSE;

  self->search_service_jid = NULL;

  self->self_avatar_sha1 = NULL;

  self->self_handle = 0;

  g_signal_connect (self->vcard_manager, "nickname-update", G_CALLBACK

      (connection_nickname_update_cb), self);

  self->presence_cache = gabble_presence_cache_new (self);

  g_signal_connect (self->presence_cache, "nickname-update", G_CALLBACK

      (connection_nickname_update_cb), self);

  g_signal_connect (self->presence_cache, "presence-update", G_CALLBACK

      (connection_presence_update_cb), self);

  g_signal_connect (self->presence_cache, "capabilities-update", G_CALLBACK

      (connection_capabilities_update_cb), self);

  capabilities_fill_cache (self->presence_cache);

  self->roster = gabble_roster_new (self);

  g_signal_connect (self->roster, "nickname-update", G_CALLBACK

      (connection_nickname_update_cb), self);

  priv->channel_factories = g_ptr_array_sized_new (1);

  g_ptr_array_add (priv->channel_factories, self->roster);

  g_ptr_array_add (priv->channel_factories,

                   g_object_new (GABBLE_TYPE_MUC_FACTORY,

                                 "connection", self,

                                 NULL));

  g_ptr_array_add (priv->channel_factories,

                   g_object_new (GABBLE_TYPE_MEDIA_FACTORY,

                                 "connection", self,

                                 NULL));

  g_ptr_array_add (priv->channel_factories,

                   g_object_new (GABBLE_TYPE_IM_FACTORY,

                                 "connection", self,

                                 NULL));

  //add for search here	

  g_ptr_array_add (priv->channel_factories,

                    g_object_new (GABBLE_TYPE_SEARCH_FACTORY,

                                 "connection", self,

                                 NULL));                               

  for (i = 0; i < priv->channel_factories->len; i++)

    {

      GObject *factory = g_ptr_array_index (priv->channel_factories, i);

      g_signal_connect (factory, "new-channel", G_CALLBACK

          (connection_new_channel_cb), self);

      g_signal_connect (factory, "channel-error", G_CALLBACK

          (connection_channel_error_cb), self);

    }

  priv->channel_requests = g_ptr_array_new ();

  /* Set default parameters for optional parameters */

  priv->resource = g_strdup (GABBLE_PARAMS_DEFAULT_RESOURCE);

  priv->port = GABBLE_PARAMS_DEFAULT_PORT;

  priv->https_proxy_port = GABBLE_PARAMS_DEFAULT_HTTPS_PROXY_PORT;

  /* initialize properties mixin */

  gabble_properties_mixin_init (G_OBJECT (self), G_STRUCT_OFFSET (

        GabbleConnection, properties));

  g_value_init (&val, G_TYPE_UINT);

  g_value_set_uint (&val, GABBLE_PARAMS_DEFAULT_STUN_PORT);

  gabble_properties_mixin_change_value (G_OBJECT (self), CONN_PROP_STUN_PORT,

                                        &val, NULL);

  gabble_properties_mixin_change_flags (G_OBJECT (self), CONN_PROP_STUN_PORT,

                                        TP_PROPERTY_FLAG_READ, 0, NULL);

  g_value_unset (&val);

  priv->caps_serial = 1;

}

static void

gabble_connection_get_property (GObject    *object,

                                guint       property_id,

                                GValue     *value,

                                GParamSpec *pspec)

{

  GabbleConnection *self = (GabbleConnection *) object;

  GabbleConnectionPrivate *priv = GABBLE_CONNECTION_GET_PRIVATE (self);

  const gchar *param_name;

  guint tp_property_id;

  switch (property_id) {

    case PROP_PROTOCOL:

      g_value_set_string (value, priv->protocol);

      break;

    case PROP_CONNECT_SERVER:

      g_value_set_string (value, priv->connect_server);

      break;

    case PROP_STREAM_SERVER:

      g_value_set_string (value, priv->stream_server);

      break;

    case PROP_PORT:

      g_value_set_uint (value, priv->port);

      break;

    case PROP_OLD_SSL:

      g_value_set_boolean (value, priv->old_ssl);

      break;

    case PROP_REGISTER:

      g_value_set_boolean (value, priv->do_register);

      break;

    case PROP_LOW_BANDWIDTH:

      g_value_set_boolean (value, priv->low_bandwidth);

      break;

    case PROP_USERNAME:

      g_value_set_string (value, priv->username);

      break;

    case PROP_PASSWORD:

      g_value_set_string (value, priv->password);

      break;

    case PROP_RESOURCE:

      g_value_set_string (value, priv->resource);

      break;

    case PROP_PRIORITY:

      g_value_set_int (value, priv->priority);

      break;

    case PROP_HTTPS_PROXY_SERVER:

      g_value_set_string (value, priv->https_proxy_server);

      break;

    case PROP_HTTPS_PROXY_PORT:

      g_value_set_uint (value, priv->https_proxy_port);

      break;

    case PROP_FALLBACK_CONFERENCE_SERVER:

      g_value_set_string (value, priv->fallback_conference_server);

      break;

    case PROP_IGNORE_SSL_ERRORS:

      g_value_set_boolean (value, priv->ignore_ssl_errors);

      break;

    case PROP_ALIAS:

      g_value_set_string (value, priv->alias);

      break;

    default:

      param_name = g_param_spec_get_name (pspec);

      if (gabble_properties_mixin_has_property (object, param_name,

            &tp_property_id))

        {

          GValue *tp_property_value =

            self->properties.properties[tp_property_id].value;

          if (tp_property_value)

            {

              g_value_copy (tp_property_value, value);

              return;

            }

        }

      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);

      break;

  }

}

static void

gabble_connection_set_property (GObject      *object,

                                guint         property_id,

                                const GValue *value,

                                GParamSpec   *pspec)

{

  GabbleConnection *self = (GabbleConnection *) object;

  GabbleConnectionPrivate *priv = GABBLE_CONNECTION_GET_PRIVATE (self);

  const gchar *param_name;

  guint tp_property_id;

  switch (property_id) {