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; }
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; }
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; }
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; }
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); } }
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; 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; }
/** 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 version_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata) { xmpp_stanza_t *reply, *query, *name, *version, *text; const char *ns; xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata; printf("Received version request from %s\n", xmpp_stanza_get_from(stanza)); reply = xmpp_stanza_reply(stanza); xmpp_stanza_set_type(reply, "result"); query = xmpp_stanza_new(ctx); xmpp_stanza_set_name(query, "query"); ns = xmpp_stanza_get_ns(xmpp_stanza_get_children(stanza)); if (ns) { xmpp_stanza_set_ns(query, ns); } name = xmpp_stanza_new(ctx); xmpp_stanza_set_name(name, "name"); xmpp_stanza_add_child(query, name); xmpp_stanza_release(name); text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(text, "libstrophe example bot"); xmpp_stanza_add_child(name, text); xmpp_stanza_release(text); version = xmpp_stanza_new(ctx); xmpp_stanza_set_name(version, "version"); xmpp_stanza_add_child(query, version); xmpp_stanza_release(version); text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(text, "1.0"); xmpp_stanza_add_child(version, text); xmpp_stanza_release(text); xmpp_stanza_add_child(reply, query); xmpp_stanza_release(query); xmpp_send(conn, reply); xmpp_stanza_release(reply); return 1; }
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; }
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); }
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_send_presence(xmpp_conn_t * const conn, xmpp_presence_show_t sw, const char *sv) { static const char *show_table[] = { "chat", "away", "xa", "dnd" }; xmpp_stanza_t *presence, *show, *status, *text; presence = xmpp_stanza_new(conn->ctx); xmpp_stanza_set_name(presence, "presence"); show = xmpp_stanza_new(conn->ctx); xmpp_stanza_set_name(show, "show"); xmpp_stanza_add_child(presence, show); text = xmpp_stanza_new(conn->ctx); xmpp_stanza_set_text(text, show_table[sw]); xmpp_stanza_add_child(show, text); xmpp_stanza_release(text); xmpp_stanza_release(show); status = xmpp_stanza_new(conn->ctx); xmpp_stanza_set_name(status, "status"); xmpp_stanza_add_child(presence, status); text = xmpp_stanza_new(conn->ctx); xmpp_stanza_set_text(text, sv); xmpp_stanza_add_child(status, text); xmpp_stanza_release(text); xmpp_stanza_release(status); xmpp_send(conn, presence); xmpp_stanza_release(presence); }
static void conn_handler(xmpp_conn_t * const conn, const xmpp_conn_event_t status, const int error, xmpp_stream_error_t * const stream_error, void * const userdata) { conflate_handle_t *handle = (conflate_handle_t *)userdata; if (status == XMPP_CONN_CONNECT) { xmpp_stanza_t* pres = NULL, *priority = NULL, *pri_text = NULL; CONFLATE_LOG(handle, LOG_LVL_INFO, "Connected."); xmpp_handler_add(conn, version_handler, "jabber:iq:version", "iq", NULL, handle); xmpp_handler_add(conn, command_handler, "http://jabber.org/protocol/commands", "iq", NULL, handle); xmpp_handler_add(conn, disco_items_handler, "http://jabber.org/protocol/disco#items", "iq", NULL, handle); xmpp_handler_add(conn, message_handler, NULL, "message", NULL, handle); xmpp_timed_handler_add(conn, keepalive_handler, 60000, handle); xmpp_timed_handler_add(conn, alarmqueue_handler, 10000, handle); /* Send initial <presence/> so that we appear online to contacts */ pres = xmpp_stanza_new(handle->ctx); assert(pres); xmpp_stanza_set_name(pres, "presence"); priority = xmpp_stanza_new(handle->ctx); assert(priority); xmpp_stanza_set_name(priority, "priority"); add_and_release(pres, priority); pri_text = xmpp_stanza_new(handle->ctx); assert(pri_text); xmpp_stanza_set_text(pri_text, "5"); add_and_release(priority, pri_text); xmpp_send(conn, pres); xmpp_stanza_release(pres); /* Store the bound jid */ if (!conflate_save_private(handle, STORED_JID_KEY, xmpp_conn_get_bound_jid(conn), handle->conf->save_path)) { CONFLATE_LOG(handle, LOG_LVL_WARN, "Failed to save the bound jid"); } } else { CONFLATE_LOG(handle, LOG_LVL_INFO, "disconnected."); xmpp_stop(handle->ctx); } }
static void 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); }
int presence_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata) { xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata; if (!strcmp(xmpp_stanza_get_name(stanza), "presence")) { xmpp_stanza_t *message, *text, *body; char username[1024]; char sendtext[1024]; printf("Enter the username you would like to send this message to: "); scanf("%[^\n]", username); char c = getchar(); printf("Type the message that you would like to send: "); scanf("%[^\n]", sendtext); message = xmpp_stanza_new(ctx); xmpp_stanza_set_name(message, "message"); xmpp_stanza_set_type(message, "chat"); xmpp_stanza_set_attribute(message, "to", username); body = xmpp_stanza_new(ctx); xmpp_stanza_set_name(body, "body"); text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(text, sendtext); xmpp_stanza_add_child(body, text); xmpp_stanza_add_child(message, body); xmpp_send(conn, message); xmpp_stanza_release(message); } }
int xmpp_ua_mse_send_cmd(xmpp_ua_t *ua, const char *remote_jid, const char *cmd, const char *option, xmpp_ua_mse_receive_rsp cb, void *userdata) { int cmd_id = -1; if (cb) cmd_id = xmpp_ua_get_unique_id(); xmpp_stanza_t *msg = xmpp_stanza_new(_xmpp_ctx); xmpp_stanza_set_name(msg, "message"); xmpp_stanza_set_type(msg, "chat"); xmpp_stanza_set_attribute(msg, "to", remote_jid); xmpp_stanza_t *body = xmpp_stanza_new(_xmpp_ctx); xmpp_stanza_set_name(body,"body"); xmpp_stanza_t *text = xmpp_stanza_new(_xmpp_ctx); char *option2; xmpp_ua_change_string(option, &option2); char *msg_text = (char *)malloc(32+strlen(cmd)+strlen(option2)); sprintf(msg_text, "ReqCmd|%d|%s|%s", cmd_id, cmd, option2); xmpp_stanza_set_text(text, msg_text); free(option2); free(msg_text); xmpp_stanza_add_child(body, text); xmpp_stanza_release(text); xmpp_stanza_add_child(msg, body); xmpp_stanza_release(body); if (cb) { mse_cmd_data data = {cb, userdata}; WaitForSingleObject(ua->mutex_4_ua, INFINITE); ua->mse_map[cmd_id] = data; ReleaseMutex(ua->mutex_4_ua); } int rc = xmpp_ua_send(ua, msg); xmpp_stanza_release(msg); return rc; }
int zkmuc_invite(zkmuc_ctx_t *ctx, const char *remote_id) { xmpp_stanza_t *stanza_msg = xmpp_stanza_new(_xmpp_ctx); xmpp_stanza_set_name(stanza_msg, "message"); xmpp_stanza_set_attribute(stanza_msg, "to", remote_id); xmpp_stanza_set_ns(stanza_msg, XMPP_NS_CONFERECE); xmpp_stanza_t *stanza_body = xmpp_stanza_new(_xmpp_ctx); xmpp_stanza_set_name(stanza_body, "body"); xmpp_stanza_t *stanza_txt = xmpp_stanza_new(_xmpp_ctx); xmpp_stanza_set_text(stanza_txt, ctx->room_id); 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; }
static void add_form_values(xmpp_ctx_t* ctx, xmpp_stanza_t *parent, const char *key, const char **values) { xmpp_stanza_t* field = xmpp_stanza_new(ctx); assert(field); xmpp_stanza_set_name(field, "field"); xmpp_stanza_set_attribute(field, "var", key); add_and_release(parent, field); for (int i = 0; values[i]; i++) { xmpp_stanza_t* value = xmpp_stanza_new(ctx); xmpp_stanza_t* text = xmpp_stanza_new(ctx); assert(value); assert(text); xmpp_stanza_set_name(value, "value"); add_and_release(field, value); xmpp_stanza_set_text(text, values[i]); add_and_release(value, text); } }
static gboolean _bookmark_add(const char *jid, const char *nick, gboolean autojoin) { gboolean added = TRUE; if (autocomplete_contains(bookmark_ac, jid)) { added = FALSE; } xmpp_conn_t *conn = connection_get_conn(); xmpp_ctx_t *ctx = connection_get_ctx(); /* TODO: send request */ xmpp_stanza_t *stanza = xmpp_stanza_new(ctx); xmpp_stanza_set_name(stanza, STANZA_NAME_IQ); char *id = generate_unique_id("bookmark_add"); xmpp_stanza_set_id(stanza, id); xmpp_stanza_set_type(stanza, STANZA_TYPE_SET); xmpp_stanza_t *pubsub = xmpp_stanza_new(ctx); xmpp_stanza_set_name(pubsub, STANZA_NAME_PUBSUB); xmpp_stanza_set_ns(pubsub, STANZA_NS_PUBSUB); xmpp_stanza_add_child(stanza, pubsub); xmpp_stanza_t *publish = xmpp_stanza_new(ctx); xmpp_stanza_set_name(publish, STANZA_NAME_PUBLISH); xmpp_stanza_set_attribute(publish, STANZA_ATTR_NODE, "storage:bookmarks"); xmpp_stanza_add_child(pubsub, publish); xmpp_stanza_t *item = xmpp_stanza_new(ctx); xmpp_stanza_set_name(item, STANZA_NAME_ITEM); xmpp_stanza_add_child(publish, item); xmpp_stanza_t *storage = xmpp_stanza_new(ctx); xmpp_stanza_set_name(storage, STANZA_NAME_STORAGE); xmpp_stanza_set_ns(storage, "storage;bookmarks"); xmpp_stanza_add_child(item, storage); xmpp_stanza_t *conference = xmpp_stanza_new(ctx); xmpp_stanza_set_name(conference, STANZA_NAME_CONFERENCE); xmpp_stanza_set_attribute(conference, STANZA_ATTR_JID, jid); if (autojoin) { xmpp_stanza_set_attribute(conference, STANZA_ATTR_AUTOJOIN, "true"); } else { xmpp_stanza_set_attribute(conference, STANZA_ATTR_AUTOJOIN, "false"); } xmpp_stanza_add_child(storage, conference); if (nick != NULL) { xmpp_stanza_t *nick_st = xmpp_stanza_new(ctx); xmpp_stanza_set_name(nick_st, STANZA_NAME_NICK); xmpp_stanza_set_text(nick_st, nick); xmpp_stanza_add_child(conference, nick_st); } xmpp_stanza_t *publish_options = xmpp_stanza_new(ctx); xmpp_stanza_set_name(publish_options, STANZA_NAME_PUBLISH_OPTIONS); xmpp_stanza_add_child(pubsub, publish_options); xmpp_stanza_t *x = xmpp_stanza_new(ctx); xmpp_stanza_set_name(x, STANZA_NAME_X); xmpp_stanza_set_ns(x, STANZA_NS_DATA); xmpp_stanza_set_attribute(x, STANZA_ATTR_TYPE, "submit"); xmpp_stanza_add_child(publish_options, x); xmpp_stanza_t *form_type = xmpp_stanza_new(ctx); xmpp_stanza_set_name(form_type, STANZA_NAME_FIELD); xmpp_stanza_set_attribute(form_type, STANZA_ATTR_VAR, "FORM_TYPE"); xmpp_stanza_set_attribute(form_type, STANZA_ATTR_TYPE, "hidden"); xmpp_stanza_t *form_type_value = xmpp_stanza_new(ctx); xmpp_stanza_set_name(form_type_value, STANZA_NAME_VALUE); xmpp_stanza_t *form_type_value_text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(form_type_value_text, "http://jabber.org/protocol/pubsub#publish-options"); xmpp_stanza_add_child(form_type_value, form_type_value_text); xmpp_stanza_add_child(form_type, form_type_value); xmpp_stanza_add_child(x, form_type); xmpp_stanza_t *persist_items = xmpp_stanza_new(ctx); xmpp_stanza_set_name(persist_items, STANZA_NAME_FIELD); xmpp_stanza_set_attribute(persist_items, STANZA_ATTR_VAR, "pubsub#persist_items"); xmpp_stanza_t *persist_items_value = xmpp_stanza_new(ctx); xmpp_stanza_set_name(persist_items_value, STANZA_NAME_VALUE); xmpp_stanza_t *persist_items_value_text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(persist_items_value_text, "true"); xmpp_stanza_add_child(persist_items_value, persist_items_value_text); xmpp_stanza_add_child(persist_items, persist_items_value); xmpp_stanza_add_child(x, persist_items); xmpp_stanza_t *access_model = xmpp_stanza_new(ctx); xmpp_stanza_set_name(access_model, STANZA_NAME_FIELD); xmpp_stanza_set_attribute(access_model, STANZA_ATTR_VAR, "pubsub#access_model"); xmpp_stanza_t *access_model_value = xmpp_stanza_new(ctx); xmpp_stanza_set_name(access_model_value, STANZA_NAME_VALUE); xmpp_stanza_t *access_model_value_text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(access_model_value_text, "whitelist"); xmpp_stanza_add_child(access_model_value, access_model_value_text); xmpp_stanza_add_child(access_model, access_model_value); xmpp_stanza_add_child(x, access_model); xmpp_send(conn, stanza); xmpp_stanza_release(stanza); /* TODO: manage bookmark_list */ /* this may be command for modifying */ autocomplete_remove(bookmark_ac, jid); autocomplete_add(bookmark_ac, jid); return added; }
static void _send_bookmarks(void) { xmpp_conn_t *conn = connection_get_conn(); xmpp_ctx_t *ctx = connection_get_ctx(); xmpp_stanza_t *iq = xmpp_stanza_new(ctx); xmpp_stanza_set_name(iq, STANZA_NAME_IQ); char *id = create_unique_id("bookmarks_update"); xmpp_stanza_set_id(iq, id); free(id); xmpp_stanza_set_type(iq, STANZA_TYPE_SET); xmpp_stanza_t *query = xmpp_stanza_new(ctx); xmpp_stanza_set_name(query, STANZA_NAME_QUERY); xmpp_stanza_set_ns(query, "jabber:iq:private"); xmpp_stanza_t *storage = xmpp_stanza_new(ctx); xmpp_stanza_set_name(storage, STANZA_NAME_STORAGE); xmpp_stanza_set_ns(storage, "storage:bookmarks"); GList *curr = bookmark_list; while (curr) { Bookmark *bookmark = curr->data; xmpp_stanza_t *conference = xmpp_stanza_new(ctx); xmpp_stanza_set_name(conference, STANZA_NAME_CONFERENCE); xmpp_stanza_set_attribute(conference, STANZA_ATTR_JID, bookmark->jid); Jid *jidp = jid_create(bookmark->jid); if (jidp->localpart) { xmpp_stanza_set_attribute(conference, STANZA_ATTR_NAME, jidp->localpart); } jid_destroy(jidp); if (bookmark->autojoin) { xmpp_stanza_set_attribute(conference, STANZA_ATTR_AUTOJOIN, "true"); } else { xmpp_stanza_set_attribute(conference, STANZA_ATTR_AUTOJOIN, "false"); } if (bookmark->nick) { xmpp_stanza_t *nick_st = xmpp_stanza_new(ctx); xmpp_stanza_set_name(nick_st, STANZA_NAME_NICK); xmpp_stanza_t *nick_text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(nick_text, bookmark->nick); xmpp_stanza_add_child(nick_st, nick_text); xmpp_stanza_add_child(conference, nick_st); xmpp_stanza_release(nick_text); xmpp_stanza_release(nick_st); } if (bookmark->password) { xmpp_stanza_t *password_st = xmpp_stanza_new(ctx); xmpp_stanza_set_name(password_st, STANZA_NAME_PASSWORD); xmpp_stanza_t *password_text = xmpp_stanza_new(ctx); xmpp_stanza_set_text(password_text, bookmark->password); xmpp_stanza_add_child(password_st, password_text); xmpp_stanza_add_child(conference, password_st); xmpp_stanza_release(password_text); xmpp_stanza_release(password_st); } xmpp_stanza_add_child(storage, conference); xmpp_stanza_release(conference); curr = curr->next; } xmpp_stanza_add_child(query, storage); xmpp_stanza_add_child(iq, query); xmpp_stanza_release(storage); xmpp_stanza_release(query); xmpp_send(conn, iq); xmpp_stanza_release(iq); }
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; if(!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"); //printf("intext char: %c\n", *intext); /* reply section */ if(*intext == '!') { intext++; char command[32]; int idx=0; while(idx<31 && *intext != '\0' && *intext != ' ') { command[idx] = *intext; idx++; intext++; } command[idx] = '\0'; while(*intext == ' ' && *intext != '\0') intext++; char *args = intext; if(command[0]=='\0') { replytext = strdup("you're barking mad!"); } else { // good command and args // if(!strcmp("google", command)) { char *res = google(args); replytext = malloc(snprintf(NULL, 0 , "result: %s", res)+1); sprintf(replytext, "result: %s", res); free(res); } else if(!strcmp("d20", command)) { srand(time(NULL)); int rand_int = (rand() % 20) + 1; if(rand_int == 20) { replytext = malloc(snprintf(NULL, 0, "d20: %d CRITICAL!!!", rand_int)+1); sprintf(replytext, "d20: %d CRITICAL!!!", rand_int); } else { replytext = malloc(snprintf(NULL, 0, "d20: %d", rand_int)+1); sprintf(replytext, "d20: %d", rand_int); } } else { replytext = malloc(snprintf(NULL, 0 , "command: %s args: %s", command, args)+1); sprintf(replytext, "command: %s args: %s", command, args); } } } else { if (strcmp(intext, "boob")==0) { replytext = malloc(strlen("Boobies!")+1); replytext = strcpy(replytext, "Boobies!"); } else { replytext = malloc(strlen(" to you too!") + strlen(intext) + 1); strcpy(replytext, intext); strcat(replytext, " to you too!"); } } /* end reply logic */ 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 int _handle_features_sasl(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata) { xmpp_stanza_t *bind, *session, *iq, *res, *text; char *resource; /* remove missing features handler */ xmpp_timed_handler_delete(conn, _handle_missing_features_sasl); /* we are expecting <bind/> and <session/> since this is a XMPP style connection */ bind = xmpp_stanza_get_child_by_name(stanza, "bind"); if (bind && strcmp(xmpp_stanza_get_ns(bind), XMPP_NS_BIND) == 0) { /* resource binding is required */ conn->bind_required = 1; } session = xmpp_stanza_get_child_by_name(stanza, "session"); if (session && strcmp(xmpp_stanza_get_ns(session), XMPP_NS_SESSION) == 0) { /* session establishment required */ conn->session_required = 1; } /* if bind is required, go ahead and start it */ if (conn->bind_required) { /* bind resource */ /* setup response handlers */ handler_add_id(conn, _handle_bind, "_xmpp_bind1", NULL); handler_add_timed(conn, _handle_missing_bind, BIND_TIMEOUT, NULL); /* send bind request */ iq = xmpp_stanza_new(conn->ctx); if (!iq) { disconnect_mem_error(conn); return 0; } xmpp_stanza_set_name(iq, "iq"); xmpp_stanza_set_type(iq, "set"); xmpp_stanza_set_id(iq, "_xmpp_bind1"); bind = xmpp_stanza_copy(bind); if (!bind) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return 0; } /* request a specific resource if we have one */ resource = xmpp_jid_resource(conn->ctx, conn->jid); if ((resource != NULL) && (strlen(resource) == 0)) { /* jabberd2 doesn't handle an empty resource */ xmpp_free(conn->ctx, resource); resource = NULL; } /* if we have a resource to request, do it. otherwise the server will assign us one */ if (resource) { res = xmpp_stanza_new(conn->ctx); if (!res) { xmpp_stanza_release(bind); xmpp_stanza_release(iq); disconnect_mem_error(conn); return 0; } xmpp_stanza_set_name(res, "resource"); text = xmpp_stanza_new(conn->ctx); if (!text) { xmpp_stanza_release(res); xmpp_stanza_release(bind); xmpp_stanza_release(iq); disconnect_mem_error(conn); return 0; } xmpp_stanza_set_text(text, resource); xmpp_stanza_add_child(res, text); xmpp_stanza_release(text); xmpp_stanza_add_child(bind, res); xmpp_stanza_release(res); xmpp_free(conn->ctx, resource); } xmpp_stanza_add_child(iq, bind); xmpp_stanza_release(bind); /* send bind request */ xmpp_send(conn, iq); xmpp_stanza_release(iq); } else { /* can't bind, disconnect */ xmpp_error(conn->ctx, "xmpp", "Stream features does not allow "\ "resource bind."); xmpp_disconnect(conn); } return 0; }
/* authenticate the connection * this may get called multiple times. if any auth method fails, * this will get called again until one auth method succeeds or every * method fails */ static void _auth(xmpp_conn_t * const conn) { xmpp_stanza_t *auth, *authdata, *query, *child, *iq; char *str, *authid; char *scram_init; int anonjid; /* if there is no node in conn->jid, we assume anonymous connect */ str = xmpp_jid_node(conn->ctx, conn->jid); if (str == NULL) { anonjid = 1; } else { xmpp_free(conn->ctx, str); anonjid = 0; } if (conn->tls_support) { tls_t *tls = tls_new(conn->ctx, conn->sock); /* If we couldn't init tls, it isn't there, so go on */ if (!tls) { conn->tls_support = 0; _auth(conn); return; } else { tls_free(tls); } auth = _make_starttls(conn); if (!auth) { disconnect_mem_error(conn); return; } handler_add(conn, _handle_proceedtls_default, XMPP_NS_TLS, NULL, NULL, NULL); xmpp_send(conn, auth); xmpp_stanza_release(auth); /* TLS was tried, unset flag */ conn->tls_support = 0; } else if (anonjid && conn->sasl_support & SASL_MASK_ANONYMOUS) { /* some crap here */ auth = _make_sasl_auth(conn, "ANONYMOUS"); if (!auth) { disconnect_mem_error(conn); return; } handler_add(conn, _handle_sasl_result, XMPP_NS_SASL, NULL, NULL, "ANONYMOUS"); xmpp_send(conn, auth); xmpp_stanza_release(auth); /* SASL ANONYMOUS was tried, unset flag */ conn->sasl_support &= ~SASL_MASK_ANONYMOUS; } else if (anonjid) { xmpp_error(conn->ctx, "auth", "No node in JID, and SASL ANONYMOUS unsupported."); xmpp_disconnect(conn); } else if (conn->sasl_support & SASL_MASK_SCRAMSHA1) { auth = _make_sasl_auth(conn, "SCRAM-SHA-1"); if (!auth) { disconnect_mem_error(conn); return; } /* don't free scram_init on success */ scram_init = _make_scram_sha1_init_msg(conn); if (!scram_init) { xmpp_stanza_release(auth); disconnect_mem_error(conn); return; } str = (char *)base64_encode(conn->ctx, (unsigned char *)scram_init, strlen(scram_init)); if (!str) { xmpp_free(conn->ctx, scram_init); xmpp_stanza_release(auth); disconnect_mem_error(conn); return; } authdata = xmpp_stanza_new(conn->ctx); if (!authdata) { xmpp_free(conn->ctx, str); xmpp_free(conn->ctx, scram_init); xmpp_stanza_release(auth); disconnect_mem_error(conn); return; } xmpp_stanza_set_text(authdata, str); xmpp_free(conn->ctx, str); xmpp_stanza_add_child(auth, authdata); xmpp_stanza_release(authdata); handler_add(conn, _handle_scram_sha1_challenge, XMPP_NS_SASL, NULL, NULL, (void *)scram_init); xmpp_send(conn, auth); xmpp_stanza_release(auth); /* SASL SCRAM-SHA-1 was tried, unset flag */ conn->sasl_support &= ~SASL_MASK_SCRAMSHA1; } else if (conn->sasl_support & SASL_MASK_DIGESTMD5) { auth = _make_sasl_auth(conn, "DIGEST-MD5"); if (!auth) { disconnect_mem_error(conn); return; } handler_add(conn, _handle_digestmd5_challenge, XMPP_NS_SASL, NULL, NULL, NULL); xmpp_send(conn, auth); xmpp_stanza_release(auth); /* SASL DIGEST-MD5 was tried, unset flag */ conn->sasl_support &= ~SASL_MASK_DIGESTMD5; } else if (conn->sasl_support & SASL_MASK_PLAIN) { auth = _make_sasl_auth(conn, "PLAIN"); if (!auth) { disconnect_mem_error(conn); return; } authdata = xmpp_stanza_new(conn->ctx); if (!authdata) { disconnect_mem_error(conn); return; } authid = _get_authid(conn); if (!authid) { disconnect_mem_error(conn); return; } str = sasl_plain(conn->ctx, authid, conn->pass); if (!str) { disconnect_mem_error(conn); return; } xmpp_stanza_set_text(authdata, str); xmpp_free(conn->ctx, str); xmpp_free(conn->ctx, authid); xmpp_stanza_add_child(auth, authdata); xmpp_stanza_release(authdata); handler_add(conn, _handle_sasl_result, XMPP_NS_SASL, NULL, NULL, "PLAIN"); xmpp_send(conn, auth); xmpp_stanza_release(auth); /* SASL PLAIN was tried */ conn->sasl_support &= ~SASL_MASK_PLAIN; } else if (conn->type == XMPP_CLIENT) { /* legacy client authentication */ iq = xmpp_stanza_new(conn->ctx); if (!iq) { disconnect_mem_error(conn); return; } xmpp_stanza_set_name(iq, "iq"); xmpp_stanza_set_type(iq, "set"); xmpp_stanza_set_id(iq, "_xmpp_auth1"); query = xmpp_stanza_new(conn->ctx); if (!query) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(query, "query"); xmpp_stanza_set_ns(query, XMPP_NS_AUTH); xmpp_stanza_add_child(iq, query); xmpp_stanza_release(query); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "username"); xmpp_stanza_add_child(query, child); xmpp_stanza_release(child); authdata = xmpp_stanza_new(conn->ctx); if (!authdata) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } str = xmpp_jid_node(conn->ctx, conn->jid); xmpp_stanza_set_text(authdata, str); xmpp_free(conn->ctx, str); xmpp_stanza_add_child(child, authdata); xmpp_stanza_release(authdata); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "password"); xmpp_stanza_add_child(query, child); xmpp_stanza_release(child); authdata = xmpp_stanza_new(conn->ctx); if (!authdata) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_text(authdata, conn->pass); xmpp_stanza_add_child(child, authdata); xmpp_stanza_release(authdata); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "resource"); xmpp_stanza_add_child(query, child); xmpp_stanza_release(child); authdata = xmpp_stanza_new(conn->ctx); if (!authdata) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } str = xmpp_jid_resource(conn->ctx, conn->jid); if (str) { xmpp_stanza_set_text(authdata, str); xmpp_free(conn->ctx, str); } else { xmpp_stanza_release(authdata); xmpp_stanza_release(iq); xmpp_error(conn->ctx, "auth", "Cannot authenticate without resource"); xmpp_disconnect(conn); return; } xmpp_stanza_add_child(child, authdata); xmpp_stanza_release(authdata); handler_add_id(conn, _handle_legacy, "_xmpp_auth1", NULL); handler_add_timed(conn, _handle_missing_legacy, LEGACY_TIMEOUT, NULL); xmpp_send(conn, iq); xmpp_stanza_release(iq); } }
/* handle the challenge phase of SCRAM-SHA-1 auth */ static int _handle_scram_sha1_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; char *challenge; char *scram_init = (char *)userdata; name = xmpp_stanza_get_name(stanza); xmpp_debug(conn->ctx, "xmpp", "handle SCRAM-SHA-1 (challenge) called for %s", name); if (strcmp(name, "challenge") == 0) { text = xmpp_stanza_get_text(stanza); if (!text) goto err; challenge = (char *)base64_decode(conn->ctx, text, strlen(text)); xmpp_free(conn->ctx, text); if (!challenge) goto err; response = sasl_scram_sha1(conn->ctx, challenge, scram_init, conn->jid, conn->pass); xmpp_free(conn->ctx, challenge); if (!response) goto err; auth = xmpp_stanza_new(conn->ctx); if (!auth) goto err_free_response; xmpp_stanza_set_name(auth, "response"); xmpp_stanza_set_ns(auth, XMPP_NS_SASL); authdata = xmpp_stanza_new(conn->ctx); if (!authdata) goto err_release_auth; xmpp_stanza_set_text(authdata, response); xmpp_free(conn->ctx, response); xmpp_stanza_add_child(auth, authdata); xmpp_stanza_release(authdata); xmpp_send(conn, auth); xmpp_stanza_release(auth); } else { xmpp_free(conn->ctx, scram_init); return _handle_sasl_result(conn, stanza, "SCRAM-SHA-1"); } return 1; err_release_auth: xmpp_stanza_release(auth); err_free_response: xmpp_free(conn->ctx, response); err: xmpp_free(conn->ctx, scram_init); disconnect_mem_error(conn); return 0; }
/** registration at connections * * @param conn a Strophe connection object */ static void _register(xmpp_conn_t * const conn) { char *str; xmpp_stanza_t *iq, *q, *child, *regdata; iq = xmpp_stanza_new(conn->ctx); if (!iq) { disconnect_mem_error(conn); return; } xmpp_stanza_set_name(iq, "iq"); xmpp_stanza_set_type(iq, "set"); xmpp_stanza_set_id(iq, "_xmpp_reg1"); q = xmpp_stanza_new(conn->ctx); if (!q) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(q, "query"); xmpp_stanza_set_ns(q, XMPP_NS_REGISTER); xmpp_stanza_add_child(iq, q); xmpp_stanza_release(q); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "registered"); xmpp_stanza_add_child(q, child); xmpp_stanza_release(child); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "username"); xmpp_stanza_add_child(q, child); xmpp_stanza_release(child); regdata = xmpp_stanza_new(conn->ctx); if (!regdata) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } str = xmpp_jid_node(conn->ctx, conn->jid); xmpp_stanza_set_text(regdata, str); xmpp_free(conn->ctx, str); xmpp_stanza_add_child(child, regdata); xmpp_stanza_release(regdata); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "password"); xmpp_stanza_add_child(q, child); xmpp_stanza_release(child); regdata = xmpp_stanza_new(conn->ctx); if (!regdata) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_text(regdata, conn->pass); xmpp_stanza_add_child(child, regdata); xmpp_stanza_release(regdata); child = xmpp_stanza_new(conn->ctx); if (!child) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } xmpp_stanza_set_name(child, "email"); xmpp_stanza_add_child(q, child); xmpp_stanza_release(child); regdata = xmpp_stanza_new(conn->ctx); if (!regdata) { xmpp_stanza_release(iq); disconnect_mem_error(conn); return; } str = xmpp_jid_node(conn->ctx, conn->jid); xmpp_stanza_set_text(regdata, str); xmpp_free(conn->ctx, str); xmpp_stanza_add_child(child, regdata); xmpp_stanza_release(regdata); handler_add_id(conn, _handle_register, "_xmpp_reg1", NULL); handler_add_timed(conn, _handle_missing_register, LAZY_REGISTRATION_TIMEOUT, NULL); xmpp_send(conn, iq); xmpp_stanza_release(iq); }
/** Create an <stream:error/> stanza object with given type and error text. * The error text is optional and may be NULL. * * @param ctx a Strophe context object * @param type enum of xmpp_error_type_t * @param text content of a 'text' * * @return a new Strophe stanza object * * @todo Handle errors in this function * * @ingroup Stanza */ xmpp_stanza_t *xmpp_error_new(xmpp_ctx_t *ctx, xmpp_error_type_t const type, const char * const text) { xmpp_stanza_t *error = _stanza_new_with_attrs(ctx, "stream:error", NULL, NULL, NULL); xmpp_stanza_t *error_type = xmpp_stanza_new(ctx); switch(type) { case XMPP_SE_BAD_FORMAT: xmpp_stanza_set_name(error_type, "bad-format"); break; case XMPP_SE_BAD_NS_PREFIX: xmpp_stanza_set_name(error_type, "bad-namespace-prefix"); break; case XMPP_SE_CONFLICT: xmpp_stanza_set_name(error_type, "conflict"); break; case XMPP_SE_CONN_TIMEOUT: xmpp_stanza_set_name(error_type, "connection-timeout"); break; case XMPP_SE_HOST_GONE: xmpp_stanza_set_name(error_type, "host-gone"); break; case XMPP_SE_HOST_UNKNOWN: xmpp_stanza_set_name(error_type, "host-unknown"); break; case XMPP_SE_IMPROPER_ADDR: xmpp_stanza_set_name(error_type, "improper-addressing"); break; case XMPP_SE_INTERNAL_SERVER_ERROR: xmpp_stanza_set_name(error_type, "internal-server-error"); break; case XMPP_SE_INVALID_FROM: xmpp_stanza_set_name(error_type, "invalid-from"); break; case XMPP_SE_INVALID_ID: xmpp_stanza_set_name(error_type, "invalid-id"); break; case XMPP_SE_INVALID_NS: xmpp_stanza_set_name(error_type, "invalid-namespace"); break; case XMPP_SE_INVALID_XML: xmpp_stanza_set_name(error_type, "invalid-xml"); break; case XMPP_SE_NOT_AUTHORIZED: xmpp_stanza_set_name(error_type, "not-authorized"); break; case XMPP_SE_POLICY_VIOLATION: xmpp_stanza_set_name(error_type, "policy-violation"); break; case XMPP_SE_REMOTE_CONN_FAILED: xmpp_stanza_set_name(error_type, "remote-connection-failed"); break; case XMPP_SE_RESOURCE_CONSTRAINT: xmpp_stanza_set_name(error_type, "resource-constraint"); break; case XMPP_SE_RESTRICTED_XML: xmpp_stanza_set_name(error_type, "restricted-xml"); break; case XMPP_SE_SEE_OTHER_HOST: xmpp_stanza_set_name(error_type, "see-other-host"); break; case XMPP_SE_SYSTEM_SHUTDOWN: xmpp_stanza_set_name(error_type, "system-shutdown"); break; case XMPP_SE_UNDEFINED_CONDITION: xmpp_stanza_set_name(error_type, "undefined-condition"); break; case XMPP_SE_UNSUPPORTED_ENCODING: xmpp_stanza_set_name(error_type, "unsupported-encoding"); break; case XMPP_SE_UNSUPPORTED_STANZA_TYPE: xmpp_stanza_set_name(error_type, "unsupported-stanza-type"); break; case XMPP_SE_UNSUPPORTED_VERSION: xmpp_stanza_set_name(error_type, "unsupported-version"); break; case XMPP_SE_XML_NOT_WELL_FORMED: xmpp_stanza_set_name(error_type, "xml-not-well-formed"); break; default: xmpp_stanza_set_name(error_type, "internal-server-error"); break; } xmpp_stanza_set_ns(error_type, XMPP_NS_STREAMS_IETF); xmpp_stanza_add_child(error, error_type); xmpp_stanza_release(error_type); if (text) { xmpp_stanza_t *error_text = xmpp_stanza_new(ctx); xmpp_stanza_t *content = xmpp_stanza_new(ctx); xmpp_stanza_set_name(error_text, "text"); xmpp_stanza_set_ns(error_text, XMPP_NS_STREAMS_IETF); xmpp_stanza_set_text(content, text); xmpp_stanza_add_child(error_text, content); xmpp_stanza_release(content); xmpp_stanza_add_child(error, error_text); xmpp_stanza_release(error_text); } return error; }
/** * Handles the service */ xmpp_stanza_t * _HandleServiceRequest(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata) { xmpp_stanza_t *reply; xmpp_stanza_t *wd, *nodetext; xmpp_ctx_t *ctx = (xmpp_ctx_t*) userdata; sdvp_method_t methodType = SDVP_METHOD_UNDEFINED; sdvp_from_t* from; char *method; sdvp_reply_params_t* sdvpReplyParams = NULL; void* replyParams; void* paramStructure = NULL; char strbuf[20]; static unsigned int watchdog = 1; //HJP: Hvorfor oprette reply her, når den næsten altid bliver overskrevet? reply = xmpp_stanza_new(ctx); xmpp_stanza_set_name(reply, "iq"); from = _CreateFrom(xmpp_stanza_get_attribute(stanza, "from"), "TODO", "TODO"); syslog(LOG_DEBUG, "Received a RPC Method call from %s\n", from->name); method = _GetRpcMethode(stanza); methodType = _GetDefinedMetodeFromMethod(method); syslog(LOG_DEBUG, "XML-RPC method name %s\n", method); free(method); if (methodType == SDVP_METHOD_UNDEFINED) { syslog(LOG_DEBUG, "Undefined method type\n"); sdvp_InitiateReplyParameters(&sdvpReplyParams, 1); sdvpReplyParams->params[0].strValue = strdup("ERROR: Method is undefined. Methods are CasE SentItive.\n"); sdvpReplyParams->params[0].type = IEC_VISIBLE_STRING; //HJP: Jeg releaser reply her, det ville være smartere kun at oprette den når nødvendigt... xmpp_stanza_release(reply); reply = _CreateReply(ctx, methodType, sdvpReplyParams); xmpp_stanza_set_type(reply, "error"); sdvp_FreeReplyParameters(sdvpReplyParams); } else if (methodType == LIAB_WATCHDOG) { xmpp_stanza_release(reply); reply = xmpp_stanza_new(ctx); xmpp_stanza_set_name(reply, "query"); xmpp_stanza_set_ns(reply, "jabber:iq:rpc"); wd = xmpp_stanza_new(ctx); xmpp_stanza_set_name(wd, "watchdog"); xmpp_stanza_add_child(reply, wd); xmpp_stanza_release(wd); nodetext = xmpp_stanza_new(ctx); sprintf(strbuf, "%u", watchdog++); xmpp_stanza_set_text(nodetext, strbuf); xmpp_stanza_add_child(wd, nodetext); xmpp_stanza_release(nodetext); } else{ if (_CallbackIsRegistered(methodType)) { paramStructure = _CreateParamStructureFromParameters(methodType, stanza); replyParams = _CallTheRightCallback(methodType, paramStructure); _FreeParamStructure(methodType,paramStructure); xmpp_stanza_release(reply); reply = _CreateReply(ctx, methodType, replyParams); sdvp_FreeCallbackReply(methodType, replyParams); sdvp_FreeReplyParameters(sdvpReplyParams); } else { // TODO: Send a error with method not implemented or alike } } _FreeFrom(from); return reply; }