mime_t * /* O - MIME database */
mimeLoadTypes(mime_t *mime, /* I - MIME database or @code NULL@ to create a new one */
const char *pathname) /* I - Directory to load from */
{
cups_dir_t *dir; /* Directory */
cups_dentry_t *dent; /* Directory entry */
char filename[1024]; /* Full filename of .types file */
DEBUG_printf(("mimeLoadTypes(mime=%p, pathname=\"%s\")", mime, pathname));
/*
* First open the directory specified by pathname...
*/
if ((dir = cupsDirOpen(pathname)) == NULL)
{
DEBUG_printf(("1mimeLoadTypes: Unable to open \"%s\": %s", pathname,
strerror(errno)));
DEBUG_printf(("1mimeLoadTypes: Returning %p.", mime));
_mimeError(mime, "Unable to open \"%s\": %s", pathname, strerror(errno));
return (mime);
}
/*
* If "mime" is NULL, make a new, empty database...
*/
if (!mime)
mime = mimeNew();
if (!mime)
{
cupsDirClose(dir);
DEBUG_puts("1mimeLoadTypes: Returning NULL.");
return (NULL);
}
/*
* Read all the .types files...
*/
while ((dent = cupsDirRead(dir)) != NULL)
{
if (strlen(dent->filename) > 6 &&
!strcmp(dent->filename + strlen(dent->filename) - 6, ".types"))
{
/*
* Load a mime.types file...
*/
snprintf(filename, sizeof(filename), "%s/%s", pathname, dent->filename);
DEBUG_printf(("1mimeLoadTypes: Loading \"%s\".", filename));
mime_load_types(mime, filename);
}
}
cupsDirClose(dir);
DEBUG_printf(("1mimeLoadTypes: Returning %p.", mime));
return (mime);
}
static int /* O - 0 = success, -1 = error, 1 = updated */
help_load_directory(
help_index_t *hi, /* I - Index */
const char *directory, /* I - Directory */
const char *relative) /* I - Relative path */
{
cups_dir_t *dir; /* Directory file */
cups_dentry_t *dent; /* Directory entry */
char *ext, /* Pointer to extension */
filename[1024], /* Full filename */
relname[1024]; /* Relative filename */
int update; /* Updated? */
help_node_t *node; /* Current node */
DEBUG_printf(("2help_load_directory(hi=%p, directory=\"%s\", relative=\"%s\")",
hi, directory, relative));
/*
* Open the directory and scan it...
*/
if ((dir = cupsDirOpen(directory)) == NULL)
return (0);
update = 0;
while ((dent = cupsDirRead(dir)) != NULL)
{
/*
* Skip "." files...
*/
if (dent->filename[0] == '.')
continue;
/*
* Get absolute and relative filenames...
*/
snprintf(filename, sizeof(filename), "%s/%s", directory, dent->filename);
if (relative)
snprintf(relname, sizeof(relname), "%s/%s", relative, dent->filename);
else
strlcpy(relname, dent->filename, sizeof(relname));
/*
* Check if we have a HTML file...
*/
if ((ext = strstr(dent->filename, ".html")) != NULL &&
(!ext[5] || !strcmp(ext + 5, ".gz")))
{
/*
* HTML file, see if we have already indexed the file...
*/
if ((node = helpFindNode(hi, relname, NULL)) != NULL)
{
/*
* File already indexed - check dates to confirm that the
* index is up-to-date...
*/
if (node->mtime == dent->fileinfo.st_mtime)
{
/*
* Same modification time, so mark all of the nodes
* for this file as up-to-date...
*/
for (; node; node = (help_node_t *)cupsArrayNext(hi->nodes))
if (!strcmp(node->filename, relname))
node->score = 0;
else
break;
continue;
}
}
update = 1;
help_load_file(hi, filename, relname, dent->fileinfo.st_mtime);
}
else if (S_ISDIR(dent->fileinfo.st_mode))
{
/*
* Process sub-directory...
*/
if (help_load_directory(hi, filename, relname) == 1)
update = 1;
}
}
cupsDirClose(dir);
return (update);
}
mime_t * /* O - MIME database */
mimeLoadFilters(mime_t *mime, /* I - MIME database */
const char *pathname, /* I - Directory to load from */
const char *filterpath) /* I - Default filter program directory */
{
cups_dir_t *dir; /* Directory */
cups_dentry_t *dent; /* Directory entry */
char filename[1024]; /* Full filename of .convs file */
cups_array_t *filtercache; /* Filter cache */
DEBUG_printf(("mimeLoadFilters(mime=%p, pathname=\"%s\", filterpath=\"%s\")",
mime, pathname, filterpath));
/*
* Range check input...
*/
if (!mime || !pathname || !filterpath)
{
DEBUG_puts("1mimeLoadFilters: Bad arguments.");
return (mime);
}
/*
* Then open the directory specified by pathname...
*/
if ((dir = cupsDirOpen(pathname)) == NULL)
{
DEBUG_printf(("1mimeLoadFilters: Unable to open \"%s\": %s", pathname,
strerror(errno)));
_mimeError(mime, "Unable to open \"%s\": %s", pathname, strerror(errno));
return (mime);
}
/*
* Read all the .convs files...
*/
filtercache = cupsArrayNew((cups_array_func_t)mime_compare_fcache, NULL);
while ((dent = cupsDirRead(dir)) != NULL)
{
if (strlen(dent->filename) > 6 &&
!strcmp(dent->filename + strlen(dent->filename) - 6, ".convs"))
{
/*
* Load a mime.convs file...
*/
snprintf(filename, sizeof(filename), "%s/%s", pathname, dent->filename);
DEBUG_printf(("1mimeLoadFilters: Loading \"%s\".", filename));
mime_load_convs(mime, filename, filterpath, filtercache);
}
}
mime_delete_fcache(filtercache);
cupsDirClose(dir);
return (mime);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[] /* I - Command-line arguments */
#ifdef PRINT_AUXV
,
char* envp[]
#endif
)
{
int i; /* Looping var */
char *opt; /* Option character */
int fg; /* Run in the foreground */
int fds; /* Number of ready descriptors */
cupsd_client_t *con; /* Current client */
cupsd_job_t *job; /* Current job */
cupsd_listener_t *lis; /* Current listener */
time_t current_time, /* Current time */
activity, /* Client activity timer */
browse_time, /* Next browse send time */
senddoc_time, /* Send-Document time */
expire_time, /* Subscription expire time */
report_time, /* Malloc/client/job report time */
event_time; /* Last time an event notification was done */
long timeout; /* Timeout for cupsdDoSelect() */
struct rlimit limit; /* Runtime limit */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
#ifdef __sgi
cups_file_t *fp; /* Fake lpsched lock file */
struct stat statbuf; /* Needed for checking lpsched FIFO */
#endif /* __sgi */
#ifdef __APPLE__
int run_as_child = 0;
/* Needed for Mac OS X fork/exec */
#else
time_t netif_time = 0; /* Time since last network update */
#endif /* __APPLE__ */
#if HAVE_LAUNCHD
int launchd_idle_exit;
/* Idle exit on select timeout? */
#endif /* HAVE_LAUNCHD */
#ifdef PRINT_AUXV
Elf32_auxv_t *auxv;
while(*envp++ != NULL);
for (auxv = (Elf32_auxv_t *)envp; auxv->a_type != AT_NULL; auxv++)
{
if (auxv->a_type == AT_SYSINFO)
{
printf("AT_RANDOM is 0x%x\n", auxv->a_un.a_val);
}
}
#endif
#if UNDERSTAND_CUPS
printf("[main.c::main()] cups has just started in main()\n");
#endif
int count = 0;
int loops_desired = -1; // loop forever unless this is set
#ifdef HAVE_GETEUID
/*
* Check for setuid invocation, which we do not support!
*/
if (getuid() != geteuid())
{
fputs("cupsd: Cannot run as a setuid program!\n", stderr);
return (1);
}
#if UNDERSTAND_CUPS
printf("[main.c::main()] uid = %d, euid = %d\n", getuid(), geteuid());
#endif
#endif /* HAVE_GETEUID */
/*
* Check for command-line arguments...
*/
#if UNDERSTAND_CUPS
printf("[main.c::main()] parsing command line arguments \n");
#endif
fg = 0;
#ifdef HAVE_LAUNCHD
if (getenv("CUPSD_LAUNCHD"))
{
Launchd = 1;
fg = 1;
}
#endif /* HAVE_LAUNCHD */
for (i = 1; i < argc; i ++)
if (argv[i][0] == '-')
for (opt = argv[i] + 1; *opt != '\0'; opt ++)
switch (*opt)
{
#ifdef __APPLE__
case 'C' : /* Run as child with config file */
run_as_child = 1;
fg = -1;
#endif /* __APPLE__ */
case 'c' : /* Configuration file */
i ++;
if (i >= argc)
{
_cupsLangPuts(stderr, _("cupsd: Expected config filename "
"after \"-c\" option!\n"));
usage(1);
}
if (argv[i][0] == '/')
{
/*
* Absolute directory...
*/
cupsdSetString(&ConfigurationFile, argv[i]);
}
else
{
/*
* Relative directory...
*/
char *current; /* Current directory */
/*
* Allocate a buffer for the current working directory to
* reduce run-time stack usage; this approximates the
* behavior of some implementations of getcwd() when they
* are passed a NULL pointer.
*/
if ((current = malloc(1024)) == NULL)
{
_cupsLangPuts(stderr,
_("cupsd: Unable to get current directory!\n"));
return (1);
}
if (!getcwd(current, 1024))
{
_cupsLangPuts(stderr,
_("cupsd: Unable to get current directory!\n"));
free(current);
return (1);
}
cupsdSetStringf(&ConfigurationFile, "%s/%s", current, argv[i]);
free(current);
}
break;
case 'f' : /* Run in foreground... */
fg = 1;
break;
case 'F' : /* Run in foreground, but disconnect from terminal... */
fg = -1;
break;
case 'h' : /* Show usage/help */
usage(0);
break;
case 'l' : /* Started by launchd... */
#ifdef HAVE_LAUNCHD
Launchd = 1;
fg = 1;
#else
_cupsLangPuts(stderr, _("cupsd: launchd(8) support not compiled "
"in, running in normal mode.\n"));
fg = 0;
#endif /* HAVE_LAUNCHD */
break;
case 'p' : /* Stop immediately for profiling */
puts("Warning: -p option is for internal testing use only!");
stop_scheduler = 1;
fg = 1;
break;
/// XXX RAZA
case 'x' : /* Number of Iterations to Perform */
i ++;
loops_desired = atoi(argv[i]);
break;
default : /* Unknown option */
_cupsLangPrintf(stderr, _("cupsd: Unknown option \"%c\" - "
"aborting!\n"), *opt);
usage(1);
break;
}
else
{
_cupsLangPrintf(stderr, _("cupsd: Unknown argument \"%s\" - aborting!\n"),
argv[i]);
usage(1);
}
#if UNDERSTAND_CUPS
printf("[main.c::main()] done parsing command line arguments \n");
printf("[main.c::main()] num_loops = %d, foreground = %d\n", loops_desired, fg);
#endif
if (!ConfigurationFile)
cupsdSetString(&ConfigurationFile, CUPS_SERVERROOT "/cupsd.conf");
printf("[main.c::main()] configuration file = %s\n", ConfigurationFile);
/*
* If the user hasn't specified "-f", run in the background...
*/
if (!fg)
{
/*
* Setup signal handlers for the parent...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGUSR1, parent_handler);
sigset(SIGCHLD, parent_handler);
sigset(SIGHUP, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGUSR1);
action.sa_handler = parent_handler;
sigaction(SIGUSR1, &action, NULL);
sigaction(SIGCHLD, &action, NULL);
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGHUP, &action, NULL);
#else
signal(SIGUSR1, parent_handler);
signal(SIGCLD, parent_handler);
signal(SIGHUP, SIG_IGN);
#endif /* HAVE_SIGSET */
if (fork() > 0)
{
/*
* OK, wait for the child to startup and send us SIGUSR1 or to crash
* and the OS send us SIGCHLD... We also need to ignore SIGHUP which
* might be sent by the init script to restart the scheduler...
*/
for (; parent_signal == 0;)
sleep(1);
if (parent_signal == SIGUSR1)
return (0);
if (wait(&i) < 0)
{
perror("cupsd");
return (1);
}
else if (WIFEXITED(i))
{
fprintf(stderr, "cupsd: Child exited with status %d!\n",
WEXITSTATUS(i));
return (2);
}
else
{
fprintf(stderr, "cupsd: Child exited on signal %d!\n", WTERMSIG(i));
return (3);
}
}
#ifdef __APPLE__
/*
* Since CoreFoundation has an overly-agressive check for whether a
* process has forked but not exec'd (whether CF has been called or
* not...), we now have to exec ourselves with the "-f" option to
* eliminate their bogus warning messages.
*/
execlp(argv[0], argv[0], "-C", ConfigurationFile, (char *)0);
exit(errno);
#endif /* __APPLE__ */
}
if (fg < 1)
{
/*
* Make sure we aren't tying up any filesystems...
*/
chdir("/");
#ifndef DEBUG
/*
* Disable core dumps...
*/
getrlimit(RLIMIT_CORE, &limit);
limit.rlim_cur = 0;
setrlimit(RLIMIT_CORE, &limit);
/*
* Disconnect from the controlling terminal...
*/
setsid();
/*
* Close all open files...
*/
getrlimit(RLIMIT_NOFILE, &limit);
for (i = 0; i < limit.rlim_cur && i < 1024; i ++)
close(i);
#endif /* DEBUG */
}
/*
* Set the timezone info...
*/
#if UNDERSTAND_CUPS
printf("[main.c::main()] setting timezone info, tzset()\n");
#endif
tzset();
#ifdef LC_TIME
setlocale(LC_TIME, "");
#if UNDERSTAND_CUPS
printf("[main.c::main()] setting locale info, setlocale()\n");
#endif
#endif /* LC_TIME */
/*
* Set the maximum number of files...
*/
getrlimit(RLIMIT_NOFILE, &limit);
#if !defined(HAVE_POLL) && !defined(HAVE_EPOLL) && !defined(HAVE_KQUEUE)
if (limit.rlim_max > FD_SETSIZE)
MaxFDs = FD_SETSIZE;
else
#endif /* !HAVE_POLL && !HAVE_EPOLL && !HAVE_KQUEUE */
#ifdef RLIM_INFINITY
if (limit.rlim_max == RLIM_INFINITY)
MaxFDs = 16384;
else
#endif /* RLIM_INFINITY */
MaxFDs = limit.rlim_max;
limit.rlim_cur = MaxFDs;
setrlimit(RLIMIT_NOFILE, &limit);
#if UNDERSTAND_CUPS
printf("[main.c::main()] set the maximum nuber of files = %d\n", MaxFDs);
#endif
cupsdStartSelect();
#if UNDERSTAND_CUPS
printf("[main.c::main()] done with cupsdStartSelect() i.e. polling engine\n");
#endif
/*
* Read configuration...
*/
if (!cupsdReadConfiguration())
{
syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting!",
ConfigurationFile);
return (1);
}
printf("[main.c::main()] done with cupsdReadConfiguration\n");
if (!strncmp(TempDir, RequestRoot, strlen(RequestRoot)))
{
/*
* Clean out the temporary directory...
*/
cups_dir_t *dir; /* Temporary directory */
cups_dentry_t *dent; /* Directory entry */
char tempfile[1024]; /* Temporary filename */
printf("[main.c::main()] cleaning temp dir = %s\n", TempDir);
if ((dir = cupsDirOpen(TempDir)) != NULL)
{
cupsdLogMessage(CUPSD_LOG_INFO,
"Cleaning out old temporary files in \"%s\"...", TempDir);
while ((dent = cupsDirRead(dir)) != NULL)
{
snprintf(tempfile, sizeof(tempfile), "%s/%s", TempDir, dent->filename);
printf("[main.c::main()] deleting temp file = %s\n", tempfile);
if (cupsdRemoveFile(tempfile)) {
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to remove temporary file \"%s\" - %s",
tempfile, strerror(errno));
printf("[main.c::main()] failed in deleting temp file = %s\n", tempfile);
}
else {
cupsdLogMessage(CUPSD_LOG_DEBUG, "Removed temporary file \"%s\"...",
tempfile);
printf("[main.c::main()] deleted temp file = %s\n", tempfile);
}
}
cupsDirClose(dir);
}
else {
cupsdLogMessage(CUPSD_LOG_ERROR,
"Unable to open temporary directory \"%s\" - %s",
TempDir, strerror(errno));
printf("[main.c::main()] couldn't open temp dir = %s\n", TempDir);
}
printf("[main.c::main()] DONE cleaning temp dir = %s\n", TempDir);
}
#if HAVE_LAUNCHD
if (Launchd)
{
/*
* If we were started by launchd get the listen sockets file descriptors...
*/
printf("[main.c::main()] launchd check in \n");
launchd_checkin();
}
#endif /* HAVE_LAUNCHD */
#if defined(__APPLE__) && defined(HAVE_DLFCN_H)
/*
* Load Print Service quota enforcement library (X Server only)
*/
PSQLibRef = dlopen(PSQLibPath, RTLD_LAZY);
if (PSQLibRef)
PSQUpdateQuotaProc = dlsym(PSQLibRef, PSQLibFuncName);
#endif /* __APPLE__ && HAVE_DLFCN_H */
#ifdef HAVE_GSSAPI
# ifdef __APPLE__
/*
* If the weak-linked GSSAPI/Kerberos library is not present, don't try
* to use it...
*/
if (krb5_init_context != NULL)
# endif /* __APPLE__ */
/*
* Setup a Kerberos context for the scheduler to use...
*/
if (krb5_init_context(&KerberosContext))
{
KerberosContext = NULL;
printf("[main.c::main()] unable to use krb5_init_context() \n");
cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to initialize Kerberos context");
}
else
{
printf("[main.c::main()] used krb5_init_context() \n");
}
#endif /* HAVE_GSSAPI */
/*
* Startup the server...
*/
cupsdStartServer();
/*
* Catch hangup and child signals and ignore broken pipes...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGCHLD, sigchld_handler);
sigset(SIGHUP, sighup_handler);
sigset(SIGPIPE, SIG_IGN);
sigset(SIGTERM, sigterm_handler);
printf("[main.c::main()] used system V signals over POSIX\n");
#elif defined(HAVE_SIGACTION)
printf("[main.c::main()] used HAVE_SIGACTION\n");
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGTERM);
sigaddset(&action.sa_mask, SIGCHLD);
action.sa_handler = sigchld_handler;
sigaction(SIGCHLD, &action, NULL);
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGHUP);
action.sa_handler = sighup_handler;
sigaction(SIGHUP, &action, NULL);
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGTERM);
sigaddset(&action.sa_mask, SIGCHLD);
action.sa_handler = sigterm_handler;
sigaction(SIGTERM, &action, NULL);
#else
printf("[main.c::main()]last signal options\n");
signal(SIGCLD, sigchld_handler); /* No, SIGCLD isn't a typo... */
signal(SIGHUP, sighup_handler);
signal(SIGPIPE, SIG_IGN);
signal(SIGTERM, sigterm_handler);
#endif /* HAVE_SIGSET */
#ifdef __sgi
/*
* Try to create a fake lpsched lock file if one is not already there.
* Some Adobe applications need it under IRIX in order to enable
* printing...
*/
printf("[main.c::main()] creating fake lpsched lock file \n");
if ((fp = cupsFileOpen("/var/spool/lp/SCHEDLOCK", "w")) == NULL)
{
syslog(LOG_LPR, "Unable to create fake lpsched lock file "
"\"/var/spool/lp/SCHEDLOCK\"\' - %s!",
strerror(errno));
}
else
{
fchmod(cupsFileNumber(fp), 0644);
fchown(cupsFileNumber(fp), User, Group);
cupsFileClose(fp);
}
#endif /* __sgi */
/*
* Initialize authentication certificates...
*/
cupsdInitCerts();
/*
* If we are running in the background, signal the parent process that
* we are up and running...
*/
#ifdef __APPLE__
if (!fg || run_as_child)
#else
if (!fg)
#endif /* __APPLE__ */
{
/*
* Send a signal to the parent process, but only if the parent is
* not PID 1 (init). This avoids accidentally shutting down the
* system on OpenBSD if you CTRL-C the server before it is up...
*/
i = getppid(); /* Save parent PID to avoid race condition */
if (i != 1)
kill(i, SIGUSR1);
}
#ifdef __APPLE__
/*
* Start power management framework...
*/
printf("[main.c::main()] starting system monitor (power management) \n");
cupsdStartSystemMonitor();
#endif /* __APPLE__ */
/*
* Start any pending print jobs...
*/
printf("[main.c::main()] starting any pending print jobs \n");
cupsdCheckJobs();
/*
* Loop forever...
*/
current_time = time(NULL);
browse_time = current_time;
event_time = current_time;
expire_time = current_time;
fds = 1;
report_time = 0;
senddoc_time = current_time;
while (!stop_scheduler)
{
// XXX RAZA
printf("[main.c::main()] scheduler loop # %d\n", count);
if (count++ == loops_desired)
{
printf("[main.c::main()] stopping scheduler loop\n");
stop_scheduler = 1;
continue;
}
printf("[main.c::main()] Top of loop, dead_children=%d, NeedReload=%d\n",
dead_children, NeedReload);
#ifdef DEBUG
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"main: Top of loop, dead_children=%d, NeedReload=%d",
dead_children, NeedReload);
#endif /* DEBUG */
/*
* Check if there are dead children to handle...
*/
if (dead_children)
process_children();
/*
* Check if we need to load the server configuration file...
*/
if (NeedReload)
{
/*
* Close any idle clients...
*/
if (cupsArrayCount(Clients) > 0)
{
for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
con;
con = (cupsd_client_t *)cupsArrayNext(Clients))
if (con->http.state == HTTP_WAITING)
cupsdCloseClient(con);
else
con->http.keep_alive = HTTP_KEEPALIVE_OFF;
cupsdPauseListening();
}
/*
* Check for any active jobs...
*/
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
if (job->state_value == IPP_JOB_PROCESSING)
break;
/*
* Restart if all clients are closed and all jobs finished, or
* if the reload timeout has elapsed...
*/
if ((cupsArrayCount(Clients) == 0 &&
(!job || NeedReload != RELOAD_ALL)) ||
(time(NULL) - ReloadTime) >= ReloadTimeout)
{
/*
* Shutdown the server...
*/
cupsdStopServer();
/*
* Read configuration...
*/
if (!cupsdReadConfiguration())
{
syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting!",
ConfigurationFile);
break;
}
#if HAVE_LAUNCHD
if (Launchd)
{
/*
* If we were started by launchd get the listen sockets file descriptors...
*/
launchd_checkin();
}
#endif /* HAVE_LAUNCHD */
/*
* Startup the server...
*/
cupsdStartServer();
}
}
/*
* Check for available input or ready output. If cupsdDoSelect()
* returns 0 or -1, something bad happened and we should exit
* immediately.
*
* Note that we at least have one listening socket open at all
* times.
*/
if ((timeout = select_timeout(fds)) > 1 && LastEvent)
timeout = 1;
#if HAVE_LAUNCHD
/*
* If no other work is scheduled and we're being controlled by
* launchd then timeout after 'LaunchdTimeout' seconds of
* inactivity...
*/
if (timeout == 86400 && Launchd && LaunchdTimeout && !NumPolled &&
!cupsArrayCount(ActiveJobs) &&
(!Browsing ||
(!BrowseRemoteProtocols &&
(!NumBrowsers || !BrowseLocalProtocols ||
cupsArrayCount(Printers) == 0))))
{
timeout = LaunchdTimeout;
launchd_idle_exit = 1;
}
else
launchd_idle_exit = 0;
#endif /* HAVE_LAUNCHD */
if ((fds = cupsdDoSelect(timeout)) < 0)
{
/*
* Got an error from select!
*/
#ifdef HAVE_DNSSD
cupsd_printer_t *p; /* Current printer */
#endif /* HAVE_DNSSD */
if (errno == EINTR) /* Just interrupted by a signal */
continue;
/*
* Log all sorts of debug info to help track down the problem.
*/
cupsdLogMessage(CUPSD_LOG_EMERG, "cupsdDoSelect() failed - %s!",
strerror(errno));
for (i = 0, con = (cupsd_client_t *)cupsArrayFirst(Clients);
con;
i ++, con = (cupsd_client_t *)cupsArrayNext(Clients))
cupsdLogMessage(CUPSD_LOG_EMERG,
"Clients[%d] = %d, file = %d, state = %d",
i, con->http.fd, con->file, con->http.state);
for (i = 0, lis = (cupsd_listener_t *)cupsArrayFirst(Listeners);
lis;
i ++, lis = (cupsd_listener_t *)cupsArrayNext(Listeners))
cupsdLogMessage(CUPSD_LOG_EMERG, "Listeners[%d] = %d", i, lis->fd);
cupsdLogMessage(CUPSD_LOG_EMERG, "BrowseSocket = %d", BrowseSocket);
cupsdLogMessage(CUPSD_LOG_EMERG, "CGIPipes[0] = %d", CGIPipes[0]);
#ifdef __APPLE__
cupsdLogMessage(CUPSD_LOG_EMERG, "SysEventPipes[0] = %d",
SysEventPipes[0]);
#endif /* __APPLE__ */
for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs);
job;
job = (cupsd_job_t *)cupsArrayNext(ActiveJobs))
cupsdLogMessage(CUPSD_LOG_EMERG, "Jobs[%d] = %d < [%d %d] > [%d %d]",
job->id,
job->status_buffer ? job->status_buffer->fd : -1,
job->print_pipes[0], job->print_pipes[1],
job->back_pipes[0], job->back_pipes[1]);
#ifdef HAVE_DNSSD
for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
p;
p = (cupsd_printer_t *)cupsArrayNext(Printers))
cupsdLogMessage(CUPSD_LOG_EMERG, "printer[%s] %d", p->name,
p->dnssd_ipp_fd);
#endif /* HAVE_DNSSD */
break;
}
current_time = time(NULL);
#ifndef __APPLE__
/*
* Update the network interfaces once a minute...
*/
if ((current_time - netif_time) >= 60)
{
netif_time = current_time;
NetIFUpdate = 1;
}
#endif /* !__APPLE__ */
#if HAVE_LAUNCHD
/*
* If no other work was scheduled and we're being controlled by launchd
* then timeout after 'LaunchdTimeout' seconds of inactivity...
*/
if (!fds && launchd_idle_exit)
{
cupsdLogMessage(CUPSD_LOG_INFO,
"Printer sharing is off and there are no jobs pending, "
"will restart on demand.");
stop_scheduler = 1;
break;
}
#endif /* HAVE_LAUNCHD */
/*
* Resume listening for new connections as needed...
*/
if (ListeningPaused && ListeningPaused <= current_time &&
cupsArrayCount(Clients) < MaxClients)
cupsdResumeListening();
/*
* Expire subscriptions and unload completed jobs as needed...
*/
if (current_time > expire_time)
{
if (cupsArrayCount(Subscriptions) > 0)
cupsdExpireSubscriptions(NULL, NULL);
cupsdUnloadCompletedJobs();
expire_time = current_time;
}
/*
* Update the browse list as needed...
*/
if (Browsing)
{
#ifdef HAVE_LIBSLP
if ((BrowseRemoteProtocols & BROWSE_SLP) &&
BrowseSLPRefresh <= current_time)
cupsdUpdateSLPBrowse();
#endif /* HAVE_LIBSLP */
#ifdef HAVE_LDAP
if ((BrowseRemoteProtocols & BROWSE_LDAP) &&
BrowseLDAPRefresh <= current_time)
cupsdUpdateLDAPBrowse();
#endif /* HAVE_LDAP */
}
if (Browsing && current_time > browse_time)
{
cupsdSendBrowseList();
browse_time = current_time;
}
/*
* Update the root certificate once every 5 minutes if we have client
* connections...
*/
if ((current_time - RootCertTime) >= RootCertDuration && RootCertDuration &&
!RunUser && cupsArrayCount(Clients))
{
/*
* Update the root certificate...
*/
cupsdDeleteCert(0);
cupsdAddCert(0, "root", NULL);
}
/*
* Check for new data on the client sockets...
*/
for (con = (cupsd_client_t *)cupsArrayFirst(Clients);
con;
con = (cupsd_client_t *)cupsArrayNext(Clients))
{
/*
* Process pending data in the input buffer...
*/
if (con->http.used)
{
cupsdReadClient(con);
continue;
}
/*
* Check the activity and close old clients...
*/
activity = current_time - Timeout;
if (con->http.activity < activity && !con->pipe_pid)
{
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Closing client %d after %d seconds of inactivity...",
con->http.fd, Timeout);
cupsdCloseClient(con);
continue;
}
}
/*
* Update any pending multi-file documents...
*/
if ((current_time - senddoc_time) >= 10)
{
cupsdCheckJobs();
senddoc_time = current_time;
}
/*
* Log statistics at most once a minute when in debug mode...
*/
if ((current_time - report_time) >= 60 && LogLevel >= CUPSD_LOG_DEBUG)
{
size_t string_count, /* String count */
alloc_bytes, /* Allocated string bytes */
total_bytes; /* Total string bytes */
#ifdef HAVE_MALLINFO
struct mallinfo mem; /* Malloc information */
mem = mallinfo();
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-arena=%lu", mem.arena);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-used=%lu",
mem.usmblks + mem.uordblks);
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: malloc-free=%lu",
mem.fsmblks + mem.fordblks);
#endif /* HAVE_MALLINFO */
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: clients=%d",
cupsArrayCount(Clients));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: jobs=%d",
cupsArrayCount(Jobs));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: jobs-active=%d",
cupsArrayCount(ActiveJobs));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: printers=%d",
cupsArrayCount(Printers));
cupsdLogMessage(CUPSD_LOG_DEBUG, "Report: printers-implicit=%d",
cupsArrayCount(ImplicitPrinters));
string_count = _cupsStrStatistics(&alloc_bytes, &total_bytes);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Report: stringpool-string-count=" CUPS_LLFMT,
CUPS_LLCAST string_count);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Report: stringpool-alloc-bytes=" CUPS_LLFMT,
CUPS_LLCAST alloc_bytes);
cupsdLogMessage(CUPSD_LOG_DEBUG,
"Report: stringpool-total-bytes=" CUPS_LLFMT,
CUPS_LLCAST total_bytes);
report_time = current_time;
}
/*
* Handle OS-specific event notification for any events that have
* accumulated. Don't send these more than once a second...
*/
if (LastEvent && (current_time - event_time) >= 1)
{
#ifdef HAVE_NOTIFY_POST
if (LastEvent & (CUPSD_EVENT_PRINTER_ADDED |
CUPSD_EVENT_PRINTER_DELETED |
CUPSD_EVENT_PRINTER_MODIFIED))
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"notify_post(\"com.apple.printerListChange\")");
notify_post("com.apple.printerListChange");
}
if (LastEvent & CUPSD_EVENT_PRINTER_STATE_CHANGED)
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"notify_post(\"com.apple.printerHistoryChange\")");
notify_post("com.apple.printerHistoryChange");
}
if (LastEvent & (CUPSD_EVENT_JOB_STATE_CHANGED |
CUPSD_EVENT_JOB_CONFIG_CHANGED |
CUPSD_EVENT_JOB_PROGRESS))
{
cupsdLogMessage(CUPSD_LOG_DEBUG2,
"notify_post(\"com.apple.jobChange\")");
notify_post("com.apple.jobChange");
}
#endif /* HAVE_NOTIFY_POST */
/*
* Reset the accumulated events...
*/
LastEvent = CUPSD_EVENT_NONE;
event_time = current_time;
}
}
/*
* Log a message based on what happened...
*/
if (stop_scheduler)
cupsdLogMessage(CUPSD_LOG_INFO, "Scheduler shutting down normally.");
else
cupsdLogMessage(CUPSD_LOG_ERROR,
"Scheduler shutting down due to program error.");
/*
* Close all network clients...
*/
cupsdStopServer();
#ifdef HAVE_LAUNCHD
/*
* Update the launchd KeepAlive file as needed...
*/
if (Launchd)
launchd_checkout();
#endif /* HAVE_LAUNCHD */
/*
* Stop all jobs...
*/
cupsdFreeAllJobs();
#ifdef __APPLE__
/*
* Stop monitoring system event monitoring...
*/
cupsdStopSystemMonitor();
#endif /* __APPLE__ */
#ifdef HAVE_GSSAPI
/*
* Free the scheduler's Kerberos context...
*/
# ifdef __APPLE__
/*
* If the weak-linked GSSAPI/Kerberos library is not present, don't try
* to use it...
*/
if (krb5_init_context != NULL)
# endif /* __APPLE__ */
if (KerberosContext)
krb5_free_context(KerberosContext);
#endif /* HAVE_GSSAPI */
#ifdef __APPLE__
#ifdef HAVE_DLFCN_H
/*
* Unload Print Service quota enforcement library (X Server only)
*/
PSQUpdateQuotaProc = NULL;
if (PSQLibRef)
{
dlclose(PSQLibRef);
PSQLibRef = NULL;
}
#endif /* HAVE_DLFCN_H */
#endif /* __APPLE__ */
#ifdef __sgi
/*
* Remove the fake IRIX lpsched lock file, but only if the existing
* file is not a FIFO which indicates that the real IRIX lpsched is
* running...
*/
if (!stat("/var/spool/lp/FIFO", &statbuf))
if (!S_ISFIFO(statbuf.st_mode))
unlink("/var/spool/lp/SCHEDLOCK");
#endif /* __sgi */
cupsdStopSelect();
return (!stop_scheduler);
}
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
cups_array_t *array, /* Test array */
*dup_array; /* Duplicate array */
int status; /* Exit status */
char *text; /* Text from array */
char word[256]; /* Word from file */
double start, /* Start time */
end; /* End time */
cups_dir_t *dir; /* Current directory */
cups_dentry_t *dent; /* Directory entry */
char *saved[32]; /* Saved entries */
void *data; /* User data for arrays */
/*
* No errors so far...
*/
status = 0;
/*
* cupsArrayNew()
*/
fputs("cupsArrayNew: ", stdout);
data = (void *)"testarray";
array = cupsArrayNew((cups_array_func_t)strcmp, data);
if (array)
puts("PASS");
else
{
puts("FAIL (returned NULL, expected pointer)");
status ++;
}
/*
* cupsArrayUserData()
*/
fputs("cupsArrayUserData: ", stdout);
if (cupsArrayUserData(array) == data)
puts("PASS");
else
{
printf("FAIL (returned %p instead of %p!)\n", cupsArrayUserData(array),
data);
status ++;
}
/*
* cupsArrayAdd()
*/
fputs("cupsArrayAdd: ", stdout);
if (!cupsArrayAdd(array, strdup("One Fish")))
{
puts("FAIL (\"One Fish\")");
status ++;
}
else
{
if (!cupsArrayAdd(array, strdup("Two Fish")))
{
puts("FAIL (\"Two Fish\")");
status ++;
}
else
{
if (!cupsArrayAdd(array, strdup("Red Fish")))
{
puts("FAIL (\"Red Fish\")");
status ++;
}
else
{
if (!cupsArrayAdd(array, strdup("Blue Fish")))
{
puts("FAIL (\"Blue Fish\")");
status ++;
}
else
puts("PASS");
}
}
}
/*
* cupsArrayCount()
*/
fputs("cupsArrayCount: ", stdout);
if (cupsArrayCount(array) == 4)
puts("PASS");
else
{
printf("FAIL (returned %d, expected 4)\n", cupsArrayCount(array));
status ++;
}
/*
* cupsArrayFirst()
*/
fputs("cupsArrayFirst: ", stdout);
if ((text = (char *)cupsArrayFirst(array)) != NULL &&
!strcmp(text, "Blue Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"Blue Fish\")\n", text);
status ++;
}
/*
* cupsArrayNext()
*/
fputs("cupsArrayNext: ", stdout);
if ((text = (char *)cupsArrayNext(array)) != NULL &&
!strcmp(text, "One Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
status ++;
}
/*
* cupsArrayLast()
*/
fputs("cupsArrayLast: ", stdout);
if ((text = (char *)cupsArrayLast(array)) != NULL &&
!strcmp(text, "Two Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"Two Fish\")\n", text);
status ++;
}
/*
* cupsArrayPrev()
*/
fputs("cupsArrayPrev: ", stdout);
if ((text = (char *)cupsArrayPrev(array)) != NULL &&
!strcmp(text, "Red Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"Red Fish\")\n", text);
status ++;
}
/*
* cupsArrayFind()
*/
fputs("cupsArrayFind: ", stdout);
if ((text = (char *)cupsArrayFind(array, (void *)"One Fish")) != NULL &&
!strcmp(text, "One Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
status ++;
}
/*
* cupsArrayCurrent()
*/
fputs("cupsArrayCurrent: ", stdout);
if ((text = (char *)cupsArrayCurrent(array)) != NULL &&
!strcmp(text, "One Fish"))
puts("PASS");
else
{
printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text);
status ++;
}
/*
* cupsArrayDup()
*/
fputs("cupsArrayDup: ", stdout);
if ((dup_array = cupsArrayDup(array)) != NULL &&
cupsArrayCount(dup_array) == 4)
puts("PASS");
else
{
printf("FAIL (returned %p with %d elements, expected pointer with 4 elements)\n",
dup_array, cupsArrayCount(dup_array));
status ++;
}
/*
* cupsArrayRemove()
*/
fputs("cupsArrayRemove: ", stdout);
if (cupsArrayRemove(array, (void *)"One Fish") &&
cupsArrayCount(array) == 3)
puts("PASS");
else
{
printf("FAIL (returned 0 with %d elements, expected 1 with 4 elements)\n",
cupsArrayCount(array));
status ++;
}
/*
* cupsArrayClear()
*/
fputs("cupsArrayClear: ", stdout);
cupsArrayClear(array);
if (cupsArrayCount(array) == 0)
puts("PASS");
else
{
printf("FAIL (%d elements, expected 0 elements)\n",
cupsArrayCount(array));
status ++;
}
/*
* Now load this source file and grab all of the unique words...
*/
fputs("Load unique words: ", stdout);
fflush(stdout);
start = get_seconds();
if ((dir = cupsDirOpen(".")) == NULL)
{
puts("FAIL (cupsDirOpen failed)");
status ++;
}
else
{
while ((dent = cupsDirRead(dir)) != NULL)
{
i = strlen(dent->filename) - 2;
if (i > 0 && dent->filename[i] == '.' &&
(dent->filename[i + 1] == 'c' ||
dent->filename[i + 1] == 'h'))
load_words(dent->filename, array);
}
cupsDirClose(dir);
end = get_seconds();
printf("%d words in %.3f seconds (%.0f words/sec), ", cupsArrayCount(array),
end - start, cupsArrayCount(array) / (end - start));
fflush(stdout);
for (text = (char *)cupsArrayFirst(array); text;)
{
/*
* Copy this word to the word buffer (safe because we strdup'd from
* the same buffer in the first place... :)
*/
strlcpy(word, text, sizeof(word));
/*
* Grab the next word and compare...
*/
if ((text = (char *)cupsArrayNext(array)) == NULL)
break;
if (strcmp(word, text) >= 0)
break;
}
if (text)
{
printf("FAIL (\"%s\" >= \"%s\"!)\n", word, text);
status ++;
}
else
puts("PASS");
}
/*
* Test deleting with iteration...
*/
fputs("Delete While Iterating: ", stdout);
text = (char *)cupsArrayFirst(array);
cupsArrayRemove(array, text);
free(text);
text = (char *)cupsArrayNext(array);
if (!text)
{
puts("FAIL (cupsArrayNext returned NULL!)");
status ++;
}
else
puts("PASS");
/*
* Test save/restore...
*/
fputs("cupsArraySave: ", stdout);
for (i = 0, text = (char *)cupsArrayFirst(array);
i < 32;
i ++, text = (char *)cupsArrayNext(array))
{
saved[i] = text;
if (!cupsArraySave(array))
break;
}
if (i < 32)
printf("FAIL (depth = %d)\n", i);
else
puts("PASS");
fputs("cupsArrayRestore: ", stdout);
while (i > 0)
{
i --;
text = cupsArrayRestore(array);
if (text != saved[i])
break;
}
if (i)
printf("FAIL (depth = %d)\n", i);
else
puts("PASS");
/*
* Delete the arrays...
*/
cupsArrayDelete(array);
cupsArrayDelete(dup_array);
/*
* Test the array with string functions...
*/
fputs("_cupsArrayNewStrings(\" \\t\\nfoo bar\\tboo\\nfar\", ' '): ", stdout);
array = _cupsArrayNewStrings(" \t\nfoo bar\tboo\nfar", ' ');
if (!array)
{
status = 1;
puts("FAIL (unable to create array)");
}
else if (cupsArrayCount(array) != 4)
{
status = 1;
printf("FAIL (got %d elements, expected 4)\n", cupsArrayCount(array));
}
else if (strcmp(text = (char *)cupsArrayFirst(array), "bar"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"bar\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "boo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"boo\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "far"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"far\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "foo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"foo\")\n", text);
}
else
puts("PASS");
fputs("_cupsArrayAddStrings(array, \"foo2,bar2\", ','): ", stdout);
_cupsArrayAddStrings(array, "foo2,bar2", ',');
if (cupsArrayCount(array) != 6)
{
status = 1;
printf("FAIL (got %d elements, expected 6)\n", cupsArrayCount(array));
}
else if (strcmp(text = (char *)cupsArrayFirst(array), "bar"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"bar\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "bar2"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"bar2\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "boo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"boo\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "far"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"far\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "foo"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"foo\")\n", text);
}
else if (strcmp(text = (char *)cupsArrayNext(array), "foo2"))
{
status = 1;
printf("FAIL (first element \"%s\", expected \"foo2\")\n", text);
}
else
puts("PASS");
cupsArrayDelete(array);
/*
* Summarize the results and return...
*/
if (!status)
puts("\nALL TESTS PASSED!");
else
printf("\n%d TEST(S) FAILED!\n", status);
return (status);
}
int /* O - Exit code */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
int request_id; /* Request ID */
int timeout; /* Timeout in seconds */
const char *server_bin; /* CUPS_SERVERBIN environment variable */
char filename[1024]; /* Backend directory filename */
cups_dir_t *dir; /* Directory pointer */
cups_dentry_t *dent; /* Directory entry */
double current_time, /* Current time */
end_time; /* Ending time */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
cups_array_t *requested, /* requested-attributes values */
*exclude, /* exclude-schemes values */
*include; /* include-schemes values */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
setbuf(stderr, NULL);
/*
* Check the command-line...
*/
if (argc != 6)
{
fputs("Usage: cups-deviced request-id limit timeout user-id options\n", stderr);
return (1);
}
request_id = atoi(argv[1]);
if (request_id < 1)
{
fprintf(stderr, "ERROR: [cups-deviced] Bad request ID %d!\n", request_id);
return (1);
}
device_limit = atoi(argv[2]);
if (device_limit < 0)
{
fprintf(stderr, "ERROR: [cups-deviced] Bad limit %d!\n", device_limit);
return (1);
}
timeout = atoi(argv[3]);
if (timeout < 1)
{
fprintf(stderr, "ERROR: [cups-deviced] Bad timeout %d!\n", timeout);
return (1);
}
normal_user = atoi(argv[4]);
if (normal_user <= 0)
{
fprintf(stderr, "ERROR: [cups-deviced] Bad user %d!\n", normal_user);
return (1);
}
num_options = cupsParseOptions(argv[5], 0, &options);
requested = cupsdCreateStringsArray(cupsGetOption("requested-attributes",
num_options, options));
exclude = cupsdCreateStringsArray(cupsGetOption("exclude-schemes",
num_options, options));
include = cupsdCreateStringsArray(cupsGetOption("include-schemes",
num_options, options));
if (!requested || cupsArrayFind(requested, "all") != NULL)
{
send_class = send_info = send_make_and_model = send_uri = send_id =
send_location = 1;
}
else
{
send_class = cupsArrayFind(requested, "device-class") != NULL;
send_info = cupsArrayFind(requested, "device-info") != NULL;
send_make_and_model = cupsArrayFind(requested, "device-make-and-model") != NULL;
send_uri = cupsArrayFind(requested, "device-uri") != NULL;
send_id = cupsArrayFind(requested, "device-id") != NULL;
send_location = cupsArrayFind(requested, "device-location") != NULL;
}
/*
* Listen to child signals...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGCHLD, sigchld_handler);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGCHLD);
action.sa_handler = sigchld_handler;
sigaction(SIGCHLD, &action, NULL);
#else
signal(SIGCLD, sigchld_handler); /* No, SIGCLD isn't a typo... */
#endif /* HAVE_SIGSET */
/*
* Try opening the backend directory...
*/
if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
server_bin = CUPS_SERVERBIN;
snprintf(filename, sizeof(filename), "%s/backend", server_bin);
if ((dir = cupsDirOpen(filename)) == NULL)
{
fprintf(stderr, "ERROR: [cups-deviced] Unable to open backend directory "
"\"%s\": %s", filename, strerror(errno));
return (1);
}
/*
* Setup the devices array...
*/
devices = cupsArrayNew((cups_array_func_t)compare_devices, NULL);
/*
* Loop through all of the device backends...
*/
while ((dent = cupsDirRead(dir)) != NULL)
{
/*
* Skip entries that are not executable files...
*/
if (!S_ISREG(dent->fileinfo.st_mode) ||
!isalnum(dent->filename[0] & 255) ||
(dent->fileinfo.st_mode & (S_IRUSR | S_IXUSR)) != (S_IRUSR | S_IXUSR))
continue;
/*
* Skip excluded or not included backends...
*/
if (cupsArrayFind(exclude, dent->filename) ||
(include && !cupsArrayFind(include, dent->filename)))
continue;
/*
* Backends without permissions for normal users run as root,
* all others run as the unprivileged user...
*/
start_backend(dent->filename,
!(dent->fileinfo.st_mode & (S_IRWXG | S_IRWXO)));
}
cupsDirClose(dir);
/*
* Collect devices...
*/
if (getenv("SOFTWARE"))
puts("Content-Type: application/ipp\n");
cupsdSendIPPHeader(IPP_OK, request_id);
cupsdSendIPPGroup(IPP_TAG_OPERATION);
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language", "en-US");
end_time = get_current_time() + timeout;
while (active_backends > 0 && (current_time = get_current_time()) < end_time)
{
/*
* Collect the output from the backends...
*/
timeout = (int)(1000 * (end_time - current_time));
if (poll(backend_fds, num_backends, timeout) > 0)
{
for (i = 0; i < num_backends; i ++)
if (backend_fds[i].revents && backends[i].pipe)
{
cups_file_t *bpipe = backends[i].pipe;
/* Copy of pipe for backend... */
do
{
if (get_device(backends + i))
{
backend_fds[i].fd = 0;
backend_fds[i].events = 0;
break;
}
}
while (bpipe->ptr &&
memchr(bpipe->ptr, '\n', bpipe->end - bpipe->ptr));
}
}
/*
* Get exit status from children...
*/
if (dead_children)
process_children();
}
cupsdSendIPPTrailer();
/*
* Terminate any remaining backends and exit...
*/
if (active_backends > 0)
{
for (i = 0; i < num_backends; i ++)
if (backends[i].pid)
kill(backends[i].pid, SIGTERM);
}
return (0);
}
int /* O - 1 if successful, 0 on error */
serverLoadConfiguration(
const char *directory) /* I - Configuration directory */
{
cups_dir_t *dir; /* Directory pointer */
cups_dentry_t *dent; /* Directory entry */
char filename[1024], /* Configuration file/directory */
iconname[1024], /* Icon file */
resource[1024], /* Resource path */
*ptr; /* Pointer into filename */
server_printer_t *printer; /* Printer */
ipp_t *attrs; /* Printer attributes */
char *authtype, /* AuthType value, if any */
*command, /* Command value, if any */
*device_uri, /* DeviceURI value, if any */
*make, /* Make value, if any */
*model, /* Model value, if any */
*proxy_user; /* ProxyUser value, if any */
/*
* First read the system configuration file, if any...
*/
snprintf(filename, sizeof(filename), "%s/system.conf", directory);
if (!load_system(filename))
return (0);
if (!serverFinalizeConfiguration())
return (0);
/*
* Then see if there are any print queues...
*/
snprintf(filename, sizeof(filename), "%s/print", directory);
if ((dir = cupsDirOpen(filename)) != NULL)
{
serverLog(SERVER_LOGLEVEL_INFO, "Loading printers from \"%s\".", filename);
while ((dent = cupsDirRead(dir)) != NULL)
{
if ((ptr = dent->filename + strlen(dent->filename) - 5) >= dent->filename && !strcmp(ptr, ".conf"))
{
/*
* Load the conf file, with any associated icon image.
*/
serverLog(SERVER_LOGLEVEL_INFO, "Loading printer from \"%s\".", dent->filename);
snprintf(filename, sizeof(filename), "%s/print/%s", directory, dent->filename);
*ptr = '\0';
snprintf(iconname, sizeof(iconname), "%s/print/%s.png", directory, dent->filename);
authtype = command = device_uri = make = model = proxy_user = NULL;
if ((attrs = serverLoadAttributes(filename, &authtype, &command, &device_uri, &make, &model, &proxy_user)) != NULL)
{
snprintf(resource, sizeof(resource), "/ipp/print/%s", dent->filename);
if ((printer = serverCreatePrinter(resource, dent->filename, NULL, make, model, access(iconname, R_OK) ? NULL : iconname, NULL, 0, 0, 0, 0, attrs, command, device_uri, proxy_user)) == NULL)
continue;
if (!Printers)
Printers = cupsArrayNew((cups_array_func_t)compare_printers, NULL);
cupsArrayAdd(Printers, printer);
}
}
else if (!strstr(dent->filename, ".png"))
serverLog(SERVER_LOGLEVEL_INFO, "Skipping \"%s\".", dent->filename);
}
cupsDirClose(dir);
}
/*
* Finally, see if there are any 3D print queues...
*/
snprintf(filename, sizeof(filename), "%s/print3d", directory);
if ((dir = cupsDirOpen(filename)) != NULL)
{
serverLog(SERVER_LOGLEVEL_INFO, "Loading 3D printers from \"%s\".", filename);
while ((dent = cupsDirRead(dir)) != NULL)
{
if ((ptr = dent->filename + strlen(dent->filename) - 5) >= dent->filename && !strcmp(ptr, ".conf"))
{
/*
* Load the conf file, with any associated icon image.
*/
serverLog(SERVER_LOGLEVEL_INFO, "Loading 3D printer from \"%s\".", dent->filename);
snprintf(filename, sizeof(filename), "%s/print3d/%s", directory, dent->filename);
*ptr = '\0';
snprintf(iconname, sizeof(iconname), "%s/print3d/%s.png", directory, dent->filename);
authtype = command = device_uri = make = model = proxy_user = NULL;
if ((attrs = serverLoadAttributes(filename, &authtype, &command, &device_uri, &make, &model, &proxy_user)) != NULL)
{
snprintf(resource, sizeof(resource), "/ipp/print3d/%s", dent->filename);
if ((printer = serverCreatePrinter(resource, dent->filename, NULL, make, model, access(iconname, R_OK) ? NULL : iconname, NULL, 0, 0, 0, 0, attrs, command, device_uri, proxy_user)) == NULL)
continue;
if (!Printers)
Printers = cupsArrayNew((cups_array_func_t)compare_printers, NULL);
cupsArrayAdd(Printers, printer);
}
}
else if (!strstr(dent->filename, ".png"))
serverLog(SERVER_LOGLEVEL_INFO, "Skipping \"%s\".", dent->filename);
}
cupsDirClose(dir);
}
return (1);
}
mime_t * /* O - Updated MIME database */
mimeMerge(mime_t *mime, /* I - MIME database to add to */
const char *pathname, /* I - Directory to load */
const char *filterpath) /* I - Directory to load */
{
cups_dir_t *dir; /* Directory */
cups_dentry_t *dent; /* Directory entry */
char filename[1024]; /* Full filename of types/converts file */
cups_array_t *filtercache; /* Filter cache */
/*
* First open the directory specified by pathname... Return NULL if nothing
* was read or if the pathname is NULL...
*/
if (!pathname)
return (NULL);
if ((dir = cupsDirOpen(pathname)) == NULL)
return (NULL);
/*
* If "mime" is NULL, make a new, blank database...
*/
if (!mime)
mime = mimeNew();
if (!mime)
{
cupsDirClose(dir);
return (NULL);
}
/*
* Read all the .types files...
*/
while ((dent = cupsDirRead(dir)) != NULL)
{
if (strlen(dent->filename) > 6 &&
!strcmp(dent->filename + strlen(dent->filename) - 6, ".types"))
{
/*
* Load a mime.types file...
*/
snprintf(filename, sizeof(filename), "%s/%s", pathname, dent->filename);
load_types(mime, filename);
}
}
cupsDirRewind(dir);
/*
* Read all the .convs files...
*/
filtercache = cupsArrayNew((cups_array_func_t)compare_fcache, NULL);
while ((dent = cupsDirRead(dir)) != NULL)
{
if (strlen(dent->filename) > 6 &&
!strcmp(dent->filename + strlen(dent->filename) - 6, ".convs"))
{
/*
* Load a mime.convs file...
*/
snprintf(filename, sizeof(filename), "%s/%s", pathname, dent->filename);
load_convs(mime, filename, filterpath, filtercache);
}
}
delete_fcache(filtercache);
cupsDirClose(dir);
return (mime);
}
static void
type_dir(mime_t *mime, /* I - MIME database */
const char *dirname) /* I - Directory */
{
cups_dir_t *dir; /* Directory */
cups_dentry_t *dent; /* Directory entry */
char filename[1024]; /* File to type */
mime_type_t *filetype; /* File type */
int compression; /* Compressed file? */
mime_type_t *pstype; /* application/vnd.cups-postscript */
cups_array_t *filters; /* Filters to pstype */
mime_filter_t *filter; /* Current filter */
int cost; /* Filter cost */
dir = cupsDirOpen(dirname);
if (!dir)
return;
pstype = mimeType(mime, "application", "vnd.cups-postscript");
while ((dent = cupsDirRead(dir)) != NULL)
{
if (dent->filename[0] == '.')
continue;
snprintf(filename, sizeof(filename), "%s/%s", dirname, dent->filename);
if (S_ISDIR(dent->fileinfo.st_mode))
type_dir(mime, filename);
if (!S_ISREG(dent->fileinfo.st_mode))
continue;
filetype = mimeFileType(mime, filename, NULL, &compression);
if (filetype)
{
printf("%s: %s/%s%s\n", filename, filetype->super, filetype->type,
compression ? " (compressed)" : "");
filters = mimeFilter(mime, filetype, pstype, &cost);
if (!filters)
puts(" No filters to convert application/vnd.cups-postscript.");
else
{
printf(" Filter cost = %d\n", cost);
filter = (mime_filter_t *)cupsArrayFirst(filters);
printf(" %s", filter->filter);
for (filter = (mime_filter_t *)cupsArrayNext(filters);
filter;
filter = (mime_filter_t *)cupsArrayNext(filters))
printf(" | %s", filter->filter);
putchar('\n');
cupsArrayDelete(filters);
}
}
else
printf("%s: unknown%s\n", filename, compression ? " (compressed)" : "");
}
cupsDirClose(dir);
}
int /* O - Exit code */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
const char *server_bin; /* CUPS_SERVERBIN environment variable */
char backends[1024]; /* Location of backends */
int request_id; /* Request ID */
int count; /* Number of devices from backend */
int compat; /* Compatibility device? */
char *backend_argv[2]; /* Arguments for backend */
cups_file_t *fp; /* Pipe to device backend */
int pid; /* Process ID of backend */
cups_dir_t *dir; /* Directory pointer */
cups_dentry_t *dent; /* Directory entry */
char filename[1024], /* Name of backend */
line[2048], /* Line from backend */
dclass[64], /* Device class */
uri[1024], /* Device URI */
info[128], /* Device info */
make_model[256], /* Make and model */
device_id[1024]; /* 1284 device ID */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
const char *requested; /* requested-attributes option */
int send_class, /* Send device-class attribute? */
send_info, /* Send device-info attribute? */
send_make_and_model, /* Send device-make-and-model attribute? */
send_uri, /* Send device-uri attribute? */
send_id; /* Send device-id attribute? */
dev_info_t *dev; /* Current device */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
setbuf(stderr, NULL);
/*
* Check the command-line...
*/
if (argc > 1)
request_id = atoi(argv[1]);
else
request_id = 1;
if (argc != 5)
{
fputs("Usage: cups-deviced request-id limit user-id options\n", stderr);
return (1);
}
if (request_id < 1)
{
fprintf(stderr, "cups-deviced: Bad request ID %d!\n", request_id);
return (1);
}
normal_user = atoi(argv[3]);
if (normal_user <= 0)
{
fprintf(stderr, "cups-deviced: Bad user %d!\n", normal_user);
return (1);
}
num_options = cupsParseOptions(argv[4], 0, &options);
requested = cupsGetOption("requested-attributes", num_options, options);
if (!requested || strstr(requested, "all"))
{
send_class = 1;
send_info = 1;
send_make_and_model = 1;
send_uri = 1;
send_id = 1;
}
else
{
send_class = strstr(requested, "device-class") != NULL;
send_info = strstr(requested, "device-info") != NULL;
send_make_and_model = strstr(requested, "device-make-and-model") != NULL;
send_uri = strstr(requested, "device-uri") != NULL;
send_id = strstr(requested, "device-id") != NULL;
}
/*
* Try opening the backend directory...
*/
if ((server_bin = getenv("CUPS_SERVERBIN")) == NULL)
server_bin = CUPS_SERVERBIN;
snprintf(backends, sizeof(backends), "%s/backend", server_bin);
if ((dir = cupsDirOpen(backends)) == NULL)
{
fprintf(stderr, "ERROR: [cups-deviced] Unable to open backend directory "
"\"%s\": %s", backends, strerror(errno));
return (1);
}
/*
* Setup the devices array...
*/
devs = cupsArrayNew((cups_array_func_t)compare_devs, NULL);
/*
* Loop through all of the device backends...
*/
while ((dent = cupsDirRead(dir)) != NULL)
{
/*
* Skip entries that are not executable files...
*/
if (!S_ISREG(dent->fileinfo.st_mode) ||
(dent->fileinfo.st_mode & (S_IRUSR | S_IXUSR)) != (S_IRUSR | S_IXUSR))
continue;
/*
* Change effective users depending on the backend permissions...
*/
snprintf(filename, sizeof(filename), "%s/%s", backends, dent->filename);
/*
* Backends without permissions for normal users run as root,
* all others run as the unprivileged user...
*/
backend_argv[0] = dent->filename;
backend_argv[1] = NULL;
fp = cupsdPipeCommand(&pid, filename, backend_argv,
(dent->fileinfo.st_mode & (S_IRWXG | S_IRWXO))
? normal_user : 0);
/*
* Collect the output from the backend...
*/
if (fp)
{
/*
* Set an alarm for the first read from the backend; this avoids
* problems when a backend is hung getting device information.
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGALRM, sigalrm_handler);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, SIGALRM);
action.sa_handler = sigalrm_handler;
sigaction(SIGALRM, &action, NULL);
#else
signal(SIGALRM, sigalrm_handler);
#endif /* HAVE_SIGSET */
alarm_tripped = 0;
count = 0;
compat = !strcmp(dent->filename, "smb");
alarm(30);
while (cupsFileGets(fp, line, sizeof(line)))
{
/*
* Reset the alarm clock...
*/
alarm(30);
/*
* Each line is of the form:
*
* class URI "make model" "name" ["1284 device ID"]
*/
device_id[0] = '\0';
if (!strncasecmp(line, "Usage", 5))
compat = 1;
else if (sscanf(line,
"%63s%1023s%*[ \t]\"%255[^\"]\"%*[ \t]\"%127[^\"]\""
"%*[ \t]\"%1023[^\"]",
dclass, uri, make_model, info, device_id) < 4)
{
/*
* Bad format; strip trailing newline and write an error message.
*/
if (line[strlen(line) - 1] == '\n')
line[strlen(line) - 1] = '\0';
fprintf(stderr, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n",
dent->filename, line);
compat = 1;
break;
}
else
{
/*
* Add the device to the array of available devices...
*/
dev = add_dev(dclass, make_model, info, uri, device_id);
if (!dev)
{
cupsDirClose(dir);
cupsFileClose(fp);
kill(pid, SIGTERM);
return (1);
}
fprintf(stderr, "DEBUG: [cups-deviced] Added device \"%s\"...\n",
uri);
count ++;
}
}
/*
* Turn the alarm clock off and close the pipe to the command...
*/
alarm(0);
if (alarm_tripped)
fprintf(stderr, "WARNING: [cups-deviced] Backend \"%s\" did not "
"respond within 30 seconds!\n", dent->filename);
cupsFileClose(fp);
kill(pid, SIGTERM);
/*
* Hack for backends that don't support the CUPS 1.1 calling convention:
* add a network device with the method == backend name.
*/
if (count == 0 && compat)
{
snprintf(line, sizeof(line), "Unknown Network Device (%s)",
dent->filename);
dev = add_dev("network", line, "Unknown", dent->filename, "");
if (!dev)
{
cupsDirClose(dir);
return (1);
}
fprintf(stderr, "DEBUG: [cups-deviced] Compatibility device "
"\"%s\"...\n", dent->filename);
}
}
else
fprintf(stderr, "WARNING: [cups-deviced] Unable to execute \"%s\" "
"backend: %s\n", dent->filename, strerror(errno));
}
cupsDirClose(dir);
/*
* Output the list of devices...
*/
puts("Content-Type: application/ipp\n");
cupsdSendIPPHeader(IPP_OK, request_id);
cupsdSendIPPGroup(IPP_TAG_OPERATION);
cupsdSendIPPString(IPP_TAG_CHARSET, "attributes-charset", "utf-8");
cupsdSendIPPString(IPP_TAG_LANGUAGE, "attributes-natural-language", "en-US");
if ((count = atoi(argv[2])) <= 0)
count = cupsArrayCount(devs);
if (count > cupsArrayCount(devs))
count = cupsArrayCount(devs);
for (dev = (dev_info_t *)cupsArrayFirst(devs);
count > 0;
count --, dev = (dev_info_t *)cupsArrayNext(devs))
{
/*
* Add strings to attributes...
*/
cupsdSendIPPGroup(IPP_TAG_PRINTER);
if (send_class)
cupsdSendIPPString(IPP_TAG_KEYWORD, "device-class", dev->device_class);
if (send_info)
cupsdSendIPPString(IPP_TAG_TEXT, "device-info", dev->device_info);
if (send_make_and_model)
cupsdSendIPPString(IPP_TAG_TEXT, "device-make-and-model",
dev->device_make_and_model);
if (send_uri)
cupsdSendIPPString(IPP_TAG_URI, "device-uri", dev->device_uri);
if (send_id)
cupsdSendIPPString(IPP_TAG_TEXT, "device-id", dev->device_id);
}
cupsdSendIPPTrailer();
/*
* Free the devices array and return...
*/
for (dev = (dev_info_t *)cupsArrayFirst(devs);
dev;
dev = (dev_info_t *)cupsArrayNext(devs))
free(dev);
cupsArrayDelete(devs);
return (0);
}