Ace

#include <pwd.h>
#include <sys/types.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
#include <sys/times.h>
#include <stdlib.h>
#include <sys/wait.h>

#include "ace/SOCK_Stream.h"
#include "ace/INET_Addr.h"
#include "ace/OS.h"
#include "ace/SOCK_Dgram.h"
#include "ace/INET_Addr.h"
#include "ace/Reactor.h"
#include "ace/Synch.h"
#include "ace/OS.h"
#include "ace/INET_Addr.h"
#include "ace/Acceptor.h"
#include "ace/Connector.h"
#include "ace/SOCK_Acceptor.h"
#include "ace/SOCK_Connector.h"
#include "ace/Reactor.h"
#include "ace/SOCK_Stream.h"
#include "ace/SOCK_Dgram.h"
#include "ace/Log_Msg.h"
#include "ace/Log_Priority.h"
#include "ace/Get_Opt.h"
#include "time.h"
#include "pexec_share.h"
#include "wd.h"


// global variables
//struct buff_stdout outbuff;
//struct buff_stderr errbuff;
//int exitcode;
extern int errno;

enum status_type execprocess(char* uname,
char* cmdline,
int nmili_sec,
int& exitcode,
struct buff_stdout& outbuff,
struct buff_stderr& errbuff);


class PEXEC_Handler:
public ACE_Svc_Handler<ACE_SOCK_STREAM,ACE_MT_SYNCH>
{
public:
PEXEC_Handler(){
}
int init();
int open(void*);
int handle_input(ACE_HANDLE);
int handle_timeout(const ACE_Time_Value&, const void*);
int handle_close(ACE_HANDLE,ACE_Reactor_Mask);
int svc();
private:
param_pack pex_pps;
ACE_Thread_Mutex mutex_;
};

typedef ACE_Acceptor<PEXEC_Handler, ACE_SOCK_ACCEPTOR> PEXEC_Acceptor;

int
PEXEC_Handler::open(void *)
{
//ACE_DEBUG((LM_DEBUG,"the gsd_handler is going to be opened\n"));
ACE_Reactor::instance()->register_handler(this,ACE_Event_Handler::READ_MASK);
return 0;
}

int
PEXEC_Handler::handle_input(ACE_HANDLE)
{
// int rlen = peer().recv(tmp_recv,128,0);
struct param_pack pps, net_pps;
//enum status_type exec_status;
//int nint;

int rlen = peer().recv((char *)&net_pps, sizeof(net_pps), 0);
if (rlen <= -1) // can not recv messge from client
{
cout << "[" << __FILE__ << ":" << __LINE__ << "]" << "\t";
/*new add 0525*/
peer().close();
/*end add*/
ACE_ERROR_RETURN((LM_ERROR,"(%P|%t, %p)","recv message failed"),-1);
return -1;
}
if (rlen == 0){
peer().close();
return -1;
}

//convert net_pps to pps
strncpy(pps.user, net_pps.user, sizeof(pps.user));
strncpy(pps.cmdline, net_pps.cmdline, sizeof(pps.cmdline));
pps.fexitcode = ntohl(net_pps.fexitcode);
pps.milisec = ntohl(net_pps.milisec);
//cout<<"user name is "<<pps.user<<endl
// <<"cmdline is "<<pps.cmdline<<endl
//<<"exitcode only is "<<pps.exitcode_only<<endl
//<<"timeout is "<<pps.timeout<<endl;

mutex_.acquire();
pex_pps = net_pps;

activate(THR_NEW_LWP,
1, //2 new threads
1, //force active false, if already created don~Rt try again.
ACE_DEFAULT_THREAD_PRIORITY,//Use default thread priority
-1,
this,//Which ACE_Task object to create? In this case this one.
0,// don~Rt care about thread handles used
0,// don~Rt care about where stacks are created
0);//don~Rt care about stack sizes
//thread_names); // keep identifiers in thread_names

return 0;
}

int
PEXEC_Handler::handle_close(ACE_HANDLE,ACE_Reactor_Mask)
{
return 0;
}

int
PEXEC_Handler::handle_timeout(const ACE_Time_Value&, const void*) {

send_wd_heartbeat(PEXEC_SRC_TYPE);
return 0;
}

int
PEXEC_Handler::svc() {

struct buff_stdout outbuff;
struct buff_stderr errbuff;
int exitcode;
status_type exec_status;
int nint;
param_pack pps;

pps = pex_pps;
mutex_.release();

//exec cmdline
exec_status = execprocess(pps.user,
pps.cmdline,
pps.milisec,
exitcode,
outbuff,
errbuff);
nint = htonl(exec_status);
if (peer().send_n((char *)&nint, sizeof(nint), 0) == -1){
ACE_DEBUG((LM_DEBUG, ACE_TEXT("send data error : %s"),
ACE_OS::strerror(ACE_OS::last_error())));
return -1;
}
//cout<<"errbuff.len = "<<errbuff.len<<endl;
//cout<<errbuff.buffer<<endl;
if (exec_status == EXEC_SUCCESS) {
//send exit code back
nint = htonl(exitcode);
if (peer().send_n((char *)&nint, sizeof(nint)) == -1) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("send data error : %s"),
ACE_OS::strerror(ACE_OS::last_error())));
//ACE_OS::printf("send data failed\n");
return -1;
}
if (pps.fexitcode) {
//send stdout len back
nint = htonl(outbuff.len);
if (peer().send_n((char *)&nint, sizeof(nint), 0) == -1) {
//ACE_OS::printf("send data failed\n");
ACE_DEBUG((LM_DEBUG, ACE_TEXT("send data error : %s"),
ACE_OS::strerror(ACE_OS::last_error())));
return -1;
}
if (outbuff.len > 0) {
if (peer().send_n(outbuff.buffer, outbuff.len, 0) == -1) {
//ACE_OS::printf("send data failed\n");
ACE_DEBUG((LM_DEBUG, ACE_TEXT("send data error : %s"),
ACE_OS::strerror(ACE_OS::last_error())));
return -1;
}
}

//send stderr len back
nint = htonl(errbuff.len);
if (peer().send_n((char *)&nint, sizeof(nint), 0) == -1) {
//ACE_OS::printf("send data failed\n");
ACE_DEBUG((LM_DEBUG, ACE_TEXT("send data error : %s"),
ACE_OS::strerror(ACE_OS::last_error())));
return -1;
}
if (errbuff.len > 0) {
if (peer().send_n(errbuff.buffer, errbuff.len, 0) == -1) {
//ACE_OS::printf("send data failed\n");
ACE_DEBUG((LM_DEBUG, ACE_TEXT("send data error : %s"),
ACE_OS::strerror(ACE_OS::last_error())));
return -1;
}
}
}
}
// peer().close();
return 0;
}

int main(int argc, char** argv)
{
ACE_INET_Addr tcp_addr(PEXEC_PORT);
ACE_INET_Addr remote_addr;
PEXEC_Acceptor *acceptor;

ACE::daemonize();
//open log
ofstream *output_file = new ofstream("/home/dware/pexecd.log", ios::out);
if (output_file && output_file->rdstate() == ios::goodbit)
ACE_LOG_MSG->msg_ostream(output_file, 1);
ACE_LOG_MSG->open(argv[0], ACE_Log_Msg::OSTREAM,0);
ACE_DEBUG ((LM_DEBUG, ACE_TEXT ("%T (%t): Starting service.\n")));

acceptor = new PEXEC_Acceptor;

if(acceptor->open(tcp_addr, ACE_Reactor::instance()) == -1)
{
char error_message[64];
printf("[%s|%d]open failed: %s", __FILE__, __LINE__, strerror(errno));
}

PEXEC_Handler My_Pexec_Handler;
ACE_Time_Value timeout(HB_TIMEOUT);
ACE_Reactor::instance()->schedule_timer(&My_Pexec_Handler,0,timeout,timeout);

while(1)
ACE_Reactor::instance()->handle_events();

return 0;
}

status_type execprocess(char* uname,
char* cmdline,
int nmili_sec,
int& exitcode,
struct buff_stdout& outbuff,
struct buff_stderr& errbuff) {

int chuser;
struct passwd *pw;
int pp_out[2], pp_err[2];
pid_t pid;
uid_t uid;
gid_t gid;
char *shellpath, *shellname;
fd_set readfd, allfd;
int nfds, rt_sel;
struct timeval tm;
int nrd_out, nrd_err;
size_t nleft_out, nleft_err;
char *ppos_out, *ppos_err;
char buff_rub[BUFF_SIZ];
int status;
int i;
//enum status_type exec_status;

chuser = strcmp(uname, "root"); /* if we are required to change user id */
//printf("chuser is %d\n", chuser);

if ((pw = getpwnam(uname)) == NULL) { /* get passwd file entry */
ACE_DEBUG((LM_DEBUG, ACE_TEXT("getpwnam error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
uid = pw->pw_uid;
gid = pw->pw_gid;
//printf("%s : uid is %d, gid is %d\n", uname, uid, gid);

/* create pipes for stdout and stderr of child process */
if (pipe(pp_out) != 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("create stdout pipe error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
if (pipe(pp_err) != 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("create stderr pipe error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}

/* create child process */
pid = fork();
if (pid < 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("fork error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
if (pid == 0) { /* child process */

close(pp_out[0]); /* close read end of stdout pipe */
close(pp_err[0]); /* close read end of stderr pipe */

if (dup2(pp_out[1], 1) == -1) { /* make stdout a copy of write end of pipe */
ACE_DEBUG((LM_DEBUG, ACE_TEXT("dup error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
close(pp_out[1]);

if (dup2(pp_err[1], 2) == -1) { /* make stderr a copy of write end of pipe */
ACE_DEBUG((LM_DEBUG, ACE_TEXT("dup error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
close(pp_err[1]);

if (chuser != 0) {
//printf("now changing uid and gid\n");
uid = pw->pw_uid;
gid = pw->pw_gid;
errno = 0;
if (setgid(gid) != 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("setgid error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
if (setuid(uid) != 0) {
ACE_DEBUG((LM_DEBUG, ACE_TEXT("setuid error : %s"), strerror(errno)));
return ERR_EXEC_COMMAND;
}
}

for (i = 3; i < 65536; i++)
ACE_OS::close(i);
//printf("now uid is %d, gid is %d\n", getuid(), getgid());
shellpath = pw->pw_shell;
shellname = strrchr(shellpath, '/');
execl(shellpath, shellname, "-c", cmdline, NULL); /* execute new process */
perror("");
exit(EXIT_FAILURE);
}
/* in parent process */
close(pp_out[1]); /* close write end of stdout pipe */
close(pp_err[1]); /* close write end of stderr pipe */

/* get num of fds to detect */
nfds = (pp_out[0] > pp_err[0]) ? pp_out[0] : pp_err[0];
nfds++;

/* initialization */
tm.tv_usec = (nmili_sec % 1000) * 1000;
tm.tv_sec = nmili_sec / 1000;
nleft_out = STDOUT_BUFF_SIZ;
nleft_err = STDERR_BUFF_SIZ;
outbuff.len = errbuff.len = 0;
ppos_out = outbuff.buffer;
ppos_err = errbuff.buffer;
nrd_out = nrd_err = 0;

FD_ZERO(&allfd);
FD_SET(pp_out[0], &allfd);
FD_SET(pp_err[0], &allfd);

while (1) {
readfd = allfd;
if (nmili_sec > 0)
rt_sel = select(nfds, &readfd, NULL, NULL, &tm);
else
rt_sel = select(nfds, &readfd, NULL, NULL, NULL);
if (rt_sel > 0) {
if (FD_ISSET(pp_out[0], &readfd) != 0) {
if (nleft_out > 0) {
nrd_out = read(pp_out[0], ppos_out, nleft_out);
if (nrd_out > 0) {
ppos_out += nrd_out;
//outbuff.len += nrd_out;
nleft_out -= nrd_out;
}
}
else
nrd_out = read(pp_out[0], buff_rub, sizeof(buff_rub));
}
if (FD_ISSET(pp_err[0], &readfd) != 0) {
if (nleft_err > 0) {
nrd_err = read(pp_err[0], ppos_err, nleft_err);
if (nrd_err > 0) {
ppos_err += nrd_err;
//errbuff.len += nrd_err;
nleft_err -= nrd_err;
}
}
else
nrd_err = read(pp_err[0], buff_rub, sizeof(buff_rub));
}
if (nrd_out == 0 && nrd_err == 0) {
outbuff.len = STDOUT_BUFF_SIZ - nleft_out;
errbuff.len = STDERR_BUFF_SIZ - nleft_err;
*ppos_out = *ppos_err = '\0';
break;
}
}
else
if (rt_sel == 0) {//time out
return ERR_EXEC_TIMEOUT;
}
else
if (rt_sel < 0) {
if (errno == EINTR) {
tm.tv_sec = nmili_sec / 1000; /* reset the timeout value */
tm.tv_usec = 0;
//printf("error\n");
continue;
}
else
break;
}
}
wait(&status);
if (WIFEXITED(status)) {
exitcode = WEXITSTATUS(status);
return EXEC_SUCCESS;
}
else
return ERR_INVALID_EXITCODE;

//turn exec_status;

}