Tlen protocol adopted

- code moved to trunk\protocols folder
- update project files (based on rev: 27, 228, 204, 350, 279, 280, 1374, 278)
- changed code organisation to c++ convention (based on rev: 1092, 503, 504) 
- changed code to Miranda NG convention (based on rev: 49, 54, 312, 401, 321, 358, 410, 441, 477, 483, 496, 507, 515, 644, 652, 743, 956, 1206,  667, 1040, 1590, 1857)
- folders restructurization (based on rev: 1890)
- code cleaning (based on rev: 270, 398, 409)
- this commit includes adopted sources of tlen_czaty.dll (former mucc.dll) plugin witch is now deprecated and will be removed

-- 
wsx22{at}o2.pl

git-svn-id: http://svn.miranda-ng.org/main/trunk@1972 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 568 insertions, 0 deletions

diff --git a/protocols/Tlen/src/jabber_xml.cpp b/protocols/Tlen/src/jabber_xml.cpp
new file mode 100644
index 0000000000..5786404dc6
--- /dev/null
+++ b/protocols/Tlen/src/jabber_xml.cpp
@@ -0,0 +1,568 @@
+/*

+

+Jabber Protocol Plugin for Miranda IM

+Tlen Protocol Plugin for Miranda NG

+Copyright (C) 2002-2004  Santithorn Bunchua

+Copyright (C) 2004-2007  Piotr Piastucki

+

+This program is free software; you can redistribute it and/or

+modify it under the terms of the GNU General Public License

+as published by the Free Software Foundation; either version 2

+of the License, or (at your option) any later version.

+

+This program is distributed in the hope that it will be useful,

+but WITHOUT ANY WARRANTY; without even the implied warranty of

+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

+GNU General Public License for more details.

+

+You should have received a copy of the GNU General Public License

+along with this program; if not, write to the Free Software

+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

+

+*/

+

+#include "jabber.h"

+#include <ctype.h>

+

+static BOOL JabberXmlProcessElem(XmlState *xmlState, XmlElemType elemType, char *elemText, char *elemAttr);

+static void JabberXmlRemoveChild(XmlNode *node, XmlNode *child);

+

+void JabberXmlInitState(XmlState *xmlState)

+{

+	if (xmlState == NULL) return;

+	xmlState->root.name = NULL;

+	xmlState->root.depth = 0;

+	xmlState->root.numAttr = 0;

+	xmlState->root.maxNumAttr = 0;

+	xmlState->root.attr = NULL;

+	xmlState->root.numChild = 0;

+	xmlState->root.maxNumChild = 0;

+	xmlState->root.child = NULL;

+	xmlState->root.text = NULL;

+	xmlState->root.state = NODE_OPEN;

+	xmlState->callback1_open = NULL;

+	xmlState->callback1_close = NULL;

+	xmlState->callback2_open = NULL;

+	xmlState->callback2_close = NULL;

+	xmlState->userdata1_open = NULL;

+	xmlState->userdata1_close = NULL;

+	xmlState->userdata2_open = NULL;

+	xmlState->userdata2_close = NULL;

+}

+

+void JabberXmlDestroyState(XmlState *xmlState)

+{

+	int i;

+	XmlNode *node;

+

+	if (xmlState == NULL) return;

+	// Note: cannot use JabberXmlFreeNode() to free xmlState->root

+	// because it will do mir_free(xmlState->root) which is not freeable.

+	node = &(xmlState->root);

+	// Free all children first

+	for (i=0; i<node->numChild; i++)

+		JabberXmlFreeNode(node->child[i]);

+	if (node->child) mir_free(node->child);

+	// Free all attributes

+	for (i=0; i<node->numAttr; i++) {

+		if (node->attr[i]->name) mir_free(node->attr[i]->name);

+		if (node->attr[i]->value) mir_free(node->attr[i]->value);

+		mir_free(node->attr[i]);

+	}

+	if (node->attr) mir_free(node->attr);

+	// Free string field

+	if (node->text) mir_free(node->text);

+	if (node->name) mir_free(node->name);

+}

+

+BOOL JabberXmlSetCallback(XmlState *xmlState, int depth, XmlElemType type, void (*callback)(XmlNode*, void*), void *userdata)

+{

+	if (depth == 1 && type == ELEM_OPEN) {

+		xmlState->callback1_open = callback;

+		xmlState->userdata1_open = userdata;

+	}

+	else if (depth == 1 && type == ELEM_CLOSE) {

+		xmlState->callback1_close = callback;

+		xmlState->userdata1_close = userdata;

+	}

+	else if (depth == 2 && type == ELEM_OPEN) {

+		xmlState->callback2_open = callback;

+		xmlState->userdata2_open = userdata;

+	}

+	else if (depth == 2 && type == ELEM_CLOSE) {

+		xmlState->callback2_close = callback;

+		xmlState->userdata2_close = userdata;

+	}

+	else

+		return FALSE;

+

+	return TRUE;

+}

+

+#define TAG_MAX_LEN 50

+#define ATTR_MAX_LEN 1024

+int JabberXmlParse(XmlState *xmlState, char *buffer, int datalen)

+{

+	char *p, *q, *r, *eob;

+	char *str;

+	int num;

+	char tag[TAG_MAX_LEN];

+	char attr[ATTR_MAX_LEN];

+	XmlElemType elemType = ELEM_OPEN;

+

+	eob = buffer + datalen;

+	num = 0;

+	// Skip leading whitespaces

+	for (p=buffer; p<eob && isspace(*p); p++,num++);

+	while (num < datalen) {

+		if (*p == '<') {	// found starting bracket

+			for (q=p+1; q<eob && *q != '>'; q++);

+			if (q < eob) {	// found closing bracket

+				for (r=p+1; *r != '>' && *r != ' ' && *r != '\t'; r++);

+				if (r-(p+1) > TAG_MAX_LEN) {

+//					JabberLog("TAG_MAX_LEN too small, ignore current tag");

+				}

+				else {

+					if (*(p+1) == '/') {	// closing tag

+						strncpy(tag, p+2, r-(p+2));

+						tag[r-(p+2)] = '\0';

+						elemType = ELEM_CLOSE;

+					}

+					else {

+						if (*(r-1) == '/') {	// single open/close tag

+							strncpy(tag, p+1, r-(p+1)-1);

+							tag[r-(p+1)-1] = '\0';

+							elemType = ELEM_OPENCLOSE;

+						}

+						else {

+							strncpy(tag, p+1, r-(p+1));

+							tag[r-(p+1)] = '\0';

+							elemType = ELEM_OPEN;

+						}

+					}

+					for (;r<q && (*r == ' ' || *r == '\t'); r++);

+					if (q-r > ATTR_MAX_LEN) {

+//						JabberLog("ATTR_MAX_LEN too small, ignore current tag");

+					}

+					else {

+						strncpy(attr, r, q-r);

+						if ((q-r)>0 && attr[q-r-1] == '/') {

+							attr[q-r-1] = '\0';

+							elemType = ELEM_OPENCLOSE;

+						}

+						else

+							attr[q-r] = '\0';

+						JabberXmlProcessElem(xmlState, elemType, tag, attr);

+					}

+				}

+				num += (q-p+1);

+				p = q + 1;

+				if (elemType == ELEM_CLOSE || elemType == ELEM_OPENCLOSE) {

+					// Skip whitespaces after end tags

+					for (; p<eob && isspace(*p); p++,num++);

+				}

+			}

+			else

+				break;

+		}

+		else {	// found inner text

+			for (q=p+1; q<eob && *q != '<'; q++);

+			if (q < eob) {	// found starting bracket of the next element

+				str = (char *) mir_alloc(q-p+1);

+				strncpy(str, p, q-p);

+				str[q-p] = '\0';

+				JabberXmlProcessElem(xmlState, ELEM_TEXT, str, NULL);

+				mir_free(str);

+				num += (q-p);

+				p = q;

+			}

+			else

+				break;

+		}

+	}

+

+	return num;

+}

+

+static void JabberXmlParseAttr(XmlNode *node, char *text)

+{

+	char *kstart, *vstart;

+	int klen, vlen;

+	char *p;

+	XmlAttr *a;

+

+	if (node == NULL || text == NULL || strlen(text) <= 0)

+		return;

+

+	for (p=text;;) {

+

+		// Skip leading whitespaces

+		for (;*p != '\0' && (*p == ' ' || *p == '\t'); p++);

+		if (*p == '\0')

+			break;

+

+		// Fetch key

+		kstart = p;

+		for (;*p != '\0' && *p != '=' && *p != ' ' && *p != '\t'; p++);

+		klen = p-kstart;

+

+		if (node->numAttr >= node->maxNumAttr) {

+			node->maxNumAttr = node->numAttr + 20;

+			node->attr = (XmlAttr **) mir_realloc(node->attr, node->maxNumAttr*sizeof(XmlAttr *));

+		}

+		a = node->attr[node->numAttr] = (XmlAttr *) mir_alloc(sizeof(XmlAttr));

+		node->numAttr++;

+

+		// Skip possible whitespaces between key and '='

+		for (;*p != '\0' && (*p == ' ' || *p == '\t'); p++);

+

+		if (*p == '\0') {

+			a->name = (char *) mir_alloc(klen+1);

+			strncpy(a->name, kstart, klen);

+			a->name[klen] = '\0';

+			a->value = mir_strdup("");

+			break;

+		}

+

+		if (*p != '=') {

+			a->name = (char *) mir_alloc(klen+1);

+			strncpy(a->name, kstart, klen);

+			a->name[klen] = '\0';

+			a->value = mir_strdup("");

+			continue;

+		}

+

+		// Found '='

+		p++;

+

+		// Skip possible whitespaces between '=' and value

+		for (;*p != '\0' && (*p == ' ' || *p == '\t'); p++);

+

+		if (*p == '\0') {

+			a->name = (char *) mir_alloc(klen+1);

+			strncpy(a->name, kstart, klen);

+			a->name[klen] = '\0';

+			a->value = mir_strdup("");

+			break;

+		}

+

+		// Fetch value

+		if (*p == '\'' || *p == '"') {

+			p++;

+			vstart = p;

+			for (;*p != '\0' && *p != *(vstart-1); p++);

+			vlen = p-vstart;

+			if (*p != '\0') p++;

+		}

+		else {

+			vstart = p;

+			for (;*p != '\0' && *p != ' ' && *p != '\t'; p++);

+			vlen = p-vstart;

+		}

+

+		a->name = (char *) mir_alloc(klen+1);

+		strncpy(a->name, kstart, klen);

+		a->name[klen] = '\0';

+		a->value = (char *) mir_alloc(vlen+1);

+		strncpy(a->value, vstart, vlen);

+		a->value[vlen] = '\0';

+	}

+}

+

+static BOOL JabberXmlProcessElem(XmlState *xmlState, XmlElemType elemType, char *elemText, char *elemAttr)

+{

+	XmlNode *node, *parentNode, *n;

+	//BOOL activateCallback = FALSE;

+	char *text, *attr;

+

+	if (elemText == NULL) return FALSE;

+

+	if (elemType == ELEM_OPEN && !strcmp(elemText, "?xml")) {

+//		JabberLog("XML: skip <?xml> tag");

+		return TRUE;

+	}

+

+	// Find active node

+	node = &(xmlState->root);

+	parentNode = NULL;

+	while (node->numChild>0 && node->child[node->numChild-1]->state == NODE_OPEN) {

+		parentNode = node;

+		node = node->child[node->numChild-1];

+	}

+

+	if (node->state != NODE_OPEN) return FALSE;

+

+	text = mir_strdup(elemText);

+

+	if (elemAttr)

+		attr = mir_strdup(elemAttr);

+	else

+		attr = NULL;

+

+	switch (elemType) {

+	case ELEM_OPEN:

+		if (node->numChild >= node->maxNumChild) {

+			node->maxNumChild = node->numChild + 20;

+			node->child = (XmlNode **) mir_realloc(node->child, node->maxNumChild*sizeof(XmlNode *));

+		}

+		n = node->child[node->numChild] = (XmlNode *) mir_alloc(sizeof(XmlNode));

+		node->numChild++;

+		n->name = text;

+		n->depth = node->depth + 1;

+		n->state = NODE_OPEN;

+		n->numChild = n->maxNumChild = 0;

+		n->child = NULL;

+		n->numAttr = n->maxNumAttr = 0;

+		n->attr = NULL;

+		JabberXmlParseAttr(n, attr);

+		n->text = NULL;

+		if (n->depth == 1 && xmlState->callback1_open != NULL)

+			(*(xmlState->callback1_open))(n, xmlState->userdata1_open);

+		if (n->depth == 2 && xmlState->callback2_open != NULL)

+			(*xmlState->callback2_open)(n, xmlState->userdata2_open);

+		break;

+	case ELEM_OPENCLOSE:

+		if (node->numChild >= node->maxNumChild) {

+			node->maxNumChild = node->numChild + 20;

+			node->child = (XmlNode **) mir_realloc(node->child, node->maxNumChild*sizeof(XmlNode *));

+		}

+		n = node->child[node->numChild] = (XmlNode *) mir_alloc(sizeof(XmlNode));

+		node->numChild++;

+		n->name = text;

+		n->depth = node->depth + 1;

+		n->state = NODE_CLOSE;

+		n->numChild = n->maxNumAttr = 0;

+		n->child = NULL;

+		n->numAttr = n->maxNumAttr = 0;

+		n->attr = NULL;

+		JabberXmlParseAttr(n, attr);

+		n->text = NULL;

+		if (n->depth == 1 && xmlState->callback1_close != NULL) {

+			(*(xmlState->callback1_close))(n, xmlState->userdata1_close);

+			JabberXmlRemoveChild(node, n);

+		}

+		if (n->depth == 2 && xmlState->callback2_close != NULL) {

+			(*xmlState->callback2_close)(n, xmlState->userdata2_close);

+			JabberXmlRemoveChild(node, n);

+		}

+		break;

+	case ELEM_CLOSE:

+		if (node->name != NULL && !strcmp(node->name, text)) {

+			node->state = NODE_CLOSE;

+			if (node->depth == 1 && xmlState->callback1_close != NULL) {

+				(*(xmlState->callback1_close))(node, xmlState->userdata1_close);

+				JabberXmlRemoveChild(parentNode, node);

+			}

+			if (node->depth == 2 && xmlState->callback2_close != NULL) {

+				(*xmlState->callback2_close)(node, xmlState->userdata2_close);

+				JabberXmlRemoveChild(parentNode, node);

+			}

+			mir_free(text);

+		}

+		else {

+//			JabberLog("XML: Closing </%s> without opening tag", text);

+			mir_free(text);

+			if (attr) mir_free(attr);

+			return FALSE;

+		}

+		break;

+	case ELEM_TEXT:

+		node->text = text;

+		break;

+	default:

+		mir_free(text);

+		if (attr) mir_free(attr);

+		return FALSE;

+	}

+

+	if (attr) mir_free(attr);

+

+	return TRUE;

+}

+

+char *JabberXmlGetAttrValue(XmlNode *node, char *key)

+{

+	int i;

+

+	if (node == NULL || node->numAttr <= 0 || key == NULL || strlen(key) <= 0)

+		return NULL;

+	for (i=0; i<node->numAttr; i++) {

+		if (node->attr[i]->name && !strcmp(key, node->attr[i]->name))

+			return node->attr[i]->value;

+	}

+	return NULL;

+}

+

+XmlNode *JabberXmlGetChild(XmlNode *node, char *tag)

+{

+	return JabberXmlGetNthChild(node, tag, 1);

+}

+

+XmlNode *JabberXmlGetNthChild(XmlNode *node, char *tag, int nth)

+{

+	int i, num;

+

+	if (node == NULL || node->numChild <= 0 || tag == NULL || strlen(tag) <= 0 || nth < 1)

+		return NULL;

+	num = 1;

+	for (i=0; i<node->numChild; i++) {

+		if (node->child[i]->name && !strcmp(tag, node->child[i]->name)) {

+			if (num == nth) {

+				return node->child[i];

+			}

+			num++;

+		}

+	}

+	return NULL;

+}

+

+XmlNode *JabberXmlGetChildWithGivenAttrValue(XmlNode *node, char *tag, char *attrKey, char *attrValue)

+{

+	int i;

+	char *str;

+

+	if (node == NULL || node->numChild <= 0 || tag == NULL || strlen(tag) <= 0 || attrKey == NULL || strlen(attrKey) <= 0 || attrValue == NULL || strlen(attrValue) <= 0)

+		return NULL;

+	for (i=0; i<node->numChild; i++) {

+		if (node->child[i]->name && !strcmp(tag, node->child[i]->name)) {

+			if ((str=JabberXmlGetAttrValue(node->child[i], attrKey)) != NULL)

+				if (!strcmp(str, attrValue))

+					return node->child[i];

+		}

+	}

+	return NULL;

+}

+

+static void JabberXmlRemoveChild(XmlNode *node, XmlNode *child)

+{

+	int i;

+

+	if (node == NULL || child == NULL || node->numChild <= 0) return;

+	for (i=0; i<node->numChild; i++) {

+		if (node->child[i] == child)

+			break;

+	}

+	if (i < node->numChild) {

+		for (++i; i<node->numChild; i++)

+			node->child[i-1] = node->child[i];

+		node->numChild--;

+		JabberXmlFreeNode(child);

+	}

+}

+

+void JabberXmlFreeNode(XmlNode *node)

+{

+	int i;

+

+	if (node == NULL) return;

+	// Free all children first

+	for (i=0; i<node->numChild; i++)

+		JabberXmlFreeNode(node->child[i]);

+	if (node->child) mir_free(node->child);

+	// Free all attributes

+	for (i=0; i<node->numAttr; i++) {

+		if (node->attr[i]->name) mir_free(node->attr[i]->name);

+		if (node->attr[i]->value) mir_free(node->attr[i]->value);

+		mir_free(node->attr[i]);

+	}

+	if (node->attr) mir_free(node->attr);

+	// Free string field

+	if (node->text) mir_free(node->text);

+	if (node->name) mir_free(node->name);

+	// Free the node itself

+	mir_free(node);

+}

+

+XmlNode *JabberXmlCopyNode(XmlNode *node)

+{

+	XmlNode *n;

+	int i;

+

+	if (node == NULL) return NULL;

+	n = (XmlNode *) mir_alloc(sizeof(XmlNode));

+	// Copy attributes

+	if (node->numAttr > 0) {

+		n->attr = (XmlAttr **) mir_alloc(node->numAttr*sizeof(XmlAttr *));

+		for (i=0; i<node->numAttr; i++) {

+			n->attr[i] = (XmlAttr *) mir_alloc(sizeof(XmlAttr));

+			if (node->attr[i]->name) n->attr[i]->name = mir_strdup(node->attr[i]->name);

+			else n->attr[i]->name = NULL;

+			if (node->attr[i]->value) n->attr[i]->value = mir_strdup(node->attr[i]->value);

+			else n->attr[i]->value = NULL;

+		}

+	}

+	else

+		n->attr = NULL;

+	// Recursively copy children

+	if (node->numChild > 0) {

+		n->child = (XmlNode **) mir_alloc(node->numChild*sizeof(XmlNode *));

+		for (i=0; i<node->numChild; i++)

+			n->child[i] = JabberXmlCopyNode(node->child[i]);

+	}

+	else

+		n->child = NULL;

+	// Copy other fields

+	n->numAttr = node->numAttr;

+	n->maxNumAttr = node->numAttr;

+	n->numChild = node->numChild;

+	n->maxNumChild = node->numChild;

+	n->depth = node->depth;

+	n->state = node->state;

+	n->name = (node->name)?mir_strdup(node->name):NULL;

+	n->text = (node->text)?mir_strdup(node->text):NULL;

+

+	return n;

+}

+

+XmlNode *JabberXmlCreateNode(char *name)

+{

+	XmlNode *n;

+

+	if (name == NULL)

+		return NULL;

+

+	n = (XmlNode *) mir_alloc(sizeof(XmlNode));

+	memset(n, 0, sizeof(XmlNode));

+	n->name = mir_strdup(name);

+	return n;

+}

+

+void JabberXmlAddAttr(XmlNode *n, char *name, char *value)

+{

+	int i;

+

+	if (n == NULL || name == NULL || value == NULL)

+		return;

+

+	i = n->numAttr;

+	(n->numAttr)++;

+	n->attr = (XmlAttr **) mir_realloc(n->attr, sizeof(XmlAttr *) * n->numAttr);

+	n->attr[i] = (XmlAttr *) mir_alloc(sizeof(XmlAttr));

+	n->attr[i]->name = mir_strdup(name);

+	n->attr[i]->value = mir_strdup(value);

+}

+

+XmlNode *JabberXmlAddChild(XmlNode *n, char *name)

+{

+	int i;

+

+	if (n == NULL || name == NULL)

+		return NULL;

+

+	i = n->numChild;

+	n->numChild++;

+	n->child = (XmlNode **) mir_realloc(n->child, sizeof(XmlNode *) * n->numChild);

+	n->child[i] = (XmlNode *) mir_alloc(sizeof(XmlNode));

+	memset(n->child[i], 0, sizeof(XmlNode));

+	n->child[i]->name = mir_strdup(name);

+	return n->child[i];

+}

+

+void JabberXmlAddText(XmlNode *n, char *text)

+{

+	if (n != NULL && text != NULL) {

+		if (n->text) mir_free(n->text);

+		n->text = mir_strdup(text);

+	}

+}

+