自学教程：C++ xmpp_stanza_get_text函数代码示例

static int zkmuc_group_msg_handler(xmpp_ua_t *ua, xmpp_stanza_t *stanza, void *userdata){	char *type = xmpp_stanza_get_type(stanza);	if (type && !strcmp(type, "groupchat"))	{		zkmuc_ctx_t *ctx = (zkmuc_ctx_t *)userdata;	//	char *from = xmpp_stanza_get_attribute(stanza, "from");		xmpp_stanza_t *stanza_body = xmpp_stanza_get_child_by_name(stanza, "zonekey");		if (!stanza_body)		{			return 0;		}		xmpp_stanza_t *stanza_jid = xmpp_stanza_get_child_by_name(stanza_body, "jid");		char *jid_value = xmpp_stanza_get_text(stanza_jid);		char *text = xmpp_stanza_get_text(stanza_body);		if (text && ctx->room_cbs.on_broadcast_message)		{			ctx->room_cbs.on_broadcast_message(ctx, /*from*/jid_value, text, ctx->room_data);		}		xmpp_free(_xmpp_ctx, jid_value);		xmpp_free(_xmpp_ctx, text);		return 1;	}		return 0;}

static gboolean_handle_carbons(xmpp_stanza_t *const stanza){    xmpp_stanza_t *carbons = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_CARBONS);    if (!carbons) {        return FALSE;    }    char *name = xmpp_stanza_get_name(carbons);    if ((g_strcmp0(name, "received") == 0) || (g_strcmp0(name, "sent")) == 0) {        xmpp_stanza_t *forwarded = xmpp_stanza_get_child_by_ns(carbons, STANZA_NS_FORWARD);        xmpp_stanza_t *message = xmpp_stanza_get_child_by_name(forwarded, STANZA_NAME_MESSAGE);        xmpp_ctx_t *ctx = connection_get_ctx();        gchar *to = xmpp_stanza_get_attribute(message, STANZA_ATTR_TO);        gchar *from = xmpp_stanza_get_attribute(message, STANZA_ATTR_FROM);        // happens when receive a carbon of a self sent message        if (!to) to = from;        Jid *jid_from = jid_create(from);        Jid *jid_to = jid_create(to);        Jid *my_jid = jid_create(jabber_get_fulljid());        // check for and deal with message        xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(message, STANZA_NAME_BODY);        if (body) {            char *message_txt = xmpp_stanza_get_text(body);            if (message_txt) {                // check for pgp encrypted message                char *enc_message = NULL;                xmpp_stanza_t *x = xmpp_stanza_get_child_by_ns(message, STANZA_NS_ENCRYPTED);                if (x) {                    enc_message = xmpp_stanza_get_text(x);                }                // if we are the recipient, treat as standard incoming message                if(g_strcmp0(my_jid->barejid, jid_to->barejid) == 0){                    sv_ev_incoming_carbon(jid_from->barejid, jid_from->resourcepart, message_txt, enc_message);                // else treat as a sent message                } else {                    sv_ev_outgoing_carbon(jid_to->barejid, message_txt, enc_message);                }                xmpp_free(ctx, message_txt);                xmpp_free(ctx, enc_message);            }        }        jid_destroy(jid_from);        jid_destroy(jid_to);        jid_destroy(my_jid);        return TRUE;    }    return FALSE;}

static int_version_result_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza,    void * const userdata){    char *id = xmpp_stanza_get_id(stanza);    if (id != NULL) {        log_debug("IQ version result handler fired, id: %s.", id);    } else {        log_debug("IQ version result handler fired.");    }    const char *jid = xmpp_stanza_get_attribute(stanza, "from");    xmpp_stanza_t *query = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);    if (query == NULL) {        return 1;    }    char *ns = xmpp_stanza_get_ns(query);    if (g_strcmp0(ns, STANZA_NS_VERSION) != 0) {        return 1;    }    char *name_str = NULL;    char *version_str = NULL;    char *os_str = NULL;    xmpp_stanza_t *name = xmpp_stanza_get_child_by_name(query, "name");    xmpp_stanza_t *version = xmpp_stanza_get_child_by_name(query, "version");    xmpp_stanza_t *os = xmpp_stanza_get_child_by_name(query, "os");    if (name != NULL) {        name_str = xmpp_stanza_get_text(name);    }    if (version != NULL) {        version_str = xmpp_stanza_get_text(version);    }    if (os != NULL) {        os_str = xmpp_stanza_get_text(os);    }    PContact contact;    Jid *jidp = jid_create(jid);    if (muc_room_is_active(jidp->barejid)) {        contact = muc_get_participant(jidp->barejid, jidp->resourcepart);    } else {        contact = roster_get_contact(jidp->barejid);    }    Resource *resource = p_contact_get_resource(contact, jidp->resourcepart);    const char *presence = string_from_resource_presence(resource->presence);    handle_software_version_result(jid, presence, name_str, version_str, os_str);    jid_destroy(jidp);    return 1;}

/** * Creates the parameter structure for the Read callback * @param[in] params This stanza is the params element in the XML-RPC format * @return The structure or null if an error were found. */static sdvp_ReadParam_t* _CreateReadParam (xmpp_stanza_t * params) {    const int expectedParams = 1;    sdvp_ReadParam_t* rv = NULL;    int i = 0;    bool elementNotFund = false;    xmpp_stanza_t *structure = NULL, *member = NULL, *value = NULL,            *type = NULL, *name = NULL;    char *text, *textname;    structure = _GetRpcStructureElementFromParams(params);    if (structure == NULL ) {        return NULL ;    }    rv = _InitiateReadParameters();    for (member = xmpp_stanza_get_children(structure);            member && !elementNotFund && (i < expectedParams); member =                    xmpp_stanza_get_next(member)) {        if (xmpp_stanza_get_name(member)                && strcmp(xmpp_stanza_get_name(member), "member") == 0) {            if (!(name = xmpp_stanza_get_child_by_name(member, "name"))) {                _FreeReadParameters(rv);                // TODO: Signal error back                return NULL ;            }            name = xmpp_stanza_get_children(name);			textname = xmpp_stanza_get_text(name);            if (strcmp(textname, "VariableAccessSpecification") == 0) {                if (!(value = xmpp_stanza_get_child_by_name(member, "value"))) {                    _FreeReadParameters(rv);                    // TODO: Signal error back					free(textname);                    return NULL ;                }                if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {                    if (xmpp_stanza_get_children(type)) {                        text = xmpp_stanza_get_text(type);                        rv->reference = text;                    } else {                        rv->reference = NULL;                    }                } else {                    elementNotFund = true;                }            } else {//                if (!type) {//                    _FreeReadParameters(rv);//                    return NULL ;//                }            }			free(textname);        }    }    return rv;}

static int_muc_user_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata){    xmpp_ctx_t *ctx = connection_get_ctx();    xmpp_stanza_t *xns_muc_user = xmpp_stanza_get_child_by_ns(stanza, STANZA_NS_MUC_USER);    char *room = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);    if (!room) {        log_warning("Message received with no from attribute, ignoring");        return 1;    }    // XEP-0045    xmpp_stanza_t *invite = xmpp_stanza_get_child_by_name(xns_muc_user, STANZA_NAME_INVITE);    if (!invite) {        return 1;    }    char *invitor_jid = xmpp_stanza_get_attribute(invite, STANZA_ATTR_FROM);    if (!invitor_jid) {        log_warning("Chat room invite received with no from attribute");        return 1;    }    Jid *jidp = jid_create(invitor_jid);    if (!jidp) {        return 1;    }    char *invitor = jidp->barejid;    char *reason = NULL;    xmpp_stanza_t *reason_st = xmpp_stanza_get_child_by_name(invite, STANZA_NAME_REASON);    if (reason_st) {        reason = xmpp_stanza_get_text(reason_st);    }    char *password = NULL;    xmpp_stanza_t *password_st = xmpp_stanza_get_child_by_name(xns_muc_user, STANZA_NAME_PASSWORD);    if (password_st) {        password = xmpp_stanza_get_text(password_st);    }    sv_ev_room_invite(INVITE_MEDIATED, invitor, room, reason, password);    jid_destroy(jidp);    if (reason) {        xmpp_free(ctx, reason);    }    if (password) {        xmpp_free(ctx, password);    }    return 1;}

static void files_read(xmpp_stanza_t *stanza) {  int rc;  rc = pthread_mutex_lock(&mutex);  wsyserr(rc != 0, "pthread_mutex_lock");  char *text = xmpp_stanza_get_text(stanza);  if(text == NULL) {    werr("xmpp_stanza_get_text returned NULL (%s, error %s)", xmpp_stanza_get_attribute(stanza, "path"), xmpp_stanza_get_attribute(stanza, "error"));    read_data = strdup ("");  }  else  {    int dec_size = strlen(text) * 3 / 4 + 1;    uint8_t *dec_text = (uint8_t *)calloc(dec_size, sizeof(uint8_t));    rc = base64_decode(dec_text, text, dec_size);    wfatal(rc < 0, "base64_decode");    if (read_data != NULL) {      free(read_data);    }    read_data = strdup((char *)dec_text);    wsyserr(read_data == NULL, "strdup");    free(text);    free(dec_text);  }  signal_read = true;  rc = pthread_cond_signal(&cond);  wsyserr(rc != 0, "pthread_cond_signal");  rc = pthread_mutex_unlock(&mutex);  wsyserr(rc != 0, "pthread_mutex_unlock");}

static int_captcha_handler(xmpp_conn_t *const conn, xmpp_stanza_t *const stanza, void *const userdata){    xmpp_ctx_t *ctx = connection_get_ctx();    char *from = xmpp_stanza_get_attribute(stanza, STANZA_ATTR_FROM);    if (!from) {        log_warning("Message received with no from attribute, ignoring");        return 1;    }    // XEP-0158    xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);    if (!body) {        return 1;    }    char *message = xmpp_stanza_get_text(body);    if (!message) {        return 1;    }    sv_ev_room_broadcast(from, message);    xmpp_free(ctx, message);    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;}

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 XMPP_IBB_Data_Process(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata){    char* intext;    unsigned char *result;    xmpp_ctx_t *ctx = (xmpp_ctx_t*)userdata;    char *szSid, szSeq;	//    xmpp_ibb_session_t* ibb_ssn;        szSid = /	xmpp_stanza_get_attribute(xmpp_stanza_get_child_by_name(stanza, "data"), "sid");     szSeq = / 	xmpp_stanza_get_attribute(xmpp_stanza_get_child_by_name(stanza, "data"), "seq");     intext = xmpp_stanza_get_text(xmpp_stanza_get_child_by_name(stanza, "data"));    printf("[Sid=%s][Seq=%s][Raw Data=%s]/n", szSid, szSeq, intext);    result = base64_decode(ctx, intext, strlen(intext));    printf("Decode result=%s/n", result);    gRecv = malloc(strlen(result)+1);    strcpy(gRecv, result);        if(gStanza == NULL)        gStanza = xmpp_stanza_copy(stanza);#if 0  //data queue function has not been verified.  	                ibb_ssn = XMPP_Get_IBB_Session_Handle(szSid);    if( ibb_ssn == NULL)		    {        printf("Opened Session ID not found/n"); 	goto error;    }    xmpp_ibb_data_t* ibb_data_new = malloc(sizeof(xmpp_ibb_data_t));    ibb_data_new->seq_num = malloc(strlen(szSeq)+1);    ibb_data_new->recv_data =  malloc(strlen(result)+1);        strcpy(ibb_data_new->seq_num, szSeq);       strcpy(ibb_data_new->recv_data, result);       XMPP_IBB_Add_Session_Data_Queue(ibb_ssn, ibb_data_new);#endiferror:    xmpp_free(ctx, szSid);    xmpp_free(ctx, szSeq);    xmpp_free(ctx, intext);    xmpp_free(ctx, result);    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;}

int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata){    char *intext, *decoded_intext;    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"));    decoded_intext = from_base64(intext, strlen(intext));    fwrite((const void*)decoded_intext, 1, strlen(intext), stdout);    free(decoded_intext);    return 1;}

/** Get text from <body/> child element. *  This function returns new allocated string. The caller is responsible *  for freeing this string with xmpp_free(). * *  @param msg well formed <message/> stanza * *  @return allocated string or NULL on failure (no <body/> element or *      memory allocation error) * *  @ingroup Stanza */char *xmpp_message_get_body(xmpp_stanza_t *msg){    xmpp_stanza_t *body;    const char *name;    char *text = NULL;    name = xmpp_stanza_get_name(msg);    body = xmpp_stanza_get_child_by_name(msg, "body");    if (name && strcmp(name, "message") == 0 && body) {        text = xmpp_stanza_get_text(body);    }    return text;}

static int _zkmuc_on_rcv_invite(xmpp_ua_t *ua, xmpp_stanza_t *stanza, void *userdata){	char *ns = xmpp_stanza_get_ns(stanza);	if (ns != NULL && !strcmp(ns, XMPP_NS_CONFERECE))	{		zkmuc_ctx_t *ctx = (zkmuc_ctx_t *)userdata;		char *from = xmpp_stanza_get_attribute(stanza, "from");		xmpp_stanza_t *stanza_body = xmpp_stanza_get_child_by_name(stanza, "body");		if (stanza_body)		{			char *room_id = xmpp_stanza_get_text(stanza_body);			ctx->invite_cb(ctx, from, room_id, ctx->invite_data);		}		return 1;	}	return 0;}

static char*_get_property(xmpp_stanza_t *const stanza, const char *const property){    char *result = NULL;    xmpp_ctx_t *ctx = connection_get_ctx();    xmpp_stanza_t *child = xmpp_stanza_get_child_by_name(stanza, property);    if (child) {        char *child_text = xmpp_stanza_get_text(child);        if (child_text) {            result = strdup(child_text);            xmpp_free(ctx, child_text);        }    }    return result;}

static int _handle_features(xmpp_conn_t * const conn,			    xmpp_stanza_t * const stanza,			    void * const userdata){    xmpp_stanza_t *child, *mech;    char *text;    /* remove the handler that detects missing stream:features */    xmpp_timed_handler_delete(conn, _handle_missing_features);    /* check for TLS */    if (!conn->secured) {        if (!conn->tls_disabled) {            child = xmpp_stanza_get_child_by_name(stanza, "starttls");            if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_TLS) == 0))                conn->tls_support = 1;        } else {            conn->tls_support = 0;        }    }    /* check for SASL */    child = xmpp_stanza_get_child_by_name(stanza, "mechanisms");    if (child && (strcmp(xmpp_stanza_get_ns(child), XMPP_NS_SASL) == 0)) {	for (mech = xmpp_stanza_get_children(child); mech;	     mech = xmpp_stanza_get_next(mech)) {	    if (xmpp_stanza_get_name(mech) && strcmp(xmpp_stanza_get_name(mech), "mechanism") == 0) {		text = xmpp_stanza_get_text(mech);		if (strcasecmp(text, "PLAIN") == 0)		    conn->sasl_support |= SASL_MASK_PLAIN;		else if (strcasecmp(text, "DIGEST-MD5") == 0)		    conn->sasl_support |= SASL_MASK_DIGESTMD5;                else if (strcasecmp(text, "SCRAM-SHA-1") == 0)                    conn->sasl_support |= SASL_MASK_SCRAMSHA1;		else if (strcasecmp(text, "ANONYMOUS") == 0)		    conn->sasl_support |= SASL_MASK_ANONYMOUS;		xmpp_free(conn->ctx, text);	    }	}    }    _auth(conn);    return 0;}

static int _zkmse_receive_rsp(xmpp_ua_t *ua, xmpp_stanza_t *stanza, void *userdata){	char *type = xmpp_stanza_get_type(stanza);	if (!type || strcmp(type, "chat"))		return 0;	char *from = xmpp_stanza_get_attribute(stanza, "from");	if (!from)		return 0;	xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(stanza, "body");	if (!body)		return 0;	char *str_body = xmpp_stanza_get_text(body);	if (!str_body)		return 0;	char cmd_type[16];	char result[128];	char *option = (char *)malloc(strlen(str_body));	int msg_id;	int rc = sscanf(str_body, "%15[^|]|%d|%*[^|]|%127[^|]|%[^/0]",  cmd_type, &msg_id, result, option);	if (rc < 4)	{		free(option);		return 0;	}	if (!strcmp(cmd_type, "AckCmd"))	{		WaitForSingleObject(ua->mutex_4_ua, INFINITE);		mse_cmd_map::iterator iter = ua->mse_map.find(msg_id);		if (iter == ua->mse_map.end())		{			free(option);			ReleaseMutex(ua->mutex_4_ua);			return 0;		}		mse_cmd_data data = iter->second;		data.cb(ua, from, result, option, data.userdata);		free(option);		ReleaseMutex(ua->mutex_4_ua);		return 1;	}	free(option);	return 0;}

GSList *_get_groups_from_item(xmpp_stanza_t *item){    GSList *groups = NULL;    xmpp_stanza_t *group_element = xmpp_stanza_get_children(item);    while (group_element) {        if (strcmp(xmpp_stanza_get_name(group_element), STANZA_NAME_GROUP) == 0) {            char *groupname = xmpp_stanza_get_text(group_element);            if (groupname) {                groups = g_slist_append(groups, groupname);            }        }        group_element = xmpp_stanza_get_next(group_element);    }    return groups;}

//TODO: Create structure for holding the rosterstatic int _HandleRosterReply(xmpp_conn_t * const conn,		xmpp_stanza_t * const stanza, void * const userdata) {	xmpp_stanza_t *query, *item, *group;	char *type, *name, *jid, *sub, groups[200], *groupName;	char *g;	int r_count = 0;	sdvpIdleCounter = 0;	sdvpPingsSent = 0;	type = xmpp_stanza_get_type(stanza);	if (strcmp(type, "error") == 0) {		syslog(LOG_WARNING, "ERROR: query failed/n");	} else {		query = xmpp_stanza_get_child_by_name(stanza, "query");		syslog(LOG_INFO, "Roster (Only the first group is shown!):/n----------/n");		for (item = xmpp_stanza_get_children(query); item; item =				xmpp_stanza_get_next(item)) {			name = xmpp_stanza_get_attribute(item, "name");			jid = xmpp_stanza_get_attribute(item, "jid");			sub = xmpp_stanza_get_attribute(item, "subscription");			// Get groups			//			strcpy(groups, "-");			for (group = xmpp_stanza_get_children(item); group; group =					xmpp_stanza_get_next(group)) {				groupName = xmpp_stanza_get_name(group);				if (strcmp(groupName, "group") == 0) {				    g = xmpp_stanza_get_text(group);					strcpy(groups, g);					free(g);				}			}			syslog(LOG_INFO, "#%d/tName=%s/n/tJID=%s/n/tsubscription=%s/n/tGroups=%s/n/n",					r_count, name, jid, sub, groups);			r_count++;		}		syslog(LOG_INFO, "----------/n");	}	return 1;}

static int _chat_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata){    xmppdata_t xdata;    char *intext;    xmppchat_userdata_t *udata = (xmppchat_userdata_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);    xdata.from = xmpp_stanza_get_attribute(stanza, "from");    xdata.data = (void *) intext;    if (udata != NULL && udata->handler != NULL)        udata->handler(conn, &xdata, udata->userdata);    return 1;}

int message_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata){	char *intext, replytext[512];    int ret;	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);	    /* exec command */    ret = cs_exe(cs, intext, ctx, conn, stanza);    sprintf(replytext, "%s ret:%d.", intext, ret);    send_chattext(ctx, conn, stanza, replytext);    xmpp_free(ctx, intext);	return 1;}

void_private_chat_handler(xmpp_stanza_t *const stanza, const char *const fulljid){    xmpp_stanza_t *body = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_BODY);    if (!body) {        return;    }    char *message = xmpp_stanza_get_text(body);    if (!message) {        return;    }    GDateTime *timestamp = stanza_get_delay(stanza);    if (timestamp) {        sv_ev_delayed_private_message(fulljid, message, timestamp);        g_date_time_unref(timestamp);    } else {        sv_ev_incoming_private_message(fulljid, message);    }    xmpp_ctx_t *ctx = connection_get_ctx();    xmpp_free(ctx, message);}

static int_bookmark_handle_result(xmpp_conn_t * const conn,    xmpp_stanza_t * const stanza, void * const userdata){    xmpp_ctx_t *ctx = connection_get_ctx();    char *id = (char *)userdata;    xmpp_stanza_t *ptr;    xmpp_stanza_t *nick;    char *name;    char *jid;    char *autojoin;    gboolean autojoin_val;    Jid *my_jid;    Bookmark *item;    xmpp_timed_handler_delete(conn, _bookmark_handle_delete);    g_free(id);    name = xmpp_stanza_get_name(stanza);    if (!name || strcmp(name, STANZA_NAME_IQ) != 0) {        return 0;    }    ptr = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);    if (!ptr) {        return 0;    }    ptr = xmpp_stanza_get_child_by_name(ptr, STANZA_NAME_STORAGE);    if (!ptr) {        return 0;    }    if (bookmark_ac == NULL) {        bookmark_ac = autocomplete_new();    }    my_jid = jid_create(jabber_get_fulljid());    ptr = xmpp_stanza_get_children(ptr);    while (ptr) {        name = xmpp_stanza_get_name(ptr);        if (!name || strcmp(name, STANZA_NAME_CONFERENCE) != 0) {            ptr = xmpp_stanza_get_next(ptr);            continue;        }        jid = xmpp_stanza_get_attribute(ptr, STANZA_ATTR_JID);        if (!jid) {            ptr = xmpp_stanza_get_next(ptr);            continue;        }        log_debug("Handle bookmark for %s", jid);        name = NULL;        nick = xmpp_stanza_get_child_by_name(ptr, "nick");        if (nick) {            char *tmp;            tmp = xmpp_stanza_get_text(nick);            if (tmp) {                name = strdup(tmp);                xmpp_free(ctx, tmp);            }        }        autojoin = xmpp_stanza_get_attribute(ptr, "autojoin");        if (autojoin && (strcmp(autojoin, "1") == 0 || strcmp(autojoin, "true") == 0)) {            autojoin_val = TRUE;        } else {            autojoin_val = FALSE;        }        autocomplete_add(bookmark_ac, jid);        item = malloc(sizeof(*item));        item->jid = strdup(jid);        item->nick = name;        item->autojoin = autojoin_val;        bookmark_list = g_list_append(bookmark_list, item);        /* TODO: preference whether autojoin */        if (autojoin_val) {            if (autojoin_count < BOOKMARK_AUTOJOIN_MAX) {                Jid *room_jid;                ++autojoin_count;                if (name == NULL) {                    name = my_jid->localpart;                }                log_debug("Autojoin %s with nick=%s", jid, name);                room_jid = jid_create_from_bare_and_resource(jid, name);                if (!muc_room_is_active(room_jid)) {                    presence_join_room(room_jid);                    /* TODO: this should be removed after fixing #195 */                    ui_room_join(room_jid);                }                jid_destroy(room_jid);            } else {                log_debug("Rejected autojoin %s (maximum has been reached)", jid);            }//.........这里部分代码省略.........

static sdvp_WriteParam_t* _CreateWriteParam (xmpp_stanza_t * params) {    int expectedParams, nVarParams = 0;    sdvp_WriteParam_t* rv = NULL;    int i = 0, j = 0, expectedDataElementsInArray;    bool elementNotFund = false;    xmpp_stanza_t *structure = NULL, *member = NULL, *value = NULL,            *type = NULL;    xmpp_stanza_t *name = NULL, *array, *arrayEntry;    char *text, *textname;    structure = _GetRpcStructureElementFromParams(params);    if (structure == NULL ) {        return NULL ;    }    // Get the number of elements    //    expectedParams = _FindNumberOfParams(params);    if (expectedParams > 1) {        nVarParams = expectedParams - 1;    } else {        // TODO: This should result in a ServiceError as minimum two is expected    }    rv = _InitiateWriteParameters(nVarParams);    for (member = xmpp_stanza_get_children(structure);            member && !elementNotFund && (i < expectedParams); member =                    xmpp_stanza_get_next(member)) {        if (xmpp_stanza_get_name(member)                && strcmp(xmpp_stanza_get_name(member), "member") == 0) {            if (!(name = xmpp_stanza_get_child_by_name(member, "name"))) {                _FreeWriteParameters(rv);                // TODO: Signal error back                return NULL ;            }            name = xmpp_stanza_get_children(name);			textname = xmpp_stanza_get_text(name);            if (strcmp(textname, "VariableAccessSpecification") == 0) {                if (!(value = xmpp_stanza_get_child_by_name(member, "value"))) {                    _FreeWriteParameters(rv);                    // TODO: Signal error back                    return NULL ;                }                if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {                    if (xmpp_stanza_get_children(type)) {                        text = xmpp_stanza_get_text(type);                        rv->params->reference = text;                    } else {                        rv->params->reference = NULL;                    }                } else {                    elementNotFund = true;                }            } else if (strcmp(textname, "ListOfData") == 0) {                if (!(value = xmpp_stanza_get_child_by_name(member, "value"))) {                    _FreeWriteParameters(rv);                    // TODO: Signal error back                    return NULL ;                }                if (!(array = xmpp_stanza_get_child_by_name(value, "array"))) {                    _FreeWriteParameters(rv);                    // TODO: Signal error back                    return NULL ;                }                expectedDataElementsInArray = _countDataElementsInArray(array);                _InitiateWriteDataParameters(rv, expectedDataElementsInArray);//                array = xmpp_stanza_get_children(array);                arrayEntry = xmpp_stanza_get_children(array);//HJP Why skip the first element?!//                arrayEntry = xmpp_stanza_get_next(arrayEntry);                for (j = 0; arrayEntry;                     arrayEntry = xmpp_stanza_get_next(arrayEntry)) {                    if (xmpp_stanza_is_tag(arrayEntry)) {                        if (!(value = xmpp_stanza_get_child_by_name(arrayEntry,                                "value"))) {                            _FreeWriteParameters(rv);                            // TODO: Signal error back                            return NULL ;                        }                        // MISSING: base64                        if ((type = xmpp_stanza_get_child_by_name(value,                                "string"))) {                            rv->params->dataAttributeValues[j]->dataType =                                    IEC_VISIBLE_STRING;                            rv->params->dataAttributeValues[j]->strValue =                                    xmpp_stanza_get_text(type);                        } else if ((type = xmpp_stanza_get_child_by_name(value,                                "i4"))                                ||                                (type = xmpp_stanza_get_child_by_name(value,                                        "int"))) {                            rv->params->dataAttributeValues[j]->dataType =                                    IEC_INT32;//.........这里部分代码省略.........

/** * Creates the parameter structure for the GetNameList callback * @param[in] params This stanza is the params element in the XML-RPC format * @return The structure or null if an error were found. */static sdvp_GetNameListParam_t* _CreateGetNameListParam (xmpp_stanza_t * params) {    const int expectedParams = 4;    sdvp_GetNameListParam_t* rv = NULL;    int i = 0;    bool elementNotFund = false;    xmpp_stanza_t *structure = NULL, *member = NULL, *value = NULL,            *type = NULL, *name = NULL;    char *text, *textname;    structure = _GetRpcStructureElementFromParams(params);    if (structure == NULL ) {        return NULL ;    }    rv = _InitiateGetNameListParameters();    for (member = xmpp_stanza_get_children(structure);            member && !elementNotFund && (i < expectedParams); member =                    xmpp_stanza_get_next(member)) {        if (xmpp_stanza_get_name(member)                && strcmp(xmpp_stanza_get_name(member), "member") == 0) {            if (!(name = xmpp_stanza_get_child_by_name(member, "name"))) {                _FreeGetNameListParameters(rv);                // TODO: Signal error back                return NULL ;            }            name = xmpp_stanza_get_children(name);			textname = xmpp_stanza_get_text(name);            if (strcmp(textname, "ObjectClass") == 0) {                if (!(value = xmpp_stanza_get_child_by_name(member, "value"))) {                    _FreeGetNameListParameters(rv);                    // TODO: Signal error back                    return NULL ;                }                if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {                    if (xmpp_stanza_get_children(type)) {                        text = xmpp_stanza_get_text(type);                        rv->params.objectClass = text;                    } else {                        rv->params.objectClass = NULL;                    }                } else {                    elementNotFund = true;                }            } else if (strcmp(textname, "ObjectScope") == 0) {                if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {                    if (xmpp_stanza_get_children(type)) {                        text = xmpp_stanza_get_text(type);                        rv->params.objectScope = text;                    } else {                        rv->params.objectScope = NULL;                    }                } else {                    elementNotFund = true;                }            } else if (strcmp(textname, "DomainName") == 0) {                if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {                    if (xmpp_stanza_get_children(type)) {                        text = xmpp_stanza_get_text(type);                        rv->params.domainName = text;                    } else {                        rv->params.domainName = NULL;                    }                } else {                    elementNotFund = true;                }            } else if (strcmp(textname, "ContinueAfter") == 0) {                if ((type = xmpp_stanza_get_child_by_name(value, "string"))) {                    if (xmpp_stanza_get_children(type)) {                        text = xmpp_stanza_get_text(type);                        rv->params.continueAfter = text;                    } else {                        rv->params.continueAfter = NULL;                    }                } else {                    elementNotFund = true;                }            } else {//                if (!type) {//                    _FreeGetNameListParameters(rv);//                    return NULL ;//                }            }			free(textname);        }    }    return rv;}

static int_bookmark_handle_result(xmpp_conn_t *const conn,    xmpp_stanza_t *const stanza, void *const userdata){    xmpp_ctx_t *ctx = connection_get_ctx();    char *id = (char *)userdata;    xmpp_stanza_t *ptr;    xmpp_stanza_t *nick;    xmpp_stanza_t *password_st;    char *name;    char *jid;    char *autojoin;    char *password;    gboolean autojoin_val;    Jid *my_jid;    Bookmark *item;    xmpp_timed_handler_delete(conn, _bookmark_handle_delete);    g_free(id);    name = xmpp_stanza_get_name(stanza);    if (!name || strcmp(name, STANZA_NAME_IQ) != 0) {        return 0;    }    ptr = xmpp_stanza_get_child_by_name(stanza, STANZA_NAME_QUERY);    if (!ptr) {        return 0;    }    ptr = xmpp_stanza_get_child_by_name(ptr, STANZA_NAME_STORAGE);    if (!ptr) {        return 0;    }    if (bookmark_ac == NULL) {        bookmark_ac = autocomplete_new();    }    my_jid = jid_create(jabber_get_fulljid());    ptr = xmpp_stanza_get_children(ptr);    while (ptr) {        name = xmpp_stanza_get_name(ptr);        if (!name || strcmp(name, STANZA_NAME_CONFERENCE) != 0) {            ptr = xmpp_stanza_get_next(ptr);            continue;        }        jid = xmpp_stanza_get_attribute(ptr, STANZA_ATTR_JID);        if (!jid) {            ptr = xmpp_stanza_get_next(ptr);            continue;        }        log_debug("Handle bookmark for %s", jid);        name = NULL;        nick = xmpp_stanza_get_child_by_name(ptr, "nick");        if (nick) {            char *tmp;            tmp = xmpp_stanza_get_text(nick);            if (tmp) {                name = strdup(tmp);                xmpp_free(ctx, tmp);            }        }        password = NULL;        password_st = xmpp_stanza_get_child_by_name(ptr, "password");        if (password_st) {            char *tmp;            tmp = xmpp_stanza_get_text(password_st);            if (tmp) {                password = strdup(tmp);                xmpp_free(ctx, tmp);            }        }        autojoin = xmpp_stanza_get_attribute(ptr, "autojoin");        if (autojoin && (strcmp(autojoin, "1") == 0 || strcmp(autojoin, "true") == 0)) {            autojoin_val = TRUE;        } else {            autojoin_val = FALSE;        }        autocomplete_add(bookmark_ac, jid);        item = malloc(sizeof(*item));        item->jid = strdup(jid);        item->nick = name;        item->password = password;        item->autojoin = autojoin_val;        bookmark_list = g_list_append(bookmark_list, item);        if (autojoin_val) {            Jid *room_jid;            char *account_name = jabber_get_account_name();            ProfAccount *account = accounts_get_account(account_name);            if (name == NULL) {                name = account->muc_nick;            }//.........这里部分代码省略.........

static int _ibb_set_handler(xmpp_conn_t * const conn, xmpp_stanza_t * const stanza, void * const userdata){    xmpp_stanza_t *child;    xmpp_ibb_userdata_t * udata = (xmpp_ibb_userdata_t *) userdata;    xmpp_ibb_session_t * sess;    char *from, *id, *type;    id = xmpp_stanza_get_id(stanza);    from = xmpp_stanza_get_attribute(stanza, "from");    type = xmpp_stanza_get_type(stanza);    if ((child = xmpp_stanza_get_child_by_name(stanza, "open")) != NULL) {        char *sid = xmpp_stanza_get_attribute(child, "sid");        char *bsize = xmpp_stanza_get_attribute(child, "block-size");        if (sid == NULL || bsize == NULL) {            xmpp_iq_ack_error(conn, id, from, "cancel", "not-acceptable");            return 1;        } else {            xmpp_iq_ack_result(conn, id, from);        }        sess = _ibb_session_init(conn, from, sid);        strncpy(sess->id, id, sizeof(sess->id));        strncpy(sess->peer, from, sizeof(sess->peer));        sess->state = STATE_READY;        sess->block_size = atoi(bsize);        if (udata != NULL && udata->open_cb != NULL)            udata->open_cb(sess, type);        ilist_add(g_list, sess);    } else if ((child = xmpp_stanza_get_child_by_name(stanza, "data")) != NULL) {        char *sid = xmpp_stanza_get_attribute(child, "sid");        sess = ilist_finditem_func(g_list, _find_sid, sid);        if (sess != NULL) {            xmppdata_t xdata;            int seq = 0;            char *intext = xmpp_stanza_get_text(child);            xmpp_iq_ack_result(conn, id, from);            xdata.from = from;            strncpy(sess->id, id, sizeof(sess->id));            seq = atoi(xmpp_stanza_get_attribute(child, "seq"));            if (seq != (sess->recv_seq + 1)) {                //printf("sequence number is not continue. new seq %d last seq %d/n", seq, sess->recv_seq);            }            sess->recv_seq = seq;            xmpp_b64decode(intext, (char **) &xdata.data, (size_t *) &xdata.size);            if (udata != NULL && udata->recv_cb != NULL)                udata->recv_cb(sess, &xdata);            xmpp_b64free(sess->recv_data);            sess->recv_data = NULL;        } else {            //printf("unknown session is not in handle./n");            xmpp_iq_ack_error(conn, id, from, "cancel", "item-not-found");        }    } else if ((child = xmpp_stanza_get_child_by_name(stanza, "close")) != NULL) {        char *sid = xmpp_stanza_get_attribute(child, "sid");        sess = ilist_finditem_func(g_list, _find_sid, sid);        if (sess != NULL) {            xmpp_iq_ack_result(conn, id, from);            strncpy(sess->id, id, sizeof(sess->id));            sess->state = STATE_NONE;            if (udata != NULL && udata->close_cb != NULL)                udata->close_cb(sess, type);            _ibb_session_release(sess);        }    }    time(&glast_ping_time);    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, *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_bind(xmpp_conn_t * const conn,			xmpp_stanza_t * const stanza,			void * const userdata){    char *type;    xmpp_stanza_t *iq, *session;    /* delete missing bind handler */    xmpp_timed_handler_delete(conn, _handle_missing_bind);    /* server has replied to bind request */    type = xmpp_stanza_get_type(stanza);    if (type && strcmp(type, "error") == 0) {	xmpp_error(conn->ctx, "xmpp", "Binding failed.");	xmpp_disconnect(conn);    } else if (type && strcmp(type, "result") == 0) {        xmpp_stanza_t *binding = xmpp_stanza_get_child_by_name(stanza, "bind");	xmpp_debug(conn->ctx, "xmpp", "Bind successful.");        if (binding) {            xmpp_stanza_t *jid_stanza = xmpp_stanza_get_child_by_name(binding,                                                                      "jid");            if (jid_stanza) {                conn->bound_jid = xmpp_stanza_get_text(jid_stanza);            }        }	/* establish a session if required */	if (conn->session_required) {	    /* setup response handlers */	    handler_add_id(conn, _handle_session, "_xmpp_session1", NULL);	    handler_add_timed(conn, _handle_missing_session,			      SESSION_TIMEOUT, NULL);	    /* send session 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_session1");	    session = xmpp_stanza_new(conn->ctx);	    if (!session) {		xmpp_stanza_release(iq);		disconnect_mem_error(conn);	    }	    xmpp_stanza_set_name(session, "session");	    xmpp_stanza_set_ns(session, XMPP_NS_SESSION);	    xmpp_stanza_add_child(iq, session);	    xmpp_stanza_release(session);	    /* send session establishment request */	    xmpp_send(conn, iq);	    xmpp_stanza_release(iq);	} else {	    conn->authenticated = 1;	    /* call connection handler */	    conn->conn_handler(conn, XMPP_CONN_CONNECT, 0, NULL,			       conn->userdata);	}    } else {	xmpp_error(conn->ctx, "xmpp", "Server sent malformed bind reply.");	xmpp_disconnect(conn);    }    return 0;}