mirror of
https://github.com/netdata/netdata.git
synced 2025-04-14 09:38:34 +00:00
0c8b46cbfd
* ndsudo command * added help * make ndsudo setuid to root * fix megacli binary name on FreeBSD * move ndsudo to collectors/plugins.d/ * address PR comments * do not print the command line argument, instead print its index --------- Co-authored-by: Ilya Mashchenko <ilya@netdata.cloud>
305 lines
8.4 KiB
C
305 lines
8.4 KiB
C
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <stdbool.h>
|
|
|
|
#define MAX_SEARCH 2
|
|
#define MAX_PARAMETERS 128
|
|
#define ERROR_BUFFER_SIZE 1024
|
|
|
|
struct command {
|
|
const char *name;
|
|
const char *params;
|
|
const char *search[MAX_SEARCH];
|
|
} allowed_commands[] = {
|
|
{
|
|
.name = "nvme-list",
|
|
.params = "list --output-format=json",
|
|
.search = {
|
|
[0] = "nvme",
|
|
[1] = NULL,
|
|
},
|
|
},
|
|
{
|
|
.name = "nvme-smart-log",
|
|
.params = "smart-log {{device}} --output-format=json",
|
|
.search = {
|
|
[0] = "nvme",
|
|
[1] = NULL,
|
|
},
|
|
},
|
|
{
|
|
.name = "megacli-disk-info",
|
|
.params = "-LDPDInfo -aAll -NoLog",
|
|
.search = {
|
|
[0] = "megacli",
|
|
[1] = "MegaCli",
|
|
},
|
|
},
|
|
{
|
|
.name = "megacli-battery-info",
|
|
.params = "-AdpBbuCmd -aAll -NoLog",
|
|
.search = {
|
|
[0] = "megacli",
|
|
[1] = "MegaCli",
|
|
},
|
|
},
|
|
{
|
|
.name = "arcconf-ld-info",
|
|
.params = "GETCONFIG 1 LD",
|
|
.search = {
|
|
[0] = "arcconf",
|
|
[1] = NULL,
|
|
},
|
|
},
|
|
{
|
|
.name = "arcconf-pd-info",
|
|
.params = "GETCONFIG 1 PD",
|
|
.search = {
|
|
[0] = "arcconf",
|
|
[1] = NULL,
|
|
},
|
|
}
|
|
};
|
|
|
|
bool command_exists_in_dir(const char *dir, const char *cmd, char *dst, size_t dst_size) {
|
|
snprintf(dst, dst_size, "%s/%s", dir, cmd);
|
|
return access(dst, X_OK) == 0;
|
|
}
|
|
|
|
bool command_exists_in_PATH(const char *cmd, char *dst, size_t dst_size) {
|
|
if(!dst || !dst_size)
|
|
return false;
|
|
|
|
char *path = getenv("PATH");
|
|
if(!path)
|
|
return false;
|
|
|
|
char *path_copy = strdup(path);
|
|
if (!path_copy)
|
|
return false;
|
|
|
|
char *dir;
|
|
bool found = false;
|
|
dir = strtok(path_copy, ":");
|
|
while(dir && !found) {
|
|
found = command_exists_in_dir(dir, cmd, dst, dst_size);
|
|
dir = strtok(NULL, ":");
|
|
}
|
|
|
|
free(path_copy);
|
|
return found;
|
|
}
|
|
|
|
struct command *find_command(const char *cmd) {
|
|
size_t size = sizeof(allowed_commands) / sizeof(allowed_commands[0]);
|
|
for(size_t i = 0; i < size ;i++) {
|
|
if(strcmp(cmd, allowed_commands[i].name) == 0)
|
|
return &allowed_commands[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool check_string(const char *str, size_t index, char *err, size_t err_size) {
|
|
const char *s = str;
|
|
while(*s) {
|
|
char c = *s++;
|
|
if(!((c >= 'A' && c <= 'Z') ||
|
|
(c >= 'a' && c <= 'z') ||
|
|
(c >= '0' && c <= '9') ||
|
|
c == ' ' || c == '_' || c == '-' || c == '/' || c == '.')) {
|
|
snprintf(err, err_size, "command line argument No %zu includes invalid character '%c'", index, c);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool check_params(int argc, char **argv, char *err, size_t err_size) {
|
|
for(int i = 0 ; i < argc ;i++)
|
|
if(!check_string(argv[i], i, err, err_size))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
char *find_variable_in_argv(const char *variable, int argc, char **argv, char *err, size_t err_size) {
|
|
for (int i = 1; i < argc - 1; i++) {
|
|
if (strcmp(argv[i], variable) == 0)
|
|
return strdup(argv[i + 1]);
|
|
}
|
|
|
|
snprintf(err, err_size, "variable '%s' is required, but was not provided in the command line parameters", variable);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
bool search_and_replace_params(struct command *cmd, char **params, size_t max_params, const char *filename, int argc, char **argv, char *err, size_t err_size) {
|
|
if (!cmd || !params || !max_params) {
|
|
snprintf(err, err_size, "search_and_replace_params() internal error");
|
|
return false;
|
|
}
|
|
|
|
const char *delim = " ";
|
|
char *token;
|
|
char *temp_params = strdup(cmd->params);
|
|
if (!temp_params) {
|
|
snprintf(err, err_size, "search_and_replace_params() cannot allocate memory");
|
|
return false;
|
|
}
|
|
|
|
size_t param_count = 0;
|
|
params[param_count++] = strdup(filename);
|
|
|
|
token = strtok(temp_params, delim);
|
|
while (token && param_count < max_params - 1) {
|
|
size_t len = strlen(token);
|
|
|
|
char *value = NULL;
|
|
|
|
if (strncmp(token, "{{", 2) == 0 && strncmp(token + len - 2, "}}", 2) == 0) {
|
|
token[0] = '-';
|
|
token[1] = '-';
|
|
token[len - 2] = '\0';
|
|
|
|
value = find_variable_in_argv(token, argc, argv, err, err_size);
|
|
}
|
|
else
|
|
value = strdup(token);
|
|
|
|
if(!value)
|
|
goto cleanup;
|
|
|
|
params[param_count++] = value;
|
|
token = strtok(NULL, delim);
|
|
}
|
|
|
|
params[param_count] = NULL; // Null-terminate the params array
|
|
free(temp_params);
|
|
return true;
|
|
|
|
cleanup:
|
|
if(!err[0])
|
|
snprintf(err, err_size, "memory allocation failure");
|
|
|
|
free(temp_params);
|
|
for (size_t i = 0; i < param_count; ++i) {
|
|
free(params[i]);
|
|
params[i] = NULL;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void show_help() {
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, "ndsudo\n");
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, "(C) Netdata Inc.\n");
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, "A helper to allow Netdata run privileged commands.\n");
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, " --test\n");
|
|
fprintf(stdout, " print the generated command that will be run, without running it.\n");
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, " --help\n");
|
|
fprintf(stdout, " print this message.\n");
|
|
fprintf(stdout, "\n");
|
|
|
|
fprintf(stdout, "The following commands are supported:\n\n");
|
|
|
|
size_t size = sizeof(allowed_commands) / sizeof(allowed_commands[0]);
|
|
for(size_t i = 0; i < size ;i++) {
|
|
fprintf(stdout, "- Command : %s\n", allowed_commands[i].name);
|
|
fprintf(stdout, " Executables: ");
|
|
for(size_t j = 0; j < MAX_SEARCH && allowed_commands[i].search[j] ;j++) {
|
|
fprintf(stdout, "%s ", allowed_commands[i].search[j]);
|
|
}
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, " Parameters : %s\n\n", allowed_commands[i].params);
|
|
}
|
|
|
|
fprintf(stdout, "The program searches for executables in the system path.\n");
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, "Variables given as {{variable}} are expected on the command line as:\n");
|
|
fprintf(stdout, " --variable VALUE\n");
|
|
fprintf(stdout, "\n");
|
|
fprintf(stdout, "VALUE can include space, A-Z, a-z, 0-9, _, -, /, and .\n");
|
|
fprintf(stdout, "\n");
|
|
}
|
|
|
|
int main(int argc, char *argv[]) {
|
|
char error_buffer[ERROR_BUFFER_SIZE] = "";
|
|
|
|
if (argc < 2) {
|
|
fprintf(stderr, "at least 2 parameters are needed, but %d were given.\n", argc);
|
|
return 1;
|
|
}
|
|
|
|
if(!check_params(argc, argv, error_buffer, sizeof(error_buffer))) {
|
|
fprintf(stderr, "invalid characters in parameters: %s\n", error_buffer);
|
|
return 2;
|
|
}
|
|
|
|
bool test = false;
|
|
const char *cmd = argv[1];
|
|
if(strcmp(cmd, "--help") == 0 || strcmp(cmd, "-h") == 0) {
|
|
show_help();
|
|
exit(0);
|
|
}
|
|
else if(strcmp(cmd, "--test") == 0) {
|
|
cmd = argv[2];
|
|
test = true;
|
|
}
|
|
|
|
struct command *command = find_command(cmd);
|
|
if(!command) {
|
|
fprintf(stderr, "command not recognized: %s\n", cmd);
|
|
return 3;
|
|
}
|
|
|
|
bool found = false;
|
|
char filename[FILENAME_MAX];
|
|
|
|
for(size_t i = 0; i < MAX_SEARCH && !found ;i++) {
|
|
if(command->search[i]) {
|
|
found = command_exists_in_PATH(command->search[i], filename, sizeof(filename));
|
|
if(!found) {
|
|
size_t len = strlen(error_buffer);
|
|
snprintf(&error_buffer[len], sizeof(error_buffer) - len, "%s ", command->search[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!found) {
|
|
fprintf(stderr, "%s: not available in PATH.\n", error_buffer);
|
|
return 4;
|
|
}
|
|
else
|
|
error_buffer[0] = '\0';
|
|
|
|
char *params[MAX_PARAMETERS];
|
|
if(!search_and_replace_params(command, params, MAX_PARAMETERS, filename, argc, argv, error_buffer, sizeof(error_buffer))) {
|
|
fprintf(stderr, "command line parameters are not satisfied: %s\n", error_buffer);
|
|
return 5;
|
|
}
|
|
|
|
if(test) {
|
|
fprintf(stderr, "Command to run: \n");
|
|
|
|
for(size_t i = 0; i < MAX_PARAMETERS && params[i] ;i++)
|
|
fprintf(stderr, "'%s' ", params[i]);
|
|
|
|
fprintf(stderr, "\n");
|
|
|
|
exit(0);
|
|
}
|
|
else {
|
|
char *clean_env[] = {NULL};
|
|
execve(filename, params, clean_env);
|
|
perror("execve"); // execve only returns on error
|
|
return 6;
|
|
}
|
|
}
|