1 // SPDX-License-Identifier: ISC OR MIT
3 * rpcd - UBUS RPC server
5 * Copyright (C) 2020 Rafał Miłecki <rafal@milecki.pl>
10 #include <linux/limits.h>
14 #include <libubox/blobmsg.h>
15 #include <libubox/ulog.h>
16 #include <libubox/uloop.h>
21 #define RC_LIST_EXEC_TIMEOUT_MS 3000
29 static const struct blobmsg_policy rc_init_policy
[] = {
30 [RC_INIT_NAME
] = { "name", BLOBMSG_TYPE_STRING
},
31 [RC_INIT_ACTION
] = { "action", BLOBMSG_TYPE_STRING
},
34 struct rc_list_context
{
35 struct uloop_process process
;
36 struct uloop_timeout timeout
;
37 struct ubus_context
*ctx
;
38 struct ubus_request_data req
;
42 /* Info about currently processed init.d entry */
54 static void rc_list_readdir(struct rc_list_context
*c
);
57 * rc_check_script - check if script is safe to execute as root
59 * Check if it's owned by root and if only root can modify it.
61 static int rc_check_script(const char *path
)
66 return UBUS_STATUS_NOT_FOUND
;
68 if (s
.st_uid
!= 0 || s
.st_gid
!= 0 || !(s
.st_mode
& S_IXUSR
) || (s
.st_mode
& S_IWOTH
))
69 return UBUS_STATUS_PERMISSION_DENIED
;
71 return UBUS_STATUS_OK
;
74 static void rc_list_add_table(struct rc_list_context
*c
)
78 e
= blobmsg_open_table(c
->buf
, c
->entry
.d_name
);
80 if (c
->entry
.start
>= 0)
81 blobmsg_add_u16(c
->buf
, "start", c
->entry
.start
);
82 if (c
->entry
.stop
>= 0)
83 blobmsg_add_u16(c
->buf
, "stop", c
->entry
.stop
);
84 blobmsg_add_u8(c
->buf
, "enabled", c
->entry
.enabled
);
85 if (c
->entry
.use_procd
)
86 blobmsg_add_u8(c
->buf
, "running", c
->entry
.running
);
88 blobmsg_close_table(c
->buf
, e
);
91 static void rpc_list_exec_timeout_cb(struct uloop_timeout
*t
)
93 struct rc_list_context
*c
= container_of(t
, struct rc_list_context
, timeout
);
95 ULOG_WARN("Timeout waiting for %s\n", c
->entry
.path
);
97 uloop_process_delete(&c
->process
);
98 kill(c
->process
.pid
, SIGKILL
);
104 * rc_exec - execute a file and call callback on complete
106 static int rc_list_exec(struct rc_list_context
*c
, const char *action
, uloop_process_handler cb
)
117 if (!c
->entry
.use_procd
)
120 /* Set stdin, stdout & stderr to /dev/null */
121 fd
= open("/dev/null", O_RDWR
);
132 execl(c
->entry
.path
, c
->entry
.path
, action
, NULL
);
135 c
->process
.pid
= pid
;
138 err
= uloop_process_add(&c
->process
);
142 c
->timeout
.cb
= rpc_list_exec_timeout_cb
;
143 err
= uloop_timeout_set(&c
->timeout
, RC_LIST_EXEC_TIMEOUT_MS
);
145 uloop_process_delete(&c
->process
);
153 static void rc_list_exec_running_cb(struct uloop_process
*p
, int stat
)
155 struct rc_list_context
*c
= container_of(p
, struct rc_list_context
, process
);
157 uloop_timeout_cancel(&c
->timeout
);
159 c
->entry
.running
= !stat
;
160 rc_list_add_table(c
);
165 static void rc_list_readdir(struct rc_list_context
*c
)
173 ubus_send_reply(c
->ctx
, &c
->req
, c
->buf
->head
);
174 ubus_complete_deferred_request(c
->ctx
, &c
->req
, UBUS_STATUS_OK
);
178 if (!strcmp(e
->d_name
, ".") || !strcmp(e
->d_name
, ".."))
181 memset(&c
->entry
, 0, sizeof(c
->entry
));
185 snprintf(c
->entry
.path
, sizeof(c
->entry
.path
), "/etc/init.d/%s", e
->d_name
);
186 if (rc_check_script(c
->entry
.path
))
189 c
->entry
.d_name
= e
->d_name
;
191 fp
= fopen(c
->entry
.path
, "r");
200 while ((c
->entry
.start
< 0 || c
->entry
.stop
< 0 || !c
->entry
.use_procd
) &&
201 count
<= 10 && fgets(line
, sizeof(line
), fp
)) {
203 if (!strncmp(line
, "START=", 6)) {
204 c
->entry
.start
= strtoul(line
+ 6, NULL
, 0);
205 } else if (!strncmp(line
, "STOP=", 5)) {
206 c
->entry
.stop
= strtoul(line
+ 5, NULL
, 0);
207 } else if (!c
->skip_running_check
&& !strncmp(line
, "USE_PROCD=", 10)) {
208 c
->entry
.use_procd
= !!strtoul(line
+ 10, NULL
, 0);
213 beginning
= !!strchr(line
, '\n');
217 if (c
->entry
.start
>= 0) {
218 snprintf(path
, sizeof(path
), "/etc/rc.d/S%02d%s", c
->entry
.start
, c
->entry
.d_name
);
219 if (!stat(path
, &s
) && (s
.st_mode
& S_IXUSR
))
220 c
->entry
.enabled
= true;
224 if (rc_list_exec(c
, "running", rc_list_exec_running_cb
))
233 * rc_list - allocate listing context and start reading directory
235 static int rc_list(struct ubus_context
*ctx
, struct ubus_object
*obj
,
236 struct ubus_request_data
*req
, const char *method
,
237 struct blob_attr
*msg
)
239 static struct blob_buf buf
;
240 struct rc_list_context
*c
;
242 blob_buf_init(&buf
, 0);
244 c
= calloc(1, sizeof(*c
));
246 return UBUS_STATUS_UNKNOWN_ERROR
;
250 c
->dir
= opendir("/etc/init.d");
253 return UBUS_STATUS_UNKNOWN_ERROR
;
256 ubus_defer_request(ctx
, req
, &c
->req
);
260 return 0; /* Deferred */
263 struct rc_init_context
{
264 struct uloop_process process
;
265 struct ubus_context
*ctx
;
266 struct ubus_request_data req
;
269 static void rc_init_cb(struct uloop_process
*p
, int stat
)
271 struct rc_init_context
*c
= container_of(p
, struct rc_init_context
, process
);
273 ubus_complete_deferred_request(c
->ctx
, &c
->req
, UBUS_STATUS_OK
);
278 static int rc_init(struct ubus_context
*ctx
, struct ubus_object
*obj
,
279 struct ubus_request_data
*req
, const char *method
,
280 struct blob_attr
*msg
)
282 struct blob_attr
*tb
[__RC_INIT_MAX
];
283 struct rc_init_context
*c
;
292 blobmsg_parse(rc_init_policy
, __RC_INIT_MAX
, tb
, blobmsg_data(msg
), blobmsg_data_len(msg
));
294 if (!tb
[RC_INIT_NAME
] || !tb
[RC_INIT_ACTION
])
295 return UBUS_STATUS_INVALID_ARGUMENT
;
297 name
= blobmsg_get_string(tb
[RC_INIT_NAME
]);
299 /* Validate script name */
300 for (chr
= name
; (chr
= strchr(chr
, '.')); chr
++) {
301 if (*(chr
+ 1) == '.')
302 return UBUS_STATUS_INVALID_ARGUMENT
;
304 if (strchr(name
, '/'))
305 return UBUS_STATUS_INVALID_ARGUMENT
;
307 snprintf(path
, sizeof(path
), "/etc/init.d/%s", name
);
309 /* Validate script privileges */
310 err
= rc_check_script(path
);
314 action
= blobmsg_get_string(tb
[RC_INIT_ACTION
]);
315 if (strcmp(action
, "disable") &&
316 strcmp(action
, "enable") &&
317 strcmp(action
, "stop") &&
318 strcmp(action
, "start") &&
319 strcmp(action
, "restart") &&
320 strcmp(action
, "reload"))
321 return UBUS_STATUS_INVALID_ARGUMENT
;
323 c
= calloc(1, sizeof(*c
));
325 return UBUS_STATUS_UNKNOWN_ERROR
;
331 return UBUS_STATUS_UNKNOWN_ERROR
;
333 /* Set stdin, stdout & stderr to /dev/null */
334 fd
= open("/dev/null", O_RDWR
);
345 execl(path
, path
, action
, NULL
);
349 c
->process
.pid
= pid
;
350 c
->process
.cb
= rc_init_cb
;
351 uloop_process_add(&c
->process
);
353 ubus_defer_request(ctx
, req
, &c
->req
);
355 return 0; /* Deferred */
359 int rpc_rc_api_init(struct ubus_context
*ctx
)
361 static const struct ubus_method rc_methods
[] = {
362 UBUS_METHOD_NOARG("list", rc_list
),
363 UBUS_METHOD("init", rc_init
, rc_init_policy
),
366 static struct ubus_object_type rc_type
=
367 UBUS_OBJECT_TYPE("rc", rc_methods
);
369 static struct ubus_object obj
= {
372 .methods
= rc_methods
,
373 .n_methods
= ARRAY_SIZE(rc_methods
),
376 return ubus_add_object(ctx
, &obj
);