/* Entry point */
int
main(int argc, char **argv)
{
	/* Init debugging level */
	mem_allocated = 0;
	debug = 0;

	/*
	 * Parse command line and set debug level.
	 * bits 0..7 reserved by main.c
	 */
	parse_cmdline(argc, argv);

	openlog(PROG, LOG_PID | ((debug & 1) ? LOG_CONS : 0), log_facility);
	log_message(LOG_INFO, "Starting " VERSION_STRING);

	/* Check if keepalived is already running */
	if (keepalived_running(daemon_mode)) {
		log_message(LOG_INFO, "daemon is already running");
		goto end;
	}

	if (debug & 1)
		enable_console_log();

	/* daemonize process */
	if (!(debug & 2))
		xdaemon(0, 0, 0);

	/* write the father's pidfile */
	if (!pidfile_write(main_pidfile, getpid()))
		goto end;

#ifndef _DEBUG_
	/* Signal handling initialization  */
	signal_init();
#endif

	/* Create the master thread */
	master = thread_make_master();

	/* Init daemon */
	start_keepalived();

#ifndef _DEBUG_
	/* Launch the scheduling I/O multiplexer */
	launch_scheduler();

	/* Finish daemon process */
	stop_keepalived();
#endif

	/*
	 * Reached when terminate signal catched.
	 * finally return from system
	 */
end:
	closelog();
	exit(0);
}

static rstatus_t
dn_pre_run(struct instance *nci)
{
    rstatus_t status;

    status = log_init(nci->log_level, nci->log_filename);
    if (status != DN_OK) {
        return status;
    }

    if (daemonize) {
        status = dn_daemonize(1);
        if (status != DN_OK) {
            return status;
        }
    }

    nci->pid = getpid();

    status = signal_init();
    if (status != DN_OK) {
        return status;
    }

    if (nci->pid_filename) {
        status = dn_create_pidfile(nci);
        if (status != DN_OK) {
            return status;
        }
    }

    dn_print_run(nci);

    return DN_OK;
}

int main(int argc, char **argv) {
    if (-1 == check_para(argc, argv)) {
        PRINTF(LEVEL_ERROR, "check argument error.\n");
        return -1;
    }

    signal_init();

    PRINTF(LEVEL_INFORM, "socks5 starting, port: %d\n", g_cfg.port);

    g_cfg.fd = socks5_srv_init(g_cfg.port, 10);
    if (-1 == g_cfg.fd) {
        PRINTF(LEVEL_ERROR, "socks server init error.\n");
        return -1;
    }

    g_cfg.state = SOCKS5_STATE_RUNNING;

    g_loop = ev_default_loop(0);

    ev_io_init(&g_io_accept, accept_cb, g_cfg.fd, EV_READ);
    ev_io_start(g_loop, &g_io_accept);

    ev_loop(g_loop, 0);

    PRINTF(LEVEL_INFORM, "time to exit.\n");
    socks5_srv_exit();
    PRINTF(LEVEL_INFORM, "exit socket server.\n");
    return 0;
}

void
silly_run(struct silly_config *config)
{
	int i;
	int err;
	pthread_t pid[3];
	R.run = 1;
	R.exit = 0;
	pthread_mutex_init(&R.mutex, NULL); 
	pthread_cond_init(&R.cond, NULL);
	if (config->daemon)
		silly_daemon(config);
	signal_init();
	silly_timer_init();
	err = silly_socket_init();
	if (err < 0) {
		fprintf(stderr, "%s socket init fail:%d\n", config->selfname, err);
		exit(-1);
	}
	silly_worker_init();
	srand(time(NULL));
	thread_create(&pid[0], thread_socket, NULL);
	thread_create(&pid[1], thread_timer, NULL);
	thread_create(&pid[2], thread_worker, config);
	fprintf(stdout, "%s is running ...\n", config->selfname);
	for (i = 0; i < 3; i++)
		pthread_join(pid[i], NULL);
	pthread_mutex_destroy(&R.mutex);
	pthread_cond_destroy(&R.cond);
	silly_worker_exit();
	silly_timer_exit();
	silly_socket_exit();
	fprintf(stdout, "%s has already exit...\n", config->selfname);
	return ;
}

static int test_signal_handler(const char *argv0, const char *tempdir, int sig)
{
	int ret, pid, status;
	char err[512] = { 0 };
	char crash_log_path[PATH_MAX];
	snprintf(crash_log_path, sizeof(crash_log_path), "%s/crash.log.%d",
		 tempdir, rand());
	pid = fork();
	if (pid == -1) {
		ret = errno;
		return ret;
	}
	else if (pid == 0) {
		struct logc lc;
		memset(&lc, 0, sizeof(lc));
		lc.crash_log_path = crash_log_path;
		signal_init(argv0, err, sizeof(err), &lc);
		if (err[0]) {
			fprintf(stderr, "signal_init error: %s\n", err);
			_exit(1);
		}
		raise(sig);
		_exit(1);
	}
	RETRY_ON_EINTR(ret, waitpid(pid, &status, 0));

	EXPECT_ZERO(validate_crash_log(crash_log_path, sig));
	return 0;
}

void sdl_application::execute(window& win)
{
	signal_init();

	SDL_GL_SetSwapInterval(1);

#ifdef EMSCRIPTEN

	emscripten_set_main_loop_arg(update_c_function, this, -1, 1);

#else

	SDL_GL_SetSwapInterval(0);

	while (running)
	{
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
		update_c_function(this);
		SDL_GL_SwapWindow(win.m_window);
	}

#endif

	signal_quit();
}

int mshell_init(struct mshell *mshell, int argc, char **argv, char **env)
{
	memset(mshell, 0, sizeof(struct mshell));
	mshell->user = getpwuid(getuid());
	mshell->main_loop = 1;
	mshell->is_show_cmdline = 1;
	getcwd(mshell->cur_dir, PATH_MAX);
	mshell->fd = 0;
	mshell->pipe = -1;
	mshell->wait_for_childs = 0;

	/*需要执行脚本*/
	if(argc >= 2) {
		mshell->fd = open(argv[1], O_RDONLY);
		if(mshell->fd < 0) {
			mshell->main_loop = 0;
			perror("open");
			return 0;
		}
		mshell->is_show_cmdline = 0;
	}

	signal_init();
	load_env(mshell, env);
	return 0;
}

int
main(int argc, char **argv)
{
	thread thread_obj;

	/* Allocate the room */
	req = (REQ *) MALLOC(sizeof (REQ));

	/* Command line parser */
	if (!parse_cmdline(argc, argv, req)) {
		FREE(req);
		exit(0);
	}

	/* Check minimum configuration need */
	if (!req->addr_ip && !req->addr_port && !req->url) {
		FREE(req);
		exit(0);
	}

	/* Init the reference timer */
	req->ref_time = timer_tol(timer_now());
	DBG("Reference timer = %lu\n", req->ref_time);

	/* Init SSL context */
	init_ssl();

	/* Signal handling initialization  */
	signal_init();

	/* Create the master thread */
	master = thread_make_master();

	/* Register the GET request */
	init_sock();

	/*
	 * Processing the master thread queues,
	 * return and execute one ready thread.
	 * Run until error, used for debuging only.
	 * Note that not calling launch_scheduler() does
	 * not activate SIGCHLD handling, however, this
	 * is no issue here.
	 */
	while (thread_fetch(master, &thread_obj))
		thread_call(&thread_obj);

	/* Finalize output informations */
	if (req->verbose)
		printf("Global response time for [%s] =%lu\n",
		       req->url, req->response_time - req->ref_time);

	/* exit cleanly */
	SSL_CTX_free(req->ctx);
	free_sock(sock);
	FREE(req);
	exit(0);
}

int			main()
{
  struct sigaction	*act;

  if (!(act = act_init(act)))
    my_error(4, 6);
  signal_init(act);
  print_pid(getpid());
  call_next_client(getpid());
}

static void init_subsystems()
{
	shared_init();
	heap_init();
	signal_init();
	process_init();
	tls_init();
	vfs_init();
	dbt_init();
}

error_t thread_dup(struct task_s *task,
                   struct thread_s *dst,
                   struct cpu_s *dst_cpu,
                   struct cluster_s *dst_clstr,
                   struct thread_s *src)
{
    register uint_t sched_policy;
    register uint_t cpu_lid;
    register uint_t cid;
    struct page_s *page;

    sched_policy = sched_getpolicy(src);
    cpu_lid      = dst_cpu->lid;
    cid          = dst_clstr->id;
    page         = dst->info.page;

    // Duplicate
    page_copy(page, src->info.page);

    // Initialize dst thread
    spinlock_init(&dst->lock, "Thread");
    dst->flags                           = 0;
    thread_clear_joinable(dst);
    dst->locks_count                     = 0;
    dst->ticks_nr                        = 0;
    thread_set_current_cpu(dst, dst_cpu);
    sched_setpolicy(dst, sched_policy);
    dst->task                            = task;
    dst->type                            = PTHREAD;
    dst->info.sched_nr                   = 0;
    dst->info.ppm_last_cid               = cid;
    dst->info.migration_cntr             = 0;
    dst->info.migration_fail_cntr        = 0;
    dst->info.tm_exec                    = 0;
    dst->info.tm_tmp                     = 0;
    dst->info.tm_usr                     = 0;
    dst->info.tm_sys                     = 0;
    dst->info.tm_sleep                   = 0;
    dst->info.tm_wait                    = 0;
    signal_init(dst);
    dst->info.join                       = NULL;
    wait_queue_init(&dst->info.wait_queue, "Join/Exit Sync");
    dst->info.attr.sched_policy          = sched_policy;
    dst->info.attr.cid                   = cid;
    dst->info.attr.cpu_lid               = cpu_lid;
    dst->info.attr.cpu_gid               = dst_cpu->gid;
    dst->info.attr.tid                   = (uint_t) dst;
    dst->info.attr.pid                   = task->pid;
    dst->info.kstack_addr                = (uint_t*)dst;
    dst->info.page                       = page;
    dst->signature                       = THREAD_ID;

    return 0;
}

static void init() {

    int initialized = protocol_init() && caps_init() && signal_init() && comm_init() && injectable_init();
    
    if (!initialized) {
        fatal("Initialization failed.");
        cleanup();
        exit(EXIT_FAILURE);
    }
    
}

int main()
{
	int fd;
	char buf[MAX_MSG_LEN] = {0};
	char client_name[128] = {0};
	pid_t pid;

	signal_init();
	
	sprintf(client_name, "%05d.socket", getpid());

	fd = client_conn(SERVER_IPC_DOMAIN_NAME, client_name);

	pid = fork();

	if (pid < 0)
	{
		DEBUG_ERR("fork error\n");
	}
	else if (pid == 0)
	{
		sprintf(client_name, "%05d.socket", getpid());
		fd = client_conn(SERVER_IPC_DOMAIN_NAME, client_name);
		if (fd < 0)
		{
			DEBUG_ERR("create server unix domain socket error\n");
			return -1;
		}

		memset(buf, 0 ,sizeof(buf));
		sprintf(buf, "client_name %s", client_name);
		write(fd, buf, sizeof(buf));

		close(fd);
		unlink(client_name);

		exit(0);
	}
	
	if (fd < 0)
	{
		DEBUG_ERR("create server unix domain socket error\n");
		return -1;
	}

	sprintf(buf, "client_name %s", client_name);
	swriten(fd, buf, sizeof(buf));

	close(fd);
	unlink(client_name);
	
	return 0;
}

void event_init()
{
  // Initialize input events
  input_init();
  // Timer to wake the event loop if a timeout argument is passed to
  // `event_poll`
  // Signals
  signal_init();
  uv_timer_init(uv_default_loop(), &timer);
  // This prepare handle that actually starts the timer
  uv_prepare_init(uv_default_loop(), &timer_prepare);
}

int
main(int argc, char * const argv[])
{
	int c;
	boolean_t fork = B_TRUE;

	progname = basename(strdup(argv[0]));

	if ((fmri = (const char *)getenv("SMF_FMRI")) == NULL)
		fmri = DEFAULT_FMRI;

	(void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)
#define	TEXT_DOMAIN "SYS_TEST"
#endif
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, "djn")) != EOF) {
		switch (c) {
		case 'd':
			dlevel = 0xffff;
			break;
		case 'j':
			json = B_TRUE;
			break;
		case 'n':
			fork = B_FALSE;
			break;
		default:
			(void) fprintf(stderr, gettext("Unknown option "
			    "\'%c\'.\n"), c);
			usage(progname);
		}
	}

	pid = getpid();

	if ((main_port = port_create()) == -1)
		err(EXIT_FAILURE, "port_create() failed");

	list_create(&links, sizeof (link_t), offsetof(link_t, node));

	VERIFY(get_sysinfo());
	lldp_read_config();
	signal_init();
	get_port_list();
	lldp_init(4);
	cdp_init(4);
	main_loop();

	return (0);
}

/*
 * Initialize whatever we need
 * for dealing with external processes
 */
void
ex_init(void) {
	keytab_init();
	well_known_init();
	signal_init();

	historyfile = getenv("HISTORY");
	if(!historyfile)
		historyfile = getenv("history");

	shell =  getenv("SHELL");
	if(!shell)
		shell=DEFAULTSHELL;
}

// Init BSP-core
int core_init()
{
    if (!core_settings.initialized)
    {
        init_core_setting();
    }

    if (core_settings.is_daemonize)
    {
        proc_daemonize();
    }

    fd_init(0);
    log_init();
    load_runtime_setting();
    status_op_core(STATUS_OP_INSTANCE_ID, (size_t) core_settings.instance_id);
    thread_init();
    save_pid();
    signal_init();
    socket_init();
    memdb_init();
    online_init();

    // Load modules
    BSP_VALUE *val = object_get_hash_str(runtime_settings, "modules");
    BSP_OBJECT *vobj = value_get_object(val);
    BSP_STRING *vstr = NULL;
    if (vobj && OBJECT_TYPE_ARRAY == vobj->type)
    {
        size_t varr_size = object_size(vobj), i;
        if (varr_size > MAX_MODULES)
        {
            varr_size = MAX_MODULES;
        }

        reset_object(vobj);
        for (i = 0; i < varr_size; i ++)
        {
            val = object_get_array(vobj, i);
            vstr = value_get_string(val);
            if (vstr)
            {
                script_load_module(vstr, 1);
            }
        }
    }

    return BSP_RTN_SUCCESS;
}

int
main (void)
{
  master = thread_master_create ();
  signal_init (master, array_size(sigs), sigs);
  
  zlog_default = openzlog("testsig", ZLOG_NONE,
                          LOG_CONS|LOG_NDELAY|LOG_PID, LOG_DAEMON);
  zlog_set_level (NULL, ZLOG_DEST_SYSLOG, ZLOG_DISABLED);
  zlog_set_level (NULL, ZLOG_DEST_STDOUT, LOG_DEBUG);
  zlog_set_level (NULL, ZLOG_DEST_MONITOR, ZLOG_DISABLED);
  
  while (thread_fetch (master, &t))
    thread_call (&t);

  exit (0);
}

static int process_ctx_init_impl(const char *argv0, int daemonize,
				struct logc *lc)
{
	char err[512] = { 0 };
	size_t err_len = sizeof(err);

	configure_glitch_log(lc);
	g_fast_log_mgr = fast_log_mgr_init(g_fast_log_dumpers);
	if (IS_ERR(g_fast_log_mgr)) {
		glitch_log("fast_log_mgr_init failed with error %d",
			PTR_ERR(g_fast_log_mgr));
		g_fast_log_mgr = NULL;
		goto error_close_glitchlog;
	}
	if (lc->fast_log == JORM_INVAL_STR)
		configure_fast_log(getenv("REDFISH_LOG"));
	else
		configure_fast_log(lc->fast_log);
	signal_init(argv0, err, err_len, lc);
	if (err[0]) {
		glitch_log("signal_init error: %s\n", err);
		goto error_free_fast_log_mgr;
	}
	if (daemonize) {
		if (daemon(0, 0) < 0) {
			int ret = errno;
			glitch_log("daemon(3) error %d\n", ret);
			goto error_signal_shutdown;
		}
	}
	create_pid_file(lc, err, err_len);
	if (err[0]) {
		glitch_log("create_pid_file error: %s\n", err);
		goto error_signal_shutdown;
	}
	return 0;

error_signal_shutdown:
	signal_shutdown();
error_free_fast_log_mgr:
	fast_log_mgr_release(g_fast_log_mgr);
	g_fast_log_mgr = NULL;
error_close_glitchlog:
	close_glitch_log();
	return 1;
}

int main(int argc, char *argv[])
{
    struct sock_t sock;
    struct sock_bind_t sock_bind;
    struct user_param_t *user_param = &(rdma_resource.user_param);

    RDMAParser parser;
    if(!parser.Parse(&(rdma_resource.user_param), argv, argc))
    {
        g_lastErrorCode = IBDT_E_InvalidParam;
        return g_lastErrorCode;
    }

    sock_bind.socket_fd = -1;
    sock_bind.counter = 0;
    sock_bind.is_daemon = (user_param->server_ip == NULL) ? 1 : 0;
    sock_bind.port = user_param->tcp_port;
    if (user_param->server_ip)
    {
        strcpy(sock_bind.ip, user_param->server_ip);
    }

    signal_init();
    RDMASock::sock_init(&sock);

    if(!RDMAResource::InitResource(&sock, &rdma_resource))
    {
        goto cleanup;
    }

    if(!RDMAThread::StartRDMAThreads(&rdma_resource, &sock_bind))
    {
        printf("Testing failed\n");
    }

    while(!stop_all)
    {
        if(!sock_bind.is_daemon)
            break;
    }

cleanup:
    RDMAResource::DestroyResource(&rdma_resource);

    return g_lastErrorCode;
}