自学教程：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++;}

static void _start_element(void *userdata,                            const xmlChar *name, const xmlChar *prefix,                           const xmlChar *uri, int nnamespaces,                           const xmlChar **namespaces, int nattrs,                           int ndefaulted, const xmlChar **attrs){    parser_t *parser = (parser_t *)userdata;    xmpp_stanza_t *child;    char **cbattrs;    if (parser->depth == 0) {        /* notify the owner */        if (parser->startcb)            cbattrs = _convert_attrs(parser, nattrs, attrs);            parser->startcb((char *)name, cbattrs,                             parser->userdata);            _free_cbattrs(parser, cbattrs);    } else {	/* build stanzas at depth 1 */	if (!parser->stanza && parser->depth != 1) {	    /* something terrible happened */	    /* FIXME: we should probably trigger a disconnect */	    xmpp_error(parser->ctx, "parser", "oops, where did our stanza go?");	} else if (!parser->stanza) {	    /* starting a new toplevel stanza */	    parser->stanza = xmpp_stanza_new(parser->ctx);	    if (!parser->stanza) {		/* FIXME: can't allocate, disconnect */	    }	    xmpp_stanza_set_name(parser->stanza, (char *)name);	    _set_attributes(parser->stanza, nattrs, attrs);	    if (uri)		xmpp_stanza_set_ns(parser->stanza, (char *)uri);	} else {	    /* starting a child of conn->stanza */	    child = xmpp_stanza_new(parser->ctx);	    if (!child) {		/* FIXME: can't allocate, disconnect */	    }	    xmpp_stanza_set_name(child, (char *)name);	    _set_attributes(child, nattrs, attrs);	    if (uri)		xmpp_stanza_set_ns(child, (char *)uri);	    /* add child to parent */	    xmpp_stanza_add_child(parser->stanza, child);	    	    /* the child is owned by the toplevel stanza now */	    xmpp_stanza_release(child);	    /* make child the current stanza */	    parser->stanza = child;	}    }    parser->depth++;}

char*message_send_chat_pgp(const char *const barejid, const char *const msg){    xmpp_conn_t * const conn = connection_get_conn();    xmpp_ctx_t * const ctx = connection_get_ctx();    char *state = _session_state(barejid);    char *jid = _session_jid(barejid);    char *id = create_unique_id("msg");    xmpp_stanza_t *message = NULL;#ifdef HAVE_LIBGPGME    char *account_name = jabber_get_account_name();    ProfAccount *account = accounts_get_account(account_name);    if (account->pgp_keyid) {        Jid *jidp = jid_create(jid);        char *encrypted = p_gpg_encrypt(jidp->barejid, msg);        if (encrypted) {            message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, "This message is encrypted.");            xmpp_stanza_t *x = xmpp_stanza_new(ctx);            xmpp_stanza_set_name(x, STANZA_NAME_X);            xmpp_stanza_set_ns(x, STANZA_NS_ENCRYPTED);            xmpp_stanza_t *enc_st = xmpp_stanza_new(ctx);            xmpp_stanza_set_text(enc_st, encrypted);            xmpp_stanza_add_child(x, enc_st);            xmpp_stanza_release(enc_st);            xmpp_stanza_add_child(message, x);            xmpp_stanza_release(x);            free(encrypted);        } else {            message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);        }        jid_destroy(jidp);    } else {        message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);    }    account_free(account);#else    message = stanza_create_message(ctx, id, jid, STANZA_TYPE_CHAT, msg);#endif    free(jid);    if (state) {        stanza_attach_state(ctx, message, state);    }    stanza_attach_carbons_private(ctx, message);    if (prefs_get_boolean(PREF_RECEIPTS_REQUEST)) {        stanza_attach_receipt_request(ctx, message);    }    xmpp_send(conn, message);    xmpp_stanza_release(message);    return id;}

static int alarmqueue_handler(xmpp_conn_t * const conn, void * const userdata){    conflate_handle_t *handle = (conflate_handle_t*) userdata;    alarm_t alarm;    const char* myjid = xmpp_conn_get_bound_jid(conn);    char id[262];    char open[2] = { 0, 0 };    char amsg[256];    char body[1500];    char num[255];    while (handle->alarms->size > 0)        {            alarm = get_alarm(handle->alarms);            open[0] = alarm.open ? '1' : '2';            snprintf(amsg, sizeof(amsg), "%s", alarm.msg);            /* if we got a legitimate alarm, send off alert */            if(alarm.open == 1)                {                    snprintf(id, sizeof(id), "_alarm%d", alarm.num);                    //handler_add_id(conn, alarm_response_handler, id, handle);                    //handler_add_timed(conn, alarm_missing_handler, 120000, handle);                    xmpp_stanza_t* msg = xmpp_stanza_new(handle->ctx);                    assert(msg);                    xmpp_stanza_set_name(msg, "message");                    //xmpp_stanza_set_type(iq, "set");                    xmpp_stanza_set_id(msg, id);                    //xmpp_stanza_set_attribute(iq, "to", xmpp_stanza_get_attribute(stanza, "from"));                    /* TODO: This needs to have a config on where to report to */                    xmpp_stanza_set_attribute(msg, "to", "[email
C++ xmpp_stanza_set_attribute函数代码示例
C++ xmpp_stanza_get_text函数代码示例