LCOV - code coverage report
Current view: top level - zxid - zxlib.c (source / functions) Hit Total Coverage
Test: ZXID Code Coverage Lines: 192 233 82.4 %
Date: 2010-12-19 Functions: 36 37 97.3 %
Branches: 46 88 52.3 %

           Branch data     Line data    Source code
       1                 :            : /* zxlib.c  -  Utility functions for generated (and other) code
       2                 :            :  * Copyright (c) 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: zxlib.c,v 1.41 2009-11-24 23:53:40 sampo Exp $
      10                 :            :  *
      11                 :            :  * 28.5.2006, created --Sampo
      12                 :            :  * 8.8.2006,  moved lookup functions to generated code --Sampo
      13                 :            :  * 12.8.2006, added special scanning of xmlns to avoid backtracking elem recognition --Sampo
      14                 :            :  * 26.8.2006, significant Common Subexpression Elimination (CSE) --Sampo
      15                 :            :  * 30.9.2007, more CSE --Sampo
      16                 :            :  * 7.10.2008, added documentation --Sampo
      17                 :            :  * 26.5.2010, added XML parse error reporting --Sampo
      18                 :            :  * 27.10.2010, re-engineered namespace handling --Sampo
      19                 :            :  */
      20                 :            : 
      21                 :            : #include "platform.h"  /* needed on Win32 for snprintf(), va_copy() et al. */
      22                 :            : 
      23                 :            : //#include <pthread.h>
      24                 :            : //#ifndef MACOSX
      25                 :            : //#include <malloc.h>
      26                 :            : //#endif
      27                 :            : #include <memory.h>
      28                 :            : #include <string.h>
      29                 :            : #include <stdarg.h>
      30                 :            : #include <stdio.h>
      31                 :            : #include <stdlib.h>
      32                 :            : 
      33                 :            : #include "errmac.h"
      34                 :            : #include "zx.h"
      35                 :            : #include "c/zx-ns.h"
      36                 :            : #include "c/zx-data.h"
      37                 :            : 
      38                 :            : /*() ZX implementation of memmem(3) for platforms that do not have this. */
      39                 :            : 
      40                 :            : /* Called by:  covimp_test, zxid_map_sec_mech x3 */
      41                 :            : char* zx_memmem(const char* haystack, int haystack_len, const char* needle, int needle_len)
      42                 :          1 : {
      43                 :          1 :   const char* lim = haystack + haystack_len - needle_len;
      44         [ +  - ]:          3 :   for (; haystack < lim; ++haystack)
      45         [ +  + ]:          3 :     if (!memcmp(haystack, needle, needle_len))
      46                 :          1 :       return (char*)haystack; /* discards const qualifier, but is right if haystack was modifiable, as often is the case. */
      47                 :          0 :   return 0;
      48                 :            : }
      49                 :            : 
      50                 :            : /*() ZX memory allocator that does not zero the buffer. Allocation is
      51                 :            :  * potentially done relative to ZX context <<italic: c>>, though
      52                 :            :  * actual (2008) implementation simply uses malloc(3).
      53                 :            :  *
      54                 :            :  * Rather than reference this function directly, you should
      55                 :            :  * use the ZX_ALLOC() macro as much as possible.
      56                 :            :  *
      57                 :            :  * Some implementations may take c->mx mutex lock. However, they will
      58                 :            :  * do so such that no deadlock will result even if already taken. */
      59                 :            : 
      60                 :            : /* Called by:  zx_zalloc */
      61                 :            : void* zx_alloc(struct zx_ctx* c, int size)
      62                 :    2930461 : {
      63                 :            :   char* p;
      64                 :    2930461 :   p = malloc(size);
      65                 :            :   DD("malloc %p size=%d", p, size);
      66         [ -  + ]:    2930461 :   if (!p) {
      67                 :          0 :     ERR("Out-of-memory(%d)", size);
      68         [ #  # ]:          0 :     if (size < 0)
      69         [ #  # ]:          0 :       DIE_ACTION(1);
      70                 :          0 :     exit(1);
      71                 :            :   }
      72                 :    2930461 :   return p;
      73                 :            : }
      74                 :            : 
      75                 :            : /*() ZX memory allocator that zeroes the buffer. Allocation is
      76                 :            :  * potentially done relative to ZX context <<italic: c>>, though
      77                 :            :  * actual (2008) implementation simply uses malloc(3).
      78                 :            :  *
      79                 :            :  * Rather than reference this function directly, you should
      80                 :            :  * use the ZX_ALLOC() macro as much as possible. */
      81                 :            : 
      82                 :            : /* Called by:  zxid_parse_conf_raw */
      83                 :            : void* zx_zalloc(struct zx_ctx* c, int size)
      84                 :    1985825 : {
      85                 :    1985825 :   char* p = zx_alloc(c, size);
      86                 :    1985825 :   ZERO(p, size);
      87                 :    1985825 :   return p;
      88                 :            : }
      89                 :            : 
      90                 :            : 
      91                 :            : /*() ZX memory free'er. Freeing is
      92                 :            :  * potentially done relative to ZX context <<italic: c>>, though
      93                 :            :  * actual (2008) implementation simply uses free(3).
      94                 :            :  *
      95                 :            :  * Rather than reference this function directly, you should
      96                 :            :  * use the ZX_FREE() macro as much as possible. */
      97                 :            : 
      98                 :            : /* Called by: */
      99                 :            : void* zx_free(struct zx_ctx* c, void* p)
     100                 :    1423682 : {
     101         [ +  + ]:    1423682 :   if (p)
     102                 :    1423530 :     free(p);
     103                 :    1423682 :   return 0;
     104                 :            : }
     105                 :            : 
     106                 :            : /*() Convert zx_str to C string. The ZX context will provide the memory. */
     107                 :            : 
     108                 :            : /* Called by:  zxid_add_a7n_at_to_pool x2, zxid_get_meta_ss, zxid_get_ses_sso_a7n, zxid_get_tas3_fault_actor, zxid_get_tas3_fault_comment, zxid_get_tas3_fault_ref, zxid_get_tas3_fault_sc1, zxid_get_tas3_fault_sc2, zxid_get_tas3_status_comment, zxid_get_tas3_status_ctlpt, zxid_get_tas3_status_ref, zxid_get_tas3_status_sc1, zxid_get_tas3_status_sc2, zxid_idp_sso, zxid_map_val_ss, zxid_mk_at_cert x3, zxid_mk_ent x2, zxid_saml2_post_enc, zxid_simple_idp_show_an, zxid_sp_sso_finalize x3, zxid_wsc_call, zxid_wsc_valid_re_env x2, zxid_wsf_validate_a7n x3, zxid_wsp_validate_env x2 */
     109                 :            : char* zx_str_to_c(struct zx_ctx* c, struct zx_str* ss)
     110                 :       3997 : {
     111                 :       3997 :   char* p = ZX_ALLOC(c, ss->len+1);
     112                 :       3997 :   memcpy(p, ss->s, ss->len);
     113                 :       3997 :   p[ss->len] = 0;
     114                 :       3997 :   return p;
     115                 :            : }
     116                 :            : 
     117                 :            : /*() zx_str_conv() helps SWIG typemaps to achieve natural conversion
     118                 :            :  * to native length + data representations of scripting languages.
     119                 :            :  * Should not need to use directly. */
     120                 :            : 
     121                 :            : /* Called by:  covimp_test */
     122                 :            : void zx_str_conv(struct zx_str* ss, int* out_len, char** out_s)  /* SWIG typemap friendly */
     123                 :          1 : {
     124                 :          1 :   *out_s = 0;
     125                 :          1 :   *out_len = 0;
     126         [ -  + ]:          1 :   if (!ss)
     127                 :          0 :     return;
     128                 :          1 :   *out_s = ss->s;
     129                 :          1 :   *out_len = ss->len;
     130                 :            : }
     131                 :            : 
     132                 :            : /*() Free both the zx_str node and the underlying string data */
     133                 :            : 
     134                 :            : /* Called by:  main, zx_free_elem, zxenc_privkey_dec, zxenc_pubkey_enc, zxenc_symkey_enc, zxid_addmd x3, zxid_anoint_a7n x5, zxid_anoint_sso_resp x4, zxid_az_soap x3, zxid_cache_epr, zxid_decode_redir_or_post, zxid_fed_mgmt_cf x3, zxid_idp_dispatch x2, zxid_idp_list_cf_cgi x3, zxid_idp_soap, zxid_idp_soap_dispatch x2, zxid_idp_sso x4, zxid_lecp_check, zxid_mgmt x3, zxid_mk_art_deref, zxid_mk_enc_a7n, zxid_mk_enc_id, zxid_mk_mni, zxid_psobj_dec, zxid_psobj_enc, zxid_reg_svc x3, zxid_saml2_post_enc x2, zxid_saml2_redir, zxid_saml2_redir_enc x2, zxid_saml2_redir_url, zxid_saml2_resp_redir, zxid_send_sp_meta, zxid_simple_idp_show_an, zxid_simple_no_ses_cf x3, zxid_simple_ses_active_cf, zxid_simple_show_page x3, zxid_slo_resp_redir, zxid_snarf_eprs_from_ses, zxid_soap_call_raw, zxid_soap_cgi_resp_body x2, zxid_sp_dispatch x2, zxid_sp_mni_soap, zxid_sp_slo_soap, zxid_sp_soap, zxid_sp_soap_dispatch x7, zxid_sp_sso_finalize, zxid_ssos_anreq, zxid_start_sso_location, zxid_user_sha1_name, zxid_write_ent_to_cache, zxid_wsf_validate_a7n, zxsig_sign */
     135                 :            : void zx_str_free(struct zx_ctx* c, struct zx_str* ss)
     136                 :       7764 : {
     137         [ +  - ]:       7764 :   if (ss->s)
     138                 :       7764 :     ZX_FREE(c, ss->s);
     139                 :       7764 :   ZX_FREE(c, ss);
     140                 :       7764 : }
     141                 :            : 
     142                 :            : /*() Construct zx_str from length and raw string data, which will be referenced, not copied. */
     143                 :            : 
     144                 :            : /* Called by:  zx_EASY_ENC_elem, zx_ref_len_elem, zx_ref_str, zx_strf, zxid_http_post_raw, zxid_map_val_ss, zxid_saml2_redir_enc x2, zxlog_path */
     145                 :            : struct zx_str* zx_ref_len_str(struct zx_ctx* c, int len, const char* s)
     146                 :      16577 : {
     147                 :      16577 :   struct zx_str* ss = ZX_ZALLOC(c, struct zx_str);
     148                 :      16577 :   ss->s = (char*)s;  /* ref points to underlying data */
     149                 :      16577 :   ss->len = len;
     150                 :      16577 :   return ss;
     151                 :            : }
     152                 :            : 
     153                 :            : /*() Construct zx_str from C string, which will be referenced, not copied. */
     154                 :            : 
     155                 :            : /* Called by:  a7n_test x3, covimp_test, test_ibm_cert_problem_enc_dec, x509_test x2, zxid_az_soap x8, zxid_ins_xacml_az_cd1_stmt, zxid_ins_xacml_az_stmt, zxid_map_val_ss, zxid_mk_di_req_svc, zxid_org_desc x5, zxid_simple_ses_active_cf x2, zxid_wsf_decor */
     156                 :            : struct zx_str* zx_ref_str(struct zx_ctx* c, const char* s)
     157                 :        384 : {
     158         [ -  + ]:        384 :   if (!s)
     159                 :          0 :     return 0;
     160                 :        384 :   return zx_ref_len_str(c, strlen(s), s);
     161                 :            : }
     162                 :            : 
     163                 :            : /*() Newly allocated string (node and data) of specified length, but uninitialized */
     164                 :            : 
     165                 :            : /* Called by:  zx_dup_len_str, zx_raw_cipher, zx_rsa_priv_dec, zx_rsa_priv_enc, zx_rsa_pub_dec, zx_rsa_pub_enc, zxenc_pubkey_enc, zxenc_symkey_enc, zxid_map_val_ss x5, zxid_pool_to_json, zxid_pool_to_ldif, zxid_pool_to_qs, zxid_psobj_dec, zxid_psobj_enc, zxid_template_page_cf, zxsig_sign x2 */
     166                 :            : struct zx_str* zx_new_len_str(struct zx_ctx* c, int len)
     167                 :      30082 : {
     168                 :      30082 :   struct zx_str* ss = ZX_ZALLOC(c, struct zx_str);
     169                 :      30082 :   ss->s = ZX_ALLOC(c, len+1);
     170                 :      30082 :   ss->s[len] = 0;
     171                 :      30082 :   ss->len = len;
     172                 :      30082 :   return ss;
     173                 :            : }
     174                 :            : 
     175                 :            : /*() Construct zx_str by duplication of raw string data of given length. */
     176                 :            : 
     177                 :            : /* Called by:  zx_dup_len_elem, zx_dup_str, zxid_add_ldif_at2ses, zxid_parse_invite, zxid_parse_psobj */
     178                 :            : struct zx_str* zx_dup_len_str(struct zx_ctx* c, int len, const char* s)
     179                 :      20843 : {
     180                 :      20843 :   struct zx_str* ss = zx_new_len_str(c, len);
     181                 :      20843 :   memcpy(ss->s, s, len);
     182                 :      20843 :   return ss;
     183                 :            : }
     184                 :            : 
     185                 :            : /*() Construct zx_str by duplication of C string. */
     186                 :            : 
     187                 :            : /* Called by:  zxid_add_attr_to_ses, zxid_add_qs_to_ses, zxid_anoint_a7n x2, zxid_anoint_sso_resp x3, zxid_attach_sol1_usage_directive, zxid_az_soap x4, zxid_call_epr, zxid_fed_mgmt_cf, zxid_get_at x2, zxid_idp_dispatch x8, zxid_idp_list_cf_cgi x2, zxid_idp_select_zxstr_cf_cgi, zxid_idp_sso x13, zxid_map_identity_token, zxid_map_val, zxid_map_val_ss x3, zxid_mk_an_stmt, zxid_mk_sa_attribute, zxid_mk_subj, zxid_mk_usr_a7n_to_sp, zxid_new_epr, zxid_parse_invite x6, zxid_parse_mni, zxid_parse_psobj x7, zxid_pepmap_extract x7, zxid_saml2_redir, zxid_saml2_resp_redir, zxid_ses_to_pool x9, zxid_show_conf x3, zxid_show_cstr_list, zxid_show_map, zxid_show_need x2, zxid_simple_ab_pep x3, zxid_slo_resp_redir, zxid_sp_dispatch x15, zxid_sp_mni_redir x3, zxid_sp_slo_redir x3, zxid_start_sso_location, zxid_wsc_prep, zxid_wsc_prepare_call, zxid_wsc_valid_re_env, zxid_wsp_decorate, zxid_wsp_validate_env */
     188                 :            : struct zx_str* zx_dup_str(struct zx_ctx* c, const char* s)
     189                 :      20359 : {
     190                 :      20359 :   return zx_dup_len_str(c, strlen(s), s);
     191                 :            : }
     192                 :            : 
     193                 :            : /*() ZX verion of strdup(). */
     194                 :            : 
     195                 :            : /* Called by:  chkuid x2, zxid_az_base_cf_ses, zxid_az_cf_ses, zxid_fed_mgmt_cf, zxid_get_ses, zxid_mk_usr_a7n_to_sp, zxid_parse_invite, zxid_parse_psobj, zxid_simple_cf_ses x2, zxid_simple_no_ses_cf, zxid_simple_redir_page, zxid_simple_ses_active_cf, zxid_simple_show_page x2, zxid_url_set */
     196                 :            : char* zx_dup_cstr(struct zx_ctx* c, const char* str)
     197                 :         68 : {
     198                 :         68 :   int len = strlen(str);
     199                 :         68 :   char* s = ZX_ALLOC(c, len+1);
     200                 :         68 :   memcpy(s, str, len+1);
     201                 :         68 :   return s;
     202                 :            : }
     203                 :            : 
     204                 :            : struct zx_str* zx_dup_zx_str(struct zx_ctx* c, struct zx_str* ss)
     205                 :         72 : {
     206                 :         72 :   return zx_dup_len_str(c, ss->len, ss->s);
     207                 :            : }
     208                 :            : 
     209                 :            : /* ------------------ ATTR ------------------ */
     210                 :            : 
     211                 :            : /*() Construct zx_attr_s from length and raw string data, which will be referenced, not copied. */
     212                 :            : 
     213                 :            : /* Called by:  zx_attrf, zx_ref_attr, zxenc_symkey_enc, zxid_check_fed, zxid_idp_sso, zxid_mk_an_stmt, zxid_mk_logout_resp, zxid_mk_mni_resp, zxid_mk_xacml_simple_at x3, zxid_mni_do_ss, zxid_ps_addent_invite, zxid_slo_resp_redir, zxid_sp_mni_redir, zxid_sp_slo_redir, zxid_sso_issue_a7n x2 */
     214                 :            : struct zx_attr_s* zx_ref_len_attr(struct zx_ctx* c, struct zx_elem_s* father, int tok, int len, const char* s)
     215                 :      36855 : {
     216                 :      36855 :   struct zx_attr_s* ss = ZX_ZALLOC(c, struct zx_attr_s);
     217                 :      36855 :   ss->g.s = (char*)s;  /* ref points to underlying data */
     218                 :      36855 :   ss->g.len = len;
     219                 :      36855 :   ss->g.tok = tok;
     220         [ +  + ]:      36855 :   if (father) {
     221                 :      35561 :     ss->g.n = &father->attr->g;
     222                 :      35561 :     father->attr = ss;
     223                 :            :   }
     224                 :      36855 :   return ss;
     225                 :            : }
     226                 :            : 
     227                 :            : /*() Construct zx_attr_s from C string, which will be referenced, not copied. */
     228                 :            : 
     229                 :            : /* Called by:  test_ibm_cert_problem_enc_dec x2, x509_test x3, zxenc_pubkey_enc, zxenc_symkey_enc x3, zxid_ac_desc x2, zxid_ar_desc, zxid_attach_sol1_usage_directive x5, zxid_az_soap x2, zxid_check_fed, zxid_contact_desc, zxid_idp_sso, zxid_idp_sso_desc x2, zxid_issuer, zxid_key_desc, zxid_map_identity_token x2, zxid_mk_Status x2, zxid_mk_art_deref, zxid_mk_authn_req x10, zxid_mk_az, zxid_mk_az_cd1, zxid_mk_dap_query, zxid_mk_dap_query_item x8, zxid_mk_dap_resquery x6, zxid_mk_dap_select x2, zxid_mk_dap_subscription x7, zxid_mk_dap_test_item x2, zxid_mk_dap_testop x2, zxid_mk_di_req_svc, zxid_mk_ecp_Request_hdr x2, zxid_mk_idp_list x2, zxid_mk_logout, zxid_mk_logout_resp, zxid_mk_mni, zxid_mk_mni_resp, zxid_mk_paos_Request_hdr x3, zxid_mk_sa_attribute_ss, zxid_mk_tas3_status, zxid_mk_transient_nid, zxid_mk_xacml_resp, zxid_mni_desc, zxid_nidmap_identity_token x2, zxid_nimap_desc, zxid_org_desc x3, zxid_ps_addent_invite x2, zxid_slo_desc, zxid_sp_sso_desc x3, zxid_sso_desc, zxid_sso_issue_a7n, zxid_wsc_prep x8, zxid_wsc_prep_secmech, zxid_wsf_decor x24, zxsig_sign x5 */
     230                 :            : struct zx_attr_s* zx_ref_attr(struct zx_ctx* c, struct zx_elem_s* father, int tok, const char* s)
     231                 :      17139 : {
     232         [ +  + ]:      17139 :   if (!s)
     233                 :          5 :     return 0;
     234                 :      17134 :   return zx_ref_len_attr(c, father, tok, strlen(s), s);
     235                 :            : }
     236                 :            : 
     237                 :            : /*() Newly allocated attribute (node and data) of specified length, but uninitialized */
     238                 :            : 
     239                 :            : /* Called by:  zx_dup_len_attr */
     240                 :            : struct zx_attr_s* zx_new_len_attr(struct zx_ctx* c, struct zx_elem_s* father, int tok, int len)
     241                 :       8774 : {
     242                 :       8774 :   struct zx_attr_s* ss = ZX_ZALLOC(c, struct zx_attr_s);
     243                 :       8774 :   ss->g.s = ZX_ALLOC(c, len+1);
     244                 :       8774 :   ss->g.s[len] = 0;
     245                 :       8774 :   ss->g.len = len;
     246                 :       8774 :   ss->g.tok = tok;
     247         [ +  - ]:       8774 :   if (father) {
     248                 :       8774 :     ss->g.n = &father->attr->g;
     249                 :       8774 :     father->attr = ss;
     250                 :            :   }
     251                 :       8774 :   return ss;
     252                 :            : }
     253                 :            : 
     254                 :            : /*() Construct zx_str by duplication of raw string data of given length. */
     255                 :            : 
     256                 :            : /* Called by:  zx_dup_attr, zxid_imreq */
     257                 :            : struct zx_attr_s* zx_dup_len_attr(struct zx_ctx* c, struct zx_elem_s* father, int tok, int len, const char* s)
     258                 :       8774 : {
     259                 :       8774 :   struct zx_attr_s* ss = zx_new_len_attr(c, father, tok, len);
     260                 :       8774 :   memcpy(ss->g.s, s, len);
     261                 :       8774 :   return ss;
     262                 :            : }
     263                 :            : 
     264                 :            : /*() Construct zx_str by duplication of C string. */
     265                 :            : 
     266                 :            : /* Called by:  zxenc_pubkey_enc, zxid_as_call_ses, zxid_attach_sol1_usage_directive, zxid_idp_sso, zxid_map_identity_token x3, zxid_mk_a7n, zxid_mk_authn_req, zxid_mk_lu_Status x3, zxid_mk_sa_attribute_ss, zxid_mk_saml_resp, zxid_mk_tas3_status x4, zxid_nidmap_identity_token, zxid_parse_mni x3 */
     267                 :            : struct zx_attr_s* zx_dup_attr(struct zx_ctx* c, struct zx_elem_s* father, int tok, const char* s)
     268                 :       8774 : {
     269                 :       8774 :   return zx_dup_len_attr(c, father, tok, strlen(s), s);
     270                 :            : }
     271                 :            : 
     272                 :            : /*() vasprintf(3) implementation that will grab its memory from ZX memory allocator. */
     273                 :            : 
     274                 :            : /* Called by:  zx_alloc_sprintf, zx_attrf, zx_strf, zxid_callf, zxid_callf_epr, zxid_wsc_prepare_callf, zxid_wsp_decoratef */
     275                 :            : char* zx_alloc_vasprintf(struct zx_ctx* c, int* retlen, const char* f, va_list ap) /* data is new memory */
     276                 :      14927 : {
     277                 :            :   va_list ap2;
     278                 :            :   int len;
     279                 :            :   char* s;
     280                 :            :   char buf[2]; 
     281                 :      14927 :   va_copy(ap2, ap);
     282                 :      14927 :   len = vsnprintf(buf, 1, f, ap2);
     283                 :      14927 :   va_end(ap2);
     284         [ -  + ]:      14927 :   if (len < 0) {
     285                 :          0 :     perror("vsnprintf");
     286   [ #  #  #  # ]:          0 :     D("Broken vsnprintf? Impossible to compute length of string. Be sure to `export LANG=C' if you get errors about multibyte characters. Length returned: %d", len);
     287         [ #  # ]:          0 :     if (retlen)
     288                 :          0 :       *retlen = 0;
     289                 :          0 :     s = ZX_ALLOC(c, 1);
     290                 :          0 :     s[0] = 0;
     291                 :          0 :     return s;
     292                 :            :   }
     293                 :      14927 :   s = ZX_ALLOC(c, len+1);
     294                 :      14927 :   vsnprintf(s, len+1, f, ap);
     295                 :      14927 :   s[len] = 0; /* must terminate manually as on win32 nul termination is not guaranteed */
     296         [ +  + ]:      14927 :   if (retlen)
     297                 :      14844 :     *retlen = len;
     298                 :      14927 :   return s;
     299                 :            : }
     300                 :            : 
     301                 :            : /*() sprintf(3) implementation that will grab its memory from ZX memory allocator. */
     302                 :            : 
     303                 :            : /* Called by:  main x2, zxid_add_env_if_needed, zxid_pw_authn x2, zxid_simple_no_ses_cf x2 */
     304                 :            : char* zx_alloc_sprintf(struct zx_ctx* c, int* retlen, const char* f, ...)  /* data is new memory */
     305                 :         82 : {
     306                 :            :   char* ret;
     307                 :            :   va_list ap;
     308                 :         82 :   va_start(ap, f);
     309                 :         82 :   ret = zx_alloc_vasprintf(c, retlen, f, ap);
     310                 :         82 :   va_end(ap);
     311                 :         82 :   return ret;
     312                 :            : }
     313                 :            : 
     314                 :            : /*(i) Construct zx_str given sprintf(3) format and grabbing memory from ZX memory allocator. */
     315                 :            : 
     316                 :            : /* Called by:  chkuid, zx_prefix_seen_whine, zxenc_pubkey_enc, zxid_date_time x2, zxid_decode_redir_or_post x5, zxid_fed_mgmt_cf x4, zxid_idp_list_cf_cgi x6, zxid_idp_select_zxstr_cf_cgi x3, zxid_idp_sso x3, zxid_lecp_check, zxid_mk_di_req_svc, zxid_mk_id, zxid_my_cdc_url, zxid_my_ent_id x3, zxid_ps_accept_invite, zxid_ps_addent_invite, zxid_ps_finalize_invite, zxid_saml2_post_enc x3, zxid_saml2_redir, zxid_saml2_redir_url, zxid_saml2_resp_redir, zxid_saml_ok, zxid_ses_to_pool x6, zxid_show_conf x5, zxid_show_cstr_list, zxid_show_map, zxid_show_need x2, zxid_simple_idp_an_ok_do_rest, zxid_simple_idp_new_user, zxid_simple_idp_recover_password, zxid_simple_idp_show_an x2, zxid_simple_no_ses_cf, zxid_simple_redir_page, zxid_simple_show_err, zxid_simple_show_page, zxid_sp_carml, zxid_start_sso_location, zxid_user_sha1_name, zxid_wsc_prep, zxid_wsf_decor */
     317                 :            : struct zx_str* zx_strf(struct zx_ctx* c, const char* f, ...)  /* data is new memory */
     318                 :       6094 : {
     319                 :            :   va_list ap;
     320                 :            :   int len;
     321                 :            :   char* s;
     322                 :       6094 :   va_start(ap, f);
     323                 :       6094 :   s = zx_alloc_vasprintf(c, &len, f, ap);
     324                 :       6094 :   va_end(ap);
     325                 :       6094 :   return zx_ref_len_str(c, len, s);
     326                 :            : }
     327                 :            : 
     328                 :            : /* Called by:  zxenc_pubkey_enc x2, zxenc_symkey_enc, zxid_ac_desc, zxid_ar_desc x2, zxid_date_time_attr x2, zxid_idp_sso_desc, zxid_mk_dap_query_item x2, zxid_mk_dap_select x4, zxid_mk_dap_testop x4, zxid_mk_id_attr, zxid_mk_paos_Request_hdr, zxid_mni_desc x2, zxid_my_ent_id_attr x3, zxid_nimap_desc x2, zxid_slo_desc x2, zxid_sp_sso_desc, zxid_sso_desc x2, zxsig_sign */
     329                 :            : struct zx_attr_s* zx_attrf(struct zx_ctx* c, struct zx_elem_s* father, int tok, const char* f, ...)  /* data is new memory */
     330                 :       8750 : {
     331                 :            :   va_list ap;
     332                 :            :   int len;
     333                 :            :   char* s;
     334                 :       8750 :   va_start(ap, f);
     335                 :       8750 :   s = zx_alloc_vasprintf(c, &len, f, ap);
     336                 :       8750 :   va_end(ap);
     337                 :       8750 :   return zx_ref_len_attr(c, father, tok, len, s);
     338                 :            : }
     339                 :            : 
     340                 :            : /*() Check if string ends in suffix */
     341                 :            : 
     342                 :            : /* Called by: */
     343                 :            : int zx_str_ends_in(struct zx_str* ss, int len, const char* suffix)
     344                 :        827 : {
     345                 :        827 :   return !memcmp(ss->s + ss->len - len, suffix, len);
     346                 :            : }
     347                 :            : 
     348                 :            : /*() Add non-XML content to the kids list. These essentially appear as DATA items. */
     349                 :            : 
     350                 :            : /* Called by:  test_ibm_cert_problem_enc_dec, x509_test, zx_new_str_elem, zxid_attach_sol1_usage_directive, zxid_az_soap x4, zxid_check_fed, zxid_issuer, zxid_mk_addr, zxid_mk_sa_attribute_ss, zxid_mk_subj, zxid_mk_transient_nid, zxid_new_epr, zxid_org_desc x5, zxid_parse_mni, zxid_ps_addent_invite x2, zxid_wsc_prep, zxid_wsc_prep_secmech x3, zxid_wsf_decor x4, zxsig_sign */
     351                 :            : void zx_add_content(struct zx_ctx* c, struct zx_elem_s* x, struct zx_str* cont)
     352                 :      17522 : {
     353   [ +  -  -  + ]:      17522 :   if (!cont || !x) {
     354                 :          0 :     ERR("Call to zx_add_content(c,%p,%p) with null values", x, cont);
     355                 :          0 :     return;
     356                 :            :   }
     357                 :      17522 :   cont->tok = ZX_TOK_DATA;
     358                 :      17522 :   cont->n = &x->kids->g;
     359                 :      17522 :   x->kids = (struct zx_elem_s*)cont;
     360                 :            : }
     361                 :            : 
     362                 :            : /*() Add kid to head of kids list. Usually you should add in schema order
     363                 :            :  * and in the end call zx_reverse_elem_lists() to make the list right order. */
     364                 :            : 
     365                 :            : /* Called by:  zx_add_kid_after_sa_Issuer, zxid_add_fed_tok2epr, zxid_az_soap, zxid_di_query, zxid_idp_as_do, zxid_imreq, zxid_mk_a7n x3, zxid_mk_logout_resp, zxid_mk_mni_resp, zxid_mk_saml_resp, zxid_soap_call_hdr_body x2, zxid_soap_cgi_resp_body, zxid_sp_soap_dispatch, zxid_wsf_sign */
     366                 :            : struct zx_elem_s* zx_add_kid(struct zx_elem_s* father, struct zx_elem_s* kid)
     367                 :       4795 : {
     368         [ +  - ]:       4795 :   if (father) {
     369                 :       4795 :     kid->g.n = &father->kids->g;
     370                 :       4795 :     father->kids = kid;
     371                 :            :   }
     372                 :       4795 :   return kid;
     373                 :            : }
     374                 :            : 
     375                 :            : /*() Add kid before another elem. This assumes father is already in
     376                 :            :  * forward order, i.e. zx_reverse_elem_lists() was already called. */
     377                 :            : 
     378                 :            : /* Called by:  zxid_add_fed_tok2epr, zxid_choose_sectok x2, zxid_ins_xacml_az_cd1_stmt x2, zxid_ins_xacml_az_stmt x2, zxid_sso_issue_a7n, zxid_wsc_prep_secmech */
     379                 :            : struct zx_elem_s* zx_add_kid_before(struct zx_elem_s* father, int before, struct zx_elem_s* kid)
     380                 :        312 : {
     381         [ -  + ]:        312 :   if (!father->kids) {
     382                 :          0 :     father->kids = kid;
     383                 :          0 :     return kid;
     384                 :            :   }
     385         [ +  + ]:        312 :   if (father->kids->g.tok == before) {
     386                 :         38 :     kid->g.n = &father->kids->g;
     387                 :         38 :     father->kids = kid;
     388                 :         38 :     return kid;
     389                 :            :   }
     390                 :        274 :   for (father = father->kids;
     391   [ +  +  +  + ]:       1037 :        father->g.n && father->g.n->tok != before;
     392                 :        489 :        father = (struct zx_elem_s*)father->g.n) ;
     393                 :            : 
     394                 :        274 :   kid->g.n = father->g.n;
     395                 :        274 :   father->g.n = &kid->g;
     396                 :        274 :   return kid;
     397                 :            : }
     398                 :            : 
     399                 :            : /*() Add Signature right after sa:Issuer. This assumes father is
     400                 :            :  * already in forward order (i.e. zx_reverse_elem_lists() was already
     401                 :            :  * called. */
     402                 :            : 
     403                 :            : /* Called by:  zxid_anoint_a7n, zxid_anoint_sso_resp, zxid_az_soap x2, zxid_idp_soap_dispatch x2, zxid_idp_sso, zxid_mk_art_deref, zxid_sp_mni_soap, zxid_sp_slo_soap, zxid_sp_soap_dispatch x6, zxid_ssos_anreq */
     404                 :            : struct zx_elem_s* zx_add_kid_after_sa_Issuer(struct zx_elem_s* father, struct zx_elem_s* kid)
     405                 :       1005 : {
     406         [ +  + ]:       1005 :   if (father->kids->g.tok == zx_sa_Issuer_ELEM) {
     407                 :       1004 :     father = father->kids;
     408                 :       1004 :     kid->g.n = father->g.n;
     409                 :       1004 :     father->g.n = &kid->g;
     410                 :       1004 :     return kid;
     411                 :            :   }
     412                 :          1 :   ERR("No <sa:Issuer> found. Adding signature at list head. %d", father->kids->g.tok);
     413                 :          1 :   return zx_add_kid(father, kid);
     414                 :            : }
     415                 :            : 
     416                 :            : /*() Replace kid element. */
     417                 :            : 
     418                 :            : /* Called by:  zxid_wsp_decorate */
     419                 :            : struct zx_elem_s* zx_replace_kid(struct zx_elem_s* father, struct zx_elem_s* kid)
     420                 :          0 : {
     421         [ #  # ]:          0 :   if (!father->kids) {
     422                 :          0 :     father->kids = kid;
     423                 :          0 :     return kid;
     424                 :            :   }
     425         [ #  # ]:          0 :   if (father->kids->g.tok == kid->g.tok) {
     426                 :          0 :     kid->g.n = father->kids->g.n;
     427                 :          0 :     father->kids = kid;
     428                 :          0 :     return kid;
     429                 :            :   }
     430                 :          0 :   for (father = father->kids;
     431   [ #  #  #  # ]:          0 :        father->g.n && father->g.n->tok != kid->g.tok;
     432                 :          0 :        father = (struct zx_elem_s*)father->g.n) ;
     433                 :            : 
     434                 :          0 :   kid->g.n = father->g.n->n;
     435                 :          0 :   father->g.n = &kid->g;
     436                 :          0 :   return kid;
     437                 :            : }
     438                 :            : 
     439                 :            : /*() Construct new simple element from zx_str by referencing, not copying, it. */
     440                 :            : 
     441                 :            : /* Called by:  main, zx_dup_len_elem, zx_ref_len_elem, zxenc_pubkey_enc, zxenc_symkey_enc, zxid_mk_a7n, zxid_mk_logout, zxid_mk_mni x4, zxid_mk_xacml_simple_at, zxid_ps_addent_invite x2, zxsig_sign */
     442                 :            : struct zx_elem_s* zx_new_str_elem(struct zx_ctx* c, struct zx_elem_s* father, int tok, struct zx_str* ss)
     443                 :      10386 : {
     444                 :            :   struct zx_elem_s* el;
     445                 :      10386 :   el = ZX_ZALLOC(c, struct zx_elem_s);
     446                 :      10386 :   el->g.tok = tok;
     447         [ +  + ]:      10386 :   if (father) {
     448                 :      10385 :     el->g.n = &father->kids->g;
     449                 :      10385 :     father->kids = el;
     450                 :            :   }
     451                 :      10386 :   zx_add_content(c, el, ss);
     452                 :      10386 :   return el;
     453                 :            : }
     454                 :            : 
     455                 :            : /*() Helper function for the zx_NEW_*() macros */
     456                 :            : 
     457                 :            : /* Called by: */
     458                 :            : struct zx_elem_s* zx_new_elem(struct zx_ctx* c, struct zx_elem_s* father, int tok)
     459                 :      73640 : {
     460                 :            :   const struct zx_el_desc* ed;
     461                 :            :   struct zx_elem_s* el;
     462                 :      73640 :   ed = zx_el_desc_lookup(tok);
     463         [ +  - ]:      73640 :   if (ed) {
     464                 :      73640 :     el = ZX_ALLOC(c, ed->siz);
     465                 :      73640 :     ZERO(el, ed->siz);
     466                 :            :   } else {
     467         [ #  # ]:          0 :     INFO("Unknown element tok=%06x in tok=%06x", tok, father?father->g.tok:0);
     468                 :          0 :     el = ZX_ZALLOC(c, struct zx_elem_s);
     469                 :          0 :     tok = ZX_TOK_NOT_FOUND;
     470                 :            :   }
     471                 :      73640 :   el->g.tok = tok;
     472         [ +  + ]:      73640 :   if (father) {
     473                 :      40360 :     el->g.n = &father->kids->g;
     474                 :      40360 :     father->kids = el;
     475                 :            :   }
     476                 :      73640 :   return el;
     477                 :            : }
     478                 :            : 
     479                 :            : /*() Construct new simple element by referencing, not copying, raw string data of given length. */
     480                 :            : 
     481                 :            : /* Called by:  zx_ref_elem, zxid_as_call_ses, zxid_key_info */
     482                 :            : struct zx_elem_s* zx_ref_len_elem(struct zx_ctx* c, struct zx_elem_s* father, int tok, int len, const char* s)
     483                 :       1136 : {
     484                 :       1136 :   return zx_new_str_elem(c, father, tok, zx_ref_len_str(c, len, s));
     485                 :            : }
     486                 :            : 
     487                 :            : /*() Construct new simple element by referencing, not copying, C string. */
     488                 :            : 
     489                 :            : /* Called by:  main, zxid_contact_desc x6, zxid_idp_sso_desc x2, zxid_mk_Status, zxid_mk_art_deref, zxid_mk_authn_req, zxid_mk_dap_query_item x4, zxid_mk_dap_resquery x4, zxid_mk_dap_select x2, zxid_mk_dap_subscription x2, zxid_mk_dap_testop x2, zxid_mk_di_req_svc x6, zxid_mk_xacml_resp, zxid_sp_sso_desc x2 */
     490                 :            : struct zx_elem_s* zx_ref_elem(struct zx_ctx* c, struct zx_elem_s* father, int tok, const char* s)
     491                 :        144 : {
     492                 :        144 :   return zx_ref_len_elem(c, father, tok, strlen(s), s);
     493                 :            : }
     494                 :            : 
     495                 :            : /* Called by:  zx_dup_elem */
     496                 :            : struct zx_elem_s* zx_dup_len_elem(struct zx_ctx* c, struct zx_elem_s* father, int tok, int len, const char* s)
     497                 :        211 : {
     498                 :        211 :   return zx_new_str_elem(c, father, tok, zx_dup_len_str(c, len, s));
     499                 :            : }
     500                 :            : 
     501                 :            : /* Called by:  zxid_add_fed_tok2epr, zxid_mk_an_stmt, zxid_mk_fault x3, zxid_new_epr x3, zxid_set_epr_secmech x2 */
     502                 :            : struct zx_elem_s* zx_dup_elem(struct zx_ctx* c, struct zx_elem_s* father, int tok, const char* s)
     503                 :        211 : {
     504                 :        211 :   return zx_dup_len_elem(c, father, tok, strlen(s), s);
     505                 :            : }
     506                 :            : 
     507                 :            : /* ----------- F r e e ----------- */
     508                 :            : 
     509                 :            : /* Called by:  zx_free_elem */
     510                 :            : void zx_free_attr(struct zx_ctx* c, struct zx_attr_s* aa, int free_strs)
     511                 :     619136 : {
     512                 :            :   struct zx_attr_s* aan;
     513         [ +  + ]:    1027911 :   for (; aa; aa = aan) {      /* attributes */
     514                 :     408775 :     aan = (struct zx_attr_s*)aa->g.n;
     515   [ -  +  #  # ]:     408775 :     if (free_strs && aa->name)
     516                 :          0 :       ZX_FREE(c, aa->name);
     517   [ -  +  #  # ]:     408775 :     if (free_strs && aa->g.s)
     518                 :          0 :       ZX_FREE(c, aa->g.s);
     519                 :     408775 :     ZX_FREE(c, aa);
     520                 :            :   }
     521                 :     619136 : }
     522                 :            : 
     523                 :            : /*() Free element and its attributes, child elements, and content.
     524                 :            :  * Depth first traversal of data structure to free it and its subelements. Simple
     525                 :            :  * strings are handled as a special case according to the free_strs flag. This
     526                 :            :  * is useful if the strings point to underlying data from the wire that was
     527                 :            :  * allocated differently. */
     528                 :            : 
     529                 :            : /* Called by:  main, zx_free_elem, zxid_mk_mni, zxid_parse_meta, zxid_set_fault, zxid_set_tas3_status */
     530                 :            : void zx_free_elem(struct zx_ctx* c, struct zx_elem_s* x, int free_strs)
     531                 :     619136 : {
     532                 :            :   struct zx_elem_s* ae;
     533                 :            :   struct zx_elem_s* aen;
     534                 :            :   
     535   [ +  +  -  + ]:     619136 :   if (x->g.tok == ZX_TOK_NOT_FOUND && free_strs) {
     536                 :          0 :     ae = x;
     537         [ #  # ]:          0 :     if (ae->g.s)
     538                 :          0 :       ZX_FREE(c, ae->g.s);
     539                 :            :   }
     540                 :     619136 :   zx_free_attr(c, x->attr, free_strs);
     541                 :            : 
     542         [ +  + ]:    1369566 :   for (ae = x->kids; ae; ae = aen) {      /* elements */
     543                 :     750430 :     aen = (struct zx_elem_s*)ae->g.n;
     544         [ +  + ]:     750430 :     switch (ae->g.tok) {
     545                 :            :     case ZX_TOK_DATA:
     546         [ -  + ]:     149423 :       if (free_strs)
     547                 :          0 :         zx_str_free(c, &ae->g);
     548                 :            :       else
     549                 :     149423 :         ZX_FREE(c, ae);
     550                 :     149423 :       break;
     551                 :            :     default:
     552                 :     601007 :       zx_free_elem(c, ae, free_strs);
     553                 :            :       //zx_FREE_elem(c, ae, free_strs);
     554                 :            :     }
     555                 :            :   }
     556                 :     619136 :   ZX_FREE(c, x);
     557                 :     619136 : }
     558                 :            : 
     559                 :            : #ifdef ZX_ENA_AUX
     560                 :            : 
     561                 :            : /* *** clone code has not been updated since great namespace reform */
     562                 :            : 
     563                 :            : /* Called by:  zxenc_pubkey_enc, zxid_as_call_ses, zxid_attach_sol1_usage_directive, zxid_idp_sso, zxid_map_identity_token x3, zxid_mk_a7n, zxid_mk_authn_req, zxid_mk_lu_Status x3, zxid_mk_sa_attribute_ss, zxid_mk_saml_resp, zxid_mk_tas3_status x4, zxid_nidmap_identity_token, zxid_parse_mni x3 */
     564                 :            : void zx_dup_attr(struct zx_ctx* c, struct zx_str* attr)
     565                 :            : {
     566                 :            :   char* p;
     567                 :            :   for (; attr; attr = (struct zx_str*)attr->g.n)
     568                 :            :     if (attr->s) {
     569                 :            :       p = ZX_ALLOC(c, attr->len);
     570                 :            :       memcpy(p, attr->s, attr->len);
     571                 :            :       attr->s = p;
     572                 :            :     }
     573                 :            : }
     574                 :            : 
     575                 :            : /* Called by: */
     576                 :            : struct zx_str* zx_clone_attr(struct zx_ctx* c, struct zx_str* attr)
     577                 :            : {
     578                 :            :   struct zx_str* ret;
     579                 :            :   struct zx_str* attrnn;
     580                 :            :   struct zx_str* attrn;
     581                 :            :   char* p;
     582                 :            :   for (attrnn = 0; attr; attr = (struct zx_str*)attr->g.n) {
     583                 :            :     ZX_DUPALLOC(c, struct zx_str, attrn, attr);
     584                 :            :     if (!attrnn)
     585                 :            :       ret = attrn;
     586                 :            :     else
     587                 :            :       attrnn->g.n = &attrn->g;
     588                 :            :     attrnn = attrn;
     589                 :            :     if (attrn->s) {
     590                 :            :       p = ZX_ALLOC(c, attrn->len);
     591                 :            :       memcpy(p, attrn->s, attrn->len);
     592                 :            :       attrn->s = p;
     593                 :            :     }
     594                 :            :   }
     595                 :            :   return ret;
     596                 :            : }
     597                 :            : 
     598                 :            : /* Called by:  TXDEEP_CLONE_ELNAME */
     599                 :            : struct zx_elem_s* zx_clone_elem_common(struct zx_ctx* c, struct zx_elem_s* x, int size, int dup_strs)
     600                 :            : {
     601                 :            :   struct zx_attr_s* aa;
     602                 :            :   struct zx_elem_s* ae;
     603                 :            :   struct zx_attr_s* aan;
     604                 :            :   struct zx_elem_s* aen;
     605                 :            :   struct zx_attr_s* aann;
     606                 :            :   struct zx_elem_s* aenn;
     607                 :            :   char* p;
     608                 :            : 
     609                 :            :   if (x->g.tok == ZX_TOK_NOT_FOUND) {
     610                 :            :     ae = (struct zx_elem_s*)x;
     611                 :            :     ZX_DUPALLOC(c, struct zx_elem_s, aen, ae);
     612                 :            :     if (dup_strs) {
     613                 :            :       aen->name = ZX_ALLOC(c, ae->name_len);
     614                 :            :       memcpy(aen->name, ae->name, ae->name_len);
     615                 :            :     }
     616                 :            :     x = &aen->gg;
     617                 :            :   } else {
     618                 :            :     struct zx_elem_s* xx = (struct zx_elem_s*)ZX_ALLOC(c, size);
     619                 :            :     memcpy(xx, x, size);
     620                 :            :     x = xx;
     621                 :            :   }
     622                 :            :   
     623                 :            :   /* *** deal with xmlns specifications in exc c14n way */
     624                 :            :   
     625                 :            :   for (aann = 0, aa = x->attr; aa; aa = (struct zx_attr_s*)aa->ss.g.n) {  /* unknown attributes */
     626                 :            :     ZX_DUPALLOC(c, struct zx_attr_s, aan, aa);
     627                 :            :     if (!aann)
     628                 :            :       x->any_attr = aan;
     629                 :            :     else
     630                 :            :       aann->ss.g.n = &aan->ss.g;
     631                 :            :     aann = aan;
     632                 :            :     
     633                 :            :     if (dup_strs && aan->name) {
     634                 :            :       p = ZX_ALLOC(c, aan->name_len);
     635                 :            :       memcpy(p, aan->name, aan->name_len);
     636                 :            :       aan->name = p;
     637                 :            :     }
     638                 :            :     if (dup_strs && aan->ss.s) {
     639                 :            :       p = ZX_ALLOC(c, aan->ss.len);
     640                 :            :       memcpy(p, aan->ss.s, aan->ss.len);
     641                 :            :       aan->ss.s = p;
     642                 :            :     }
     643                 :            :   }
     644                 :            :   
     645                 :            :   for (aenn = 0, ae = x->kids; ae; ae = (struct zx_elem_s*)ae->gg.g.n) {  /* unknown elements */
     646                 :            :     switch (ae->g.tok) {
     647                 :            :     case ZX_TOK_DATA:
     648                 :            :       ZX_DUPALLOC(c, struct zx_str, aen, ae);
     649                 :            :       if (aen->g.s) {
     650                 :            :         p = ZX_ALLOC(c, aen->g.len);
     651                 :            :         memcpy(p, aen->g.s, aen->g.len);
     652                 :            :         aen->s = p;
     653                 :            :       }
     654                 :            :       break;
     655                 :            :     default:
     656                 :            :       aen = (struct zx_elem_s*)zx_DEEP_CLONE_elem(c, &ae->gg, dup_strs);
     657                 :            :     }
     658                 :            :     if (!aenn)
     659                 :            :       x->kids = aen;
     660                 :            :     else
     661                 :            :       aenn->gg.g.n = &aen->gg.g;
     662                 :            :     aenn = aen;
     663                 :            :   }
     664                 :            :   return x;
     665                 :            : }
     666                 :            : 
     667                 :            : /* Called by:  TXDUP_STRS_ELNAME */
     668                 :            : void zx_dup_strs_common(struct zx_ctx* c, struct zx_elem_s* x)
     669                 :            : {
     670                 :            :   struct zx_attr_s* aa;
     671                 :            :   struct zx_elem_s* ae;
     672                 :            :   char* p;
     673                 :            :   
     674                 :            :   if (x->g.tok == ZX_TOK_NOT_FOUND) {
     675                 :            :     ae = (struct zx_elem_s*)x;
     676                 :            :     p = ZX_ALLOC(c, ae->name_len);
     677                 :            :     memcpy(p, ae->name, ae->name_len);
     678                 :            :     ae->name = p;
     679                 :            :   }
     680                 :            :   
     681                 :            :   /* *** deal with xmlns specifications in exc c14n way */
     682                 :            : 
     683                 :            :   for (aa = x->attr; aa; aa = (struct zx_attr_s*)aa->ss.g.n) {  /* unknown attributes */
     684                 :            :     if (aa->name) {
     685                 :            :       p = ZX_ALLOC(c, aa->name_len);
     686                 :            :       memcpy(p, aa->name, aa->name_len);
     687                 :            :       aa->name = p;
     688                 :            :     }
     689                 :            :     if (aa->ss.s) {
     690                 :            :       p = ZX_ALLOC(c, aa->ss.len);
     691                 :            :       memcpy(p, aa->ss.s, aa->ss.len);
     692                 :            :       aa->ss.s = p;
     693                 :            :     }
     694                 :            :   }
     695                 :            : 
     696                 :            :   for (ae = x->kids; ae; ae = (struct zx_elem_s*)ae->gg.g.n)   /* unknown elements */
     697                 :            :     switch (ae->g.tok) {
     698                 :            :     case ZX_TOK_DATA:
     699                 :            :       if (ae->g.s) {
     700                 :            :         p = ZX_ALLOC(c, ae->g.len);
     701                 :            :         memcpy(p, ae->g.s, ae->g.len);
     702                 :            :         ss->s = p;
     703                 :            :       }
     704                 :            :       break;
     705                 :            :     default:
     706                 :            :       zx_DUP_STRS_elem(c, &ae->gg);
     707                 :            :     }
     708                 :            : }
     709                 :            : 
     710                 :            : int zx_walk_so_unknown_attributes(struct zx_ctx* c, struct zx_elem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
     711                 :            : {
     712                 :            :   struct zx_attr_s* aa;
     713                 :            :   int ret;
     714                 :            :   
     715                 :            :   for (aa = x->attr; aa; aa = (struct zx_attr_s*)aa->ss.g.n) {  /* unknown attributes */
     716                 :            :     ret = callback(&aa->ss.g, ctx);
     717                 :            :     if (ret)
     718                 :            :       return ret;
     719                 :            :   }
     720                 :            :   return 0;
     721                 :            : }
     722                 :            : 
     723                 :            : int zx_walk_so_unknown_elems_and_content(struct zx_ctx* c, struct zx_elem_s* x, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
     724                 :            : {
     725                 :            :   struct zx_elem_s* ae;
     726                 :            :   int ret;
     727                 :            :   
     728                 :            :   for (ae = x->kids; ae; ae = (struct zx_elem_s*)ae->gg.g.n) {  /* unknown elements */
     729                 :            :     switch (ae->g.tok) {
     730                 :            :     case ZX_TOK_DATA:
     731                 :            :       ret = callback(ae, ctx);
     732                 :            :       break;
     733                 :            :     default:
     734                 :            :       ret = zx_WALK_SO_elem(c, ae, ctx, callback);
     735                 :            :     }
     736                 :            :     if (ret)
     737                 :            :       return ret;
     738                 :            :   }
     739                 :            :   return 0;
     740                 :            : }
     741                 :            : 
     742                 :            : /* Called by: */
     743                 :            : struct zx_elem_s* zx_deep_clone_elems(struct zx_ctx* c, struct zx_elem_s* x, int dup_strs)
     744                 :            : {
     745                 :            :   struct zx_elem_s* se;
     746                 :            :   struct zx_elem_s* sen;
     747                 :            :   struct zx_elem_s* senn;
     748                 :            :   
     749                 :            :   for (senn = 0, se = x; se; se = (struct zx_elem_s*)se->g.n) {
     750                 :            :     sen = zx_DEEP_CLONE_elem(c, se, dup_strs);
     751                 :            :     if (!senn)
     752                 :            :       x = sen;
     753                 :            :     else
     754                 :            :       senn->g.n = &sen->g;
     755                 :            :     senn = sen;
     756                 :            :   }
     757                 :            :   return x;
     758                 :            : }
     759                 :            : 
     760                 :            : 
     761                 :            : int zx_walk_so_elems(struct zx_ctx* c, struct zx_elem_s* se, void* ctx, int (*callback)(struct zx_node_s* node, void* ctx))
     762                 :            : {
     763                 :            :   int ret;
     764                 :            : 
     765                 :            :   for (; se; se = (struct zx_elem_s*)se->g.n) {
     766                 :            :     ret = zx_WALK_SO_elem(c, se, ctx, callback);
     767                 :            :     if (ret)
     768                 :            :       return ret;
     769                 :            :   }
     770                 :            :   return 0;
     771                 :            : }
     772                 :            : 
     773                 :            : /* Called by: */
     774                 :            : void zx_dup_strs_elems(struct zx_ctx* c, struct zx_elem_s* se)
     775                 :            : {
     776                 :            :   for (; se; se = (struct zx_elem_s*)se->g.n)
     777                 :            :     zx_DUP_STRS_elem(c, se);
     778                 :            : }
     779                 :            : 
     780                 :            : #endif  /* end ZX_ENA_AUX */
     781                 :            : 
     782                 :            : /* EOF -- zxlib.c */

Generated by: LCOV version 1.9