void daemon_init(const char *prog, const char *pid_file, int nofork) { pid_t pid; if (check_process_running(prog, pid_file, &pid) && (pid != getpid())) { syslog(LOG_ERR, "daemon_init: Process \"%s\" already running.\n", prog); exit(1); } if (setup_sigmask() < 0) { syslog(LOG_ERR, "daemon_init: Unable to set signal mask.\n"); exit(1); } if(!nofork && daemon(0, 0)) { syslog(LOG_ERR, "daemon_init: Unable to daemonize.\n"); exit(1); } update_pidfile(pid_file); }
int main ( int argc, char *argv[] ) { int rc; struct stat struct_stat; pthread_t pid; pthread_attr_t attr; int i, num_sources; uid_t gmetad_uid; mode_t rrd_umask; char * gmetad_username; struct passwd *pw; gmetad_config_t *c = &gmetad_config; apr_interval_time_t sleep_time; apr_time_t last_metadata; double random_sleep_factor; unsigned int rand_seed; rc = apr_initialize(); if (rc != APR_SUCCESS) { return -1; } /* create a memory pool. */ apr_pool_create(&global_context, NULL); /* Ignore SIGPIPE */ signal( SIGPIPE, SIG_IGN ); initialize_scoreboard(); /* Mark the time this gmetad started */ started = apr_time_now(); if (cmdline_parser(argc, argv, &args_info) != 0) err_quit("command-line parser error"); num_sources = number_of_datasources( args_info.conf_arg ); if(!num_sources) { err_quit("%s doesn't have any data sources specified", args_info.conf_arg); } memset(&root, 0, sizeof(root)); root.id = ROOT_NODE; /* Get the real number of data sources later */ sources = hash_create( num_sources + 10 ); if (! sources ) { err_quit("Unable to create sources hash\n"); } root.authority = hash_create( num_sources + 10 ); if (!root.authority) { err_quit("Unable to create root authority (our grids and clusters) hash\n"); } root.metric_summary = hash_create (DEFAULT_METRICSIZE); if (!root.metric_summary) { err_quit("Unable to create root summary hash"); } parse_config_file ( args_info.conf_arg ); /* If given, use command line directives over config file ones. */ if (args_info.debug_given) { c->debug_level = args_info.debug_arg; } debug_level = c->debug_level; set_debug_msg_level(debug_level); /* Setup our default authority pointer if the conf file hasnt yet. * Done in the style of hash node strings. */ if (!root.stringslen) { gethostname(hostname, HOSTNAMESZ); root.authority_ptr = 0; sprintf(root.strings, "http://%s/ganglia/", hostname); root.stringslen += strlen(root.strings) + 1; } rand_seed = apr_time_now() * (int)pthread_self(); for(i = 0; i < root.stringslen; rand_seed = rand_seed * root.strings[i++]); /* Debug level 1 is error output only, and no daemonizing. */ if (!debug_level) { rrd_umask = c->umask; daemon_init (argv[0], 0, rrd_umask); } if (args_info.pid_file_given) { update_pidfile (args_info.pid_file_arg); } /* The rrd_rootdir must be writable by the gmetad process */ if( c->should_setuid ) { if(! (pw = getpwnam(c->setuid_username))) { err_sys("Getpwnam error"); } gmetad_uid = pw->pw_uid; gmetad_username = c->setuid_username; } else { gmetad_uid = getuid(); if(! (pw = getpwuid(gmetad_uid))) { err_sys("Getpwnam error"); } gmetad_username = strdup(pw->pw_name); } debug_msg("Going to run as user %s", gmetad_username); if( c->should_setuid ) { become_a_nobody(c->setuid_username); } if( c->write_rrds ) { if( stat( c->rrd_rootdir, &struct_stat ) ) { err_sys("Please make sure that %s exists", c->rrd_rootdir); } if ( struct_stat.st_uid != gmetad_uid ) { err_quit("Please make sure that %s is owned by %s", c->rrd_rootdir, gmetad_username); } if (! (struct_stat.st_mode & S_IWUSR) ) { err_quit("Please make sure %s has WRITE permission for %s", gmetad_username, c->rrd_rootdir); } } if(debug_level) { fprintf(stderr,"Sources are ...\n"); hash_foreach( sources, print_sources, NULL); } #ifdef WITH_MEMCACHED if (c->memcached_parameters != NULL) { memcached_connection_pool = memcached_pool(c->memcached_parameters, strlen(c->memcached_parameters)); } #endif /* WITH_MEMCACHED */ server_socket = g_tcp_socket_server_new( c->xml_port ); if (server_socket == NULL) { err_quit("tcp_listen() on xml_port failed"); } debug_msg("xml listening on port %d", c->xml_port); interactive_socket = g_tcp_socket_server_new( c->interactive_port ); if (interactive_socket == NULL) { err_quit("tcp_listen() on interactive_port failed"); } debug_msg("interactive xml listening on port %d", c->interactive_port); /* Forward metrics to Graphite using carbon protocol */ if (c->carbon_server != NULL) { if (!strcmp(c->carbon_protocol, "udp")) { carbon_udp_socket = init_carbon_udp_socket (c->carbon_server, c->carbon_port); if (carbon_udp_socket == NULL) err_quit("carbon %s socket failed for %s:%d", c->carbon_protocol, c->carbon_server, c->carbon_port); } debug_msg("carbon forwarding ready to send via %s to %s:%d", c->carbon_protocol, c->carbon_server, c->carbon_port); } #ifdef WITH_RIEMANN if (c->riemann_server !=NULL) { if (!strcmp(c->riemann_protocol, "udp")) { riemann_udp_socket = init_riemann_udp_socket (c->riemann_server, c->riemann_port); if (riemann_udp_socket == NULL) err_quit("[riemann] %s socket failed for %s:%d", c->riemann_protocol, c->riemann_server, c->riemann_port); } else { err_quit("[riemann] TCP transport not supported yet."); } debug_msg("[riemann] ready to forward metrics via %s to %s:%d", c->riemann_protocol, c->riemann_server, c->riemann_port); } #endif /* WITH_RIEMANN */ /* initialize summary mutex */ root.sum_finished = (pthread_mutex_t *) malloc(sizeof(pthread_mutex_t)); pthread_mutex_init(root.sum_finished, NULL); pthread_attr_init( &attr ); pthread_attr_setdetachstate( &attr, PTHREAD_CREATE_DETACHED ); /* Spin off the non-interactive server threads. (Half as many as interactive). */ for (i=0; i < c->server_threads/2; i++) pthread_create(&pid, &attr, server_thread, (void*) 0); /* Spin off the interactive server threads. */ for (i=0; i < c->server_threads; i++) pthread_create(&pid, &attr, server_thread, (void*) 1); hash_foreach( sources, spin_off_the_data_threads, NULL ); /* A thread to cleanup old metrics and hosts */ pthread_create(&pid, &attr, cleanup_thread, (void *) NULL); debug_msg("cleanup thread has been started"); /* Meta data */ last_metadata = 0; for(;;) { /* Do at a random interval, between (shortest_step/2) +/- METADATA_SLEEP_RANDOMIZE percent */ random_sleep_factor = (1 + (METADATA_SLEEP_RANDOMIZE / 50.0) * ((rand_r(&rand_seed) - RAND_MAX/2)/(float)RAND_MAX)); sleep_time = random_sleep_factor * apr_time_from_sec(c->shortest_step) / 2; /* Make sure the sleep time is at least 1 second */ if(apr_time_sec(apr_time_now() + sleep_time) < (METADATA_MINIMUM_SLEEP + apr_time_sec(apr_time_now()))) sleep_time += apr_time_from_sec(METADATA_MINIMUM_SLEEP); apr_sleep(sleep_time); /* Need to be sure root is locked while doing summary */ pthread_mutex_lock(root.sum_finished); /* Flush the old values */ hash_foreach(root.metric_summary, zero_out_summary, NULL); root.hosts_up = 0; root.hosts_down = 0; /* Sum the new values */ hash_foreach(root.authority, do_root_summary, NULL ); /* summary completed */ pthread_mutex_unlock(root.sum_finished); /* Save them to RRD */ hash_foreach(root.metric_summary, write_root_summary, NULL); /* Remember our last run */ last_metadata = apr_time_now(); } apr_pool_destroy(global_context); apr_terminate(); return 0; }
int main(int argc, char *argv[]) { int sockfd , clisockfd; unsigned int clilen; int childpid; struct sockaddr_in serv_addr,cli_addr; int err_select;//JY1113 #ifdef LPR_with_ASUS//JY1112 int LPRflag = 0; fd_set rfds, afds; int nfds; int sockfd_ASUS; unsigned int clilen_ASUS; int childpid_ASUS; struct sockaddr_in serv_addr_ASUS,cli_addr_ASUS; #endif #ifdef Raw_Printing_with_ASUS //Lisa int netfd, fd, clientlen, one = 1; struct sockaddr_in netaddr, client; #endif int lock; int pid = 0; FILE *fp; fp = fopen("/var/run/lpdparent.pid", "r"); if (fp) { fscanf(fp, "%d", &pid); fclose(fp); } if ((pid > 1) && (kill(pid, 0) == 0 || errno != ESRCH)) { syslog(LOGOPTS, "another lpd daemon exists!!\n"); exit(0); } update_pidfile(); //Initial the server the not busy lptstatus.busy = FALSE; sigset_t sigs_to_catch; sigemptyset(&sigs_to_catch); sigaddset(&sigs_to_catch, SIGCLD); sigaddset(&sigs_to_catch, SIGINT); sigaddset(&sigs_to_catch, SIGQUIT); sigaddset(&sigs_to_catch, SIGKILL); sigaddset(&sigs_to_catch, SIGUSR2); sigprocmask(SIG_UNBLOCK, &sigs_to_catch, NULL); //Setup the signal handler signal(SIGCLD, sig_child); signal(SIGINT, sig_cleanup); signal(SIGQUIT, sig_cleanup); signal(SIGKILL, sig_cleanup); signal(SIGUSR2, sig_remove);//JY1110 if((sockfd = socket(AF_INET,SOCK_STREAM,0)) < 0 ) { syslog(LOGOPTS, "can't open stream socket: %m"); exit(0); } bzero((char *)&serv_addr , sizeof(serv_addr)); serv_addr.sin_family = AF_INET; serv_addr.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr.sin_port = htons(PNT_SVR_PORT_LPR); if(bind(sockfd,(struct sockaddr *)&serv_addr , sizeof(serv_addr)) < 0 ) { syslog(LOGOPTS, "can't bind socket with port %d: %m", PNT_SVR_PORT_LPR); exit(0); } /*JY1111*/ int windowsize=2920; setsockopt(sockfd, SOL_SOCKET, SO_RCVBUF, (char *)&windowsize, sizeof(windowsize)); int no_delay=1; setsockopt(sockfd, IPPROTO_TCP, TCP_NODELAY, &no_delay, sizeof(no_delay)); // by Jiahao. 20080808. listen(sockfd , 15); #ifdef Raw_Printing_with_ASUS //Lisa if ((netfd = socket(AF_INET, SOCK_STREAM, IPPROTO_IP)) < 0) { syslog(LOGOPTS, "cannot open stream socket for raw printing: %m\n"); exit(1); } if (setsockopt(netfd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one)) < 0) { syslog(LOGOPTS, "cannot setsocketopt for raw printing: %m\n"); exit(1); } netaddr.sin_family = AF_INET; netaddr.sin_port = htons(BASEPORT); netaddr.sin_addr.s_addr = htonl(INADDR_ANY); memset(netaddr.sin_zero, 0, sizeof(netaddr.sin_zero)); if (bind(netfd, (struct sockaddr*) &netaddr, sizeof(netaddr)) < 0) { syslog(LOGOPTS, "cannot bind socket with port %d for raw printing: %m\n", BASEPORT); exit(1); } if (listen(netfd, 5) < 0) { syslog(LOGOPTS, "cannot listen socket for raw printing: %m\n"); exit(1); } //clientlen = sizeof(client); //memset(&client, 0, sizeof(client)); #endif #ifdef LPR_with_ASUS//JY1112 if((sockfd_ASUS = socket(AF_INET,SOCK_STREAM,0)) < 0 ) { syslog(LOG_ERR, "can't open stream socket for LPR: %m"); exit(0); } bzero((char *)&serv_addr_ASUS , sizeof(serv_addr_ASUS)); serv_addr_ASUS.sin_family = AF_INET; serv_addr_ASUS.sin_addr.s_addr = htonl(INADDR_ANY); serv_addr_ASUS.sin_port = htons(PNT_SVR_PORT_ASUS); if(bind(sockfd_ASUS,(struct sockaddr *)&serv_addr_ASUS , sizeof(serv_addr_ASUS)) < 0 ) { syslog(LOG_ERR, "can't bind socket for LPR: %m"); exit(0); } setsockopt(sockfd_ASUS, SOL_SOCKET, SO_RCVBUF, (char *)&windowsize, sizeof(windowsize)); listen(sockfd_ASUS , 15); /*set the fds*/ nfds=MAX(sockfd, sockfd_ASUS); FD_ZERO(&afds); #endif while(TRUE) { //if (busy) syslog(LOG_NOTICE, "busying %d %d\n", lptstatus.busy, busy); lock = file_lock("printer"); // by Jiahao for U2EC. 20080808. if (lptstatus.busy==FALSE && nvram_invmatch("MFP_busy", "2")) { busy=FALSE; nvram_set_int_temp("MFP_busy", 0); nvram_set_temp("u2ec_busyip", ""); } file_unlock(lock); #ifdef Raw_Printing_with_ASUS //Lisa FD_SET(netfd, &afds); #endif #ifdef LPR_with_ASUS//JY1112 FD_SET(sockfd, &afds); FD_SET(sockfd_ASUS, &afds); memcpy(&rfds, &afds, sizeof(rfds)); if((err_select=select(nfds+1, &rfds, (fd_set *)0, (fd_set *)0, (struct timeval *)0 )) < 0) { //JY1120 printf("select error on sockfd: error=%d\n", errno); /**/ // printf("sockfd_FD_ISSET=%d\n", FD_ISSET(sockfd, &rfds)); //JY1120 printf("sockfd_ASUS FD_ISSET=%d\n", FD_ISSET(sockfd_ASUS, &rfds)); /**/ // if(errno != 4)//JY1113: delete //syslog(LOG_NOTICE, "select error %d\n", err_select); continue; } #endif clilen = sizeof(cli_addr); if(FD_ISSET(sockfd_ASUS, &rfds)) { LPRflag = 0; clisockfd = accept(sockfd_ASUS,(struct sockaddr *)&cli_addr, &clilen); } #ifdef LPR_with_ASUS//JY1112 else if(FD_ISSET(sockfd, &rfds)) { LPRflag = 1; clisockfd = accept(sockfd,(struct sockaddr *)&cli_addr, &clilen); } #endif #ifdef Raw_Printing_with_ASUS //Lisa // else if(FD_ISSET(netfd, &rfds) && busy==FALSE) else if(FD_ISSET(netfd, &rfds)) { lock = file_lock("printer"); // by Jiahao for U2EC. 20080808. if (nvram_match("MFP_busy", "0")) { file_unlock(lock); LPRflag = 2; clisockfd = accept(netfd, (struct sockaddr*) &cli_addr, &clilen); } else { file_unlock(lock); sleep(2); continue; } } #endif else { //syslog(LOG_NOTICE, "No select\n"); sleep(2); continue; } strcpy(clientaddr , inet_ntoa(cli_addr.sin_addr)); if(clisockfd < 0) { //syslog(LOG_NOTICE, "LPD error: No clisockfd %d\n", LPRflag); continue; } lock = file_lock("printer"); // if (busy!=FALSE) /* 2004/09/10 by Joey, process nack in parent for LPR and Remote Prot */ if (nvram_invmatch("MFP_busy", "0")) // by Jiahao for U2EC. 20080808. { file_unlock(lock); //syslog(LOG_NOTICE, "Printing others 1 %d %d\n", LPRflag, clisockfd); if (LPRflag==0) processReq(clisockfd); else if (LPRflag==1) processReq_LPR(clisockfd, 0); //syslog(LOG_NOTICE, "Printing others %d %d\n", LPRflag, clisockfd); close(clisockfd); // For Raw printing, don't resonse to client while busy sleep(5); continue; } nvram_set_int_temp("MFP_busy", 1); if (nvram_match("lan_ipaddr_t", "")) nvram_set_temp("u2ec_busyip", nvram_safe_get("lan_ipaddr")); else nvram_set_temp("u2ec_busyip", nvram_safe_get("lan_ipaddr_t")); file_unlock(lock); if( (childpid = fork() ) < 0) { } else if(childpid == 0) { //syslog(LOG_NOTICE, "Printing %d\n", LPRflag); if(LPRflag==0) processReq(clisockfd); #ifdef LPR_with_ASUS//JY1114 else if(LPRflag==1) processReq_LPR(clisockfd, 1); #endif #ifdef Raw_Printing_with_ASUS //Lisa else if(LPRflag == 2) processReq_Raw(clisockfd); #endif close(sockfd); close(sockfd_ASUS); #ifdef Raw_Printing_with_ASUS close(netfd); #endif exit(0); } //syslog(0, "Printing Process %d %d %d\n", busy, lptstatus.busy, childpid); //parents process goes on here //remark PRINT("fork -- childpid %d\n",childpid); if(lptstatus.busy == FALSE) { lptstatus.busy = TRUE; // busy = TRUE; // remarked by Jiahao for U2EC. 20080808. strcpy(lptstatus.addr , inet_ntoa(cli_addr.sin_addr)); lptstatus.pid = childpid; } close(clisockfd); } }