src/credential/credential_serialization.h

   1 /*
   2      This file is part of GNUnet.
   3      Copyright (C) 2009-2013, 2016 GNUnet e.V.
   4
   5      GNUnet is free software; you can redistribute it and/or modify
   6      it under the terms of the GNU General Public License as published
   7      by the Free Software Foundation; either version 3, or (at your
   8      option) any later version.
   9
  10      GNUnet is distributed in the hope that it will be useful, but
  11      WITHOUT ANY WARRANTY; without even the implied warranty of
  12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13      General Public License for more details.
  14
  15      You should have received a copy of the GNU General Public License
  16      along with GNUnet; see the file COPYING.  If not, write to the
  17      Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  18      Boston, MA 02110-1301, USA.
  19 */
  20
  21
  22 /**
  23  * @file credential/credential_serialization.h
  24  * @brief API to serialize and deserialize delegation chains
  25  * and credentials
  26  * @author Martin Schanzenbach
  27  */
  28 #ifndef CREDENTIAL_SERIALIZATION_H
  29 #define CREDENTIAL_SERIALIZATION_H
  30
  31 #include "platform.h"
  32 #include "gnunet_util_lib.h"
  33 #include "gnunet_constants.h"
  34 #include "gnunet_credential_service.h"
  35
  36 /**
  37  * Calculate how many bytes we will need to serialize
  38  * the given delegation record
  39  *
  40  * @param ds_count number of delegation chain entries
  41  * @param dsr array of #GNUNET_CREDENTIAL_Delegation
  42  * @return the required size to serialize
  43  */
  44 size_t
  45 GNUNET_CREDENTIAL_delegation_set_get_size (unsigned int ds_count,
  46                                            const struct GNUNET_CREDENTIAL_DelegationSet *dsr);
  47
  48 /**
  49  * Serizalize the given delegation record entries
  50  *
  51  * @param d_count number of delegation chain entries
  52  * @param dsr array of #GNUNET_CREDENTIAL_Delegation
  53  * @param dest_size size of the destination
  54  * @param dest where to store the result
  55  * @return the size of the data, -1 on failure
  56  */
  57 ssize_t
  58 GNUNET_CREDENTIAL_delegation_set_serialize (unsigned int d_count,
  59                                             const struct GNUNET_CREDENTIAL_DelegationSet *dsr,
  60                                             size_t dest_size,
  61                                             char *dest);
  62
  63
  64 /**
  65  * Deserialize the given destination
  66  *
  67  * @param len size of the serialized delegation recird
  68  * @param src the serialized data
  69  * @param d_count the number of delegation chain entries
  70  * @param dsr where to put the delegation chain entries
  71  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  72  */
  73 int
  74 GNUNET_CREDENTIAL_delegation_set_deserialize (size_t len,
  75                                               const char *src,
  76                                               unsigned int d_count,
  77                                               struct GNUNET_CREDENTIAL_DelegationSet *dsr);
  78
  79   /**
  80    * Calculate how many bytes we will need to serialize
  81    * the given delegation chain and credential
  82    *
  83    * @param d_count number of delegation chain entries
  84    * @param dd array of #GNUNET_CREDENTIAL_Delegation
  85    * @param c_count number of credential entries
  86    * @param cd a #GNUNET_CREDENTIAL_Credential
  87    * @return the required size to serialize
  88    */
  89   size_t
  90     GNUNET_CREDENTIAL_delegation_chain_get_size (unsigned int d_count,
  91                                                  const struct GNUNET_CREDENTIAL_Delegation *dd,
  92                                                  unsigned int c_count,
  93                                                  const struct GNUNET_CREDENTIAL_Credential *cd);
  94
  95   /**
  96    * Serizalize the given delegation chain entries and credential
  97    *
  98    * @param d_count number of delegation chain entries
  99    * @param dd array of #GNUNET_CREDENTIAL_Delegation
 100    * @param c_count number of credential entries
 101    * @param cd a #GNUNET_CREDENTIAL_Credential
 102    * @param dest_size size of the destination
 103    * @param dest where to store the result
 104    * @return the size of the data, -1 on failure
 105    */
 106   ssize_t
 107     GNUNET_CREDENTIAL_delegation_chain_serialize (unsigned int d_count,
 108                                                   const struct GNUNET_CREDENTIAL_Delegation *dd,
 109                                                   unsigned int c_count,
 110                                                   const struct GNUNET_CREDENTIAL_Credential *cd,
 111                                                   size_t dest_size,
 112                                                   char *dest);
 113
 114
 115   /**
 116    * Deserialize the given destination
 117    *
 118    * @param len size of the serialized delegation chain and cred
 119    * @param src the serialized data
 120    * @param d_count the number of delegation chain entries
 121    * @param dd where to put the delegation chain entries
 122    * @param c_count number of credential entries
 123    * @param cd where to put the credential data
 124    * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 125    */
 126   int
 127     GNUNET_CREDENTIAL_delegation_chain_deserialize (size_t len,
 128                                                     const char *src,
 129                                                     unsigned int d_count,
 130                                                     struct GNUNET_CREDENTIAL_Delegation *dd,
 131                                                     unsigned int c_count,
 132                                                     struct GNUNET_CREDENTIAL_Credential *cd);
 133   size_t
 134   GNUNET_CREDENTIAL_credentials_get_size (unsigned int c_count,
 135                                           const struct GNUNET_CREDENTIAL_Credential *cd);
 136
 137 ssize_t
 138 GNUNET_CREDENTIAL_credentials_serialize (unsigned int c_count,
 139                                          const struct GNUNET_CREDENTIAL_Credential *cd,
 140                                          size_t dest_size,
 141                                          char *dest);
 142
 143
 144 int
 145 GNUNET_CREDENTIAL_credentials_deserialize (size_t len,
 146                                            const char *src,
 147                                            unsigned int c_count,
 148                                            struct GNUNET_CREDENTIAL_Credential *cd);
 149
 150
 151 int
 152 GNUNET_CREDENTIAL_credential_serialize (struct GNUNET_CREDENTIAL_Credential *cred,
 153                                         char **data);
 154
 155 struct GNUNET_CREDENTIAL_Credential*
 156 GNUNET_CREDENTIAL_credential_deserialize (const char* data,
 157                                           size_t data_size);
 158 #endif
 159 /* end of credential_serialization.h */