LCOV - code coverage report
Current view: top level - zxid - zxcot.c (source / functions) Hit Total Coverage
Test: ZXID Code Coverage Lines: 202 242 83.5 %
Date: 2010-12-19 Functions: 7 7 100.0 %
Branches: 121 189 64.0 %

           Branch data     Line data    Source code
       1                 :            : /* zxcot.c  -  CoT (Circle-of-Trust) management tool: list CoT, add metadata to CoT
       2                 :            :  * Copyright (c) 2009-2010 Sampo Kellomaki (sampo@iki.fi), All Rights Reserved.
       3                 :            :  * This is confidential unpublished proprietary source code of the author.
       4                 :            :  * NO WARRANTY, not even implied warranties. Contains trade secrets.
       5                 :            :  * Distribution prohibited unless authorized in writing.
       6                 :            :  * Licensed under Apache License 2.0, see file COPYING.
       7                 :            :  * $Id: zxcot.c,v 1.5 2009-11-29 12:23:06 sampo Exp $
       8                 :            :  *
       9                 :            :  * 27.8.2009, created --Sampo
      10                 :            :  */
      11                 :            : 
      12                 :            : #include "platform.h"  /* for dirent.h */
      13                 :            : 
      14                 :            : #include <string.h>
      15                 :            : #include <stdio.h>
      16                 :            : #include <fcntl.h>
      17                 :            : #include <errno.h>
      18                 :            : 
      19                 :            : #include "errmac.h"
      20                 :            : #include "zx.h"
      21                 :            : #include "zxid.h"
      22                 :            : #include "zxidutil.h"
      23                 :            : #include "zxidconf.h"
      24                 :            : #include "c/zxidvers.h"
      25                 :            : #include "c/zx-const.h"
      26                 :            : #include "c/zx-ns.h"
      27                 :            : #include "c/zx-data.h"
      28                 :            : 
      29                 :            : char* help =
      30                 :            : "zxcot  -  Circle-of-Trust and metadata management tool R" ZXID_REL "\n\
      31                 :            : Copyright (c) 2009-2010 Sampo Kellomaki (sampo@iki.fi), All Rights Reserved.\n\
      32                 :            : NO WARRANTY, not even implied warranties. Licensed under Apache License v2.0\n\
      33                 :            : See http://www.apache.org/licenses/LICENSE-2.0\n\
      34                 :            : Send well researched bug reports to the author. Home: zxid.org\n\
      35                 :            : \n\
      36                 :            : Usage: zxcot [options] [dir]         # Gives listing of metadata\n\
      37                 :            :        zxcot -a [options] [dir] <meta.xml\n\
      38                 :            :        zxcot -b [options] [dir] <epr.xml\n\
      39                 :            :        curl https://site.com/metadata.xml | zxcot -a [options] [dir]\n\
      40                 :            :        zxcot -g https://site.com/metadata.xml [options] [dir]\n\
      41                 :            :        zxcot -m [options] >meta.xml  # Generate our own metadata\n\
      42                 :            :        zxcot -p https://site.com/metadata.xml\n\
      43                 :            :   [dir]            CoT directory. Default /var/zxid/cot\n\
      44                 :            :   -c CONF          Optional configuration string (default -c PATH=/var/zxid/)\n\
      45                 :            :                    Most of the configuration is read from /var/zxid/zxid.conf\n\
      46                 :            :   -a               Add metadata from stdin\n\
      47                 :            :   -b               Register Web Service, add Service EPR from stdin\n\
      48                 :            :   -bs              Register Web Service and Bootstrap, add Service EPR from stdin\n\
      49                 :            :   -e endpoint abstract entid servicetype   Dump EPR to stdout.\n\
      50                 :            :   -g URL           Do HTTP(S) GET to URL and add as metadata (if compiled w/libcurl)\n\
      51                 :            :   -n               Dryrun. Do not actually add the metadata. Instead print it to stdout.\n\
      52                 :            :   -s               Swap columns, for easier sorting by URL\n\
      53                 :            :   -m               Output metadata of this installation (our own metadata)\n\
      54                 :            :   -p ENTID         Print sha1 name corresponding to an entity ID.\n\
      55                 :            :   -v               Verbose messages.\n\
      56                 :            :   -q               Be extra quiet.\n\
      57                 :            :   -d               Turn on debugging.\n\
      58                 :            :   -h               This help message\n\
      59                 :            :   --               End of options\n\
      60                 :            : \n\
      61                 :            : zxcot -e http://idp.tas3.pt:8081/zxididp?o=S 'TAS3 Default Discovery Service (ID-WSF 2.0)' http://idp.tas3.pt:8081/zxididp?o=B urn:liberty:disco:2006-08 | zxcot -b\n\
      62                 :            : \n";
      63                 :            : 
      64                 :            : #define ZXID_MAX_MD (256*1024)
      65                 :            : 
      66                 :            : int swap = 0;
      67                 :            : int addmd = 0;
      68                 :            : int regsvc = 0;
      69                 :            : int regbs = 0;
      70                 :            : int genmd = 0;
      71                 :            : int dryrun = 0;
      72                 :            : int inflate_flag = 2;  /* Auto */
      73                 :            : int verbose = 1;
      74                 :            : char buf[ZXID_MAX_MD+1];
      75                 :            : char* mdurl = 0;
      76                 :            : char* entid = 0;
      77                 :            : char* cotdir  = ZXID_PATH ZXID_COT_DIR;
      78                 :            : char* dimddir = ZXID_PATH ZXID_DIMD_DIR;
      79                 :            : char* uiddir  = ZXID_PATH ZXID_UID_DIR;
      80                 :            : zxid_conf* cf = 0;
      81                 :            : 
      82                 :            : /* Called by:  main x8, zxcall_main, zxcot_main, zxdecode_main */
      83                 :            : static void opt(int* argc, char*** argv, char*** env)
      84                 :         20 : {
      85                 :            :   int len;
      86                 :            :   struct zx_str* ss;
      87                 :            :   
      88         [ +  + ]:         20 :   if (*argc <= 1) return;
      89                 :            :   
      90                 :            :   while (1) {
      91                 :         46 :     ++(*argv); --(*argc);
      92                 :            :     
      93   [ +  +  +  + ]:         46 :     if (!(*argc) || ((*argv)[0][0] != '-')) break;  /* normal exit from options loop */
      94                 :            :     
      95   [ +  +  +  +  :         32 :     switch ((*argv)[0][1]) {
          +  +  +  +  +  
             +  +  +  +  
                      + ]
      96         [ +  - ]:          1 :     case '-': if ((*argv)[0][2]) break;
      97                 :          1 :       ++(*argv); --(*argc);
      98                 :            :       DD("End of options by --");
      99                 :          1 :       return;  /* -- ends the options */
     100                 :            : 
     101                 :            :     case 'a':
     102         [ +  - ]:          2 :       switch ((*argv)[0][2]) {
     103                 :            :       case '\0':
     104                 :          2 :         ++addmd;
     105                 :          2 :         continue;
     106                 :            :       }
     107                 :          0 :       break;
     108                 :            : 
     109                 :            :     case 'b':
     110      [ +  +  - ]:          3 :       switch ((*argv)[0][2]) {
     111                 :            :       case 's':
     112                 :          1 :         ++regsvc;
     113                 :          1 :         ++regbs;
     114                 :          1 :         dimddir = ZXID_PATH "idp" ZXID_DIMD_DIR;
     115                 :          1 :         uiddir  = ZXID_PATH "idp" ZXID_UID_DIR;
     116                 :          1 :         continue;
     117                 :            :       case '\0':
     118                 :          2 :         ++regsvc;
     119                 :          2 :         dimddir  = ZXID_PATH "idp" ZXID_DIMD_DIR;
     120                 :          2 :         continue;
     121                 :            :       }
     122                 :          0 :       break;
     123                 :            : 
     124                 :            :     case 'c':
     125         [ +  - ]:          2 :       switch ((*argv)[0][2]) {
     126                 :            :       case '\0':
     127                 :          2 :         ++(*argv); --(*argc);
     128         [ +  - ]:          2 :         if ((*argc) < 1) break;
     129                 :          2 :         zxid_parse_conf(cf, (*argv)[0]);
     130                 :          2 :         continue;
     131                 :            :       }
     132                 :          0 :       break;
     133                 :            : 
     134                 :            :     case 'e':
     135         [ +  - ]:          3 :       switch ((*argv)[0][2]) {
     136                 :            :       case '\0':
     137         [ +  - ]:          3 :         if ((*argc) < 4) break;
     138                 :          3 :         printf(
     139                 :            : "<a:EndpointReference xmlns:a=\"http://www.w3.org/2005/08/addressing\" "
     140                 :            : "xmlns:wsu=\"http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd\" "
     141                 :            :     "notOnOrAfter=\"2037-01-05T23:03:59.001Z\" "
     142                 :            :     "wsu:Id=\"EPRID92lFPo3ZNEt_3rHtJFoU\">"
     143                 :            :   "<a:Address>%s</a:Address>"
     144                 :            :   "<a:Metadata>"
     145                 :            :     "<sbf:Framework xmlns:sbf=\"urn:liberty:sb\" version=\"2.0\"></sbf:Framework>"
     146                 :            :     "<di:Abstract xmlns:di=\"urn:liberty:disco:2006-08\">%s</di:Abstract>"
     147                 :            :     "<di:ProviderID xmlns:di=\"urn:liberty:disco:2006-08\">%s</di:ProviderID>"
     148                 :            :     "<di:ServiceType xmlns:di=\"urn:liberty:disco:2006-08\">%s</di:ServiceType>"
     149                 :            :   "</a:Metadata>"
     150                 :            : "</a:EndpointReference>", (*argv)[1], (*argv)[2], (*argv)[3], (*argv)[4]);
     151                 :          3 :         exit(0);
     152                 :            :       }
     153                 :          0 :       break;
     154                 :            : 
     155                 :            :     case 'g':
     156         [ +  - ]:          2 :       switch ((*argv)[0][2]) {
     157                 :            :       case '\0':
     158                 :          2 :         ++(*argv); --(*argc);
     159         [ +  - ]:          2 :         if ((*argc) < 1) break;
     160                 :          2 :         mdurl = (*argv)[0];
     161                 :          2 :         ++addmd;
     162                 :          2 :         continue;
     163                 :            :       }
     164                 :          0 :       break;
     165                 :            : 
     166                 :            :     case 'd':
     167      [ +  +  - ]:          2 :       switch ((*argv)[0][2]) {
     168                 :            :       case '\0':
     169                 :          1 :         ++zx_debug;
     170                 :          1 :         continue;
     171                 :            :       case 'c':
     172                 :          1 :         ss = zxid_show_conf(cf);
     173                 :          1 :         fprintf(stderr, "\n======== CONF ========\n%.*s\n^^^^^^^^ CONF ^^^^^^^^\n",ss->len,ss->s);
     174                 :          1 :         continue;
     175                 :            :       }
     176                 :          0 :       break;
     177                 :            : 
     178                 :            :     case 's':
     179         [ +  - ]:          4 :       switch ((*argv)[0][2]) {
     180                 :            :       case '\0':
     181                 :          4 :         ++swap;
     182                 :          4 :         continue;
     183                 :            :       }
     184                 :          0 :       break;
     185                 :            : 
     186                 :            :     case 'p':
     187         [ +  - ]:          1 :       switch ((*argv)[0][2]) {
     188                 :            :       case '\0':
     189                 :          1 :         ++(*argv); --(*argc);
     190         [ +  - ]:          1 :         if ((*argc) < 1) break;
     191                 :          1 :         entid = (*argv)[0];
     192                 :          1 :         continue;
     193                 :            :       }
     194                 :          0 :       break;
     195                 :            : 
     196                 :            :     case 'm':
     197         [ +  - ]:          3 :       switch ((*argv)[0][2]) {
     198                 :            :       case '\0':
     199                 :          3 :         ++genmd;
     200                 :          3 :         continue;
     201                 :            :       }
     202                 :          0 :       break;
     203                 :            : 
     204                 :            :     case 'n':
     205         [ +  - ]:          3 :       switch ((*argv)[0][2]) {
     206                 :            :       case '\0':
     207                 :          3 :         ++dryrun;
     208                 :          3 :         continue;
     209                 :            :       }
     210                 :          0 :       break;
     211                 :            : 
     212                 :            : #if 0
     213                 :            :     case 'l':
     214                 :            :       switch ((*argv)[0][2]) {
     215                 :            :       case 'i':
     216                 :            :         if (!strcmp((*argv)[0],"-license")) {
     217                 :            :           extern char* license;
     218                 :            :           fprintf(stderr, license);
     219                 :            :           exit(0);
     220                 :            :         }
     221                 :            :         break;
     222                 :            :       }
     223                 :            :       break;
     224                 :            : #endif
     225                 :            : 
     226                 :            :     case 'q':
     227         [ +  - ]:          1 :       switch ((*argv)[0][2]) {
     228                 :            :       case '\0':
     229                 :          1 :         verbose = 0;
     230                 :          1 :         continue;
     231                 :            :       }
     232                 :          0 :       break;
     233                 :            : 
     234                 :            :     case 'v':
     235         [ +  - ]:          4 :       switch ((*argv)[0][2]) {
     236                 :            :       case '\0':
     237                 :          4 :         ++verbose;
     238                 :          4 :         continue;
     239                 :            :       }
     240                 :            :       break;
     241                 :            : 
     242                 :            :     } 
     243                 :            :     /* fall thru means unrecognized flag */
     244         [ +  - ]:          1 :     if (*argc)
     245                 :          1 :       fprintf(stderr, "Unrecognized flag `%s'\n", (*argv)[0]);
     246         [ +  - ]:          1 :     if (verbose>1) {
     247                 :          1 :       printf(help);
     248                 :          1 :       exit(0);
     249                 :            :     }
     250                 :          0 :     fprintf(stderr, help);
     251                 :            :     /*fprintf(stderr, "version=0x%06x rel(%s)\n", zxid_version(), zxid_version_str());*/
     252                 :          0 :     exit(3);
     253                 :         27 :   }
     254         [ +  + ]:         14 :   if (*argc) {
     255                 :          2 :     uiddir = dimddir = cotdir = (*argv)[0];
     256                 :          2 :     len = strlen(cotdir);
     257         [ +  - ]:          2 :     if (cotdir[len-1] != '/') {
     258                 :          2 :       cotdir = malloc(len+1);
     259                 :          2 :       strcpy(cotdir, (*argv)[0]);
     260                 :          2 :       cotdir[len] = '/';
     261                 :          2 :       cotdir[len+1] = 0;
     262                 :          2 :       uiddir = dimddir = cotdir;
     263                 :            :     }
     264                 :            :   }
     265                 :            : }
     266                 :            : 
     267                 :            : /* --------------- reg_svc --------------- */
     268                 :            : 
     269                 :            : /*() IdP and Discovery. Register service metadata to /var/zxid/idpdimd/XX,
     270                 :            :  * and possibly boostrap to /var/zxid/idpuid/.all/.bs/YY
     271                 :            :  *
     272                 :            :  * bs_reg:: Register-also-as-bootstrap flag
     273                 :            :  * dry_run:: nonzero: do not write anything
     274                 :            :  * ddimd:: Discovery metadata directory, such as /var/zxid/idpdimd/
     275                 :            :  * duid:: uid dir such as  /var/zxid/idpuid/
     276                 :            :  * returns:: 0 on success, nonzero on error. */
     277                 :            : 
     278                 :            : /* Called by:  zxcot_main */
     279                 :            : static int zxid_reg_svc(zxid_conf* cf, int bs_reg, int dry_run, const char* ddimd, const char* duid)
     280                 :          2 : {
     281                 :            :   char sha1_name[28];
     282                 :            :   char path[ZXID_MAX_BUF];
     283                 :            :   char* p;
     284                 :            :   //char* uiddir;
     285                 :            :   int got, fd;
     286                 :            :   struct zx_root_s* r;
     287                 :            :   zxid_epr* epr;
     288                 :            :   struct zx_str* ss;
     289                 :            :   struct zx_str* tt;
     290                 :            :   
     291                 :          2 :   read_all_fd(0, buf, sizeof(buf)-1, &got);  /* Read EPR */
     292                 :          2 :   buf[got] = 0;
     293                 :          2 :   p = buf;
     294                 :            :   
     295                 :          2 :   r = zx_dec_zx_root(cf->ctx, got, buf, "cot reg_svc");
     296   [ +  -  -  + ]:          2 :   if (!r || !r->EndpointReference) {
     297                 :          0 :     ERR("Failed to parse <EndpointReference> buf(%.*s)", got, buf);
     298                 :          0 :     return 1;
     299                 :            :   }
     300                 :          2 :   epr = r->EndpointReference;
     301   [ +  -  +  -  :          2 :   if (!ZX_SIMPLE_ELEM_CHK(epr->Address)) {
          +  -  +  -  +  
                -  -  + ]
     302                 :          0 :     ERR("<EndpointReference> MUST have <Address> element buf(%.*s)", got, buf);
     303                 :          0 :     return 1;
     304                 :            :   }
     305         [ -  + ]:          2 :   if (!epr->Metadata) {
     306                 :          0 :     ERR("<EndpointReference> MUST have <Metadata> element buf(%.*s)", got, buf);
     307                 :          0 :     return 1;
     308                 :            :   }
     309   [ +  -  +  -  :          2 :   if (!ZX_SIMPLE_ELEM_CHK(epr->Metadata->ProviderID)) {
          +  -  +  -  +  
                -  -  + ]
     310                 :          0 :     ERR("<EndpointReference> MUST have <Metadata> with <ProviderID> element buf(%.*s)", got, buf);
     311                 :          0 :     return 1;
     312                 :            :   }
     313         [ -  + ]:          2 :   if (!epr->Metadata->ServiceType) {
     314                 :          0 :     ERR("<EndpointReference> MUST have <ServiceType> element buf(%.*s)", got, buf);
     315                 :          0 :     return 1;
     316                 :            :   }
     317                 :            : 
     318                 :            :   /* *** possibly add something here and double check the required fields are available. */
     319                 :            : 
     320                 :          2 :   ss = zx_easy_enc_elem_opt(cf, &epr->gg);
     321         [ -  + ]:          2 :   if (!ss)
     322                 :          0 :     return 2;
     323                 :            :   
     324                 :            : #if 0
     325                 :            :   // *** wrong
     326                 :            :   tt = ZX_GET_CONTENT(epr->Metadata->ProviderID);
     327                 :            : #else
     328   [ +  -  +  -  :          2 :   tt = ZX_GET_CONTENT(epr->Metadata->ServiceType);
                   +  - ]
     329                 :            : #endif
     330                 :          2 :   got = MIN(tt->len, sizeof(path)-1);
     331         [ +  - ]:          2 :   memcpy(path, tt?tt->s:"", got);
     332                 :          2 :   path[got] = 0;
     333                 :          2 :   zxid_fold_svc(path, got);
     334                 :            : 
     335                 :          2 :   sha1_safe_base64(sha1_name, ss->len, ss->s);
     336                 :          2 :   sha1_name[27] = 0;
     337                 :            : 
     338         [ +  - ]:          2 :   if (verbose)
     339                 :          2 :     fprintf(stderr, "Registering metadata in %s%s,%s\n", ddimd, path, sha1_name);
     340                 :            :   
     341         [ +  + ]:          2 :   if (dry_run) {
     342         [ +  - ]:          1 :     if (verbose)
     343                 :          1 :       fprintf(stderr, "Register EPR dry run. Would have written to path(%s%s,%s). "
     344                 :            :               "You may also want to\n"
     345                 :            :               "  touch %s.all/.bs/%s,%s\n\n", ddimd, path, sha1_name, uiddir, path, sha1_name);
     346                 :          1 :     fflush(stdin);
     347                 :          1 :     write_all_fd(fdstdout, ss->s, ss->len);
     348                 :          1 :     zx_str_free(cf->ctx, ss);
     349                 :          1 :     return 0;
     350                 :            :   }
     351                 :            :   
     352   [ -  +  #  # ]:          1 :   D("Register EPR path(%s%s,%s) in discovery metadata.", ddimd, path, sha1_name);
     353                 :          1 :   fd = open_fd_from_path(O_CREAT | O_WRONLY | O_TRUNC, 0666, "zxcot -b", 1,
     354                 :            :                          "%s%s,%s", ddimd, path, sha1_name);
     355         [ -  + ]:          1 :   if (fd == BADFD) {
     356                 :          0 :     perror("open epr for registering");
     357                 :          0 :     ERR("Failed to open file for writing: sha1_name(%s,%s) to service registration", path, sha1_name);
     358                 :          0 :     zx_str_free(cf->ctx, ss);
     359                 :          0 :     return 1;
     360                 :            :   }
     361                 :            :   
     362                 :          1 :   write_all_fd(fd, ss->s, ss->len);
     363                 :          1 :   zx_str_free(cf->ctx, ss);
     364                 :          1 :   close_file(fd, (const char*)__FUNCTION__);
     365                 :            : 
     366         [ +  - ]:          1 :   if (bs_reg) {
     367         [ +  - ]:          1 :     if (verbose)
     368                 :          1 :       fprintf(stderr, "Activating bootstrap %s.all/.bs/%s,%s", duid, path, sha1_name);
     369                 :            : 
     370         [ +  - ]:          1 :     if (!dryrun) {
     371                 :          1 :       fd = open_fd_from_path(O_CREAT | O_WRONLY | O_TRUNC, 0666, "zxcot -bs", 1,
     372                 :            :                              "%s.all/.bs/%s,%s", duid, path, sha1_name);
     373         [ -  + ]:          1 :       if (fd == BADFD) {
     374                 :          0 :         perror("open epr for bootstrap activation");
     375                 :          0 :         ERR("Failed to open file for writing: sha1_name(%s,%s) to bootstrap activation", path, sha1_name);
     376                 :          0 :         return 1;
     377                 :            :       }
     378                 :            :     
     379                 :          1 :       write_all_fd(fd, "", 0);
     380                 :          1 :       close_file(fd, (const char*)__FUNCTION__);
     381                 :            :     }
     382                 :            :   } else {
     383   [ #  #  #  # ]:          0 :     D("You may also want to activate bootstrap by\n  touch %s.all/.bs/%s,%s", duid, path, sha1_name);
     384                 :            :   }
     385                 :          1 :   return 0;
     386                 :            : }
     387                 :            : 
     388                 :            : /* --------------- addmd --------------- */
     389                 :            : 
     390                 :            : /*() Add metadata of a partner to the Circle-of-Trust, represented by the CoT dir */
     391                 :            : 
     392                 :            : /* Called by:  zxcot_main */
     393                 :            : static int zxid_addmd(zxid_conf* cf, char* mdurl, int dry_run, const char* dcot)
     394                 :          4 : {
     395                 :            :   int got, fd;
     396                 :            :   char* p;
     397                 :            :   zxid_entity* ent;
     398                 :            :   struct zx_str* ss;
     399                 :            :   
     400         [ +  + ]:          4 :   if (mdurl) {
     401                 :          2 :     ent = zxid_get_meta(cf, mdurl);
     402                 :            :   } else {
     403                 :          2 :     read_all_fd(0, buf, sizeof(buf)-1, &got);
     404                 :          2 :     buf[got] = 0;
     405                 :          2 :     p = buf;
     406                 :          2 :     ent = zxid_parse_meta(cf, &p, buf+got);
     407                 :            :   }
     408                 :            :   
     409         [ +  + ]:          4 :   if (!ent) {
     410                 :          1 :     ERR("***** Parsing metadata failed %d", 0);
     411                 :          1 :     return 1;
     412                 :            :   }
     413                 :            : 
     414         [ +  + ]:          6 :   for (; ent; ent = ent->n) {
     415                 :          3 :     ss = zx_easy_enc_elem_opt(cf, &ent->ed->gg);
     416         [ -  + ]:          3 :     if (!ss)
     417                 :          0 :       return 2;
     418                 :            :   
     419         [ +  + ]:          3 :     if (dry_run) {
     420                 :          2 :       write_all_fd(fdstdout, ss->s, ss->len);
     421                 :          2 :       zx_str_free(cf->ctx, ss);
     422         [ +  - ]:          2 :       if (verbose>1)
     423                 :          2 :         printf("\n\nDry run ent(%s) to %s%s\n", ent->eid, dcot, ent->sha1_name);
     424                 :          2 :       continue;
     425                 :            :     }
     426         [ +  - ]:          1 :     if (verbose)
     427                 :          1 :       printf("Writing ent(%s) to %s%s\n", ent->eid, dcot, ent->sha1_name);
     428                 :            :   
     429                 :          1 :     fd = open_fd_from_path(O_CREAT | O_WRONLY | O_TRUNC, 0666, "zxcot -a", 1,
     430                 :            :                            "%s%s", dcot, ent->sha1_name);
     431         [ -  + ]:          1 :     if (fd == BADFD) {
     432                 :          0 :       perror("open metadata for writing metadata to cache");
     433                 :          0 :       ERR("Failed to open file for writing: sha1_name(%s) to metadata cache", ent->sha1_name);
     434                 :          0 :       zx_str_free(cf->ctx, ss);
     435                 :          0 :       return 1;
     436                 :            :     }
     437                 :            :     
     438                 :          1 :     write_all_fd(fd, ss->s, ss->len);
     439                 :          1 :     zx_str_free(cf->ctx, ss);
     440                 :          1 :     close_file(fd, (const char*)__FUNCTION__);
     441                 :            :   }
     442                 :          3 :   return 0;
     443                 :            : }
     444                 :            : 
     445                 :            : /* --------------- genmd --------------- */
     446                 :            : 
     447                 :            : /*() Generate our own metadata */
     448                 :            : 
     449                 :            : /* Called by:  zxcot_main */
     450                 :            : static int zxid_genmd(zxid_conf* cf, int dry_run, const char* dcot)
     451                 :          3 : {
     452                 :            :   zxid_cgi cgi;
     453                 :          3 :   struct zx_str* meta = zxid_sp_meta(cf, &cgi);
     454                 :          3 :   ZERO(&cgi, sizeof(cgi));
     455                 :          3 :   printf("%.*s", meta->len, meta->s);
     456                 :          3 :   return 0;
     457                 :            : }
     458                 :            : 
     459                 :            : /* --------------- lscot --------------- */
     460                 :            : 
     461                 :            : /*() Print a line of Circle-of-Trust listing */
     462                 :            : 
     463                 :            : /* Called by:  zxid_lscot x2 */
     464                 :            : static int zxid_lscot_line(zxid_conf* cf, int col_swap, const char* dcot, const char* den)
     465                 :         98 : {
     466                 :            :   zxid_entity* ent;
     467                 :            :   char* p;
     468                 :         98 :   int got = read_all(ZXID_MAX_MD, buf, "zxcot line", 1, "%s%s", dcot, den);
     469         [ +  + ]:         98 :   if (!got) {
     470                 :          1 :     ERR("Zero data in file(%s%s). If cot directory does not exist consider running zxmkdirs.sh", dcot, den);
     471                 :          1 :     return 1;
     472                 :            :   }
     473                 :         97 :   p = buf;
     474                 :         97 :   ent = zxid_parse_meta(cf, &p, buf+got);
     475         [ -  + ]:         97 :   if (!ent) {
     476                 :          0 :     ERR("***** Parsing metadata failed for(%s%s)", dcot, den);
     477                 :          0 :     return 2;
     478                 :            :   }
     479         [ +  + ]:        291 :   while (ent) {
     480      [ +  +  + ]:         97 :     switch (col_swap) {
     481         [ +  + ]:         37 :     case 1:  printf("%-50s %s%s %s\n", ent->eid, dcot, den, STRNULLCHKD(ent->dpy_name)); break;
     482                 :         20 :     case 2:  printf("%s\n",       ent->eid); break;
     483         [ +  + ]:         40 :     default: printf("%s%s %-50s %s\n", dcot, den, ent->eid, STRNULLCHKD(ent->dpy_name));
     484                 :            :     }
     485   [ +  -  +  + ]:         97 :     if (strcmp(*den?den:dcot, ent->sha1_name))
     486         [ +  - ]:          4 :       fprintf(stderr, "Filename(%s) does not match sha1_name(%s)\n", *den?den:dcot, ent->sha1_name);
     487                 :         97 :     ent = ent->n;
     488                 :            :   }
     489                 :         97 :   return 0;
     490                 :            : }
     491                 :            : 
     492                 :            : /*() List the contents of the Circle-of-Trust, represented by the CoT directory,
     493                 :            :  * in various formats. */
     494                 :            : 
     495                 :            : /* Called by:  zxcot_main */
     496                 :            : static int zxid_lscot(zxid_conf* cf, int col_swap, const char* dcot)
     497                 :          6 : {
     498                 :            :   int got, ret;
     499                 :            :   char* p;
     500                 :            :   DIR* dir;
     501                 :            :   struct dirent* de;
     502                 :            : 
     503                 :          6 :   dir = opendir(dcot);
     504         [ +  + ]:          6 :   if (!dir) {
     505                 :          1 :     perror("opendir for /var/zxid/cot (or other if configured) for loading cot cache");
     506   [ -  +  #  # ]:          1 :     D("failed path(%s)", dcot);
     507                 :            :     
     508                 :          1 :     got = strlen(dcot);
     509                 :          1 :     p = ZX_ALLOC(cf->ctx, got+1);
     510                 :          1 :     memcpy(p, dcot, got-1);
     511                 :          1 :     p[got-1] = 0;  /* chop off / */
     512                 :          1 :     got = zxid_lscot_line(cf, col_swap, p, "");
     513                 :          1 :     ZX_FREE(cf->ctx, p);
     514                 :          1 :     return got;
     515                 :            :   }
     516                 :            :   
     517         [ +  + ]:        121 :   while (de = readdir(dir)) {
     518   [ +  +  +  + ]:        111 :     if (de->d_name[0] == '.' || de->d_name[strlen(de->d_name)-1] == '~')
     519                 :            :       continue;
     520                 :         97 :     ret = zxid_lscot_line(cf, col_swap, dcot, de->d_name);
     521   [ -  +  #  # ]:         97 :     if (!ONE_OF_2(ret, 0, 2))
     522                 :          0 :       return ret;
     523                 :            :   }
     524                 :          5 :   return 0;
     525                 :            : }
     526                 :            : 
     527                 :            : /* ============== MAIN ============ */
     528                 :            : 
     529                 :            : #ifndef zxcot_main
     530                 :            : #define zxcot_main main
     531                 :            : #endif
     532                 :            : 
     533                 :            : /*() Circle of Trust management tool */
     534                 :            : 
     535                 :            : /* Called by: */
     536                 :            : int zxcot_main(int argc, char** argv, char** env)
     537                 :         20 : {
     538                 :         20 :   strncpy(zx_instance, "\tzxcot", sizeof(zx_instance));
     539                 :         20 :   cf = zxid_new_conf_to_cf(0);
     540                 :            : 
     541                 :         20 :   opt(&argc, &argv, &env);
     542                 :            :   
     543         [ +  + ]:         16 :   if (entid) {
     544                 :            :     char sha1_name[28];
     545                 :          1 :     sha1_safe_base64(sha1_name, strlen(entid), entid);
     546                 :          1 :     sha1_name[27] = 0;
     547                 :          1 :     printf("%s\n", sha1_name);
     548                 :          1 :     return 0;
     549                 :            :   }
     550                 :            :     
     551         [ +  + ]:         15 :   if (addmd)
     552                 :          4 :     return zxid_addmd(cf, mdurl, dryrun, cotdir);
     553                 :            :   
     554         [ +  + ]:         11 :   if (regsvc)
     555                 :          2 :     return zxid_reg_svc(cf, regbs, dryrun, dimddir, uiddir);
     556                 :            : 
     557         [ +  + ]:          9 :   if (genmd)
     558                 :          3 :     return zxid_genmd(cf, dryrun, cotdir);
     559                 :            :   
     560                 :          6 :   return zxid_lscot(cf, swap, cotdir);
     561                 :            : }
     562                 :            : 
     563                 :            : /* EOF  --  zxcot.c */

Generated by: LCOV version 1.9