source: ogServer-Git/src/legacy.c

Last change on this file was 893101f, checked in by OpenGnSys Support Team <soporte-og@…>, 3 years ago

missing copyright header to new src/legacy.c file
  • Property mode set to 100644
File size: 7.4 KB
Line 
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
21static 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
45static 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
57static 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
69static 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
92static 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
115static 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
128static 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
150static 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, &params) < 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
170static 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, &params) < 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
191static 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, &params) < 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
247const 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}
Note: See TracBrowser for help on using the repository browser.