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
156
157
158
|
/*
* Copyright (c) 2002-2013 Balabit
* Copyright (c) 2013 Viktor Juhasz
* Copyright (c) 2013 Viktor Tusa
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
* As an additional exemption you are allowed to compile & link against the
* OpenSSL libraries as published by the OpenSSL project. See the file
* COPYING for details.
*
*/
#include "run-id.h"
#include "persistable-state-header.h"
#include "str-format.h"
#include "messages.h"
#define RUN_ID_PERSIST_KEY "run_id"
int cached_run_id = 0;
typedef struct _RunIDState
{
PersistableStateHeader header;
gint run_id;
} RunIDState;
static void
_run_id_set_entry(PersistState *state, PersistEntryHandle handle, guint32 value)
{
RunIDState *mapped_entry;
mapped_entry = persist_state_map_entry(state, handle);
mapped_entry->run_id = value;
persist_state_unmap_entry(state, handle);
}
static guint32
_run_id_recover_legacy_entry(PersistState *state, PersistEntryHandle handle)
{
guint32 old_entry;
guint32 *mapped_entry;
mapped_entry = persist_state_map_entry(state, handle);
old_entry = *mapped_entry;
persist_state_unmap_entry(state, handle);
return old_entry;
}
static PersistEntryHandle
_run_id_process_existing_entry(PersistState *state, PersistEntryHandle handle, gsize size, guint8 version)
{
if (size == sizeof(RunIDState))
{
return handle;
}
if (size == sizeof(guint32))
{
// In some legacy code we only used a single guint32 value to store the run_id. (without the proper header)
// If the size of the entry matches exactly, we convert it. Otherwise we can not use it, and allocate a new one.
msg_warning("run-id: persist state: found a legacy run-id state, reinitialize it");
guint32 old_entry = _run_id_recover_legacy_entry(state, handle);
PersistEntryHandle new_handle = persist_state_alloc_entry(state, RUN_ID_PERSIST_KEY, sizeof(RunIDState));
if (new_handle)
_run_id_set_entry(state, new_handle, old_entry);
return new_handle;
}
msg_warning("run-id: persist state: invalid run-id found, allocating a new state",
evt_tag_int("size", size),
evt_tag_int("version", version));
return persist_state_alloc_entry(state, RUN_ID_PERSIST_KEY, sizeof(RunIDState));
}
static PersistEntryHandle
_run_id_get_validated_handle(PersistState *state)
{
gsize size;
guint8 version;
PersistEntryHandle handle;
handle = persist_state_lookup_entry(state, RUN_ID_PERSIST_KEY, &size, &version);
if (handle)
{
return _run_id_process_existing_entry(state, handle, size, version);
}
return persist_state_alloc_entry(state, RUN_ID_PERSIST_KEY, sizeof(RunIDState));
}
gboolean
run_id_init(PersistState *state)
{
PersistEntryHandle handle;
RunIDState *run_id_state;
handle = _run_id_get_validated_handle(state);
if (handle == 0)
{
msg_error("run-id: could not allocate persist state");
return FALSE;
}
run_id_state = persist_state_map_entry(state, handle);
run_id_state->run_id++;
cached_run_id = run_id_state->run_id;
persist_state_unmap_entry(state, handle);
return TRUE;
};
int
run_id_get(void)
{
return cached_run_id;
};
gboolean
run_id_is_same_run(gint other_id)
{
return cached_run_id == other_id;
};
void
run_id_append_formatted_id(GString *str)
{
if (cached_run_id)
format_uint32_padded(str, 0, 0, 10, cached_run_id);
};
void
run_id_deinit(void)
{
cached_run_id = 0;
};
|
