comparison libpurple/protocols/msn/soap.c @ 20539:2c8c6d77f12c

Make use of the GQueue in MsnSoapConn to manage the SOAP requests, allowing them to work perfectly even when dispatching multiple requests at once. Delete a user from the userlist after the contact is deleted from the server.

20525:5bef3197383a

/*setup the soap process step*/
void
msn_soap_set_process_step(MsnSoapConn *soapconn, MsnSoapStep step)
{
	soapconn->step = step;
}

//msn_soap_new(MsnSession *session,gpointer data,int sslconn)
/*new a soap connection*/

	soapconn->gsc = NULL;
	soapconn->input_handler = 0;
	soapconn->output_handler = 0;

	msn_soap_set_process_step(soapconn,MSN_SOAP_UNCONNECTED);
	soapconn->soap_queue = g_queue_new();
	return soapconn;
}

/*ssl soap connect callback*/
void
msn_soap_connect_cb(gpointer data, PurpleSslConnection *gsc,
				 PurpleInputCondition cond)
{
	MsnSoapConn * soapconn;
	MsnSession *session;

	purple_debug_misc("MSN SOAP","SOAP server connection established!\n");

	soapconn = data;
	g_return_if_fail(soapconn != NULL);

	session = soapconn->session;
	g_return_if_fail(session != NULL);

	soapconn->gsc = gsc;

	/*connection callback*/
	if(soapconn->connect_cb != NULL){
		soapconn->connect_cb(data,gsc,cond);
	}

	msn_soap_set_process_step(soapconn,MSN_SOAP_CONNECTED);
	/*we do the SOAP request here*/
	msn_soap_post_head_request(soapconn);
}

/*ssl soap error callback*/

msn_soap_error_cb(PurpleSslConnection *gsc, PurpleSslErrorType error, void *data)
{	
	MsnSoapConn * soapconn = data;

	g_return_if_fail(data != NULL);
	purple_debug_warning("MSN SOAP","Soap connection error!\n");
	msn_soap_set_process_step(soapconn, MSN_SOAP_UNCONNECTED);

	/*error callback*/
	if(soapconn->error_cb != NULL){
		soapconn->error_cb(gsc,error,data);
	}
}

/*init the soap connection*/
void
msn_soap_init(MsnSoapConn *soapconn,char * host,int ssl,
				PurpleSslInputFunction	connect_cb,
				PurpleSslErrorFunction	error_cb)
{
	purple_debug_misc("MSN SOAP","Initializing SOAP connection\n");
	soapconn->login_host = g_strdup(host);
	soapconn->ssl_conn = ssl;
	soapconn->connect_cb = connect_cb;

/*connect the soap connection*/
void
msn_soap_connect(MsnSoapConn *soapconn)
{
	if(soapconn->ssl_conn){
		purple_ssl_connect(soapconn->session->account, soapconn->login_host,
				PURPLE_SSL_DEFAULT_PORT, msn_soap_connect_cb, msn_soap_error_cb,
				soapconn);
	}else{
	}
	msn_soap_set_process_step(soapconn,MSN_SOAP_CONNECTING);
}

/*close the soap connection*/
void
msn_soap_close(MsnSoapConn *soapconn)
{
	if(soapconn->ssl_conn){
		if(soapconn->gsc != NULL){
			purple_ssl_close(soapconn->gsc);
			soapconn->gsc = NULL;
		}
	}else{
	}
	msn_soap_set_process_step(soapconn,MSN_SOAP_UNCONNECTED);
}

/*clean the unhandled SOAP request*/
void
msn_soap_clean_unhandled_request(MsnSoapConn *soapconn)
{
	MsnSoapReq *request;

	g_return_if_fail(soapconn != NULL);

	soapconn->body = NULL;

	while ((request = g_queue_pop_head(soapconn->soap_queue)) != NULL){
		if (soapconn->read_cb) {
			soapconn->read_cb(soapconn, -1, 0);
		}
		msn_soap_request_free(request);
	}
}

	/*close ssl connection*/
	msn_soap_close(soapconn);

	/*process the unhandled soap request*/
	msn_soap_clean_unhandled_request(soapconn);

	g_queue_free(soapconn->soap_queue);
	g_free(soapconn);
}

 * if connected return 1
 */
int
msn_soap_connected(MsnSoapConn *soapconn)
{
	if(soapconn->ssl_conn){
		return (soapconn->gsc == NULL? 0 : 1);
	}
	return(soapconn->fd>0? 1 : 0);
}

/*read and append the content to the buffer*/
static gssize
msn_soap_read(MsnSoapConn *soapconn)

			default : purple_debug_error("MSN SOAP", "Read error!"
						"read len: %d, error = %s\n",
						len, strerror(errno));
				  purple_input_remove(soapconn->input_handler);
				  soapconn->input_handler = 0;
				  g_free(soapconn->read_buf);
				  soapconn->read_buf = NULL;
				  soapconn->read_len = 0;
				  /* TODO: error handling */
				  return len;

		purple_debug_info("MSN SOAP", "HTTP Redirect\n");
		location = strstr(soapconn->read_buf, "Location: ");
		if (location == NULL)
		{
			msn_soap_free_read_buf(soapconn);

			return;
		}
		location = strchr(location, ' ') + 1;

		if ((c = strchr(location, '\r')) != NULL)
			*c = '\0';

		/* Skip the http:// */
		if ((c = strchr(location, '/')) != NULL)
			location = c + 2;

			*c = '\0';
		}

		g_free(soapconn->login_host);
		soapconn->login_host = g_strdup(location);

		purple_ssl_connect(session->account, soapconn->login_host,
			PURPLE_SSL_DEFAULT_PORT, msn_soap_connect_cb,
			msn_soap_error_cb, soapconn);
	}
	/* Another case of redirection, active on May, 2007
	   See http://msnpiki.msnfanatic.com/index.php/MSNP13:SOAPTweener#Redirect
	 */
	else if (strstr(soapconn->read_buf,
                    "<faultcode>psf:Redirect</faultcode>") != NULL)
	{
		char *location, *c;

		location = strstr(soapconn->read_buf, "<psf:redirectUrl>");
		/* Omit the tag preceding the URL */
		location += strlen("<psf:redirectUrl>");
		location = strstr(location, ":/");
		if (location == NULL)
		{
			msn_soap_free_read_buf(soapconn);
			return;
		}

		location += strlen("://"); /* Skip http:// or https:// */

		if ( (c = strstr(location, "</psf:redirectUrl>")) != NULL )
			*c = '\0';

		if ( (c = strstr(location, "/")) != NULL )
		{
			g_free(soapconn->login_path);
			soapconn->login_path = g_strdup(c);
			*c = '\0';
		}

		g_free(soapconn->login_host);
		soapconn->login_host = g_strdup(location);

		purple_ssl_connect(session->account, soapconn->login_host,
			PURPLE_SSL_DEFAULT_PORT, msn_soap_connect_cb,
			msn_soap_error_cb, soapconn);
	}
	else if (strstr(soapconn->read_buf, "HTTP/1.1 401 Unauthorized") != NULL)
	{
		const char *error;

	 * Further info: http://msnpiki.msnfanatic.com/index.php/MSNP13:SOAPTweener
	 */
	else if (strstr(soapconn->read_buf,
				"<faultcode>wsse:FailedAuthentication</faultcode>") != NULL)
	{
		char *faultstring;

		faultstring = strstr(soapconn->read_buf, "<faultstring>");

		if (faultstring != NULL)
		{
			faultstring += strlen("<faultstring>");
			*strstr(soapconn->read_buf, "</faultstring>") = '\0';
		}
		
		msn_session_set_error(session, MSN_ERROR_AUTH, faultstring);
	}
	else if (strstr(soapconn->read_buf, "HTTP/1.1 503 Service Unavailable"))
	{
		msn_session_set_error(session, MSN_ERROR_SERV_UNAVAILABLE, NULL);
	}
	else if ((strstr(soapconn->read_buf, "HTTP/1.1 200 OK"))
		||(strstr(soapconn->read_buf, "HTTP/1.1 500")))
	{
			/*OK! process the SOAP body*/
			body_start = (char *)g_strstr_len(soapconn->read_buf, soapconn->read_len,"\r\n\r\n");
			if (!body_start) {
				return;
			}
			body_start += 4;

			//	purple_debug_misc("msn", "Soap Read: {%s}\n", soapconn->read_buf);

			/* we read the content-length*/
			length_start = strstr(soapconn->read_buf, "Content-Length: ");
			length_start += strlen("Content-Length: ");
			length_end = strstr(length_start, "\r\n");
			body_len = g_strndup(length_start, length_end - length_start);

			/*setup the conn body */
			soapconn->body		= body_start;
			soapconn->body_len	= atoi(body_len);
			g_free(body_len);
#ifdef MSN_SOAP_DEBUG
			purple_debug_misc("MSN SOAP","SOAP bytes read so far: %d, Content-Length: %d\n", soapconn->read_len, soapconn->body_len);
#endif
			soapconn->need_to_read = (body_start - soapconn->read_buf + soapconn->body_len) - soapconn->read_len;
			if ( soapconn->need_to_read > 0 ) {
				return;
			}

#if defined(MSN_SOAP_DEBUG) && !defined(_WIN32)

			node = xmlnode_from_str(soapconn->body, soapconn->body_len);
	
			if (node != NULL) {
				formattedxml = xmlnode_to_formatted_str(node, NULL);
				http_headers = g_strndup(soapconn->read_buf, soapconn->body - soapconn->read_buf);
				
				purple_debug_info("MSN SOAP","Data with XML payload received from the SOAP server:\n%s%s\n", http_headers, formattedxml);
				g_free(http_headers);
				g_free(formattedxml);
				xmlnode_free(node);
			}
			else
				purple_debug_info("MSN SOAP","Data received from the SOAP server:\n%s\n", soapconn->read_buf);
#endif

			/*remove the read handler*/
			purple_input_remove(soapconn->input_handler);
			soapconn->input_handler = 0;
			/*
			 * close the soap connection,if more soap request came,
			 * Just reconnect to do it,
			 *
			 * To solve the problem described below:
			 * When I post the soap request in one socket one after the other,
			 * The first read is ok, But the second soap read always got 0 bytes,
			 * Weird!
			 * */
			msn_soap_close(soapconn);

			/*call the read callback*/
			if ( soapconn->read_cb != NULL ) {
				soapconn->read_cb(soapconn, source, 0);
			}
	}
	return;
}

void 
msn_soap_free_read_buf(MsnSoapConn *soapconn)

	MsnSoapConn *soapconn = data;
	int len, total_len;

	g_return_if_fail(soapconn != NULL);
	if ( soapconn->write_buf == NULL ) {
		purple_debug_error("MSN SOAP","SOAP buffer is NULL\n");
		purple_input_remove(soapconn->output_handler);
		soapconn->output_handler = -1;
		return;
	}
	total_len = strlen(soapconn->write_buf);

	/* 

	if (len < 0 && errno == EAGAIN)
		return;
	else if (len <= 0){
		/*SSL write error!*/
		purple_input_remove(soapconn->output_handler);
		soapconn->output_handler = -1;
		/* TODO: notify of the error */
		purple_debug_error("MSN SOAP","Error writing to SSL connection!\n");
		return;
	}
	soapconn->written_len += len;

	if (soapconn->written_len < total_len)
		return;

	purple_input_remove(soapconn->output_handler);
	soapconn->output_handler = -1;

	/*clear the write buff*/
	msn_soap_free_write_buf(soapconn);

	/* Write finish!
	 * callback for write done
	 */
	if(soapconn->written_cb != NULL){
		soapconn->written_cb(soapconn, source, 0);
	}
	/*maybe we need to read the input?*/
	if (soapconn->input_handler == 0) {
		soapconn->input_handler = purple_input_add(soapconn->gsc->fd,
			PURPLE_INPUT_READ, msn_soap_read_cb, soapconn);
	}
//	msn_soap_read_cb(soapconn,source,0);
}

/*write the buffer to SOAP connection*/
void
msn_soap_write(MsnSoapConn * soapconn, char *write_buf, PurpleInputFunction written_cb)
{
	soapconn->write_buf = write_buf;
	soapconn->written_len = 0;
	soapconn->written_cb = written_cb;
	
	msn_soap_free_read_buf(soapconn);

	/*clear the read buffer first*/
	/*start the write*/
	soapconn->output_handler = purple_input_add(soapconn->gsc->fd, PURPLE_INPUT_WRITE,
													msn_soap_write_cb, soapconn);
	msn_soap_write_cb(soapconn, soapconn->gsc->fd, PURPLE_INPUT_WRITE);
}

/* New a soap request*/
MsnSoapReq *
msn_soap_request_new(const char *host,const char *post_url,const char *soap_action,
				const char *body, const gpointer data_cb,
				PurpleInputFunction read_cb,PurpleInputFunction written_cb)
{
	MsnSoapReq *request;

	request = g_new0(MsnSoapReq, 1);
	request->id = 0;

	request->soap_action		= g_strdup(soap_action);
	request->body		= g_strdup(body);
	request->data_cb 	= data_cb;
	request->read_cb	= read_cb;
	request->written_cb	= written_cb;

	return request;
}

/*free a soap request*/

	g_free(request->login_path);
	g_free(request->soap_action);
	g_free(request->body);
	request->read_cb	= NULL;
	request->written_cb	= NULL;

	g_free(request);
}

/*post the soap request queue's head request*/
void
msn_soap_post_head_request(MsnSoapConn *soapconn)
{
	purple_debug_info("MSN SOAP", "Posting new request from head of the queue\n");
	
	g_return_if_fail(soapconn->soap_queue != NULL);

	if(!g_queue_is_empty(soapconn->soap_queue)){
		MsnSoapReq *request;
		if((request = g_queue_pop_head(soapconn->soap_queue)) != NULL){
			msn_soap_post_request(soapconn,request);
		}
	} else {
		purple_debug_info("MSN SOAP", "No requests to process found.\n");
		msn_soap_set_process_step(soapconn,MSN_SOAP_CONNECTED_IDLE);
	}
}

/*post the soap request ,
 * if not connected, Connected first.
 */
void
msn_soap_post(MsnSoapConn *soapconn,MsnSoapReq *request,
				MsnSoapConnectInitFunction msn_soap_init_func)
{
	if (request != NULL) {
		g_queue_push_tail(soapconn->soap_queue, request);
	}
	if (!msn_soap_connected(soapconn) && (soapconn->step == MSN_SOAP_UNCONNECTED)
					&&(!g_queue_is_empty(soapconn->soap_queue))) {
		/*not connected?and we have something to process connect it first*/
		purple_debug_misc("MSN SOAP","No connection to SOAP server. Connecting...\n");
		msn_soap_init_func(soapconn);
		msn_soap_connect(soapconn);
		return;
	}
	purple_debug_misc("MSN SOAP","Connected to SOAP server\n");

	/*if connected, what we only needed to do is to queue the request, 
	 * when SOAP request in the queue processed done, will do this command.
	 * we just waiting...
	 * If we send the request this time,error may occure
	 */
	if (soapconn->step == MSN_SOAP_CONNECTED_IDLE){
		msn_soap_post_head_request(soapconn);
	}
}

/*Post the soap request action*/
void
msn_soap_post_request(MsnSoapConn *soapconn,MsnSoapReq *request)
{
	char * soap_head = NULL;
	char * request_str = NULL;
#ifdef MSN_SOAP_DEBUG
#if !defined(_WIN32)

20539:2c8c6d77f12c

/*setup the soap process step*/
void
msn_soap_set_process_step(MsnSoapConn *soapconn, MsnSoapStep step)
{
#ifdef MSN_SOAP_DEBUG
	const char *MsnSoapStepText[] =
	{
		"Unconnected",
		"Connecting",
		"Connected",
		"Processing",
		"Connected Idle"
	};

	purple_debug_info("MSN SOAP", "Setting SOAP process step to %s\n", MsnSoapStepText[step]);
#endif
	soapconn->step = step;
}

//msn_soap_new(MsnSession *session,gpointer data,int sslconn)
/*new a soap connection*/

	soapconn->gsc = NULL;
	soapconn->input_handler = 0;
	soapconn->output_handler = 0;

	msn_soap_set_process_step(soapconn, MSN_SOAP_UNCONNECTED);
	soapconn->soap_queue = g_queue_new();

	return soapconn;
}

/*ssl soap connect callback*/
void
msn_soap_connect_cb(gpointer data, PurpleSslConnection *gsc,
				 PurpleInputCondition cond)
{
	MsnSoapConn * soapconn;
	MsnSession *session;
	gboolean soapconn_is_valid = FALSE;

	purple_debug_misc("MSN SOAP","SOAP server connection established!\n");

	soapconn = data;
	g_return_if_fail(soapconn != NULL);

	session = soapconn->session;
	g_return_if_fail(session != NULL);

	soapconn->gsc = gsc;

	msn_soap_set_process_step(soapconn, MSN_SOAP_CONNECTED);

	/*connection callback*/
	if (soapconn->connect_cb != NULL) {
		soapconn_is_valid = soapconn->connect_cb(soapconn, gsc);
	}

	if (!soapconn_is_valid) {
		return;
	}

	/*we do the SOAP request here*/
	msn_soap_post_head_request(soapconn);
}

/*ssl soap error callback*/

msn_soap_error_cb(PurpleSslConnection *gsc, PurpleSslErrorType error, void *data)
{	
	MsnSoapConn * soapconn = data;

	g_return_if_fail(data != NULL);

	purple_debug_warning("MSN SOAP","Soap connection error!\n");

	msn_soap_set_process_step(soapconn, MSN_SOAP_UNCONNECTED);

	/*error callback*/
	if (soapconn->error_cb != NULL) {
		soapconn->error_cb(soapconn, gsc, error);
	} else {
		msn_soap_post(soapconn, NULL);
	}
}

/*init the soap connection*/
void
msn_soap_init(MsnSoapConn *soapconn,char * host,int ssl,
				MsnSoapSslConnectCbFunction connect_cb,
				MsnSoapSslErrorCbFunction error_cb)
{
	purple_debug_misc("MSN SOAP","Initializing SOAP connection\n");
	soapconn->login_host = g_strdup(host);
	soapconn->ssl_conn = ssl;
	soapconn->connect_cb = connect_cb;

/*connect the soap connection*/
void
msn_soap_connect(MsnSoapConn *soapconn)
{
	if (soapconn->ssl_conn) {
		purple_ssl_connect(soapconn->session->account, soapconn->login_host,
				PURPLE_SSL_DEFAULT_PORT, msn_soap_connect_cb, msn_soap_error_cb,
				soapconn);
	} else {
	}

	msn_soap_set_process_step(soapconn, MSN_SOAP_CONNECTING);
}


static void
msn_soap_close_handler(guint *handler)
{
	if (*handler > 0) {
		purple_input_remove(*handler);
		*handler = 0;
	} 
#ifdef MSN_SOAP_DEBUG
	else {
		purple_debug_misc("MSN SOAP", "Handler inactive, not removing\n");
	}
#endif

}


/*close the soap connection*/
void
msn_soap_close(MsnSoapConn *soapconn)
{
	if (soapconn->ssl_conn) {
		if (soapconn->gsc != NULL) {
			purple_ssl_close(soapconn->gsc);
			soapconn->gsc = NULL;
		}
	} else {
	}
	msn_soap_set_process_step(soapconn, MSN_SOAP_UNCONNECTED);
}

/*clean the unhandled SOAP request*/
void
msn_soap_clean_unhandled_requests(MsnSoapConn *soapconn)
{
	MsnSoapReq *request;

	g_return_if_fail(soapconn != NULL);

	soapconn->body = NULL;

	while ((request = g_queue_pop_head(soapconn->soap_queue)) != NULL){
		if (soapconn->read_cb) {
			soapconn->read_cb(soapconn);
		}
		msn_soap_request_free(request);
	}
}

	/*close ssl connection*/
	msn_soap_close(soapconn);

	/*process the unhandled soap request*/
	msn_soap_clean_unhandled_requests(soapconn);

	g_queue_free(soapconn->soap_queue);
	g_free(soapconn);
}

 * if connected return 1
 */
int
msn_soap_connected(MsnSoapConn *soapconn)
{
	if (soapconn->ssl_conn) {
		return (soapconn->gsc == NULL ? 0 : 1);
	}
	return (soapconn->fd > 0 ? 1 : 0);
}

/*read and append the content to the buffer*/
static gssize
msn_soap_read(MsnSoapConn *soapconn)

			default : purple_debug_error("MSN SOAP", "Read error!"
						"read len: %d, error = %s\n",
						len, strerror(errno));
				  purple_input_remove(soapconn->input_handler);
				  //soapconn->input_handler = 0;
				  g_free(soapconn->read_buf);
				  soapconn->read_buf = NULL;
				  soapconn->read_len = 0;
				  /* TODO: error handling */
				  return len;

		purple_debug_info("MSN SOAP", "HTTP Redirect\n");
		location = strstr(soapconn->read_buf, "Location: ");
		if (location == NULL)
		{
			c = (char *) g_strstr_len(soapconn->read_buf, soapconn->read_len,"\r\n\r\n");
			if (c != NULL) {
				/* we have read the whole HTTP headers and found no Location: */
				msn_soap_free_read_buf(soapconn);
				msn_soap_post(soapconn, NULL);
			}

			return;
		}
		location = strchr(location, ' ') + 1;

		if ((c = strchr(location, '\r')) != NULL)
			*c = '\0';
		else
			return;

		/* Skip the http:// */
		if ((c = strchr(location, '/')) != NULL)
			location = c + 2;

			*c = '\0';
		}

		g_free(soapconn->login_host);
		soapconn->login_host = g_strdup(location);
		
		msn_soap_close_handler( &(soapconn->input_handler) );
		msn_soap_close(soapconn);

		if (purple_ssl_connect(session->account, soapconn->login_host,
			PURPLE_SSL_DEFAULT_PORT, msn_soap_connect_cb,
			msn_soap_error_cb, soapconn) == NULL) {
		
			purple_debug_error("MSN SOAP", "Unable to connect to %s !\n", soapconn->login_host);
			// dispatch next request
			msn_soap_post(soapconn, NULL);
		}
	}
	/* Another case of redirection, active on May, 2007
	   See http://msnpiki.msnfanatic.com/index.php/MSNP13:SOAPTweener#Redirect
	 */
	else if (strstr(soapconn->read_buf,
                    "<faultcode>psf:Redirect</faultcode>") != NULL)
	{
		char *location, *c;

		if ( (location = strstr(soapconn->read_buf, "<psf:redirectUrl>") ) == NULL)
			return;

		/* Omit the tag preceding the URL */
		location += strlen("<psf:redirectUrl>");
		if (location > soapconn->read_buf + soapconn->read_len)
			return;
		if ( (location = strstr(location, "://")) == NULL)
			return;

		location += strlen("://"); /* Skip http:// or https:// */

		if ( (c = strstr(location, "</psf:redirectUrl>")) != NULL )
			*c = '\0';
		else
			return;

		if ( (c = strstr(location, "/")) != NULL )
		{
			g_free(soapconn->login_path);
			soapconn->login_path = g_strdup(c);
			*c = '\0';
		}

		g_free(soapconn->login_host);
		soapconn->login_host = g_strdup(location);
		
		msn_soap_close_handler( &(soapconn->input_handler) );
		msn_soap_close(soapconn);

		if (purple_ssl_connect(session->account, soapconn->login_host,
				PURPLE_SSL_DEFAULT_PORT, msn_soap_connect_cb,
				msn_soap_error_cb, soapconn) == NULL) {

			purple_debug_error("MSN SOAP", "Unable to connect to %s !\n", soapconn->login_host);
			// dispatch next request
			msn_soap_post(soapconn, NULL);
		}
	}
	else if (strstr(soapconn->read_buf, "HTTP/1.1 401 Unauthorized") != NULL)
	{
		const char *error;

	 * Further info: http://msnpiki.msnfanatic.com/index.php/MSNP13:SOAPTweener
	 */
	else if (strstr(soapconn->read_buf,
				"<faultcode>wsse:FailedAuthentication</faultcode>") != NULL)
	{
		gchar *faultstring;

		faultstring = strstr(soapconn->read_buf, "<faultstring>");

		if (faultstring != NULL)
		{
			gchar *c;
			faultstring += strlen("<faultstring>");
			if (faultstring < soapconn->read_buf + soapconn->read_len) {
				c = strstr(soapconn->read_buf, "</faultstring>");
				if (c != NULL) {
					*c = '\0';
					msn_session_set_error(session, MSN_ERROR_AUTH, faultstring);
				}
			}
		}
		
	}
	else if (strstr(soapconn->read_buf, "HTTP/1.1 503 Service Unavailable"))
	{
		msn_session_set_error(session, MSN_ERROR_SERV_UNAVAILABLE, NULL);
	}
	else if ((strstr(soapconn->read_buf, "HTTP/1.1 200 OK"))
		||(strstr(soapconn->read_buf, "HTTP/1.1 500")))
	{
		gboolean soapconn_is_valid = FALSE;

		/*OK! process the SOAP body*/
		body_start = (char *)g_strstr_len(soapconn->read_buf, soapconn->read_len,"\r\n\r\n");
		if (!body_start) {
			return;
		}
		body_start += 4;

		if (body_start > soapconn->read_buf + soapconn->read_len)
			return;

		/* we read the content-length*/
		if ( (length_start = g_strstr_len(soapconn->read_buf, soapconn->read_len, "Content-Length: ")) != NULL)
			length_start += strlen("Content-Length: ");

		if (length_start > soapconn->read_buf + soapconn->read_len)
			return;

		if ( (length_end = strstr(length_start, "\r\n")) == NULL )
			return;

		body_len = g_strndup(length_start, length_end - length_start);

		/*setup the conn body */
		soapconn->body		= body_start;
		soapconn->body_len	= atoi(body_len);
		g_free(body_len);
#ifdef MSN_SOAP_DEBUG
		purple_debug_misc("MSN SOAP","SOAP bytes read so far: %d, Content-Length: %d\n", soapconn->read_len, soapconn->body_len);
#endif
		soapconn->need_to_read = (body_start - soapconn->read_buf + soapconn->body_len) - soapconn->read_len;
		if ( soapconn->need_to_read > 0 ) {
			return;
		}

#if defined(MSN_SOAP_DEBUG) && !defined(_WIN32)

		node = xmlnode_from_str(soapconn->body, soapconn->body_len);
	
		if (node != NULL) {
			formattedxml = xmlnode_to_formatted_str(node, NULL);
			http_headers = g_strndup(soapconn->read_buf, soapconn->body - soapconn->read_buf);
				
			purple_debug_info("MSN SOAP","Data with XML payload received from the SOAP server:\n%s%s\n", http_headers, formattedxml);
			g_free(http_headers);
			g_free(formattedxml);
			xmlnode_free(node);
		}
		else
			purple_debug_info("MSN SOAP","Data received from the SOAP server:\n%s\n", soapconn->read_buf);
#endif

		/*remove the read handler*/
		msn_soap_close_handler( &(soapconn->input_handler) );
//		purple_input_remove(soapconn->input_handler);
//		soapconn->input_handler = 0;
		/*
		 * close the soap connection,if more soap request came,
		 * Just reconnect to do it,
		 *
		 * To solve the problem described below:
		 * When I post the soap request in one socket one after the other,
		 * The first read is ok, But the second soap read always got 0 bytes,
		 * Weird!
		 * */
		msn_soap_close(soapconn);

		/*call the read callback*/
		if ( soapconn->read_cb != NULL ) {
			soapconn_is_valid = soapconn->read_cb(soapconn);
		}
		
		if (!soapconn_is_valid) {
			return;
		}

		/* dispatch next request in queue */
		msn_soap_post(soapconn, NULL);
	}	
	return;
}

void 
msn_soap_free_read_buf(MsnSoapConn *soapconn)

	MsnSoapConn *soapconn = data;
	int len, total_len;

	g_return_if_fail(soapconn != NULL);
	if ( soapconn->write_buf == NULL ) {
		purple_debug_error("MSN SOAP","SOAP write buffer is NULL\n");
	//	msn_soap_check_conn_errors(soapconn);
	//	purple_input_remove(soapconn->output_handler);
	//	soapconn->output_handler = 0;
		msn_soap_close_handler( &(soapconn->output_handler) );
		return;
	}
	total_len = strlen(soapconn->write_buf);

	/* 

	if (len < 0 && errno == EAGAIN)
		return;
	else if (len <= 0){
		/*SSL write error!*/
//		msn_soap_check_conn_errors(soapconn);

		msn_soap_close_handler( &(soapconn->output_handler) );
//		purple_input_remove(soapconn->output_handler);
//		soapconn->output_handler = 0;

		msn_soap_close(soapconn);

		/* TODO: notify of the error */
		purple_debug_error("MSN SOAP", "Error writing to SSL connection!\n");
		msn_soap_post(soapconn, NULL);
		return;
	}
	soapconn->written_len += len;

	if (soapconn->written_len < total_len)
		return;

	msn_soap_close_handler( &(soapconn->output_handler) );
//	purple_input_remove(soapconn->output_handler);
//	soapconn->output_handler = 0;

	/*clear the write buff*/
	msn_soap_free_write_buf(soapconn);

	/* Write finish!
	 * callback for write done
	 */
	if(soapconn->written_cb != NULL){
		soapconn->written_cb(soapconn);
	}
	/*maybe we need to read the input?*/
	if ( soapconn->input_handler == 0 ) {
		soapconn->input_handler = purple_input_add(soapconn->gsc->fd,
			PURPLE_INPUT_READ, msn_soap_read_cb, soapconn);
	}
}

/*write the buffer to SOAP connection*/
void
msn_soap_write(MsnSoapConn * soapconn, char *write_buf, MsnSoapWrittenCbFunction written_cb)
{
	if (soapconn == NULL) {
		return;
	}

	msn_soap_set_process_step(soapconn, MSN_SOAP_PROCESSING);

	soapconn->write_buf = write_buf;
	soapconn->written_len = 0;
	soapconn->written_cb = written_cb;
	
	msn_soap_free_read_buf(soapconn);

	/*clear the read buffer first*/
	/*start the write*/
	soapconn->output_handler = purple_input_add(soapconn->gsc->fd, PURPLE_INPUT_WRITE,
						    msn_soap_write_cb, soapconn);
	msn_soap_write_cb(soapconn, soapconn->gsc->fd, PURPLE_INPUT_WRITE);
}

/* New a soap request*/
MsnSoapReq *
msn_soap_request_new(const char *host,const char *post_url,const char *soap_action,
				const char *body, const gpointer data_cb,
				MsnSoapReadCbFunction read_cb,
				MsnSoapWrittenCbFunction written_cb,
				MsnSoapConnectInitFunction connect_init)
{
	MsnSoapReq *request;

	request = g_new0(MsnSoapReq, 1);
	request->id = 0;

	request->soap_action		= g_strdup(soap_action);
	request->body		= g_strdup(body);
	request->data_cb 	= data_cb;
	request->read_cb	= read_cb;
	request->written_cb	= written_cb;
	request->connect_init	= connect_init;

	return request;
}

/*free a soap request*/

	g_free(request->login_path);
	g_free(request->soap_action);
	g_free(request->body);
	request->read_cb	= NULL;
	request->written_cb	= NULL;
	request->connect_init	= NULL;

	g_free(request);
}

/*post the soap request queue's head request*/
void
msn_soap_post_head_request(MsnSoapConn *soapconn)
{
	g_return_if_fail(soapconn != NULL);
	g_return_if_fail(soapconn->soap_queue != NULL);
	
	if (soapconn->step == MSN_SOAP_CONNECTED ||
	    soapconn->step == MSN_SOAP_CONNECTED_IDLE) {

		purple_debug_info("MSN SOAP", "Posting new request from head of the queue\n");

		if ( !g_queue_is_empty(soapconn->soap_queue) ) {
			MsnSoapReq *request;

			if ( (request = g_queue_pop_head(soapconn->soap_queue)) != NULL ) {
				msn_soap_post_request(soapconn,request);
			}
		} else {
			purple_debug_info("MSN SOAP", "No requests to process found.\n");
			msn_soap_set_process_step(soapconn, MSN_SOAP_CONNECTED_IDLE);
		}
	}
}

/*post the soap request ,
 * if not connected, Connected first.
 */
void
msn_soap_post(MsnSoapConn *soapconn,MsnSoapReq *request)
{
	MsnSoapReq *head_request;

	if (soapconn == NULL)
		return;

	if (request != NULL) {
#ifdef MSN_SOAP_DEBUG
		purple_debug_misc("MSN SOAP", "Request added to the queue\n");
#endif
		g_queue_push_tail(soapconn->soap_queue, request);
	}

	if ( !g_queue_is_empty(soapconn->soap_queue)) {

		/* we may have to reinitialize the soap connection, so avoid
		 * reusing the connection for now */

		if (soapconn->step == MSN_SOAP_CONNECTED_IDLE) {
			purple_debug_misc("MSN SOAP","Already connected to SOAP server, re-initializing\n");
			msn_soap_close_handler( &(soapconn->input_handler) );
			msn_soap_close_handler( &(soapconn->output_handler) );
			msn_soap_close(soapconn);
		}

		if (!msn_soap_connected(soapconn) && (soapconn->step == MSN_SOAP_UNCONNECTED)) {

			/*not connected?and we have something to process connect it first*/
			purple_debug_misc("MSN SOAP","No connection to SOAP server. Connecting...\n");
			head_request = g_queue_peek_head(soapconn->soap_queue);

			if (head_request == NULL) {
				purple_debug_error("MSN SOAP", "Queue is not empty, but failed to peek the head request!\n");
				return;
			}

			if (head_request->connect_init != NULL) {
				head_request->connect_init(soapconn);
			}
			msn_soap_connect(soapconn);
			return;
		}

		purple_debug_info("MSN SOAP", "Currently processing another SOAP request\n");
	} else {
		purple_debug_info("MSN SOAP", "No requests left to dispatch\n");
	}
}

/*Post the soap request action*/
void
msn_soap_post_request(MsnSoapConn *soapconn, MsnSoapReq *request)
{
	char * soap_head = NULL;
	char * request_str = NULL;
#ifdef MSN_SOAP_DEBUG
#if !defined(_WIN32)