K2.6 patches and update.

[tomato.git] / release / src-rt / wl / exe / shellproc_linux.c

/*
 * Remote shell command execution (common for all transports) for linux
 *
 * Copyright (C) 2010, 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,v 1.12 2009-08-11 08:51:01 Exp $
 */

/* 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>
#ifndef MACOSX
#include <malloc.h>
#endif
#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)
{
#ifndef MACOSX
        if (mkdir(SHELL_RESP_PATH, FILE_PERMISSION) < 0) {
                if (errno != EEXIST)
                        return BCME_ERROR;
        }
#else
        system("mkdir -p /tmp/RWL");
#endif /* mkdir linux command doesnot work in MAC, hence using shell */

        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;
}