/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection containing a new message to parse
* @param handler function called after the message has been parsed
*/
request_reader(tcp::connection_ptr& tcp_conn, finished_handler_t handler)
: http::reader(true, tcp_conn), m_http_msg(new http::request),
m_finished(handler)
{
m_http_msg->set_remote_ip(tcp_conn->get_remote_ip());
set_logger(PION_GET_LOGGER("pion.http.request_reader"));
}
bool Convert(const VfsPath& daeFilename, const VfsPath& pmdFilename, CColladaManager::FileType type)
{
// To avoid always loading the DLL when it's usually not going to be
// used (and to do the same on Linux where delay-loading won't help),
// and to avoid compile-time dependencies (because it's a minor pain
// to get all the right libraries to build the COLLADA DLL), we load
// it dynamically when it is required, instead of using the exported
// functions and binding at link-time.
if (!dll.IsLoaded())
{
if (!TryLoadDLL())
return false;
if (!LoadSkeletonDefinitions())
{
dll.Unload(); // Error should have been logged already
return false;
}
}
// Set the filename for the logger to report
set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&daeFilename)));
// We need to null-terminate the buffer, so do it (possibly inefficiently)
// by converting to a CStr
CStr daeData;
{
CVFSFile daeFile;
if (daeFile.Load(m_VFS, daeFilename) != PSRETURN_OK)
return false;
daeData = daeFile.GetAsString();
}
// Do the conversion into a memory buffer
// We need to check the result, as archive builder needs to know if the source dae
// was sucessfully converted to .pmd/psa
int result = -1;
WriteBuffer writeBuffer;
switch (type)
{
case CColladaManager::PMD:
result = convert_dae_to_pmd(daeData.c_str(), ColladaOutput, &writeBuffer);
break;
case CColladaManager::PSA:
result = convert_dae_to_psa(daeData.c_str(), ColladaOutput, &writeBuffer);
break;
}
// don't create zero-length files (as happens in test_invalid_dae when
// we deliberately pass invalid XML data) because the VFS caching
// logic warns when asked to load such.
if (writeBuffer.Size())
{
Status ret = m_VFS->CreateFile(pmdFilename, writeBuffer.Data(), writeBuffer.Size());
ENSURE(ret == INFO::OK);
}
return (result == 0);
}
void
syslogd_enable(char const * ident, int log_facility,
struct syslogd_options const * opt)
{
// default rsyslogd
if (opt == NULL) {
openlog(ident, LOG_PID | LOG_CONS, 0);
set_logger(vsyslogf);
return;
}
// used configured rsyslogd
bzero(syslogd_tag__, sizeof(syslogd_tag__));
bzero(syslogd_pid__, sizeof(syslogd_pid__));
snprintf(syslogd_pid__, sizeof(syslogd_pid__), "[%d]", getpid());
if (getlogin_r(&syslogd_tag__[0], sizeof(syslogd_tag__)) < 0) {
switch (errno) {
case ENXIO: case ERANGE: case ENOTTY:
errno = 0;
break;
default : DIE("getlogin_r error '%m'");
}
}
SYSLOG_INFO__ = SYSLOG_TRACE__ =
((log_facility & LOG_FACMASK) | (LOG_INFO & LOG_PRIMASK));
SYSLOG_WARNING__ =
((log_facility & LOG_FACMASK) | (LOG_WARNING & LOG_PRIMASK));
SYSLOG_ERROR__ = SYSLOG_FATAL__ =
((log_facility & LOG_FACMASK) | (LOG_ERR & LOG_PRIMASK));
if (opt->unix_socket)
open_unix_socket(opt, ALL_TYPES);
else
open_inet_socket(opt, ALL_TYPES);
set_logger(vslogf_rfc3164);
}
/*
* radclock process specific init of the clock_handle
*/
static int
init_handle(struct radclock_handle *handle)
{
/* Input source */
struct stampsource *stamp_source;
int err;
JDEBUG
/* Clock has been init', set the pointer to the clock */
set_verbose(handle, handle->conf->verbose_level, 1);
set_logger(logger_verbose_bridge);
if (handle->run_mode == RADCLOCK_SYNC_LIVE) {
/* Initial status words */
// TODO there should be more of them set in here, some are for live and
// dead runs, but not all!
ADD_STATUS(handle, STARAD_STARVING);
/*
* Initialise IPC shared memory segment
*/
if (handle->conf->server_ipc == BOOL_ON) {
err = shm_init_writer(handle->clock);
if (err)
return (1);
verbose(LOG_NOTICE, "IPC Shared Memory ready");
}
}
/* Open input file from which to read TS data */
if (!VM_SLAVE(handle)) {
stamp_source = create_source(handle);
if (!stamp_source) {
verbose(LOG_ERR, "Error creating stamp source, exiting");
exit(EXIT_FAILURE);
}
/* Hang stamp source on the handler */
handle->stamp_source = (void *) stamp_source;
}
/* Open output files */
open_output_stamp(handle);
open_output_matlab(handle);
return (0);
}
/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection used to send the request
* @param http_request_ptr pointer to the request that will be sent
* @param handler function called after the request has been sent
*/
request_writer(tcp::connection_ptr& tcp_conn, http::request_ptr& http_request_ptr,
finished_handler_t handler)
: http::writer(tcp_conn, handler), m_http_request(http_request_ptr)
{
set_logger(PION_GET_LOGGER("pion.http.request_writer"));
// check if we should initialize the payload content using
// the request's content buffer
if (m_http_request->get_content_length() > 0
&& m_http_request->get_content() != NULL
&& m_http_request->get_content()[0] != '\0')
{
write_no_copy(m_http_request->get_content(),
m_http_request->get_content_length());
}
}
cookie_auth::cookie_auth(user_manager_ptr userManager,
const std::string& login,
const std::string& logout,
const std::string& redirect)
: http::auth(userManager), m_login(login), m_logout(logout), m_redirect(redirect),
m_random_gen(), m_random_range(0, 255), m_random_die(m_random_gen, m_random_range),
m_cache_cleanup_time(boost::posix_time::second_clock::universal_time())
{
// set logger for this class
set_logger(PION_GET_LOGGER("pion.http.cookie_auth"));
// Seed random number generator with current time as time_t int value, cast to the required type.
// (Note that boost::mt19937::result_type is boost::uint32_t, and casting to an unsigned n-bit integer is
// defined by the standard to keep the lower n bits. Since ::time() returns seconds since Jan 1, 1970,
// it will be a long time before we lose any entropy here, even if time_t is a 64-bit int.)
m_random_gen.seed(static_cast<boost::mt19937::result_type>(::time(NULL)));
// generate some random numbers to increase entropy of the rng
for (unsigned int n = 0; n < 100; ++n)
m_random_die();
}
int daemon_start(newt_config config) {
pthread_t worker_ids[WorkerLength];
thread_info_t workers[] = {
{connection_worker, &config},
{stomp_management_worker, NULL},
};
int i;
if(config.loglevel != NULL) {
set_logger(config.loglevel);
}
for(i=0; i<WorkerLength; i++) {
pthread_create(&worker_ids[i], NULL, workers[i].func, workers[i].argument);
}
for(i=0; i<WorkerLength; i++) {
pthread_join(worker_ids[i], NULL);
}
return RET_SUCCESS;
}
Status ReloadChangedFile(const VfsPath& path)
{
// Ignore files that aren't in the right path
if (!boost::algorithm::starts_with(path.string(), L"art/skeletons/"))
return INFO::OK;
if (path.Extension() != L".xml")
return INFO::OK;
m_skeletonHashInvalidated = true;
// If the file doesn't exist (e.g. it was deleted), don't bother reloading
// or 'unloading' since that isn't possible
if (!VfsFileExists(path))
return INFO::OK;
if (!dll.IsLoaded() && !TryLoadDLL())
return ERR::FAIL;
LOGMESSAGE("Hotloading skeleton definitions from '%s'", path.string8());
// Set the filename for the logger to report
set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&path)));
CVFSFile skeletonFile;
if (skeletonFile.Load(m_VFS, path) != PSRETURN_OK)
{
LOGERROR("Failed to read skeleton defintions from '%s'", path.string8());
return ERR::FAIL;
}
int ok = set_skeleton_definitions((const char*)skeletonFile.GetBuffer(), (int)skeletonFile.GetBufferSize());
if (ok < 0)
{
LOGERROR("Failed to load skeleton definitions from '%s'", path.string8());
return ERR::FAIL;
}
return INFO::OK;
}
bool LoadSkeletonDefinitions()
{
VfsPaths pathnames;
if (vfs::GetPathnames(m_VFS, L"art/skeletons/", L"*.xml", pathnames) < 0)
{
LOGERROR("No skeleton definition files present");
return false;
}
bool loaded = false;
for (const VfsPath& path : pathnames)
{
LOGMESSAGE("Loading skeleton definitions from '%s'", path.string8());
// Set the filename for the logger to report
set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&path)));
CVFSFile skeletonFile;
if (skeletonFile.Load(m_VFS, path) != PSRETURN_OK)
{
LOGERROR("Failed to read skeleton defintions from '%s'", path.string8());
continue;
}
int ok = set_skeleton_definitions((const char*)skeletonFile.GetBuffer(), (int)skeletonFile.GetBufferSize());
if (ok < 0)
{
LOGERROR("Failed to load skeleton definitions from '%s'", path.string8());
continue;
}
loaded = true;
}
if (!loaded)
LOGERROR("Failed to load any skeleton definitions");
return loaded;
}
statistics_collector::statistics_collector(boost::shared_ptr<configuration> config,
boost::shared_ptr<zmq::context_t> zmq_context,
boost::shared_ptr<base_logger> logger) :
is_enabled_(false),
config_(config),
zmq_context_(zmq_context),
is_running_(false)
{
if (!config_) {
std::string error_str = "configuration object is empty";
error_str += " at " + std::string(BOOST_CURRENT_FUNCTION);
throw error(error_str);
}
if (!zmq_context_) {
std::string error_str = "zmq context object is empty";
error_str += " at " + std::string(BOOST_CURRENT_FUNCTION);
throw error(error_str);
}
set_logger(logger);
init();
}
bool Convert(const VfsPath& daeFilename, const VfsPath& pmdFilename, CColladaManager::FileType type)
{
// To avoid always loading the DLL when it's usually not going to be
// used (and to do the same on Linux where delay-loading won't help),
// and to avoid compile-time dependencies (because it's a minor pain
// to get all the right libraries to build the COLLADA DLL), we load
// it dynamically when it is required, instead of using the exported
// functions and binding at link-time.
if (! dll.IsLoaded())
{
if (! dll.LoadDLL())
{
LOGERROR(L"Failed to load COLLADA conversion DLL");
return false;
}
try
{
dll.LoadSymbol("set_logger", set_logger);
dll.LoadSymbol("set_skeleton_definitions", set_skeleton_definitions);
dll.LoadSymbol("convert_dae_to_pmd", convert_dae_to_pmd);
dll.LoadSymbol("convert_dae_to_psa", convert_dae_to_psa);
}
catch (PSERROR_DllLoader&)
{
LOGERROR(L"Failed to load symbols from COLLADA conversion DLL");
dll.Unload();
return false;
}
VfsPath skeletonPath("art/skeletons/skeletons.xml");
// Set the filename for the logger to report
set_logger(ColladaLog, static_cast<void*>(&skeletonPath));
CVFSFile skeletonFile;
if (skeletonFile.Load(g_VFS, skeletonPath) != PSRETURN_OK)
{
LOGERROR(L"Failed to read skeleton definitions");
dll.Unload();
return false;
}
int ok = set_skeleton_definitions((const char*)skeletonFile.GetBuffer(), (int)skeletonFile.GetBufferSize());
if (ok < 0)
{
LOGERROR(L"Failed to load skeleton definitions");
dll.Unload();
return false;
}
// TODO: the cached PMD/PSA files should probably be invalidated when
// the skeleton definition file is changed, else people will get confused
// as to why it's not picking up their changes
}
// Set the filename for the logger to report
set_logger(ColladaLog, const_cast<void*>(static_cast<const void*>(&daeFilename)));
// We need to null-terminate the buffer, so do it (possibly inefficiently)
// by converting to a CStr
CStr daeData;
{
CVFSFile daeFile;
if (daeFile.Load(g_VFS, daeFilename) != PSRETURN_OK)
return false;
daeData = daeFile.GetAsString();
}
// Do the conversion into a memory buffer
WriteBuffer writeBuffer;
switch (type)
{
case CColladaManager::PMD: convert_dae_to_pmd(daeData.c_str(), ColladaOutput, &writeBuffer); break;
case CColladaManager::PSA: convert_dae_to_psa(daeData.c_str(), ColladaOutput, &writeBuffer); break;
}
// don't create zero-length files (as happens in test_invalid_dae when
// we deliberately pass invalid XML data) because the VFS caching
// logic warns when asked to load such.
if (writeBuffer.Size())
{
Status ret = g_VFS->CreateFile(pmdFilename, writeBuffer.Data(), writeBuffer.Size());
ENSURE(ret == INFO::OK);
}
return true;
}
~CColladaManagerImpl()
{
if (dll.IsLoaded())
set_logger(NULL, NULL); // unregister the log handler
}
/**
* protected constructor restricts creation of objects (use create())
*
* @param tcp_conn TCP connection used to send the request
* @param handler function called after the request has been sent
*/
request_writer(tcp::connection_ptr& tcp_conn, finished_handler_t handler)
: http::writer(tcp_conn, handler), m_http_request(new http::request)
{
set_logger(PION_GET_LOGGER("pion.http.request_writer"));
}
madara::expression::ComponentNode::ComponentNode(logger::Logger& logger)
{
set_logger(logger);
}
int main(int argc, char **argv) {
struct sockaddr_un addr;
pid_t pid, sid;
int pipefd[2];
int clfd;
char deamonize;
if(argc==2 && !strncmp(argv[1], "-f", 3)) {
deamonize=0;
} else {
deamonize=1;
}
if(deamonize) {
if(pipe2(pipefd, O_CLOEXEC)) {
print( FATAL, "pipe2: %s", strerror(errno) );
return EXIT_FAILURE;
}
pid = fork();
if(pid<0) {
print( FATAL, "fork: %s", strerror(errno) );
return EXIT_FAILURE;
} else if(pid) {
close(pipefd[1]);
if(!read(pipefd[0], &clfd, 1))
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
close(pipefd[0]);
umask(0);
if(open_logfile(LOG_PATH)) {
print( FATAL, "cannot open logfile");
return EXIT_FAILURE;
}
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
set_logger(file_logger);
sid = setsid();
if(sid<0) {
print( FATAL, "setsid: %s", strerror(errno) );
return EXIT_FAILURE;
}
}
if(init_structs())
return EXIT_FAILURE;
if(load_handlers())
return EXIT_FAILURE;
if(load_users())
return EXIT_FAILURE;
if(remove_old_socket())
return EXIT_FAILURE;
sockfd = socket(AF_UNIX, SOCK_STREAM, 0);
if(sockfd < 0) {
print( FATAL, "socket: %s", strerror(errno) );
return EXIT_FAILURE;
}
if(register_signal_handlers()) {
close(sockfd);
return EXIT_FAILURE;
}
memset(&addr, 0, sizeof(struct sockaddr_un));
addr.sun_family = AF_UNIX;
strncpy(addr.sun_path, SOCKET_PATH, sizeof(addr.sun_path)-1);
if(bind(sockfd, (struct sockaddr*)&addr, sizeof(addr))) {
print( FATAL, "bind: %s", strerror(errno) );
close(sockfd);
unlink(SOCKET_PATH);
return EXIT_FAILURE;
}
if(listen(sockfd, 5)) {
print( FATAL, "listen: %s", strerror(errno) );
close(sockfd);
unlink(SOCKET_PATH);
return EXIT_FAILURE;
}
if(start_reaper()) {
close(sockfd);
unlink(SOCKET_PATH);
return EXIT_FAILURE;
}
#ifndef NDEBUG
chmod(SOCKET_PATH, 0666);
#endif
if(deamonize) {
if(write(pipefd[1], "!", 1) != 1) {
print( FATAL, "cannot notify that daemon started" );
return EXIT_FAILURE;
}
close(pipefd[1]);
}
while(1) {
if((clfd=accept(sockfd, NULL, NULL)) < 0) {
if(errno == EINVAL) {
#ifndef NDEBUG
print( DEBUG, "socket closed" );
#endif
}
print( ERROR, "accept: %s", strerror(errno) );
break;
}
if(serve_new_client(clfd)) {
print( WARNING, "cannot serve new connection" );
close(clfd);
}
}
unlink(SOCKET_PATH);
close_connections();
stop_reaper();
destroy_structs();
unload_users();
unload_handlers();
return EXIT_SUCCESS;
}
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);
}
~CColladaManagerImpl()
{
if (dll.IsLoaded())
set_logger(NULL, NULL); // unregister the log handler
UnregisterFileReloadFunc(ReloadChangedFileCB, this);
}
