C++ xmpp_stanza_new函数代码示例

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++;
}