Repository navigation
Expand file tree
/
Copy pathkeydb.cpp
More file actions
124 lines (113 loc) · 2.9 KB
/
Copy pathkeydb.cpp
File metadata and controls
124 lines (113 loc) · 2.9 KB
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
#include "keydb.h"
#include <string.h>
#include <stdlib.h>
#include <errno.h>
#include <time.h>
/*
Open keys.tdb. EBUSY can happen briefly when a concurrent transaction
(keydb.py, the web admin) holds the open lock; retry with a short
backoff like conn_db_open() does so a transient collision doesn't
fail a reload or a signing-key load.
*/
TDB_CONTEXT *db_open(void)
{
static const struct timespec backoffs[] = {
{0, 0},
{0, 10 * 1000 * 1000}, // 10ms
{0, 50 * 1000 * 1000},
{0, 100 * 1000 * 1000},
{0, 250 * 1000 * 1000},
};
for (size_t i = 0; i < sizeof(backoffs) / sizeof(backoffs[0]); i++) {
if (i > 0) {
nanosleep(&backoffs[i], nullptr);
}
auto *db = tdb_open(KEY_FILE, 1000, 0, O_RDWR | O_CREAT, 0600);
if (db != nullptr) {
return db;
}
if (errno != EBUSY) {
return nullptr;
}
}
return nullptr;
}
TDB_CONTEXT *db_open_transaction(void)
{
auto *db = db_open();
if (db == nullptr) {
return db;
}
if (tdb_transaction_start(db) != 0) {
tdb_close(db);
return nullptr;
}
return db;
}
void db_close(TDB_CONTEXT *db)
{
tdb_close(db);
}
void db_close_cancel(TDB_CONTEXT *db)
{
tdb_transaction_cancel(db);
db_close(db);
}
void db_close_commit(TDB_CONTEXT *db)
{
tdb_transaction_prepare_commit(db);
tdb_transaction_commit(db);
db_close(db);
}
bool db_load_key(TDB_CONTEXT *db, int port2, struct KeyEntry &key)
{
TDB_DATA k;
k.dptr = (uint8_t *)&port2;
k.dsize = sizeof(int);
auto d = tdb_fetch(db, k);
if (d.dptr == nullptr || d.dsize < KEYENTRY_MIN_SIZE) {
if (d.dptr) {
free(d.dptr);
}
return false;
}
// zero-init so fields not present in older on-disk layouts default to 0
memset(&key, 0, sizeof(key));
size_t copy = d.dsize < sizeof(key) ? d.dsize : sizeof(key);
memcpy(&key, d.dptr, copy);
free(d.dptr);
return key.magic == KEY_MAGIC;
}
bool db_save_key(TDB_CONTEXT *tdb, int port2, const struct KeyEntry &ke)
{
TDB_DATA k;
k.dptr = (uint8_t*)&port2;
k.dsize = sizeof(int);
// preserve any trailing bytes the on-disk record has beyond our struct
auto orig = tdb_fetch(tdb, k);
size_t tail = 0;
if (orig.dptr != nullptr && orig.dsize > sizeof(ke)) {
tail = orig.dsize - sizeof(ke);
}
size_t total = sizeof(ke) + tail;
uint8_t *buf = (uint8_t*)malloc(total);
if (buf == nullptr) {
if (orig.dptr) {
free(orig.dptr);
}
return false;
}
memcpy(buf, &ke, sizeof(ke));
if (tail > 0) {
memcpy(buf + sizeof(ke), orig.dptr + sizeof(ke), tail);
}
if (orig.dptr) {
free(orig.dptr);
}
TDB_DATA d;
d.dptr = buf;
d.dsize = total;
bool ok = tdb_store(tdb, k, d, TDB_REPLACE) == 0;
free(buf);
return ok;
}