int main(int argc, char *argv[]){

	char *service = SERVER_PORT;
	if (daemon_init() == -1){
		printf("can't fork self\n");
		exit(0);
	}

    if(is_already_running(argv[0]) != 0){
        fprintf(stdout, "%s process is already exists.\n", argv[0]);
        exit(-1);
    }

	int servSock = SetupTcpServerSocket(service);
	if(servSock < 0){
		fprintf(stderr, "SetupTCPServerSocket() failed");
	}

	for(; ;){
		int clntSock = AcceptTcpConnection(servSock);

		HandleTcpClient(clntSock);
		close(clntSock);
	}
}

void
action_eapol_success(const struct eap_header *eap_head,
                        const struct pcap_pkthdr *packetinfo,
                        const uint8_t *packet)
{
    extern enum STATE   state;
    extern int          background;
    extern pthread_t    live_keeper_id;

    state = ONLINE;
    fprintf(stdout, ">>Protocol: EAP_SUCCESS\n");
    fprintf(stdout, "&&Info: Authorized Access to Network. \n");
    print_server_info (packet, packetinfo->caplen, EAP_SUCCESS);

    /* 成为后台守护进程 */
    if (background){
        background = 0;         /* 防止以后误触发 */
        daemon_init();
    }
    /* 获得succes_key */
    ruijie_succes_key = ntohl (
            ruijie_byte_to_int32 (
                (const uint8_t*)(packet + 0x104)));

    /* 打开保持线程 */
    if ( !live_keeper_id ) {
        if ( pthread_create(&live_keeper_id, NULL, 
                    keep_alive, NULL) != 0 ){
            fprintf(stderr, "@@Fatal ERROR: "
                            "Init Life Keeper Thread Failure.\n");
            exit (EXIT_FAILURE);
        }
    }
}

/**
 * Run the daemon. 
 * @param cfgfile: the config file name.
 * @param cmdline_verbose: verbosity resulting from commandline -v.
 *    These increase verbosity as specified in the config file.
 * @param debug_mode: if set, do not daemonize.
 * @param log_default_identity: Default identity to report in logs
 */
static void 
run_daemon(const char* cfgfile, int cmdline_verbose, int debug_mode, const char* log_default_identity)
{
	struct config_file* cfg = NULL;
	struct daemon* daemon = NULL;
	int done_setup = 0;

	if(!(daemon = daemon_init()))
		fatal_exit("alloc failure");
	while(!daemon->need_to_exit) {
		if(done_setup)
			verbose(VERB_OPS, "Restart of %s.", PACKAGE_STRING);
		else	verbose(VERB_OPS, "Start of %s.", PACKAGE_STRING);

		/* config stuff */
		if(!(cfg = config_create()))
			fatal_exit("Could not alloc config defaults");
		if(!config_read(cfg, cfgfile, daemon->chroot)) {
			if(errno != ENOENT)
				fatal_exit("Could not read config file: %s",
					cfgfile);
			log_warn("Continuing with default config settings");
		}
		apply_settings(daemon, cfg, cmdline_verbose, debug_mode, log_default_identity);
		if(!done_setup)
			config_lookup_uid(cfg);
	
		/* prepare */
		if(!daemon_open_shared_ports(daemon))
			fatal_exit("could not open ports");
		if(!done_setup) { 
			perform_setup(daemon, cfg, debug_mode, &cfgfile);
			done_setup = 1; 
		} else {
			/* reopen log after HUP to facilitate log rotation */
			if(!cfg->use_syslog)
				log_init(cfg->logfile, 0, cfg->chrootdir);
		}
		/* work */
		daemon_fork(daemon);

		/* clean up for restart */
		verbose(VERB_ALGO, "cleanup.");
		daemon_cleanup(daemon);
		config_delete(cfg);
	}
	verbose(VERB_ALGO, "Exit cleanup.");
	/* this unlink may not work if the pidfile is located outside
	 * of the chroot/workdir or we no longer have permissions */
	if(daemon->pidfile) {
		int fd;
		/* truncate pidfile */
		fd = open(daemon->pidfile, O_WRONLY | O_TRUNC, 0644);
		if(fd != -1)
			close(fd);
		/* delete pidfile */
		unlink(daemon->pidfile);
	}
	daemon_delete(daemon);
}

void init(char *name, char *pass, int port)
{
    signal_setup();
    memset(&config, 0, sizeof(config));

    // set defaults
    config.buffer_start_fill = 220;
    config.port = port;
    config.password = pass;
    config.apname = name;
    if (config.daemonise)
    {
        daemon_init();
    }

    log_setup();
    config.output = audio_get_output(config.output_name);
    config.output->init();

    uint8_t ap_md5[16];
    MD5_CTX ctx;
    MD5_Init(&ctx);
    MD5_Update(&ctx, config.apname, strlen(config.apname));
    MD5_Final(ap_md5, &ctx);
    memcpy(config.hw_addr, ap_md5, sizeof(config.hw_addr));
    if (config.meta_dir)
        metadata_open();

    rtsp_listen_loop();
}

int main(int argv, char* argc[])
{
	long file_size;
	if((file_size=(daemon_init(argc[1],argc[2],argc[3])))==-1)
	{
		fprintf(stderr, "Error setting up daemon.\r\n\
				Please run with <Log_File> <File_To_Watch> {OPTIONAL} <Daemon_Name>\r\n");

//--------------------------------------------------------------------
// Main function
//--------------------------------------------------------------------
int main(int argc, char **argv)
{
  daemon_init(argv[0]);

  syslog(LOG_USER | LOG_DEBUG, "[%d]Starting ...", getpid());

  //typedef void (*sighandler_t) (int);
  //sighandler_t signal(int signum, sighandler_t handler);
  signal(SIGTERM, signal_handler);
  signal(SIGINT, signal_handler);
  signal(SIGQUIT, signal_handler);

  for (;;)
  {
    if (global_exit_flag > 0)
    {
      syslog(LOG_USER | LOG_DEBUG, "It's time to exit, see you later.");
      break;
    }

    // do something here.
    sleep(1);
  }

  closelog();

  return 0;
}

int main(int argc,char *argv[])
{
    void thread_make(int);
    int i,nthreads;
    socklen_t addrlen;

    if(argc<3||argc>4)
        err_quit("usage:server [<host>] <port#> <#threads>");

    daemon_init(argv[0],0);  /*守护进程化当前进程*/

    if(argc==3)
    {
        listenfd=Tcp_listen(NULL,argv[1],&addrlen);
    }
    else if(argc==4)
    {
        listenfd=Tcp_listen(argv[1],argv[2],&addrlen);
    }

    nthreads=atoi(argv[argc-1]);
    tptr=Calloc(nthreads,sizeof(pthread_t));
    for(i=0; i<nthreads; i++)
    {
        thread_make(i);
    }
    for(;;)
        pause();
}

int main(int argc, char *argv[])
{

    if(daemon_init(argc, argv) <0) {
        return -1;
    }

    char log_path[256] = {0};
    if(!GetIniSectionItem(ulu_c2hd_upgrade_conf, "me", "log_path", log_path)) {
        strcat(log_path, "./");
    }

    log::instance()->init(log_path, "ulu_c2hd_upgrade");
    debug_log("log_path = %s\n", log_path);

    if(web_interface::instance()->get_server_list(ulu_c2hd_upgrade_conf, type_devmgr_server) <0) {
        error_log("get_server_list fail, exit in 2s\n");
        sleep(2);
        return -1;
    }

    server * s = base_server::instance();
    s->init();

    int appid = s->register_app(new upgradeapp, 10000, "upgrade");
    s->post_app_msg(appid, ev_init_app);

    s->loop();

    return 0;
}

int main (int argc, char *argv[])
{
    char *groupaddress = "ff18:583:786d:8ec9:d3d6:fd2b:1155:e066";
    char *interface = NULL;

    openlog("ubavahid",LOG_PID | LOG_PERROR ,LOG_DAEMON);
    segfault_init();

    if (!g_thread_supported ()) g_thread_init (NULL);
    g_type_init();
    GMainLoop * mainloop = g_main_loop_new(NULL,FALSE);
    
    if( argc < 2 ){
        syslog(LOG_ERR, "Please specify an interface to bind to.");
        return 1;
    }
    interface = argv[1];

    if( argc > 2 ){
        groupaddress = argv[2];
    }

    avahi_init(mainloop);
    ubavahid_init(interface, groupaddress);

    if( argc < 4 ){
        daemon_init();
        openlog("ubavahid", LOG_PID , LOG_DAEMON);
        daemon_close_stderror();
    }

    g_main_loop_run(mainloop);
    return 0;
}

int main(int argc, char **argv) {
    int listenfd, connfd;
    socklen_t addrlen, len;
    struct sockaddr *cliaddr;
    char buff[MAXLINE];
    time_t ticks;

    if (argc < 2 || argc > 3)
        err_quit("usage: daytimetcpsrv2 [ <host> ] <service or port#>");

    daemon_init(argv[0], 0);

    if (argc == 2)
        listenfd = Tcp_listen(NULL, argv[1], &addrlen);
    else
        listenfd = Tcp_listen(argv[1], argv[2], &addrlen);

    cliaddr = Malloc(addrlen);

    for (;;) {
        len = addrlen;
        connfd = Accept(listenfd, cliaddr, &len);
        err_msg("connection from %s", Sock_ntop(cliaddr, len));
        ticks = time(NULL);
        snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
        Write(connfd, buff, strlen(buff));
        Close(connfd);
    }
}

int main(int argc, char *argv[])
{

 	if(daemon_init(argc, argv) <0){
 		return -1;
 	}

	char log_path[256] = {0};
	if(!GetIniSectionItem(ulu_c2hd_upgrade_conf, "me", "log_path", log_path)){
		strcat(log_path, "./");
	}

	debug_log("log_path = %s\n", log_path);
	server * s = base_server::instance();
	
	s->init();
	log::instance()->init(log_path, "ulu_c2hd_upgrade");
	
	int appid = s->register_app(new upgradeapp, 10000, "upgrade"); 
	s->post_app_msg(appid, ev_init_app);
	
	s->loop();
	
	return 0;
}

int
main(int argc, char **argv)
{
    /* network */
    int		     listenfd, connfd;
    int                  servport;
    struct sockaddr_in   servaddr;
    char		     readline[MAXLINE];

    /* data */
    struct cmd           cmd;
    int                  ndata = 0;
    int                  err,c;
    char                 data[MAXBUFF];


    servport = atoi(WPORT);
    daemon_init(argv[0], 0);

    /* parse commandline */
    while ((c = getopt(argc, argv, "p:")) != -1) {
        switch(c) {
        case 'p':
            servport = atoi(optarg);
            break;
        case '?':
            usaged(1,"command line error","");
            break;
        }
    }


    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family      = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    servaddr.sin_port        = htons(servport);

    Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));

    Listen(listenfd, LISTENQ);

    for ( ; ; ) {
        connfd = accept(listenfd, (SA *) NULL, NULL);
        Read(connfd, readline, MAXLINE);
        cmd.command = atoi(readline);
        cmd.argcmd  = 0;
        cmd.netflg  = 0;

        err = getsrd( data, &ndata, &cmd);

        Write(connfd, data, ndata);

        Close(connfd);
    }
}

int main(int argc, char *argv[])
{
	int retVal;
	pthread_t threadId;
	
	//check for arguments
	if( argc < 2 )
	{
		fprintf(stderr, "Usage: %s [port]\n", argv[0]);
		exit(1);
	}
	
	//spawn daemon
	daemon_init("hakims_HW7_server", LOG_DAEMON);
	
	weblog = fopen("weblog", "a");
	
	//open socket
	sock = socket(AF_INET, SOCK_STREAM, 0);
	QAP(sock >= 0, "Error opening socket.\n", NULL);
	
	//nullify server, and initialize
	memset( (char*)&server, 0, sizeof(server));
	server.sin_family = AF_INET;
	server.sin_addr.s_addr = INADDR_ANY;
	server.sin_port = htons( (unsigned short)atoi(argv[1]) );
	
	//bind socket
	if( bind(sock, (struct sockaddr*)&server, sizeof(server)) < 0 )
		QAP(0, "Error binding socket.\n", NULL);
	
	//listen for incoming connections
	if( listen(sock, THREADCOUNT) < 0 ) //backlog set to # of threads
		QAP(0, "Error listening to socket.\n", NULL);
	
	//keep accepting connections
	while(1)
	{
		//sleeps until connection to accept is available
		connection* con = malloc( sizeof(connection) );
		socklen_t fromSize = sizeof(con->from);
		
		//accept sometimes returns a bad FD, but looping until a good one is returned works.
		do
		{
			con->sock = accept(sock, (struct sockaddr*)&(con->from), &fromSize);
		}
		while(con->sock < 0);
		
		
		//spawn thread
		retVal = pthread_create(&threadId, NULL, &ThreadRoutine, con);
		QAP(retVal == 0, "Error in pthread_create.\n", NULL);
	}
	
	return 0;
}

int main(int argc,char ** argv)
{
  daemon_init();
  for (;;)
  {
    process_commands();
    sleep(10);
  }
  return 0;
}

/*----------------------------------------------------------------
* main
*
* wland entry point.
*
* Arguments:
*	argc	number of command line arguments
*	argv	array of argument strings
*
* Returns: 
*	0	- success 
*	~0	- failure
----------------------------------------------------------------*/
int main(int argc, char *argv[])
{
	int errflg;
	int optch;

	errflg = 0;

	/* Set Globals */
	msgfp = NULL;
	nlfd = -1;
	user_process = 0;

	while ((optch = getopt(argc, argv, "Vvd:u")) != -1) {
		switch (optch) {
		case 'V':
		case 'v':
			fprintf(stderr, "wland version %s\n", WLAN_RELEASE);
			return 0;
			break;
		case 'd':
			wland_path = strdup(optarg);
			break;
		case 'u':
			user_process = 1;
			break;
		default:
			errflg = 1; break;
		}
	}

	if (errflg || (optind < argc)) {
		usage(argv[0]);
		exit(1);
	}

	if ( chdir(wland_path) < 0 ) {
		fprintf(stderr, "wland: ERROR changing to directory %s\n",
			wland_path);
		exit(1);
	}

	if ( !user_process ) {
		if ( !(daemon_init()) ) {
			exit(1);
		}
	}

	if ( !(netlink_init()) ) {
		exit(1);
	}

	process_messages();

	return 0;
}

int main()
{
#if 0
	if(daemon_init() != 0)
		puts("daemon_init failed");
	else
		puts("daemon inited");
#endif
	version();
	(void) new TCPServer(new Board);
}

int main(int argc, char *argv[])
{
    if (daemon_init(LOCKFILE) < 0) {
        return -1;
    }
    
    while(1) {
        sleep(10);
    }

    return 0;
}

int log_init(char *program_name, int size)
{
	logdbg(stderr,"enter log_init\n");
	log_name = program_name;

	if (log_daemon) {
		struct sigaction sa_old;
		struct sigaction sa_new;
		pid_t pid;

		openlog(log_name, 0, LOG_DAEMON);
		setlogmask (LOG_UPTO (LOG_DEBUG));

		if (logarea_init(size)) {
			syslog(LOG_ERR, "logarea init failed");
			return -1;
		}

		pid = fork();
		if (pid < 0) {
			syslog(LOG_ERR, "starting logger failed");
			exit(1);
		} else if (pid) {
			syslog(LOG_WARNING,
			       "iSCSI logger with pid=%d started!", pid);
			return pid;
		}

		daemon_init();

		/* flush on daemon's crash */
		sa_new.sa_handler = (void*)catch_signal;
		sigemptyset(&sa_new.sa_mask);
		sa_new.sa_flags = 0;
		sigaction(SIGSEGV, &sa_new, &sa_old );
		sigaction(SIGTERM, &sa_new, &sa_old );

		while(1) {
			log_flush();
			sleep(1);

			if (log_stop_daemon)
				break;
		}

		__log_close();
		exit(0);
	}

	return 0;
}

int main(int argc, char **argv) {
	struct mountwatch_change_s change;
	struct package_s p;
	int i;
	char *n;

	dbp_error_log = stderr;
	config_init();
	if (!(dbp_error_log = fopen(config_struct.daemon_log, "w"))) {
		dbp_error_log = stderr;
		fprintf(stderr, "Unable to open %s\n", config_struct.daemon_log);
	} else
		setbuf(dbp_error_log, NULL);
	p = package_init();
	comm_dbus_register(&p);

	if (!mountwatch_init())
		exit(-1);
	if (!daemon_init())
		exit(-1);
	
	for (;;) {
		change = mountwatch_diff();
		for (i = 0; i < change.entries; i++) {
			switch (change.entry[i].tag) {
				case MOUNTWATCH_TAG_REMOVED:
					package_release_mount(&p, change.entry[i].device);
					break;
				case MOUNTWATCH_TAG_ADDED:
					package_crawl_mount(&p, change.entry[i].device, change.entry[i].mount);
					break;
				case MOUNTWATCH_TAG_PKG_ADDED:
					package_register_path(&p, change.entry[i].device, change.entry[i].path, change.entry[i].mount, &n);
					free(n);
					break;
				case MOUNTWATCH_TAG_PKG_REMOVED:
					package_release_path(&p, change.entry[i].path);
					break;
				default:
					break;
			}
		}

		mountwatch_change_free(change);
	}

	return 0;
}

int
main(int argc, char **argv)
{
	int listenfd, connfd;
	socklen_t addrlen, len;
	struct sockaddr	*cliaddr;
	char buff[MAXLINE];
	time_t ticks;

	if (argc < 2 || argc > 3) {
		fprintf(stderr, "usage: daytimetcpsrv2 [ <host> ] <service or port>\n");
		exit(1);
	}

	daemon_init(argv[0], 0);

	if (argc == 2)
		listenfd = tcp_listen(NULL, argv[1], &addrlen);
	else
		listenfd = tcp_listen(argv[1], argv[2], &addrlen);

	if ((cliaddr = malloc(addrlen)) == NULL) {
		syslog(LOG_ERR, "malloc error: %m");
		exit(1);
	}

	for ( ; ; ) {
		len = addrlen;
		if ((connfd = accept(listenfd, cliaddr, &len)) < 0) {
			syslog(LOG_ERR, "accept error: %m");
			exit(1);
		}
		syslog(LOG_INFO, "connection from %s\n", sock_ntop(cliaddr, len));

		ticks = time(NULL);
		snprintf(buff, sizeof(buff), "%.24s\r\n", ctime(&ticks));
		if (write(connfd, buff, strlen(buff)) != strlen(buff)) {
			syslog(LOG_ERR, "write error: %m");
			exit(1);
		}

		if (close(connfd) < 0) {
			syslog(LOG_ERR, "close error: %m");
			exit(1);
		}
	}
}