LCOV - code coverage report
Current view: top level - shishi/lib - tktccache.c (source / functions) Hit Total Coverage
Test: GNU Shishi Lines: 80 139 57.6 %
Date: 2010-05-20 Functions: 3 9 33.3 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 36 76 47.4 %

           Branch data     Line data    Source code
       1                 :            : /* ccache.c --- Credential Cache compatibility ticket set handling.
       2                 :            :  * Copyright (C) 2002, 2003, 2004, 2006, 2007, 2008, 2009, 2010  Simon Josefsson
       3                 :            :  *
       4                 :            :  * This file is part of Shishi.
       5                 :            :  *
       6                 :            :  * Shishi is free software; you can redistribute it and/or modify it
       7                 :            :  * under the terms of the GNU General Public License as published by
       8                 :            :  * the Free Software Foundation; either version 3 of the License, or
       9                 :            :  * (at your option) any later version.
      10                 :            :  *
      11                 :            :  * Shishi is distributed in the hope that it will be useful, but
      12                 :            :  * WITHOUT ANY WARRANTY; without even the implied warranty of
      13                 :            :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14                 :            :  * GNU General Public License for more details.
      15                 :            :  *
      16                 :            :  * You should have received a copy of the GNU General Public License
      17                 :            :  * along with Shishi; if not, see http://www.gnu.org/licenses or write
      18                 :            :  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
      19                 :            :  * Floor, Boston, MA 02110-1301, USA
      20                 :            :  *
      21                 :            :  */
      22                 :            : 
      23                 :            : #include "internal.h"
      24                 :            : #include "ccache.h"
      25                 :            : 
      26                 :            : #include "utils.h"
      27                 :            : 
      28                 :            : /**
      29                 :            :  * shishi_tkts_default_ccache_guess:
      30                 :            :  * @handle: Shishi library handle create by shishi_init().
      31                 :            :  *
      32                 :            :  * Guesses the default ccache ticket filename; it is the contents of
      33                 :            :  * the environment variable KRB5CCNAME or /tmp/krb5cc_UID where UID is
      34                 :            :  * the user's identity in decimal, as returned by getuid().
      35                 :            :  *
      36                 :            :  * Return value: Returns default ccache filename as a string that has
      37                 :            :  *   to be deallocated with free() by the caller.
      38                 :            :  **/
      39                 :            : char *
      40                 :          0 : shishi_tkts_default_ccache_guess (Shishi * handle)
      41                 :            : {
      42                 :            :   char *envfile;
      43                 :            : 
      44                 :          0 :   envfile = getenv ("KRB5CCNAME");
      45         [ #  # ]:          0 :   if (envfile)
      46                 :          0 :     return xstrdup (envfile);
      47                 :            : 
      48                 :            : #if HAVE_GETUID
      49                 :          0 :   return xasprintf ("/tmp/krb5cc_%lu", (unsigned long) getuid ());
      50                 :            : #else
      51                 :            :   return xasprintf ("/tmp/krb5cc_0");
      52                 :            : #endif
      53                 :            : }
      54                 :            : 
      55                 :            : /**
      56                 :            :  * shishi_tkts_default_ccache:
      57                 :            :  * @handle: Shishi library handle create by shishi_init().
      58                 :            :  *
      59                 :            :  * Get filename of default ccache filename.
      60                 :            :  *
      61                 :            :  * Return value: Returns the default ccache filename used in the
      62                 :            :  *   library.  The string is not a copy, so don't modify or deallocate
      63                 :            :  *   it.
      64                 :            :  **/
      65                 :            : const char *
      66                 :          0 : shishi_tkts_default_ccache (Shishi * handle)
      67                 :            : {
      68         [ #  # ]:          0 :   if (!handle->ccachedefault)
      69                 :            :     {
      70                 :            :       char *p;
      71                 :            : 
      72                 :          0 :       p = shishi_tkts_default_ccache_guess (handle);
      73                 :          0 :       shishi_tkts_default_ccache_set (handle, p);
      74                 :          0 :       free (p);
      75                 :            :     }
      76                 :            : 
      77                 :          0 :   return handle->ccachedefault;
      78                 :            : }
      79                 :            : 
      80                 :            : /**
      81                 :            :  * shishi_tkts_default_ccache_set:
      82                 :            :  * @handle: Shishi library handle create by shishi_init().
      83                 :            :  * @ccache: string with new default ccache filename, or
      84                 :            :  *                 NULL to reset to default.
      85                 :            :  *
      86                 :            :  * Set the default ccache filename used in the library.  The string is
      87                 :            :  * copied into the library, so you can dispose of the variable
      88                 :            :  * immediately after calling this function.
      89                 :            :  **/
      90                 :            : void
      91                 :          0 : shishi_tkts_default_ccache_set (Shishi * handle, const char *ccache)
      92                 :            : {
      93                 :          0 :   free (handle->ccachedefault);
      94         [ #  # ]:          0 :   if (ccache)
      95                 :          0 :     handle->ccachedefault = xstrdup (ccache);
      96                 :            :   else
      97                 :          0 :     handle->ccachedefault = NULL;
      98                 :          0 : }
      99                 :            : 
     100                 :            : /**
     101                 :            :  * shishi_tkts_add_ccache_mem:
     102                 :            :  * @handle: shishi handle as allocated by shishi_init().
     103                 :            :  * @data: constant memory buffer with ccache of @len size.
     104                 :            :  * @len: size of memory buffer with ccache data.
     105                 :            :  * @tkts: allocated key set to store tickets in.
     106                 :            :  *
     107                 :            :  * Read tickets from a ccache data structure, and add them to the
     108                 :            :  * ticket set.
     109                 :            :  *
     110                 :            :  * The ccache format is proprietary, and this function support (at
     111                 :            :  * least) the 0x0504 format.  See the section The Credential Cache
     112                 :            :  * Binary File Format in the Shishi manual for a description of the
     113                 :            :  * file format.
     114                 :            :  *
     115                 :            :  * Returns: Returns %SHISHI_CCACHE_ERROR if the data does not
     116                 :            :  *   represent a valid ccache structure, and %SHISHI_OK on success.
     117                 :            :  **/
     118                 :            : int
     119                 :          1 : shishi_tkts_add_ccache_mem (Shishi * handle,
     120                 :            :                             const char *data, size_t len, Shishi_tkts * tkts)
     121                 :            : {
     122                 :          1 :   int rc = SHISHI_OK;
     123                 :            :   struct ccache ccache;
     124                 :            : 
     125         [ -  + ]:          1 :   if (VERBOSENOISE (handle))
     126                 :            :     {
     127                 :          0 :       printf ("ccache len %d (0x%x)\n", len, len);
     128                 :          0 :       _shishi_hexprint (data, len);
     129                 :            :     }
     130                 :            : 
     131                 :          1 :   rc = ccache_parse (data, len, &ccache);
     132         [ -  + ]:          1 :   if (rc < 0)
     133                 :          0 :     return SHISHI_CCACHE_ERROR;
     134                 :            : 
     135         [ -  + ]:          1 :   if (VERBOSENOISE (handle))
     136                 :          0 :     ccache_print (&ccache);
     137                 :            : 
     138         [ +  + ]:          3 :   while (ccache.credentialslen)
     139                 :            :     {
     140                 :            :       struct ccache_credential cred;
     141                 :            :       Shishi_tkt *tkt;
     142                 :            :       Shishi_asn1 ticket;
     143                 :            :       size_t n;
     144                 :            : 
     145                 :          2 :       rc = ccache_parse_credential (ccache.credentials,
     146                 :            :                                     ccache.credentialslen, &cred, &n);
     147         [ -  + ]:          2 :       if (rc < 0)
     148                 :          0 :         return SHISHI_CCACHE_ERROR;
     149                 :            : 
     150         [ -  + ]:          2 :       if (VERBOSENOISE (handle))
     151                 :          0 :         ccache_print_credential (&cred);
     152                 :            : 
     153                 :            :       /* Sanity check credential first. */
     154                 :            : 
     155         [ -  + ]:          2 :       if (shishi_cipher_keylen (cred.key.keytype) != cred.key.keylen)
     156                 :          0 :         continue;
     157                 :            : 
     158                 :          2 :       ticket = shishi_der2asn1_ticket (handle, cred.ticket.data,
     159                 :            :                                        cred.ticket.length);
     160         [ -  + ]:          2 :       if (!ticket)
     161                 :          0 :         continue;
     162                 :            : 
     163                 :            :       /* Let's create a new ticket... */
     164                 :            : 
     165                 :          2 :       rc = shishi_tkt (handle, &tkt);
     166         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     167                 :          0 :         return rc;
     168                 :            : 
     169                 :          2 :       shishi_tkt_ticket_set (tkt, ticket);
     170                 :            : 
     171                 :            :       {
     172                 :            :         const char *cname[CCACHE_MAX_COMPONENTS + 1];
     173                 :            :         size_t i;
     174                 :            : 
     175 [ +  + ][ +  - ]:          4 :         for (i = 0; i < cred.client.num_components
     176                 :          2 :              && i < CCACHE_MAX_COMPONENTS; i++)
     177                 :          2 :           cname[i] = cred.client.components[i].data;
     178                 :          2 :         cname[i] = NULL;
     179                 :            : 
     180                 :          2 :         rc = shishi_kdcrep_crealm_set (handle,
     181                 :            :                                        shishi_tkt_kdcrep (tkt),
     182                 :          2 :                                        cred.client.realm.data);
     183         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     184                 :          0 :           return rc;
     185                 :            : 
     186                 :          2 :         rc = shishi_kdcrep_cname_set (handle,
     187                 :            :                                       shishi_tkt_kdcrep (tkt),
     188                 :          2 :                                       cred.client.name_type, cname);
     189         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     190                 :          0 :           return rc;
     191                 :            :       }
     192                 :            : 
     193                 :            :       {
     194                 :            :         char *sname[CCACHE_MAX_COMPONENTS + 1];
     195                 :            :         size_t i;
     196                 :            : 
     197 [ +  + ][ +  - ]:          6 :         for (i = 0; i < cred.server.num_components
     198                 :          4 :              && i < CCACHE_MAX_COMPONENTS; i++)
     199                 :          4 :           sname[i] = cred.server.components[i].data;
     200                 :          2 :         sname[i] = NULL;
     201                 :            : 
     202                 :          2 :         rc = shishi_enckdcreppart_srealm_set (handle,
     203                 :            :                                               shishi_tkt_enckdcreppart (tkt),
     204                 :          2 :                                               cred.server.realm.data);
     205         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     206                 :          0 :           return rc;
     207                 :            : 
     208                 :          2 :         rc = shishi_enckdcreppart_sname_set (handle,
     209                 :            :                                              shishi_tkt_enckdcreppart (tkt),
     210                 :          2 :                                              cred.server.name_type, sname);
     211         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     212                 :          0 :           return rc;
     213                 :            :       }
     214                 :            : 
     215                 :          2 :       rc = shishi_tkt_flags_set (tkt, cred.tktflags);
     216         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     217                 :          0 :         return rc;
     218                 :            : 
     219                 :          2 :       rc = shishi_enckdcreppart_authtime_set
     220                 :            :         (handle,
     221                 :            :          shishi_tkt_enckdcreppart (tkt),
     222                 :          2 :          shishi_generalize_time (handle, cred.authtime));
     223         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     224                 :          0 :         return rc;
     225                 :            : 
     226         [ +  - ]:          4 :       rc = shishi_enckdcreppart_starttime_set
     227                 :            :         (handle,
     228                 :            :          shishi_tkt_enckdcreppart (tkt),
     229                 :          2 :          cred.starttime ? shishi_generalize_time (handle, cred.starttime)
     230                 :            :          : NULL);
     231         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     232                 :          0 :         return rc;
     233                 :            : 
     234                 :          2 :       rc = shishi_enckdcreppart_endtime_set
     235                 :            :         (handle,
     236                 :            :          shishi_tkt_enckdcreppart (tkt),
     237                 :          2 :          shishi_generalize_time (handle, cred.endtime));
     238         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     239                 :          0 :         return rc;
     240                 :            : 
     241         [ -  + ]:          2 :       rc = shishi_enckdcreppart_renew_till_set
     242                 :            :         (handle,
     243                 :            :          shishi_tkt_enckdcreppart (tkt),
     244                 :          0 :          cred.renew_till ? shishi_generalize_time (handle, cred.renew_till)
     245                 :            :          : NULL);
     246         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     247                 :          0 :         return rc;
     248                 :            : 
     249                 :            :       {
     250                 :          2 :         uint32_t nonce = 0;
     251                 :          2 :         rc = shishi_enckdcreppart_nonce_set (handle,
     252                 :            :                                              shishi_tkt_enckdcreppart (tkt),
     253                 :            :                                              nonce);
     254         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     255                 :          0 :           return rc;
     256                 :            :       }
     257                 :            : 
     258                 :          2 :       rc = shishi_kdcrep_set_ticket (handle, shishi_tkt_kdcrep (tkt),
     259                 :            :                                      shishi_tkt_ticket (tkt));
     260         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     261                 :          0 :         return rc;
     262                 :            : 
     263                 :          2 :       rc = shishi_kdcrep_set_enc_part (handle, shishi_tkt_kdcrep (tkt),
     264                 :            :                                        0, 0, "", 0);
     265         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     266                 :          0 :         return rc;
     267                 :            : 
     268                 :            :       /* Add key. */
     269                 :            : 
     270                 :            :       {
     271                 :            :         Shishi_key *key;
     272                 :            : 
     273                 :          2 :         rc = shishi_key (handle, &key);
     274         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     275                 :          0 :           return rc;
     276                 :            : 
     277                 :          2 :         shishi_key_type_set (key, cred.key.keytype);
     278                 :          2 :         shishi_key_value_set (key, cred.key.keyvalue);
     279                 :          2 :         rc = shishi_tkt_key_set (tkt, key);
     280         [ -  + ]:          2 :         if (rc != SHISHI_OK)
     281                 :          0 :           return rc;
     282                 :            : 
     283                 :          2 :         shishi_key_done (key);
     284                 :            :       }
     285                 :            : 
     286                 :            :       /* Add new ticket to the set... */
     287                 :            : 
     288                 :          2 :       rc = shishi_tkts_add (tkts, tkt);
     289         [ -  + ]:          2 :       if (rc != SHISHI_OK)
     290                 :          0 :         return rc;
     291                 :            : 
     292                 :          2 :       ccache.credentials += n;
     293                 :          2 :       ccache.credentialslen -= n;
     294                 :            :     }
     295                 :            : 
     296                 :            : #if 0
     297                 :            :   {
     298                 :            :     char *data;
     299                 :            :     size_t len;
     300                 :            :     rc = shishi_tkts_to_ccache_mem (handle, tkts, &data, &len);
     301                 :            :     printf ("gaah res %d\n", rc);
     302                 :            :   }
     303                 :            : #endif
     304                 :            : 
     305                 :          1 :   return rc;
     306                 :            : }
     307                 :            : 
     308                 :            : /**
     309                 :            :  * shishi_tkts_add_ccache_file:
     310                 :            :  * @handle: shishi handle as allocated by shishi_init().
     311                 :            :  * @filename: name of file to read.
     312                 :            :  * @tkts: allocated ticket set to store tickets in.
     313                 :            :  *
     314                 :            :  * Read tickets from a ccache data structure, and add them to the
     315                 :            :  * ticket set.
     316                 :            :  *
     317                 :            :  * The ccache format is proprietary, and this function support (at
     318                 :            :  * least) the 0x0504 format.  See the section The Credential Cache
     319                 :            :  * Binary File Format in the Shishi manual for a description of the
     320                 :            :  * file format.
     321                 :            :  *
     322                 :            :  * Returns: Returns %SHISHI_IO_ERROR if the file cannot be read,
     323                 :            :  *   %SHISHI_CCACHE_ERROR if the data cannot be parsed as a valid ccache
     324                 :            :  *   structure, and %SHISHI_OK on success.
     325                 :            :  **/
     326                 :            : int
     327                 :          1 : shishi_tkts_add_ccache_file (Shishi * handle,
     328                 :            :                              const char *filename, Shishi_tkts * tkts)
     329                 :            : {
     330                 :            :   size_t len;
     331                 :          1 :   char *ccache = read_binary_file (filename, &len);
     332                 :            :   int rc;
     333                 :            : 
     334         [ -  + ]:          1 :   if (!ccache)
     335                 :          0 :     return SHISHI_IO_ERROR;
     336                 :            : 
     337                 :          1 :   rc = shishi_tkts_add_ccache_mem (handle, ccache, len, tkts);
     338                 :            : 
     339                 :          1 :   free (ccache);
     340                 :            : 
     341                 :          1 :   return rc;
     342                 :            : }
     343                 :            : 
     344                 :            : /**
     345                 :            :  * shishi_tkts_from_ccache_mem:
     346                 :            :  * @handle: shishi handle as allocated by shishi_init().
     347                 :            :  * @data: constant memory buffer with ccache of @len size.
     348                 :            :  * @len: size of memory buffer with ccache data.
     349                 :            :  * @outtkts: pointer to ticket set that will be allocated and populated,
     350                 :            :  *   must be deallocated by caller on succes.
     351                 :            :  *
     352                 :            :  * Read tickets from a ccache data structure, and add them to the
     353                 :            :  * ticket set.
     354                 :            :  *
     355                 :            :  * The ccache format is proprietary, and this function support (at
     356                 :            :  * least) the 0x0504 format.  See the section The Credential Cache
     357                 :            :  * Binary File Format in the Shishi manual for a description of the
     358                 :            :  * file format.
     359                 :            :  *
     360                 :            :  * Returns: Returns %SHISHI_CCACHE_ERROR if the data does not
     361                 :            :  *   represent a valid ccache structure, and %SHISHI_OK on success.
     362                 :            :  **/
     363                 :            : int
     364                 :          0 : shishi_tkts_from_ccache_mem (Shishi * handle,
     365                 :            :                              const char *data, size_t len,
     366                 :            :                              Shishi_tkts ** outtkts)
     367                 :            : {
     368                 :            :   int rc;
     369                 :            : 
     370                 :          0 :   rc = shishi_tkts (handle, outtkts);
     371         [ #  # ]:          0 :   if (rc != SHISHI_OK)
     372                 :          0 :     return rc;
     373                 :            : 
     374                 :          0 :   rc = shishi_tkts_add_ccache_mem (handle, data, len, *outtkts);
     375         [ #  # ]:          0 :   if (rc != SHISHI_OK)
     376                 :            :     {
     377                 :          0 :       shishi_tkts_done (outtkts);
     378                 :          0 :       return rc;
     379                 :            :     }
     380                 :            : 
     381                 :          0 :   return SHISHI_OK;
     382                 :            : }
     383                 :            : 
     384                 :            : /**
     385                 :            :  * shishi_tkts_from_ccache_file:
     386                 :            :  * @handle: shishi handle as allocated by shishi_init().
     387                 :            :  * @filename: name of file to read.
     388                 :            :  * @outtkts: pointer to ticket set that will be allocated and populated,
     389                 :            :  *   must be deallocated by caller on succes.
     390                 :            :  *
     391                 :            :  * Read tickets from a ccache data structure, and add them to the
     392                 :            :  * ticket set.
     393                 :            :  *
     394                 :            :  * The ccache format is proprietary, and this function support (at
     395                 :            :  * least) the 0x0504 format.  See the section The Credential Cache
     396                 :            :  * Binary File Format in the Shishi manual for a description of the
     397                 :            :  * file format.
     398                 :            :  *
     399                 :            :  * Returns: Returns %SHISHI_IO_ERROR if the file cannot be read,
     400                 :            :  *   %SHISHI_CCACHE_ERROR if the data cannot be parsed as a valid ccache
     401                 :            :  *   structure, and %SHISHI_OK on success.
     402                 :            :  **/
     403                 :            : int
     404                 :          1 : shishi_tkts_from_ccache_file (Shishi * handle,
     405                 :            :                               const char *filename, Shishi_tkts ** outtkts)
     406                 :            : {
     407                 :            :   int rc;
     408                 :            : 
     409                 :          1 :   rc = shishi_tkts (handle, outtkts);
     410         [ -  + ]:          1 :   if (rc != SHISHI_OK)
     411                 :          0 :     return rc;
     412                 :            : 
     413                 :          1 :   rc = shishi_tkts_add_ccache_file (handle, filename, *outtkts);
     414         [ -  + ]:          1 :   if (rc != SHISHI_OK)
     415                 :            :     {
     416                 :          0 :       shishi_tkts_done (outtkts);
     417                 :          0 :       return rc;
     418                 :            :     }
     419                 :            : 
     420                 :          1 :   return SHISHI_OK;
     421                 :            : }
     422                 :            : 
     423                 :            : extern int
     424                 :            : shishi_tkt_to_ccache_mem (Shishi * handle, Shishi_tkt * tkt,
     425                 :            :                           char **data, size_t * len);
     426                 :            : 
     427                 :            : int
     428                 :          0 : shishi_tkt_to_ccache_mem (Shishi * handle,
     429                 :            :                           Shishi_tkt * tkt, char **data, size_t * len)
     430                 :            : {
     431                 :            : #if 0
     432                 :            :   struct ccache_credential cred;
     433                 :            :   char tmp[1024];
     434                 :            :   size_t i;
     435                 :            :   int rc;
     436                 :            : 
     437                 :            :   memset (&cred, 0, sizeof (cred));
     438                 :            : 
     439                 :            :   rc = shishi_asn1_to_der (handle, shishi_tkt_ticket (tkt),
     440                 :            :                            &cred.ticket.data, &cred.ticket.length);
     441                 :            :   if (rc != SHISHI_OK)
     442                 :            :     return rc;
     443                 :            : 
     444                 :            :   /* Sanity check credential first. */
     445                 :            : 
     446                 :            :   if (shishi_key_length (shishi_tkt_key (tkt)) > CCACHE_MAX_KEYLEN)
     447                 :            :     return SHISHI_CCACHE_ERROR;
     448                 :            : 
     449                 :            :   rc = shishi_asn1_read (handle, shishi_tkt_kdcrep (tkt), "crealm",
     450                 :            :                          &cred.client.realm.data, &cred.client.realm.length);
     451                 :            :   if (rc != SHISHI_OK)
     452                 :            :     return rc;
     453                 :            : 
     454                 :            :   rc = shishi_asn1_read (handle, shishi_tkt_enckdcreppart (tkt), "srealm",
     455                 :            :                          &cred.server.realm.data, &cred.server.realm.length);
     456                 :            :   if (rc != SHISHI_OK)
     457                 :            :     return rc;
     458                 :            : 
     459                 :            :   return SHISHI_OK;
     460                 :            : 
     461                 :            : #if 0
     462                 :            :   {
     463                 :            :     char *cname[CCACHE_MAX_COMPONENTS + 1];
     464                 :            :     size_t i;
     465                 :            : 
     466                 :            :     for (i = 0; i < cred.client.num_components
     467                 :            :          && i < CCACHE_MAX_COMPONENTS; i++)
     468                 :            :       cname[i] = cred.client.components[i].data;
     469                 :            :     cname[i] = NULL;
     470                 :            : 
     471                 :            :     rc = shishi_kdcrep_crealm_set (handle,
     472                 :            :                                    shishi_tkt_kdcrep (tkt),
     473                 :            :                                    cred.client.realm.data);
     474                 :            :     if (rc != SHISHI_OK)
     475                 :            :       return rc;
     476                 :            : 
     477                 :            :     rc = shishi_kdcrep_cname_set (handle,
     478                 :            :                                   shishi_tkt_kdcrep (tkt),
     479                 :            :                                   cred.client.name_type, cname);
     480                 :            :     if (rc != SHISHI_OK)
     481                 :            :       return rc;
     482                 :            :   }
     483                 :            : 
     484                 :            :   {
     485                 :            :     char *sname[CCACHE_MAX_COMPONENTS + 1];
     486                 :            :     size_t i;
     487                 :            : 
     488                 :            :     for (i = 0; i < cred.server.num_components
     489                 :            :          && i < CCACHE_MAX_COMPONENTS; i++)
     490                 :            :       sname[i] = cred.server.components[i].data;
     491                 :            :     sname[i] = NULL;
     492                 :            : 
     493                 :            :     rc = shishi_enckdcreppart_srealm_set (handle,
     494                 :            :                                           shishi_tkt_enckdcreppart (tkt),
     495                 :            :                                           cred.server.realm.data);
     496                 :            :     if (rc != SHISHI_OK)
     497                 :            :       return rc;
     498                 :            : 
     499                 :            :     rc = shishi_enckdcreppart_sname_set (handle,
     500                 :            :                                          shishi_tkt_enckdcreppart (tkt),
     501                 :            :                                          cred.server.name_type, sname);
     502                 :            :     if (rc != SHISHI_OK)
     503                 :            :       return rc;
     504                 :            :   }
     505                 :            : #endif
     506                 :            : 
     507                 :            :   rc = shishi_tkt_flags (tkt, &cred.tktflags);
     508                 :            :   if (rc != SHISHI_OK)
     509                 :            :     return rc;
     510                 :            : 
     511                 :            :   {
     512                 :            :     time_t t;
     513                 :            :     rc = shishi_ctime (handle, shishi_tkt_enckdcreppart (tkt),
     514                 :            :                        "authtime", &t);
     515                 :            :     if (rc != SHISHI_OK)
     516                 :            :       return rc;
     517                 :            :     cred.authtime = t;
     518                 :            :   }
     519                 :            : 
     520                 :            :   {
     521                 :            :     time_t t;
     522                 :            :     rc = shishi_ctime (handle, shishi_tkt_enckdcreppart (tkt),
     523                 :            :                        "starttime", &t);
     524                 :            :     if (rc == SHISHI_ASN1_NO_ELEMENT)
     525                 :            :       cred.starttime = 0;
     526                 :            :     else if (rc != SHISHI_OK)
     527                 :            :       return rc;
     528                 :            :     cred.starttime = t;
     529                 :            :   }
     530                 :            : 
     531                 :            :   {
     532                 :            :     time_t t;
     533                 :            :     rc = shishi_ctime (handle, shishi_tkt_enckdcreppart (tkt), "endtime", &t);
     534                 :            :     if (rc != SHISHI_OK)
     535                 :            :       return rc;
     536                 :            :     cred.endtime = t;
     537                 :            :   }
     538                 :            : 
     539                 :            :   {
     540                 :            :     time_t t;
     541                 :            :     rc = shishi_ctime (handle, shishi_tkt_enckdcreppart (tkt),
     542                 :            :                        "renew-till", &t);
     543                 :            :     if (rc == SHISHI_ASN1_NO_ELEMENT)
     544                 :            :       cred.renew_till = 0;
     545                 :            :     else if (rc != SHISHI_OK)
     546                 :            :       return rc;
     547                 :            :     cred.renew_till = t;
     548                 :            :   }
     549                 :            : 
     550                 :            :   cred.key.keylen = shishi_key_length (shishi_tkt_key (tkt));
     551                 :            :   cred.key.keytype = shishi_key_type (shishi_tkt_key (tkt));
     552                 :            :   memcpy (cred.key.storage, shishi_key_value (shishi_tkt_key (tkt)),
     553                 :            :           shishi_key_length (shishi_tkt_key (tkt)));
     554                 :            :   cred.key.keyvalue = &cred.key.storage[0];
     555                 :            : 
     556                 :            :   i = 1024;
     557                 :            :   rc = ccache_pack_credential (&cred, tmp, &i);
     558                 :            :   printf ("rc %d len %d\n", rc, i);
     559                 :            : 
     560                 :            :   {
     561                 :            :     struct ccache_credential foo;
     562                 :            :     size_t n;
     563                 :            : 
     564                 :            :     rc = ccache_parse_credential (tmp, i, &foo, &n);
     565                 :            :     if (rc < 0)
     566                 :            :       return SHISHI_CCACHE_ERROR;
     567                 :            : 
     568                 :            :     printf ("packed:");
     569                 :            :     ccache_print_credential (&foo);
     570                 :            :   }
     571                 :            :   _shishi_escapeprint (tmp, i);
     572                 :            : #endif
     573                 :            : 
     574                 :          0 :   return SHISHI_CCACHE_ERROR;
     575                 :            : }
     576                 :            : 
     577                 :            : extern int
     578                 :            : shishi_tkts_to_ccache_mem (Shishi * handle, Shishi_tkts * tkts,
     579                 :            :                            char **data, size_t * len);
     580                 :            : 
     581                 :            : int
     582                 :          0 : shishi_tkts_to_ccache_mem (Shishi * handle,
     583                 :            :                            Shishi_tkts * tkts, char **data, size_t * len)
     584                 :            : {
     585                 :          0 :   return SHISHI_CCACHE_ERROR;
     586                 :            : 
     587                 :            : #if 0
     588                 :            :   struct ccache info;
     589                 :            :   int rc = SHISHI_OK;
     590                 :            :   size_t i;
     591                 :            : 
     592                 :            :   for (i = 0; i < shishi_tkts_size (tkts); i++)
     593                 :            :     {
     594                 :            :       Shishi_tkt *tkt = shishi_tkts_nth (tkts, i);
     595                 :            :       struct ccache_credential cred;
     596                 :            : 
     597                 :            :       printf ("ccache %d\n", i);
     598                 :            : 
     599                 :            :       if (!tkt)
     600                 :            :         return SHISHI_INVALID_TKTS;
     601                 :            : 
     602                 :            :       rc = shishi_tkt_to_ccache_mem (handle, tkt, data, len);
     603                 :            :       printf ("f %d\n", rc);
     604                 :            :     }
     605                 :            : 
     606                 :            :   memset (&info, 0, sizeof (info));
     607                 :            : 
     608                 :            :   rc = ccache_pack (&info, *data, *len);
     609                 :            :   printf ("pack res %d len %d\n", rc, *len);
     610                 :            : 
     611                 :            :   return rc;
     612                 :            : #endif
     613                 :            : }

Generated by: LCOV version 1.8