int main(int argc, char *argv[]) { struct radclock_handle *handle; struct radclock_config *conf; int is_daemon = 0; /* File and command line reading */ int ch; /* Mask variable used to know which parameter to update */ uint32_t param_mask = 0; /* PID lock file for daemon */ int daemon_pid_fd = 0; /* Initialize PID lockfile to a default value */ const char *pid_lockfile = DAEMON_LOCK_FILE; /* Misc */ int err; /* turn off buffering to allow results to be seen immediately if JDEBUG*/ #ifdef WITH_JDEBUG setvbuf(stdout, (char *)NULL, _IONBF, 0); setvbuf(stderr, (char *)NULL, _IONBF, 0); #endif /* * Register Signal handlers. We use sigaction() instead of signal() to catch * signals. The main reason concerns the SIGHUP signal. In Linux, the * syscalls are restarted as soon as the signal handler returns. This * prevent pcap_breakloop() to do its job (see pcap man page). Using * sigaction() we can overwrite the default flag to prevent this behavior */ sigset_t block_mask; sigfillset (&block_mask); struct sigaction sig_struct; sig_struct.sa_handler = signal_handler; sig_struct.sa_mask = block_mask; sig_struct.sa_flags = 0; sigaction(SIGHUP, &sig_struct, NULL); /* hangup signal (1) */ sigaction(SIGTERM, &sig_struct, NULL); /* software termination signal (15) */ sigaction(SIGUSR1, &sig_struct, NULL); /* user signal 1 (30) */ sigaction(SIGUSR2, &sig_struct, NULL); /* user signal 2 (31) */ /* Initialise verbose data to defaults */ verbose_data.handle = NULL; verbose_data.is_daemon = 0; verbose_data.verbose_level = 0; verbose_data.fd = NULL; strcpy(verbose_data.logfile, ""); pthread_mutex_init(&(verbose_data.vmutex), NULL); /* Management of configuration options */ conf = (struct radclock_config *) malloc(sizeof(struct radclock_config)); JDEBUG_MEMORY(JDBG_MALLOC, conf); memset(conf, 0, sizeof(struct radclock_config)); /* * The command line arguments are given the priority and override possible * values of the configuration file But the configuration file is parsed * after the command line because we need to know if we are running a daemon * or not (configuration file is different if we run a daemon or not). Use * the param_mask variable to indicate which values have to be updated from * the config file */ /* Initialize the physical parameters, and other config parameters. */ config_init(conf); /* Init the mask we use to signal configuration updates */ param_mask = UPDMASK_NOUPD; /* Reading the command line arguments */ while ((ch = getopt(argc, argv, "dxvhc:i:l:n:t:r:w:s:a:o:p:P:U:D:V")) != -1) switch (ch) { case 'x': SET_UPDATE(param_mask, UPDMASK_SERVER_IPC); conf->server_ipc = BOOL_OFF; break; case 'c': strcpy(conf->conffile, optarg); break; case 'd': is_daemon = 1; break; case 'l': strcpy(conf->logfile, optarg); break; case 'n': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_HOSTNAME); strcpy(conf->hostname, optarg); break; case 'p': SET_UPDATE(param_mask, UPDMASK_POLLPERIOD); if ( atoi(optarg) < RAD_MINPOLL ) { conf->poll_period = RAD_MINPOLL; fprintf(stdout, "Warning: Poll period too small, set to %d\n", conf->poll_period); } else conf->poll_period = atoi(optarg); if ( conf->poll_period > RAD_MAXPOLL ) { conf->poll_period = RAD_MAXPOLL; fprintf(stdout, "Warning: Poll period too big, set to %d\n", conf->poll_period); } break; case 't': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_TIME_SERVER); strcpy(conf->time_server, optarg); break; case 'i': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_NETWORKDEV); strcpy(conf->network_device, optarg); break; case 'r': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_SYNC_IN_PCAP); strcpy(conf->sync_in_pcap, optarg); break; case 'w': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_SYNC_OUT_PCAP); strcpy(conf->sync_out_pcap, optarg); break; case 's': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_SYNC_IN_ASCII); strcpy(conf->sync_in_ascii, optarg); break; case 'a': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_SYNC_OUT_ASCII); strcpy(conf->sync_out_ascii, optarg); break; case 'o': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_CLOCK_OUT_ASCII); strcpy(conf->clock_out_ascii, optarg); break; case 'P': if (strlen(optarg) > MAXLINE) { fprintf(stdout, "ERROR: parameter too long\n"); exit (1); } SET_UPDATE(param_mask, UPDMASK_PID_FILE); pid_lockfile = optarg; break; case 'v': SET_UPDATE(param_mask, UPDMASK_VERBOSE); conf->verbose_level++; break; case 'U': SET_UPDATE(param_mask, UPD_NTP_UPSTREAM_PORT); conf->ntp_upstream_port = atoi(optarg); break; case 'D': SET_UPDATE(param_mask, UPD_NTP_DOWNSTREAM_PORT); conf->ntp_downstream_port = atoi(optarg); break; case 'V': fprintf(stdout, "%s version %s\n", PACKAGE_NAME, PACKAGE_VERSION); case 'h': case '?': default: usage(); } argc -= optind; argv += optind; /* Little hack to deal with parsing of long options in the command line */ if (conf->verbose_level > 0) SET_UPDATE(param_mask, UPDMASK_VERBOSE); /* Create the radclock handle */ clock_handle = create_handle(conf, is_daemon); if (!clock_handle) { verbose(LOG_ERR, "Could not create clock handle"); return (-1); } handle = clock_handle; /* * Have not parsed the config file yet, so will have to do it again since it * may not be the right settings. Handles config parse messages in the right * log file though. So far clock has not been sent to init, no syscall * registered, pass a NULL pointer to verbose. */ set_verbose(handle, handle->conf->verbose_level, 0); set_logger(logger_verbose_bridge); /* Daemonize now, so that we can open the log files and close connection to * stdin since we parsed the command line */ if (handle->is_daemon) { struct stat sb; if (stat(RADCLOCK_RUN_DIRECTORY, &sb) < 0) { if (mkdir(RADCLOCK_RUN_DIRECTORY, 0755) < 0) { verbose(LOG_ERR, "Cannot create %s directory. Run as root or " "(!daemon && !server)", RADCLOCK_RUN_DIRECTORY); return (1); } } /* Check this everytime in case something happened */ chmod(RADCLOCK_RUN_DIRECTORY, 00755); if (!(daemonize(pid_lockfile, &daemon_pid_fd))) { fprintf(stderr, "Error: did not manage to create the daemon\n"); exit(EXIT_FAILURE); } } /* * Retrieve configuration from the config file (write it down if it does not * exist) That should be the only occasion when get_config() is called and * the param_mask is not positioned to UPDMASK_NOUPD !!! Only the * parameters not specified on the command line are updated */ if (!config_parse(handle->conf, ¶m_mask, handle->is_daemon)) return (0); /* * Now that we have the configuration to use (verbose level), let's * initialise the verbose level to correct value */ set_verbose(handle, handle->conf->verbose_level, 0); set_logger(logger_verbose_bridge); /* Check for incompatible configurations and correct them */ if (( handle->conf->synchro_type == SYNCTYPE_SPY ) || ( handle->conf->synchro_type == SYNCTYPE_PIGGY )) { if (handle->conf->server_ntp == BOOL_ON) { verbose(LOG_ERR, "Configuration error. Disabling NTP server " "(incompatible with spy or piggy mode)."); handle->conf->server_ntp = BOOL_OFF; } if ( handle->conf->adjust_sysclock == BOOL_ON ) { verbose(LOG_ERR, "Configuration error. Disabling adjust system " "clock (incompatible with spy or piggy mode)."); handle->conf->adjust_sysclock = BOOL_OFF; } } /* Diagnosis output for the configuration used */ config_print(LOG_NOTICE, handle->conf); /* Reinit the mask that counts updated values */ param_mask = UPDMASK_NOUPD; // TODO extract extra checks from is_live_source and make an input fix // function instead, would be clearer // TODO the conf->network_device business is way too messy /* * Need to know if we are replaying data or not. If not, no need to create * shared global data on the system or open a BPF. This define input to the * init of the radclock handle */ if (!is_live_source(handle)) handle->run_mode = RADCLOCK_SYNC_DEAD; else handle->run_mode = RADCLOCK_SYNC_LIVE; /* Init clock handle and private data */ if (handle->run_mode == RADCLOCK_SYNC_LIVE) { err = clock_init_live(handle->clock, &handle->rad_data); if (err) { verbose(LOG_ERR, "Could not initialise the RADclock"); return (1); } } /* Init radclock specific stuff */ err = init_handle(handle); if (err) { verbose(LOG_ERR, "Radclock process specific init failed."); return (1); } /* * Now 2 cases. Either we are running live or we are replaying some data. * If we run live, we will spawn some threads and do some smart things. If * we replay data, no need to do all of that, we access data and process it * in the same thread. */ if (handle->run_mode == RADCLOCK_SYNC_DEAD) { // TODO : manage peers better !! struct bidir_peer peer; /* Some basic initialisation which is required */ init_peer_stamp_queue(&peer); peer.stamp_i = 0; // TODO XXX Need to manage peers better !! /* Register active peer */ handle->active_peer = (void *)&peer; while (1) { err = process_rawdata(handle, &peer); if (err < 0) break; } destroy_peer_stamp_queue(&peer); } /* * We loop in here in case we are rehashed. Threads are (re-)created every * time we loop in */ else { while (err == 0) { err = start_live(handle); if (err == 0) { if (rehash_daemon(handle, param_mask)) verbose(LOG_ERR, "SIGHUP - Failed to rehash daemon !!."); } } } // TODO: look into making the stats a separate structure. Could be much // TODO: easier to manage long int n_stamp; unsigned int ref_count; n_stamp = ((struct bidir_output *)handle->algo_output)->n_stamps; ref_count = ((struct stampsource*)(handle->stamp_source))->ntp_stats.ref_count; verbose(LOG_NOTICE, "%u NTP packets captured", ref_count); verbose(LOG_NOTICE,"%ld missed NTP packets", ref_count - 2 * n_stamp); verbose(LOG_NOTICE, "%ld valid timestamp tuples extracted", n_stamp); /* Close output files */ close_output_stamp(handle); /* Print out last good phat value */ verbose(LOG_NOTICE, "Last estimate of the clock source period: %12.10lg", RAD_DATA(handle)->phat); /* Say bye and close syslog */ verbose(LOG_NOTICE, "RADclock stopped"); if (handle->is_daemon) closelog (); unset_verbose(); /* Free the lock file */ if (handle->is_daemon) { write(daemon_pid_fd, "", 0); lockf(daemon_pid_fd, F_ULOCK, 0); } // TODO: all the destructors have to be re-written destroy_source(handle, (struct stampsource *)(handle->stamp_source)); /* Clear thread stuff */ pthread_mutex_destroy(&(handle->globaldata_mutex)); pthread_mutex_destroy(&(handle->wakeup_mutex)); pthread_cond_destroy(&(handle->wakeup_cond)); /* Detach IPC shared memory if were running as IPC server. */ if (handle->conf->server_ipc == BOOL_ON) shm_detach(handle->clock); /* Free the clock structure. All done. */ pthread_mutex_destroy(&(handle->pcap_queue->rdb_mutex)); pthread_mutex_destroy(&(handle->ieee1588eq_queue->rdb_mutex)); free(handle->pcap_queue); free(handle->ieee1588eq_queue); free(handle); handle = NULL; clock_handle = NULL; exit(EXIT_SUCCESS); }
void widget_live_image::showEvent(QShowEvent* event){ QWidget::showEvent(event); start_live(); }