xmpp_stanza_t *
stanza_create_presence(xmpp_ctx_t *ctx, const char * const show,
const char * const status)
{
xmpp_stanza_t *presence = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(presence, STANZA_NAME_PRESENCE);
if (show != NULL) {
xmpp_stanza_t *show_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(show_stanza, STANZA_NAME_SHOW);
xmpp_stanza_t *text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, show);
xmpp_stanza_add_child(show_stanza, text);
xmpp_stanza_add_child(presence, show_stanza);
xmpp_stanza_release(text);
xmpp_stanza_release(show_stanza);
}
if (status != NULL) {
xmpp_stanza_t *status_stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(status_stanza, STANZA_NAME_STATUS);
xmpp_stanza_t *text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, status);
xmpp_stanza_add_child(status_stanza, text);
xmpp_stanza_add_child(presence, status_stanza);
xmpp_stanza_release(text);
xmpp_stanza_release(status_stanza);
}
return presence;
}
xmpp_stanza_t *
stanza_create_message(xmpp_ctx_t *ctx, const char * const recipient,
const char * const type, const char * const message,
const char * const state)
{
char *encoded_xml = encode_xml(message);
xmpp_stanza_t *msg, *body, *text;
msg = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(msg, STANZA_NAME_MESSAGE);
xmpp_stanza_set_type(msg, type);
xmpp_stanza_set_attribute(msg, STANZA_ATTR_TO, recipient);
body = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(body, STANZA_NAME_BODY);
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, encoded_xml);
xmpp_stanza_add_child(body, text);
xmpp_stanza_add_child(msg, body);
if (state != NULL) {
xmpp_stanza_t *chat_state = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(chat_state, state);
xmpp_stanza_set_ns(chat_state, STANZA_NS_CHATSTATES);
xmpp_stanza_add_child(msg, chat_state);
}
g_free(encoded_xml);
return msg;
}
void send_stdin_once(xmpp_conn_t * const conn, xmpp_ctx_t *ctx, char *jid_to)
{
int n;
char buf[1024], *stdin_b64;
xmpp_stanza_t *message, *body, *text;
while (n = fread(buf, sizeof(char), sizeof buf, stdin)){
stdin_b64 = to_base64(buf, n);
message = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(message, "message");
xmpp_stanza_set_type(message, "chat");
xmpp_stanza_set_attribute(message, "to", jid_to);
body = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(body, "body");
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(text, stdin_b64);
xmpp_stanza_add_child(body, text);
xmpp_stanza_add_child(message, body);
xmpp_send(conn, message);
xmpp_stanza_release(message);
free(stdin_b64);
}
}
static void _respond_iq_with_error(xmpp_conn_t *conn, xmpp_stanza_t *stanza, const char *type, const char* condition)
{
char *id = xmpp_stanza_get_attribute(stanza, "id");
if (!id)
return;
xmpp_stanza_t *response = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(response, "iq");
xmpp_stanza_set_attribute(response, "type", "error");
xmpp_stanza_set_attribute(response, "id", id);
char *req_from = xmpp_stanza_get_attribute(stanza, "from");
//当req_from为NULL时, to属性应该设为服务器, 不设应该默认是服务器;
if (req_from)
xmpp_stanza_set_attribute(response, "to", req_from);
xmpp_stanza_t *stanza_error = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_error, "error");
xmpp_stanza_set_attribute(stanza_error, "type", type);
xmpp_stanza_t *stanza_condition = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_condition, condition);
xmpp_stanza_set_ns(stanza_condition, XMPP_NS_STANZA);
xmpp_stanza_add_child(stanza_error, stanza_condition);
xmpp_stanza_add_child(response, stanza_error);
xmpp_stanza_release(stanza_condition);
xmpp_stanza_release(stanza_error);
xmpp_send(conn, response);
xmpp_stanza_release(response);
}
static void _zkmuc_destroy_room(char *room_jid, xmpp_ua_t *ua)
{
xmpp_stanza_t *iq = xmpp_stanza_new(_xmpp_ctx);
char id[128];
xmpp_ua_get_unique_string(ua, id);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_id(iq, id);
xmpp_stanza_set_type(iq, "set");
xmpp_stanza_set_attribute(iq, "to", room_jid);
xmpp_stanza_t *query = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(query, "query");
xmpp_stanza_set_ns(query, XMPP_NS_MUC_OWNER);
xmpp_stanza_t *destroy = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(destroy, "destroy");
xmpp_stanza_set_attribute(destroy, "jid", room_jid);
xmpp_stanza_add_child(query, destroy);
xmpp_stanza_release(destroy);
xmpp_stanza_add_child(iq, query);
xmpp_stanza_release(query);
xmpp_ua_id_handler_add(ua, zkmuc_destroy_room_result, id, NULL);
xmpp_ua_send(ua, iq);
xmpp_stanza_release(iq);
}
static int
_disco_items_get_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
const char *id = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_ID);
const char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if (id != NULL) {
log_debug("IQ disco items get handler fired, id: %s.", id);
} else {
log_debug("IQ disco items get handler fired.");
}
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 = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(query, STANZA_NAME_QUERY);
xmpp_stanza_set_ns(query, XMPP_NS_DISCO_ITEMS);
xmpp_stanza_add_child(response, query);
xmpp_send(conn, response);
xmpp_stanza_release(response);
}
return 1;
}
int zkmuc_broadcast_message(zkmuc_ctx_t *ctx, const char *msg)
{
xmpp_stanza_t *stanza_msg = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_msg, "message");
xmpp_stanza_set_attribute(stanza_msg, "to", ctx->room_id);
xmpp_stanza_set_type(stanza_msg, "groupchat");
xmpp_stanza_t *stanza_body = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_body, "zonekey");
xmpp_stanza_t *stanza_jid = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_jid, "jid");
xmpp_stanza_t *stanza_jid_value = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_text(stanza_jid_value, xmpp_ua_get_jid(ctx->ua));
xmpp_stanza_add_child(stanza_jid, stanza_jid_value);
xmpp_stanza_release(stanza_jid_value);
xmpp_stanza_add_child(stanza_body, stanza_jid);
xmpp_stanza_release(stanza_jid);
xmpp_stanza_t *stanza_txt = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_text(stanza_txt, msg);
xmpp_stanza_add_child(stanza_body, stanza_txt);
xmpp_stanza_release(stanza_txt);
xmpp_stanza_add_child(stanza_msg, stanza_body);
xmpp_stanza_release(stanza_body);
xmpp_ua_send(ctx->ua, stanza_msg);
xmpp_stanza_release(stanza_msg);
return 0;
}
int zkmuc_get_room_description(zkmuc_ctx_t *ctx, const char *room_id, on_get_room_description cb, void *user_data)
{
char iq_id[128];
xmpp_ua_get_unique_string(ctx->ua, iq_id);
xmpp_stanza_t *stanza_iq = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_iq, "iq");
xmpp_stanza_set_attribute(stanza_iq, "to", room_id);
xmpp_stanza_set_attribute(stanza_iq, "id", iq_id);
xmpp_stanza_set_type(stanza_iq, "get");
xmpp_stanza_t *stanza_query = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_query, "query");
xmpp_stanza_set_ns(stanza_query, XMPP_NS_MUC_ROOM_INFO);
xmpp_stanza_add_child(stanza_iq, stanza_query);
xmpp_stanza_release(stanza_query);
room_info_data *info_data = (room_info_data *)malloc(sizeof(room_info_data));
info_data->cb = cb;
info_data->ctx = ctx;
info_data->user_data = user_data;
xmpp_ua_id_handler_add(ctx->ua, _on_room_info, iq_id, info_data);
xmpp_ua_send(ctx->ua, stanza_iq);
xmpp_stanza_release(stanza_iq);
return 0;
}
int zkmuc_enter_room(zkmuc_ctx_t *ctx, const char *room_id, const char *nick, zkmuc_room_cbs *cbs, void *user_data)
{
char room_jid[256];
ctx->room_id = strdup(room_id);
sprintf(room_jid, "%s/%s", room_id, nick);
ctx->room_jid = strdup(room_jid);
ctx->room_cbs = *cbs;///////
ctx->room_data = user_data;///////
xmpp_ua_presence_handler_add(ctx->ua, zkmuc_room_presence_handler, ctx);
xmpp_ua_msg_handler_add(ctx->ua, zkmuc_group_msg_handler, ctx);
xmpp_ua_msg_handler_add(ctx->ua, _zkmuc_source_query, ctx);
xmpp_stanza_t *prensece = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(prensece, "presence");
xmpp_stanza_set_attribute(prensece, "to", ctx->room_jid);
xmpp_stanza_t *x = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(x, "x");
xmpp_stanza_set_ns(x, XMPP_NS_MUC);
xmpp_stanza_add_child(prensece, x);
xmpp_stanza_release(x);
xmpp_ua_send(ctx->ua, prensece);
xmpp_stanza_release(prensece);
return 0;
}
static void add_cmd_error(xmpp_ctx_t *ctx,
xmpp_stanza_t * reply, const char *code,
const char *ns, const char *name,
const char *specificns, const char *specificcond)
{
xmpp_stanza_set_attribute(reply, "type", "error");
xmpp_stanza_t *error = xmpp_stanza_new(ctx);
assert(error);
xmpp_stanza_set_name(error, "error");
xmpp_stanza_set_attribute(error, "type", "modify");
xmpp_stanza_set_attribute(error, "code", code);
add_and_release(reply, error);
xmpp_stanza_t *etype = xmpp_stanza_new(ctx);
assert(etype);
xmpp_stanza_set_name(etype, name);
xmpp_stanza_set_attribute(etype, "xmlns", ns);
add_and_release(error, etype);
if (specificns && specificcond) {
xmpp_stanza_t *specific = xmpp_stanza_new(ctx);
assert(specific);
xmpp_stanza_set_name(specific, specificcond);
xmpp_stanza_set_attribute(specific, "xmlns", specificns);
add_and_release(error, specific);
}
}
/** 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;
}
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 xmppchat_send_message(xmpp_conn_t *conn, xmppdata_t *xdata)
{
xmpp_stanza_t *szmsg, *szbody, *sztext;
xmpp_ctx_t *ctx;
ctx = xmpp_conn_get_context(conn);
sztext = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(sztext, xdata->data);
szbody = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(szbody, "body");
xmpp_stanza_add_child(szbody, sztext);
szmsg = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(szmsg, "message");
xmpp_stanza_set_type(szmsg, "chat");
xmpp_stanza_set_attribute(szmsg, "to", xdata->tojid);
xmpp_stanza_add_child(szmsg, szbody);
xmpp_send(conn, szmsg);
xmpp_stanza_release(szmsg);
return 0;
}
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 void _start_element(void *userdata,
const XML_Char *nsname,
const XML_Char **attrs)
{
parser_t *parser = (parser_t *)userdata;
xmpp_stanza_t *child;
char *ns, *name;
ns = _xml_namespace(parser->ctx, nsname);
name = _xml_name(parser->ctx, nsname);
if (parser->depth == 0) {
/* notify the owner */
if (parser->startcb)
parser->startcb((char *)name, (char **)attrs,
parser->userdata);
} else {
/* build stanzas at depth 1 */
if (!parser->stanza && parser->depth != 1) {
/* something terrible happened */
/* FIXME: shutdown disconnect */
xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
} else if (!parser->stanza) {
/* starting a new toplevel stanza */
parser->stanza = xmpp_stanza_new(parser->ctx);
if (!parser->stanza) {
/* FIXME: can't allocate, disconnect */
}
xmpp_stanza_set_name(parser->stanza, name);
_set_attributes(parser->stanza, attrs);
if (ns)
xmpp_stanza_set_ns(parser->stanza, ns);
} else {
/* starting a child of parser->stanza */
child = xmpp_stanza_new(parser->ctx);
if (!child) {
/* FIXME: can't allocate, disconnect */
}
xmpp_stanza_set_name(child, name);
_set_attributes(child, attrs);
if (ns)
xmpp_stanza_set_ns(child, ns);
/* add child to parent */
xmpp_stanza_add_child(parser->stanza, child);
/* the child is owned by the toplevel stanza now */
xmpp_stanza_release(child);
/* make child the current stanza */
parser->stanza = child;
}
}
if (ns) xmpp_free(parser->ctx, ns);
if (name) xmpp_free(parser->ctx, name);
parser->depth++;
}
static void _start_element(void *userdata,
const xmlChar *name, const xmlChar *prefix,
const xmlChar *uri, int nnamespaces,
const xmlChar **namespaces, int nattrs,
int ndefaulted, const xmlChar **attrs)
{
parser_t *parser = (parser_t *)userdata;
xmpp_stanza_t *child;
char **cbattrs;
if (parser->depth == 0) {
/* notify the owner */
if (parser->startcb)
cbattrs = _convert_attrs(parser, nattrs, attrs);
parser->startcb((char *)name, cbattrs,
parser->userdata);
_free_cbattrs(parser, cbattrs);
} else {
/* build stanzas at depth 1 */
if (!parser->stanza && parser->depth != 1) {
/* something terrible happened */
/* FIXME: we should probably trigger a disconnect */
xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");
} else if (!parser->stanza) {
/* starting a new toplevel stanza */
parser->stanza = xmpp_stanza_new(parser->ctx);
if (!parser->stanza) {
/* FIXME: can't allocate, disconnect */
}
xmpp_stanza_set_name(parser->stanza, (char *)name);
_set_attributes(parser->stanza, nattrs, attrs);
if (uri)
xmpp_stanza_set_ns(parser->stanza, (char *)uri);
} else {
/* starting a child of conn->stanza */
child = xmpp_stanza_new(parser->ctx);
if (!child) {
/* FIXME: can't allocate, disconnect */
}
xmpp_stanza_set_name(child, (char *)name);
_set_attributes(child, nattrs, attrs);
if (uri)
xmpp_stanza_set_ns(child, (char *)uri);
/* add child to parent */
xmpp_stanza_add_child(parser->stanza, child);
/* the child is owned by the toplevel stanza now */
xmpp_stanza_release(child);
/* make child the current stanza */
parser->stanza = child;
}
}
parser->depth++;
}
char*
message_send_chat_pgp(const char *const barejid, const char *const msg)
{
xmpp_conn_t * const conn = connection_get_conn();
xmpp_ctx_t * const ctx = connection_get_ctx();
char *state = _session_state(barejid);
char *jid = _session_jid(barejid);
char *id = create_unique_id("msg");
xmpp_stanza_t *message = NULL;
#ifdef HAVE_LIBGPGME
char *account_name = jabber_get_account_name();
ProfAccount *account = accounts_get_account(account_name);
if (account->pgp_keyid) {
Jid *jidp = jid_create(jid);
char *encrypted = p_gpg_encrypt(jidp->barejid, msg);
if (encrypted) {
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, "This message is encrypted.");
xmpp_stanza_t *x = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(x, STANZA_NAME_X);
xmpp_stanza_set_ns(x, STANZA_NS_ENCRYPTED);
xmpp_stanza_t *enc_st = xmpp_stanza_new(ctx);
xmpp_stanza_set_text(enc_st, encrypted);
xmpp_stanza_add_child(x, enc_st);
xmpp_stanza_release(enc_st);
xmpp_stanza_add_child(message, x);
xmpp_stanza_release(x);
free(encrypted);
} else {
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);
}
jid_destroy(jidp);
} else {
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);
}
account_free(account);
#else
message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);
#endif
free(jid);
if (state) {
stanza_attach_state(ctx, message, state);
}
stanza_attach_carbons_private(ctx, message);
if (prefs_get_boolean(PREF_RECEIPTS_REQUEST)) {
stanza_attach_receipt_request(ctx, message);
}
xmpp_send(conn, message);
xmpp_stanza_release(message);
return id;
}
static int alarmqueue_handler(xmpp_conn_t * const conn, void * const userdata)
{
conflate_handle_t *handle = (conflate_handle_t*) userdata;
alarm_t alarm;
const char* myjid = xmpp_conn_get_bound_jid(conn);
char id[262];
char open[2] = { 0, 0 };
char amsg[256];
char body[1500];
char num[255];
while (handle->alarms->size > 0)
{
alarm = get_alarm(handle->alarms);
open[0] = alarm.open ? '1' : '2';
snprintf(amsg, sizeof(amsg), "%s", alarm.msg);
/* if we got a legitimate alarm, send off alert */
if(alarm.open == 1)
{
snprintf(id, sizeof(id), "_alarm%d", alarm.num);
//handler_add_id(conn, alarm_response_handler, id, handle);
//handler_add_timed(conn, alarm_missing_handler, 120000, handle);
xmpp_stanza_t* msg = xmpp_stanza_new(handle->ctx);
assert(msg);
xmpp_stanza_set_name(msg, "message");
//xmpp_stanza_set_type(iq, "set");
xmpp_stanza_set_id(msg, id);
//xmpp_stanza_set_attribute(iq, "to", xmpp_stanza_get_attribute(stanza, "from"));
/* TODO: This needs to have a config on where to report to */
xmpp_stanza_set_attribute(msg, "to", "*****@*****.**");
xmpp_stanza_set_attribute(msg, "from", myjid);
xmpp_stanza_t* mbody = xmpp_stanza_new(handle->ctx);
assert(mbody);
xmpp_stanza_set_name(mbody, "body");
snprintf(body, sizeof(body), "Alert\n%s", amsg);
snprintf(num, sizeof(num), "%d", alarm.num);
xmpp_stanza_set_text(mbody, body);
add_and_release(msg, mbody);
xmpp_stanza_t* alert = xmpp_stanza_new(handle->ctx);
assert(alert);
xmpp_stanza_set_name(alert, "alert");
xmpp_stanza_set_attribute(alert, "xmlns", "http://northscale.net/protocol/alerts");
xmpp_stanza_set_attribute(alert, "open", open);
xmpp_stanza_set_attribute(alert, "msg", amsg);
xmpp_stanza_set_attribute(alert, "num", num);
xmpp_stanza_set_attribute(alert, "name", alarm.name);
add_and_release(msg, alert);
xmpp_send(conn, msg);
xmpp_stanza_release(msg);
}
}
return 1;
}
/* handle the challenge phase of digest auth */
static int _handle_digestmd5_challenge(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza,
void * const userdata)
{
char *text;
char *response;
xmpp_stanza_t *auth, *authdata;
char *name;
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp",\
"handle digest-md5 (challenge) called for %s", name);
if (strcmp(name, "challenge") == 0) {
text = xmpp_stanza_get_text(stanza);
response = sasl_digest_md5(conn->ctx, text, conn->jid, conn->pass);
if (!response) {
disconnect_mem_error(conn);
return 0;
}
xmpp_free(conn->ctx, text);
auth = xmpp_stanza_new(conn->ctx);
if (!auth) {
disconnect_mem_error(conn);
return 0;
}
xmpp_stanza_set_name(auth, "response");
xmpp_stanza_set_ns(auth, XMPP_NS_SASL);
authdata = xmpp_stanza_new(conn->ctx);
if (!authdata) {
disconnect_mem_error(conn);
return 0;
}
xmpp_stanza_set_text(authdata, response);
xmpp_free(conn->ctx, response);
xmpp_stanza_add_child(auth, authdata);
xmpp_stanza_release(authdata);
handler_add(conn, _handle_digestmd5_rspauth,
XMPP_NS_SASL, NULL, NULL, NULL);
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
} else {
return _handle_sasl_result(conn, stanza, "DIGEST-MD5");
}
/* remove ourselves */
return 0;
}
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
}
static int _zkmuc_source_query(xmpp_ua_t *ua, xmpp_stanza_t *stanza, void *userdata)
{
zkmuc_ctx_t *ctx = (zkmuc_ctx_t *)userdata;
char *from = xmpp_stanza_get_attribute(stanza, "from");
char *id = xmpp_stanza_get_id(stanza);
if (id == NULL)
{
return 0;
}
xmpp_stanza_t *x = xmpp_stanza_get_child_by_name(stanza, "x");
if(x && xmpp_stanza_get_ns(x) && !strcmp(XMPP_NS_SOURCE, xmpp_stanza_get_ns(x)))
{
char *action = xmpp_stanza_get_attribute(x, "action");
if (!strcmp("query", action))
{
xmpp_stanza_t *message = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(message, "message");
xmpp_stanza_set_attribute(message, "to", from);
xmpp_stanza_set_id(message, id);
xmpp_stanza_t *result_x = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(result_x, "x");
xmpp_stanza_set_ns(result_x, XMPP_NS_SOURCE);
xmpp_stanza_set_attribute(result_x, "action", "result");
WaitForSingleObject(ctx->_mutex_4_source, INFINITE);
zkmuc_source_t *item = ctx->head;
while (item)
{
xmpp_stanza_t *stanza_item = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_item, "item");
char buf[32];
xmpp_stanza_set_attribute(stanza_item, "cid", itoa(item->cid, buf, 10));
xmpp_stanza_set_attribute(stanza_item, "sid", itoa(item->sid, buf, 10));
xmpp_stanza_set_attribute(stanza_item, "desc", item->description);
xmpp_stanza_set_attribute(stanza_item, "mcu", item->mcu);
xmpp_stanza_add_child(result_x, stanza_item);
xmpp_stanza_release(stanza_item);
item = item->next;
}
ReleaseMutex(ctx->_mutex_4_source);
xmpp_stanza_add_child(message, result_x);
xmpp_stanza_release(result_x);
xmpp_ua_send(ctx->ua, message);
xmpp_stanza_release(message);
return 1;
}
}
return 0;
}
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);
}
}
int register_user(mio_conn_t *conn, char *user, char *pass)
{
int err;
mio_response_t *response = mio_response_new();
xmpp_stanza_t *iq = NULL, *query = NULL, *username = NULL, *username_tag = NULL, *password = NULL, *password_tag = NULL;
mio_stanza_t *stanza = mio_stanza_new(conn);
// Check if connection is active
if (!conn->xmpp_conn->authenticated) {
return MIO_ERROR_DISCONNECTED;
}
// Create a new user stanza
iq = xmpp_stanza_new(conn->xmpp_conn->ctx);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_attribute(iq, "id", "reg2");
xmpp_stanza_set_type(iq, "set");
// Creqte query stanza
query = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
xmpp_stanza_set_name(query,"query");
xmpp_stanza_set_ns(query,"jabber:iq:register");
// create username stanza
username = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
username_tag = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
xmpp_stanza_set_name(username,"username");
xmpp_stanza_set_text(username_tag, user);
// create password stanza
password = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
password_tag = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
xmpp_stanza_set_name(password, "password");
xmpp_stanza_set_text(password_tag,pass);
// create password stanza
password = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
password_tag = xmpp_stanza_new(conn -> xmpp_conn -> ctx);
xmpp_stanza_set_name(password, "password");
xmpp_stanza_set_text(password_tag,pass);
// Build xmpp message
xmpp_stanza_add_child(password, password_tag);
xmpp_stanza_add_child(username, username_tag);
xmpp_stanza_add_child(query, username);
xmpp_stanza_add_child(query, password);
xmpp_stanza_add_child(iq, query);
stanza -> xmpp_stanza = iq;
// Send out the stanza
err = _mio_send_nonblocking(conn, stanza);
// Release the stanzas
mio_stanza_free(stanza);
mio_response_free(response);
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;
}
/** Create a stanza object in reply to another.
* This function makes a copy of a stanza object with the attribute “to” set
* its original “from”.
* The stanza will have a reference count of one, so the caller does not
* need to clone it.
*
* @param stanza a Strophe stanza object
*
* @return a new Strophe stanza object
*
* @ingroup Stanza
*/
xmpp_stanza_t *xmpp_stanza_reply(xmpp_stanza_t * const stanza)
{
xmpp_stanza_t *copy = NULL;
const char *from;
int rc;
from = xmpp_stanza_get_from(stanza);
if (!from) goto copy_error;
copy = xmpp_stanza_new(stanza->ctx);
if (!copy) goto copy_error;
copy->type = stanza->type;
if (stanza->data) {
copy->data = xmpp_strdup(stanza->ctx, stanza->data);
if (!copy->data) goto copy_error;
}
if (stanza->attributes) {
if (_stanza_copy_attributes(copy, stanza) < 0)
goto copy_error;
}
xmpp_stanza_del_attribute(copy, "to");
xmpp_stanza_del_attribute(copy, "from");
rc = xmpp_stanza_set_to(copy, from);
if (rc != XMPP_EOK) goto copy_error;
return copy;
copy_error:
if (copy) xmpp_stanza_release(copy);
return NULL;
}
/* 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);
}
}
static int
_iq_handle_ping_get(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
const char *id = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_ID);
const char *to = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_TO);
const char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);
if ((from == NULL) || (to == NULL)) {
return 1;
}
xmpp_stanza_t *pong = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pong, STANZA_NAME_IQ);
xmpp_stanza_set_attribute(pong, STANZA_ATTR_TO, from);
xmpp_stanza_set_attribute(pong, STANZA_ATTR_FROM, to);
xmpp_stanza_set_attribute(pong, STANZA_ATTR_TYPE, STANZA_TYPE_RESULT);
if (id != NULL) {
xmpp_stanza_set_attribute(pong, STANZA_ATTR_ID, id);
}
xmpp_send(conn, pong);
xmpp_stanza_release(pong);
return 1;
}
/* handle the rspauth phase of digest auth */
static int _handle_digestmd5_rspauth(xmpp_conn_t * const conn,
xmpp_stanza_t * const stanza,
void * const userdata)
{
xmpp_stanza_t *auth;
char *name;
name = xmpp_stanza_get_name(stanza);
xmpp_debug(conn->ctx, "xmpp",
"handle digest-md5 (rspauth) called for %s", name);
if (strcmp(name, "challenge") == 0) {
/* assume it's an rspauth response */
auth = xmpp_stanza_new(conn->ctx);
if (!auth) {
disconnect_mem_error(conn);
return 0;
}
xmpp_stanza_set_name(auth, "response");
xmpp_stanza_set_ns(auth, XMPP_NS_SASL);
xmpp_send(conn, auth);
xmpp_stanza_release(auth);
} else {
return _handle_sasl_result(conn, stanza, "DIGEST-MD5");
}
return 1;
}
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);
}
}
/**
* 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);
}
}