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 it
   6      under the terms of the GNU Affero General Public License as published
   7      by the Free Software Foundation, either version 3 of the License,
   8      or (at your 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      Affero General Public License for more details.
  14
  15      You should have received a copy of the GNU Affero General Public License
  16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18      SPDX-License-Identifier: AGPL3.0-or-later
  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 */