qjyu
/
OrangePi_CM5
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
OrangePi_CM5/external/cache/sources/wl/wl/shellproc_linux.c

709 lines
19 KiB
C
Raw Blame History

/*
* Remote shell command execution (common for all transports) for linux
*
* Copyright (C) 2013, Broadcom Corporation
* All Rights Reserved.
*
* This is UNPUBLISHED PROPRIETARY SOURCE CODE of Broadcom Corporation;
* the contents of this file may not be disclosed to third parties, copied
* or duplicated in any form, in whole or in part, without the prior
* written permission of Broadcom Corporation.
*
* $Id: shellproc_linux.c 281542 2011-09-02 17:31:19Z $
*/
/* Linux remote shell command execution
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/types.h>
#include <netinet/in.h>
#include <sys/wait.h>
#include <signal.h>
#include <fcntl.h>
#include <typedefs.h>
#include <bcmutils.h>
#include <bcmcdc.h>
#include "wlu_remote.h"
#include <sys/poll.h>
#include <malloc.h>
#include <miniopt.h>
#include <sys/utsname.h>
#define ASYNC_RESP 0
#define MAX_SHELL_ASYNC_RESP 128 /* Support for maximum 5 async process */
#define MAX_ASYNC_FILE_LENGTH 50
#define MAX_PID_CMD_LENGTH 20
#define MAX_PID_RESP_LENTH 50
#define MAX_SHELL_CMD_LENTH 256
#define PID_TOKEN_SIZE 50
#define PID_SEARCH_CMD_SIZE 100
#define ASYNC_SHELL_CHAR "%" /* Async process identifier from the client */
#define FILE_PERMISSION 777
#define DEFAULT_SHELL_TIMEOUT 0 /* Default TimeOut Value for synchronous shell commands */
#define SHELL_RETURNVALUE_SIZE 2 /* Size of Return Value of the shell command */
#define SHELL_ASYNCCMD_ID 1 /* To identify if it is an async command */
#define REBOOT_MSG "Rebooting AP ...\n"
/* Function prototypes */
static int rwl_get_file_size(char *file_name);
static int remote_shell_async_exec(char *buf_ptr);
static int remote_shell_sync_exec(char *cmd_buf_ptr, void *wl);
/* Data structure to hold async shell information */
typedef struct remote_shell_async {
pid_t PID;
char file_name[MAX_ASYNC_FILE_LENGTH];
} remote_shell_async_t;
remote_shell_async_t g_async_resp[MAX_SHELL_ASYNC_RESP];
extern int g_shellsync_pid;
extern unsigned char g_return_stat;
extern void rwl_chld_handler(int num);
extern int set_ctrlc;
extern void handle_ctrlc(int unused);
/* Global variable to store the timeout value for the shell commands */
static int g_shellsync_timeout = DEFAULT_SHELL_TIMEOUT;
char globalbuffer[MAX_SHELL_CMD_LENTH];
/* Wait for process termination.
* This function returns immediately if the child has
* already exited (zombie process)
*/
static void
sigchld_handler(int s)
{
UNUSED_PARAMETER(s);
while (waitpid(-1, NULL, WNOHANG) > 0);
}
/* Create a main directory \tmp\RWL\ for the shell response files */
int
rwl_create_dir(void)
{
if (mkdir(SHELL_RESP_PATH, FILE_PERMISSION) < 0) {
if (errno != EEXIST)
return BCME_ERROR;
}
return SUCCESS;
}
/* Main function for shell command execution */
int
remote_shell_execute(char* buf_ptr, void *wl)
{
char *async_cmd_flag;
int msg_len;
/* Check for the "%" token in the buffer from client
* If "%" token is present, execute asynchronous process
* else, execute synchronous shell process
*/
async_cmd_flag = strstr((char*)buf_ptr, ASYNC_SHELL_CHAR);
if ((async_cmd_flag != NULL) && (!strcmp(async_cmd_flag, ASYNC_SHELL_CHAR))) {
g_shellsync_pid = SHELL_ASYNCCMD_ID;
msg_len = remote_shell_async_exec(buf_ptr);
}
else {
msg_len = remote_shell_sync_exec(buf_ptr, wl);
strcpy(buf_ptr, globalbuffer);
}
return msg_len;
}
/* Function to get the shell response from the file */
int
remote_shell_async_get_resp(char* shell_fname, char* buf_ptr, int msg_len)
{
int sts = 0;
FILE *shell_fpt;
shell_fpt = fopen(shell_fname, "rb");
if (shell_fpt == NULL) {
DPRINT_ERR(ERR, "\nShell Cmd:File open error\n");
return sts;
}
/* If there is any response from the shell, Read the file and
* update the buffer for the shell response
* else Just send the return value of the command executed
*/
if (g_shellsync_pid != SHELL_ASYNCCMD_ID) {
if (msg_len)
sts = fread(buf_ptr, sizeof(char), msg_len, shell_fpt);
fscanf(shell_fpt, "%2x", &sts);
}
else
sts = fread(buf_ptr, sizeof(char), MAX_SHELL_CMD_LENTH, shell_fpt);
fclose(shell_fpt);
remove(shell_fname);
DPRINT_DBG(OUTPUT, "\n Resp buff from shell cmdis %s\n", buf_ptr);
return sts;
}
/*
* Function to get the shell response length
* by opening the file containing the shell response
* and get the total file size.
* For a given input file name it returns File size.
*/
static int
rwl_get_file_size(char *file_name)
{
FILE *shell_fpt;
int filesize = 0;
shell_fpt = fopen(file_name, "rb");
if (shell_fpt == NULL) {
DPRINT_DBG(OUTPUT, "\nShell Cmd:File open error\n");
return filesize;
}
/* obtain file size */
if (fseek(shell_fpt, 0, SEEK_END) < 0)
return filesize;
filesize = ftell(shell_fpt);
fclose(shell_fpt);
return filesize;
}
/*
* Function for executing asynchronous shell comamnd
* Stores the results in async temp file and returns the PID
*/
static int
remote_shell_async_exec(char *buf_ptr)
{
int PID_val, val, msg_len, sts;
FILE *fpt;
int async_count = 0; /* counter needs to be initialized */
struct sigaction sa;
char pid_search_cmd[MAX_PID_CMD_LENGTH];
char pid_resp_buf[MAX_PID_RESP_LENTH];
char temp_async_file_name[MAX_ASYNC_FILE_LENGTH];
pid_t pid;
char *pid_token, next_pid[PID_TOKEN_SIZE][PID_TOKEN_SIZE];
struct utsname name;
/* Call the signal handler for reaping defunct or zombie process */
sa.sa_handler = sigchld_handler;
sigemptyset(&sa.sa_mask);
sa.sa_flags = SA_RESTART;
if (sigaction(SIGCHLD, &sa, NULL) == -1) {
perror("sigaction:");
}
/* Store the async file name if that async process is not killed.
* Async file name: async_temp_0...5
*/
for (val = 0; val < MAX_SHELL_ASYNC_RESP; val++) {
if (g_async_resp[val].PID > 0) {
async_count++;
} else {
sprintf(g_async_resp[val].file_name, "%s%d", "async_temp_", val);
break;
}
}
sprintf(temp_async_file_name, "%s%s", SHELL_RESP_PATH,
g_async_resp[val].file_name);
DPRINT_DBG(OUTPUT, "\nasync_count:%d\n", async_count);
if (async_count >= MAX_SHELL_ASYNC_RESP) {
sprintf(buf_ptr, "\n%s\n", "Exceeded max async process forking");
return BCME_ERROR;
}
/* Open a child process. The fork will return the PID of the child process
* (i.e) defunct process PID in parent's thread of execution. Zero is returned
* for child's thread of execution.
*/
if ((pid = fork()) == 0) {
/* Redirect the async process output to the async file
* Then after the client executes the kill command for that
* async process, the file will give the status of async process
*/
strtok(buf_ptr, ASYNC_SHELL_CHAR); /* Remove % character from the command buf */
uname(&name);
/*
* Checking for mips architecture
* different command for mips and x86
*/
if (strncmp(name.machine, "mips", sizeof(name.machine)) != 0) {
strcat(buf_ptr, "&> "); /* buf_ptr is now "ping 127.0.0.1&> " */
strcat(buf_ptr, temp_async_file_name); /* Add path \tmp\RWL\async_temp_* */
}
else {
strcat(buf_ptr, " > "); /* buf_ptr is now "ping 127.0.0.1> " */
strcat(buf_ptr, temp_async_file_name); /* Add path \tmp\RWL\async_temp_* */
strcat(buf_ptr, " 2>&1 &");
}
if ((sts = execl(SH_PATH, "sh", "-c", buf_ptr, NULL)) == -1) {
sprintf(buf_ptr, "%s\n", "Not able to execute shell cmd");
return BCME_ERROR;
}
exit(0);
} /* end of fork */
if (pid < 0) {
perror("\nFork error:");
sprintf(buf_ptr, "%s\n", "Forking async process failed");
return BCME_ERROR;
}
/* Find the PID of the running process (for ex: ping)
* pidof -s options returns latest PID of the command.
*/
strtok(buf_ptr, " ");
uname(&name);
/* Checking for mips architecture */
if (strncmp(name.machine, "mips", sizeof(name.machine)) != 0)
sprintf(pid_search_cmd, "pidof -s %s", buf_ptr);
else
sprintf(pid_search_cmd, "pidof %s", buf_ptr);
sleep(1);
/* Execute the command e.g "pidof ping" */
if ((fpt = popen(pid_search_cmd, "r")) == NULL) {
sprintf(buf_ptr, "%s\n", "Can't return PID");
return BCME_ERROR;
}
/* Get the PID and copy the PID in buf_ptr to send to the client */
fgets(pid_resp_buf, sizeof(pid_resp_buf), fpt);
/* Checking for mips architecture */
if (strncmp(name.machine, "mips", sizeof(name.machine)) != 0) {
PID_val = atoi(pid_resp_buf);
}
else {
/* code to extract the correct PID */
pid_token = strtok_r(pid_resp_buf, " ", (char **)next_pid);
if (pid_token != NULL) {
while (pid_token != NULL) {
/* the pid buffer will terminate with a '\n'
* It will affect the string tokenizing logic
* To avoid this we're using the if case
*/
if (strncmp(pid_token, "\n", sizeof(pid_token)) == 0)
break;
PID_val = atoi(pid_token);
pid_token = strtok_r(NULL, " ", (char **)next_pid);
}
}
else
PID_val = atoi(pid_token);
}
if (PID_val == 0) {
msg_len = rwl_get_file_size(temp_async_file_name);
remote_shell_async_get_resp(temp_async_file_name, buf_ptr, msg_len);
} else {
g_async_resp[val].PID = PID_val;
/* Update PID value in buffer to send it to client */
sprintf(buf_ptr, "%d", PID_val);
msg_len = strlen(buf_ptr);
}
pclose(fpt);
/* In async case, the PID value will be copied to the input buffer only
* and there is no need of getting the response from the file. So return
* value can be -1.
*/
return msg_len;
}
/* Process for 'kill' command.
* Kill command can also be used from the client to get the
* result of asynchronous command and actually kill the mentioned process
*/
static int
remote_kill_cmd_exec(char *cmd_buf_ptr)
{
char file_name[MAX_ASYNC_FILE_LENGTH];
int PID_val, val, msg_len;
FILE *fpt;
char *pid_token, next_pid[PID_TOKEN_SIZE][PID_TOKEN_SIZE];
system(cmd_buf_ptr);
/* Parse the PID val from the kill command.
*/
pid_token = strtok_r(cmd_buf_ptr, " ", (char **)next_pid);
while (pid_token != NULL) {
/* to extract the PID from the kill command */
if (strncmp(pid_token, "\n", sizeof(pid_token)) == 0)
break;
PID_val = atoi(pid_token);
pid_token = strtok_r(NULL, " ", (char **)next_pid);
}
/* Check for the matching PID from the async structure and
* give the last 256 bytes statistics of the async process
* that was running
*/
for (val = 0; val < MAX_SHELL_ASYNC_RESP; ++val) {
if (g_async_resp[val].PID == PID_val) {
/* We found a match here. Hence get the response now from the
* corresponding async response file
*/
sprintf(file_name, "%s%s", SHELL_RESP_PATH, g_async_resp[val].file_name);
msg_len = rwl_get_file_size(file_name);
if (msg_len > 0) {
if ((fpt = fopen(file_name, "rb")) == NULL) {
DPRINT_DBG(OUTPUT, "\nShell Cmd:File open error\n");
return BCME_ERROR;
}
if (fseek(fpt, 0, SEEK_SET) < 0) {
fclose(fpt);
return BCME_ERROR;
}
if (fread(cmd_buf_ptr, sizeof(char), MAX_SHELL_CMD_LENTH,
fpt) <= 0) {
sprintf(cmd_buf_ptr, "%s\n", "Shell Resp:Reading error");
fclose(fpt);
return BCME_ERROR;
}
fclose(fpt);
}
else
sprintf(cmd_buf_ptr, "ed %d: No Response\n", PID_val);
remove(g_async_resp[val].file_name);
g_async_resp[val].PID = 0;
break;
}
}
return MAX_SHELL_CMD_LENTH;
}
/* Handle --timeout command line option for linux servers */
int
shell_timeout_cmd(char *cmd_buf_ptr, char *sync_file_name)
{
char *token1, *token2, *nexttoken;
FILE* fp;
int msg_len;
token1 = strtok_r(cmd_buf_ptr, "--timeout ", &nexttoken);
if (token1)
token2 = strtok_r(NULL, token1, &nexttoken);
if (token1 == NULL || atoi(token1) <= 0 || token2 == NULL) {
fp = fopen(sync_file_name, "w+");
fprintf(fp, "Usage: ./wl --<transport> <ip/mac> sh"
"--timeout <timeout value> <shell command>\n");
fprintf(fp, "Eg: ./wl --socket 172.22.65.226 sh --timeout 15 ls\n");
fflush(fp);
msg_len = rwl_get_file_size(sync_file_name);
strcpy(cmd_buf_ptr, sync_file_name);
fclose(fp);
strcpy(globalbuffer, sync_file_name);
printf("Fix timeout problem in socket!!!!!\n");
return msg_len;
}
else
g_shellsync_timeout = atoi(token1);
return BCME_OK;
}
/* Handle synchronous shell commands here */
static int
remote_shell_sync_exec(char *cmd_buf_ptr, void *wl)
{
char *kill_cmd_token;
char sync_file_name[] = TEMPLATE;
int fd, msg_len;
char cmd[(strlen(cmd_buf_ptr) + 1)];
int pid, status, pid_final;
char buf[SHELL_RESP_SIZE], cmd_find_lastpid[PID_SEARCH_CMD_SIZE];
int nbytes = 0;
int child_status;
static int sent_once = 0;
struct utsname name;
FILE *fpt;
/* Default Size of Return Value of the shell command is 2bytes */
kill_cmd_token = strstr(cmd_buf_ptr, "kill");
/* Synchronous Kill command processing is handled separately */
if (kill_cmd_token != NULL) {
msg_len = remote_kill_cmd_exec(cmd_buf_ptr);
remote_tx_response(wl, cmd_buf_ptr, msg_len);
return 0;
}
/* Process synchronous command other than kill command */
if ((fd = mkstemp(sync_file_name)) < 0) {
perror("mkstemp failed");
DPRINT_ERR(ERR, "\n errno:%d\n", errno);
sprintf(cmd_buf_ptr, "%s\n", "mkstemp failed");
return BCME_ERROR;
}
close(fd);
strcpy(cmd, cmd_buf_ptr);
/* Synchronous timeout command processing is handled separately */
if (strstr(cmd_buf_ptr, "--timeout") != NULL) {
if ((msg_len = shell_timeout_cmd (cmd, sync_file_name) > 0)) {
/* Signal end of command output */
g_rem_ptr->msg.len = 0;
g_rem_ptr->msg.cmd = g_return_stat;
remote_tx_response(wl, NULL, 0);
return msg_len;
} else {
/* Parse out --timeout <val> since command is successful
* point buffer to the shell command
*/
strcpy(cmd, cmd_buf_ptr);
strtok_r(cmd, " ", &cmd_buf_ptr);
strcpy(cmd, cmd_buf_ptr);
strtok_r(cmd, " ", &cmd_buf_ptr);
}
}
/* Schedule an ALARM in case of timeout value of SHELL_TIMEOUT seconds */
/* Defalut time out only in case of Non socket transport */
alarm(g_shellsync_timeout);
/* registering the relevant signals to handle end of child process,
* the ctrl+c event on the server side and the kill command on the
* server process
*/
signal(SIGCHLD, rwl_chld_handler);
signal(SIGINT, handle_ctrlc);
signal(SIGTERM, handle_ctrlc);
/* Set g_sig_chld before forking */
g_sig_chld = 1;
if (strcmp("reboot", cmd_buf_ptr) == 0) { /* reboot command */
memset(buf, 0, sizeof(buf));
strncpy(buf, REBOOT_MSG, sizeof(REBOOT_MSG));
remote_tx_response(wl, buf, 0);
/* Signal end of command output */
g_rem_ptr->msg.len = 0;
g_rem_ptr->msg.cmd = 0;
remote_tx_response(wl, NULL, 0);
sleep(1);
/* Clean up the temp file */
remove(sync_file_name);
}
if ((pid = fork()) == 0) {
close(STDOUT_FILENO);
fd = open(sync_file_name, O_WRONLY|O_SYNC);
/* Redirect stdin to dev/null. This handles un usual commands like
* sh cat from the client side
*/
close(STDIN_FILENO);
open("/dev/null", O_RDONLY);
close(STDERR_FILENO);
fcntl(fd, F_DUPFD, STDERR_FILENO);
if ((status = execl(SH_PATH, "sh", "-c", cmd_buf_ptr, NULL)) == -1) {
perror("Exec error");
}
} /* end of fork */
g_shellsync_pid = pid;
/* The g_return_stat is being set for short commands */
waitpid(g_shellsync_pid, &child_status, WNOHANG);
if (WIFEXITED(child_status))
g_return_stat = WEXITSTATUS(child_status);
else
g_return_stat = 1;
/* Read file in the interim from a temp file and send back the results */
fd = open(sync_file_name, O_RDONLY|O_SYNC);
while (1) {
/* read file in the interim and send back the results */
nbytes = read(fd, buf, SHELL_RESP_SIZE);
g_rem_ptr->msg.len = nbytes;
if (nbytes > 0) {
remote_tx_response(wl, buf, 0);
#ifdef RWL_SERIAL
/* usleep introduced for flooding of data over serial port */
usleep(1);
#endif
}
if (get_ctrlc_header(wl) >= 0) {
if (g_rem_ptr->msg.flags == (unsigned)CTRLC_FLAG) {
uname(&name);
/* Checking for mips architecture
* The mips machine responds differently to
* execl command. so the pid is incremented
* to kill the right command.
*/
if (strncmp(name.machine, "mips", sizeof(name.machine)) == 0)
pid++;
if (strncmp(name.machine, "armv5tel", sizeof(name.machine)) == 0) {
snprintf(cmd_find_lastpid, sizeof(cmd_find_lastpid),
"ps | awk \'PRINT $1\' | tail -n 1");
if ((fpt = popen(cmd_find_lastpid, "r")) == NULL) {
sprintf(buf, "%s\n", "Can't return PID");
return BCME_ERROR;
}
fgets(cmd_find_lastpid, sizeof(cmd_find_lastpid), fpt);
pid_final = atoi(cmd_find_lastpid);
while (pid <= pid_final) {
kill(pid, SIGKILL);
pid++;
}
pclose(fpt);
}
else {
kill(pid, SIGKILL);
}
break;
}
}
if (get_ctrlc_header(wl) >= 0) {
if (g_rem_ptr->msg.flags == (unsigned)CTRLC_FLAG) {
uname(&name);
/* Checking for mips architecture
* The mips machine responds differently to
* execl command. so the pid is incremented
* to kill the right command.
*/
if (strncmp(name.machine, "mips", sizeof(name.machine)) == 0) {
pid++;
kill(pid, SIGKILL);
}
/* Checking for arm architecture
* The multiple commands would not work
* for ctrl+C. So we kill the processes
* spawned after the parent. This method has
* its own limitations but the busybox in pxa
* doesnot have many options to implement it better
*/
else {
if (strncmp(name.machine, "armv5tel",
sizeof(name.machine)) == 0) {
/* The command below is used to get the
* PIDs and they are killed
*/
snprintf(cmd_find_lastpid,
sizeof(cmd_find_lastpid),
"ps | awk \'PRINT $1\' | tail -n 1");
if ((fpt = popen(cmd_find_lastpid, "r")) == NULL) {
sprintf(buf, "%s\n", "Can't return PID");
return BCME_ERROR;
}
fgets(cmd_find_lastpid, sizeof(cmd_find_lastpid),
fpt);
pid_final = atoi(cmd_find_lastpid);
while (pid <= pid_final) {
kill(pid, SIGKILL);
pid++;
}
pclose(fpt);
}
/* In the case of x86, on receiving ctrl+C
* the child PIDs are obtained by searching
* the parent PID to obtain the PIDs of the
* and kill them
*/
else {
while (pid != 0) {
/* The commad below is used to get the
* child PIDs by using their parent PID
*/
snprintf(cmd_find_lastpid,
sizeof(cmd_find_lastpid),
"ps al | awk \"{ if (\\$4 == %d)"
" {print \\$3}}\"| head -n 1",
g_shellsync_pid);
if ((fpt = popen(cmd_find_lastpid, "r"))
== NULL) {
sprintf(buf, "%s\n",
"Can't return PID");
return BCME_ERROR;
}
fgets(cmd_find_lastpid,
sizeof(cmd_find_lastpid),
fpt);
pid = atoi(cmd_find_lastpid);
if (pid == 0)
kill(g_shellsync_pid, SIGKILL);
else
kill(pid, SIGKILL);
pclose(fpt);
}
}
}
break;
}
}
if (set_ctrlc == 1) {
g_rem_ptr->msg.len = 0;
g_rem_ptr->msg.cmd = g_return_stat;
remote_tx_response(wl, NULL, g_return_stat);
unlink(sync_file_name);
kill(0, SIGKILL);
}
/* It is possible that the child would have exited
* However we did not get a chance to read the file
* In this case go once again and check the file
*/
if (!sent_once && !g_sig_chld) {
sent_once = 1;
continue;
}
if (!(g_sig_chld || nbytes))
break;
}
wait(NULL);
close(fd);
/* Signal end of command output */
g_rem_ptr->msg.len = 0;
g_rem_ptr->msg.cmd = g_return_stat;
remote_tx_response(wl, NULL, g_return_stat);
/* Cancel the time out alarm if any */
alarm(0);
sent_once = 0;
/* Clean up the temp file */
unlink(sync_file_name);
g_shellsync_timeout = DEFAULT_SHELL_TIMEOUT;
signal(SIGINT, SIG_DFL);
signal(SIGTERM, SIG_DFL);
return BCME_OK;
}
Reference in New Issue View Git Blame Copy Permalink