/*ARGSUSED*/
static void
handle_int(int sig)
{
FILE *fp;
char dumpname[MAXPATHLEN];
time_t now;
struct rusage rusage;
(void) snprintf(dumpname, sizeof (dumpname), "/tmp/pppoed.%ld",
getpid());
if ((fp = fopen(dumpname, "w+")) == NULL) {
logerr("%s: %s", dumpname, mystrerror(errno));
return;
}
now = time(NULL);
(void) fprintf(fp, "pppoed running %s", ctime(&now));
(void) fprintf(fp, "Started on %s", ctime(&time_started));
if (last_reread != 0)
(void) fprintf(fp, "Last reconfig %s", ctime(&last_reread));
(void) putc('\n', fp);
if (getrusage(RUSAGE_SELF, &rusage) == 0) {
(void) fprintf(fp,
"CPU usage: user %ld.%06ld, system %ld.%06ld\n",
rusage.ru_utime.tv_sec, rusage.ru_utime.tv_usec,
rusage.ru_stime.tv_sec, rusage.ru_stime.tv_usec);
}
(void) fprintf(fp, "Packets: %lu received (%lu PADI, %lu PADR), ",
input_packets, padi_packets, padr_packets);
(void) fprintf(fp, "%lu transmitted\n", output_packets);
(void) fprintf(fp, "Sessions started: %lu\n\n", sessions_started);
dump_configuration(fp);
(void) fclose(fp);
}
int export_screens(struct option* opt)
{
dump_configuration(screens, num_screens, opt);
return 0;
}
/* ----------
* SlonMain
* ----------
*/
static void
SlonMain(void)
{
PGresult *res;
SlonDString query;
int i,
n;
PGconn *startup_conn;
slon_pid = getpid();
#ifndef WIN32
slon_worker_pid = slon_pid;
#endif
if (pthread_mutex_init(&slon_wait_listen_lock, NULL) < 0)
{
slon_log(SLON_FATAL, "main: pthread_mutex_init() failed - %s\n",
strerror(errno));
slon_abort();
}
if (pthread_cond_init(&slon_wait_listen_cond, NULL) < 0)
{
slon_log(SLON_FATAL, "main: pthread_cond_init() failed - %s\n",
strerror(errno));
slon_abort();
}
/*
* Dump out current configuration - all elements of the various arrays...
*/
dump_configuration();
/*
* Connect to the local database to read the initial configuration
*/
startup_conn = PQconnectdb(rtcfg_conninfo);
if (startup_conn == NULL)
{
slon_log(SLON_FATAL, "main: PQconnectdb() failed - sleep 10s\n");
sleep(10);
slon_retry();
exit(-1);
}
if (PQstatus(startup_conn) != CONNECTION_OK)
{
slon_log(SLON_FATAL, "main: Cannot connect to local database - %s - sleep 10s\n",
PQerrorMessage(startup_conn));
PQfinish(startup_conn);
sleep(10);
slon_retry();
exit(-1);
}
/*
* Get our local node ID
*/
rtcfg_nodeid = db_getLocalNodeId(startup_conn);
if (rtcfg_nodeid < 0)
{
slon_log(SLON_FATAL, "main: Node is not initialized properly - sleep 10s\n");
sleep(10);
slon_retry();
exit(-1);
}
if (db_checkSchemaVersion(startup_conn) < 0)
{
slon_log(SLON_FATAL, "main: Node has wrong Slony-I schema or module version loaded\n");
slon_abort();
}
slon_log(SLON_CONFIG, "main: local node id = %d\n", rtcfg_nodeid);
dstring_init(&query);
slon_mkquery(&query, "select %s.slon_node_health_check();", rtcfg_namespace);
res = PQexec(startup_conn, dstring_data(&query));
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
slon_log(SLON_FATAL, "could not call slon_node_health_check() - %",
PQresultErrorMessage(res));
slon_abort();
}
else
{
if (PQntuples(res) != 1)
{
slon_log(SLON_FATAL,
"query '%s' returned %d rows (expected 1)\n",
query, PQntuples(res));
slon_abort();
}
else
{
if (*(PQgetvalue(res, 0, 0)) == 'f')
{
slon_log(SLON_FATAL,
"slon_node_health_check() returned false - fatal health problem!\n%s\nREPAIR CONFIG may be helpful to rectify this problem\n",
PQresultErrorMessage(res));
slon_abort();
}
}
}
PQclear(res);
dstring_free(&query);
#ifndef WIN32
if (signal(SIGHUP, SIG_IGN) == SIG_ERR)
{
slon_log(SLON_FATAL, "main: SIGHUP signal handler setup failed -(%d) %s\n", errno, strerror(errno));
slon_abort();
}
if (signal(SIGINT, SIG_IGN) == SIG_ERR)
{
slon_log(SLON_FATAL, "main: SIGINT signal handler setup failed -(%d) %s\n", errno, strerror(errno));
slon_abort();
}
if (signal(SIGTERM, SIG_IGN) == SIG_ERR)
{
slon_log(SLON_FATAL, "main: SIGTERM signal handler setup failed -(%d) %s\n", errno, strerror(errno));
slon_abort();
}
if (signal(SIGCHLD, SIG_IGN) == SIG_ERR)
{
slon_log(SLON_FATAL, "main: SIGCHLD signal handler setup failed -(%d) %s\n", errno, strerror(errno));
slon_abort();
}
if (signal(SIGQUIT, SIG_IGN) == SIG_ERR)
{
slon_log(SLON_FATAL, "main: SIGQUIT signal handler setup failed -(%d) %s\n", errno, strerror(errno));
slon_abort();
}
#endif
slon_log(SLON_INFO, "main: main process started\n");
/*
* Start the event scheduling system
*/
slon_log(SLON_CONFIG, "main: launching sched_start_mainloop\n");
if (sched_start_mainloop() < 0)
slon_retry();
slon_log(SLON_CONFIG, "main: loading current cluster configuration\n");
/*
* Begin a transaction
*/
res = PQexec(startup_conn,
"start transaction; "
"set transaction isolation level serializable;");
if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
slon_log(SLON_FATAL, "Cannot start transaction - %s - sleep 10s\n",
PQresultErrorMessage(res));
sleep(10);
PQclear(res);
slon_retry();
}
PQclear(res);
/*
* Read configuration table sl_node
*/
dstring_init(&query);
slon_mkquery(&query,
"select no_id, no_active, no_comment, "
" (select coalesce(max(con_seqno),0) from %s.sl_confirm "
" where con_origin = no_id and con_received = %d) "
" as last_event, "
" (select ev_snapshot from %s.sl_event "
" where ev_origin = no_id "
" and ev_seqno = (select max(ev_seqno) "
" from %s.sl_event "
" where ev_origin = no_id "
" and ev_type = 'SYNC')) as last_snapshot "
"from %s.sl_node "
"order by no_id; ",
rtcfg_namespace, rtcfg_nodeid,
rtcfg_namespace, rtcfg_namespace,
rtcfg_namespace);
res = PQexec(startup_conn, dstring_data(&query));
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
slon_log(SLON_FATAL, "main: Cannot get node list - %s\n",
PQresultErrorMessage(res));
PQclear(res);
dstring_free(&query);
slon_retry();
}
for (i = 0, n = PQntuples(res); i < n; i++)
{
int no_id = (int) strtol(PQgetvalue(res, i, 0), NULL, 10);
int no_active = (*PQgetvalue(res, i, 1) == 't') ? 1 : 0;
char *no_comment = PQgetvalue(res, i, 2);
int64 last_event;
if (no_id == rtcfg_nodeid)
{
/*
* Complete our own local node entry
*/
rtcfg_nodeactive = no_active;
rtcfg_nodecomment = strdup(no_comment);
}
else
{
/*
* Add a remote node
*/
slon_scanint64(PQgetvalue(res, i, 3), &last_event);
rtcfg_storeNode(no_id, no_comment);
rtcfg_setNodeLastEvent(no_id, last_event);
rtcfg_setNodeLastSnapshot(no_id, PQgetvalue(res, i, 4));
/*
* If it is active, remember for activation just before we start
* processing events.
*/
if (no_active)
rtcfg_needActivate(no_id);
}
}
PQclear(res);
/*
* Read configuration table sl_path - the interesting pieces
*/
slon_mkquery(&query,
"select pa_server, pa_conninfo, pa_connretry "
"from %s.sl_path where pa_client = %d"
" and pa_conninfo<>'<event pending>'",
rtcfg_namespace, rtcfg_nodeid);
res = PQexec(startup_conn, dstring_data(&query));
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
slon_log(SLON_FATAL, "main: Cannot get path config - %s\n",
PQresultErrorMessage(res));
PQclear(res);
dstring_free(&query);
slon_retry();
}
for (i = 0, n = PQntuples(res); i < n; i++)
{
int pa_server = (int) strtol(PQgetvalue(res, i, 0), NULL, 10);
char *pa_conninfo = PQgetvalue(res, i, 1);
int pa_connretry = (int) strtol(PQgetvalue(res, i, 2), NULL, 10);
rtcfg_storePath(pa_server, pa_conninfo, pa_connretry);
}
PQclear(res);
/*
* Load the initial listen configuration
*/
rtcfg_reloadListen(startup_conn);
/*
* Read configuration table sl_set
*/
slon_mkquery(&query,
"select set_id, set_origin, set_comment "
"from %s.sl_set",
rtcfg_namespace);
res = PQexec(startup_conn, dstring_data(&query));
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
slon_log(SLON_FATAL, "main: Cannot get set config - %s\n",
PQresultErrorMessage(res));
PQclear(res);
dstring_free(&query);
slon_retry();
}
for (i = 0, n = PQntuples(res); i < n; i++)
{
int set_id = (int) strtol(PQgetvalue(res, i, 0), NULL, 10);
int set_origin = (int) strtol(PQgetvalue(res, i, 1), NULL, 10);
char *set_comment = PQgetvalue(res, i, 2);
rtcfg_storeSet(set_id, set_origin, set_comment);
}
PQclear(res);
/*
* Read configuration table sl_subscribe - only subscriptions for local
* node
*/
slon_mkquery(&query,
"select sub_set, sub_provider, sub_forward, sub_active "
"from %s.sl_subscribe "
"where sub_receiver = %d",
rtcfg_namespace, rtcfg_nodeid);
res = PQexec(startup_conn, dstring_data(&query));
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
slon_log(SLON_FATAL, "main: Cannot get subscription config - %s\n",
PQresultErrorMessage(res));
PQclear(res);
dstring_free(&query);
slon_retry();
}
for (i = 0, n = PQntuples(res); i < n; i++)
{
int sub_set = (int) strtol(PQgetvalue(res, i, 0), NULL, 10);
int sub_provider = (int) strtol(PQgetvalue(res, i, 1), NULL, 10);
char *sub_forward = PQgetvalue(res, i, 2);
char *sub_active = PQgetvalue(res, i, 3);
rtcfg_storeSubscribe(sub_set, sub_provider, sub_forward);
if (*sub_active == 't')
rtcfg_enableSubscription(sub_set, sub_provider, sub_forward);
}
PQclear(res);
/*
* Remember the last known local event sequence
*/
slon_mkquery(&query,
"select coalesce(max(ev_seqno), -1) from %s.sl_event "
"where ev_origin = '%d'",
rtcfg_namespace, rtcfg_nodeid);
res = PQexec(startup_conn, dstring_data(&query));
if (PQresultStatus(res) != PGRES_TUPLES_OK)
{
slon_log(SLON_FATAL, "main: Cannot get last local eventid - %s\n",
PQresultErrorMessage(res));
PQclear(res);
dstring_free(&query);
slon_retry();
}
if (PQntuples(res) == 0)
strcpy(rtcfg_lastevent, "-1");
else if (PQgetisnull(res, 0, 0))
strcpy(rtcfg_lastevent, "-1");
else
strcpy(rtcfg_lastevent, PQgetvalue(res, 0, 0));
PQclear(res);
dstring_free(&query);
slon_log(SLON_CONFIG,
"main: last local event sequence = %s\n",
rtcfg_lastevent);
/*
* Rollback the transaction we used to get the config snapshot
*/
res = PQexec(startup_conn, "rollback transaction;");
if (PQresultStatus(res) != PGRES_COMMAND_OK)
{
slon_log(SLON_FATAL, "main: Cannot rollback transaction - %s\n",
PQresultErrorMessage(res));
PQclear(res);
slon_retry();
}
PQclear(res);
/*
* Done with the startup, don't need the local connection any more.
*/
PQfinish(startup_conn);
slon_log(SLON_CONFIG, "main: configuration complete - starting threads\n");
/*
* Create the local event thread that monitors the local node for
* administrative events to adjust the configuration at runtime. We wait
* here until the local listen thread has checked that there is no other
* slon daemon running.
*/
pthread_mutex_lock(&slon_wait_listen_lock);
if (pthread_create(&local_event_thread, NULL, localListenThread_main, NULL) < 0)
{
slon_log(SLON_FATAL, "main: cannot create localListenThread - %s\n",
strerror(errno));
slon_retry();
}
pthread_cond_wait(&slon_wait_listen_cond, &slon_wait_listen_lock);
if (!slon_listen_started)
{
/**
* The local listen thread did not start up properly.
*/
slon_log(SLON_FATAL, "main: localListenThread did not start\n");
slon_abort();
}
pthread_mutex_unlock(&slon_wait_listen_lock);
/*
* Enable all nodes that are active
*/
rtcfg_doActivate();
/*
* Create the local cleanup thread that will remove old events and log
* data.
*/
if (pthread_create(&local_cleanup_thread, NULL, cleanupThread_main, NULL) < 0)
{
slon_log(SLON_FATAL, "main: cannot create cleanupThread - %s\n",
strerror(errno));
slon_retry();
}
/*
* Create the local sync thread that will generate SYNC events if we had
* local database updates.
*/
if (pthread_create(&local_sync_thread, NULL, syncThread_main, NULL) < 0)
{
slon_log(SLON_FATAL, "main: cannot create syncThread - %s\n",
strerror(errno));
slon_retry();
}
/*
* Create the local monitor thread that will process monitoring requests
*/
if (monitor_threads)
{
if (pthread_create(&local_monitor_thread, NULL, monitorThread_main, NULL) < 0)
{
slon_log(SLON_FATAL, "main: cannot create monitorThread - %s\n",
strerror(errno));
slon_retry();
}
}
/*
* Wait until the scheduler has shut down all remote connections
*/
slon_log(SLON_INFO, "main: running scheduler mainloop\n");
if (sched_wait_mainloop() < 0)
{
slon_log(SLON_FATAL, "main: scheduler returned with error\n");
slon_retry();
}
slon_log(SLON_INFO, "main: scheduler mainloop returned\n");
/*
* Wait for all remote threads to finish
*/
main_thread = pthread_self();
slon_log(SLON_CONFIG, "main: wait for remote threads\n");
rtcfg_joinAllRemoteThreads();
/*
* Wait for the local threads to finish
*/
if (pthread_join(local_event_thread, NULL) < 0)
slon_log(SLON_ERROR, "main: cannot join localListenThread - %s\n",
strerror(errno));
if (pthread_join(local_cleanup_thread, NULL) < 0)
slon_log(SLON_ERROR, "main: cannot join cleanupThread - %s\n",
strerror(errno));
if (pthread_join(local_sync_thread, NULL) < 0)
slon_log(SLON_ERROR, "main: cannot join syncThread - %s\n",
strerror(errno));
if (pthread_join(local_monitor_thread, NULL) < 0)
slon_log(SLON_ERROR, "main: cannot join monitorThread - %s\n",
strerror(errno));
slon_log(SLON_CONFIG, "main: done\n");
exit(0);
}
static __libcobalt_ctor void __init_cobalt(void)
{
pthread_t ptid = pthread_self();
struct sched_param parm;
int policy, ret;
const char *p;
p = getenv("XENO_CONFIG_OUTPUT");
if (p && *p) {
dump_configuration();
_exit(0);
}
#ifndef CONFIG_SMP
ret = get_static_cpu_count();
if (ret > 0)
report_error("running non-SMP libraries on SMP kernel?");
#endif
__cobalt_main_ptid = ptid;
cobalt_default_mutexattr_init();
cobalt_default_condattr_init();
if (__cobalt_defer_init)
return;
__libcobalt_init();
if (__cobalt_no_shadow)
return;
p = getenv("XENO_NOSHADOW");
if (p && *p)
return;
ret = __STD(pthread_getschedparam(ptid, &policy, &parm));
if (ret) {
report_error("pthread_getschedparam: %s", strerror(ret));
exit(EXIT_FAILURE);
}
/*
* Switch the main thread to a Xenomai shadow.
* __cobalt_main_prio might have been overriden by
* some compilation unit which has been linked in, to force
* the scheduling parameters. Otherwise, the current policy
* and priority are reused, for declaring the thread to the
* Xenomai scheduler.
*
* SCHED_FIFO is assumed for __cobalt_main_prio > 0.
*/
if (__cobalt_main_prio > 0) {
policy = SCHED_FIFO;
parm.sched_priority = __cobalt_main_prio;
} else if (__cobalt_main_prio == 0) {
policy = SCHED_OTHER;
parm.sched_priority = 0;
}
ret = __RT(pthread_setschedparam(ptid, policy, &parm));
if (ret) {
report_error("pthread_setschedparam: %s", strerror(ret));
exit(EXIT_FAILURE);
}
}
int main(int argc, char** argv) {
int opt;
uint16_t register_number = REGISTER_INVALID;
uint16_t register_value;
int result = hackrf_init();
if( result ) {
printf("hackrf_init() failed: %s (%d)\n", hackrf_error_name(result), result);
return -1;
}
hackrf_device* device = NULL;
result = hackrf_open(&device);
if( result ) {
printf("hackrf_open() failed: %s (%d)\n", hackrf_error_name(result), result);
return -1;
}
int option_index = 0;
while( (opt = getopt_long(argc, argv, "cn:rw:", long_options, &option_index)) != EOF ) {
switch( opt ) {
case 'n':
result = parse_int(optarg, ®ister_number);
break;
case 'w':
result = parse_int(optarg, ®ister_value);
if( result == HACKRF_SUCCESS ) {
result = write_register(device, register_number, register_value);
}
break;
case 'r':
if( register_number == REGISTER_INVALID ) {
result = dump_registers(device);
} else {
result = dump_register(device, register_number);
}
break;
case 'c':
dump_configuration(device);
break;
default:
usage();
}
if( result != HACKRF_SUCCESS ) {
printf("argument error: %s (%d)\n", hackrf_error_name(result), result);
break;
}
}
result = hackrf_close(device);
if( result ) {
printf("hackrf_close() failed: %s (%d)\n", hackrf_error_name(result), result);
return -1;
}
hackrf_exit();
return 0;
}
static int init(char *argv[]) {
struct stat fstatus;
struct group *group;
cp_string filename;
const char *uri=cupsBackendDeviceURI(argv);
if ((uri != NULL) && (strncmp(uri, "cups-pdf:/", 10) == 0) && strlen(uri) > 10) {
uri = uri + 10;
sprintf(filename, "%s/cups-pdf-%s.conf", CP_CONFIG_PATH, uri);
}
else {
sprintf(filename, "%s/cups-pdf.conf", CP_CONFIG_PATH);
}
read_config_file(filename);
cwwdebug(filename);
read_config_ppd();
read_config_options(argv[5]);
(void) umask(0077);
group=getgrnam(Conf_Grp);
if (group)
(void) setgid(group->gr_gid);
cwwdebug(Conf_Log);
if (strlen(Conf_Log)) {
if (stat(Conf_Log, &fstatus) || !S_ISDIR(fstatus.st_mode)) {
if (create_dir(Conf_Log, 1))
return 1;
if (chmod(Conf_Log, 0700))
return 1;
}
snprintf(filename, BUFSIZE, "%s/%s%s%s", Conf_Log, "cups-pdf-", getenv("PRINTER"), "_log");
logfp=fopen(filename, "a");
}
char tmpstr[100];
*tmpstr = '\0';
sprintf(tmpstr, "uid = %d, euid = %d", getuid(), geteuid());
cwwdebug(tmpstr);
if (logfp == NULL) {
cwwdebug(strerror(errno));
cwwdebug("logfp == NULL");
}
cwwdebug(filename);
dump_configuration();
if (!group) {
log_event(CPERROR, "Grp not found: %s", Conf_Grp);
return 1;
}
else
log_event(CPDEBUG, "switching to new gid: %s", Conf_Grp);
cwwdebug("group");
(void) umask(0022);
cwwdebug("umask");
cwwdebug(Conf_Spool);
if (stat(Conf_Spool, &fstatus) || !S_ISDIR(fstatus.st_mode)) {
if (create_dir(Conf_Spool, 0)) {
log_event(CPERROR, "failed to create spool directory: %s", Conf_Spool);
return 1;
}
cwwdebug("create_dir(Conf_Spool, 0) success!");
if (chmod(Conf_Spool, 0751)) {
log_event(CPERROR, "failed to set mode on spool directory: %s", Conf_Spool);
return 1;
}
cwwdebug("chmod(Conf_Spool, 0751) success!");
if (chown(Conf_Spool, -1, group->gr_gid))
log_event(CPERROR, "failed to set group id %s on spool directory: %s (non fatal)", Conf_Grp, Conf_Spool);
log_event(CPSTATUS, "spool directory created: %s", Conf_Spool);
}
cwwdebug("stat");
(void) umask(0077);
return 0;
}
