LCOV - code coverage report
Current view: top level - zxid - zxidconf.c (source / functions) Hit Total Coverage
Test: ZXID Code Coverage Lines: 524 766 68.4 %
Date: 2010-12-19 Functions: 28 29 96.6 %
Branches: 396 916 43.2 %

           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 */

Generated by: LCOV version 1.9