bee2-rs 0.2.1

Bindings for cryptographic library Bee2
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

/*
*******************************************************************************
\file blob.c
\brief Blobs
\project bee2 [cryptographic library]
\created 2012.04.01
\version 2023.03.23
\copyright The Bee2 authors
\license Licensed under the Apache License, Version 2.0 (see LICENSE.txt).
*******************************************************************************
*/

#include "bee2/core/blob.h"
#include "bee2/core/mem.h"
#include "bee2/core/util.h"

/*
*******************************************************************************
Блоб: реализация

В куче выделяется память под указатель ptr. Память выделяется страницами.

Первые sizeof(size_t) октетов по адресу ptr --- размер блоба,
следующие октеты --- собственно блоб.

\todo Обеспечить защиту памяти блоба от утечек.

\todo Полноценная проверка корректности блоба.
*******************************************************************************
*/

// память для блобов выделяется страницами
#define BLOB_PAGE_SIZE 1024

// требуется страниц
#define blobPageCount(size)\
	(((size) + sizeof(size_t) + BLOB_PAGE_SIZE - 1) / BLOB_PAGE_SIZE)

// требуется памяти на страницах
#define blobActualSize(size)\
	(blobPageCount(size) * BLOB_PAGE_SIZE)

// heap-указатель для блоба
#define blobPtrOf(blob) ((size_t*)blob - 1)

// размер блоба
#define blobSizeOf(blob) (*blobPtrOf(blob))

// страничный размер блоба
#define blobActualSizeOf(blob) (blobActualSize(blobSizeOf(blob)))

// блоб для heap-указателя
#define blobValueOf(ptr) ((blob_t)((size_t*)ptr + 1))

blob_t blobCreate(size_t size)
{
	size_t* ptr;
	if (size == 0)
		return 0;
	ptr = (size_t*)memAlloc(blobActualSize(size));
	if (ptr == 0)
		return 0;
	*ptr = size;
	memSetZero(blobValueOf(ptr), size);
	return blobValueOf(ptr);
}

bool_t blobIsValid(const blob_t blob)
{
	return blob == 0 || memIsValid(blobPtrOf(blob), blobActualSizeOf(blob));
}

void blobWipe(blob_t blob)
{
	ASSERT(blobIsValid(blob));
	if (blob != 0)
		memWipe(blob, blobSizeOf(blob));
}

void blobClose(blob_t blob)
{
	ASSERT(blobIsValid(blob));
	if (blob)
	{
		memWipe(blobPtrOf(blob), blobActualSizeOf(blob));
		memFree(blobPtrOf(blob));
	}
}

blob_t blobResize(blob_t blob, size_t size)
{
	size_t old_size;
	size_t* ptr;
	// pre
	ASSERT(blobIsValid(blob));
	// создать блоб
	if (blob == 0)
		return blobCreate(size);
	// освободить блоб
	if (size == 0)
	{
		blobClose(blob);
		return 0;
	}
	// сохранить размер
	old_size = blobSizeOf(blob);
	// перераспределить память?
	ptr = blobPtrOf(blob);
	if (blobActualSizeOf(blob) != blobActualSize(size))
	{
		ptr = (size_t*)memRealloc(ptr, blobActualSize(size));
		if (ptr == 0)
			return 0;
	}
	// настроить и возвратить блоб
	*ptr = size;
	blob = blobValueOf(ptr);
	if (size > old_size)
		memSetZero((octet*)blob + old_size, size - old_size);
	return blob;
}

size_t blobSize(const blob_t blob)
{
	ASSERT(blobIsValid(blob));
	return blob == 0 ? 0 : blobSizeOf(blob);
}

blob_t blobCopy(blob_t dest, const blob_t src)
{
	size_t size;
	ASSERT(blobIsValid(dest) && blobIsValid(src));
	if (dest == src)
		return dest;
	size = blobSize(src);
	dest = blobResize(dest, size);
	if (dest)
		memCopy(dest, src, size);
	return dest;
}

bool_t blobEq(const blob_t blob1, const blob_t blob2)
{
	ASSERT(blobIsValid(blob1) && blobIsValid(blob2));
	return blobSize(blob1) == blobSize(blob2) &&
		memEq(blob1, blob2, blobSize(blob1));
}

int blobCmp(const blob_t blob1, const blob_t blob2)
{
	ASSERT(blobIsValid(blob1) && blobIsValid(blob2));
	if (blobSize(blob1) != blobSize(blob2))
		return blobSize(blob1) < blobSize(blob2) ? - 1 : 1;
	return memCmp(blob1, blob2, blobSize(blob1));
}