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;
}
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);
}
}
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);
}
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;
}
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
_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;
}
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
}
void XMPP_IBB_Ack_Send(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata)
{
xmpp_ctx_t *ctx = (xmpp_ctx_t *)userdata;
xmpp_stanza_t *iq;
iq = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_type(iq, "result");
xmpp_stanza_set_id(iq, xmpp_stanza_get_attribute(stanza, "id"));
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_send(conn, iq);
xmpp_stanza_release(iq);
}
/*
* Copy the attributes of stanza src into stanza dst. Return -1 on error.
*/
static int _stanza_copy_attributes(xmpp_stanza_t * dst,
const xmpp_stanza_t * const src)
{
hash_iterator_t *iter;
const char *key;
const char *val;
int rc = XMPP_EOK;
iter = hash_iter_new(src->attributes);
if (!iter) rc = XMPP_EMEM;
while (rc == XMPP_EOK && (key = hash_iter_next(iter))) {
val = hash_get(src->attributes, key);
if (!val) rc = XMPP_EINT;
if (rc == XMPP_EOK)
rc = xmpp_stanza_set_attribute(dst, key, val);
}
hash_iter_release(iter);
if (rc != XMPP_EOK && dst->attributes) {
hash_release(dst->attributes);
dst->attributes = NULL;
}
return rc;
}
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 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_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;
}
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;
}
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;
}
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;
}
static void
_send_room_presence(xmpp_conn_t *conn, xmpp_stanza_t *presence)
{
GList *rooms_p = muc_get_active_room_list();
GList *rooms = rooms_p;
while (rooms != NULL) {
const char *room = rooms->data;
const char *nick = muc_get_room_nick(room);
if (nick != NULL) {
char *full_room_jid = create_fulljid(room, nick);
xmpp_stanza_set_attribute(presence, STANZA_ATTR_TO, full_room_jid);
log_debug("Sending presence to room: %s", full_room_jid);
xmpp_send(conn, presence);
free(full_room_jid);
}
rooms = g_list_next(rooms);
}
if (rooms_p != NULL) {
g_list_free(rooms_p);
}
}
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;
}
static void zkmuc_unlock_room(zkmuc_ctx_t *ctx)
{
xmpp_stanza_t *iq = xmpp_stanza_new(_xmpp_ctx);
char id[128];
xmpp_ua_get_unique_string(ctx->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", ctx->room_id);
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 *x = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(x, "x");
xmpp_stanza_set_ns(x, XMPP_NS_X);
xmpp_stanza_set_type(x, "submit");
xmpp_stanza_t *field = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(field, "field");
xmpp_stanza_set_attribute(field, "var", "muc#roomconfig_roomname");
xmpp_stanza_t *stanza_value = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_name(stanza_value, "value");
xmpp_stanza_t *stanza_text = xmpp_stanza_new(_xmpp_ctx);
xmpp_stanza_set_text(stanza_text, ctx->room_desc);
xmpp_stanza_add_child(stanza_value, stanza_text);
xmpp_stanza_release(stanza_text);
xmpp_stanza_add_child(field, stanza_value);
xmpp_stanza_release(stanza_value);
xmpp_stanza_add_child(x, field);
xmpp_stanza_release(field);
xmpp_stanza_add_child(query, x);
xmpp_stanza_release(x);
xmpp_stanza_add_child(iq, query);
xmpp_stanza_release(query);
xmpp_ua_id_handler_add(ctx->ua, zkmuc_unlock_room_result, id, ctx);
xmpp_ua_send(ctx->ua, iq);
xmpp_stanza_release(iq);
}
xmpp_ibb_session_t *xmpp_ibb_open(xmpp_conn_t * const conn, char * const peer, char * const sid)
{
xmpp_ibb_session_t *sess;
xmpp_stanza_t *iq, *open;
xmpp_ctx_t *ctx;
const char *jid = xmpp_conn_get_bound_jid(conn);
char sizetemp[6] = "";
int size;
if (peer == NULL || strlen(peer) == 0) {
return NULL;
}
sess = _ibb_session_init(conn, peer, sid);
if (sess == NULL) {
return NULL;
}
size = snprintf(sizetemp, sizeof(sizetemp), "%d", sess->block_size);
if (size < sizeof(sizetemp)) {
sizetemp[size] = '\0';
}
nmtoken_generate(sess->id, 8);
ctx = xmpp_conn_get_context(conn);
iq = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_type(iq, "set");
xmpp_stanza_set_id(iq, sess->id);
xmpp_stanza_set_attribute(iq, "from", jid);
xmpp_stanza_set_attribute(iq, "to", sess->peer);
open = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(open, "open");
xmpp_stanza_set_ns(open, XMLNS_IBB);
xmpp_stanza_set_attribute(open, "block-size", sizetemp);
xmpp_stanza_set_attribute(open, "sid", sess->sid);
xmpp_stanza_set_attribute(open, "stanza", "iq");
xmpp_stanza_add_child(iq, open);
xmpp_send(conn, iq);
xmpp_stanza_release(open);
xmpp_stanza_release(iq);
ilist_add(g_list, sess);
return sess;
}
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;
}
/**
* This is called when someone sends a RPC method call
* Checks for XML-RPC format validation and sends error if so otherwise it calls the
* HandleServiceCall for finding the right service and creating the right structures
* @return KEEP_THIS_HANDLER_ACTIVE
*/
int HandleRpcCall(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,
void * const userdata) {
xmpp_stanza_t *reply;
xmpp_stanza_t *xmlRpcReply;
xmpp_ctx_t *ctx = (xmpp_ctx_t*) userdata;
sdvp_from_t* from;
sdvp_reply_params_t* replyParams = NULL;
int formatInvalid;
sdvpIdleCounter = 0;
sdvpPingsSent = 0;
reply = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(reply, "iq");
// TODO: Get the Group and get the jid
from = _CreateFrom(xmpp_stanza_get_attribute(stanza, "from"), "TODO",
"TODO");
syslog(LOG_DEBUG, "Received a RPC Method call from %s\n", from->name);
formatInvalid = _CheckRpcFormat(stanza);
if (formatInvalid) {
// FIXME: Something here fails!
syslog(LOG_WARNING, "Error in XML-RPC format\n");
sdvp_InitiateReplyParameters(&replyParams, 1);
replyParams->params[0].strValue = strdup("Error in XML-RPC format\n");
replyParams->params[0].type = IEC_VISIBLE_STRING;
xmpp_stanza_set_type(reply, "error");
// TODO: Create a type
//HJP var her!
xmlRpcReply = _CreateReply(ctx, SDVP_METHOD_UNDEFINED ,replyParams);
xmpp_stanza_add_child(reply, xmlRpcReply);
//HJP: stanza_add_child laver en kopi, så der skal releases
xmpp_stanza_release(xmlRpcReply);
sdvp_FreeReplyParameters(replyParams);
} else {
// The reply from this function should be ready to send
xmlRpcReply = _HandleServiceRequest(conn, stanza, userdata);
xmpp_stanza_add_child(reply, xmlRpcReply);
//HJP: stanza_add_child laver en kopi, så der skal releases
xmpp_stanza_release(xmlRpcReply);
}
xmpp_stanza_set_id(reply, xmpp_stanza_get_id(stanza));
xmpp_stanza_set_attribute(reply, "to",
xmpp_stanza_get_attribute(stanza, "from"));
xmpp_stanza_set_type(reply, "result");
xmpp_send(conn, reply);
xmpp_stanza_release(reply); // Frees the stanza and all of its children
_FreeFrom(from);
return KEEP_THIS_HANDLER_ACTIVE;
}
void zkmuc_leave_room(zkmuc_ctx_t *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_set_type(prensece, "unavailable");
xmpp_ua_send(ctx->ua, prensece);
xmpp_stanza_release(prensece);
}
static void add_disco_item(xmpp_ctx_t* ctx, xmpp_stanza_t* query,
const char* jid, char* node, char* name)
{
xmpp_stanza_t* item = xmpp_stanza_new(ctx);
assert(item);
assert(ctx);
assert(query);
assert(jid);
assert(node);
assert(name);
xmpp_stanza_set_name(item, "item");
xmpp_stanza_set_attribute(item, "jid", jid);
xmpp_stanza_set_attribute(item, "node", node);
xmpp_stanza_set_attribute(item, "name", name);
add_and_release(query, item);
}
static void _set_attributes(xmpp_stanza_t *stanza, const xmlChar **attrs)
{
int i;
if (!attrs) return;
for (i = 0; attrs[i]; i += 2) {
xmpp_stanza_set_attribute(stanza, attrs[i], attrs[i+1]);
}
}
xmpp_stanza_t *
stanza_create_room_newnick_presence(xmpp_ctx_t *ctx,
const char * const full_room_jid)
{
xmpp_stanza_t *presence = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(presence, STANZA_NAME_PRESENCE);
xmpp_stanza_set_attribute(presence, STANZA_ATTR_TO, full_room_jid);
return presence;
}
void
mood_publish(mood_callback_t callback, const char * const usermood,
const char * const usertext)
{
xmpp_stanza_t *iq, *pubsub, *publish, *item, *mood, *stanza, *text;
iq = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_type(iq, "set");
xmpp_stanza_set_id(iq, "mood1"); /* FIXME */
pubsub = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(pubsub, "pubsub");
xmpp_stanza_set_ns(pubsub, NS_PUBSUB);
xmpp_stanza_add_child(iq, pubsub);
xmpp_stanza_release(pubsub);
publish = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(publish, "publish");
xmpp_stanza_set_attribute(publish, "node", NS_MOOD);
xmpp_stanza_add_child(pubsub, publish);
xmpp_stanza_release(publish);
item = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(item, "item");
xmpp_stanza_add_child(publish, item);
xmpp_stanza_release(item);
mood = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(mood, "mood");
xmpp_stanza_set_ns(mood, NS_MOOD);
xmpp_stanza_add_child(item, mood);
xmpp_stanza_release(mood);
if (usermood != NULL) {
stanza = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(stanza, usermood);
xmpp_stanza_add_child(mood, stanza);
xmpp_stanza_release(stanza);
}
if (usertext != NULL) {
text = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(text, "text");
xmpp_stanza_set_text(text, usertext);
xmpp_stanza_add_child(mood, text);
xmpp_stanza_release(text);
}
xmpp_id_handler_add(conn, mood_result_handler,
xmpp_stanza_get_id(iq), callback);
xmpp_send(conn, iq);
xmpp_stanza_release(iq);
}
void conflate_init_form(conflate_form_result *r)
{
if (!r->container) {
r->container = xmpp_stanza_new(r->ctx);
/* X data in the command response */
xmpp_stanza_set_name(r->container, "x");
xmpp_stanza_set_attribute(r->container, "xmlns", "jabber:x:data");
xmpp_stanza_set_type(r->container, "result");
add_and_release(r->cmd_res, r->container);
}
}
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;
}
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;
xmpp_stanza_t *iq, *query;
if (status == XMPP_CONN_CONNECT) {
fprintf(stderr, "DEBUG: connected\n");
/* create iq stanza for request */
iq = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(iq, "iq");
xmpp_stanza_set_type(iq, "get");
xmpp_stanza_set_id(iq, "active1");
xmpp_stanza_set_attribute(iq, "to", "xxxxxxxxx.com");
query = xmpp_stanza_new(ctx);
xmpp_stanza_set_name(query, "query");
xmpp_stanza_set_ns(query, XMPP_NS_DISCO_ITEMS);
xmpp_stanza_set_attribute(query, "node", "sessions");
xmpp_stanza_add_child(iq, query);
/* we can release the stanza since it belongs to iq now */
xmpp_stanza_release(query);
/* set up reply handler */
xmpp_id_handler_add(conn, handle_reply, "active1", ctx);
/* send out the stanza */
xmpp_send(conn, iq);
/* release the stanza */
xmpp_stanza_release(iq);
} else {
fprintf(stderr, "DEBUG: disconnected\n");
xmpp_stop(ctx);
}
}
