#define SWITCH_XML_WS "\t\r\n " // whitespace
#define SWITCH_XML_ERRL 128 // maximum error string length
+#include "SimpleGlob.h"
static int preprocess(const char *file, int write_fd, int rlevel);
struct xml_section_t {
const char *name;
- switch_xml_section_t section;
+ //switch_xml_section_t section;
+ uint32_t section;
};
{
size_t x;
char buf[1024] = "";
- switch_xml_section_t sections = SWITCH_XML_SECTION_RESULT;
-
+ //switch_xml_section_t sections = SWITCH_XML_SECTION_RESULT;
+ uint32_t sections = SWITCH_XML_SECTION_RESULT;
+
if (str) {
for (x = 0; x < strlen(str); x++) {
buf[x] = (char) tolower((int) str[x]);
}
}
}
- return sections;
+ return (switch_xml_section_t) sections;
}
SWITCH_DECLARE(switch_status_t) switch_xml_bind_search_function(switch_xml_search_function_t function, switch_xml_section_t sections, void *user_data)
switch_xml_binding_t *binding = NULL, *ptr = NULL;
assert(function != NULL);
- if (!(binding = switch_core_alloc(XML_MEMORY_POOL, sizeof(*binding)))) {
+ if (!(binding = (switch_xml_binding_t *) switch_core_alloc(XML_MEMORY_POOL, sizeof(*binding)))) {
return SWITCH_STATUS_MEMERR;
}
if (ent[b++]) { // found a match
if ((c = (long) strlen(ent[b])) - 1 > (e = strchr(s, ';')) - s) {
l = (d = (long) (s - r)) + c + (long) strlen(e); // new length
- r = (r == m) ? strcpy(malloc(l), r) : realloc(r, l);
+ r = (r == m) ? strcpy((char *)malloc(l), r) : (char *)realloc(r, l);
e = strchr((s = r + d), ';'); // fix up pointers
}
xml->txt = s; // initial character content
else { // allocate our own memory and make a copy
xml->txt = (xml->flags & SWITCH_XML_TXTM) // allocate some space
- ? realloc(xml->txt, (l = strlen(xml->txt)) + len)
- : strcpy(malloc((l = strlen(xml->txt)) + len), xml->txt);
+ ? (char *)realloc(xml->txt, (l = strlen(xml->txt)) + len)
+ : strcpy((char *)malloc((l = strlen(xml->txt)) + len), xml->txt);
strcpy(xml->txt + l, s); // add new char content
if (s != m)
free(s); // free s if it was malloced by switch_xml_decode()
}
if (!root->pi[0])
- *(root->pi = malloc(sizeof(char **))) = NULL; //first pi
+ *(root->pi = (char ***)malloc(sizeof(char **))) = NULL; //first pi
while (root->pi[i] && strcmp(target, root->pi[i][0]))
i++; // find target
if (!root->pi[i]) { // new target
- root->pi = realloc(root->pi, sizeof(char **) * (i + 2));
- root->pi[i] = malloc(sizeof(char *) * 3);
+ root->pi = (char ***)realloc(root->pi, sizeof(char **) * (i + 2));
+ root->pi[i] = (char **)malloc(sizeof(char *) * 3);
root->pi[i][0] = target;
root->pi[i][1] = (char *) (root->pi[i + 1] = NULL); // terminate pi list
root->pi[i][2] = strdup(""); // empty document position list
while (root->pi[i][j])
j++; // find end of instruction list for this target
- root->pi[i] = realloc(root->pi[i], sizeof(char *) * (j + 3));
- root->pi[i][j + 2] = realloc(root->pi[i][j + 1], j + 1);
+ root->pi[i] = (char **)realloc(root->pi[i], sizeof(char *) * (j + 3));
+ root->pi[i][j + 2] = (char *)realloc(root->pi[i][j + 1], j + 1);
strcpy(root->pi[i][j + 2] + j - 1, (root->xml.name) ? ">" : "<");
root->pi[i][j + 1] = NULL; // null terminate pi list for this target
root->pi[i][j] = s; // set instruction
char q, *c, *t, *n = NULL, *v, **ent, **pe;
int i, j;
- pe = memcpy(malloc(sizeof(SWITCH_XML_NIL)), SWITCH_XML_NIL, sizeof(SWITCH_XML_NIL));
-
+ pe = (char **)memcpy(malloc(sizeof(SWITCH_XML_NIL)), SWITCH_XML_NIL, sizeof(SWITCH_XML_NIL));
+
for (s[len] = '\0'; s;) {
while (*s && *s != '<' && *s != '%')
s++; // find next declaration
}
for (i = 0, ent = (*c == '%') ? pe : root->ent; ent[i]; i++);
- ent = realloc(ent, (i + 3) * sizeof(char *)); // space for next ent
+ ent = (char **)realloc(ent, (i + 3) * sizeof(char *)); // space for next ent
if (*c == '%')
pe = ent;
else
}
s += strspn(s + 1, SWITCH_XML_WS) + 1; // find next token
- c = (strncmp(s, "CDATA", 5)) ? "*" : " "; // is it cdata?
+ c = (strncmp(s, "CDATA", 5)) ? (char *)"*" : (char *)" "; // is it cdata?
if (!strncmp(s, "NOTATION", 8))
s += strspn(s + 8, SWITCH_XML_WS) + 8;
s = (*s == '(') ? strchr(s, ')') : s + strcspn(s, SWITCH_XML_WS);
}
if (!root->attr[i]) { // new tag name
- root->attr = (!i) ? malloc(2 * sizeof(char **))
- : realloc(root->attr, (i + 2) * sizeof(char **));
- root->attr[i] = malloc(2 * sizeof(char *));
+ root->attr = (!i) ? (char ***)malloc(2 * sizeof(char **))
+ : (char ***)realloc(root->attr, (i + 2) * sizeof(char **));
+ root->attr[i] = (char **)malloc(2 * sizeof(char *));
root->attr[i][0] = t; // set tag name
root->attr[i][1] = (char *) (root->attr[i + 1] = NULL);
}
for (j = 1; root->attr[i][j]; j += 3); // find end of list
- root->attr[i] = realloc(root->attr[i], (j + 4) * sizeof(char *));
+ root->attr[i] = (char **)realloc(root->attr[i], (j + 4) * sizeof(char *));
root->attr[i][j + 3] = NULL; // null terminate list
root->attr[i][j + 2] = c; // is it cdata?
if (be == -1)
return NULL; // not UTF-16
- u = malloc(max);
+ u = (char *)malloc(max);
for (sl = 2; sl < *len - 1; sl += 2) {
c = (be) ? (((*s)[sl] & 0xFF) << 8) | ((*s)[sl + 1] & 0xFF) //UTF-16BE
: (((*s)[sl + 1] & 0xFF) << 8) | ((*s)[sl] & 0xFF); //UTF-16LE
}
while (l + 6 > max)
- u = realloc(u, max += SWITCH_XML_BUFSIZE);
+ u = (char *)realloc(u, max += SWITCH_XML_BUFSIZE);
if (c < 0x80)
u[l++] = (char) c; // US-ASCII subset
else { // multi-byte UTF-8 sequence
u[l++] = (char) (0x80 | ((c >> (6 * --b)) & 0x3F)); // payload
}
}
- return *s = realloc(u, *len = l);
+ return *s = (char *)realloc(u, *len = l);
}
// frees a tag attribute list
for (i = 0; (a = root->attr[i]) && strcmp(a[0], d); i++);
for (l = 0; *s && *s != '/' && *s != '>'; l += 2) { // new attrib
- attr = (l) ? realloc(attr, (l + 4) * sizeof(char *))
- : malloc(4 * sizeof(char *)); // allocate space
- attr[l + 3] = (l) ? realloc(attr[l + 1], (l / 2) + 2)
- : malloc(2); // mem for list of maloced vals
+ attr = (l) ? (char **)realloc(attr, (l + 4) * sizeof(char *))
+ : (char **)malloc(4 * sizeof(char *)); // allocate space
+ attr[l + 3] = (l) ? (char *)realloc(attr[l + 1], (l / 2) + 2)
+ : (char *)malloc(2); // mem for list of maloced vals
strcpy(attr[l + 3] + (l / 2), " "); // value is not malloced
attr[l + 2] = NULL; // null terminate list
attr[l + 1] = ""; // temporary attribute value
switch_size_t l, len = 0;
char *s;
- if (!(s = malloc(SWITCH_XML_BUFSIZE)))
+ if (!(s = (char *)malloc(SWITCH_XML_BUFSIZE)))
return NULL;
do {
len += (l = fread((s + len), 1, SWITCH_XML_BUFSIZE, fp));
if (l == SWITCH_XML_BUFSIZE)
- s = realloc(s, len + SWITCH_XML_BUFSIZE);
+ s = (char *)realloc(s, len + SWITCH_XML_BUFSIZE);
} while (s && l == SWITCH_XML_BUFSIZE);
if (!s)
} else { // mmap failed, read file into memory
#endif // HAVE_MMAP
l = read(fd, m = malloc(st.st_size), st.st_size);
- root = (switch_xml_root_t) switch_xml_parse_str(m, l);
+ root = (switch_xml_root_t) switch_xml_parse_str((char *)m, l);
root->dynamic = 1; // so we know to free s in switch_xml_free()
#ifdef HAVE_MMAP
}
}
-/* for apr file and directory handling */
-#include <apr_file_io.h>
-
static int preprocess_glob(const char *pattern, int write_fd, int rlevel)
{
+ char *argv[1] = {0};
+ int argc = 1;
+ char *full_path = NULL;
- switch_array_header_t *result;
- switch_memory_pool_t *pool;
- char **list;
- int i;
- char *p, *dir_path = NULL;
-
- switch_core_new_memory_pool(&pool);
- assert(pool != NULL);
-
- if (switch_is_file_path(pattern)) {
- dir_path = switch_core_strdup(pool, pattern);
- if ((p = strrchr(dir_path, *SWITCH_PATH_SEPARATOR))) {
- *p = '\0';
- }
- } else {
- p = switch_core_sprintf(pool, "%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, pattern);
- pattern = p;
- dir_path = switch_core_strdup(pool, pattern);
- if ((p = strrchr(dir_path, *SWITCH_PATH_SEPARATOR))) {
- *p = '\0';
- }
+ if (!switch_is_file_path(pattern)) {
+ full_path = switch_mprintf("%s%s%s", SWITCH_GLOBAL_dirs.conf_dir, SWITCH_PATH_SEPARATOR, pattern);
+ pattern = full_path;
}
+
+ argv[0] = (char *)pattern;
- switch_match_glob(pattern, &result, pool);
+ CSimpleGlob glob(SG_GLOB_NODOT|SG_GLOB_NOCHECK);
- list = (char **)result->elts;
+ if (SG_SUCCESS != glob.Add(argc, argv)) {
+ if (stderr) {
+ fprintf(stderr, "Error including %s\n", argv[0]);
+ }
+ goto end;
+ }
- for (i = 0; i < result->nelts; i++) {
- char *path = list[i];
- if (strcmp(path, ".") && strcmp(path, "..")) {
- p = switch_core_sprintf(pool, "%s%s%s", dir_path, SWITCH_PATH_SEPARATOR, path);
- if (preprocess(p, write_fd, rlevel) < 0) {
- const char *reason = strerror(errno);
- if (rlevel > 100) {
- reason = "Maximum recursion limit reached";
- }
- fprintf(stderr, "Error including %s (%s)\n", p, reason);
+ for (int n = 0; n < glob.FileCount(); ++n) {
+ if (preprocess(glob.File(n), write_fd, rlevel) < 0) {
+ const char *reason = strerror(errno);
+ if (rlevel > 100) {
+ reason = "Maximum recursion limit reached";
}
+ fprintf(stderr, "Error including %s (%s)\n", argv[0], reason);
}
+
}
- switch_core_destroy_memory_pool(&pool);
-
+ end:
+
+ switch_safe_free(full_path);
return write_fd;
}
if ((fd = open(file, O_RDONLY, 0)) > -1) {
fstat(fd, &st);
l = read(fd, m = malloc(st.st_size), st.st_size);
- root = (switch_xml_root_t) switch_xml_parse_str(m, l);
+ root = (switch_xml_root_t) switch_xml_parse_str((char *)m, l);
root->dynamic = 1;
close(fd);
return &root->xml;
while (s != e) {
while (*dlen + 10 > *max)
- *dst = realloc(*dst, *max += SWITCH_XML_BUFSIZE);
+ *dst = (char *)realloc(*dst, *max += SWITCH_XML_BUFSIZE);
switch (*s) {
case '\0':
static char *switch_xml_toxml_r(switch_xml_t xml, char **s, switch_size_t *len, switch_size_t *max, switch_size_t start, char ***attr, uint32_t * count)
{
int i, j;
- char *txt = (xml->parent) ? xml->parent->txt : "";
+ char *txt = (char *)(xml->parent) ? xml->parent->txt : (char *)"";
switch_size_t off = 0;
uint32_t lcount = 0;
*s = switch_xml_ampencode(txt + start, xml->off - start, s, len, max, 0);
while (*len + strlen(xml->name) + 5 + (strlen(XML_INDENT) * (*count)) + 1 > *max) // reallocate s
- *s = realloc(*s, *max += SWITCH_XML_BUFSIZE);
+ *s = (char *)realloc(*s, *max += SWITCH_XML_BUFSIZE);
if (*(*s + (*len) - 1) == '>') {
*len += sprintf(*s + *len, "\n"); // indent
if (switch_xml_attr(xml, xml->attr[i]) != xml->attr[i + 1])
continue;
while (*len + strlen(xml->attr[i]) + 7 + (strlen(XML_INDENT) * (*count)) > *max) // reallocate s
- *s = realloc(*s, *max += SWITCH_XML_BUFSIZE);
+ *s = (char *)realloc(*s, *max += SWITCH_XML_BUFSIZE);
*len += sprintf(*s + *len, " %s=\"", xml->attr[i]);
switch_xml_ampencode(xml->attr[i + 1], 0, s, len, max, 1);
if (!attr[i][j + 1] || switch_xml_attr(xml, attr[i][j]) != attr[i][j + 1])
continue; // skip duplicates and non-values
while (*len + strlen(attr[i][j]) + 8 + (strlen(XML_INDENT) * (*count)) > *max) // reallocate s
- *s = realloc(*s, *max += SWITCH_XML_BUFSIZE);
+ *s = (char *)realloc(*s, *max += SWITCH_XML_BUFSIZE);
*len += sprintf(*s + *len, " %s=\"", attr[i][j]);
switch_xml_ampencode(attr[i][j + 1], 0, s, len, max, 1);
}
while (*len + strlen(xml->name) + 5 + (strlen(XML_INDENT) * (*count)) > *max) // reallocate s
- *s = realloc(*s, *max += SWITCH_XML_BUFSIZE);
+ *s = (char *)realloc(*s, *max += SWITCH_XML_BUFSIZE);
if (xml->child || xml->txt) {
SWITCH_DECLARE(char *) switch_xml_toxml(switch_xml_t xml)
{
char *s;
- s = malloc(SWITCH_XML_BUFSIZE);
+ s = (char *)malloc(SWITCH_XML_BUFSIZE);
return switch_xml_toxml_buf(xml, s, SWITCH_XML_BUFSIZE, 0);
}
if (!xml || !xml->name) {
- if (!(r = realloc(s, len + 1))) {
+ if (!(r = (char *)realloc(s, len + 1))) {
abort();
}
return r;
continue; // not pre-root
}
while (len + strlen(t = root->pi[i][0]) + strlen(n) + 7 > max) {
- if (!(r = realloc(s, max += SWITCH_XML_BUFSIZE))) {
+ if (!(r = (char *)realloc(s, max += SWITCH_XML_BUFSIZE))) {
abort();
}
s = r;
continue; // not post-root
}
while (len + strlen(t = root->pi[i][0]) + strlen(n) + 7 > max) {
- if (!(r = realloc(s, max += SWITCH_XML_BUFSIZE))) {
+ if (!(r = (char *)realloc(s, max += SWITCH_XML_BUFSIZE))) {
abort();
}
s = r;
}
}
- if (!(r = realloc(s, len + 1))) {
+ if (!(r = (char *)realloc(s, len + 1))) {
abort();
}
root->xml.name = (char *) name;
root->cur = &root->xml;
strcpy(root->err, root->xml.txt = "");
- root->ent = memcpy(malloc(sizeof(ent)), ent, sizeof(ent));
+ root->ent = (char **)memcpy(malloc(sizeof(ent)), ent, sizeof(ent));
root->attr = root->pi = (char ***) (root->xml.attr = SWITCH_XML_NIL);
return &root->xml;
}
if (!value)
return xml; // nothing to do
if (xml->attr == SWITCH_XML_NIL) { // first attribute
- xml->attr = malloc(4 * sizeof(char *));
+ xml->attr = (char **)malloc(4 * sizeof(char *));
xml->attr[1] = strdup(""); // empty list of malloced names/vals
} else
- xml->attr = realloc(xml->attr, (l + 4) * sizeof(char *));
+ xml->attr = (char **)realloc(xml->attr, (l + 4) * sizeof(char *));
xml->attr[l] = (char *) name; // set attribute name
xml->attr[l + 2] = NULL; // null terminate attribute list
- xml->attr[l + 3] = realloc(xml->attr[l + 1], (c = (int) strlen(xml->attr[l + 1])) + 2);
+ xml->attr[l + 3] = (char *)realloc(xml->attr[l + 1], (c = (int) strlen(xml->attr[l + 1])) + 2);
strcpy(xml->attr[l + 3] + c, " "); // set name/value as not malloced
if (xml->flags & SWITCH_XML_DUP)
xml->attr[l + 3][c] = SWITCH_XML_NAMEM;
if (xml->attr[c + 1][l / 2] & SWITCH_XML_NAMEM)
free(xml->attr[l]);
memmove(xml->attr + l, xml->attr + l + 2, (c - l + 2) * sizeof(char *));
- xml->attr = realloc(xml->attr, (c + 2) * sizeof(char *));
+ xml->attr = (char **)realloc(xml->attr, (c + 2) * sizeof(char *));
memmove(xml->attr[c + 1] + (l / 2), xml->attr[c + 1] + (l / 2) + 1, (c / 2) - (l / 2)); // fix list of which name/vals are malloced
}
xml->flags &= ~SWITCH_XML_DUP; // clear strdup() flag
projects / thirdparty / freeswitch.git / commitdiff
