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
159
160
161
162
|
/*
* (C) Copyright 2013-2023
* Stefano Babic <stefano.babic@swupdate.org>
*
* SPDX-License-Identifier: GPL-2.0-only
*/
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <limits.h>
#include "swupdate.h"
#include "handler.h"
#include "lua_util.h"
#include "util.h"
#define MAX_INSTALLER_HANDLER 64
struct installer_handler supported_types[MAX_INSTALLER_HANDLER];
static unsigned long nr_installers = 0;
static unsigned long handler_index = ULONG_MAX;
static int __register_handler(const char *desc,
handler installer, HANDLER_MASK mask, void *data, handler_type_t lifetime)
{
int i;
if ((nr_installers > MAX_INSTALLER_HANDLER - 1) || !desc)
return -1;
/*
* Do not register the same handler twice
*/
for (i = 0; i < nr_installers; i++) {
if ((strlen(desc) == strlen(supported_types[i].desc)) &&
strcmp(desc, supported_types[i].desc) == 0)
return -1;
}
strlcpy(supported_types[nr_installers].desc, desc,
sizeof(supported_types[nr_installers].desc));
supported_types[nr_installers].installer = installer;
supported_types[nr_installers].data = data;
supported_types[nr_installers].mask = mask;
supported_types[nr_installers].noglobal = (lifetime == SESSION_HANDLER);
nr_installers++;
return 0;
}
int register_handler(const char *desc,
handler installer, HANDLER_MASK mask, void *data)
{
return __register_handler(desc, installer, mask, data, GLOBAL_HANDLER);
}
int register_session_handler(const char *desc,
handler installer, HANDLER_MASK mask, void *data)
{
return __register_handler(desc, installer, mask, data, SESSION_HANDLER);
}
int unregister_handler(const char *desc)
{
int i;
for (i = 0; i < nr_installers; i++) {
if ((strlen(desc) == strlen(supported_types[i].desc)) &&
IS_STR_EQUAL(desc, supported_types[i].desc)) {
break;
}
}
/* Not found */
if (i == nr_installers)
return -1;
for (int j = i + 1; j < nr_installers; j++) {
strlcpy(supported_types[j - 1].desc, supported_types[j].desc,
sizeof(supported_types[j -1].desc));
supported_types[j - 1].installer = supported_types[j].installer;
supported_types[j - 1].data = supported_types[j].data;
supported_types[j - 1].mask = supported_types[j].mask;
}
nr_installers--;
return 0;
}
void unregister_session_handlers(void)
{
int i;
for (i = nr_installers - 1; i >= 0; i--) {
if (supported_types[i].noglobal) {
unregister_handler(supported_types[i].desc);
}
}
}
void print_registered_handlers(bool global)
{
unsigned int i;
unsigned int count = 0;
if (!nr_installers)
return;
/*
* Invert logic to ask for session handlers
*/
bool noglobal = !global;
INFO("Registered %s handlers:", global ? "global" : "session");
for (i = 0; i < nr_installers; i++) {
if (noglobal == supported_types[i].noglobal) {
count++;
INFO("\t%s", supported_types[i].desc);
}
}
if (count == 0) {
INFO("\tnone registered.");
}
}
struct installer_handler *find_handler(struct img_type *img)
{
unsigned int i;
for (i = 0; i < nr_installers; i++) {
if ((strlen(img->type) == strlen(supported_types[i].desc)) &&
strcmp(img->type,
supported_types[i].desc) == 0)
break;
}
if (i >= nr_installers)
return NULL;
return &supported_types[i];
}
struct installer_handler *get_next_handler(void)
{
if (handler_index == ULONG_MAX) {
handler_index = 0;
}
if (handler_index >= nr_installers) {
handler_index = ULONG_MAX;
return NULL;
}
return &supported_types[handler_index++];
}
unsigned int get_handler_mask(struct img_type *img)
{
struct installer_handler *hnd;
unsigned int mask = 0;
hnd = find_handler(img);
if (hnd)
mask = hnd->mask;
return mask;
}
|
