int main(int argc, char ** argv)
{
if (argc < 2) {
fprintf(stderr, "Usage: safeexec COMMAND [COMMAND_ARG...]\n");
return 1;
}
{
const char * command_path = argv[1];
char ** command_args = &argv[1];
int ret;
int ppid = getpid();
ret = fork();
if (ret == -1) { ERR_EXIT("fork() failed"); }
if(ret > 0) {
// parent
if (prctl(PR_SET_PDEATHSIG, SIGTERM) == -1) { ERR_EXIT("parent prctl() failed"); }
return parent_main(ret);
} else {
// child
if (prctl(PR_SET_PDEATHSIG, SIGKILL) == -1) { ERR_EXIT("child prctl() failed"); }
if (ppid != getppid()) { ERRF_EXIT(("parent process(%d) has been dead", ppid)); }
if (execvp(command_path, command_args) == -1) { ERRF_EXIT(("execvp() failed [command = %s]", command_path)); };
}
}
return 0;
}
int
main (int argc, char *argv[])
{
int exitstatus;
if (!(argc > 1 && strcmp (argv[1], "-child") == 0))
{
/* This is the parent process. */
signal (SIGINT, cleanup_then_die);
signal (SIGTERM, cleanup_then_die);
#ifdef SIGHUP
signal (SIGHUP, cleanup_then_die);
#endif
exitstatus = parent_main ();
}
else
{
/* This is the child process. */
exitstatus = child_main ();
}
unlink (DATA_FILENAME);
return exitstatus;
}
int main(int argc, char ** argv)
{
if (argc < 2) {
fprintf(stderr, "Usage: safeexec COMMAND [COMMAND_ARG...]\n");
return 1;
}
{
const char * command_path = argv[1];
char ** command_args = &argv[1];
int ret;
ret = fork();
if (ret == -1) { ERR_EXIT("fork() failed"); }
if(ret > 0) {
// parent
return parent_main(ret);
} else {
// child
// XXX: When the parent process is killed by SIGKILL signal, the child process will be still alive
if (execvp(command_path, command_args) == -1) { ERRF_EXIT(("execvp() failed [command=%s]", command_path)); };
}
}
return 0;
}
int
main (int argc,
char *argv[])
{
int ret;
#ifndef G_OS_WIN32
sigset_t sig_mask, old_mask;
sigemptyset (&sig_mask);
sigaddset (&sig_mask, SIGUSR1);
if (sigprocmask (SIG_UNBLOCK, &sig_mask, &old_mask) == 0)
{
if (sigismember (&old_mask, SIGUSR1))
g_message ("SIGUSR1 was blocked, unblocking it");
}
#endif
dir = g_get_current_dir ();
filename = g_build_filename (dir, "maptest", NULL);
displayname = g_filename_display_name (filename);
childname = g_build_filename (dir, "mapchild", NULL);
if (argc > 1)
ret = child_main (argc, argv);
else
ret = parent_main (argc, argv);
g_free (childname);
g_free (filename);
g_free (displayname);
g_free (dir);
return ret;
}
int
main (int argc,
char *argv[])
{
dir = g_get_current_dir ();
filename = g_build_filename (dir, "maptest", NULL);
displayname = g_filename_display_name (filename);
childname = g_build_filename (dir, "mapchild", NULL);
if (argc > 1)
return child_main (argc, argv);
else
return parent_main (argc, argv);
}
int
main(int argc, const char *argv[])
{
struct sockaddr_storage addr;
struct sockaddr_un *paddr;
sigset_t set;
pid_t pid;
int error, status;
const char *path;
if (argc < 2)
return (1);
path = argv[1];
paddr = (struct sockaddr_un *)&addr;
paddr->sun_family = AF_LOCAL;
strcpy(paddr->sun_path, path);
paddr->sun_len = SUN_LEN(paddr);
if (sigfillset(&set) == -1)
return (2);
if (sigprocmask(SIG_BLOCK, &set, NULL) == -1)
return (3);
pid = fork();
switch (pid) {
case -1:
return (4);
case 0:
return (child_main((struct sockaddr *)paddr));
default:
break;
}
error = parent_main((struct sockaddr *)paddr, pid);
if (wait4(pid, &status, 0, NULL) == -1)
return (5);
if (!WIFEXITED(status))
return (6);
if (WEXITSTATUS(status) != 0)
return (64 + WEXITSTATUS(status));
return (error == 0 ? 0 : (32 + error));
}
int main() {
common_initialize();
pid_t child_pid = fork();
if (child_pid == 0) {
// In child
return child_main();
}
// In parent
int ret = parent_main();
int status,
wait_ret = waitpid(child_pid, &status, 0);
if (wait_ret != child_pid || !WIFEXITED(status)) {
return 1 | ret;
}
return ret;
}
int main(int argc, char *argv[])
{
int pfd[2];
struct flock fl;
socketpair(AF_UNIX, SOCK_STREAM, 0, pfd);
printf("sizeof(off_t) : %d\n", sizeof(off_t));
printf("sizeof(size_t) : %d\n", sizeof(size_t));
printf("sizeof(l_start) : %d\n", sizeof(fl.l_start));
if ((child_pid=fork()) == 0) {
close(pfd[0]);
child_main(pfd[1]);
} else {
close(pfd[1]);
parent_main(pfd[0]);
}
return 0;
}
int daemon_main(const char * ident, const daemon_winsvc_options * svc_opts,
int (*main_func)(int, char **), int argc, char **argv )
{
int rc;
#ifdef _DEBUG
// Enable Debug heap checks
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG)
|_CRTDBG_ALLOC_MEM_DF|_CRTDBG_CHECK_ALWAYS_DF|_CRTDBG_LEAK_CHECK_DF);
#endif
// Check for [status|stop|reload|restart|sigusr1|sigusr2] parameters
if ((rc = initd_main(ident, argc, argv)) >= 0)
return rc;
// Check for [install|remove] parameters
if (svc_opts && (rc = svcadm_main(ident, svc_opts, argc, argv)) >= 0)
return rc;
// Run as service if svc_opts.cmd_opt is given as first(!) argument
svc_mode = (svc_opts && argc >= 2 && !strcmp(argv[1], svc_opts->cmd_opt));
if (!svc_mode) {
// Daemon: Try to simulate a Unix-like daemon
HANDLE rev;
BOOL exists;
// Create main event to detect process type:
// 1. new: parent process => start child and wait for detach() or exit() of child.
// 2. exists && signaled: child process => do the real work, signal detach() to parent
// 3. exists && !signaled: already running => exit()
if (!(rev = create_event(EVT_RUNNING, TRUE/*signaled*/, TRUE, &exists)))
return 100;
if (!exists && !debugging()) {
// Event new => parent process
return parent_main(rev);
}
if (WaitForSingleObject(rev, 0) == WAIT_OBJECT_0) {
// Event was signaled => In child process
return child_main(rev, main_func, argc, argv);
}
// Event no longer signaled => Already running!
daemon_help(stdout, ident, "already running");
CloseHandle(rev);
return 1;
}
else {
// Service: Start service_main() via SCM
SERVICE_TABLE_ENTRY service_table[] = {
{ (char*)svc_opts->svcname, service_main }, { NULL, NULL }
};
svc_main_func = main_func;
svc_main_argc = argc;
svc_main_argv = argv;
if (!StartServiceCtrlDispatcher(service_table)) {
printf("%s: cannot dispatch service, Error=%ld\n"
"Option \"%s\" cannot be used to start %s as a service from console.\n"
"Use \"%s install ...\" to install the service\n"
"and \"net start %s\" to start it.\n",
ident, GetLastError(), svc_opts->cmd_opt, ident, ident, ident);
#ifdef _DEBUG
if (debugging())
service_main(argc, argv);
#endif
return 100;
}
Sleep(1000);
ExitThread(0); // Do not redo exit() processing
/*NOTREACHED*/
return 0;
}
}
int ACEApp::init(int argc, ACE_TCHAR* argv[])
{
// get the program name
#ifdef WIN32
char* ptr = ACE_OS::strrchr(argv[0], '\\');
#else
char* ptr = ACE_OS::strrchr(argv[0], '/');
#endif
if (ptr)
{
// strip path name
strcpy(program_, ptr + 1);
}
else
{
strcpy(program_, argv[0]);
}
#ifdef WIN32
// strip .exe extension on WIN32
ptr = strchr(program_, '.');
if (ptr)
{
*ptr = '\0';
}
#endif
int child_proc_num = 0;
ACE_Get_Opt get_opt(argc, argv, "vdp:c:");
char c;
while ((c = get_opt()) != EOF)
{
switch (c)
{
case 'd': // run as daemon
ACE::daemonize();
break;
case 'p': // specified program name
strcpy(program_, get_opt.opt_arg());
break;
case 'c': // child process number
child_proc_num = atoi(get_opt.opt_arg());
break;
case 'v':
//disp version info
disp_version();
return 0;
default:
break;
}
}
ACE_OS::signal (SIGPIPE, SIG_IGN);
ACE_OS::signal (SIGTERM, SIG_IGN);
ACE_OS::signal (SIGCHLD, SIG_IGN);
ACE_Sig_Action sig_int((ACE_SignalHandler)daemon_quit, SIGINT);
//ACE_Sig_Action sig_term((ACE_SignalHandler)daemon_quit, SIGTERM);
//ACE_Sig_Action sig_chld((ACE_SignalHandler)child_sighdr, SIGCHLD);
ACE_UNUSED_ARG(sig_int);
//ACE_UNUSED_ARG(sig_term);
//ACE_UNUSED_ARG(sig_chld);
//在 init_log() 之前即可
if (init_reactor() != 0)
{
ACE_DEBUG((LM_ERROR, "[%D] init reactor failed, program exit\n"));
return -1;
}
ACE_DEBUG((LM_INFO, "[%D] init reactor succ\n"));
if (init_sys_path(program_) != 0)
{
ACE_DEBUG((LM_ERROR, "[%D] init sys path failed, program exit\n"));
return -1;
}
if (init_conf() != 0)
{
ACE_DEBUG((LM_ERROR, "[%D] init conf failed, program exit\n"));
return -1;
}
ACE_DEBUG((LM_INFO, "[%D] init conf succeed\n"));
if (init_log() != 0)
{
ACE_DEBUG((LM_ERROR, "[%D] init log failed, program exit\n"));
return -1;
}
ACE_DEBUG((LM_INFO, "[%D] init log succ\n"));
//版本信息记录日志
disp_version();
if (init_app(argc, argv) != 0)
{
ACE_DEBUG((LM_ERROR, "[%D] init app failed, program exit\n"));
return -1;
}
ACE_DEBUG((LM_INFO, "[%D] init app succ\n"));
write_pid_file();
ACE_DEBUG((LM_INFO, "[%D] write pid file succ\n"));
if (child_proc_num > 0)
{
parent_main(child_proc_num);
}
else
{
ACE_DEBUG((LM_INFO, "[%D] enter daemon main pid: %d\n",
ACE_OS::getpid()));
daemon_main();
ACE_DEBUG((LM_INFO, "[%D] leave daemon main pid: %d\n",
ACE_OS::getpid()));
}
quit_app();
return 0;
}
