int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
xmpp_stanza_t *reply, *body, *text;
char *intext;
xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
if (!xmpp_stanza_get_child_by_name(stanza, "body")) return 1;
if (xmpp_stanza_get_attribute(stanza, "type") != NULL && !strcmp(xmpp_stanza_get_attribute(stanza, "type"), "error")) return 1;
intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
printf("Incoming message from %s: %s\n", xmpp_stanza_get_attribute(stanza, "from"), intext);
reply = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(reply, "message");
xmpp_stanza_set_type(reply, xmpp_stanza_get_type(stanza) ? xmpp_stanza_get_type(stanza) : "chat");
xmpp_stanza_set_attribute(reply, "to", xmpp_stanza_get_attribute(stanza, "from"));
body = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(body, "body");
char replytext[1024];
scanf("%[^\n]", replytext);
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, replytext);
xmpp_stanza_add_child(body, text);
xmpp_stanza_add_child(reply, body);
xmpp_send(conn, reply);
xmpp_stanza_release(reply);
return 1;
}
int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
xmpp_stanza_t *reply;
char *intext, *replytext;
if (!xmpp_stanza_get_child_by_name(stanza, "body"))
return 1;
if (xmpp_stanza_get_type(stanza) != NULL && !strcmp(xmpp_stanza_get_type(stanza), "error"))
return 1;
intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
printf("Incoming message from %s: %s\n", xmpp_stanza_get_from(stanza), intext);
reply = xmpp_stanza_reply(stanza);
if (xmpp_stanza_get_type(reply) == NULL)
xmpp_stanza_set_type(reply, "chat");
replytext = (char *) malloc(strlen(" to you too!") + strlen(intext) + 1);
strcpy(replytext, intext);
strcat(replytext, " to you too!");
xmpp_free(ctx, intext);
xmpp_message_set_body(reply, replytext);
xmpp_send(conn, reply);
xmpp_stanza_release(reply);
free(replytext);
return 1;
}
static int _on_room_info(xmpp_ua_t *ua, xmpp_stanza_t * const stanza, void * const userdata)
{
room_info_data *info_data = (room_info_data *)userdata;
char *type = xmpp_stanza_get_type(stanza);
if (strcmp(type, "result"))
{
info_data->cb(info_data->ctx, NULL, -2, info_data->user_data);
free(info_data);
return 1;
}
xmpp_stanza_t *stanza_query = xmpp_stanza_get_child_by_name(stanza, "query");
if (stanza_query)
{
xmpp_stanza_t *stanza_identity = xmpp_stanza_get_child_by_name(stanza_query, "identity");
if (stanza_identity)
{
char *room_desc = xmpp_stanza_get_attribute(stanza_identity, "name");
info_data->cb(info_data->ctx, room_desc, 0, info_data->user_data);
free(info_data);
return 1;
}
}
info_data->cb(info_data->ctx, NULL, -1, info_data->user_data);
free(info_data);
return 1;
}
static int zkmuc_group_msg_handler(xmpp_ua_t *ua, xmpp_stanza_t *stanza, void *userdata)
{
char *type = xmpp_stanza_get_type(stanza);
if (type && !strcmp(type, "groupchat"))
{
zkmuc_ctx_t *ctx = (zkmuc_ctx_t *)userdata;
// char *from = xmpp_stanza_get_attribute(stanza, "from");
xmpp_stanza_t *stanza_body = xmpp_stanza_get_child_by_name(stanza, "zonekey");
if (!stanza_body)
{
return 0;
}
xmpp_stanza_t *stanza_jid = xmpp_stanza_get_child_by_name(stanza_body, "jid");
char *jid_value = xmpp_stanza_get_text(stanza_jid);
char *text = xmpp_stanza_get_text(stanza_body);
if (text && ctx->room_cbs.on_broadcast_message)
{
ctx->room_cbs.on_broadcast_message(ctx, /*from*/jid_value, text, ctx->room_data);
}
xmpp_free(_xmpp_ctx, jid_value);
xmpp_free(_xmpp_ctx, text);
return 1;
}
return 0;
}
gboolean
stanza_get_delay(xmpp_stanza_t * const stanza, GTimeVal *tv_stamp)
{
// first check for XEP-0203 delayed delivery
xmpp_stanza_t *delay = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_DELAY);
if (delay != NULL) {
char *xmlns = xmpp_stanza_get_attribute(delay, STANZA_ATTR_XMLNS);
if ((xmlns != NULL) && (strcmp(xmlns, "urn:xmpp:delay") == 0)) {
char *stamp = xmpp_stanza_get_attribute(delay, STANZA_ATTR_STAMP);
if ((stamp != NULL) && (g_time_val_from_iso8601(stamp, tv_stamp))) {
return TRUE;
}
}
}
// otherwise check for XEP-0091 legacy delayed delivery
// stanp format : CCYYMMDDThh:mm:ss
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_X);
if (x != NULL) {
char *xmlns = xmpp_stanza_get_attribute(x, STANZA_ATTR_XMLNS);
if ((xmlns != NULL) && (strcmp(xmlns, "jabber:x:delay") == 0)) {
char *stamp = xmpp_stanza_get_attribute(x, STANZA_ATTR_STAMP);
if ((stamp != NULL) && (g_time_val_from_iso8601(stamp, tv_stamp))) {
return TRUE;
}
}
}
return FALSE;
}
int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
xmpp_stanza_t *reply, *body, *text;
char *intext, *replytext;
xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
if(!xmpp_stanza_get_child_by_name(stanza, "body")) return 1;
intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
printf("Incoming message from %s: %s\n", xmpp_stanza_get_attribute(stanza, "from"), intext);
reply = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(reply, "message");
xmpp_stanza_set_type(reply, xmpp_stanza_get_type(stanza)?xmpp_stanza_get_type(stanza):"chat");
xmpp_stanza_set_attribute(reply, "to", xmpp_stanza_get_attribute(stanza, "from"));
body = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(body, "body");
replytext = malloc(strlen(" to you too!") + strlen(intext) + 1);
strcpy(replytext, intext);
strcat(replytext, " to you too!");
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, replytext);
xmpp_stanza_add_child(body, text);
xmpp_stanza_add_child(reply, body);
xmpp_send(conn, reply);
xmpp_stanza_release(reply);
free(replytext);
return 1;
}
static gboolean
_handle_carbons(xmpp_stanza_t *const stanza)
{
xmpp_stanza_t *carbons = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CARBONS);
if (!carbons) {
return FALSE;
}
char *name = xmpp_stanza_get_name(carbons);
if ((g_strcmp0(name, "received") == 0) || (g_strcmp0(name, "sent")) == 0) {
xmpp_stanza_t *forwarded = xmpp_stanza_get_child_by_ns(carbons, STANZA_NS_FORWARD);
xmpp_stanza_t *message = xmpp_stanza_get_child_by_name(forwarded, STANZA_NAME_MESSAGE);
xmpp_ctx_t *ctx = connection_get_ctx();
gchar *to = xmpp_stanza_get_attribute(message, STANZA_ATTR_TO);
gchar *from = xmpp_stanza_get_attribute(message, STANZA_ATTR_FROM);
// happens when receive a carbon of a self sent message
if (!to) to = from;
Jid *jid_from = jid_create(from);
Jid *jid_to = jid_create(to);
Jid *my_jid = jid_create(jabber_get_fulljid());
// check for and deal with message
xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(message, STANZA_NAME_BODY);
if (body) {
char *message_txt = xmpp_stanza_get_text(body);
if (message_txt) {
// check for pgp encrypted message
char *enc_message = NULL;
xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(message, STANZA_NS_ENCRYPTED);
if (x) {
enc_message = xmpp_stanza_get_text(x);
}
// if we are the recipient, treat as standard incoming message
if(g_strcmp0(my_jid->barejid, jid_to->barejid) == 0){
sv_ev_incoming_carbon(jid_from->barejid, jid_from->resourcepart, message_txt, enc_message);
// else treat as a sent message
} else {
sv_ev_outgoing_carbon(jid_to->barejid, message_txt, enc_message);
}
xmpp_free(ctx, message_txt);
xmpp_free(ctx, enc_message);
}
}
jid_destroy(jid_from);
jid_destroy(jid_to);
jid_destroy(my_jid);
return TRUE;
}
return FALSE;
}
gboolean
stanza_contains_chat_state(xmpp_stanza_t *stanza)
{
return ((xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_ACTIVE) != NULL) ||
(xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_COMPOSING) != NULL) ||
(xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_PAUSED) != NULL) ||
(xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_GONE) != NULL) ||
(xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_INACTIVE) != NULL));
}
static xmpp_stanza_t* n_handler(const char *cmd,
xmpp_stanza_t* cmd_stanza,
xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza,
void * const userdata,
bool direct,
conflate_mgmt_cb_t cb)
{
conflate_handle_t *handle = (conflate_handle_t*) userdata;
xmpp_ctx_t *ctx = handle->ctx;
conflate_form_result result = { .conn = conn,
.ctx = ctx,
.reply = NULL,
.cmd_res = NULL,
.container = NULL };
kvpair_t *form = NULL;
assert(cb);
result.reply = create_reply(ctx, stanza);
result.cmd_res = create_cmd_response(ctx, cmd_stanza);
add_and_release(result.reply, result.cmd_res);
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(cmd_stanza, "x");
if (x) {
xmpp_stanza_t *fields = xmpp_stanza_get_child_by_name(x, "field");
if (fields) {
form = grok_form(fields);
}
}
enum conflate_mgmt_cb_result rv = cb(handle->conf->userdata, handle,
cmd, direct, form, &result);
CONFLATE_LOG(handle, LOG_LVL_DEBUG, "Result of %s: %s", cmd, cb_name(rv));
switch (rv) {
case RV_ERROR:
add_cmd_error(ctx, result.reply, "500",
"urn:ietf:params:xml:ns:xmpp-stanzas",
"internal-server-error", NULL, NULL);
break;
case RV_BADARG:
add_cmd_error(ctx, result.reply, "400",
"urn:ietf:params:xml:ns:xmpp-stanzas", "bad-request",
"http://jabber.org/protocol/commands", "bad-payload");
break;
case RV_OK:
/* Things are good, use the built form */
break;
}
free_kvpair(form);
return result.reply;
}
static int
_version_result_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
char *id = xmpp_stanza_get_id(stanza);
if (id != NULL) {
log_debug("IQ version result handler fired, id: %s.", id);
} else {
log_debug("IQ version result handler fired.");
}
const char *jid = xmpp_stanza_get_attribute(stanza, "from");
xmpp_stanza_t *query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
if (query == NULL) {
return 1;
}
char *ns = xmpp_stanza_get_ns(query);
if (g_strcmp0(ns, STANZA_NS_VERSION) != 0) {
return 1;
}
char *name_str = NULL;
char *version_str = NULL;
char *os_str = NULL;
xmpp_stanza_t *name = xmpp_stanza_get_child_by_name(query, "name");
xmpp_stanza_t *version = xmpp_stanza_get_child_by_name(query, "version");
xmpp_stanza_t *os = xmpp_stanza_get_child_by_name(query, "os");
if (name != NULL) {
name_str = xmpp_stanza_get_text(name);
}
if (version != NULL) {
version_str = xmpp_stanza_get_text(version);
}
if (os != NULL) {
os_str = xmpp_stanza_get_text(os);
}
PContact contact;
Jid *jidp = jid_create(jid);
if (muc_room_is_active(jidp->barejid)) {
contact = muc_get_participant(jidp->barejid, jidp->resourcepart);
} else {
contact = roster_get_contact(jidp->barejid);
}
Resource *resource = p_contact_get_resource(contact, jidp->resourcepart);
const char *presence = string_from_resource_presence(resource->presence);
handle_software_version_result(jid, presence, name_str, version_str, os_str);
jid_destroy(jidp);
return 1;
}
int XMPP_IBB_Data_Process(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
char* intext;
unsigned char *result;
xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;
char *szSid, szSeq;
// xmpp_ibb_session_t* ibb_ssn;
szSid = \
xmpp_stanza_get_attribute(xmpp_stanza_get_child_by_name(stanza, "data"), "sid");
szSeq = \
xmpp_stanza_get_attribute(xmpp_stanza_get_child_by_name(stanza, "data"), "seq");
intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "data"));
printf("[Sid=%s][Seq=%s][Raw Data=%s]\n", szSid, szSeq, intext);
result = base64_decode(ctx, intext, strlen(intext));
printf("Decode result=%s\n", result);
gRecv = malloc(strlen(result)+1);
strcpy(gRecv, result);
if(gStanza == NULL)
gStanza = xmpp_stanza_copy(stanza);
#if 0 //data queue function has not been verified.
ibb_ssn = XMPP_Get_IBB_Session_Handle(szSid);
if( ibb_ssn == NULL)
{
printf("Opened Session ID not found\n");
goto error;
}
xmpp_ibb_data_t* ibb_data_new = malloc(sizeof(xmpp_ibb_data_t));
ibb_data_new->seq_num = malloc(strlen(szSeq)+1);
ibb_data_new->recv_data = malloc(strlen(result)+1);
strcpy(ibb_data_new->seq_num, szSeq);
strcpy(ibb_data_new->recv_data, result);
XMPP_IBB_Add_Session_Data_Queue(ibb_ssn, ibb_data_new);
#endif
error:
xmpp_free(ctx, szSid);
xmpp_free(ctx, szSeq);
xmpp_free(ctx, intext);
xmpp_free(ctx, result);
return 1;
}
/**
* Creates the parameter structure for the Read callback
* @param[in] params This stanza is the params element in the XML-RPC format
* @return The structure or null if an error were found.
*/
static sdvp_ReadParam_t* _CreateReadParam (xmpp_stanza_t * params) {
const int expectedParams = 1;
sdvp_ReadParam_t* rv = NULL;
int i = 0;
bool elementNotFund = false;
xmpp_stanza_t *structure = NULL, *member = NULL, *value = NULL,
*type = NULL, *name = NULL;
char *text, *textname;
structure = _GetRpcStructureElementFromParams(params);
if (structure == NULL ) {
return NULL ;
}
rv = _InitiateReadParameters();
for (member = xmpp_stanza_get_children(structure);
member && !elementNotFund && (i < expectedParams); member =
xmpp_stanza_get_next(member)) {
if (xmpp_stanza_get_name(member)
&& strcmp(xmpp_stanza_get_name(member), "member") == 0) {
if (!(name = xmpp_stanza_get_child_by_name(member, "name"))) {
_FreeReadParameters(rv);
// TODO: Signal error back
return NULL ;
}
name = xmpp_stanza_get_children(name);
textname = xmpp_stanza_get_text(name);
if (strcmp(textname, "VariableAccessSpecification") == 0) {
if (!(value = xmpp_stanza_get_child_by_name(member, "value"))) {
_FreeReadParameters(rv);
// TODO: Signal error back
free(textname);
return NULL ;
}
if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {
if (xmpp_stanza_get_children(type)) {
text = xmpp_stanza_get_text(type);
rv->reference = text;
} else {
rv->reference = NULL;
}
} else {
elementNotFund = true;
}
} else {
// if (!type) {
// _FreeReadParameters(rv);
// return NULL ;
// }
}
free(textname);
}
}
return rv;
}
static int
_muc_user_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata)
{
xmpp_ctx_t *ctx = connection_get_ctx();
xmpp_stanza_t *xns_muc_user = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);
char *room = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (!room) {
log_warning("Message received with no from attribute, ignoring");
return 1;
}
// XEP-0045
xmpp_stanza_t *invite = xmpp_stanza_get_child_by_name(xns_muc_user, STANZA_NAME_INVITE);
if (!invite) {
return 1;
}
char *invitor_jid = xmpp_stanza_get_attribute(invite, STANZA_ATTR_FROM);
if (!invitor_jid) {
log_warning("Chat room invite received with no from attribute");
return 1;
}
Jid *jidp = jid_create(invitor_jid);
if (!jidp) {
return 1;
}
char *invitor = jidp->barejid;
char *reason = NULL;
xmpp_stanza_t *reason_st = xmpp_stanza_get_child_by_name(invite, STANZA_NAME_REASON);
if (reason_st) {
reason = xmpp_stanza_get_text(reason_st);
}
char *password = NULL;
xmpp_stanza_t *password_st = xmpp_stanza_get_child_by_name(xns_muc_user, STANZA_NAME_PASSWORD);
if (password_st) {
password = xmpp_stanza_get_text(password_st);
}
sv_ev_room_invite(INVITE_MEDIATED, invitor, room, reason, password);
jid_destroy(jidp);
if (reason) {
xmpp_free(ctx, reason);
}
if (password) {
xmpp_free(ctx, password);
}
return 1;
}
int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
char *intext, *decoded_intext;
if(!xmpp_stanza_get_child_by_name(stanza, "body")) return 1;
if(!strcmp(xmpp_stanza_get_attribute(stanza, "type"), "error")) return 1;
intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
decoded_intext = from_base64(intext, strlen(intext));
fwrite((const void*)decoded_intext, 1, strlen(intext), stdout);
free(decoded_intext);
return 1;
}
int
blocked_set_handler(xmpp_stanza_t *stanza)
{
xmpp_stanza_t *block = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BLOCK);
if (block) {
xmpp_stanza_t *child = xmpp_stanza_get_children(block);
while (child) {
if (g_strcmp0(xmpp_stanza_get_name(child), STANZA_NAME_ITEM) == 0) {
const char *jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
if (jid) {
blocked = g_list_append(blocked, strdup(jid));
autocomplete_add(blocked_ac, jid);
}
}
child = xmpp_stanza_get_next(child);
}
}
xmpp_stanza_t *unblock = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_UNBLOCK);
if (unblock) {
xmpp_stanza_t *child = xmpp_stanza_get_children(unblock);
if (!child) {
g_list_free_full(blocked, free);
blocked = NULL;
autocomplete_clear(blocked_ac);
} else {
while (child) {
if (g_strcmp0(xmpp_stanza_get_name(child), STANZA_NAME_ITEM) == 0) {
const char *jid = xmpp_stanza_get_attribute(child, STANZA_ATTR_JID);
if (jid) {
GList *found = g_list_find_custom(blocked, jid, (GCompareFunc)g_strcmp0);
if (found) {
blocked = g_list_remove_link(blocked, found);
g_list_free_full(found, free);
autocomplete_remove(blocked_ac, jid);
}
}
}
child = xmpp_stanza_get_next(child);
}
}
}
return 1;
}
/*
* Main callback function to dispatch XEP-0047 open/data/close stanzas
* @param conn a Strophe connection object
* @param stanza a Strophe stanza object received from sender.
* @param userdata a callback interface to pass xmpp_ctx.
*/
int XMPP_IBB_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
char* szBlock_size;
char* szSid;
printf("XMPP IBB Handler\n");
if( xmpp_stanza_get_child_by_name(stanza, "open") != NULL)
{
printf(" =====XEP0047 Open Handle\n");
szBlock_size = \
xmpp_stanza_get_attribute( xmpp_stanza_get_child_by_name(stanza, "open"), "block-size");
szSid = \
xmpp_stanza_get_attribute(xmpp_stanza_get_child_by_name(stanza, "open"), "sid");
printf("XEP0047 IQ blocksize=%s sid=%s \n",szBlock_size, szSid );
#if 0 // The is used to support multi sesssion. not verified.
xmpp_ibb_session_t* ibb_ssn_p;
ibb_ssn_p = malloc(sizeof(xmpp_ibb_session_t));
ibb_ssn_p->sid = malloc(strlen(szSid)+1);
ibb_ssn_p->szblock_size = malloc(strlen(szBlock_size)+1);
ibb_ssn_p->ibb_data_queue = NULL;
ibb_ssn_p->next = NULL;
strcpy(ibb_ssn_p->sid, szBlock_size);
strcpy(ibb_ssn_p->szblock_size, szSid);
//=================> gXMPP_IBB_handle-> next = ibb_ssn_p;
XMPP_IBB_Add_Session_Queue(ibb_ssn_p);
#endif
XMPP_IBB_Ack_Send(conn, stanza, userdata);
}
else if( xmpp_stanza_get_child_by_name(stanza, "data") != NULL)
{
XMPP_IBB_Ack_Send(conn, stanza, userdata);
printf("========XEP0047 Data process\n");
XMPP_IBB_Data_Process(conn, stanza , userdata);
}
else if( xmpp_stanza_get_child_by_name(stanza, "close") )
{
XMPP_IBB_Ack_Send(conn, stanza, userdata);
}
return 1;
}
static int
_captcha_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata)
{
xmpp_ctx_t *ctx = connection_get_ctx();
char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (!from) {
log_warning("Message received with no from attribute, ignoring");
return 1;
}
// XEP-0158
xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);
if (!body) {
return 1;
}
char *message = xmpp_stanza_get_text(body);
if (!message) {
return 1;
}
sv_ev_room_broadcast(from, message);
xmpp_free(ctx, message);
return 1;
}
static int _zkmuc_on_source_query(xmpp_ua_t *ua, xmpp_stanza_t *stanza, void *userdata)
{
query_source_data *data = (query_source_data *)userdata;
char *from = xmpp_stanza_get_attribute(stanza, "from");
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(stanza, "x");
xmpp_stanza_t *item = xmpp_stanza_get_children(x);
zkmuc_source_t *head = NULL;
zkmuc_source_t **current = &head;
while (item)
{
if (!strcmp("item", xmpp_stanza_get_name(item)))
{
*current = (zkmuc_source_t *)malloc(sizeof(zkmuc_source_t));
(*current)->cid = atoi(xmpp_stanza_get_attribute(item, "cid"));
(*current)->sid = atoi(xmpp_stanza_get_attribute(item, "sid"));
(*current)->description = strdup(xmpp_stanza_get_attribute(item, "desc"));
(*current)->mcu = strdup(xmpp_stanza_get_attribute(item, "mcu"));
current = &(*current)->next;
}
item = xmpp_stanza_get_next(item);
}
*current = NULL;
data->cb(data->ctx, from, data->userdata, head);
_zkmuc_free_all_remote_source(head);
free(data);
return 1;
}
static int
_pong_handler(xmpp_conn_t *const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
char *id = xmpp_stanza_get_id(stanza);
char *type = xmpp_stanza_get_type(stanza);
if (id != NULL && type != NULL) {
// show warning if error
if (strcmp(type, STANZA_TYPE_ERROR) == 0) {
log_warning("Server ping (id=%s) responded with error", id);
// turn off autoping if error type is 'cancel'
xmpp_stanza_t *error = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_ERROR);
if (error != NULL) {
char *errtype = xmpp_stanza_get_type(error);
if (errtype != NULL) {
if (strcmp(errtype, "cancel") == 0) {
log_warning("Server ping (id=%s) error type 'cancel', disabling autoping.", id);
handle_autoping_cancel();
xmpp_timed_handler_delete(conn, _ping_timed_handler);
}
}
}
}
}
// remove this handler
return 0;
}
static int command_handler(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_stanza_t *reply = NULL, *req = NULL;
char *cmd = NULL;
/* Figure out what the command is */
req = xmpp_stanza_get_child_by_name(stanza, "command");
assert(req);
assert(strcmp(xmpp_stanza_get_name(req), "command") == 0);
cmd = xmpp_stanza_get_attribute(req, "node");
assert(cmd);
CONFLATE_LOG(((conflate_handle_t *)userdata), LOG_LVL_INFO,
"Command: %s", cmd);
reply = command_dispatch(conn, stanza, userdata, cmd, req, true);
if (reply) {
xmpp_send(conn, reply);
xmpp_stanza_release(reply);
}
return 1;
}
int
stanza_get_idle_time(xmpp_stanza_t * const stanza)
{
xmpp_stanza_t *query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
if (query == NULL) {
return 0;
}
char *ns = xmpp_stanza_get_ns(query);
if (ns == NULL) {
return 0;
}
if (strcmp(ns, STANZA_NS_LASTACTIVITY) != 0) {
return 0;
}
char *seconds_str = xmpp_stanza_get_attribute(query, STANZA_ATTR_SECONDS);
if (seconds_str == NULL) {
return 0;
}
int result = atoi(seconds_str);
if (result < 1) {
return 0;
} else {
return result;
}
}
int handle_reply(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_stanza_t *query, *item;
char *type, *name;
type = xmpp_stanza_get_type(stanza);
if (strcmp(type, "error") == 0)
fprintf(stderr, "ERROR: query failed\n");
else {
query = xmpp_stanza_get_child_by_name(stanza, "query");
printf("Roster:\n");
for (item = xmpp_stanza_get_children(query); item;
item = xmpp_stanza_get_next(item))
if ((name = xmpp_stanza_get_attribute(item, "name")))
printf("\t %s (%s) sub=%s\n",
name,
xmpp_stanza_get_attribute(item, "jid"),
xmpp_stanza_get_attribute(item, "subscription"));
else
printf("\t %s sub=%s\n",
xmpp_stanza_get_attribute(item, "jid"),
xmpp_stanza_get_attribute(item, "subscription"));
printf("END OF LIST\n");
}
/* disconnect */
xmpp_disconnect(conn);
return 0;
}
static int
_iq_handle_discoinfo_get(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
const char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
xmpp_stanza_t *incoming_query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);
const char *node_str = xmpp_stanza_get_attribute(incoming_query, STANZA_ATTR_NODE);
if (from != NULL) {
xmpp_stanza_t *response = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(response, STANZA_NAME_IQ);
xmpp_stanza_set_id(response, xmpp_stanza_get_id(stanza));
xmpp_stanza_set_attribute(response, STANZA_ATTR_TO, from);
xmpp_stanza_set_type(response, STANZA_TYPE_RESULT);
xmpp_stanza_t *query = caps_create_query_response_stanza(ctx);
if (node_str != NULL) {
xmpp_stanza_set_attribute(query, STANZA_ATTR_NODE, node_str);
}
xmpp_stanza_add_child(response, query);
xmpp_send(conn, response);
xmpp_stanza_release(query);
xmpp_stanza_release(response);
}
return 1;
}
/** Add <body/> child element to a <message/> stanza with the given text.
*
* @param msg a <message> stanza object without <body/> child element.
*
* @return 0 on success (XMPP_EOK), and a number less than 0 on failure
* (XMPP_EMEM, XMPP_EINVOP)
*
* @ingroup Stanza
*/
int xmpp_message_set_body(xmpp_stanza_t *msg, const char * const text)
{
xmpp_ctx_t *ctx = msg->ctx;
xmpp_stanza_t *body;
xmpp_stanza_t *text_stanza;
const char *name;
int ret;
/* check that msg is a <message/> stanza and doesn't contain <body/> */
name = xmpp_stanza_get_name(msg);
body = xmpp_stanza_get_child_by_name(msg, "body");
if (!name || strcmp(name, "message") != 0 || body)
return XMPP_EINVOP;
body = xmpp_stanza_new(ctx);
text_stanza = xmpp_stanza_new(ctx);
ret = body && text_stanza ? XMPP_EOK : XMPP_EMEM;
if (ret == XMPP_EOK)
ret = xmpp_stanza_set_name(body, "body");
if (ret == XMPP_EOK)
ret = xmpp_stanza_set_text(text_stanza, text);
if (ret == XMPP_EOK)
ret = xmpp_stanza_add_child(body, text_stanza);
if (ret == XMPP_EOK)
ret = xmpp_stanza_add_child(msg, body);
if (text_stanza)
xmpp_stanza_release(text_stanza);
if (body)
xmpp_stanza_release(body);
return ret;
}
static int _handle_features(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_stanza_t *child, *mech;
char *text;
/* remove the handler that detects missing stream:features */
xmpp_timed_handler_delete(conn, _handle_missing_features);
/* check for TLS */
if (!conn->secured) {
if (!conn->tls_disabled) {
child = xmpp_stanza_get_child_by_name(stanza, "starttls");
if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0))
conn->tls_support = 1;
} else {
conn->tls_support = 0;
}
}
/* check for SASL */
child = xmpp_stanza_get_child_by_name(stanza, "mechanisms");
if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_SASL) == 0)) {
for (mech = xmpp_stanza_get_children(child); mech;
mech = xmpp_stanza_get_next(mech)) {
if (xmpp_stanza_get_name(mech) && strcmp(xmpp_stanza_get_name(mech), "mechanism") == 0) {
text = xmpp_stanza_get_text(mech);
if (strcasecmp(text, "PLAIN") == 0)
conn->sasl_support |= SASL_MASK_PLAIN;
else if (strcasecmp(text, "DIGEST-MD5") == 0)
conn->sasl_support |= SASL_MASK_DIGESTMD5;
else if (strcasecmp(text, "SCRAM-SHA-1") == 0)
conn->sasl_support |= SASL_MASK_SCRAMSHA1;
else if (strcasecmp(text, "ANONYMOUS") == 0)
conn->sasl_support |= SASL_MASK_ANONYMOUS;
xmpp_free(conn->ctx, text);
}
}
}
_auth(conn);
return 0;
}
gboolean
stanza_is_muc_self_presence(xmpp_stanza_t * const stanza,
const char * const self_jid)
{
if (stanza == NULL) {
return FALSE;
}
if (strcmp(xmpp_stanza_get_name(stanza), STANZA_NAME_PRESENCE) != 0) {
return FALSE;
}
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_X);
if (x == NULL) {
return FALSE;
}
char *ns = xmpp_stanza_get_ns(x);
if (ns == NULL) {
return FALSE;
}
if (strcmp(ns, STANZA_NS_MUC_USER) != 0) {
return FALSE;
}
xmpp_stanza_t *x_children = xmpp_stanza_get_children(x);
if (x_children == NULL) {
return FALSE;
}
while (x_children != NULL) {
if (strcmp(xmpp_stanza_get_name(x_children), STANZA_NAME_STATUS) == 0) {
char *code = xmpp_stanza_get_attribute(x_children, STANZA_ATTR_CODE);
if (strcmp(code, "110") == 0) {
return TRUE;
}
}
x_children = xmpp_stanza_get_next(x_children);
}
// for older server that don't send status 110
x_children = xmpp_stanza_get_children(x);
while (x_children != NULL) {
if (strcmp(xmpp_stanza_get_name(x_children), STANZA_NAME_ITEM) == 0) {
char *jid = xmpp_stanza_get_attribute(x_children, STANZA_ATTR_JID);
if (jid != NULL) {
if (g_str_has_prefix(jid, self_jid)) {
return TRUE;
}
}
}
x_children = xmpp_stanza_get_next(x_children);
}
return FALSE;
}
static gboolean
_is_required(xmpp_stanza_t *const stanza)
{
xmpp_stanza_t *child = xmpp_stanza_get_child_by_name(stanza, "required");
if (child) {
return TRUE;
} else {
return FALSE;
}
}
int
handle_disco_items(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_stanza_t *query, *item;
xmppipe_state_t *state = userdata;
xmpp_ctx_t *ctx = state->ctx;
query = xmpp_stanza_get_child_by_name(stanza, "query");
if (query == NULL)
return 1;
for (item = xmpp_stanza_get_children(query); item != NULL;
item = xmpp_stanza_get_next(item)) {
xmpp_stanza_t *iq, *reply;
const char *jid = NULL;
const char *name = NULL;
char *id = NULL;
name = xmpp_stanza_get_name(item);
if (name == NULL)
continue;
if (XMPPIPE_STRNEQ(name, "item"))
continue;
jid = xmpp_stanza_get_attribute(item, "jid");
if (jid == NULL)
continue;
iq = xmppipe_stanza_new(ctx);
xmppipe_stanza_set_name(iq, "iq");
xmppipe_stanza_set_type(iq, "get");
xmppipe_stanza_set_attribute(iq, "to", jid);
id = xmpp_uuid_gen(state->ctx);
if (id == NULL) {
errx(EXIT_FAILURE, "unable to allocate message id");
}
xmppipe_stanza_set_id(iq, id);
reply = xmppipe_stanza_new(ctx);
xmppipe_stanza_set_name(reply, "query");
xmppipe_stanza_set_ns(reply, "http://jabber.org/protocol/disco#info");
xmppipe_stanza_add_child(iq, reply);
xmppipe_send(state, iq);
(void)xmpp_stanza_release(iq);
xmpp_free(state->ctx, id);
}
return 0;
}
static int _chat_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
xmppdata_t xdata;
char *intext;
xmppchat_userdata_t *udata = (xmppchat_userdata_t *) userdata;
if (!xmpp_stanza_get_child_by_name(stanza, "body"))
return 1;
if (xmpp_stanza_get_attribute(stanza, "type") != NULL && !strcmp(xmpp_stanza_get_attribute(stanza, "type"), "error"))
return 1;
intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "body"));
//printf("Incoming message from %s: %s\n", xmpp_stanza_get_attribute(stanza, "from"), intext);
xdata.from = xmpp_stanza_get_attribute(stanza, "from");
xdata.data = (void *) intext;
if (udata != NULL && udata->handler != NULL)
udata->handler(conn, &xdata, udata->userdata);
return 1;
}
void XMPP_IBB_SendPayload(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata, char* resp )
{
static int seq = 0;
int data_seq = 0;
char Data_Seq_Buf[32];
char ID_Buf[32];
char* encoded_data;
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
xmpp_stanza_t *iq, *data, *text;
iq = xmpp_stanza_new(ctx);
data = xmpp_stanza_new(ctx);
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_type(iq, "set");
sprintf(ID_Buf, "ID-seq-%d", seq);
seq++;
xmpp_stanza_set_id(iq, ID_Buf);
xmpp_stanza_set_attribute(iq, "to", xmpp_stanza_get_attribute(stanza, "from"));
xmpp_stanza_set_attribute(iq, "from", xmpp_stanza_get_attribute(stanza, "to"));
xmpp_stanza_set_name(data, "data");
xmpp_stanza_set_ns(data, XMLNS_IBB);
xmpp_stanza_set_attribute(data, "sid", \
xmpp_stanza_get_attribute(xmpp_stanza_get_child_by_name(stanza, "data"), "sid"));
sprintf(Data_Seq_Buf , "%d", data_seq);
xmpp_stanza_set_attribute(data, "seq", Data_Seq_Buf);
printf("\n[Response =%s]\n", resp);
encoded_data = base64_encode(ctx, (unsigned char*)resp, strlen(resp));
xmpp_stanza_set_text_with_size(text, encoded_data, strlen(encoded_data));
xmpp_stanza_add_child(data, text);
xmpp_stanza_add_child(iq, data);
xmpp_send(conn, iq);
seq++;
free(resp);
xmpp_free(ctx, encoded_data);
xmpp_stanza_release(data);
xmpp_stanza_release(iq);
xmpp_stanza_release(text);
xmpp_stanza_release(stanza); //copied by IBB IQ receiver handler
}
