comparison libpurple/protocols/simple/simple.c @ 32819:2c6510167895 default tip

propagate from branch 'im.pidgin.pidgin.2.x.y' (head 3315c5dfbd0ad16511bdcf865e5b07c02d07df24) to branch 'im.pidgin.pidgin' (head cbd1eda6bcbf0565ae7766396bb8f6f419cb6a9a)

32818:01ff09d4a463

static const char *simple_list_icon(PurpleAccount *a, PurpleBuddy *b) {
	return "simple";
}

static void simple_keep_alive(PurpleConnection *gc) {
	struct simple_account_data *sip = gc->proto_data;
	if(sip->udp) { /* in case of UDP send a packet only with a 0 byte to
			 remain in the NAT table */
		gchar buf[2] = {0, 0};
		purple_debug_info("simple", "sending keep alive\n");
		sendto(sip->fd, buf, 1, 0, (struct sockaddr*)&sip->serveraddr, sizeof(struct sockaddr_in));

		tmp = tmp->next;
	}
}

static void simple_set_status(PurpleAccount *account, PurpleStatus *status) {
	PurpleStatusPrimitive primitive = purple_status_type_get_primitive(purple_status_get_type(status));
	struct simple_account_data *sip = NULL;

	if (!purple_status_is_active(status))
		return;

	if (account->gc)
		sip = account->gc->proto_data;

	if (sip)
	{
		g_free(sip->status);
		if (primitive == PURPLE_STATUS_AVAILABLE)

		connection_remove(sip, ret->fd);
		entry = sip->openconns;
	}
}

static void simple_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
{
	struct simple_account_data *sip = (struct simple_account_data *)gc->proto_data;
	struct simple_buddy *b;
	const char *name = purple_buddy_get_name(buddy);
	if(strncmp(name, "sip:", 4)) {
		gchar *buf = g_strdup_printf("sip:%s", name);
		purple_blist_rename_buddy(buddy, buf);

	account = purple_connection_get_account(gc);
	buddies = purple_find_buddies(account, NULL);
	while (buddies) {
		PurpleBuddy *buddy = buddies->data;
		simple_add_buddy(gc, buddy, purple_buddy_get_group(buddy));

		buddies = g_slist_delete_link(buddies, buddies);
	}
}

static void simple_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
{
	const char *name = purple_buddy_get_name(buddy);
	struct simple_account_data *sip = (struct simple_account_data *)gc->proto_data;
	struct simple_buddy *b = g_hash_table_lookup(sip->buddies, name);
	g_hash_table_remove(sip->buddies, name);
	g_free(b->name);
	g_free(b);
}

}

static void simple_canwrite_cb(gpointer data, gint source, PurpleInputCondition cond) {
	PurpleConnection *gc = data;
	struct simple_account_data *sip = gc->proto_data;
	gsize max_write;
	gssize written;

	max_write = purple_circ_buffer_get_max_read(sip->txbuf);

		written = 0;
	else if (written <= 0) {
		/*TODO: do we really want to disconnect on a failure to write?*/
		gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
				g_strerror(errno));
		purple_connection_error_reason(gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
		g_free(tmp);
		return;
	}

	struct sip_connection *conn;

	if(source < 0) {
		gchar *tmp = g_strdup_printf(_("Unable to connect: %s"),
				error_message);
		purple_connection_error_reason(gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
		g_free(tmp);
		return;
	}

	sip = gc->proto_data;
	sip->fd = source;
	sip->connecting = FALSE;

	simple_canwrite_cb(gc, sip->fd, PURPLE_INPUT_WRITE);

	conn->inputhandler = purple_input_add(sip->fd, PURPLE_INPUT_READ, simple_input_cb, gc);
}


static void sendlater(PurpleConnection *gc, const char *buf) {
	struct simple_account_data *sip = gc->proto_data;

	if(!sip->connecting) {
		purple_debug_info("simple", "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, _("Unable to connect"));
		}
		sip->connecting = TRUE;
	}

	if(purple_circ_buffer_get_max_read(sip->txbuf) > 0)

	purple_circ_buffer_append(sip->txbuf, buf, strlen(buf));
}

static void sendout_pkt(PurpleConnection *gc, const char *buf) {
	struct simple_account_data *sip = gc->proto_data;
	time_t currtime = time(NULL);
	int writelen = strlen(buf);

	purple_debug(PURPLE_DEBUG_MISC, "simple", "\n\nsending - %s\n######\n%s\n######\n\n", ctime(&currtime), buf);
	if(sip->udp) {

}

static void send_sip_request(PurpleConnection *gc, const gchar *method,
		const gchar *url, const gchar *to, const gchar *addheaders,
		const gchar *body, struct sip_dialog *dialog, TransCallback tc) {
	struct simple_account_data *sip = gc->proto_data;
	char *callid = dialog ? g_strdup(dialog->callid) : gencallid();
	char *auth = NULL;
	const char *addh = "";
	gchar *branch = genbranch();
	gchar *tag = NULL;

	g_free(hdr);
	g_free(fullto);
}

static int simple_im_send(PurpleConnection *gc, const char *who, const char *what, PurpleMessageFlags flags) {
	struct simple_account_data *sip = gc->proto_data;
	char *to = g_strdup(who);
	char *text = purple_unescape_html(what);
	simple_send_message(sip, to, text, NULL);
	g_free(to);
	g_free(text);

			break;
		case 401:
			if(sip->registerstatus != SIMPLE_REGISTER_RETRY) {
				purple_debug_info("simple", "REGISTER retries %d\n", sip->registrar.retries);
				if(sip->registrar.retries > SIMPLE_REGISTER_RETRY_MAX) {
					if (!purple_account_get_remember_password(sip->gc->account))
						purple_account_set_password(sip->gc->account, NULL);
					purple_connection_error_reason(sip->gc,
						PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
						_("Incorrect password"));
					return TRUE;
				}
				tmp = sipmsg_find_header(msg, "WWW-Authenticate");

			break;
		default:
			if (sip->registerstatus != SIMPLE_REGISTER_RETRY) {
				purple_debug_info("simple", "Unrecognized return code for REGISTER.\n");
				if (sip->registrar.retries > SIMPLE_REGISTER_RETRY_MAX) {
					purple_connection_error_reason(sip->gc,
						PURPLE_CONNECTION_ERROR_OTHER_ERROR,
						_("Unknown server response"));
					return TRUE;
				}
				sip->registerstatus = SIMPLE_REGISTER_RETRY;

	send_sip_response(sip->gc, msg, 200, "OK", NULL);
}

static unsigned int simple_typing(PurpleConnection *gc, const char *name, PurpleTypingState state) {
	struct simple_account_data *sip = gc->proto_data;

	gchar *xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
			"<isComposing xmlns=\"urn:ietf:params:xml:ns:im-iscomposing\"\n"
			"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
			"xsi:schemaLocation=\"urn:ietf:params:xml:ns:im-composing iscomposing.xsd\">\n"

	}
}

static void simple_udp_process(gpointer data, gint source, PurpleInputCondition con) {
	PurpleConnection *gc = data;
	struct simple_account_data *sip = gc->proto_data;
	struct sipmsg *msg;
	int len;
	time_t currtime = time(NULL);

	static char buffer[65536];

}

static void simple_input_cb(gpointer data, gint source, PurpleInputCondition cond)
{
	PurpleConnection *gc = data;
	struct simple_account_data *sip = gc->proto_data;
	int len;
	struct sip_connection *conn = connection_find(sip, source);
	if(!conn) {
		purple_debug_error("simple", "Connection not found!\n");
		return;

		purple_debug_info("simple", "simple_input_cb: read error\n");
		connection_remove(sip, source);
		if(sip->fd == source) sip->fd = -1;
		return;
	}
	gc->last_received = time(NULL);
	conn->inbufused += len;
	conn->inbuf[conn->inbufused] = '\0';

	process_input(sip, conn);
}

/* Callback for new connections on incoming TCP port */
static void simple_newconn_cb(gpointer data, gint source, PurpleInputCondition cond) {
	PurpleConnection *gc = data;
	struct simple_account_data *sip = gc->proto_data;
	struct sip_connection *conn;
	int newfd, flags;

	newfd = accept(source, NULL, NULL);

	struct sip_connection *conn;

	if(source < 0) {
		gchar *tmp = g_strdup_printf(_("Unable to connect: %s"),
				error_message);
		purple_connection_error_reason(gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
		g_free(tmp);
		return;
	}

	sip = gc->proto_data;
	sip->fd = source;

	conn = connection_create(sip, source);

	sip->registertimeout = purple_timeout_add((rand()%100)+10*1000, (GSourceFunc)subscribe_timeout, sip);

	struct simple_account_data *sip = (struct simple_account_data*) data;

	sip->listen_data = NULL;

	if(listenfd == -1) {
		purple_connection_error_reason(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to create listen socket"));
		return;
	}

	int addr_size;

	sip->query_data = NULL;

	if (!hosts || !hosts->data) {
		purple_connection_error_reason(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to resolve hostname"));
		return;
	}

		g_free(hosts->data);
		hosts = g_slist_remove(hosts, hosts->data);
	}

	/* create socket for incoming connections */
	sip->listen_data = purple_network_listen_range(5060, 5160, SOCK_DGRAM,
				simple_udp_host_resolved_listen_cb, sip);
	if (sip->listen_data == NULL) {
		purple_connection_error_reason(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to create listen socket"));
		return;
	}
}

	sip->listen_data = NULL;

	sip->listenfd = listenfd;
	if(sip->listenfd == -1) {
		purple_connection_error_reason(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to create listen socket"));
		return;
	}

	purple_debug_info("simple", "connecting to %s port %d\n",
			sip->realhostname, sip->realport);
	/* open tcp connection to the server */
	if (purple_proxy_connect(sip->gc, sip->account, sip->realhostname,
			sip->realport, login_cb, sip->gc) == NULL) {
		purple_connection_error_reason(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to connect"));
	}
}

	if(!sip->realport) sip->realport = 5060;

	/* TCP case */
	if(!sip->udp) {
		/* create socket for incoming connections */
		sip->listen_data = purple_network_listen_range(5060, 5160, SOCK_STREAM,
					simple_tcp_connect_listen_cb, sip);
		if (sip->listen_data == NULL) {
			purple_connection_error_reason(sip->gc,
				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				_("Unable to create listen socket"));
			return;
		}
	} else { /* UDP */
		purple_debug_info("simple", "using udp with server %s and port %d\n", hostname, port);

		sip->query_data = purple_dnsquery_a_account(sip->account, hostname,
			port, simple_udp_host_resolved, sip);
		if (sip->query_data == NULL) {
			purple_connection_error_reason(sip->gc,
				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				_("Unable to resolve hostname"));
		}
	}
}

	const char *username = purple_account_get_username(account);
	gc = purple_account_get_connection(account);

	if (strpbrk(username, " \t\v\r\n") != NULL) {
		purple_connection_error_reason(gc,
			PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
			_("SIP usernames may not contain whitespaces or @ symbols"));
		return;
	}

	gc->proto_data = sip = g_new0(struct simple_account_data, 1);
	sip->gc = gc;
	sip->fd = -1;
	sip->listenfd = -1;
	sip->account = account;
	sip->registerexpire = 900;

	if(!sip->udp)
		sip->txbuf = purple_circ_buffer_new(0);

	userserver = g_strsplit(username, "@", 2);
	if (userserver[1] == NULL || userserver[1][0] == '\0') {
		purple_connection_error_reason(gc,
			PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
			_("SIP connect server not specified"));
		return;
	}

		hosttoconnect = sip->servername;
	} else {
		hosttoconnect = purple_account_get_string(account, "proxy", sip->servername);
	}

	sip->srv_query_data = purple_srv_resolve_account(account, "sip",
			sip->udp ? "udp" : "tcp", hosttoconnect, srvresolved, sip);
}

static void simple_close(PurpleConnection *gc)
{
	struct simple_account_data *sip = gc->proto_data;

	if (!sip)
		return;

	/* unregister */

		purple_timeout_remove(sip->registertimeout);
	if (sip->query_data != NULL)
		purple_dnsquery_destroy(sip->query_data);

	if (sip->srv_query_data != NULL)
		purple_srv_cancel(sip->srv_query_data);

	if (sip->listen_data != NULL)
		purple_network_listen_cancel(sip->listen_data);

	if (sip->fd >= 0)

	if (sip->txbuf)
		purple_circ_buffer_destroy(sip->txbuf);
	g_free(sip->realhostname);

	g_free(sip);
	gc->proto_data = NULL;
}

static PurplePluginProtocolInfo prpl_info =
{
	0,
	NULL,					/* user_splits */
	NULL,					/* protocol_options */
	NO_BUDDY_ICONS,			/* icon_spec */
	simple_list_icon,		/* list_icon */

	NULL,					/* chat_whisper */
	NULL,					/* chat_send */
	simple_keep_alive,		/* keepalive */
	NULL,					/* register_user */
	NULL,					/* get_cb_info */
	NULL,					/* get_cb_away */
	NULL,					/* alias_buddy */
	NULL,					/* group_buddy */
	NULL,					/* rename_group */
	NULL,					/* buddy_free */
	NULL,					/* convo_closed */

	simple_send_raw,		/* send_raw */
	NULL,					/* roomlist_room_serialize */
	NULL,					/* unregister_user */
	NULL,					/* send_attention */
	NULL,					/* get_attention_types */
	sizeof(PurplePluginProtocolInfo),       /* struct_size */
	NULL,					/* get_account_text_table */
	NULL,					/* initiate_media */
	NULL,					/* get_media_caps */
	NULL,					/* get_moods */
	NULL,					/* set_public_alias */
	NULL,					/* get_public_alias */
	NULL,					/* add_buddy_with_invite */
	NULL					/* add_buddies_with_invite */
};


static PurplePluginInfo info =
{

32819:2c6510167895

static const char *simple_list_icon(PurpleAccount *a, PurpleBuddy *b) {
	return "simple";
}

static void simple_keep_alive(PurpleConnection *gc) {
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	if(sip->udp) { /* in case of UDP send a packet only with a 0 byte to
			 remain in the NAT table */
		gchar buf[2] = {0, 0};
		purple_debug_info("simple", "sending keep alive\n");
		sendto(sip->fd, buf, 1, 0, (struct sockaddr*)&sip->serveraddr, sizeof(struct sockaddr_in));

		tmp = tmp->next;
	}
}

static void simple_set_status(PurpleAccount *account, PurpleStatus *status) {
	PurpleConnection *gc = purple_account_get_connection(account);
	PurpleStatusPrimitive primitive = purple_status_type_get_primitive(purple_status_get_type(status));
	struct simple_account_data *sip = NULL;

	if (!purple_status_is_active(status))
		return;

	if (gc)
		sip = purple_connection_get_protocol_data(gc);

	if (sip)
	{
		g_free(sip->status);
		if (primitive == PURPLE_STATUS_AVAILABLE)

		connection_remove(sip, ret->fd);
		entry = sip->openconns;
	}
}

static void simple_add_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group, const char *message)
{
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	struct simple_buddy *b;
	const char *name = purple_buddy_get_name(buddy);
	if(strncmp(name, "sip:", 4)) {
		gchar *buf = g_strdup_printf("sip:%s", name);
		purple_blist_rename_buddy(buddy, buf);

	account = purple_connection_get_account(gc);
	buddies = purple_find_buddies(account, NULL);
	while (buddies) {
		PurpleBuddy *buddy = buddies->data;
		simple_add_buddy(gc, buddy, purple_buddy_get_group(buddy), NULL);

		buddies = g_slist_delete_link(buddies, buddies);
	}
}

static void simple_remove_buddy(PurpleConnection *gc, PurpleBuddy *buddy, PurpleGroup *group)
{
	const char *name = purple_buddy_get_name(buddy);
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	struct simple_buddy *b = g_hash_table_lookup(sip->buddies, name);
	g_hash_table_remove(sip->buddies, name);
	g_free(b->name);
	g_free(b);
}

}

static void simple_canwrite_cb(gpointer data, gint source, PurpleInputCondition cond) {
	PurpleConnection *gc = data;
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	gsize max_write;
	gssize written;

	max_write = purple_circ_buffer_get_max_read(sip->txbuf);

		written = 0;
	else if (written <= 0) {
		/*TODO: do we really want to disconnect on a failure to write?*/
		gchar *tmp = g_strdup_printf(_("Lost connection with server: %s"),
				g_strerror(errno));
		purple_connection_error(gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
		g_free(tmp);
		return;
	}

	struct sip_connection *conn;

	if(source < 0) {
		gchar *tmp = g_strdup_printf(_("Unable to connect: %s"),
				error_message);
		purple_connection_error(gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
		g_free(tmp);
		return;
	}

	sip = purple_connection_get_protocol_data(gc);
	sip->fd = source;
	sip->connecting = FALSE;

	simple_canwrite_cb(gc, sip->fd, PURPLE_INPUT_WRITE);

	conn->inputhandler = purple_input_add(sip->fd, PURPLE_INPUT_READ, simple_input_cb, gc);
}


static void sendlater(PurpleConnection *gc, const char *buf) {
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);

	if(!sip->connecting) {
		purple_debug_info("simple", "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(gc, PURPLE_CONNECTION_ERROR_NETWORK_ERROR, _("Unable to connect"));
		}
		sip->connecting = TRUE;
	}

	if(purple_circ_buffer_get_max_read(sip->txbuf) > 0)

	purple_circ_buffer_append(sip->txbuf, buf, strlen(buf));
}

static void sendout_pkt(PurpleConnection *gc, const char *buf) {
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	time_t currtime = time(NULL);
	int writelen = strlen(buf);

	purple_debug(PURPLE_DEBUG_MISC, "simple", "\n\nsending - %s\n######\n%s\n######\n\n", ctime(&currtime), buf);
	if(sip->udp) {

}

static void send_sip_request(PurpleConnection *gc, const gchar *method,
		const gchar *url, const gchar *to, const gchar *addheaders,
		const gchar *body, struct sip_dialog *dialog, TransCallback tc) {
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	char *callid = dialog ? g_strdup(dialog->callid) : gencallid();
	char *auth = NULL;
	const char *addh = "";
	gchar *branch = genbranch();
	gchar *tag = NULL;

	g_free(hdr);
	g_free(fullto);
}

static int simple_im_send(PurpleConnection *gc, const char *who, const char *what, PurpleMessageFlags flags) {
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	char *to = g_strdup(who);
	char *text = purple_unescape_html(what);
	simple_send_message(sip, to, text, NULL);
	g_free(to);
	g_free(text);

			break;
		case 401:
			if(sip->registerstatus != SIMPLE_REGISTER_RETRY) {
				purple_debug_info("simple", "REGISTER retries %d\n", sip->registrar.retries);
				if(sip->registrar.retries > SIMPLE_REGISTER_RETRY_MAX) {
					if (!purple_account_get_remember_password(purple_connection_get_account(sip->gc)))
						purple_account_set_password(purple_connection_get_account(sip->gc), NULL);
					purple_connection_error(sip->gc,
						PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED,
						_("Incorrect password"));
					return TRUE;
				}
				tmp = sipmsg_find_header(msg, "WWW-Authenticate");

			break;
		default:
			if (sip->registerstatus != SIMPLE_REGISTER_RETRY) {
				purple_debug_info("simple", "Unrecognized return code for REGISTER.\n");
				if (sip->registrar.retries > SIMPLE_REGISTER_RETRY_MAX) {
					purple_connection_error(sip->gc,
						PURPLE_CONNECTION_ERROR_OTHER_ERROR,
						_("Unknown server response"));
					return TRUE;
				}
				sip->registerstatus = SIMPLE_REGISTER_RETRY;

	send_sip_response(sip->gc, msg, 200, "OK", NULL);
}

static unsigned int simple_typing(PurpleConnection *gc, const char *name, PurpleTypingState state) {
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);

	gchar *xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
			"<isComposing xmlns=\"urn:ietf:params:xml:ns:im-iscomposing\"\n"
			"xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"\n"
			"xsi:schemaLocation=\"urn:ietf:params:xml:ns:im-composing iscomposing.xsd\">\n"

	}
}

static void simple_udp_process(gpointer data, gint source, PurpleInputCondition con) {
	PurpleConnection *gc = data;
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	struct sipmsg *msg;
	int len;
	time_t currtime = time(NULL);

	static char buffer[65536];

}

static void simple_input_cb(gpointer data, gint source, PurpleInputCondition cond)
{
	PurpleConnection *gc = data;
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	int len;
	struct sip_connection *conn = connection_find(sip, source);
	if(!conn) {
		purple_debug_error("simple", "Connection not found!\n");
		return;

		purple_debug_info("simple", "simple_input_cb: read error\n");
		connection_remove(sip, source);
		if(sip->fd == source) sip->fd = -1;
		return;
	}
	purple_connection_update_last_received(gc);
	conn->inbufused += len;
	conn->inbuf[conn->inbufused] = '\0';

	process_input(sip, conn);
}

/* Callback for new connections on incoming TCP port */
static void simple_newconn_cb(gpointer data, gint source, PurpleInputCondition cond) {
	PurpleConnection *gc = data;
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);
	struct sip_connection *conn;
	int newfd, flags;

	newfd = accept(source, NULL, NULL);

	struct sip_connection *conn;

	if(source < 0) {
		gchar *tmp = g_strdup_printf(_("Unable to connect: %s"),
				error_message);
		purple_connection_error(gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR, tmp);
		g_free(tmp);
		return;
	}

	sip = purple_connection_get_protocol_data(gc);
	sip->fd = source;

	conn = connection_create(sip, source);

	sip->registertimeout = purple_timeout_add((rand()%100)+10*1000, (GSourceFunc)subscribe_timeout, sip);

	struct simple_account_data *sip = (struct simple_account_data*) data;

	sip->listen_data = NULL;

	if(listenfd == -1) {
		purple_connection_error(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to create listen socket"));
		return;
	}

	int addr_size;

	sip->query_data = NULL;

	if (!hosts || !hosts->data) {
		purple_connection_error(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to resolve hostname"));
		return;
	}

		g_free(hosts->data);
		hosts = g_slist_remove(hosts, hosts->data);
	}

	/* create socket for incoming connections */
	sip->listen_data = purple_network_listen_range(5060, 5160, AF_UNSPEC, SOCK_DGRAM, TRUE,
				simple_udp_host_resolved_listen_cb, sip);
	if (sip->listen_data == NULL) {
		purple_connection_error(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to create listen socket"));
		return;
	}
}

	sip->listen_data = NULL;

	sip->listenfd = listenfd;
	if(sip->listenfd == -1) {
		purple_connection_error(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to create listen socket"));
		return;
	}

	purple_debug_info("simple", "connecting to %s port %d\n",
			sip->realhostname, sip->realport);
	/* open tcp connection to the server */
	if (purple_proxy_connect(sip->gc, sip->account, sip->realhostname,
			sip->realport, login_cb, sip->gc) == NULL) {
		purple_connection_error(sip->gc,
			PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
			_("Unable to connect"));
	}
}

	if(!sip->realport) sip->realport = 5060;

	/* TCP case */
	if(!sip->udp) {
		/* create socket for incoming connections */
		sip->listen_data = purple_network_listen_range(5060, 5160, AF_UNSPEC, SOCK_STREAM, TRUE,
					simple_tcp_connect_listen_cb, sip);
		if (sip->listen_data == NULL) {
			purple_connection_error(sip->gc,
				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				_("Unable to create listen socket"));
			return;
		}
	} else { /* UDP */
		purple_debug_info("simple", "using udp with server %s and port %d\n", hostname, port);

		sip->query_data = purple_dnsquery_a(sip->account, hostname,
			port, simple_udp_host_resolved, sip);
		if (sip->query_data == NULL) {
			purple_connection_error(sip->gc,
				PURPLE_CONNECTION_ERROR_NETWORK_ERROR,
				_("Unable to resolve hostname"));
		}
	}
}

	const char *username = purple_account_get_username(account);
	gc = purple_account_get_connection(account);

	if (strpbrk(username, " \t\v\r\n") != NULL) {
		purple_connection_error(gc,
			PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
			_("SIP usernames may not contain whitespaces or @ symbols"));
		return;
	}

	sip = g_new0(struct simple_account_data, 1);
	purple_connection_set_protocol_data(gc, sip);
	sip->gc = gc;
	sip->fd = -1;
	sip->listenfd = -1;
	sip->account = account;
	sip->registerexpire = 900;

	if(!sip->udp)
		sip->txbuf = purple_circ_buffer_new(0);

	userserver = g_strsplit(username, "@", 2);
	if (userserver[1] == NULL || userserver[1][0] == '\0') {
		purple_connection_error(gc,
			PURPLE_CONNECTION_ERROR_INVALID_SETTINGS,
			_("SIP connect server not specified"));
		return;
	}

		hosttoconnect = sip->servername;
	} else {
		hosttoconnect = purple_account_get_string(account, "proxy", sip->servername);
	}

	sip->srv_query_data = purple_srv_resolve(account, "sip",
			sip->udp ? "udp" : "tcp", hosttoconnect, srvresolved, sip);
}

static void simple_close(PurpleConnection *gc)
{
	struct simple_account_data *sip = purple_connection_get_protocol_data(gc);

	if (!sip)
		return;

	/* unregister */

		purple_timeout_remove(sip->registertimeout);
	if (sip->query_data != NULL)
		purple_dnsquery_destroy(sip->query_data);

	if (sip->srv_query_data != NULL)
		purple_srv_txt_query_destroy(sip->srv_query_data);

	if (sip->listen_data != NULL)
		purple_network_listen_cancel(sip->listen_data);

	if (sip->fd >= 0)

	if (sip->txbuf)
		purple_circ_buffer_destroy(sip->txbuf);
	g_free(sip->realhostname);

	g_free(sip);
	purple_connection_set_protocol_data(gc, NULL);
}

static PurplePluginProtocolInfo prpl_info =
{
	sizeof(PurplePluginProtocolInfo),       /* struct_size */
	0,
	NULL,					/* user_splits */
	NULL,					/* protocol_options */
	NO_BUDDY_ICONS,			/* icon_spec */
	simple_list_icon,		/* list_icon */

	NULL,					/* chat_whisper */
	NULL,					/* chat_send */
	simple_keep_alive,		/* keepalive */
	NULL,					/* register_user */
	NULL,					/* get_cb_info */
	NULL,					/* alias_buddy */
	NULL,					/* group_buddy */
	NULL,					/* rename_group */
	NULL,					/* buddy_free */
	NULL,					/* convo_closed */

	simple_send_raw,		/* send_raw */
	NULL,					/* roomlist_room_serialize */
	NULL,					/* unregister_user */
	NULL,					/* send_attention */
	NULL,					/* get_attention_types */
	NULL,					/* get_account_text_table */
	NULL,					/* initiate_media */
	NULL,					/* get_media_caps */
	NULL,					/* get_moods */
	NULL,					/* set_public_alias */
	NULL					/* get_public_alias */
};


static PurplePluginInfo info =
{