Branch data Line data Source code
1 : : /* zxidconf.c - Handwritten functions for parsing ZXID configuration file
2 : : * Copyright (c) 2009-2010 Sampo Kellomaki (sampo@iki.fi), All Rights Reserved.
3 : : * Copyright (c) 2006-2009 Symlabs (symlabs@symlabs.com), All Rights Reserved.
4 : : * Author: Sampo Kellomaki (sampo@iki.fi)
5 : : * This is confidential unpublished proprietary source code of the author.
6 : : * NO WARRANTY, not even implied warranties. Contains trade secrets.
7 : : * Distribution prohibited unless authorized in writing.
8 : : * Licensed under Apache License 2.0, see file COPYING.
9 : : * $Id: zxidconf.c,v 1.51 2010-01-08 02:10:09 sampo Exp $
10 : : *
11 : : * 12.8.2006, created --Sampo
12 : : * 16.1.2007, split from zxidlib.c --Sampo
13 : : * 27.3.2007, lazy reading of certificates --Sampo
14 : : * 22.2.2008, added path_supplied feature --Sampo
15 : : * 7.10.2008, added documentation --Sampo
16 : : * 29.8.2009, added Auto-Cert feature a.k.a. zxid_mk_self_signed_cert() --Sampo
17 : : * 4.9.2009, added NEED, WANT, INMAP, PEPMAP, OUTMAP, and ATTRSRC --Sampo
18 : : * 15.11.2009, added SHOW_CONF (o=d) option --Sampo
19 : : * 7.1.2010, added WSC and WSP signing options --Sampo
20 : : * 12.2.2010, added pthread locking --Sampo
21 : : * 31.5.2010, added 4 web service call PEPs --Sampo
22 : : */
23 : :
24 : : #include "platform.h" /* needed on Win32 for pthread_mutex_lock() et al. */
25 : :
26 : : #include <memory.h>
27 : : #include <string.h>
28 : : #ifdef USE_CURL
29 : : #include <curl/curl.h>
30 : : #endif
31 : :
32 : : #include "errmac.h"
33 : : #include "zxid.h"
34 : : #include "zxidutil.h"
35 : : #include "zxidconf.h"
36 : : #include "c/zxidvers.h"
37 : :
38 : : /* ============== Configuration ============== */
39 : : /* Eventually configuration will be read from some file, but for
40 : : * now, we settle for compilation time configuration, see zxidconf.h */
41 : :
42 : : #ifdef USE_OPENSSL
43 : :
44 : : #include <openssl/rand.h>
45 : : #include <openssl/x509.h>
46 : : #include <openssl/rsa.h>
47 : :
48 : : #if 0
49 : : /*(-) Compute raw SHA1 digest hash over contents of a file.
50 : : *
51 : : * cf:: ZXID configuration object, used for deteminin path prefix and for memory allocation
52 : : * name:: Name of the file (under hierarchy defined by PATH configuration option)
53 : : * sha1:: A sha1 buffer which should be exactly 20 bytes (160 bits) long. The
54 : : * buffer will be modified in place by this function. */
55 : :
56 : : /* Called by: zxid_init_conf */
57 : : void zxid_sha1_file(zxid_conf* cf, char* name, char* sha1)
58 : : {
59 : : int gotall;
60 : : char* buf;
61 : : ZERO(sha1, 20);
62 : : buf = read_all_alloc(cf->ctx, "sha1_file", 1, &gotall, "%s%s", cf->path, name);
63 : : if (!buf)
64 : : return;
65 : : SHA1(buf, gotall, sha1);
66 : : ZX_FREE(cf->ctx, buf);
67 : : }
68 : : #endif
69 : :
70 : : /*() Extract a certificate from PEM encoded string. */
71 : :
72 : : /* Called by: opt, test_mode, zxid_read_cert */
73 : : X509* zxid_extract_cert(char* buf, char* name)
74 : 186 : {
75 : 186 : X509* x = 0; /* Forces d2i_X509() to alloc the memory. */
76 : : char* p;
77 : : char* e;
78 : 186 : OpenSSL_add_all_algorithms();
79 : 186 : p = strstr(buf, PEM_CERT_START);
80 [ - + ]: 186 : if (!p) {
81 : 0 : ERR("No certificate found in file(%s)\n", name);
82 : 0 : return 0;
83 : : }
84 : 186 : p += sizeof(PEM_CERT_START) - 1;
85 [ - + ]: 186 : if (*p == 0xd) ++p;
86 [ - + ]: 186 : if (*p != 0xa) return 0;
87 : 186 : ++p;
88 : :
89 : 186 : e = strstr(buf, PEM_CERT_END);
90 [ - + ]: 186 : if (!e) return 0;
91 : :
92 : 186 : p = unbase64_raw(p, e, buf, zx_std_index_64);
93 [ + - - + ]: 186 : if (!d2i_X509(&x, (const unsigned char**)&buf /* *** compile warning */, p-buf) || !x) {
94 : 0 : ERR("DER decoding of X509 certificate failed.\n%d", 0);
95 : 0 : return 0;
96 : : }
97 : 186 : return x;
98 : : }
99 : :
100 : : /*() Extract a private key from PEM encoded string.
101 : : * *** This function needs to expand to handle DSA */
102 : :
103 : : /* Called by: opt, test_mode, zxid_read_private_key */
104 : : EVP_PKEY* zxid_extract_private_key(char* buf, char* name)
105 : 217 : {
106 : : char* p;
107 : : char* e;
108 : : int typ;
109 : 217 : EVP_PKEY* pk = 0; /* Forces d2i_PrivateKey() to alloc the memory. */
110 : 217 : OpenSSL_add_all_algorithms();
111 : :
112 [ + - ]: 217 : if (p = strstr(buf, PEM_RSA_PRIV_KEY_START)) {
113 : 217 : typ = EVP_PKEY_RSA;
114 [ # # ]: 0 : } else if (p = strstr(buf, PEM_DSA_PRIV_KEY_START)) {
115 : 0 : typ = EVP_PKEY_DSA;
116 : : } else {
117 : 0 : ERR("No private key found in file(%s)\n", name);
118 : 0 : return 0;
119 : : }
120 : 217 : p += sizeof(PEM_RSA_PRIV_KEY_START) - 1;
121 [ - + ]: 217 : if (*p == 0xd) ++p;
122 [ - + ]: 217 : if (*p != 0xa) return 0;
123 : 217 : ++p;
124 : :
125 : 217 : e = strstr(buf, typ == EVP_PKEY_RSA ? PEM_RSA_PRIV_KEY_END : PEM_RSA_PRIV_KEY_END);
126 [ - + ]: 217 : if (!e) return 0;
127 : :
128 : 217 : p = unbase64_raw(p, e, buf, zx_std_index_64);
129 [ + - - + ]: 217 : if (!d2i_PrivateKey(typ, &pk, (const unsigned char**)&buf, p-buf) || !pk) {
130 : 0 : ERR("DER decoding of private key failed.\n%d", 0);
131 : 0 : return 0;
132 : : }
133 : 217 : return pk; /* RSA* rsa = EVP_PKEY_get1_RSA(pk); */
134 : : }
135 : :
136 : : /*() Extract a certificate from PEM encoded file. */
137 : :
138 : : /* Called by: zxid_idp_sso_desc x2, zxid_init_conf x3, zxid_lazy_load_sign_cert_and_pkey, zxid_sp_sso_desc x2, zxlog_write_line */
139 : : X509* zxid_read_cert(zxid_conf* cf, char* name)
140 : 184 : {
141 : : char buf[4096];
142 : 184 : int got = read_all(sizeof(buf), buf, "read_cert", 1, "%s" ZXID_PEM_DIR "%s", cf->path, name);
143 [ + + + - ]: 184 : if (!got && cf->auto_cert)
144 : 2 : zxid_mk_self_sig_cert(cf, sizeof(buf), buf, "read_cert", name);
145 : 184 : return zxid_extract_cert(buf, name);
146 : : }
147 : :
148 : : /*() Extract a private key from PEM encoded file. */
149 : :
150 : : /* Called by: test_ibm_cert_problem x2, test_ibm_cert_problem_enc_dec x2, zxenc_privkey_dec, zxid_init_conf x3, zxid_lazy_load_sign_cert_and_pkey, zxlog_write_line x2 */
151 : : EVP_PKEY* zxid_read_private_key(zxid_conf* cf, char* name)
152 : 215 : {
153 : : char buf[4096];
154 : 215 : int got = read_all(sizeof(buf), buf, "read_private_key", 1, "%s" ZXID_PEM_DIR "%s", cf->path, name);
155 [ - + # # ]: 215 : if (!got && cf->auto_cert)
156 : 0 : zxid_mk_self_sig_cert(cf, sizeof(buf), buf, "read_private_key", name);
157 : 215 : return zxid_extract_private_key(buf, name);
158 : : }
159 : :
160 : : /*() Lazy load signing certificate and private key. This reads them from disk
161 : : * if needed. If they do not exist and auto_cert is enabled, they will be
162 : : * generated on disk and the read. Once read from disk, they will be cached in
163 : : * memory. */
164 : :
165 : : /* Called by: zxid_anoint_a7n, zxid_anoint_sso_resp, zxid_az_soap x3, zxid_idp_soap_dispatch x2, zxid_idp_sso, zxid_mk_art_deref, zxid_mk_at_cert, zxid_saml2_post_enc, zxid_saml2_redir_enc, zxid_sp_mni_soap, zxid_sp_slo_soap, zxid_sp_soap_dispatch x7, zxid_ssos_anreq, zxid_wsf_sign */
166 : : int zxid_lazy_load_sign_cert_and_pkey(zxid_conf* cf, X509** cert, EVP_PKEY** pkey, const char* logkey)
167 : 1614 : {
168 [ - + # # ]: 1614 : LOCK(cf->mx, logkey);
169 [ + + ]: 1614 : if (cert) {
170 [ + + ]: 1605 : if (!(*cert = cf->sign_cert)) // Lazy load cert and private key
171 : 170 : *cert = cf->sign_cert = zxid_read_cert(cf, "sign-nopw-cert.pem");
172 : : }
173 [ + + ]: 1614 : if (!(*pkey = cf->sign_pkey))
174 : 175 : *pkey = cf->sign_pkey = zxid_read_private_key(cf, "sign-nopw-cert.pem");
175 [ - + # # ]: 1614 : UNLOCK(cf->mx, logkey);
176 [ + + + - : 1614 : if (cert && !*cert || !*pkey)
- + ]
177 : 0 : return 0;
178 : 1614 : return 1;
179 : : }
180 : : #endif
181 : :
182 : : /*() Set obscure options of ZX and ZXID layers. Used to set debug options.
183 : : * Generally setting these options is not supported, but this function
184 : : * exists to avoid uncontrolled access to global variables. At least this
185 : : * way the unsupported activity will happen in one controlled place where
186 : : * it can be ignored, if need to be. You have been warned. */
187 : :
188 : : /* Called by: zxid_fed_mgmt_cf, zxid_idp_list_cf_cgi, zxid_simple_cf_ses */
189 : : int zxid_set_opt(zxid_conf* cf, int which, int val)
190 : 223 : {
191 [ + + - ]: 223 : switch (which) {
192 : 222 : case 1: zx_debug = val; return val;
193 : 1 : case 5: exit(val); /* This is typically used to force __gcov_flush() */
194 : : }
195 : 0 : return -1;
196 : : }
197 : :
198 : : /*() Set obscure options of ZX and ZXID layers. Used to set debug options.
199 : : * Generally setting these options is not supported, but this function
200 : : * exists to avoid uncontrolled access to global variables. At least this
201 : : * way the unsupported activity will happen in one controlled place where
202 : : * it can be ignored, if need to be. You have been warned. */
203 : :
204 : : /* Called by: */
205 : : char* zxid_set_opt_cstr(zxid_conf* cf, int which, char* val)
206 : 0 : {
207 [ # # # # ]: 0 : switch (which) {
208 : 0 : case 2: strncpy(zx_instance, val, sizeof(zx_instance)); return zx_instance;
209 : 0 : case 3: D_INDENT(val); return zx_indent;
210 : 0 : case 4: D_DEDENT(val); return zx_indent;
211 : : }
212 : 0 : return 0;
213 : : }
214 : :
215 : : /*() Set the URL configuration variable. Usually you would use zxid_parse_conf()
216 : : * to manipulate this and some other options. This function exists for some
217 : : * special cases encountered in scripting language bindings. */
218 : :
219 : : /* Called by: main x2, zxidwspcgi_main */
220 : : void zxid_url_set(zxid_conf* cf, char* url)
221 : 18 : {
222 [ + - - + ]: 18 : if (!cf || !url) {
223 : 0 : ERR("NULL pointer as cf or url argument cf=%p url=%p", cf, url);
224 : 0 : return;
225 : : }
226 [ + - - + ]: 18 : D("Setting url(%s)", url);
227 : 18 : cf->url = zx_dup_cstr(cf->ctx, url);
228 : : }
229 : :
230 : : /* ================== Attribute Broker Config ================*/
231 : :
232 : : #define IS_RULE(rule, val) (!memcmp((rule), (val), sizeof(val)-1) && (rule)[sizeof(val)-1] == '$')
233 : :
234 : : /*() Create new (common pool) attribute and add it to a linked list */
235 : :
236 : : /* Called by: zxid_add_at_values x3, zxid_add_attr_to_ses x2, zxid_add_qs_to_ses, zxid_load_atsrc, zxid_load_need */
237 : : struct zxid_attr* zxid_new_at(zxid_conf* cf, struct zxid_attr* at, int name_len, char* name, int val_len, char* val, char* lk)
238 : 6413 : {
239 : 6413 : struct zxid_attr* aa = ZX_ZALLOC(cf->ctx, struct zxid_attr);
240 : 6413 : aa->n = at;
241 : 6413 : at = aa;
242 : 6413 : COPYVAL(at->name, name, name+name_len);
243 [ + + ]: 6413 : if (val)
244 : 2257 : COPYVAL(at->val, val, val+val_len);
245 [ + + + + : 6413 : D("%s:\tATTR name(%.*s)=val(%.*s)", lk, name_len, name, MIN(val_len, 100), STRNULLCHK(val));
- + ]
246 : 6413 : return aa;
247 : : }
248 : :
249 : :
250 : : /*() Parse need specification and add it to linked list
251 : : * A,B$usage$retention$oblig$ext;A,B$usage$retention$oblig$ext;...
252 : : */
253 : :
254 : : /* Called by: zxid_init_conf x2, zxid_parse_conf_raw x2 */
255 : : static struct zxid_need* zxid_load_need(zxid_conf* cf, struct zxid_need* need, char* v)
256 : 554 : {
257 : : char* attrs;
258 : : char* usage;
259 : : char* retent;
260 : : char* oblig;
261 : : char* ext;
262 : 554 : char* p = v;
263 : : char* a;
264 : : int len;
265 : : struct zxid_need* nn;
266 : :
267 [ + - + - ]: 1108 : while (p && *p) {
268 : 554 : attrs = p;
269 : 554 : p = strchr(p, '$');
270 [ - + ]: 554 : if (!p) {
271 : 0 : ERR("Malformed NEED or WANT directive: attribute list at pos %d", p-v);
272 : 0 : return need;
273 : : }
274 : :
275 : 554 : usage = ++p;
276 : 554 : p = strchr(p, '$');
277 [ - + ]: 554 : if (!p) {
278 : 0 : ERR("Malformed NEED or WANT directive: usage missing at pos %d", p-v);
279 : 0 : return need;
280 : : }
281 : :
282 : 554 : retent = ++p;
283 : 554 : p = strchr(p, '$');
284 [ - + ]: 554 : if (!p) {
285 : 0 : ERR("Malformed NEED or WANT directive: retention missing at pos %d", p-v);
286 : 0 : return need;
287 : : }
288 : :
289 : 554 : oblig = ++p;
290 : 554 : p = strchr(p, '$');
291 [ - + ]: 554 : if (!p) {
292 : 0 : ERR("Malformed NEED or WANT directive: obligations missing at pos %d", p-v);
293 : 0 : return need;
294 : : }
295 : :
296 : 554 : ext = ++p;
297 : 554 : p = strchr(p, ';'); /* Stanza ends in separator ; or end of string nul */
298 [ + - ]: 554 : if (!p)
299 : 554 : p = ext + strlen(ext);
300 : :
301 [ - + # # ]: 554 : if (IS_RULE(usage, "reset")) {
302 : 0 : INFO("Reset need %p", need);
303 [ # # ]: 0 : for (; need; need = nn) {
304 : 0 : nn = need->n;
305 : 0 : ZX_FREE(cf->ctx, need);
306 : : }
307 [ # # ]: 0 : if (!*p) break;
308 : 0 : ++p;
309 : 0 : continue;
310 : : }
311 : :
312 : 554 : nn = ZX_ZALLOC(cf->ctx, struct zxid_need);
313 : 554 : nn->n = need;
314 : 554 : need = nn;
315 : :
316 : 554 : COPYVAL(nn->usage, usage, retent-1);
317 : 554 : COPYVAL(nn->retent, retent, oblig-1);
318 : 554 : COPYVAL(nn->oblig, oblig, ext-1);
319 : 554 : COPYVAL(nn->ext, ext, p);
320 : :
321 : : DD("need attrs(%.*s) usage(%s) retent(%s) oblig(%s) ext(%s)", usage-attrs-1, attrs, nn->usage, nn->retent, nn->oblig, nn->ext);
322 : :
323 : 2770 : for (a = attrs; ; a += len+1) {
324 : 2770 : len = strcspn(a, ",$");
325 : 2770 : nn->at = zxid_new_at(cf, nn->at, len, a, 0,0, "need/want");
326 [ + + ]: 2770 : if (a[len] == '$')
327 : 554 : break;
328 : 2216 : }
329 [ - + ]: 554 : if (!*p) break;
330 : 0 : ++p;
331 : : }
332 : :
333 : 554 : return need;
334 : : }
335 : :
336 : : /*() Parse map specification and add it to linked list
337 : : * srcns$A$rule$b$ext;src$A$rule$b$ext;...
338 : : * The list ends up being built in reverse order, which at runtime
339 : : * causes last stanzas to be evaluated first and first match is used.
340 : : * Thus you should place most specific rules last and most generic rules first.
341 : : * See also: zxid_find_map() and zxid_map_val()
342 : : */
343 : :
344 : : /* Called by: zxid_init_conf x7, zxid_mk_usr_a7n_to_sp, zxid_parse_conf_raw x7, zxid_read_map */
345 : : struct zxid_map* zxid_load_map(zxid_conf* cf, struct zxid_map* map, char* v)
346 : 2317 : {
347 : : char* ns;
348 : : char* A;
349 : : char* rule;
350 : : char* b;
351 : : char* ext;
352 : 2317 : char* p = v;
353 : : int len;
354 : : struct zxid_map* mm;
355 : :
356 : : DD("v(%s)", v);
357 : :
358 [ + - + + ]: 15012 : while (p && *p) {
359 : 12141 : ns = p;
360 : 12141 : p = strchr(p, '$');
361 [ - + ]: 12141 : if (!p) {
362 : 0 : ERR("Malformed MAP directive: source namespace missing at pos %d", p-v);
363 : 0 : return map;
364 : : }
365 : :
366 : 12141 : A = ++p;
367 : 12141 : p = strchr(p, '$');
368 [ - + ]: 12141 : if (!p) {
369 : 0 : ERR("Malformed MAP directive: source attribute name missing at pos %d", p-v);
370 : 0 : return map;
371 : : }
372 : :
373 : 12141 : rule = ++p;
374 : 12141 : p = strchr(p, '$');
375 [ - + ]: 12141 : if (!p) {
376 : 0 : ERR("Malformed MAP directive: rule missing at pos %d", p-v);
377 : 0 : return map;
378 : : }
379 : :
380 : 12141 : b = ++p;
381 : 12141 : p = strchr(p, '$');
382 [ - + ]: 12141 : if (!p) {
383 : 0 : ERR("Malformed MAP directive: destination attribute name missing at pos %d", p-v);
384 : 0 : return map;
385 : : }
386 : :
387 : 12141 : ext = ++p;
388 : 12141 : len = strcspn(p, ";\n"); /* Stanza ends in separator ; or end of string nul */
389 : 12141 : p = ext + len;
390 : :
391 [ - + # # ]: 12141 : if (IS_RULE(rule, "reset")) {
392 : 0 : INFO("Reset map %p", map);
393 [ # # ]: 0 : for (; map; map = mm) {
394 : 0 : mm = map->n;
395 : 0 : ZX_FREE(cf->ctx, map);
396 : : }
397 [ # # ]: 0 : if (!*p) break;
398 : 0 : ++p;
399 : 0 : continue;
400 : : }
401 : :
402 : 12141 : mm = ZX_ZALLOC(cf->ctx, struct zxid_map);
403 : 12141 : mm->n = map;
404 : 12141 : map = mm;
405 : :
406 [ + + + + : 12141 : if (IS_RULE(rule, "") || IS_RULE(rule, "rename")) { mm->rule = ZXID_MAP_RULE_RENAME; }
+ - ]
407 [ + + + - ]: 3459 : else if (IS_RULE(rule, "del")) { mm->rule = ZXID_MAP_RULE_DEL; }
408 [ + + + - ]: 654 : else if (IS_RULE(rule, "feidedec")) { mm->rule = ZXID_MAP_RULE_FEIDEDEC; }
409 [ + + + - ]: 626 : else if (IS_RULE(rule, "feideenc")) { mm->rule = ZXID_MAP_RULE_FEIDEENC; }
410 [ + + + - ]: 588 : else if (IS_RULE(rule, "unsb64-inf")) { mm->rule = ZXID_MAP_RULE_UNSB64_INF; }
411 [ - + # # ]: 560 : else if (IS_RULE(rule, "def-sb64")) { mm->rule = ZXID_MAP_RULE_DEF_SB64; }
412 [ + + + - ]: 560 : else if (IS_RULE(rule, "unsb64")) { mm->rule = ZXID_MAP_RULE_UNSB64; }
413 [ - + # # ]: 532 : else if (IS_RULE(rule, "sb64")) { mm->rule = ZXID_MAP_RULE_SB64; }
414 : :
415 [ + + + + ]: 532 : else if (IS_RULE(rule, "a7n")) { mm->rule = ZXID_MAP_RULE_WRAP_A7N; }
416 [ + + + - ]: 494 : else if (IS_RULE(rule, "a7n-feideenc")) { mm->rule = ZXID_MAP_RULE_WRAP_A7N | ZXID_MAP_RULE_FEIDEENC; }
417 [ + + + - ]: 456 : else if (IS_RULE(rule, "a7n-def-sb64")) { mm->rule = ZXID_MAP_RULE_WRAP_A7N | ZXID_MAP_RULE_DEF_SB64; }
418 [ + + + - ]: 380 : else if (IS_RULE(rule, "a7n-sb64")) { mm->rule = ZXID_MAP_RULE_WRAP_A7N | ZXID_MAP_RULE_SB64; }
419 : :
420 [ + + - + ]: 342 : else if (IS_RULE(rule, "x509")) { mm->rule = ZXID_MAP_RULE_WRAP_X509; }
421 [ + + + - ]: 342 : else if (IS_RULE(rule, "x509-feideenc")) { mm->rule = ZXID_MAP_RULE_WRAP_X509 | ZXID_MAP_RULE_FEIDEENC; }
422 [ + + + - ]: 304 : else if (IS_RULE(rule, "x509-def-sb64")) { mm->rule = ZXID_MAP_RULE_WRAP_X509 | ZXID_MAP_RULE_DEF_SB64; }
423 [ + + + - ]: 266 : else if (IS_RULE(rule, "x509-sb64")) { mm->rule = ZXID_MAP_RULE_WRAP_X509 | ZXID_MAP_RULE_SB64; }
424 : :
425 [ + + + + ]: 228 : else if (IS_RULE(rule, "file")) { mm->rule = ZXID_MAP_RULE_WRAP_FILE; }
426 [ + + + - ]: 190 : else if (IS_RULE(rule, "file-feideenc")) { mm->rule = ZXID_MAP_RULE_WRAP_FILE | ZXID_MAP_RULE_FEIDEENC; }
427 [ + + + - ]: 152 : else if (IS_RULE(rule, "file-def-sb64")) { mm->rule = ZXID_MAP_RULE_WRAP_FILE | ZXID_MAP_RULE_DEF_SB64; }
428 [ + + + - ]: 114 : else if (IS_RULE(rule, "file-sb64")) { mm->rule = ZXID_MAP_RULE_WRAP_FILE | ZXID_MAP_RULE_SB64; }
429 : :
430 : : else {
431 : 76 : ERR("Unknown map rule(%.*s) at col %d of (%s)", b-rule, rule, rule-v, v);
432 : : //ERR("sizeof(rename)=%d cmp=%d c(%c)", sizeof("rename"), memcmp(rule, "rename", sizeof("rename")-1), rule[sizeof("rename")]);
433 : : }
434 : :
435 : 12141 : COPYVAL(mm->ns, ns, A-1);
436 : 12141 : COPYVAL(mm->src, A, rule-1);
437 : 12141 : COPYVAL(mm->dst, b, ext-1);
438 : 12141 : COPYVAL(mm->ext, ext, p);
439 : :
440 : : DD("map ns(%s) src(%s) rule=%d dst(%s) ext(%s)", mm->ns, mm->src, mm->rule, mm->dst, mm->ext);
441 [ + + + - ]: 12141 : if (!*p || *p == '\n') break;
442 : 10378 : ++p;
443 : : }
444 : :
445 : 2317 : return map;
446 : : }
447 : :
448 : : /*() Parse ATTRSRC specification and add it to linked list
449 : : * namespace$A,B$weight$accessparamURL$AAPMLref$otherLim$ext;namespace$A,B$weight$accessparamURL$AAPMLref$otherLim$ext;...
450 : : */
451 : :
452 : : /* Called by: zxid_init_conf x4, zxid_parse_conf_raw x4 */
453 : : static struct zxid_cstr_list* zxid_load_cstr_list(zxid_conf* cf, struct zxid_cstr_list* l, char* p)
454 : 1108 : {
455 : : char* q;
456 : : struct zxid_cstr_list* cs;
457 : :
458 [ + + + + ]: 2770 : for (; p && *p;) {
459 : 554 : q = p;
460 : 554 : p = strchr(p, ',');
461 [ + - ]: 554 : if (!p)
462 : 554 : p = q + strlen(q);
463 : 554 : cs = ZX_ZALLOC(cf->ctx, struct zxid_cstr_list);
464 : 554 : cs->n = l;
465 : 554 : l = cs;
466 : 554 : COPYVAL(cs->s, q, p);
467 : : }
468 : 1108 : return l;
469 : : }
470 : :
471 : : /*() Parse ATTRSRC specification and add it to linked list
472 : : * namespace$A,B$weight$accessparamURL$AAPMLref$otherLim$ext;namespace$A,B$weight$accessparamURL$AAPMLref$otherLim$ext;...
473 : : */
474 : :
475 : : /* Called by: zxid_init_conf, zxid_parse_conf_raw */
476 : : static struct zxid_atsrc* zxid_load_atsrc(zxid_conf* cf, struct zxid_atsrc* atsrc, char* v)
477 : 277 : {
478 : : char* ns;
479 : : char* attrs;
480 : : char* weight;
481 : : char* url;
482 : : char* aapml;
483 : : char* otherlim;
484 : : char* ext;
485 : 277 : char* p = v;
486 : : char* a;
487 : : int len;
488 : : struct zxid_atsrc* as;
489 : :
490 [ + - - + ]: 554 : while (p && *p) {
491 : 0 : ns = p;
492 : 0 : p = strchr(p, '$');
493 [ # # ]: 0 : if (!p) {
494 : 0 : ERR("Malformed ATSRC directive: namespace missing at pos %d", p-v);
495 : 0 : return atsrc;
496 : : }
497 : :
498 : 0 : attrs = ++p;
499 : 0 : p = strchr(p, '$');
500 [ # # ]: 0 : if (!p) {
501 : 0 : ERR("Malformed ATSRC directive: attribute list missing at pos %d", p-v);
502 : 0 : return atsrc;
503 : : }
504 : :
505 : 0 : weight = ++p;
506 : 0 : p = strchr(p, '$');
507 [ # # ]: 0 : if (!p) {
508 : 0 : ERR("Malformed ATSRC directive: weight missing at pos %d", p-v);
509 : 0 : return atsrc;
510 : : }
511 : :
512 : 0 : url = ++p;
513 : 0 : p = strchr(p, '$');
514 [ # # ]: 0 : if (!p) {
515 : 0 : ERR("Malformed ATSRC directive: url missing at pos %d", p-v);
516 : 0 : return atsrc;
517 : : }
518 : :
519 : 0 : aapml = ++p;
520 : 0 : p = strchr(p, '$');
521 [ # # ]: 0 : if (!p) {
522 : 0 : ERR("Malformed ATSRC directive: aapml ref missing at pos %d", p-v);
523 : 0 : return atsrc;
524 : : }
525 : :
526 : 0 : otherlim = ++p;
527 : 0 : p = strchr(p, '$');
528 [ # # ]: 0 : if (!p) {
529 : 0 : ERR("Malformed ATSRC directive: otherlim missing at pos %d", p-v);
530 : 0 : return atsrc;
531 : : }
532 : :
533 : 0 : ext = ++p;
534 : 0 : p = strchr(p, ';'); /* Stanza ends in separator ; or end of string nul */
535 [ # # ]: 0 : if (!p)
536 : 0 : p = ext + strlen(ext);
537 : :
538 [ # # # # ]: 0 : if (IS_RULE(url, "reset")) {
539 : 0 : INFO("Reset atsrc %p", atsrc);
540 [ # # ]: 0 : for (; atsrc; atsrc = as) {
541 : 0 : as = atsrc->n;
542 : 0 : ZX_FREE(cf->ctx, atsrc);
543 : : }
544 [ # # ]: 0 : if (!*p) break;
545 : 0 : ++p;
546 : 0 : continue;
547 : : }
548 : :
549 : 0 : as = ZX_ZALLOC(cf->ctx, struct zxid_atsrc);
550 : 0 : as->n = atsrc;
551 : 0 : atsrc = as;
552 : :
553 : 0 : COPYVAL(as->ns, ns, attrs-1);
554 : 0 : COPYVAL(as->weight, weight, url-1);
555 : 0 : COPYVAL(as->url, url, aapml-1);
556 : 0 : COPYVAL(as->aapml, aapml, otherlim-1);
557 : 0 : COPYVAL(as->otherlim, otherlim, ext-1);
558 : 0 : COPYVAL(as->ext, ext, p);
559 : :
560 [ # # # # ]: 0 : D("atsrc ns(%s) attrs(%.*s) weight(%s) url(%s) aapml(%s) otherlim(%s) ext(%s)", as->ns, weight-attrs-1, attrs, as->weight, as->url, as->aapml, as->otherlim, as->ext);
561 : :
562 : 0 : for (a = attrs; ; a += len+1) {
563 : 0 : len = strcspn(a, ",$");
564 : 0 : as->at = zxid_new_at(cf, as->at, len, a, 0,0, "atsrc");
565 [ # # ]: 0 : if (a[len] == '$')
566 : 0 : break;
567 : 0 : }
568 [ # # ]: 0 : if (!*p) break;
569 : 0 : ++p;
570 : : }
571 : :
572 : 277 : return atsrc;
573 : : }
574 : :
575 : : /*() Check whether attribute is in a (needed or wanted) list. Just a linear
576 : : * scan as it is simple and good enough for handful of attributes. */
577 : :
578 : : /* Called by: zxid_add_at_values x2, zxid_add_attr_to_ses x2 */
579 : : struct zxid_need* zxid_is_needed(struct zxid_need* need, const char* name)
580 : 7112 : {
581 : : struct zxid_attr* at;
582 [ + - - + ]: 7112 : if (!name || !*name)
583 : 0 : return 0;
584 [ + + ]: 10581 : for (; need; need = need->n)
585 [ + + ]: 36965 : for (at = need->at; at; at = at->n)
586 [ + + - + : 33496 : if (at->name[0] == '*' && !at->name[1] /* Wild card */
+ + ]
587 : : || !strcmp(at->name, name)) /* Match! */
588 : 3643 : return need;
589 : 3469 : return 0;
590 : : }
591 : :
592 : : /*() Check whether attribute is in a (needed or wanted) list. Just a linear
593 : : * scan as it is simple and good enough for handful of attributes.
594 : : * The list ends up being built in reverse order, which at runtime
595 : : * causes last stanzas to be evaluated first and first match is used.
596 : : * Thus you should place most specific rules last and most generic rules first.
597 : : * See also: zxid_load_map() and zxid_map_val() */
598 : :
599 : : /* Called by: pool2apache, zxid_add_at_values, zxid_add_attr_to_ses, zxid_add_mapped_attr x2, zxid_pepmap_extract, zxid_pool_to_json x2, zxid_pool_to_ldif x2, zxid_pool_to_qs x2 */
600 : : struct zxid_map* zxid_find_map(struct zxid_map* map, const char* name)
601 : 14969 : {
602 [ + - - + ]: 14969 : if (!name || !*name)
603 : 0 : return 0;
604 [ + + ]: 73009 : for (; map; map = map->n)
605 [ + + - + : 65496 : if (map->src[0] == '*' && !map->src[1] /* Wild card (only sensible for del and data xform) */
+ + ]
606 : : || !strcmp(map->src, name)) /* Match! */
607 : 7456 : return map;
608 : 7513 : return 0;
609 : : }
610 : :
611 : : /*() Check whether name is in the list. Used for Local PDP wite and black lists. */
612 : :
613 : : /* Called by: zxid_localpdp x4 */
614 : : struct zxid_cstr_list* zxid_find_cstr_list(struct zxid_cstr_list* cs, const char* name)
615 : 92 : {
616 [ + - - + ]: 92 : if (!name || !*name)
617 : 0 : return 0;
618 [ + + ]: 184 : for (; cs; cs = cs->n)
619 [ - + # # : 92 : if (cs->s[0] == '*' && !cs->s[1] /* Wild card */
- + ]
620 : : || !strcmp(cs->s, name)) /* Match! */
621 : 0 : return cs;
622 : 92 : return 0;
623 : : }
624 : :
625 : : /*() Check whether attribute is in pool. */
626 : :
627 : : /* Called by: zxid_localpdp x2 */
628 : : struct zxid_attr* zxid_find_at(struct zxid_attr* pool, const char* name)
629 : 194 : {
630 [ + - - + ]: 194 : if (!name || !*name)
631 : 0 : return 0;
632 [ + + ]: 7200 : for (; pool; pool = pool->n)
633 [ + + ]: 7098 : if (!strcmp(pool->name, name)) /* Match! */
634 : 92 : return pool;
635 : 102 : return 0;
636 : : }
637 : :
638 : : /*() Given URL, return a newly allocated string corresponding
639 : : * to the domain name part of the URL. Used to grab fedusername_suffix
640 : : * from the url config option. */
641 : :
642 : : /* Called by: zxid_parse_conf_raw */
643 : : static char* zxid_grab_domain_name(zxid_conf* cf, const char* url)
644 : 649 : {
645 : : char* dom;
646 : : char* p;
647 : : int len;
648 [ + - - + ]: 649 : if (!url || !*url)
649 : 0 : return 0;
650 : 649 : dom = strchr(url, ':');
651 [ + - + - : 649 : if (!dom || dom[1] != '/' || dom[2] != '/')
- + ]
652 : 0 : return 0;
653 : 649 : dom += 3;
654 : : /* After shipping https:// scan for domain name allowable characters. */
655 : 649 : len = strspn(dom, ".abcdefghijklmnopqrstuvwxyz0123456789-ABCDEFGHIJKLMNOPQRSTUVWXYZ");
656 : 649 : p = ZX_ALLOC(cf->ctx, len+1);
657 : 649 : memcpy(p, dom, len);
658 : 649 : p[len] = 0;
659 : 649 : return p;
660 : : }
661 : :
662 : : pthread_mutex_t zxid_ent_cache_mx;
663 : : int zxid_ent_cache_mx_init = 0;
664 : :
665 : : /*(i) Initialize configuration object, which must have already been
666 : : * allocated, to factory defaults (i.e. compiled in defaults, see
667 : : * zxidconf.h).
668 : : *
669 : : * cf:: Pointer to previously allocated configuration object
670 : : * path:: Since this configuration option is so fundamental, it can
671 : : * be supplied directly as argument. However, unlike zxid_new_conf()
672 : : * this does not cause the config file to be read.
673 : : * return:: 0 on success (currently, 2008, this function can not
674 : : * fail - thus it is common to ignore the return value)
675 : : *
676 : : * N.B. This function does NOT initialize the ZX context object although
677 : : * it is a field of this object. You MUST separately initialize
678 : : * the ZX context object, e.g. using zx_reset_ctx() or zx_init_ctx(),
679 : : * before you can use ZXID configuration object in any memory allocation prone
680 : : * activity (which is nearly every function in this API).
681 : : */
682 : :
683 : : /* Called by: zxid_conf_to_cf_len, zxid_init_conf_ctx */
684 : : int zxid_init_conf(zxid_conf* cf, const char* zxid_path)
685 : 277 : {
686 : : DD("Initconf with path(%s)", zxid_path);
687 : 277 : cf->magic = ZXID_CONF_MAGIC;
688 [ + + ]: 277 : cf->path_len = zxid_path ? strlen(zxid_path) : 0;
689 : 277 : cf->path = ZX_ALLOC(cf->ctx, cf->path_len+1);
690 : 277 : memcpy(cf->path, zxid_path, cf->path_len);
691 : 277 : cf->path[cf->path_len] = 0;
692 : 277 : cf->nice_name = ZXID_NICE_NAME;
693 : 277 : cf->org_name = ZXID_ORG_NAME;
694 : 277 : cf->org_url = ZXID_ORG_URL;
695 : 277 : cf->locality = ZXID_LOCALITY;
696 : 277 : cf->state = ZXID_STATE;
697 : 277 : cf->country = ZXID_COUNTRY;
698 : 277 : cf->contact_org = ZXID_CONTACT_ORG;
699 : 277 : cf->contact_name = ZXID_CONTACT_NAME;
700 : 277 : cf->contact_email = ZXID_CONTACT_EMAIL;
701 : 277 : cf->contact_tel = ZXID_CONTACT_TEL;
702 : 277 : cf->fedusername_suffix = ZXID_FEDUSERNAME_SUFFIX;
703 : 277 : cf->url = ZXID_URL;
704 : 277 : cf->non_standard_entityid = ZXID_NON_STANDARD_ENTITYID;
705 : 277 : cf->redirect_hack_imposed_url = ZXID_REDIRECT_HACK_IMPOSED_URL;
706 : 277 : cf->redirect_hack_zxid_url = ZXID_REDIRECT_HACK_ZXID_URL;
707 : 277 : cf->cdc_url = ZXID_CDC_URL;
708 : 277 : cf->cdc_choice = ZXID_CDC_CHOICE;
709 : 277 : cf->authn_req_sign = ZXID_AUTHN_REQ_SIGN;
710 : 277 : cf->want_sso_a7n_signed = ZXID_WANT_SSO_A7N_SIGNED;
711 : 277 : cf->want_authn_req_signed = ZXID_WANT_AUTHN_REQ_SIGNED;
712 : 277 : cf->sso_soap_sign = ZXID_SSO_SOAP_SIGN;
713 : 277 : cf->sso_soap_resp_sign = ZXID_SSO_SOAP_RESP_SIGN;
714 : 277 : cf->sso_sign = ZXID_SSO_SIGN;
715 : 277 : cf->wsc_sign = ZXID_WSC_SIGN;
716 : 277 : cf->wsp_sign = ZXID_WSP_SIGN;
717 : 277 : cf->wspcgicmd = ZXID_WSPCGICMD;
718 : 277 : cf->nameid_enc = ZXID_NAMEID_ENC;
719 : 277 : cf->post_a7n_enc = ZXID_POST_A7N_ENC;
720 : 277 : cf->canon_inopt = ZXID_CANON_INOPT;
721 [ + - ]: 277 : if (cf->ctx) cf->ctx->canon_inopt = cf->canon_inopt;
722 : 277 : cf->enc_tail_opt = ZXID_ENC_TAIL_OPT;
723 : 277 : cf->enckey_opt = ZXID_ENCKEY_OPT;
724 : 277 : cf->idpatopt = ZXID_IDPATOPT;
725 : 277 : cf->idp_list_meth = ZXID_IDP_LIST_METH;
726 : 277 : cf->di_allow_create = ZXID_DI_ALLOW_CREATE;
727 : 277 : cf->di_nid_fmt = ZXID_DI_NID_FMT;
728 : 277 : cf->di_a7n_enc = ZXID_DI_A7N_ENC;
729 : 277 : cf->bootstrap_level = ZXID_BOOTSTRAP_LEVEL;
730 : 277 : cf->show_conf = ZXID_SHOW_CONF;
731 : : #ifdef USE_OPENSSL
732 : : if (zxid_path) {
733 : : #if 0
734 : : /* DO NOT ENABLE! The certificates and keys are read "just in time" if and when needed. */
735 : : cf->sign_cert = zxid_read_cert(cf, "sign-nopw-cert.pem");
736 : : cf->sign_pkey = zxid_read_private_key(cf, "sign-nopw-cert.pem");
737 : : cf->enc_cert = zxid_read_cert(cf, "enc-nopw-cert.pem");
738 : : cf->enc_pkey = zxid_read_private_key(cf, "enc-nopw-cert.pem");
739 : : cf->log_sign_pkey = zxid_read_private_key(cf, "logsign-nopw-cert.pem");
740 : : cf->log_enc_cert = zxid_read_cert(cf, "logenc-nopw-cert.pem");
741 : : zxid_sha1_file(cf, "pem/logenc.key", cf->log_symkey);
742 : : #endif
743 : : }
744 : : #else
745 : : ERR("This copy of zxid was compiled to NOT use OpenSSL. Reading certificate and private key is not supported. Signing and signature verification are not supported either. Add -DUSE_OPENSSL and recompile. %d", 0);
746 : : #endif
747 : 277 : cf->md_fetch = ZXID_MD_FETCH;
748 : 277 : cf->md_populate_cache = ZXID_MD_POPULATE_CACHE;
749 : 277 : cf->md_cache_first = ZXID_MD_CACHE_FIRST;
750 : 277 : cf->md_cache_last = ZXID_MD_CACHE_LAST;
751 : 277 : cf->load_cot_cache = ZXID_LOAD_COT_CACHE;
752 : 277 : cf->auto_cert = ZXID_AUTO_CERT;
753 : 277 : cf->ses_arch_dir = ZXID_SES_ARCH_DIR;
754 : 277 : cf->ses_cookie_name = ZXID_SES_COOKIE_NAME;
755 : 277 : cf->user_local = ZXID_USER_LOCAL;
756 : 277 : cf->idp_ena = ZXID_IDP_ENA;
757 : 277 : cf->imps_ena = ZXID_IMPS_ENA;
758 : 277 : cf->as_ena = ZXID_AS_ENA;
759 : 277 : cf->pdp_ena = ZXID_PDP_ENA;
760 : :
761 : 277 : cf->loguser = ZXID_LOGUSER;
762 : 277 : cf->log_level = ZXLOG_LEVEL;
763 : 277 : cf->log_err = ZXLOG_ERR; /* Log enables and signing and encryption flags (if USE_OPENSSL) */
764 : 277 : cf->log_act = ZXLOG_ACT;
765 : 277 : cf->log_issue_a7n = ZXLOG_ISSUE_A7N;
766 : 277 : cf->log_issue_msg = ZXLOG_ISSUE_MSG;
767 : 277 : cf->log_rely_a7n = ZXLOG_RELY_A7N;
768 : 277 : cf->log_rely_msg = ZXLOG_RELY_MSG;
769 : 277 : cf->log_err_in_act = ZXLOG_ERR_IN_ACT;
770 : 277 : cf->log_act_in_err = ZXLOG_ACT_IN_ERR;
771 : 277 : cf->log_sigfail_is_err = ZXLOG_SIGFAIL_IS_ERR;
772 : :
773 : 277 : cf->sig_fatal = ZXID_SIG_FATAL;
774 : 277 : cf->nosig_fatal = ZXID_NOSIG_FATAL;
775 : 277 : cf->msg_sig_ok = ZXID_MSG_SIG_OK;
776 : 277 : cf->timeout_fatal = ZXID_TIMEOUT_FATAL;
777 : 277 : cf->audience_fatal = ZXID_AUDIENCE_FATAL;
778 : 277 : cf->dup_a7n_fatal = ZXID_DUP_A7N_FATAL;
779 : 277 : cf->dup_msg_fatal = ZXID_DUP_MSG_FATAL;
780 : 277 : cf->relto_fatal = ZXID_RELTO_FATAL;
781 : 277 : cf->wsp_nosig_fatal = ZXID_WSP_NOSIG_FATAL;
782 : 277 : cf->notimestamp_fatal = ZXID_NOTIMESTAMP_FATAL;
783 : 277 : cf->anon_ok = ZXID_ANON_OK;
784 : 277 : cf->required_authnctx = ZXID_REQUIRED_AUTHNCTX;
785 : 277 : cf->issue_authnctx_pw = ZXID_ISSUE_AUTHNCTX_PW;
786 : 277 : cf->idp_pref_acs_binding = ZXID_IDP_PREF_ACS_BINDING;
787 : 277 : cf->mandatory_attr = ZXID_MANDATORY_ATTR;
788 : :
789 : 277 : cf->before_slop = ZXID_BEFORE_SLOP;
790 : 277 : cf->after_slop = ZXID_AFTER_SLOP;
791 : 277 : cf->timeskew = ZXID_TIMESKEW;
792 : 277 : cf->a7nttl = ZXID_A7NTTL;
793 : 277 : cf->pdp_url = ZXID_PDP_URL;
794 : 277 : cf->pdp_call_url = ZXID_PDP_CALL_URL;
795 : 277 : cf->xasp_vers = ZXID_XASP_VERS;
796 : :
797 : 277 : cf->need = zxid_load_need(cf, 0, ZXID_NEED);
798 : 277 : cf->want = zxid_load_need(cf, 0, ZXID_WANT);
799 : 277 : cf->attrsrc = zxid_load_atsrc(cf, 0, ZXID_ATTRSRC);
800 : 277 : cf->inmap = zxid_load_map(cf, 0, ZXID_INMAP);
801 : 277 : cf->outmap = zxid_load_map(cf, 0, ZXID_OUTMAP);
802 : 277 : cf->pepmap = zxid_load_map(cf, 0, ZXID_PEPMAP);
803 : 277 : cf->pepmap_rqout = zxid_load_map(cf, 0, ZXID_PEPMAP_RQOUT);
804 : 277 : cf->pepmap_rqin = zxid_load_map(cf, 0, ZXID_PEPMAP_RQIN);
805 : 277 : cf->pepmap_rsout = zxid_load_map(cf, 0, ZXID_PEPMAP_RSOUT);
806 : 277 : cf->pepmap_rsin = zxid_load_map(cf, 0, ZXID_PEPMAP_RSIN);
807 : :
808 : 277 : cf->localpdp_role_permit = zxid_load_cstr_list(cf, 0, ZXID_LOCALPDP_ROLE_PERMIT);
809 : 277 : cf->localpdp_role_deny = zxid_load_cstr_list(cf, 0, ZXID_LOCALPDP_ROLE_DENY);
810 : 277 : cf->localpdp_idpnid_permit = zxid_load_cstr_list(cf, 0, ZXID_LOCALPDP_IDPNID_PERMIT);
811 : 277 : cf->localpdp_idpnid_deny = zxid_load_cstr_list(cf, 0, ZXID_LOCALPDP_IDPNID_DENY);
812 : :
813 : 277 : cf->wsc_localpdp_obl_pledge = ZXID_WSC_LOCALPDP_OBL_PLEDGE;
814 : 277 : cf->wsp_localpdp_obl_req = ZXID_WSP_LOCALPDP_OBL_REQ;
815 : 277 : cf->wsp_localpdp_obl_emit = ZXID_WSP_LOCALPDP_OBL_EMIT;
816 : 277 : cf->wsc_localpdp_obl_accept = ZXID_WSC_LOCALPDP_OBL_ACCEPT;
817 : :
818 : 277 : cf->redir_to_content = ZXID_REDIR_TO_CONTENT;
819 : 277 : cf->remote_user_ena = ZXID_REMOTE_USER_ENA;
820 : 277 : cf->max_soap_retry = ZXID_MAX_SOAP_RETRY;
821 : 277 : cf->mod_saml_attr_prefix = ZXID_MOD_SAML_ATTR_PREFIX;
822 : :
823 : 277 : cf->bare_url_entityid = ZXID_BARE_URL_ENTITYID;
824 : 277 : cf->show_tech = ZXID_SHOW_TECH;
825 : 277 : cf->idp_sel_page = ZXID_IDP_SEL_PAGE;
826 : 277 : cf->idp_sel_templ_file= ZXID_IDP_SEL_TEMPL_FILE;
827 : 277 : cf->idp_sel_templ = ZXID_IDP_SEL_TEMPL;
828 : : #if 0
829 : : cf->idp_sel_start = ZXID_IDP_SEL_START;
830 : : cf->idp_sel_new_idp = ZXID_IDP_SEL_NEW_IDP;
831 : : cf->idp_sel_our_eid = ZXID_IDP_SEL_OUR_EID;
832 : : cf->idp_sel_tech_user = ZXID_IDP_SEL_TECH_USER;
833 : : cf->idp_sel_tech_site = ZXID_IDP_SEL_TECH_SITE;
834 : : cf->idp_sel_footer = ZXID_IDP_SEL_FOOTER;
835 : : cf->idp_sel_end = ZXID_IDP_SEL_END;
836 : : #endif
837 : :
838 : 277 : cf->an_page = ZXID_AN_PAGE;
839 : 277 : cf->an_templ_file = ZXID_AN_TEMPL_FILE;
840 : 277 : cf->an_templ = ZXID_AN_TEMPL;
841 : :
842 : 277 : cf->post_templ_file = ZXID_POST_TEMPL_FILE;
843 : 277 : cf->post_templ = ZXID_POST_TEMPL;
844 : :
845 : 277 : cf->err_page = ZXID_ERR_PAGE;
846 : 277 : cf->err_templ_file = ZXID_ERR_TEMPL_FILE;
847 : 277 : cf->err_templ = ZXID_ERR_TEMPL;
848 : :
849 : 277 : cf->new_user_page = ZXID_NEW_USER_PAGE;
850 : 277 : cf->recover_passwd = ZXID_RECOVER_PASSWD;
851 : 277 : cf->atsel_page = ZXID_ATSEL_PAGE;
852 : :
853 : 277 : cf->mgmt_start = ZXID_MGMT_START;
854 : 277 : cf->mgmt_logout = ZXID_MGMT_LOGOUT;
855 : 277 : cf->mgmt_defed = ZXID_MGMT_DEFED;
856 : 277 : cf->mgmt_footer = ZXID_MGMT_FOOTER;
857 : 277 : cf->mgmt_end = ZXID_MGMT_END;
858 : :
859 : 277 : LOCK_INIT(cf->mx);
860 : 277 : LOCK_INIT(cf->curl_mx);
861 [ + + ]: 277 : if (!zxid_ent_cache_mx_init) {
862 : 272 : LOCK_INIT(zxid_ent_cache_mx);
863 : 272 : zxid_ent_cache_mx_init = 1;
864 : : }
865 : :
866 : : #if 1
867 : : DD("path(%.*s) cf->magic=%x", cf->path_len, cf->path, cf->magic);
868 : : #else
869 : : fprintf(stderr, "t %9s:%-3d %-16s %s d " "path(%.*s) cf->magic=%x" "\n",
870 : : __FILE__, __LINE__, __FUNCTION__, ERRMAC_INSTANCE, cf->path_len, cf->path, cf->magic);
871 : : fflush(stderr);
872 : : #endif
873 : 277 : return 0;
874 : : }
875 : :
876 : : /*() Reset the seen doubly linked list to empty and initialize memory
877 : : * allocation related function pointers to system malloc(3). Without
878 : : * such initialization, any meomory allocation activity as well as
879 : : * any XML parsing activity is doomed to segmentation fault. */
880 : :
881 : : /* Called by: dirconf, main x3, zx_init_ctx, zxid_az, zxid_az_base, zxid_simple_len */
882 : : void zx_reset_ctx(struct zx_ctx* ctx)
883 : 292 : {
884 : 292 : ZERO(ctx, sizeof(struct zx_ctx));
885 : 292 : LOCK_INIT(ctx->mx);
886 : 292 : ctx->guard_seen_n.seen_n = &ctx->guard_seen_p;
887 : 292 : ctx->guard_seen_p.seen_p = &ctx->guard_seen_n;
888 : 292 : ctx->malloc_func = &malloc;
889 : 292 : ctx->realloc_func = &realloc;
890 : 292 : ctx->free_func = &free;
891 : 292 : }
892 : :
893 : : /*() Allocate new ZX object and initialize it in standard
894 : : * way, i.e. use malloc(3) for memory allocation. */
895 : :
896 : : /* Called by: zxid_conf_to_cf_len, zxid_init_conf_ctx */
897 : : struct zx_ctx* zx_init_ctx()
898 : 86 : {
899 : : struct zx_ctx* ctx;
900 : 86 : ctx = malloc(sizeof(struct zx_ctx));
901 [ + + - + ]: 86 : D("malloc %p size=%d", ctx, sizeof(struct zx_ctx));
902 [ - + ]: 86 : if (!ctx) {
903 : 0 : ERR("out-of-memory in ctx alloc sizeof=%d", sizeof(struct zx_ctx));
904 : 0 : return 0;
905 : : }
906 : 86 : zx_reset_ctx(ctx);
907 : 86 : return ctx;
908 : : }
909 : :
910 : : /*() Minimal initialization of
911 : : * the context is performed. Certificate and key operations as well as
912 : : * CURL initialization are omitted. However the zx_ctx is installed so
913 : : * that memory allocation against the context should work.
914 : : * Supplying zxid_path merely initializes the PATH config option,
915 : : * but does not cause configuration file to be read.
916 : : *
917 : : * Just initializes the config object to factory defaults (see zxidconf.h).
918 : : * Previous content of the config object is lost. */
919 : :
920 : : /* Called by: zxid_conf_to_cf_len, zxid_new_conf */
921 : : zxid_conf* zxid_init_conf_ctx(zxid_conf* cf, const char* zxid_path)
922 : 15 : {
923 : : #if 0
924 : : fprintf(stderr, "Waiting 60 secs for gdb attach...\n");
925 : : sleep(60);
926 : : #endif
927 : 15 : cf->ctx = zx_init_ctx();
928 [ - + ]: 15 : if (!cf->ctx)
929 : 0 : return 0;
930 : 15 : zxid_init_conf(cf, zxid_path);
931 : : #ifdef USE_CURL
932 [ + + ]: 15 : if (zxid_path) {
933 : 8 : cf->curl = curl_easy_init();
934 [ - + ]: 8 : if (!cf->curl) {
935 : 0 : ERR("Failed to initialize libcurl %d",0);
936 : 0 : exit(2);
937 : : }
938 : : }
939 : : #endif
940 : 15 : return cf;
941 : : }
942 : :
943 : : /*() Allocate conf object and initialize it with default config or config file.
944 : : * See zxid_new_conf_to_cf() for a more complete solution.
945 : : * Just initializes the config object to factory defaults (see zxidconf.h).
946 : : * Previous content of the config object is lost. */
947 : :
948 : : /* Called by: a7n_test, attribute_sort_test, covimp_test, main x5, so_enc_dec, test_ibm_cert_problem, test_ibm_cert_problem_enc_dec, test_mode, x509_test */
949 : : zxid_conf* zxid_new_conf(const char* zxid_path)
950 : 15 : {
951 : : /* *** unholy malloc()s: should use our own allocator! */
952 : 15 : zxid_conf* cf = malloc(sizeof(zxid_conf));
953 [ - + ]: 15 : if (!cf) {
954 : 0 : ERR("out-of-memory %d", sizeof(zxid_conf));
955 : 0 : exit(1);
956 : : }
957 : 15 : return zxid_init_conf_ctx(cf, zxid_path);
958 : : }
959 : :
960 : : /* ======================= CONF PARSING ======================== */
961 : :
962 : : #if defined(ZXID_CONF_FILE) || defined(ZXID_CONF_FLAG)
963 : :
964 : : #define SCAN_INT(v, lval) sscanf(v,"%i",&i); lval=i /* Safe for char, too */
965 : :
966 : : /*(i) Parse partial configuration specifications, such as may occur
967 : : * on command line or in a configuration file.
968 : : *
969 : : * Generally you should
970 : : * call first zxid_new_conf(), or at least zxid_init_conf(), and
971 : : * then call this function to apply modifications over the defaults.
972 : : * The configuration options are named after the config options
973 : : * that appear in zxidconf.h, except that prefix ZXID_ is removed.
974 : : *
975 : : * N.B. The qs memory must come from static or permanently allocated
976 : : * source as direct pointers to inside it will be taken. The memory
977 : : * will be modified to add nul terminations. Do not use stack based
978 : : * memory like local variable (unless local of main()).
979 : : * Do consider strdup() or similar before calling this function.
980 : : *
981 : : * cf:: Previously allocated and initialized ZXID configuration object
982 : : * qs_len:: Query String length. -1 means nul terminated C string
983 : : * qs:: Configuration data in extended CGI Query String format. "extended"
984 : : * means newline can be used as separator, in addition to ampersand ("&")
985 : : * This argument is modified in place, changing separators to nul string
986 : : * terminations.
987 : : * return:: -1 on failure, 0 on success */
988 : :
989 : : /* Called by: zxid_conf_to_cf_len x2, zxid_parse_conf, zxid_parse_conf_raw */
990 : : int zxid_parse_conf_raw(zxid_conf* cf, int qs_len, char* qs)
991 : 684 : {
992 : : int i, len;
993 : : char *p, *n, *v, *val, *name, *buf;
994 [ + - - + ]: 684 : if (qs_len != -1 && qs[qs_len]) { /* *** access one past end of buffer */
995 : 0 : ERR("LIMITATION: The configuration strings MUST be nul terminated (even when length is supplied explicitly). qs_len=%d qs(%.*s)", qs_len, qs_len, qs);
996 : 0 : return -1;
997 : : }
998 [ + + ]: 12318 : while (*qs) {
999 : 10950 : qs += strspn(qs, "& \n\t\r"); /* Skip over & or &&, or line end */
1000 [ + - ]: 10950 : if (!*qs) break;
1001 [ + + ]: 10950 : if (*qs == '#')
1002 : 4735 : goto scan_end;
1003 : :
1004 : 6215 : qs = strchr(name = qs, '='); /* Scan name (until '=') */
1005 [ + - ]: 6215 : if (!qs) break; /* No = ever found and at EOF. No value avail. */
1006 [ - + ]: 6215 : if (qs == name) { /* Key was an empty string: skip it */
1007 : 4735 : scan_end:
1008 : 4735 : qs += strcspn(qs, "&\n\r"); /* Scan value (until '&') */
1009 : 4735 : continue;
1010 : : }
1011 : 6215 : n = p = name;
1012 [ - + # # : 6215 : URL_DECODE(p, name, qs);
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # - + +
+ ]
1013 : 6215 : *p = 0;
1014 : :
1015 : 6215 : val = ++qs;
1016 : 6215 : qs += strcspn(qs, "&\n\r"); /* Skip over = and scan val */
1017 : 6215 : v = p = val;
1018 [ + + + - : 6215 : URL_DECODE(p, val, qs);
+ - - + #
# # # # #
# # + - -
+ # # # #
# # # # +
- + - + -
+ - - + +
+ ]
1019 [ + + ]: 6215 : if (*qs)
1020 : 5991 : ++qs;
1021 : 6215 : *p = 0;
1022 : :
1023 [ + + - + : 6215 : switch (n[0]) {
- - + - -
+ + + + +
+ + + -
- ]
1024 : : case 'A': /* AUTHN_REQ_SIGN, ACT, AUDIENCE_FATAL, AFTER_SLOP */
1025 [ - + ]: 316 : if (!strcmp(n, "AUTO_CERT")) { SCAN_INT(v, cf->auto_cert); break; }
1026 [ - + ]: 316 : if (!strcmp(n, "AUTHN_REQ_SIGN")) { SCAN_INT(v, cf->authn_req_sign); break; }
1027 [ - + ]: 316 : if (!strcmp(n, "ACT")) { SCAN_INT(v, cf->log_act); break; }
1028 [ - + ]: 316 : if (!strcmp(n, "ACT_IN_ERR")) { SCAN_INT(v, cf->log_err_in_act); break; }
1029 [ + + ]: 316 : if (!strcmp(n, "AUDIENCE_FATAL")) { SCAN_INT(v, cf->audience_fatal); break; }
1030 [ - + ]: 310 : if (!strcmp(n, "AFTER_SLOP")) { SCAN_INT(v, cf->after_slop); break; }
1031 [ - + # # : 310 : if (!strcmp(n, "ANON_OK")) { cf->anon_ok = v; D("anon_ok(%s)", cf->anon_ok); break; }
# # ]
1032 [ - + ]: 310 : if (!strcmp(n, "AN_PAGE")) { cf->an_page = v; break; }
1033 [ - + ]: 310 : if (!strcmp(n, "AN_TEMPL_FILE")) { cf->an_templ_file = v; break; }
1034 [ - + ]: 310 : if (!strcmp(n, "AN_TEMPL")) { cf->an_templ = v; break; }
1035 [ + + ]: 310 : if (!strcmp(n, "ATSEL_PAGE")) { cf->atsel_page = v; break; }
1036 [ - + ]: 155 : if (!strcmp(n, "ATTRSRC")) { cf->attrsrc = zxid_load_atsrc(cf, cf->attrsrc, v); break; }
1037 [ - + ]: 155 : if (!strcmp(n, "A7NTTL")) { SCAN_INT(v, cf->a7nttl); break; }
1038 [ + - ]: 155 : if (!strcmp(n, "AS_ENA")) { SCAN_INT(v, cf->as_ena); break; }
1039 : 0 : goto badcf;
1040 : : case 'B': /* BEFORE_SLOP */
1041 [ - + ]: 155 : if (!strcmp(n, "BEFORE_SLOP")) { SCAN_INT(v, cf->before_slop); break; }
1042 [ - + ]: 155 : if (!strcmp(n, "BOOTSTRAP_LEVEL")) { SCAN_INT(v, cf->bootstrap_level); break; }
1043 [ + - ]: 155 : if (!strcmp(n, "BARE_URL_ENTITYID")) { SCAN_INT(v, cf->bare_url_entityid); break; }
1044 : 0 : goto badcf;
1045 : : case 'C': /* CDC_URL, CDC_CHOICE */
1046 [ # # ]: 0 : if (!strcmp(n, "CDC_URL")) { cf->cdc_url = v; break; }
1047 [ # # ]: 0 : if (!strcmp(n, "CDC_CHOICE")) { SCAN_INT(v, cf->cdc_choice); break; }
1048 [ # # ]: 0 : if (!strcmp(n, "CONTACT_ORG")) { cf->contact_org = v; break; }
1049 [ # # ]: 0 : if (!strcmp(n, "CONTACT_NAME")) { cf->contact_name = v; break; }
1050 [ # # ]: 0 : if (!strcmp(n, "CONTACT_EMAIL")) { cf->contact_email = v; break; }
1051 [ # # ]: 0 : if (!strcmp(n, "CONTACT_TEL")) { cf->contact_tel = v; break; }
1052 [ # # ]: 0 : if (!strcmp(n, "COUNTRY")) { cf->country = v; break; }
1053 [ # # # # ]: 0 : if (!strcmp(n, "CANON_INOPT")) { SCAN_INT(v, cf->canon_inopt); if (cf->ctx) cf->ctx->canon_inopt = cf->canon_inopt; break; }
1054 : 0 : goto badcf;
1055 : : case 'D': /* DUP_A7N_FATAL, DUP_MSG_FATAL */
1056 [ - + ]: 378 : if (!strcmp(n, "DEFAULTQS")) { cf->defaultqs = v; break; }
1057 [ + + ]: 378 : if (!strcmp(n, "DUP_A7N_FATAL")) { SCAN_INT(v, cf->dup_a7n_fatal); break; }
1058 [ + - ]: 189 : if (!strcmp(n, "DUP_MSG_FATAL")) { SCAN_INT(v, cf->dup_msg_fatal); break; }
1059 [ # # ]: 0 : if (!strcmp(n, "DI_ALLOW_CREATE")) { cf->di_allow_create = *v; break; }
1060 [ # # ]: 0 : if (!strcmp(n, "DI_NID_FMT")) { SCAN_INT(v, cf->di_nid_fmt); break; }
1061 [ # # ]: 0 : if (!strcmp(n, "DI_A7N_ENC")) { SCAN_INT(v, cf->di_a7n_enc); break; }
1062 : 0 : goto badcf;
1063 : : case 'E': /* ERR, ERR_IN_ACT */
1064 [ # # ]: 0 : if (!strcmp(n, "ERR")) { SCAN_INT(v, cf->log_err); break; }
1065 [ # # ]: 0 : if (!strcmp(n, "ERR_IN_ACT")) { SCAN_INT(v, cf->log_err_in_act); break; }
1066 [ # # ]: 0 : if (!strcmp(n, "ENC_TAIL_OPT")) { SCAN_INT(v, cf->enc_tail_opt); break; }
1067 [ # # ]: 0 : if (!strcmp(n, "ENCKEY_OPT")) { SCAN_INT(v, cf->enckey_opt); break; }
1068 [ # # ]: 0 : if (!strcmp(n, "ERR_PAGE")) { cf->err_page = v; break; }
1069 [ # # ]: 0 : if (!strcmp(n, "ERR_TEMPL_FILE")) { cf->err_templ_file = v; break; }
1070 [ # # ]: 0 : if (!strcmp(n, "ERR_TEMPL")) { cf->err_templ = v; break; }
1071 : 0 : goto badcf;
1072 : : case 'F':
1073 [ # # ]: 0 : if (!strcmp(n, "FEDUSERNAME_SUFFIX")) { cf->fedusername_suffix = v; break; }
1074 : 0 : goto badcf;
1075 : : case 'I': /* ISSUE_A7N, ISSUE_MSG */
1076 [ - + ]: 615 : if (!strcmp(n, "ISSUE_A7N")) { SCAN_INT(v, cf->log_issue_a7n); break; }
1077 [ - + ]: 615 : if (!strcmp(n, "ISSUE_MSG")) { SCAN_INT(v, cf->log_issue_msg); break; }
1078 [ - + ]: 615 : if (!strcmp(n, "ISSUE_AUTHNCTX_PW")) { cf->issue_authnctx_pw = v; break; }
1079 : : #if 0
1080 : : if (!strcmp(n, "IDP_SEL_START")) { cf->idp_sel_start = v; break; }
1081 : : if (!strcmp(n, "IDP_SEL_NEW_IDP")) { cf->idp_sel_new_idp = v; break; }
1082 : : if (!strcmp(n, "IDP_SEL_OUR_EID")) { cf->idp_sel_our_eid = v; break; }
1083 : : if (!strcmp(n, "IDP_SEL_TECH_USER")) { cf->idp_sel_tech_user =v; break; }
1084 : : if (!strcmp(n, "IDP_SEL_TECH_SITE")) { cf->idp_sel_tech_site =v; break; }
1085 : : if (!strcmp(n, "IDP_SEL_FOOTER")) { cf->idp_sel_footer = v; break; }
1086 : : if (!strcmp(n, "IDP_SEL_END")) { cf->idp_sel_end = v; break; }
1087 : : #endif
1088 [ - + ]: 615 : if (!strcmp(n, "IDP_SEL_PAGE")) { cf->idp_sel_page = v; break; }
1089 [ - + ]: 615 : if (!strcmp(n, "IDP_SEL_TEMPL_FILE")) { cf->idp_sel_templ_file = v; break; }
1090 [ - + ]: 615 : if (!strcmp(n, "IDP_SEL_TEMPL")) { cf->idp_sel_templ = v; break; }
1091 [ + + ]: 615 : if (!strcmp(n, "IDP_ENA")) { SCAN_INT(v, cf->idp_ena); break; }
1092 [ + + ]: 460 : if (!strcmp(n, "IMPS_ENA")) { SCAN_INT(v, cf->imps_ena); break; }
1093 [ - + ]: 305 : if (!strcmp(n, "IDP_PREF_ACS_BINDING")) { cf->idp_pref_acs_binding = v; break; }
1094 [ - + ]: 305 : if (!strcmp(n, "IDPATOPT")) { SCAN_INT(v, cf->idpatopt); break; }
1095 [ + - ]: 305 : if (!strcmp(n, "IDP_LIST_METH")) { SCAN_INT(v, cf->idp_list_meth); break; }
1096 [ # # ]: 0 : if (!strcmp(n, "INMAP")) { cf->inmap = zxid_load_map(cf, cf->inmap, v); break; }
1097 : 0 : goto badcf;
1098 : : case 'L': /* LEVEL (log level) */
1099 [ # # ]: 0 : if (!strcmp(n, "LEVEL")) { SCAN_INT(v, cf->log_level); break; }
1100 [ # # ]: 0 : if (!strcmp(n, "LOGUSER")) { SCAN_INT(v, cf->loguser); break; }
1101 [ # # ]: 0 : if (!strcmp(n, "LOCALPDP_ROLE_PERMIT")) { cf->localpdp_role_permit = zxid_load_cstr_list(cf, cf->localpdp_role_permit, v); break; }
1102 [ # # ]: 0 : if (!strcmp(n, "LOCALPDP_ROLE_DENY")) { cf->localpdp_role_deny = zxid_load_cstr_list(cf, cf->localpdp_role_deny, v); break; }
1103 [ # # ]: 0 : if (!strcmp(n, "LOCALPDP_IDPNID_PERMIT")) { cf->localpdp_idpnid_permit = zxid_load_cstr_list(cf, cf->localpdp_idpnid_permit, v); break; }
1104 [ # # ]: 0 : if (!strcmp(n, "LOCALPDP_IDPNID_DENY")) { cf->localpdp_idpnid_deny = zxid_load_cstr_list(cf, cf->localpdp_idpnid_deny, v); break; }
1105 [ # # ]: 0 : if (!strcmp(n, "LOAD_COT_CACHE")) { cf->load_cot_cache = v; break; }
1106 [ # # ]: 0 : if (!strcmp(n, "LOCALITY")) { cf->locality = v; break; }
1107 : 0 : goto badcf;
1108 : : case 'M': /* MD_FETCH, MD_POPULATE_CACHE, MD_CACHE_FIRST, MD_CACHE_LAST */
1109 [ # # ]: 0 : if (!strcmp(n, "MANDATORY_ATTR")) { cf->mandatory_attr = v; break; }
1110 [ # # ]: 0 : if (!strcmp(n, "MD_FETCH")) { SCAN_INT(v, cf->md_fetch); break; }
1111 [ # # ]: 0 : if (!strcmp(n, "MD_POPULATE_CACHE")) { SCAN_INT(v, cf->md_populate_cache); break; }
1112 [ # # ]: 0 : if (!strcmp(n, "MD_CACHE_FIRST")) { SCAN_INT(v, cf->md_cache_first); break; }
1113 [ # # ]: 0 : if (!strcmp(n, "MD_CACHE_LAST")) { SCAN_INT(v, cf->md_cache_last); break; }
1114 [ # # ]: 0 : if (!strcmp(n, "MGMT_START")) { cf->mgmt_start = v; break; }
1115 [ # # ]: 0 : if (!strcmp(n, "MGMT_LOGOUT")) { cf->mgmt_logout = v; break; }
1116 [ # # ]: 0 : if (!strcmp(n, "MGMT_DEFED")) { cf->mgmt_defed = v; break; }
1117 [ # # ]: 0 : if (!strcmp(n, "MGMT_FOOTER")) { cf->mgmt_footer = v; break; }
1118 [ # # ]: 0 : if (!strcmp(n, "MGMT_END")) { cf->mgmt_end = v; break; }
1119 [ # # ]: 0 : if (!strcmp(n, "MSG_SIG_OK")) { SCAN_INT(v, cf->msg_sig_ok); break; }
1120 [ # # ]: 0 : if (!strcmp(n, "MAX_SOAP_RETRY")) { SCAN_INT(v, cf->max_soap_retry); break; }
1121 [ # # ]: 0 : if (!strcmp(n, "MOD_SAML_ATTR_PREFIX")) { cf->mod_saml_attr_prefix = v; break; }
1122 : :
1123 : 0 : goto badcf;
1124 : : case 'N': /* NAMEID_ENC, NICE_NAME, NOSIG_FATAL */
1125 [ - + ]: 953 : if (!strcmp(n, "NAMEID_ENC")) { SCAN_INT(v, cf->nameid_enc); break; }
1126 [ + + ]: 953 : if (!strcmp(n, "NICE_NAME")) { cf->nice_name = v; break; }
1127 [ - + ]: 338 : if (!strcmp(n, "NON_STANDARD_ENTITYID")) { cf->non_standard_entityid = v; break; }
1128 [ + + ]: 338 : if (!strcmp(n, "NOSIG_FATAL")) { SCAN_INT(v, cf->nosig_fatal); break; }
1129 [ - + ]: 155 : if (!strcmp(n, "NOTIMESTAMP_FATAL")) { SCAN_INT(v, cf->notimestamp_fatal); break; }
1130 [ - + ]: 155 : if (!strcmp(n, "NEED")) { cf->need = zxid_load_need(cf, cf->need, v); break; }
1131 [ + - ]: 155 : if (!strcmp(n, "NEW_USER_PAGE")) { cf->new_user_page = v; break; }
1132 : 0 : goto badcf;
1133 : : case 'O': /* OUTMAP */
1134 [ + + ]: 948 : if (!strcmp(n, "OUTMAP")) { cf->outmap = zxid_load_map(cf, cf->outmap, v); break; }
1135 [ + + ]: 920 : if (!strcmp(n, "ORG_NAME")) { cf->org_name = v; break; }
1136 [ + - ]: 460 : if (!strcmp(n, "ORG_URL")) { cf->org_url = v; break; }
1137 : 0 : goto badcf;
1138 : : case 'P': /* PATH (e.g. /var/zxid) */
1139 : : DD("PATH maybe n(%s)=v(%s)", n, v);
1140 [ + + ]: 1275 : if (!strcmp(n, "PATH")) {
1141 : : DD("PATH inside file(%.*s) %d new(%s)", cf->path_len, cf->path, cf->path_supplied, v);
1142 [ - + # # : 200 : if (cf->path_supplied && !memcmp(cf->path, v, cf->path_len) || cf->path_supplied > 5) {
- + ]
1143 [ # # # # ]: 0 : D("Skipping PATH inside file(%.*s) %d", cf->path_len, cf->path, cf->path_supplied);
1144 : 0 : break;
1145 : : }
1146 : 200 : cf->path = v;
1147 : 200 : cf->path_len = strlen(v);
1148 : 200 : ++cf->path_supplied;
1149 : 200 : buf = read_all_alloc(cf->ctx, "-conf_to_cf", 1, &len, "%szxid.conf", cf->path);
1150 [ + + + - ]: 200 : if (buf && len)
1151 : 198 : zxid_parse_conf_raw(cf, len, buf); /* Recurse */
1152 : 200 : break;
1153 : : }
1154 [ + + ]: 1075 : if (!strcmp(n, "PDP_ENA")) { SCAN_INT(v, cf->pdp_ena); break; }
1155 [ + + ]: 765 : if (!strcmp(n, "PDP_URL")) { cf->pdp_url = v; break; }
1156 [ - + ]: 305 : if (!strcmp(n, "PDP_CALL_URL")) { cf->pdp_call_url = v; break; }
1157 [ + - ]: 305 : if (!strcmp(n, "PEPMAP")) { cf->pepmap = zxid_load_map(cf, cf->pepmap, v); break; }
1158 [ # # ]: 0 : if (!strcmp(n, "PEPMAP_RQOUT")) { cf->pepmap_rqout = zxid_load_map(cf, cf->pepmap_rqout, v); break; }
1159 [ # # ]: 0 : if (!strcmp(n, "PEPMAP_RQIN")) { cf->pepmap_rqin = zxid_load_map(cf, cf->pepmap_rqin, v); break; }
1160 [ # # ]: 0 : if (!strcmp(n, "PEPMAP_RSOUT")) { cf->pepmap_rsout = zxid_load_map(cf, cf->pepmap_rsout, v); break; }
1161 [ # # ]: 0 : if (!strcmp(n, "PEPMAP_RSIN")) { cf->pepmap_rsin = zxid_load_map(cf, cf->pepmap_rsin, v); break; }
1162 [ # # ]: 0 : if (!strcmp(n, "POST_A7N_ENC")) { SCAN_INT(v, cf->post_a7n_enc); break; }
1163 [ # # ]: 0 : if (!strcmp(n, "POST_TEMPL_FILE")) { cf->post_templ_file = v; break; }
1164 [ # # ]: 0 : if (!strcmp(n, "POST_TEMPL")) { cf->post_templ = v; break; }
1165 : 0 : goto badcf;
1166 : : case 'R': /* RELY_A7N, RELY_MSG */
1167 [ - + ]: 155 : if (!strcmp(n, "REDIRECT_HACK_IMPOSED_URL")) { cf->redirect_hack_imposed_url = v; break; }
1168 [ - + ]: 155 : if (!strcmp(n, "REDIRECT_HACK_ZXID_URL")) {
1169 : 0 : cf->redirect_hack_zxid_url = v;
1170 : 0 : p = strchr(v, '?');
1171 [ # # ]: 0 : if (p) {
1172 : 0 : *p = 0;
1173 : 0 : cf->redirect_hack_zxid_qs = p+1;
1174 : : }
1175 : 0 : break;
1176 : : }
1177 [ - + ]: 155 : if (!strcmp(n, "REDIR_TO_CONTENT")) { SCAN_INT(v, cf->redir_to_content); break; }
1178 [ - + ]: 155 : if (!strcmp(n, "REMOTE_USER_ENA")) { SCAN_INT(v, cf->remote_user_ena); break; }
1179 [ - + ]: 155 : if (!strcmp(n, "RELY_A7N")) { SCAN_INT(v, cf->log_rely_a7n); break; }
1180 [ - + ]: 155 : if (!strcmp(n, "RELY_MSG")) { SCAN_INT(v, cf->log_rely_msg); break; }
1181 [ - + ]: 155 : if (!strcmp(n, "REQUIRED_AUTHNCTX")) {
1182 : : /* Count how many */
1183 [ # # ]: 0 : for (i=2, p=v; *p; ++p)
1184 [ # # ]: 0 : if (*p == '$')
1185 : 0 : ++i;
1186 : 0 : cf->required_authnctx = zx_zalloc(cf->ctx, sizeof(char*) * i);
1187 : : /* Populate array with strings, stomping the separator char $ to nul termination. */
1188 [ # # ]: 0 : for (i=0, p=v; *p; ++i) {
1189 : 0 : cf->required_authnctx[i] = p;
1190 : 0 : p = strchr(p, '$');
1191 [ # # ]: 0 : if (!p)
1192 : 0 : break;
1193 : 0 : *p++ = 0;
1194 : : }
1195 : 0 : break;
1196 : : }
1197 [ + - ]: 155 : if (!strcmp(n, "RECOVER_PASSWD")) { cf->recover_passwd = v; break; }
1198 [ # # ]: 0 : if (!strcmp(n, "RELTO_FATAL")) { SCAN_INT(v, cf->relto_fatal); break; }
1199 : 0 : goto badcf;
1200 : : case 'S': /* SES_ARCH_DIR, SIGFAIL_IS_ERR, SIG_FATAL */
1201 [ - + # # : 155 : if (!strcmp(n, "SES_ARCH_DIR")) { cf->ses_arch_dir = (v[0]=='0' && !v[1]) ? 0 : v; break; }
# # ]
1202 [ + - - + : 155 : if (!strcmp(n, "SES_COOKIE_NAME")) { cf->ses_cookie_name = (v[0]=='0' && !v[1]) ? 0 : v; break; }
# # ]
1203 [ # # ]: 0 : if (!strcmp(n, "SIGFAIL_IS_ERR")) { SCAN_INT(v, cf->log_sigfail_is_err); break; }
1204 [ # # ]: 0 : if (!strcmp(n, "SIG_FATAL")) { SCAN_INT(v, cf->sig_fatal); break; }
1205 [ # # ]: 0 : if (!strcmp(n, "SSO_SIGN")) { SCAN_INT(v, cf->sso_sign); break; }
1206 [ # # ]: 0 : if (!strcmp(n, "SSO_SOAP_SIGN")) { SCAN_INT(v, cf->sso_soap_sign); break; }
1207 [ # # ]: 0 : if (!strcmp(n, "SSO_SOAP_RESP_SIGN")) { SCAN_INT(v, cf->sso_soap_resp_sign); break; }
1208 [ # # ]: 0 : if (!strcmp(n, "SHOW_CONF")) { SCAN_INT(v, cf->show_conf); break; }
1209 [ # # ]: 0 : if (!strcmp(n, "SHOW_TECH")) { SCAN_INT(v, cf->show_tech); break; }
1210 [ # # ]: 0 : if (!strcmp(n, "STATE")) { cf->state = v; break; }
1211 : 0 : goto badcf;
1212 : : case 'T': /* TIMEOUT_FATAL */
1213 [ + - ]: 6 : if (!strcmp(n, "TIMEOUT_FATAL")) { SCAN_INT(v, cf->timeout_fatal); break; }
1214 [ # # ]: 0 : if (!strcmp(n, "TIMESKEW")) { SCAN_INT(v, cf->timeskew); break; }
1215 : 0 : goto badcf;
1216 : : case 'U': /* URL, USER_LOCAL */
1217 [ + - ]: 649 : if (!strcmp(n, "URL")) { cf->url = v; cf->fedusername_suffix = zxid_grab_domain_name(cf, cf->url); break; }
1218 [ # # ]: 0 : if (!strcmp(n, "USER_LOCAL")) { SCAN_INT(v, cf->user_local); break; }
1219 : 0 : goto badcf;
1220 : : case 'W': /* WANT_SSO_A7N_SIGNED */
1221 [ - + ]: 610 : if (!strcmp(n, "WANT")) { cf->want = zxid_load_need(cf, cf->want, v); break; }
1222 [ - + ]: 610 : if (!strcmp(n, "WANT_SSO_A7N_SIGNED")) { SCAN_INT(v, cf->want_sso_a7n_signed); break; }
1223 [ - + ]: 610 : if (!strcmp(n, "WANT_AUTHN_REQ_SIGNED")) { SCAN_INT(v, cf->want_authn_req_signed); break; }
1224 [ - + ]: 610 : if (!strcmp(n, "WSC_SIGN")) { SCAN_INT(v, cf->wsc_sign); break; }
1225 [ - + ]: 610 : if (!strcmp(n, "WSP_SIGN")) { SCAN_INT(v, cf->wsp_sign); break; }
1226 [ - + ]: 610 : if (!strcmp(n, "WSPCGICMD")) { cf->wspcgicmd = v; break; }
1227 [ - + ]: 610 : if (!strcmp(n, "WSP_NOSIG_FATAL")) { SCAN_INT(v, cf->wsp_nosig_fatal); break; }
1228 [ + + ]: 610 : if (!strcmp(n, "WSC_LOCALPDP_OBL_PLEDGE")) { cf->wsc_localpdp_obl_pledge = v; break; }
1229 [ - + ]: 305 : if (!strcmp(n, "WSP_LOCALPDP_OBL_REQ")) { cf->wsp_localpdp_obl_req = v; break; }
1230 [ + - ]: 305 : if (!strcmp(n, "WSP_LOCALPDP_OBL_EMIT")) { cf->wsp_localpdp_obl_emit = v; break; }
1231 [ # # ]: 0 : if (!strcmp(n, "WSC_LOCALPDP_OBL_ACCEPT")) { cf->wsc_localpdp_obl_accept = v; break; }
1232 : 0 : goto badcf;
1233 : : case 'X': /* XASP_VERS */
1234 [ # # ]: 0 : if (!strcmp(n, "XASP_VERS")) { cf->xasp_vers = v; break; }
1235 : : goto badcf;
1236 : : default:
1237 : 0 : badcf:
1238 : 0 : ERR("Unknown config option(%s) val(%s), ignored.", n, v);
1239 : 0 : zxlog(cf, 0, 0, 0, 0, 0, 0, 0, "N", "S", "BADCF", n, 0);
1240 : : }
1241 : : }
1242 : 684 : return 0;
1243 : : }
1244 : :
1245 : : /*() Wrapper with initial error checking for zxid_parse_conf_raw(), which see. */
1246 : :
1247 : : /* Called by: opt x9, set_zxid_conf */
1248 : : int zxid_parse_conf(zxid_conf* cf, char* qs)
1249 : 27 : {
1250 [ + - - + ]: 27 : if (!cf || !qs)
1251 : 0 : return -1;
1252 : 27 : return zxid_parse_conf_raw(cf, strlen(qs), qs);
1253 : : }
1254 : :
1255 : : #endif
1256 : :
1257 : : /*() Pretty print need or want chain. */
1258 : :
1259 : : /* Called by: zxid_show_conf x2 */
1260 : : static struct zx_str* zxid_show_need(zxid_conf* cf, struct zxid_need* np)
1261 : 8 : {
1262 : : struct zxid_attr* ap;
1263 : : struct zx_str* ss;
1264 : 8 : struct zx_str* need = zx_dup_str(cf->ctx, "");
1265 [ + + ]: 16 : for (; np; np = np->n) {
1266 : 8 : ss = zx_dup_str(cf->ctx, "");
1267 [ + + ]: 48 : for (ap = np->at; ap; ap = ap->n) {
1268 [ + - ]: 40 : ss = zx_strf(cf->ctx, "%s,%.*s", STRNULLCHK(ap->name), ss->len, ss->s);
1269 : : }
1270 [ + - ]: 8 : if (ss->len) { /* chop off last comma separator */
1271 : 8 : ss->len -= 1;
1272 : 8 : ss->s[ss->len] = 0;
1273 : : }
1274 [ + - + - : 8 : need = zx_strf(cf->ctx, " attrs(%s)\n usage(%s)\n retent(%s)\n oblig(%s)\n ext(%s)$\n%.*s", ss->s, STRNULLCHK(np->usage), STRNULLCHK(np->retent), STRNULLCHK(np->oblig), STRNULLCHK(np->ext),
+ - + - ]
1275 : : need->len, need->s);
1276 : : }
1277 [ + - ]: 8 : if (need->len) { /* chop off last dollar separator */
1278 : 8 : need->len -= 2;
1279 : 8 : need->s[need->len] = 0;
1280 : : }
1281 : 8 : return need;
1282 : : }
1283 : :
1284 : : /*() Pretty print map chain. */
1285 : :
1286 : : /* Called by: zxid_show_conf x7 */
1287 : : static struct zx_str* zxid_show_map(zxid_conf* cf, struct zxid_map* mp)
1288 : 28 : {
1289 : 28 : struct zx_str* inmap = zx_dup_str(cf->ctx, "");
1290 [ + + ]: 199 : for (; mp; mp = mp->n) {
1291 [ + - + - : 171 : inmap = zx_strf(cf->ctx, " rule=%d$ ns(%s)$ src(%s)$ dst(%s)$ ext(%s);\n%.*s", mp->rule, STRNULLCHK(mp->ns), STRNULLCHK(mp->src), STRNULLCHK(mp->dst), STRNULLCHK(mp->ext), inmap->len, inmap->s);
+ - + - ]
1292 : : }
1293 [ + + ]: 28 : if (inmap->len) { /* chop off last semicolon separator */
1294 : 21 : inmap->len -= 2;
1295 : 21 : inmap->s[inmap->len] = 0;
1296 : : }
1297 : 28 : return inmap;
1298 : : }
1299 : :
1300 : :
1301 : : /*() Pretty print cstr list as used in local PDP. */
1302 : :
1303 : : /* Called by: zxid_show_conf x4 */
1304 : : static struct zx_str* zxid_show_cstr_list(zxid_conf* cf, struct zxid_cstr_list* cp)
1305 : 16 : {
1306 : 16 : struct zx_str* ss = zx_dup_str(cf->ctx, "");
1307 [ + + ]: 24 : for (; cp; cp = cp->n) {
1308 [ + - ]: 8 : ss = zx_strf(cf->ctx, " %s,\n%.*s", STRNULLCHK(cp->s), ss->len, ss->s);
1309 : : }
1310 [ + + ]: 16 : if (ss->len) { /* chop off last comma separator */
1311 : 8 : ss->len -= 2;
1312 : 8 : ss->s[ss->len] = 0;
1313 : : }
1314 : 16 : return ss;
1315 : : }
1316 : :
1317 : : /*() Generate our SP CARML and return it as a string. */
1318 : :
1319 : : /* Called by: opt x2, zxid_simple_show_conf */
1320 : : struct zx_str* zxid_show_conf(zxid_conf* cf)
1321 : 4 : {
1322 : : char* p;
1323 : : struct zxid_attr* ap;
1324 : : struct zxid_atsrc* sp;
1325 : : struct zx_str* ss;
1326 : : struct zx_str* required_authnctx;
1327 : : struct zx_str* need;
1328 : : struct zx_str* want;
1329 : : struct zx_str* attrsrc;
1330 : : struct zx_str* inmap;
1331 : : struct zx_str* outmap;
1332 : : struct zx_str* pepmap;
1333 : : struct zx_str* pepmap_rqout;
1334 : : struct zx_str* pepmap_rqin;
1335 : : struct zx_str* pepmap_rsout;
1336 : : struct zx_str* pepmap_rsin;
1337 : : struct zx_str* localpdp_role_permit;
1338 : : struct zx_str* localpdp_role_deny;
1339 : : struct zx_str* localpdp_idpnid_permit;
1340 : : struct zx_str* localpdp_idpnid_deny;
1341 [ + - ]: 4 : if (cf->log_level>0)
1342 : 4 : zxlog(cf, 0, 0, 0, 0, 0, 0, 0, "N", "W", "MYCONF", 0, 0);
1343 : :
1344 [ - + ]: 4 : if (!cf->show_conf) {
1345 : 0 : return zx_strf(cf->ctx, "<title>ZXID Conf disabled</title><body bgcolor=white>ZXID Conf viewing disabled using SHOW_CONF=0 option.");
1346 : : }
1347 : :
1348 : : /* N.B. The following way of "concatenating" strings leaks memory of the intermediate
1349 : : * results. We can't be bothered as the o=d is just a debug page. */
1350 : :
1351 : 4 : required_authnctx = zx_dup_str(cf->ctx, "");
1352 [ - + - + ]: 4 : for (p = cf->required_authnctx ? *cf->required_authnctx:0; p; ++p) {
1353 : 0 : required_authnctx = zx_strf(cf->ctx, " %s$\n%.*s", p, required_authnctx->len, required_authnctx->s);
1354 : : }
1355 [ - + ]: 4 : if (required_authnctx->len) { /* chop off last dollar separator */
1356 : 0 : required_authnctx->len -= 2;
1357 : 0 : required_authnctx->s[required_authnctx->len] = 0;
1358 : : }
1359 : :
1360 : 4 : need = zxid_show_need(cf, cf->need);
1361 : 4 : want = zxid_show_need(cf, cf->want);
1362 : :
1363 : 4 : attrsrc = zx_dup_str(cf->ctx, "");
1364 [ - + ]: 4 : for (sp = cf->attrsrc; sp; sp = sp->n) {
1365 : 0 : ss = zx_dup_str(cf->ctx, "");
1366 [ # # ]: 0 : for (ap = sp->at; ap; ap = ap->n) {
1367 [ # # ]: 0 : ss = zx_strf(cf->ctx, "%s,%.*s", STRNULLCHK(ap->name), ss->len, ss->s);
1368 : : }
1369 [ # # ]: 0 : if (ss->len) { /* chop off last dollar separator */
1370 : 0 : ss->len -= 1;
1371 : 0 : ss->s[ss->len] = 0;
1372 : : }
1373 [ # # # # : 0 : attrsrc = zx_strf(cf->ctx, " attrs(%s)\n ns(%s)\n weight(%s)\n url(%s)\n aapml(%s)\n otherlim(%s)\n ext(%s)$\n%.*s", ss->s, STRNULLCHK(sp->ns), STRNULLCHK(sp->weight), STRNULLCHK(sp->url), STRNULLCHK(sp->aapml), STRNULLCHK(sp->otherlim), STRNULLCHK(sp->ext),
# # # # #
# # # ]
1374 : : attrsrc->len, attrsrc->s);
1375 : : }
1376 [ - + ]: 4 : if (attrsrc->len) { /* chop off last dollar separator */
1377 : 0 : attrsrc->len -= 2;
1378 : 0 : attrsrc->s[attrsrc->len] = 0;
1379 : : }
1380 : :
1381 : 4 : inmap = zxid_show_map(cf, cf->inmap);
1382 : 4 : outmap = zxid_show_map(cf, cf->outmap);
1383 : 4 : pepmap = zxid_show_map(cf, cf->pepmap);
1384 : 4 : pepmap_rqout = zxid_show_map(cf, cf->pepmap_rqout);
1385 : 4 : pepmap_rqin = zxid_show_map(cf, cf->pepmap_rqin);
1386 : 4 : pepmap_rsout = zxid_show_map(cf, cf->pepmap_rsout);
1387 : 4 : pepmap_rsin = zxid_show_map(cf, cf->pepmap_rsin);
1388 : :
1389 : 4 : localpdp_role_permit = zxid_show_cstr_list(cf, cf->localpdp_role_permit);
1390 : 4 : localpdp_role_deny = zxid_show_cstr_list(cf, cf->localpdp_role_deny);
1391 : 4 : localpdp_idpnid_permit = zxid_show_cstr_list(cf, cf->localpdp_idpnid_permit);
1392 : 4 : localpdp_idpnid_deny = zxid_show_cstr_list(cf, cf->localpdp_idpnid_deny);
1393 : :
1394 : 4 : ss = zxid_my_ent_id(cf);
1395 : :
1396 [ - + + - : 4 : return zx_strf(cf->ctx,
- + + - -
+ + - + -
+ - + - +
- - + - +
- + + - +
- - + + -
+ - + - +
- - + + -
+ - - + +
- + - - +
+ - + - +
- + - - +
- + + - -
+ - + + -
- + - + -
+ - + - +
+ - - + -
+ - + - +
+ - + - +
- + - + -
+ - - + ]
1397 : : "<title>ZXID Conf for %s</title><body bgcolor=white><h1>ZXID Conf for %s</h1>"
1398 : : "<p>Please see config file in %szxid.conf, and documentation in zxid-conf.pd and zxidconf.h\n"
1399 : : "<p>[ <a href=\"?o=B\">Metadata</a> | <a href=\"?o=c\">CARML</a> | <a href=\"?o=d\">This Conf Dump</a> ]\n"
1400 : : "<p>Version: R" ZXID_REL " (" ZXID_COMPILE_DATE ")\n"
1401 : :
1402 : : "<pre>"
1403 : : "PATH=%s\n"
1404 : : "URL=%s\n"
1405 : : "AFFILIATION=%s\n"
1406 : : "NICE_NAME=%s\n"
1407 : : "ORG_NAME=%s\n"
1408 : : "ORG_URL=%s\n"
1409 : : "LOCALITY=%s\n"
1410 : : "STATE=%s\n"
1411 : : "COUNTRY=%s\n"
1412 : : "CONTACT_ORG=%s\n"
1413 : : "CONTACT_NAME=%s\n"
1414 : : "CONTACT_EMAIL=%s\n"
1415 : : "CONTACT_TEL=%s\n"
1416 : : "FEDUSERNAME_SUFFIX=%s\n"
1417 : : "#ZXID_CONF_FILE=%d (compile)\n"
1418 : : "#ZXID_CONF_FLAG=%d (compile)\n"
1419 : : "NON_STANDARD_ENTITYID=%s\n"
1420 : : "REDIRECT_HACK_IMPOSED_URL=%s\n"
1421 : : "REDIRECT_HACK_ZXID_URL=%s\n"
1422 : : "REDIRECT_HACK_ZXID_QS=%s\n"
1423 : : "DEFAULTQS=%s\n"
1424 : : "CDC_URL=%s\n"
1425 : : "CDC_CHOICE=%d\n"
1426 : :
1427 : : "LOAD_COT_CACHE=%s\n"
1428 : : "MD_FETCH=%d\n"
1429 : : "MD_POPULATE_CACHE=%d\n"
1430 : : "MD_CACHE_FIRST=%d\n"
1431 : : "MD_CACHE_LAST=%d\n"
1432 : :
1433 : : "AUTO_CERT=%d\n"
1434 : : "AUTHN_REQ_SIGN=%d\n"
1435 : : "WANT_AUTHN_REQ_SIGNED=%d\n"
1436 : : "WANT_SSO_A7N_SIGNED=%d\n"
1437 : : "SSO_SOAP_SIGN=%d\n"
1438 : : "SSO_SOAP_RESP_SIGN=%d\n"
1439 : : "SSO_SIGN=%x\n"
1440 : : "WSC_SIGN=%x\n"
1441 : : "WSP_SIGN=%x\n"
1442 : : "WSPCGICMD=%s\n"
1443 : : "NAMEID_ENC=%x\n"
1444 : : "POST_A7N_ENC=%d\n"
1445 : : "CANON_INOPT=%x\n"
1446 : : "ENC_TAIL_OPT=%x\n"
1447 : : "ENCKEY_OPT=%d\n"
1448 : : "IDPATOPT=%d\n"
1449 : : "DI_ALLOW_CREATE=%d\n"
1450 : : "DI_NID_FMT=%d\n"
1451 : : "DI_A7N_ENC=%d\n"
1452 : : "BOOTSTRAP_LEVEL=%d\n"
1453 : : "SHOW_CONF=%x\n"
1454 : : "#ZXID_ID_BITS=%d (compile)\n"
1455 : : "#ZXID_ID_MAX_BITS=%d (compile)\n"
1456 : : "#ZXID_TRUE_RAND=%d (compile)\n"
1457 : : "SES_ARCH_DIR=%s\n"
1458 : : "SES_COOKIE_NAME=%s\n"
1459 : : "IPPORT=%s\n"
1460 : : "USER_LOCAL=%d\n"
1461 : : "IDP_ENA=%d\n"
1462 : : "IMPS_ENA=%d\n"
1463 : : "AS_ENA=%d\n"
1464 : : "PDP_ENA=%d\n"
1465 : : "#ZXID_MAX_BUF=%d (compile)\n"
1466 : :
1467 : : "LOG_ERR=%d\n"
1468 : : "LOG_ACT=%d\n"
1469 : : "LOG_ISSUE_A7N=%d\n"
1470 : : "LOG_ISSUE_MSG=%d\n"
1471 : : "LOG_RELY_A7N=%d\n"
1472 : : "LOG_RELY_MSG=%d\n"
1473 : : "LOG_ERR_IN_ACT=%d\n"
1474 : : "LOG_ACT_IN_ERR=%d\n"
1475 : : "LOG_SIGFAIL_IS_ERR=%d\n"
1476 : : "LOG_LEVEL=%d\n"
1477 : : "LOGUSER=%d\n"
1478 : :
1479 : : "SIG_FATAL=%d\n"
1480 : : "NOSIG_FATAL=%d\n"
1481 : : "MSG_SIG_OK=%d\n"
1482 : : "TIMEOUT_FATAL=%d\n"
1483 : : "AUDIENCE_FATAL=%d\n"
1484 : : "DUP_A7N_FATAL=%d\n"
1485 : : "DUP_MSG_FATAL=%d\n"
1486 : : "RELTO_FATAL=%d\n"
1487 : : "WSP_NOSIG_FATAL=%d\n"
1488 : : "NOTIMESTAMP_FATAL=%d\n"
1489 : : "REDIR_TO_CONTENT=%d\n"
1490 : : "REMOTE_USER_ENA=%d\n"
1491 : : "MAX_SOAP_RETRY=%d\n"
1492 : :
1493 : : "BEFORE_SLOP=%d\n"
1494 : : "AFTER_SLOP=%d\n"
1495 : : "TIMESKEW=%d\n"
1496 : : "A7NTTL=%d\n"
1497 : :
1498 : : "ANON_OK=%s\n"
1499 : : "ISSUE_AUTHNCTX_PW=%s\n"
1500 : : "IDP_PREF_ACS_BINDING=%s\n"
1501 : : "MANDATORY_ATTR=%s\n"
1502 : : "PDP_URL=%s\n"
1503 : : "PDP_CALL_URL=%s\n"
1504 : : "XASP_VERS=%s\n"
1505 : : "MOD_SAML_ATTR_PREFIX=%s\n"
1506 : : "BARE_URL_ENTITYID=%d\n"
1507 : : "SHOW_TECH=%d\n"
1508 : :
1509 : : "IDP_LIST_METH=%d\n"
1510 : : "IDP_SEL_PAGE=%s\n"
1511 : : "IDP_SEL_TEMPL_FILE=%s\n"
1512 : : "</pre>"
1513 : : "<textarea cols=100 rows=20>"
1514 : : "IDP_SEL_TEMPL=%s\n"
1515 : : #if 0
1516 : : "IDP_SEL_START=%s\n"
1517 : : "IDP_SEL_NEW_IDP=%s\n"
1518 : : "IDP_SEL_OUR_EID=%s\n"
1519 : : "IDP_SEL_TECH_USER=%s\n"
1520 : : "IDP_SEL_TECH_SITE=%s\n"
1521 : : "IDP_SEL_FOOTER=%s\n"
1522 : : "IDP_SEL_END=%s\n"
1523 : : #endif
1524 : : "</textarea><pre>\n"
1525 : :
1526 : : "AN_PAGE=%s\n"
1527 : : "AN_TEMPL_FILE=%s\n"
1528 : : "</pre><textarea cols=100 rows=20>"
1529 : : "AN_TEMPL=%s\n"
1530 : : "</textarea><pre>\n"
1531 : :
1532 : : "POST_TEMPL_FILE=%s\n"
1533 : : "</pre><textarea cols=100 rows=7>"
1534 : : "POST_TEMPL=%s\n"
1535 : : "</textarea><pre>\n"
1536 : :
1537 : : "ERR_PAGE=%s\n"
1538 : : "ERR_TEMPL_FILE=%s\n"
1539 : : "</pre><textarea cols=100 rows=7>"
1540 : : "ERR_TEMPL=%s\n"
1541 : : "</textarea><pre>\n"
1542 : :
1543 : : "NEW_USER_PAGE=%s\n"
1544 : : "RECOVER_PASSWD=%s\n"
1545 : : "ATSEL_PAGE=%s\n"
1546 : :
1547 : : "</pre><textarea cols=100 rows=15>"
1548 : : "MGMT_START=%s\n"
1549 : : "MGMT_LOGOUT=%s\n"
1550 : : "MGMT_DEFED=%s\n"
1551 : : "MGMT_FOOTER=%s\n"
1552 : : "MGMT_END=%s\n"
1553 : : "</textarea>"
1554 : :
1555 : : "<pre>\n"
1556 : : "DBG=%s\n"
1557 : :
1558 : : "REQUIRED_AUTHN_CTX=\n%s\n"
1559 : : "NEED=\n%s\n"
1560 : : "WANT=\n%s\n"
1561 : : "ATTRSRC=\n%s\n"
1562 : : "INMAP=\n%s\n"
1563 : : "OUTMAP=\n%s\n"
1564 : : "PEPMAP=\n%s\n"
1565 : : "PEPMAP_RQOUT=\n%s\n"
1566 : : "PEPMAP_RQIN=\n%s\n"
1567 : : "PEPMAP_RSOUT=\n%s\n"
1568 : : "PEPMAP_RSIN=\n%s\n"
1569 : : "LOCALPDP_ROLE_PERMIT=\n%s\n"
1570 : : "LOCALPDP_ROLE_DENY=\n%s\n"
1571 : : "LOCALPDP_IDPNID_PERMIT=\n%s\n"
1572 : : "LOCALPDP_IDPNID_DENY=\n%s\n"
1573 : : "WSC_LOCALPDP_OBL_PLEDGE=%s\n"
1574 : : "WSP_LOCALPDP_OBL_REQ=%s\n"
1575 : : "WSP_LOCALPDP_OBL_EMIT=%s\n"
1576 : : "WSC_LOCALPDP_OBL_ACCEPT=%s\n"
1577 : : "</pre>",
1578 : : cf->url, ss->s,
1579 : : cf->path,
1580 : :
1581 : : cf->path,
1582 : : cf->url,
1583 : : STRNULLCHK(cf->affiliation),
1584 : : STRNULLCHK(cf->nice_name),
1585 : : STRNULLCHK(cf->org_name),
1586 : : STRNULLCHK(cf->org_url),
1587 : : STRNULLCHK(cf->locality),
1588 : : STRNULLCHK(cf->state),
1589 : : STRNULLCHK(cf->country),
1590 : : STRNULLCHK(cf->contact_org),
1591 : : STRNULLCHK(cf->contact_name),
1592 : : STRNULLCHK(cf->contact_email),
1593 : : STRNULLCHK(cf->contact_tel),
1594 : : STRNULLCHK(cf->fedusername_suffix),
1595 : : ZXID_CONF_FILE,
1596 : : ZXID_CONF_FLAG,
1597 : : STRNULLCHK(cf->non_standard_entityid),
1598 : : STRNULLCHK(cf->redirect_hack_imposed_url),
1599 : : STRNULLCHK(cf->redirect_hack_zxid_url),
1600 : : STRNULLCHK(cf->redirect_hack_zxid_qs),
1601 : : STRNULLCHK(cf->defaultqs),
1602 : : STRNULLCHK(cf->cdc_url),
1603 : : cf->cdc_choice,
1604 : :
1605 : : STRNULLCHK(cf->load_cot_cache),
1606 : : cf->md_fetch,
1607 : : cf->md_populate_cache,
1608 : : cf->md_cache_first,
1609 : : cf->md_cache_last,
1610 : :
1611 : : cf->auto_cert,
1612 : : cf->authn_req_sign,
1613 : : cf->want_authn_req_signed,
1614 : : cf->want_sso_a7n_signed,
1615 : : cf->sso_soap_sign,
1616 : : cf->sso_soap_resp_sign,
1617 : : cf->sso_sign,
1618 : : cf->wsc_sign,
1619 : : cf->wsp_sign,
1620 : : cf->wspcgicmd,
1621 : : cf->nameid_enc,
1622 : : cf->post_a7n_enc,
1623 : : cf->canon_inopt,
1624 : : cf->enc_tail_opt,
1625 : : cf->enckey_opt,
1626 : : cf->idpatopt,
1627 : : cf->di_allow_create,
1628 : : cf->di_nid_fmt,
1629 : : cf->di_a7n_enc,
1630 : : cf->bootstrap_level,
1631 : : cf->show_conf,
1632 : : ZXID_ID_BITS,
1633 : : ZXID_ID_MAX_BITS,
1634 : : ZXID_TRUE_RAND,
1635 : : STRNULLCHK(cf->ses_arch_dir),
1636 : : STRNULLCHK(cf->ses_cookie_name),
1637 : : STRNULLCHK(cf->ipport),
1638 : : cf->user_local,
1639 : : cf->idp_ena,
1640 : : cf->imps_ena,
1641 : : cf->as_ena,
1642 : : cf->pdp_ena,
1643 : : ZXID_MAX_BUF,
1644 : :
1645 : : cf->log_err,
1646 : : cf->log_act,
1647 : : cf->log_issue_a7n,
1648 : : cf->log_issue_msg,
1649 : : cf->log_rely_a7n,
1650 : : cf->log_rely_msg,
1651 : : cf->log_err_in_act,
1652 : : cf->log_act_in_err,
1653 : : cf->log_sigfail_is_err,
1654 : : cf->log_level,
1655 : : cf->loguser,
1656 : :
1657 : : cf->sig_fatal,
1658 : : cf->nosig_fatal,
1659 : : cf->msg_sig_ok,
1660 : : cf->timeout_fatal,
1661 : : cf->audience_fatal,
1662 : : cf->dup_a7n_fatal,
1663 : : cf->dup_msg_fatal,
1664 : : cf->relto_fatal,
1665 : : cf->wsp_nosig_fatal,
1666 : : cf->notimestamp_fatal,
1667 : : cf->redir_to_content,
1668 : : cf->remote_user_ena,
1669 : : cf->max_soap_retry,
1670 : :
1671 : : cf->before_slop,
1672 : : cf->after_slop,
1673 : : cf->timeskew,
1674 : : cf->a7nttl,
1675 : :
1676 : : STRNULLCHK(cf->anon_ok),
1677 : : STRNULLCHK(cf->issue_authnctx_pw),
1678 : : STRNULLCHK(cf->idp_pref_acs_binding),
1679 : : STRNULLCHK(cf->mandatory_attr),
1680 : : STRNULLCHK(cf->pdp_url),
1681 : : STRNULLCHK(cf->pdp_call_url),
1682 : : STRNULLCHK(cf->xasp_vers),
1683 : : STRNULLCHK(cf->mod_saml_attr_prefix),
1684 : : cf->bare_url_entityid,
1685 : : cf->show_tech,
1686 : :
1687 : : cf->idp_list_meth,
1688 : : STRNULLCHK(cf->idp_sel_page),
1689 : : STRNULLCHK(cf->idp_sel_templ_file),
1690 : : STRNULLCHK(cf->idp_sel_templ),
1691 : : #if 0
1692 : : STRNULLCHK(cf->idp_sel_start),
1693 : : STRNULLCHK(cf->idp_sel_new_idp),
1694 : : STRNULLCHK(cf->idp_sel_our_eid),
1695 : : STRNULLCHK(cf->idp_sel_tech_user),
1696 : : STRNULLCHK(cf->idp_sel_tech_site),
1697 : : STRNULLCHK(cf->idp_sel_footer),
1698 : : STRNULLCHK(cf->idp_sel_end),
1699 : : #endif
1700 : : STRNULLCHK(cf->an_page),
1701 : : STRNULLCHK(cf->an_templ_file),
1702 : : STRNULLCHK(cf->an_templ),
1703 : :
1704 : : STRNULLCHK(cf->post_templ_file),
1705 : : STRNULLCHK(cf->post_templ),
1706 : :
1707 : : STRNULLCHK(cf->err_page),
1708 : : STRNULLCHK(cf->err_templ_file),
1709 : : STRNULLCHK(cf->err_templ),
1710 : :
1711 : : STRNULLCHK(cf->new_user_page),
1712 : : STRNULLCHK(cf->recover_passwd),
1713 : : STRNULLCHK(cf->atsel_page),
1714 : :
1715 : : STRNULLCHK(cf->mgmt_start),
1716 : : STRNULLCHK(cf->mgmt_logout),
1717 : : STRNULLCHK(cf->mgmt_defed),
1718 : : STRNULLCHK(cf->mgmt_footer),
1719 : : STRNULLCHK(cf->mgmt_end),
1720 : :
1721 : : STRNULLCHK(cf->dbg),
1722 : :
1723 : : required_authnctx->s,
1724 : : need->s,
1725 : : want->s,
1726 : : attrsrc->s,
1727 : : inmap->s,
1728 : : outmap->s,
1729 : : pepmap->s,
1730 : : pepmap_rqout->s,
1731 : : pepmap_rqin->s,
1732 : : pepmap_rsout->s,
1733 : : pepmap_rsin->s,
1734 : : localpdp_role_permit->s,
1735 : : localpdp_role_deny->s,
1736 : : localpdp_idpnid_permit->s,
1737 : : localpdp_idpnid_deny->s,
1738 : : STRNULLCHK(cf->wsc_localpdp_obl_pledge),
1739 : : STRNULLCHK(cf->wsp_localpdp_obl_req),
1740 : : STRNULLCHK(cf->wsp_localpdp_obl_emit),
1741 : : STRNULLCHK(cf->wsc_localpdp_obl_accept)
1742 : : );
1743 : : }
1744 : :
1745 : : /* EOF -- zxidconf.c */
|
