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
  47                                            GNUNET_CREDENTIAL_DelegationSet *dsr);
  48
  49 /**
  50  * Serizalize the given delegation record entries
  51  *
  52  * @param d_count number of delegation chain entries
  53  * @param dsr array of #GNUNET_CREDENTIAL_Delegation
  54  * @param dest_size size of the destination
  55  * @param dest where to store the result
  56  * @return the size of the data, -1 on failure
  57  */
  58 ssize_t
  59 GNUNET_CREDENTIAL_delegation_set_serialize (unsigned int d_count,
  60                                             const struct
  61                                             GNUNET_CREDENTIAL_DelegationSet *dsr,
  62                                             size_t dest_size,
  63                                             char *dest);
  64
  65
  66 /**
  67  * Deserialize the given destination
  68  *
  69  * @param len size of the serialized delegation recird
  70  * @param src the serialized data
  71  * @param d_count the number of delegation chain entries
  72  * @param dsr where to put the delegation chain entries
  73  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
  74  */
  75 int
  76 GNUNET_CREDENTIAL_delegation_set_deserialize (size_t len,
  77                                               const char *src,
  78                                               unsigned int d_count,
  79                                               struct
  80                                               GNUNET_CREDENTIAL_DelegationSet *
  81                                               dsr);
  82
  83 /**
  84  * Calculate how many bytes we will need to serialize
  85  * the given delegation chain and credential
  86  *
  87  * @param d_count number of delegation chain entries
  88  * @param dd array of #GNUNET_CREDENTIAL_Delegation
  89  * @param c_count number of credential entries
  90  * @param cd a #GNUNET_CREDENTIAL_Credential
  91  * @return the required size to serialize
  92  */
  93 size_t
  94 GNUNET_CREDENTIAL_delegation_chain_get_size (unsigned int d_count,
  95                                              const struct
  96                                              GNUNET_CREDENTIAL_Delegation *dd,
  97                                              unsigned int c_count,
  98                                              const struct
  99                                              GNUNET_CREDENTIAL_Credential *cd);
 100
 101 /**
 102  * Serizalize the given delegation chain entries and credential
 103  *
 104  * @param d_count number of delegation chain entries
 105  * @param dd array of #GNUNET_CREDENTIAL_Delegation
 106  * @param c_count number of credential entries
 107  * @param cd a #GNUNET_CREDENTIAL_Credential
 108  * @param dest_size size of the destination
 109  * @param dest where to store the result
 110  * @return the size of the data, -1 on failure
 111  */
 112 ssize_t
 113 GNUNET_CREDENTIAL_delegation_chain_serialize (unsigned int d_count,
 114                                               const struct
 115                                               GNUNET_CREDENTIAL_Delegation *dd,
 116                                               unsigned int c_count,
 117                                               const struct
 118                                               GNUNET_CREDENTIAL_Credential *cd,
 119                                               size_t dest_size,
 120                                               char *dest);
 121
 122
 123 /**
 124  * Deserialize the given destination
 125  *
 126  * @param len size of the serialized delegation chain and cred
 127  * @param src the serialized data
 128  * @param d_count the number of delegation chain entries
 129  * @param dd where to put the delegation chain entries
 130  * @param c_count number of credential entries
 131  * @param cd where to put the credential data
 132  * @return #GNUNET_OK on success, #GNUNET_SYSERR on error
 133  */
 134 int
 135 GNUNET_CREDENTIAL_delegation_chain_deserialize (size_t len,
 136                                                 const char *src,
 137                                                 unsigned int d_count,
 138                                                 struct
 139                                                 GNUNET_CREDENTIAL_Delegation *dd,
 140                                                 unsigned int c_count,
 141                                                 struct
 142                                                 GNUNET_CREDENTIAL_Credential *cd);
 143 size_t
 144 GNUNET_CREDENTIAL_credentials_get_size (unsigned int c_count,
 145                                         const struct
 146                                         GNUNET_CREDENTIAL_Credential *cd);
 147
 148 ssize_t
 149 GNUNET_CREDENTIAL_credentials_serialize (unsigned int c_count,
 150                                          const struct
 151                                          GNUNET_CREDENTIAL_Credential *cd,
 152                                          size_t dest_size,
 153                                          char *dest);
 154
 155
 156 int
 157 GNUNET_CREDENTIAL_credentials_deserialize (size_t len,
 158                                            const char *src,
 159                                            unsigned int c_count,
 160                                            struct GNUNET_CREDENTIAL_Credential *
 161                                            cd);
 162
 163
 164 int
 165 GNUNET_CREDENTIAL_credential_serialize (struct
 166                                         GNUNET_CREDENTIAL_Credential *cred,
 167                                         char **data);
 168
 169 struct GNUNET_CREDENTIAL_Credential*
 170 GNUNET_CREDENTIAL_credential_deserialize (const char*data,
 171                                           size_t data_size);
 172 #endif
 173 /* end of credential_serialization.h */