84 lines
3.1 KiB
C
84 lines
3.1 KiB
C
// Copyright 2021 Google LLC
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
|
// use this file except in compliance with the License. You may obtain a copy of
|
|
// the License at
|
|
//
|
|
// https://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
// License for the specific language governing permissions and limitations under
|
|
// the License.
|
|
|
|
#ifndef DICE_CBOR_WRITER_H_
|
|
#define DICE_CBOR_WRITER_H_
|
|
|
|
#include <stdbool.h>
|
|
#include <stddef.h>
|
|
#include <stdint.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
struct CborOut {
|
|
uint8_t* buffer;
|
|
size_t buffer_size;
|
|
size_t cursor;
|
|
};
|
|
|
|
// Initializes an output stream for writing CBOR tokens.
|
|
static inline void CborOutInit(uint8_t* buffer, size_t buffer_size,
|
|
struct CborOut* out) {
|
|
out->buffer = buffer;
|
|
out->buffer_size = buffer_size;
|
|
out->cursor = 0;
|
|
}
|
|
|
|
// Returns the number of bytes of encoded data. If |CborOutOverflowed()|
|
|
// returns false, this number of bytes have been written, otherwise, this is the
|
|
// number of bytes that that would have been written had there been space.
|
|
static inline size_t CborOutSize(const struct CborOut* out) {
|
|
return out->cursor;
|
|
}
|
|
|
|
// Returns whether the |out| buffer contains the encoded tokens written to it or
|
|
// whether the encoded tokens did not fit and the contents of the buffer should
|
|
// be considered invalid.
|
|
static inline bool CborOutOverflowed(const struct CborOut* out) {
|
|
return out->cursor == SIZE_MAX || out->cursor > out->buffer_size;
|
|
}
|
|
|
|
// These functions write simple deterministically encoded CBOR tokens to an
|
|
// output buffer. The offset is always increased, even if there is not enough
|
|
// space in the output buffer to allow for measurement of the encoded data.
|
|
// Use |CborOutOverflowed()| to check whether or not the buffer successfully
|
|
// contains all of the of the encoded data.
|
|
//
|
|
// Complex types are constructed from these simple types, see RFC 8949. The
|
|
// caller is responsible for correct and deterministic encoding of complex
|
|
// types.
|
|
void CborWriteInt(int64_t val, struct CborOut* out);
|
|
void CborWriteUint(uint64_t val, struct CborOut* out);
|
|
void CborWriteBstr(size_t data_size, const uint8_t* data, struct CborOut* out);
|
|
void CborWriteTstr(const char* str, struct CborOut* out);
|
|
void CborWriteArray(size_t num_elements, struct CborOut* out);
|
|
void CborWriteMap(size_t num_pairs, struct CborOut* out);
|
|
void CborWriteFalse(struct CborOut* out);
|
|
void CborWriteTrue(struct CborOut* out);
|
|
void CborWriteNull(struct CborOut* out);
|
|
|
|
// These functions write the type header and reserve space for the caller to
|
|
// populate. The reserved space is left uninitialized. Returns NULL if space
|
|
// could not be reserved in the output buffer.
|
|
uint8_t* CborAllocBstr(size_t data_size, struct CborOut* out);
|
|
char* CborAllocTstr(size_t size, struct CborOut* out);
|
|
|
|
#ifdef __cplusplus
|
|
} // extern "C"
|
|
#endif
|
|
|
|
#endif // DICE_CBOR_WRITER_H_
|