comparison: dav/config.c
dav/config.c
- changeset 119
- 451607eeff05
- parent 75
- 56962faf2b42
- child 142
- 0c0ccb7f71ba
equal
deleted
inserted
replaced
| 118:1e2b1005004c | 119:451607eeff05 |
|---|---|
| 134 ucx_map_free(repos); | 134 ucx_map_free(repos); |
| 135 | 135 |
| 136 ucx_map_free(keys); | 136 ucx_map_free(keys); |
| 137 } | 137 } |
| 138 | 138 |
| 139 void load_repository(xmlNode *reponode) { | 139 Repository* repository_new() { |
| 140 xmlNode *node = reponode->children; | |
| 141 Repository *repo = calloc(1, sizeof(Repository)); | 140 Repository *repo = calloc(1, sizeof(Repository)); |
| 142 repo->encrypt_name = false; | 141 repo->encrypt_name = false; |
| 143 repo->encrypt_content = false; | 142 repo->encrypt_content = false; |
| 144 repo->decrypt_name = false; | 143 repo->decrypt_name = false; |
| 145 repo->decrypt_content = true; | 144 repo->decrypt_content = true; |
| 146 repo->ssl_version = CURL_SSLVERSION_DEFAULT; | 145 repo->ssl_version = CURL_SSLVERSION_DEFAULT; |
| 146 return repo; | |
| 147 } | |
| 148 | |
| 149 void load_repository(xmlNode *reponode) { | |
| 150 xmlNode *node = reponode->children; | |
| 151 Repository *repo = repository_new(); | |
| 147 while(node) { | 152 while(node) { |
| 148 if(node->type == XML_ELEMENT_NODE) { | 153 if(node->type == XML_ELEMENT_NODE) { |
| 154 char *name = (char*)node->name; | |
| 149 char *value = util_xml_get_text(node); | 155 char *value = util_xml_get_text(node); |
| 150 if(!value) { | 156 if(value) { |
| 151 // next | 157 if(repo_add_config(repo, name, value)) { |
| 152 } else if(xstreq(node->name, "name")) { | 158 fprintf( |
| 153 repo->name = strdup(value); | 159 stderr, |
| 154 } else if(xstreq(node->name, "url")) { | 160 "Unkown repository config element: %s\n", |
| 155 repo->url = strdup(value); | 161 name); |
| 156 } else if(xstreq(node->name, "user")) { | |
| 157 repo->user = strdup(value); | |
| 158 } else if(xstreq(node->name, "password")) { | |
| 159 repo->password = util_base64decode(value); | |
| 160 } else if(xstreq(node->name, "default-key")) { | |
| 161 repo->default_key = strdup(value); | |
| 162 } else if(xstreq(node->name, "full-encryption")) { | |
| 163 if(util_getboolean(value)) { | |
| 164 repo->encrypt_name = true; | |
| 165 repo->encrypt_content = true; | |
| 166 repo->decrypt_name = true; | |
| 167 repo->decrypt_content = true; | |
| 168 } | 162 } |
| 169 } else if(xstreq(node->name, "content-encryption")) { | |
| 170 if(util_getboolean(value)) { | |
| 171 repo->encrypt_content = true; | |
| 172 repo->decrypt_content = true; | |
| 173 } else { | |
| 174 repo->encrypt_content = false; | |
| 175 } | |
| 176 } else if(xstreq(node->name, "decrypt-content")) { | |
| 177 repo->decrypt_content = util_getboolean(value); | |
| 178 } else if(xstreq(node->name, "decrypt-name")) { | |
| 179 repo->decrypt_name = util_getboolean(value); | |
| 180 } else if(xstreq(node->name, "ssl-version")) { | |
| 181 if(xstrEQ(value, "TLSv1")) { | |
| 182 repo->ssl_version = CURL_SSLVERSION_TLSv1; | |
| 183 } else if(xstrEQ(value, "SSLv2")) { | |
| 184 repo->ssl_version = CURL_SSLVERSION_SSLv2; | |
| 185 } else if(xstrEQ(value, "SSLv3")) { | |
| 186 repo->ssl_version = CURL_SSLVERSION_SSLv3; | |
| 187 } | |
| 188 #if LIBCURL_VERSION_MAJOR >= 7 | |
| 189 #if LIBCURL_VERSION_MINOR >= 34 | |
| 190 else if(xstrEQ(value, "TLSv1.0")) { | |
| 191 repo->ssl_version = CURL_SSLVERSION_TLSv1_0; | |
| 192 } else if(xstrEQ(value, "TLSv1.1")) { | |
| 193 repo->ssl_version = CURL_SSLVERSION_TLSv1_1; | |
| 194 } else if(xstrEQ(value, "TLSv1.2")) { | |
| 195 repo->ssl_version = CURL_SSLVERSION_TLSv1_2; | |
| 196 } | |
| 197 #endif | |
| 198 #endif | |
| 199 else { | |
| 200 fprintf(stderr, "Unknown ssl version: %s\n", value); | |
| 201 } | |
| 202 } else if(xstreq(node->name, "encrypt") || xstreq(node->name, "store-key-property") || xstreq(node->name, "decrypt")) { | |
| 203 fprintf(stderr, "Error: config.xml contains deprecated elements\n"); | |
| 204 fprintf(stderr, "The elements <encrypt>, <decrypt> and <store-key-property> are removed\n"); | |
| 205 fprintf(stderr, "Use the following: \n\n"); | |
| 206 fprintf(stderr, "<content-encryption>true</content-encryption>\n"); | |
| 207 fprintf(stderr, "enables file content encryption and decryption\n\n"); | |
| 208 fprintf(stderr, "<full-encryption>true</full-encryption>\n"); | |
| 209 fprintf(stderr, "enables content and file name encryption/decryption\n\n"); | |
| 210 fprintf(stderr, "<decrypt-content>$BOOL</decrypt-content>\n"); | |
| 211 fprintf(stderr, "only enables/disables content decryption\n\n"); | |
| 212 fprintf(stderr, "<decrypt-name>$BOOL</decrypt-name>\n"); | |
| 213 fprintf(stderr, "only enables/disables name decryption\n\n"); | |
| 214 exit(-1); | |
| 215 } | 163 } |
| 216 } | 164 } |
| 217 node = node->next; | 165 node = node->next; |
| 218 } | 166 } |
| 219 | 167 |
| 232 fprintf(stderr, "Abort.\n"); | 180 fprintf(stderr, "Abort.\n"); |
| 233 exit(-1); | 181 exit(-1); |
| 234 } | 182 } |
| 235 | 183 |
| 236 ucx_map_cstr_put(repos, repo->name, repo); | 184 ucx_map_cstr_put(repos, repo->name, repo); |
| 185 } | |
| 186 | |
| 187 int repo_add_config(Repository *repo, char *key, char *value) { | |
| 188 if(xstreq(key, "name")) { | |
| 189 repo->name = strdup(value); | |
| 190 } else if(xstreq(key, "url")) { | |
| 191 repo->url = strdup(value); | |
| 192 } else if(xstreq(key, "user")) { | |
| 193 repo->user = strdup(value); | |
| 194 } else if(xstreq(key, "password")) { | |
| 195 repo->password = util_base64decode(value); | |
| 196 } else if(xstreq(key, "default-key")) { | |
| 197 repo->default_key = strdup(value); | |
| 198 } else if(xstreq(key, "full-encryption")) { | |
| 199 if(util_getboolean(value)) { | |
| 200 repo->encrypt_name = true; | |
| 201 repo->encrypt_content = true; | |
| 202 repo->decrypt_name = true; | |
| 203 repo->decrypt_content = true; | |
| 204 } | |
| 205 } else if(xstreq(key, "content-encryption")) { | |
| 206 if(util_getboolean(value)) { | |
| 207 repo->encrypt_content = true; | |
| 208 repo->decrypt_content = true; | |
| 209 } else { | |
| 210 repo->encrypt_content = false; | |
| 211 } | |
| 212 } else if(xstreq(key, "decrypt-content")) { | |
| 213 repo->decrypt_content = util_getboolean(value); | |
| 214 } else if(xstreq(key, "decrypt-name")) { | |
| 215 repo->decrypt_name = util_getboolean(value); | |
| 216 } else if(xstreq(key, "ssl-version")) { | |
| 217 if(xstrEQ(value, "TLSv1")) { | |
| 218 repo->ssl_version = CURL_SSLVERSION_TLSv1; | |
| 219 } else if(xstrEQ(value, "SSLv2")) { | |
| 220 repo->ssl_version = CURL_SSLVERSION_SSLv2; | |
| 221 } else if(xstrEQ(value, "SSLv3")) { | |
| 222 repo->ssl_version = CURL_SSLVERSION_SSLv3; | |
| 223 } | |
| 224 #if LIBCURL_VERSION_MAJOR >= 7 | |
| 225 #if LIBCURL_VERSION_MINOR >= 34 | |
| 226 else if(xstrEQ(value, "TLSv1.0")) { | |
| 227 repo->ssl_version = CURL_SSLVERSION_TLSv1_0; | |
| 228 } else if(xstrEQ(value, "TLSv1.1")) { | |
| 229 repo->ssl_version = CURL_SSLVERSION_TLSv1_1; | |
| 230 } else if(xstrEQ(value, "TLSv1.2")) { | |
| 231 repo->ssl_version = CURL_SSLVERSION_TLSv1_2; | |
| 232 } | |
| 233 #endif | |
| 234 #endif | |
| 235 else { | |
| 236 fprintf(stderr, "Unknown ssl version: %s\n", value); | |
| 237 } | |
| 238 } else { | |
| 239 return -1; | |
| 240 } | |
| 241 return 0; | |
| 237 } | 242 } |
| 238 | 243 |
| 239 void load_proxy(xmlNode *proxynode, int type) { | 244 void load_proxy(xmlNode *proxynode, int type) { |
| 240 Proxy *proxy; | 245 Proxy *proxy; |
| 241 const char *stype; | 246 const char *stype; |
| 391 } | 396 } |
| 392 | 397 |
| 393 Proxy* get_https_proxy() { | 398 Proxy* get_https_proxy() { |
| 394 return https_proxy; | 399 return https_proxy; |
| 395 } | 400 } |
| 401 |
