dav: comparison dav/config.c

-:1d2be1b31e70
+:d7c4ba50b7d8
 #include <libidav/utils.h>
 #define xstreq(a,b) xmlStrEqual(BAD_CAST a, BAD_CAST b)
 #define xstrEQ(a,b) !xmlStrcasecmp(BAD_CAST a, BAD_CAST b)
-#define print_error(...) \
+#define print_error(lineno, ...) \
 do {\
-fprintf(stderr, "Error (config.xml): " __VA_ARGS__); \
+fprintf(stderr, "Error (config.xml line %u): ", lineno); \
+fprintf(stderr, __VA_ARGS__); \
 fprintf(stderr, "Abort.\n"); \
 } while(0);
-#define print_warning(...) \
+#define print_warning(lineno, ...) \
-fprintf(stderr, "Warning (config.xml): " __VA_ARGS__);
+do {\
+fprintf(stderr, "Warning (config.xml line %u): ", lineno); \
+fprintf(stderr, __VA_ARGS__); \
+} while(0);
 #ifdef _WIN32
 #define ENV_HOME getenv("USERPROFILE")
 #else
 #define ENV_HOME getenv("HOME")
 repo->ssl_version = CURL_SSLVERSION_DEFAULT;
 repo->authmethods = CURLAUTH_BASIC;
 return repo;
 }
-int load_repository(xmlNode *reponode) {
+static int repo_add_config(Repository *repo, const xmlNode* node) {
-Repository *repo = repository_new();
+unsigned short lineno = node->line;
-{
+char *key = (char*)node->name;
-xmlNode *node = reponode->children;
+char *value = util_xml_get_text(node);
-int ret = 0;
-while(node && !ret) {
-if(node->type == XML_ELEMENT_NODE) {
-char *name = (char*)node->name;
-char *value = util_xml_get_text(node);
-ret = repo_add_config(repo, name, value);
-}
-node = node->next;
-}
-if(ret) {
-free(repo);
-return 1;
-}
-}
-if(!repo->name) {
-print_error("missing name for repository.\n");
-return 1;
-}
-if(!repo->url) {
-print_error("missing url for repository '%s'.\n", repo->name);
-return 1;
-}
-ucx_map_cstr_put(repos, repo->name, repo);
-return 0;
-}
-int repo_add_config(Repository *repo, char *key, char *value) {
 /* every key needs a value */
 if(!value) {
 /* TODO: maybe this should only be reported, if the key is valid
 * But this makes the code very ugly.
 */
-print_error("missing value for config element: %s\n", key);
+print_error(lineno, "missing value for config element: %s\n", key);
 return 1;
 }
 if(xstreq(key, "name")) {
 repo->name = strdup(value);
 repo->ssl_version = CURL_SSLVERSION_TLSv1_2;
 }
 #endif
 #endif
 else {
-print_warning("unknown ssl version: %s\n", value);
+print_warning(lineno, "unknown ssl version: %s\n", value);
 }
 } else if(xstreq(key, "authmethods")) {
 repo->authmethods = CURLAUTH_NONE;
 const char *delims = " \r\n";
 char *meths = strdup(value);
 } else if(xstrEQ(value, "any")) {
 repo->authmethods = CURLAUTH_ANY;
 } else if(xstrEQ(value, "none")) {
 /* skip */
 } else {
-print_warning("unknown authentication method: %s\n", value);
+print_warning(lineno,
+"unknown authentication method: %s\n", value);
 }
 meth = strtok(NULL, delims);
 }
 free(meths);
 } else {
-print_error("unkown repository config element: %s\n", key);
+print_error(lineno, "unkown repository config element: %s\n", key);
 return 1;
 }
 return 0;
 }
-int load_proxy(DavProxy *proxy, xmlNode *proxynode, int type) {
+int load_repository(const xmlNode *reponode) {
+Repository *repo = repository_new();
+{
+xmlNode *node = reponode->children;
+int ret = 0;
+while(node && !ret) {
+if(node->type == XML_ELEMENT_NODE) {
+ret = repo_add_config(repo, node);
+}
+node = node->next;
+}
+if(ret) {
+free(repo);
+return 1;
+}
+}
+if(!repo->name) {
+print_error(reponode->line, "missing name for repository.\n");
+return 1;
+}
+if(!repo->url) {
+print_error(reponode->line,
+"missing url for repository '%s'.\n", repo->name);
+return 1;
+}
+ucx_map_cstr_put(repos, repo->name, repo);
+return 0;
+}
+int load_proxy(DavProxy *proxy, const xmlNode *proxynode, int type) {
 const char *stype;
 if(type == HTTPS_PROXY) {
 stype = "https";
 } else if(type == HTTP_PROXY) {
 stype = "http";
 }
 if(!proxy) {
-print_error("no memory reserved for %s proxy.\n", stype);
+// no xml error - so report this directly via fprintf
+fprintf(stderr, "no memory reserved for %s proxy.\n", stype);
 return 1;
 }
 xmlNode *node = proxynode->children;
 int ret = 0;
 } else if(xstreq(node->name, "no")) {
 if(!(reportmissingvalue = !value)) {
 proxy->no_proxy = strdup(value);
 }
 } else {
-print_error("invalid element for proxy config: %s\n",
+print_error(node->line,
+"invalid element for proxy config: %s\n", node->name);
+ret = 1;
+}
+if (reportmissingvalue) {
+print_error(node->line,
+"missing value for proxy configuration element: %s\n",
 node->name);
 ret = 1;
 }
-if (reportmissingvalue) {
-print_error("missing value for proxy configuration "
-"element '%s'.\n", node->name);
-ret = 1;
-}
 }
 node = node->next;
 }
 if(!ret && !proxy->url) {
-print_error("missing url for %s proxy.\n", stype);
+print_error(proxynode->line, "missing url for %s proxy.\n", stype);
 return 1;
 }
 return ret;
 }
-int load_key(xmlNode *keynode) {
+int load_key(const xmlNode *keynode) {
 xmlNode *node = keynode->children;
 Key *key = calloc(1, sizeof(Key));
 key->type = KEY_AES256;
 int error = 0;
 sstr_t key_data = load_key_file(value);
 if(key_data.length > 0) {
 key->data = key_data.ptr;
 key->length = key_data.length;
 } else {
-print_error("cannot get key from file: %s\n", value);
+print_error(node->line,
+"cannot get key from file: %s\n", value);
 error = 1;
 }
 } else if(xstreq(node->name, "type")) {
 if(!strcmp(value, "aes128")) {
 key->type = KEY_AES128;
 } else if(!strcmp(value, "aes256")) {
 key->type = KEY_AES256;
 } else {
-print_error("unknown key type %s\n", value);
+print_error(node->line, "unknown key type %s\n", value);
 error = 1;
 }
 }
 }
 }
 if(key->type == KEY_AES256) {
 expected_length = 32;
 }
 if(key->length < expected_length) {
-print_error("key %s is too small (%zu < %zu)\n",
+print_error(keynode->line, "key %s is too small (%zu < %zu)\n",
 key->name,
 key->length,
 expected_length);
 error = 1;
 }

Mercurial > hg > dav / file comparison

comparison: dav/config.c

dav/config.c