/* define a handler for connection events */
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
if (status == XMPP_CONN_CONNECT) {
xmpp_stanza_t* pres;
fprintf(stderr, "DEBUG: connected\n");
xmpp_handler_add(conn, version_handler, "jabber:iq:version", "iq", NULL, ctx);
xmpp_handler_add(conn, message_handler, NULL, "message", NULL, ctx);
xmpp_handler_add(conn, presence_handler, NULL, "presence", NULL, ctx);
/* Send initial <presence/> so that we appear online to contacts */
pres = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pres, "presence");
xmpp_send(conn, pres);
xmpp_stanza_release(pres);
}
else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(ctx);
}
}
/**
* This connection handler is called after connection has been etablized.
* All initial messages can therefore be put here.
*/
static void sdvp_HandleConnection(xmpp_conn_t * const conn,
const xmpp_conn_event_t status, const int error,
xmpp_stream_error_t * const stream_error, void * const userdata) {
xmpp_ctx_t *ctx = (xmpp_ctx_t *) userdata;
xmpp_stanza_t* pres;
char packetId[PACKET_ID_LENGTH_INC_TERM];
if (status == XMPP_CONN_CONNECT) {
syslog(LOG_DEBUG, "Connected\n");
xmpp_handler_add(conn, HandleRpcCall, "jabber:iq:rpc", "iq", "get",
ctx);
xmpp_handler_add(conn, PresenceHandler, NULL, "presence", NULL, ctx);
xmpp_handler_add(conn, HandlePing, "urn:xmpp:ping", "iq", "get", ctx);
xmpp_id_handler_add(conn, HandlePingResult, "ping", ctx);
// Send initial <presence/> so that we appear online to contacts
// This is very important as the server don't route messages/iq's if not online!
//
pres = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pres, "presence");
_GeneratePacketId(packetId, PACKET_ID_LENGTH_INC_TERM);
xmpp_stanza_set_id(pres, packetId);
xmpp_send(conn, pres);
xmpp_stanza_release(pres);
// Send request for roaster
_SendRosterRequest(conn, ctx);
if (callbackOnConnectionChange != NULL ) {
callbackOnConnectionChange(SDVP_CONN_CONNECT);
}
} else {
syslog(LOG_WARNING, "conn_handler disconnected\n");
sdvpIsRunning = false;
xmpp_stop(ctx);
}
}
static void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void * const userdata)
{
conflate_handle_t *handle = (conflate_handle_t *)userdata;
if (status == XMPP_CONN_CONNECT) {
xmpp_stanza_t* pres = NULL, *priority = NULL, *pri_text = NULL;
CONFLATE_LOG(handle, LOG_LVL_INFO, "Connected.");
xmpp_handler_add(conn, version_handler, "jabber:iq:version", "iq", NULL, handle);
xmpp_handler_add(conn, command_handler, "http://jabber.org/protocol/commands",
"iq", NULL, handle);
xmpp_handler_add(conn, disco_items_handler,
"http://jabber.org/protocol/disco#items", "iq", NULL, handle);
xmpp_handler_add(conn, message_handler, NULL, "message", NULL, handle);
xmpp_timed_handler_add(conn, keepalive_handler, 60000, handle);
xmpp_timed_handler_add(conn, alarmqueue_handler, 10000, handle);
/* Send initial <presence/> so that we appear online to contacts */
pres = xmpp_stanza_new(handle->ctx);
assert(pres);
xmpp_stanza_set_name(pres, "presence");
priority = xmpp_stanza_new(handle->ctx);
assert(priority);
xmpp_stanza_set_name(priority, "priority");
add_and_release(pres, priority);
pri_text = xmpp_stanza_new(handle->ctx);
assert(pri_text);
xmpp_stanza_set_text(pri_text, "5");
add_and_release(priority, pri_text);
xmpp_send(conn, pres);
xmpp_stanza_release(pres);
/* Store the bound jid */
if (!conflate_save_private(handle, STORED_JID_KEY,
xmpp_conn_get_bound_jid(conn),
handle->conf->save_path)) {
CONFLATE_LOG(handle, LOG_LVL_WARN, "Failed to save the bound jid");
}
}
else {
CONFLATE_LOG(handle, LOG_LVL_INFO, "disconnected.");
xmpp_stop(handle->ctx);
}
}
static void _on_xmpp_conn(xmpp_conn_t * const conn,
const xmpp_conn_event_t event,
const int error,
xmpp_stream_error_t * const stream_error,
void * const userdata)
{
WaitForSingleObject(_mutex_4_conn, INFINITE);
conn_ua_map::iterator iter = _conn_map.find(conn);
if (iter == _conn_map.end())
{
ReleaseMutex(_mutex_4_conn);
return;
}
xmpp_ua_t *ua= iter->second;
ReleaseMutex(_mutex_4_conn);
if (event == XMPP_CONN_CONNECT)
{
xmpp_handler_add(conn, _cb_mesage, NULL, "message", NULL, NULL);
xmpp_handler_add(conn, _cb_presence, NULL, "presence", NULL, NULL);
xmpp_handler_add(conn, _cb_iq, NULL, "iq", NULL, NULL);
WaitForSingleObject(ua->mutex_4_ua, INFINITE);
xmpp_ua_conn_cb_list *current = ua->conn_head;
while (current)
{
current->cb(ua, 0, current->userdata);
current = current->next;
}
ReleaseMutex(ua->mutex_4_ua);
}
else
{
WaitForSingleObject(_mutex_4_conn, INFINITE);
_conn_map.erase(iter);
ReleaseMutex(_mutex_4_conn);
WaitForSingleObject(ua->mutex_4_ua, INFINITE);
xmpp_ua_conn_cb_list *current = ua->conn_head;
while (current)
{
current->cb(ua, -1, current->userdata);
current = current->next;
}
ua->conn = NULL;
ReleaseMutex(ua->mutex_4_ua);
}
}
/* define a handler for connection events */
void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status,
const int error, xmpp_stream_error_t * const stream_error,
void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
if (status == XMPP_CONN_CONNECT)
{
xmpp_handler_add(conn,message_handler, NULL, "message", NULL, ctx);
// fprintf(stderr, "DEBUG: connected\n");
xmpp_stanza_t* pres;
pres = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pres, "presence");
xmpp_send(conn, pres);
xmpp_stanza_release(pres);
// xmpp_disconnect(conn);
}
else {
fprintf(stderr, "DEBUG: disconnected\n");
// xmpp_stop(ctx);
}
}
void conn_handler(xmpp_conn_t *conn, xmpp_conn_event_t status,
const int error, xmpp_stream_error_t *stream_error,
void *userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
if (status == XMPP_CONN_CONNECT) {
fprintf(stderr, "DEBUG: connected\n");
// 上线
xmpp_stanza_t *pres = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pres, "presence");
xmpp_send(conn, pres);
xmpp_stanza_release(pres);
// 消息处理器
xmpp_handler_add(conn, handle_txt_msg, NULL, "message", NULL, ctx);
// 启动控制台解析器
int err = pthread_create(&console_thread, NULL, console_routine, conn);
if (err != 0) {
fprintf(stderr, "can't create console thread");
}
} else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(ctx);
}
}
void
presence_handlers_init(void)
{
xmpp_conn_t * const conn = connection_get_conn();
xmpp_ctx_t * const ctx = connection_get_ctx();
xmpp_handler_add(conn, _presence_handler, NULL, STANZA_NAME_PRESENCE, NULL, ctx);
}
void xmppchat_handler_add(xmpp_conn_t *conn, xmppchat_handler handler, void *userdata)
{
//xmppchat_userdata_t *udata;
//udata = (xmppchat_userdata_t *) malloc(sizeof(xmppchat_userdata_t));
s_chat_udata.handler = handler;
s_chat_udata.userdata = userdata;
xmpp_handler_add(conn, _chat_handler, NULL, "message", "chat", &s_chat_udata);
}
int
xmppipe_muc_init(xmppipe_state_t *state)
{
xmpp_stanza_t *iq = NULL;
xmpp_stanza_t *query = NULL;
xmpp_handler_add(state->conn, handle_presence_error,
"http://jabber.org/protocol/muc", "presence", "error", state);
xmpp_handler_add(state->conn, handle_presence,
"http://jabber.org/protocol/muc#user", "presence", NULL, state);
/* Discover the MUC service */
if (state->out == NULL) {
xmpp_handler_add(state->conn, handle_disco_items,
"http://jabber.org/protocol/disco#items", "iq", "result",
state);
xmpp_handler_add(state->conn, handle_disco_info,
"http://jabber.org/protocol/disco#info", "iq", "result",
state);
iq = xmppipe_stanza_new(state->ctx);
xmppipe_stanza_set_name(iq, "iq");
xmppipe_stanza_set_type(iq, "get");
xmppipe_stanza_set_attribute(iq, "to", state->server);
xmppipe_stanza_set_id(iq, "_xmppipe_muc_init");
query = xmppipe_stanza_new(state->ctx);
xmppipe_stanza_set_name(query, "query");
xmppipe_stanza_set_ns(query, "http://jabber.org/protocol/disco#items");
xmppipe_stanza_add_child(iq, query);
xmppipe_send(state, iq);
(void)xmpp_stanza_release(iq);
xmppipe_next_state(state, XMPPIPE_S_MUC_SERVICE_LOOKUP);
}
return 0;
}
void xmpp_ibb_register(xmpp_conn_t * const conn, xmpp_ibb_reg_funcs_t *reg)
{
static xmpp_ibb_userdata_t s_ibb_udata;
if (conn == NULL || reg == NULL) {
return;
}
srand(time(NULL)); //for generate random string
s_ibb_udata.open_cb = reg->open_cb;
s_ibb_udata.close_cb = reg->close_cb;
s_ibb_udata.recv_cb = reg->recv_cb;
s_ibb_udata.error_cb = reg->error_cb;
if (g_list != NULL) {
ilist_destroy(g_list);
}
g_list = ilist_new();
xmpp_handler_add(conn, _ibb_set_handler, XMLNS_IBB, "iq", "set", &s_ibb_udata);
xmpp_handler_add(conn, _ibb_result_handler, NULL, "iq", "result", &s_ibb_udata);
xmpp_handler_add(conn, _ibb_error_handler, NULL, "iq", "error", &s_ibb_udata);
xmpp_handler_add(conn, _ibb_pres_handler, NULL, "presence", "unavailable", &s_ibb_udata);
}
static int _SendRosterRequest(xmpp_conn_t * const conn, xmpp_ctx_t *ctx) {
xmpp_stanza_t *roaster, *roaster_qry;
char packetId[PACKET_ID_LENGTH_INC_TERM];
_GeneratePacketId(packetId, PACKET_ID_LENGTH_INC_TERM);
roaster = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(roaster, "iq");
xmpp_stanza_set_type(roaster, "get");
xmpp_stanza_set_id(roaster, packetId);
roaster_qry = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(roaster_qry, "query");
xmpp_stanza_set_ns(roaster_qry, XMPP_NS_ROSTER);
xmpp_stanza_add_child(roaster, roaster_qry);
// we can release the stanza since it belongs to sr_iq now
xmpp_stanza_release(roaster_qry);
// set up reply handler
xmpp_handler_add(conn, _HandleRosterReply, "jabber:iq:roster", NULL, NULL,
ctx);
xmpp_send(conn, roaster);
xmpp_stanza_release(roaster);
return 0;
}
int
xmppipe_stream_init(xmppipe_state_t *state)
{
xmpp_stanza_t *enable = NULL;
if (state->sm_request_interval == 0)
return 0;
/* <enable xmlns='urn:xmpp:sm:3'/> */
enable = xmppipe_stanza_new(state->ctx);
xmppipe_stanza_set_name(enable, "enable");
xmppipe_stanza_set_ns(enable, "urn:xmpp:sm:3");
xmpp_send(state->conn, enable);
(void)xmpp_stanza_release(enable);
xmpp_handler_add(state->conn, handle_sm_enabled,
"urn:xmpp:sm:3", "enabled", NULL, state);
xmpp_handler_add(state->conn, handle_sm_request,
"urn:xmpp:sm:3", "r", NULL, state);
xmpp_handler_add(state->conn, handle_sm_ack,
"urn:xmpp:sm:3", "a", NULL, state);
xmpp_handler_add(state->conn, handle_message,
NULL, "message", NULL, state);
xmpp_handler_add(state->conn, handle_version,
"jabber:iq:version", "iq", NULL, state);
xmpp_id_handler_add(state->conn, handle_ping_reply, "c2s1", state);
/* XXX multiple handlers can be called for each event
* XXX
* XXX * is the order handlers are called determinisitc?
* XXX * the NULL handler needs to installed as soon as stream management is enabled
* XXX * a handler has to exist for unsupported events
*/
xmpp_handler_add(state->conn, handle_null, NULL, NULL, NULL, state);
return 0;
}
