void NormalizeString (DPL::Optional<DPL::String>& txt)
{
if (!!txt) {
std::string tmp = DPL::ToUTF8String(*txt);
const xmlChar* str = reinterpret_cast<const xmlChar*>(tmp.c_str());
if (!xmlCheckUTF8(str)) {
LogError("Not valid UTF8");
return;
}
int i = 0;
xmlChar* c;
while ((c = const_cast<xmlChar*>(xmlUTF8Strpos(str, i))) != NULL) {
if (!IsSpace(c)) {
break;
}
++i;
}
xmlChar* tmpnew = xmlUTF8Strndup(c, xmlUTF8Strlen(c) + 1);
bool first = false;
xmlChar* s = tmpnew;
while ((c = const_cast<xmlChar*>(xmlUTF8Strpos(str, i))) != NULL) {
if (IsSpace(c)) {
first = true;
++i;
} else {
if (c[0] == 0x0) {
break;
}
if (first) {
xmlChar space[6] = { 0x20 };
CopyChar(s, space);
s += xmlUTF8Size(s);
first = false;
}
CopyChar(s, c);
s += xmlUTF8Size(s);
++i;
}
}
s[0] = 0x0;
txt = DPL::FromUTF8String(reinterpret_cast<char*>(tmpnew));
xmlFree(tmpnew);
}
}
/**
* xmlUTF8Charcmp:
* @utf1: pointer to first UTF8 char
* @utf2: pointer to second UTF8 char
*
* compares the two UCS4 values
*
* returns result of the compare as with xmlStrncmp
*/
int
xmlUTF8Charcmp(const xmlChar *utf1, const xmlChar *utf2) {
if (utf1 == NULL ) {
if (utf2 == NULL)
return 0;
return -1;
}
return xmlStrncmp(utf1, utf2, xmlUTF8Size(utf1));
}
bool CopyChar(xmlChar* out,
xmlChar* in)
{
int size = xmlUTF8Size(in);
switch (size) {
case 6:
out[5] = in[5];
case 5:
out[4] = in[4];
case 4:
out[3] = in[3];
case 3:
out[2] = in[2];
case 2:
out[1] = in[1];
case 1:
out[0] = in[0];
return true;
default:
return false;
}
}
/**
* exsltStrReplaceFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Takes a string, and two node sets and returns the string with all strings in
* the first node set replaced by all strings in the second node set.
*/
static void
exsltStrReplaceFunction (xmlXPathParserContextPtr ctxt, int nargs) {
int i, i_empty, n, slen0, rlen0, *slen, *rlen;
void *mem = NULL;
const xmlChar *src, *start;
xmlChar *string, *search_str = NULL, *replace_str = NULL;
xmlChar **search, **replace;
xmlNodeSetPtr search_set = NULL, replace_set = NULL;
xmlBufferPtr buf;
if (nargs != 3) {
xmlXPathSetArityError(ctxt);
return;
}
/* get replace argument */
if (!xmlXPathStackIsNodeSet(ctxt))
replace_str = xmlXPathPopString(ctxt);
else
replace_set = xmlXPathPopNodeSet(ctxt);
if (xmlXPathCheckError(ctxt))
goto fail_replace;
/* get search argument */
if (!xmlXPathStackIsNodeSet(ctxt)) {
search_str = xmlXPathPopString(ctxt);
n = 1;
}
else {
search_set = xmlXPathPopNodeSet(ctxt);
n = search_set != NULL ? search_set->nodeNr : 0;
}
if (xmlXPathCheckError(ctxt))
goto fail_search;
/* get string argument */
string = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
goto fail_string;
/* check for empty search node list */
if (n <= 0) {
exsltStrReturnString(ctxt, string, xmlStrlen(string));
goto done_empty_search;
}
/* allocate memory for string pointer and length arrays */
if (n == 1) {
search = &search_str;
replace = &replace_str;
slen = &slen0;
rlen = &rlen0;
}
else {
mem = xmlMalloc(2 * n * (sizeof(const xmlChar *) + sizeof(int)));
if (mem == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_malloc;
}
search = (xmlChar **) mem;
replace = search + n;
slen = (int *) (replace + n);
rlen = slen + n;
}
/* process arguments */
i_empty = -1;
for (i=0; i<n; ++i) {
if (search_set != NULL) {
search[i] = xmlXPathCastNodeToString(search_set->nodeTab[i]);
if (search[i] == NULL) {
n = i;
goto fail_process_args;
}
}
slen[i] = xmlStrlen(search[i]);
if (i_empty < 0 && slen[i] == 0)
i_empty = i;
if (replace_set != NULL) {
if (i < replace_set->nodeNr) {
replace[i] = xmlXPathCastNodeToString(replace_set->nodeTab[i]);
if (replace[i] == NULL) {
n = i + 1;
goto fail_process_args;
}
}
else
replace[i] = NULL;
}
else {
if (i == 0)
replace[i] = replace_str;
else
replace[i] = NULL;
}
if (replace[i] == NULL)
rlen[i] = 0;
else
rlen[i] = xmlStrlen(replace[i]);
}
if (i_empty >= 0 && rlen[i_empty] == 0)
i_empty = -1;
/* replace operation */
buf = xmlBufferCreate();
if (buf == NULL) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer;
}
src = string;
start = string;
while (*src != 0) {
int max_len = 0, i_match = 0;
for (i=0; i<n; ++i) {
if (*src == search[i][0] &&
slen[i] > max_len &&
xmlStrncmp(src, search[i], slen[i]) == 0)
{
i_match = i;
max_len = slen[i];
}
}
if (max_len == 0) {
if (i_empty >= 0 && start < src) {
if (xmlBufferAdd(buf, start, src - start) ||
xmlBufferAdd(buf, replace[i_empty], rlen[i_empty]))
{
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
start = src;
}
src += xmlUTF8Size(src);
}
else {
if ((start < src &&
xmlBufferAdd(buf, start, src - start)) ||
(rlen[i_match] &&
xmlBufferAdd(buf, replace[i_match], rlen[i_match])))
{
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
src += slen[i_match];
start = src;
}
}
if (start < src && xmlBufferAdd(buf, start, src - start)) {
xmlXPathSetError(ctxt, XPATH_MEMORY_ERROR);
goto fail_buffer_add;
}
/* create result node set */
exsltStrReturnString(ctxt, xmlBufferContent(buf), xmlBufferLength(buf));
/* clean up */
fail_buffer_add:
xmlBufferFree(buf);
fail_buffer:
fail_process_args:
if (search_set != NULL) {
for (i=0; i<n; ++i)
xmlFree(search[i]);
}
if (replace_set != NULL) {
for (i=0; i<n; ++i) {
if (replace[i] != NULL)
xmlFree(replace[i]);
}
}
if (mem != NULL)
xmlFree(mem);
fail_malloc:
done_empty_search:
xmlFree(string);
fail_string:
if (search_set != NULL)
xmlXPathFreeNodeSet(search_set);
else
xmlFree(search_str);
fail_search:
if (replace_set != NULL)
xmlXPathFreeNodeSet(replace_set);
else
xmlFree(replace_str);
fail_replace:
return;
}
/**
* exsltStrTokenizeFunction:
* @ctxt: an XPath parser context
* @nargs: the number of arguments
*
* Splits up a string on the characters of the delimiter string and returns a
* node set of token elements, each containing one token from the string.
*/
static void
exsltStrTokenizeFunction(xmlXPathParserContextPtr ctxt, int nargs)
{
xsltTransformContextPtr tctxt;
xmlChar *str, *delimiters, *cur;
const xmlChar *token, *delimiter;
xmlNodePtr node;
xmlDocPtr container;
xmlXPathObjectPtr ret = NULL;
int clen;
if ((nargs < 1) || (nargs > 2)) {
xmlXPathSetArityError(ctxt);
return;
}
if (nargs == 2) {
delimiters = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt))
return;
} else {
delimiters = xmlStrdup((const xmlChar *) "\t\r\n ");
}
if (delimiters == NULL)
return;
str = xmlXPathPopString(ctxt);
if (xmlXPathCheckError(ctxt) || (str == NULL)) {
xmlFree(delimiters);
return;
}
/* Return a result tree fragment */
tctxt = xsltXPathGetTransformContext(ctxt);
if (tctxt == NULL) {
xsltTransformError(xsltXPathGetTransformContext(ctxt), NULL, NULL,
"exslt:tokenize : internal error tctxt == NULL\n");
goto fail;
}
container = xsltCreateRVT(tctxt);
if (container != NULL) {
xsltRegisterLocalRVT(tctxt, container);
ret = xmlXPathNewNodeSet(NULL);
if (ret != NULL) {
for (cur = str, token = str; *cur != 0; cur += clen) {
clen = xmlUTF8Size(cur);
if (*delimiters == 0) { /* empty string case */
xmlChar ctmp;
ctmp = *(cur+clen);
*(cur+clen) = 0;
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", cur);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*(cur+clen) = ctmp; /* restore the changed byte */
token = cur + clen;
} else for (delimiter = delimiters; *delimiter != 0;
delimiter += xmlUTF8Size(delimiter)) {
if (!xmlUTF8Charcmp(cur, delimiter)) {
if (cur == token) {
/* discard empty tokens */
token = cur + clen;
break;
}
*cur = 0; /* terminate the token */
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
*cur = *delimiter; /* restore the changed byte */
token = cur + clen;
break;
}
}
}
if (token != cur) {
node = xmlNewDocRawNode(container, NULL,
(const xmlChar *) "token", token);
xmlAddChild((xmlNodePtr) container, node);
xmlXPathNodeSetAddUnique(ret->nodesetval, node);
}
/*
* Mark it as a function result in order to avoid garbage
* collecting of tree fragments
*/
xsltExtensionInstructionResultRegister(tctxt, ret);
}
}
fail:
if (str != NULL)
xmlFree(str);
if (delimiters != NULL)
xmlFree(delimiters);
if (ret != NULL)
valuePush(ctxt, ret);
else
valuePush(ctxt, xmlXPathNewNodeSet(NULL));
}
bool IsSpace(const xmlChar* str)
{
int charlen = xmlUTF8Size(str);
switch (charlen) {
case 1:
switch (*str) {
case 0x09:
case 0x0a:
case 0x0b:
case 0x0c:
case 0x0d:
case 0x20:
return true;
default:
return false;
}
case 2:
switch (*(str + 1)) {
case 0x85:
case 0xa0:
return true;
default:
return false;
}
case 3:
switch (*str) {
case 0xe1:
{
unsigned char c2 = *(str + 1);
unsigned char c3 = *(str + 2);
if ((c2 == 0x9a && c3 == 0x80) || (c2 == 0xa0 && c3 == 0x8e)) {
return true;
} else {
return false;
}
}
case 0xe2:
switch (*(str + 1)) {
case 0x80:
switch (*(str + 2)) {
case 0x80:
case 0x81:
case 0x82:
case 0x83:
case 0x84:
case 0x85:
case 0x86:
case 0x87:
case 0x88:
case 0x89:
case 0x8a:
case 0xa8:
case 0xa9:
case 0xaf:
return true;
}
case 0x81:
if (*(str + 2) == 0x9f) {
return true;
} else {
return false;
}
default:
return false;
}
case 0xe3:
if (*(str + 1) == 0x80 && *(str + 2) == 0x80) {
return true;
} else {
return false;
}
default:
return false;
}
default:
return false;
}
}
/**
* print_element_names:
* @a_node: the initial xml node to consider.
*
* Prints the names of the all the xml elements
* that are siblings or children of a given xml node.
*/
gchar *
read_connection(struct connection *conn, xmlNode * a_node)
{
static gchar err[512];
bzero(conn, sizeof(*conn));
xmlAttr *properties = a_node->properties;
/* Set some defaults */
conn->allocation_type = ALLOCATION_TYPE_DHCP;
conn->connection_type = CONNECTION_TYPE_WLAN;
conn->phy.wlan.auth_type = AUTH_TYPE_OPEN;
conn->phy.wlan.encryption_type = ENCRYPTION_TYPE_NONE;
conn->phy.wlan.key_type = KEY_TYPE_ASCII;
for(properties = a_node->properties; properties; properties = properties->next) {
char *name = (char *)properties->name;
char *value = (char *)properties->children->content;
if(!strcmp(name, "type")) {
if(!strcmp(value, "wlan"))
conn->connection_type = CONNECTION_TYPE_WLAN;
else if(!strcmp(value, "lan"))
conn->connection_type = CONNECTION_TYPE_LAN;
else {
conn->connection_type = CONNECTION_TYPE_UNKNOWN;
g_snprintf(err, sizeof(err), "Unrecognized connection type: %s\n", value);
return err;
}
}
else if(!strcmp(name, "hwaddr"))
strncpy(conn->phy.wlan.hwaddr, value, sizeof(conn->phy.wlan.hwaddr)-1);
else if(!strcmp(name, "ssid")) {
strncpy(conn->phy.wlan.ssid, value, sizeof(conn->phy.wlan.ssid)-1);
conn->phy.wlan.ssid_len = xmlUTF8Size(properties->name);
}
else if(!strcmp(name, "auth")) {
if(!strcmp(value, "OPEN"))
conn->phy.wlan.auth_type = AUTH_TYPE_OPEN;
else if(!strcmp(value, "WEPAUTO"))
conn->phy.wlan.auth_type = AUTH_TYPE_WEPAUTO;
else if(!strcmp(value, "WPAPSK"))
conn->phy.wlan.auth_type = AUTH_TYPE_WPAPSK;
else if(!strcmp(value, "WPA2PSK"))
conn->phy.wlan.auth_type = AUTH_TYPE_WPA2PSK;
else {
conn->phy.wlan.auth_type = AUTH_TYPE_UNKNOWN;
g_snprintf(err, sizeof(err), "Unrecognized auth: %s\n", value);
return err;
}
}
else if(!strcmp(name, "encryption")) {
if(!strcmp(value, "NONE"))
conn->phy.wlan.encryption_type = ENCRYPTION_TYPE_NONE;
else if(!strcmp(value, "WEP"))
conn->phy.wlan.encryption_type = ENCRYPTION_TYPE_WEP;
else if(!strcmp(value, "TKIP"))
conn->phy.wlan.encryption_type = ENCRYPTION_TYPE_TKIP;
else if(!strcmp(value, "AES"))
conn->phy.wlan.encryption_type = ENCRYPTION_TYPE_AES;
else {
conn->phy.wlan.encryption_type = ENCRYPTION_TYPE_UNKNOWN;
g_snprintf(err, sizeof(err), "Unrecognized encryption: %s\n", value);
return err;
}
}
else if(!strcmp(name, "encoding")) {
if(!strcmp(value, "ascii"))
conn->phy.wlan.key_type = KEY_TYPE_ASCII;
else if(!strcmp(value, "hex"))
conn->phy.wlan.key_type = KEY_TYPE_HEX;
else {
conn->phy.wlan.key_type = KEY_TYPE_UNKNOWN;
g_snprintf(err, sizeof(err), "Unrecognized encoding type: %s\n", value);
return err;
}
}
else if(!strcmp(name, "key"))
strncpy(conn->phy.wlan.key, value, sizeof(conn->phy.wlan.key)-1);
else if(!strcmp(name, "allocation")) {
if(!strcmp(value, "static"))
conn->allocation_type = ALLOCATION_TYPE_STATIC;
else if(!strcmp(value, "dhcp"))
conn->allocation_type = ALLOCATION_TYPE_DHCP;
else {
conn->allocation_type = ALLOCATION_TYPE_UNKNOWN;
g_snprintf(err, sizeof(err), "Unrecognized allocation: %s\n", value);
return err;
}
}
else if(!strcmp(name, "ip"))
strtoip(value, &conn->ip);
else if(!strcmp(name, "netmask"))
strtoip(value, &conn->netmask);
else if(!strcmp(name, "gateway"))
strtoip(value, &conn->gateway);
else if(!strcmp(name, "nameserver1"))
strtoip(value, &conn->nameserver1);
else if(!strcmp(name, "nameserver2"))
strtoip(value, &conn->nameserver2);
else if(!strcmp(name, "username"))
; // Ignore
else {
fprintf(stderr, "Unrecognized field: %s\n", name);
}
}
return NULL;
}
