1 | /* |
---|
2 | * Copyright (C) 2020-2021 Soleta Networks <info@soleta.eu> |
---|
3 | * |
---|
4 | * This program is free software: you can redistribute it and/or modify it under |
---|
5 | * the terms of the GNU Affero General Public License as published by the |
---|
6 | * Free Software Foundation; either version 3 of the License, or |
---|
7 | * (at your option) any later version. |
---|
8 | */ |
---|
9 | |
---|
10 | #include <jansson.h> |
---|
11 | #include <netinet/in.h> |
---|
12 | #include <stdlib.h> |
---|
13 | #include <syslog.h> |
---|
14 | |
---|
15 | #include "json.h" |
---|
16 | #include "rest.h" |
---|
17 | #include "legacy.h" |
---|
18 | |
---|
19 | #define LEGACY_CMD_MAX 4096 |
---|
20 | |
---|
21 | static const char *og_cmd_wol_to_legacy(struct og_cmd_json *cmd) |
---|
22 | { |
---|
23 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
24 | const json_t *root = cmd->json; |
---|
25 | const char *wol_type; |
---|
26 | uint32_t type; |
---|
27 | int len; |
---|
28 | |
---|
29 | wol_type = json_string_value(json_object_get(root, "type")); |
---|
30 | if (!wol_type) |
---|
31 | return NULL; |
---|
32 | |
---|
33 | if (!strcmp(wol_type, "broadcast")) |
---|
34 | type = 1; |
---|
35 | else |
---|
36 | type = 2; |
---|
37 | |
---|
38 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), "nfn=Arrancar\rmar=%u", type); |
---|
39 | if (len >= (int)sizeof(legacy_cmd)) |
---|
40 | return NULL; |
---|
41 | |
---|
42 | return strdup(legacy_cmd); |
---|
43 | } |
---|
44 | |
---|
45 | static const char *og_cmd_poweroff_to_legacy(struct og_cmd_json *cmd) |
---|
46 | { |
---|
47 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
48 | int len; |
---|
49 | |
---|
50 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), "nfn=Apagar"); |
---|
51 | if (len >= (int)sizeof(legacy_cmd)) |
---|
52 | return NULL; |
---|
53 | |
---|
54 | return strdup(legacy_cmd); |
---|
55 | } |
---|
56 | |
---|
57 | static const char *og_cmd_reboot_to_legacy(struct og_cmd_json *cmd) |
---|
58 | { |
---|
59 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
60 | int len; |
---|
61 | |
---|
62 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), "nfn=Reiniciar"); |
---|
63 | if (len >= (int)sizeof(legacy_cmd)) |
---|
64 | return NULL; |
---|
65 | |
---|
66 | return strdup(legacy_cmd); |
---|
67 | } |
---|
68 | |
---|
69 | static const char *og_cmd_session_to_legacy(struct og_cmd_json *cmd) |
---|
70 | { |
---|
71 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
72 | const json_t *root = cmd->json; |
---|
73 | const char *dsk, *par; |
---|
74 | int len; |
---|
75 | |
---|
76 | dsk = json_string_value(json_object_get(root, "disk")); |
---|
77 | if (!dsk) |
---|
78 | return NULL; |
---|
79 | par = json_string_value(json_object_get(root, "part")); |
---|
80 | if (!par) |
---|
81 | return NULL; |
---|
82 | |
---|
83 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), |
---|
84 | "nfn=IniciarSesion\rdsk=%s\rpar=%s", |
---|
85 | dsk, par); |
---|
86 | if (len >= (int)sizeof(legacy_cmd)) |
---|
87 | return NULL; |
---|
88 | |
---|
89 | return strdup(legacy_cmd); |
---|
90 | } |
---|
91 | |
---|
92 | static const char *og_cmd_software_to_legacy(struct og_cmd_json *cmd) |
---|
93 | { |
---|
94 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
95 | const json_t *root = cmd->json; |
---|
96 | const char *dsk, *par; |
---|
97 | int len; |
---|
98 | |
---|
99 | dsk = json_string_value(json_object_get(root, "disk")); |
---|
100 | if (!dsk) |
---|
101 | return NULL; |
---|
102 | par = json_string_value(json_object_get(root, "partition")); |
---|
103 | if (!par) |
---|
104 | return NULL; |
---|
105 | |
---|
106 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), |
---|
107 | "nfn=InventarioSoftware\rdsk=%s\rpar=%s", |
---|
108 | dsk, par); |
---|
109 | if (len >= (int)sizeof(legacy_cmd)) |
---|
110 | return NULL; |
---|
111 | |
---|
112 | return strdup(legacy_cmd); |
---|
113 | } |
---|
114 | |
---|
115 | static const char *og_cmd_hardware_to_legacy(struct og_cmd_json *cmd) |
---|
116 | { |
---|
117 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
118 | int len; |
---|
119 | |
---|
120 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), |
---|
121 | "nfn=InventarioHardware"); |
---|
122 | if (len >= (int)sizeof(legacy_cmd)) |
---|
123 | return NULL; |
---|
124 | |
---|
125 | return strdup(legacy_cmd); |
---|
126 | } |
---|
127 | |
---|
128 | static const char *og_cmd_shell_run_to_legacy(struct og_cmd_json *cmd) |
---|
129 | { |
---|
130 | const json_t *root = cmd->json; |
---|
131 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
132 | const char *scp; |
---|
133 | int len; |
---|
134 | |
---|
135 | scp = json_string_value(json_object_get(root, "run")); |
---|
136 | if (!scp) |
---|
137 | return NULL; |
---|
138 | |
---|
139 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), |
---|
140 | "nfn=EjecutarScript\rscp=%s", scp); |
---|
141 | if (len >= (int)sizeof(legacy_cmd)) { |
---|
142 | syslog(LOG_ERR, "script payload too large (%s:%d)\n", |
---|
143 | __func__, __LINE__); |
---|
144 | return NULL; |
---|
145 | } |
---|
146 | |
---|
147 | return strdup(legacy_cmd); |
---|
148 | } |
---|
149 | |
---|
150 | static char *og_cmd_image_create_to_legacy(struct og_cmd_json *cmd) |
---|
151 | { |
---|
152 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
153 | struct og_msg_params params = {}; |
---|
154 | json_t *root = cmd->json; |
---|
155 | int len; |
---|
156 | |
---|
157 | if (og_json_parse_create_image(root, ¶ms) < 0) |
---|
158 | return NULL; |
---|
159 | |
---|
160 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), |
---|
161 | "nfn=CrearImagen\rdsk=%s\rpar=%s\rcpt=%s\ridi=%s\rnci=%s\ripr=%s", |
---|
162 | params.disk, params.partition, params.code, params.id, |
---|
163 | params.name, params.repository); |
---|
164 | if (len >= (int)sizeof(legacy_cmd)) |
---|
165 | return NULL; |
---|
166 | |
---|
167 | return strdup(legacy_cmd); |
---|
168 | } |
---|
169 | |
---|
170 | static const char *og_cmd_image_restore_to_legacy(struct og_cmd_json *cmd) |
---|
171 | { |
---|
172 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
173 | struct og_msg_params params = {}; |
---|
174 | json_t *root = cmd->json; |
---|
175 | int len; |
---|
176 | |
---|
177 | if (og_json_parse_restore_image(root, ¶ms) < 0) |
---|
178 | return NULL; |
---|
179 | |
---|
180 | len = snprintf(legacy_cmd, sizeof(legacy_cmd), |
---|
181 | "nfn=RestaurarImagen\rdsk=%s\rpar=%s\ridi=%s\rnci=%s\ripr=%s\rifs=%s\rptc=%s", |
---|
182 | params.disk, params.partition, params.id, params.name, |
---|
183 | params.repository, params.profile, params.type); |
---|
184 | if (len >= (int)sizeof(legacy_cmd)) { |
---|
185 | return NULL; |
---|
186 | } |
---|
187 | |
---|
188 | return strdup(legacy_cmd); |
---|
189 | } |
---|
190 | |
---|
191 | static const char *og_cmd_setup_to_legacy(struct og_cmd_json *cmd) |
---|
192 | { |
---|
193 | char legacy_cmd[LEGACY_CMD_MAX + 1] = {}; |
---|
194 | uint32_t bufsiz = sizeof(legacy_cmd); |
---|
195 | const char *dsk, *ttp, *che, *tch; |
---|
196 | struct og_msg_params params = {}; |
---|
197 | json_t *partition_setup, *value; |
---|
198 | const json_t *root = cmd->json; |
---|
199 | uint32_t consumed = 0; |
---|
200 | size_t index; |
---|
201 | int len; |
---|
202 | |
---|
203 | dsk = json_string_value(json_object_get(root, "disk")); |
---|
204 | if (!dsk) |
---|
205 | return NULL; |
---|
206 | ttp = json_string_value(json_object_get(root, "type")); |
---|
207 | if (!ttp) |
---|
208 | return NULL; |
---|
209 | che = json_string_value(json_object_get(root, "cache")); |
---|
210 | if (!che) |
---|
211 | return NULL; |
---|
212 | tch = json_string_value(json_object_get(root, "cache_size")); |
---|
213 | if (!tch) |
---|
214 | return NULL; |
---|
215 | |
---|
216 | len = snprintf(legacy_cmd + consumed, bufsiz, "nfn=Configurar\rttp=%s\rdsk=%s\rcfg=dis=%s*che=%s*tch=%s!", |
---|
217 | ttp, dsk, dsk, che, tch); |
---|
218 | if (len >= bufsiz) |
---|
219 | return NULL; |
---|
220 | consumed += len; |
---|
221 | if (consumed < bufsiz) |
---|
222 | bufsiz -= len; |
---|
223 | |
---|
224 | partition_setup = json_object_get(root, "partition_setup"); |
---|
225 | if (!partition_setup) |
---|
226 | return NULL; |
---|
227 | if (og_json_parse_partition_setup(partition_setup, ¶ms) < 0) |
---|
228 | return NULL; |
---|
229 | |
---|
230 | json_array_foreach(partition_setup, index, value) { |
---|
231 | len = snprintf(legacy_cmd + consumed, bufsiz, "par=%s*cpt=%s*sfi=%s*tam=%s*ope=%s%%", |
---|
232 | params.partition_setup[index].number, |
---|
233 | params.partition_setup[index].code, |
---|
234 | params.partition_setup[index].filesystem, |
---|
235 | params.partition_setup[index].size, |
---|
236 | params.partition_setup[index].format); |
---|
237 | if (len >= bufsiz) |
---|
238 | return NULL; |
---|
239 | consumed += len; |
---|
240 | if (consumed < bufsiz) |
---|
241 | bufsiz -= len; |
---|
242 | } |
---|
243 | |
---|
244 | return strdup(legacy_cmd); |
---|
245 | } |
---|
246 | |
---|
247 | const char *og_msg_params_to_legacy(struct og_cmd_json *cmd) |
---|
248 | { |
---|
249 | const char *legacy_cmd = NULL; |
---|
250 | |
---|
251 | if (!strncmp(cmd->type, "wol", strlen("wol"))) |
---|
252 | legacy_cmd = og_cmd_wol_to_legacy(cmd); |
---|
253 | else if (!strncmp(cmd->type, "poweroff", strlen("poweroff"))) |
---|
254 | legacy_cmd = og_cmd_poweroff_to_legacy(cmd); |
---|
255 | else if (!strncmp(cmd->type, "reboot", strlen("reboot"))) |
---|
256 | legacy_cmd = og_cmd_reboot_to_legacy(cmd); |
---|
257 | else if (!strncmp(cmd->type, "session", strlen("session"))) |
---|
258 | legacy_cmd = og_cmd_session_to_legacy(cmd); |
---|
259 | else if (!strncmp(cmd->type, "software", strlen("software"))) |
---|
260 | legacy_cmd = og_cmd_software_to_legacy(cmd); |
---|
261 | else if (!strncmp(cmd->type, "hardware", strlen("hardware"))) |
---|
262 | legacy_cmd = og_cmd_hardware_to_legacy(cmd); |
---|
263 | else if (!strncmp(cmd->type, "run", strlen("run"))) |
---|
264 | legacy_cmd = og_cmd_shell_run_to_legacy(cmd); |
---|
265 | else if (!strncmp(cmd->type, "image_create", strlen("image_create"))) |
---|
266 | legacy_cmd = og_cmd_image_create_to_legacy(cmd); |
---|
267 | else if (!strncmp(cmd->type, "image_restore", strlen("image_restore"))) |
---|
268 | legacy_cmd = og_cmd_image_restore_to_legacy(cmd); |
---|
269 | else if (!strncmp(cmd->type, "setup", strlen("setup"))) |
---|
270 | legacy_cmd = og_cmd_setup_to_legacy(cmd); |
---|
271 | |
---|
272 | if (!legacy_cmd) { |
---|
273 | syslog(LOG_ERR, "failed to translate command %s (%s:%d)\n", |
---|
274 | cmd->type, __func__, __LINE__); |
---|
275 | } |
---|
276 | |
---|
277 | return legacy_cmd; |
---|
278 | } |
---|