static int /* O - Number of lines */ count_lines(cups_file_t *fp) /* I - File to read from */ { int count; /* Number of lines */ char line[1024]; /* Line buffer */ for (count = 0; cupsFileGets(fp, line, sizeof(line)); count ++); return (count); }
static int /* O - 1 for YES or AUTOMATIC, 0 for NO */ get_hostconfig(const char *name) /* I - Name of service */ { cups_file_t *fp; /* Hostconfig file */ char line[1024], /* Line from file */ *ptr; /* Pointer to value */ int state = 1; /* State of service */ /* * Try opening the /etc/hostconfig file; if we can't open it, assume that * the service is enabled/auto. */ if ((fp = cupsFileOpen("/etc/hostconfig", "r")) != NULL) { /* * Read lines from the file until we find the service... */ while (cupsFileGets(fp, line, sizeof(line))) { if (line[0] == '#' || (ptr = strchr(line, '=')) == NULL) continue; *ptr++ = '\0'; if (!_cups_strcasecmp(line, name)) { /* * Found the service, see if it is set to "-NO-"... */ if (!_cups_strncasecmp(ptr, "-NO-", 4)) state = 0; break; } } cupsFileClose(fp); } return (state); }
static int /* O - 1 on success, 0 on failure */ cups_read_strings(cups_file_t *strings, /* I - .strings file */ char *buffer, /* I - Line buffer */ size_t bufsize, /* I - Size of line buffer */ char **id, /* O - Pointer to ID string */ char **str) /* O - Pointer to translation string */ { char *bufptr; /* Pointer into buffer */ while (cupsFileGets(strings, buffer, bufsize)) { if (buffer[0] != '\"') continue; *id = buffer + 1; bufptr = cups_scan_strings(buffer); if (*bufptr != '\"') continue; *bufptr++ = '\0'; while (*bufptr && *bufptr != '\"') bufptr ++; if (!*bufptr) continue; *str = bufptr + 1; bufptr = cups_scan_strings(bufptr); if (*bufptr != '\"') continue; *bufptr = '\0'; return (1); } return (0); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { help_index_t *hi, /* Help index */ *si; /* Search index */ help_node_t *n; /* Current help node */ int i; /* Looping var */ const char *query; /* Search query */ const char *cache_dir; /* CUPS_CACHEDIR environment variable */ const char *docroot; /* CUPS_DOCROOT environment variable */ const char *helpfile, /* Current help file */ *helptitle = NULL; /* Current help title */ const char *topic; /* Current topic */ char topic_data[1024]; /* Topic form data */ const char *section; /* Current section */ char filename[1024], /* Filename */ directory[1024]; /* Directory */ cups_file_t *fp; /* Help file */ char line[1024]; /* Line from file */ int printable; /* Show printable version? */ /* * Get any form variables... */ cgiInitialize(); printable = cgiGetVariable("PRINTABLE") != NULL; /* * Set the web interface section... */ cgiSetVariable("SECTION", "help"); cgiSetVariable("REFRESH_PAGE", ""); /* * Load the help index... */ if ((cache_dir = getenv("CUPS_CACHEDIR")) == NULL) cache_dir = CUPS_CACHEDIR; snprintf(filename, sizeof(filename), "%s/help.index", cache_dir); if ((docroot = getenv("CUPS_DOCROOT")) == NULL) docroot = CUPS_DOCROOT; snprintf(directory, sizeof(directory), "%s/help", docroot); fprintf(stderr, "DEBUG: helpLoadIndex(filename=\"%s\", directory=\"%s\")\n", filename, directory); hi = helpLoadIndex(filename, directory); if (!hi) { perror(filename); cgiStartHTML(cgiText(_("Online Help"))); cgiSetVariable("ERROR", cgiText(_("Unable to load help index."))); cgiCopyTemplateLang("error.tmpl"); cgiEndHTML(); return (1); } fprintf(stderr, "DEBUG: %d nodes in help index...\n", cupsArrayCount(hi->nodes)); /* * See if we are viewing a file... */ for (i = 0; i < argc; i ++) fprintf(stderr, "DEBUG: argv[%d]=\"%s\"\n", i, argv[i]); if ((helpfile = getenv("PATH_INFO")) != NULL) { helpfile ++; if (!*helpfile) helpfile = NULL; } if (helpfile) { /* * Verify that the help file exists and is part of the index... */ snprintf(filename, sizeof(filename), "%s/help/%s", docroot, helpfile); fprintf(stderr, "DEBUG: helpfile=\"%s\", filename=\"%s\"\n", helpfile, filename); if (access(filename, R_OK)) { perror(filename); cgiStartHTML(cgiText(_("Online Help"))); cgiSetVariable("ERROR", cgiText(_("Unable to access help file."))); cgiCopyTemplateLang("error.tmpl"); cgiEndHTML(); return (1); } if ((n = helpFindNode(hi, helpfile, NULL)) == NULL) { cgiStartHTML(cgiText(_("Online Help"))); cgiSetVariable("ERROR", cgiText(_("Help file not in index."))); cgiCopyTemplateLang("error.tmpl"); cgiEndHTML(); return (1); } /* * Save the page title and help file... */ helptitle = n->text; topic = n->section; /* * Send a standard page header... */ if (printable) puts("Content-Type: text/html;charset=utf-8\n"); else cgiStartHTML(n->text); } else { /* * Send a standard page header... */ cgiStartHTML(cgiText(_("Online Help"))); topic = cgiGetVariable("TOPIC"); } /* * Do a search as needed... */ if (cgiGetVariable("CLEAR")) cgiSetVariable("QUERY", ""); query = cgiGetVariable("QUERY"); si = helpSearchIndex(hi, query, topic, helpfile); cgiClearVariables(); if (query) cgiSetVariable("QUERY", query); if (topic) cgiSetVariable("TOPIC", topic); if (helpfile) cgiSetVariable("HELPFILE", helpfile); if (helptitle) cgiSetVariable("HELPTITLE", helptitle); fprintf(stderr, "DEBUG: query=\"%s\", topic=\"%s\"\n", query ? query : "(null)", topic ? topic : "(null)"); if (si) { help_node_t *nn; /* Parent node */ fprintf(stderr, "DEBUG: si=%p, si->sorted=%p, cupsArrayCount(si->sorted)=%d\n", si, si->sorted, cupsArrayCount(si->sorted)); for (i = 0, n = (help_node_t *)cupsArrayFirst(si->sorted); n; i ++, n = (help_node_t *)cupsArrayNext(si->sorted)) { if (helpfile && n->anchor) snprintf(line, sizeof(line), "#%s", n->anchor); else if (n->anchor) snprintf(line, sizeof(line), "/help/%s?QUERY=%s#%s", n->filename, query ? query : "", n->anchor); else snprintf(line, sizeof(line), "/help/%s?QUERY=%s", n->filename, query ? query : ""); cgiSetArray("QTEXT", i, n->text); cgiSetArray("QLINK", i, line); if (!helpfile && n->anchor) { nn = helpFindNode(hi, n->filename, NULL); snprintf(line, sizeof(line), "/help/%s?QUERY=%s", nn->filename, query ? query : ""); cgiSetArray("QPTEXT", i, nn->text); cgiSetArray("QPLINK", i, line); } else { cgiSetArray("QPTEXT", i, ""); cgiSetArray("QPLINK", i, ""); } fprintf(stderr, "DEBUG: [%d] = \"%s\" @ \"%s\"\n", i, n->text, line); } helpDeleteIndex(si); } /* * OK, now list the bookmarks within the index... */ for (i = 0, section = NULL, n = (help_node_t *)cupsArrayFirst(hi->sorted); n; n = (help_node_t *)cupsArrayNext(hi->sorted)) { if (n->anchor) continue; /* * Add a section link as needed... */ if (n->section && (!section || strcmp(n->section, section))) { /* * Add a link for this node... */ snprintf(line, sizeof(line), "/help/?TOPIC=%s&QUERY=%s", cgiFormEncode(topic_data, n->section, sizeof(topic_data)), query ? query : ""); cgiSetArray("BMLINK", i, line); cgiSetArray("BMTEXT", i, n->section); cgiSetArray("BMINDENT", i, "0"); i ++; section = n->section; } if (!topic || strcmp(n->section, topic)) continue; /* * Add a link for this node... */ snprintf(line, sizeof(line), "/help/%s?TOPIC=%s&QUERY=%s", n->filename, cgiFormEncode(topic_data, n->section, sizeof(topic_data)), query ? query : ""); cgiSetArray("BMLINK", i, line); cgiSetArray("BMTEXT", i, n->text); cgiSetArray("BMINDENT", i, "1"); i ++; if (helpfile && !strcmp(helpfile, n->filename)) { help_node_t *nn; /* Pointer to sub-node */ cupsArraySave(hi->sorted); for (nn = (help_node_t *)cupsArrayFirst(hi->sorted); nn; nn = (help_node_t *)cupsArrayNext(hi->sorted)) if (nn->anchor && !strcmp(helpfile, nn->filename)) { /* * Add a link for this node... */ snprintf(line, sizeof(line), "#%s", nn->anchor); cgiSetArray("BMLINK", i, line); cgiSetArray("BMTEXT", i, nn->text); cgiSetArray("BMINDENT", i, "2"); i ++; } cupsArrayRestore(hi->sorted); } } /* * Show the search and bookmark content... */ if (!helpfile || !printable) cgiCopyTemplateLang("help-header.tmpl"); else cgiCopyTemplateLang("help-printable.tmpl"); /* * If we are viewing a file, copy it in now... */ if (helpfile) { if ((fp = cupsFileOpen(filename, "r")) != NULL) { int inbody; /* Are we inside the body? */ inbody = 0; while (cupsFileGets(fp, line, sizeof(line))) { if (inbody) { if (!_cups_strncasecmp(line, "</BODY>", 7)) break; printf("%s\n", line); } else if (!_cups_strncasecmp(line, "<BODY", 5)) inbody = 1; } cupsFileClose(fp); } else { perror(filename); cgiSetVariable("ERROR", cgiText(_("Unable to open help file."))); cgiCopyTemplateLang("error.tmpl"); } } /* * Send a standard trailer... */ if (!printable) { cgiCopyTemplateLang("help-trailer.tmpl"); cgiEndHTML(); } else puts("</BODY>\n</HTML>"); /* * Delete the index... */ helpDeleteIndex(hi); /* * Return with no errors... */ return (0); }
static void update_smb(int onoff) /* I - 1 = turn on, 0 = turn off */ { if (!SMBConfigFile) return; if (!strncmp(SMBConfigFile, "samba:///", 9)) { /* * Enable/disable SMB via the specified smb.conf config file... */ char newfile[1024]; /* New smb.conf.N file */ cups_file_t *ofp, /* Original file pointer */ *nfp; /* New file pointer */ char line[1024]; /* Line from file */ int in_printers; /* In [printers] section? */ snprintf(newfile, sizeof(newfile), "%s.N", SMBConfigFile + 8); if ((ofp = cupsFileOpen(SMBConfigFile + 8, "r")) == NULL) { cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to open \"%s\" - %s", SMBConfigFile + 8, strerror(errno)); return; } if ((nfp = cupsFileOpen(newfile, "w")) == NULL) { cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create \"%s\" - %s", newfile, strerror(errno)); cupsFileClose(ofp); return; } /* * Copy all of the lines from the smb.conf file... */ in_printers = 0; while (cupsFileGets(ofp, line, sizeof(line))) { if (in_printers && strstr(line, "printable =")) snprintf(line, sizeof(line), " printable = %s", onoff ? "yes" : "no"); cupsFilePrintf(nfp, "%s\n", line); if (line[0] == '[') in_printers = !strcmp(line, "[printers]"); } cupsFileClose(nfp); cupsFileClose(ofp); rename(newfile, SMBConfigFile + 8); } else cupsdLogMessage(CUPSD_LOG_INFO, "Unknown SMBConfigFile scheme!"); }
cups_array_t * /* O - New message array */ _cupsMessageLoad(const char *filename, /* I - Message catalog to load */ int unquote) /* I - Unescape \foo in strings? */ { cups_file_t *fp; /* Message file */ cups_array_t *a; /* Message array */ _cups_message_t *m; /* Current message */ char s[4096], /* String buffer */ *ptr, /* Pointer into buffer */ *temp; /* New string */ size_t length, /* Length of combined strings */ ptrlen; /* Length of string */ DEBUG_printf(("4_cupsMessageLoad(filename=\"%s\")", filename)); /* * Create an array to hold the messages... */ if ((a = _cupsMessageNew(NULL)) == NULL) { DEBUG_puts("5_cupsMessageLoad: Unable to allocate array!"); return (NULL); } /* * Open the message catalog file... */ if ((fp = cupsFileOpen(filename, "r")) == NULL) { DEBUG_printf(("5_cupsMessageLoad: Unable to open file: %s", strerror(errno))); return (a); } /* * Read messages from the catalog file until EOF... * * The format is the GNU gettext .po format, which is fairly simple: * * msgid "some text" * msgstr "localized text" * * The ID and localized text can span multiple lines using the form: * * msgid "" * "some long text" * msgstr "" * "localized text spanning " * "multiple lines" */ m = NULL; while (cupsFileGets(fp, s, sizeof(s)) != NULL) { /* * Skip blank and comment lines... */ if (s[0] == '#' || !s[0]) continue; /* * Strip the trailing quote... */ if ((ptr = strrchr(s, '\"')) == NULL) continue; *ptr = '\0'; /* * Find start of value... */ if ((ptr = strchr(s, '\"')) == NULL) continue; ptr ++; /* * Unquote the text... */ if (unquote) cups_unquote(ptr, ptr); /* * Create or add to a message... */ if (!strncmp(s, "msgid", 5)) { /* * Add previous message as needed... */ if (m) { if (m->str && m->str[0]) { cupsArrayAdd(a, m); } else { /* * Translation is empty, don't add it... (STR #4033) */ free(m->id); if (m->str) free(m->str); free(m); } } /* * Create a new message with the given msgid string... */ if ((m = (_cups_message_t *)calloc(1, sizeof(_cups_message_t))) == NULL) { cupsFileClose(fp); return (a); } if ((m->id = strdup(ptr)) == NULL) { free(m); cupsFileClose(fp); return (a); } } else if (s[0] == '\"' && m) { /* * Append to current string... */ length = strlen(m->str ? m->str : m->id); ptrlen = strlen(ptr); if ((temp = realloc(m->str ? m->str : m->id, length + ptrlen + 1)) == NULL) { if (m->str) free(m->str); free(m->id); free(m); cupsFileClose(fp); return (a); } if (m->str) { /* * Copy the new portion to the end of the msgstr string - safe * to use memcpy because the buffer is allocated to the correct * size... */ m->str = temp; memcpy(m->str + length, ptr, ptrlen + 1); } else { /* * Copy the new portion to the end of the msgid string - safe * to use memcpy because the buffer is allocated to the correct * size... */ m->id = temp; memcpy(m->id + length, ptr, ptrlen + 1); } } else if (!strncmp(s, "msgstr", 6) && m) { /* * Set the string... */ if ((m->str = strdup(ptr)) == NULL) { free(m->id); free(m); cupsFileClose(fp); return (a); } } } /* * Add the last message string to the array as needed... */ if (m) { if (m->str && m->str[0]) { cupsArrayAdd(a, m); } else { /* * Translation is empty, don't add it... (STR #4033) */ free(m->id); if (m->str) free(m->str); free(m); } } /* * Close the message catalog file and return the new array... */ cupsFileClose(fp); DEBUG_printf(("5_cupsMessageLoad: Returning %d messages...", cupsArrayCount(a))); return (a); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ char *opt; /* Option character */ int close_all = 1, /* Close all file descriptors? */ disconnect = 1, /* Disconnect from controlling terminal? */ fg = 0, /* Run in foreground? */ run_as_child = 0, /* Running as child process? */ print_profile = 0; /* Print the sandbox profile to stdout? */ 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 */ senddoc_time, /* Send-Document time */ expire_time, /* Subscription expire time */ report_time, /* Malloc/client/job report time */ event_time; /* Last event notification time */ 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 __APPLE__ int use_sysman = 1; /* Use system management functions? */ #else time_t netif_time = 0; /* Time since last network update */ #endif /* __APPLE__ */ #if defined(HAVE_ONDEMAND) int service_idle_exit; /* Idle exit on select timeout? */ #endif /* HAVE_ONDEMAND */ #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); } #endif /* HAVE_GETEUID */ /* * Check for command-line arguments... */ fg = 0; #ifdef HAVE_LAUNCHD if (getenv("CUPSD_LAUNCHD")) { OnDemand = 1; fg = 1; close_all = 0; disconnect = 0; } #endif /* HAVE_LAUNCHD */ for (i = 1; i < argc; i ++) if (argv[i][0] == '-') for (opt = argv[i] + 1; *opt != '\0'; opt ++) switch (*opt) { case 'C' : /* Run as child with config file */ run_as_child = 1; fg = 1; close_all = 0; case 'c' : /* Configuration file */ i ++; if (i >= argc) { _cupsLangPuts(stderr, _("cupsd: Expected config filename " "after \"-c\" option.")); 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.")); return (1); } if (!getcwd(current, 1024)) { _cupsLangPuts(stderr, _("cupsd: Unable to get current directory.")); free(current); return (1); } cupsdSetStringf(&ConfigurationFile, "%s/%s", current, argv[i]); free(current); } break; case 'f' : /* Run in foreground... */ fg = 1; disconnect = 0; close_all = 0; break; case 'F' : /* Run in foreground, but disconnect from terminal... */ fg = 1; close_all = 0; break; case 'h' : /* Show usage/help */ usage(0); break; case 'l' : /* Started by launchd/systemd/upstart... */ #if defined(HAVE_ONDEMAND) OnDemand = 1; fg = 1; close_all = 0; disconnect = 0; #else _cupsLangPuts(stderr, _("cupsd: On-demand support not compiled " "in, running in normal mode.")); fg = 0; disconnect = 1; close_all = 1; #endif /* HAVE_ONDEMAND */ break; case 'p' : /* Stop immediately for profiling */ fputs("cupsd: -p (startup profiling) is for internal testing " "use only!\n", stderr); stop_scheduler = 1; fg = 1; disconnect = 0; close_all = 0; break; case 'P' : /* Disable security profiles */ fputs("cupsd: -P (disable sandboxing) is for internal testing use only.\n", stderr); UseSandboxing = 0; break; case 's' : /* Set cups-files.conf location */ i ++; if (i >= argc) { _cupsLangPuts(stderr, _("cupsd: Expected cups-files.conf " "filename after \"-s\" option.")); usage(1); } if (argv[i][0] != '/') { /* * Relative filename not allowed... */ _cupsLangPuts(stderr, _("cupsd: Relative cups-files.conf " "filename not allowed.")); usage(1); } cupsdSetString(&CupsFilesFile, argv[i]); break; #ifdef __APPLE__ case 'S' : /* Disable system management functions */ fputs("cupsd: -S (disable system management) for internal " "testing use only!\n", stderr); use_sysman = 0; break; #endif /* __APPLE__ */ case 't' : /* Test the cupsd.conf file... */ TestConfigFile = 1; fg = 1; disconnect = 0; close_all = 0; break; case 'T' : /* Print security profile */ print_profile = 1; fg = 1; disconnect = 0; close_all = 0; break; default : /* Unknown option */ _cupsLangPrintf(stderr, _("cupsd: Unknown option \"%c\" - " "aborting."), *opt); usage(1); break; } else { _cupsLangPrintf(stderr, _("cupsd: Unknown argument \"%s\" - aborting."), argv[i]); usage(1); } if (!ConfigurationFile) cupsdSetString(&ConfigurationFile, CUPS_SERVERROOT "/cupsd.conf"); if (!CupsFilesFile) { char *filename, /* Copy of cupsd.conf filename */ *slash; /* Final slash in cupsd.conf filename */ size_t len; /* Size of buffer */ len = strlen(ConfigurationFile) + 15; if ((filename = malloc(len)) == NULL) { _cupsLangPrintf(stderr, _("cupsd: Unable to get path to " "cups-files.conf file.")); return (1); } strlcpy(filename, ConfigurationFile, len); if ((slash = strrchr(filename, '/')) == NULL) { _cupsLangPrintf(stderr, _("cupsd: Unable to get path to " "cups-files.conf file.")); return (1); } strlcpy(slash, "/cups-files.conf", len - (size_t)(slash - filename)); cupsdSetString(&CupsFilesFile, filename); free(filename); } if (disconnect) { /* * Make sure we aren't tying up any filesystems... */ chdir("/"); /* * Disconnect from the controlling terminal... */ setsid(); } if (close_all) { /* * Close all open files... */ getrlimit(RLIMIT_NOFILE, &limit); for (i = 0; i < (int)limit.rlim_cur && i < 1024; i ++) close(i); /* * Redirect stdin/out/err to /dev/null... */ if ((i = open("/dev/null", O_RDONLY)) != 0) { dup2(i, 0); close(i); } if ((i = open("/dev/null", O_WRONLY)) != 1) { dup2(i, 1); close(i); } if ((i = open("/dev/null", O_WRONLY)) != 2) { dup2(i, 2); close(i); } } else LogStderr = cupsFileStderr(); /* * Run in the background as needed... */ 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); } } #if defined(__OpenBSD__) && OpenBSD < 201211 /* * Call _thread_sys_closefrom() so the child process doesn't reset the * parent's file descriptors to be blocking. This is a workaround for a * limitation of userland libpthread on older versions of OpenBSD. */ _thread_sys_closefrom(0); #endif /* __OpenBSD__ && OpenBSD < 201211 */ /* * Since many system libraries create fork-unsafe data on execution of a * program, we need to re-execute the background cupsd with the "-C" and "-s" * options to avoid problems. Unfortunately, we also have to assume that * argv[0] contains the name of the cupsd executable - there is no portable * way to get the real pathname... */ execlp(argv[0], argv[0], "-C", ConfigurationFile, "-s", CupsFilesFile, (char *)0); exit(errno); } /* * Set the timezone info... */ tzset(); #ifdef LC_TIME setlocale(LC_TIME, ""); #endif /* LC_TIME */ #ifdef HAVE_DBUS_THREADS_INIT /* * Enable threading support for D-BUS... */ dbus_threads_init_default(); #endif /* HAVE_DBUS_THREADS_INIT */ /* * 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 = (rlim_t)MaxFDs; setrlimit(RLIMIT_NOFILE, &limit); cupsdStartSelect(); /* * Read configuration... */ if (!cupsdReadConfiguration()) return (1); else if (TestConfigFile) { printf("\"%s\" is OK.\n", CupsFilesFile); printf("\"%s\" is OK.\n", ConfigurationFile); return (0); } else if (print_profile) { cups_file_t *fp; /* File pointer */ const char *profile = cupsdCreateProfile(42, 0); /* Profile */ char line[1024]; /* Line from file */ if ((fp = cupsFileOpen(profile, "r")) == NULL) { printf("Unable to open profile file \"%s\": %s\n", profile ? profile : "(null)", strerror(errno)); return (1); } while (cupsFileGets(fp, line, sizeof(line))) puts(line); cupsFileClose(fp); return (0); } /* * Clean out old temp files and printer cache data. */ if (!strncmp(TempDir, RequestRoot, strlen(RequestRoot))) cupsdCleanFiles(TempDir, NULL); cupsdCleanFiles(CacheDir, "*.ipp"); #if defined(HAVE_ONDEMAND) if (OnDemand) { /* * If we were started on demand by launchd or systemd get the listen sockets * file descriptors... */ service_checkin(); service_checkout(); } #endif /* HAVE_ONDEMAND */ /* * Startup the server... */ httpInitialize(); 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); #elif defined(HAVE_SIGACTION) 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 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 */ /* * Initialize authentication certificates... */ cupsdInitCerts(); /* * If we are running in the background, signal the parent process that * we are up and running... */ if (!fg || run_as_child) { /* * 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... */ if (use_sysman) cupsdStartSystemMonitor(); #endif /* __APPLE__ */ /* * Send server-started event... */ #if defined(HAVE_ONDEMAND) if (OnDemand) cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started on demand."); else #endif /* HAVE_ONDEMAND */ if (fg) cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started in foreground."); else cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started in background."); /* * Start any pending print jobs... */ cupsdCheckJobs(); /* * Loop forever... */ current_time = time(NULL); event_time = current_time; expire_time = current_time; fds = 1; report_time = 0; senddoc_time = current_time; while (!stop_scheduler) { /* * 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 (httpGetState(con->http) == HTTP_WAITING) cupsdCloseClient(con); else con->http->keep_alive = HTTP_KEEPALIVE_OFF; cupsdPauseListening(); } /* * Restart if all clients are closed and all jobs finished, or * if the reload timeout has elapsed... */ if ((cupsArrayCount(Clients) == 0 && (cupsArrayCount(PrintingJobs) == 0 || NeedReload != RELOAD_ALL)) || (time(NULL) - ReloadTime) >= ReloadTimeout) { /* * Shutdown the server... */ #ifdef HAVE_ONDEMAND if (OnDemand) break; #endif /* HAVE_ONDEMAND */ DoingShutdown = 1; cupsdStopServer(); /* * Read configuration... */ if (!cupsdReadConfiguration()) { #ifdef HAVE_SYSTEMD_SD_JOURNAL_H sd_journal_print(LOG_ERR, "Unable to read configuration file \"%s\" - exiting.", ConfigurationFile); #else syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting.", ConfigurationFile); #endif /* HAVE_SYSTEMD_SD_JOURNAL_H */ break; } /* * Startup the server... */ DoingShutdown = 0; cupsdStartServer(); /* * Send a server-restarted event... */ cupsdAddEvent(CUPSD_EVENT_SERVER_RESTARTED, NULL, NULL, "Scheduler restarted."); } } /* * 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; #ifdef HAVE_ONDEMAND /* * If no other work is scheduled and we're being controlled by * launchd then timeout after 'LaunchdTimeout' seconds of * inactivity... */ if (timeout == 86400 && OnDemand && IdleExitTimeout && !cupsArrayCount(ActiveJobs) && # ifdef HAVE_SYSTEMD !WebInterface && # endif /* HAVE_SYSTEMD */ (!Browsing || !BrowseLocalProtocols || !cupsArrayCount(Printers))) { timeout = IdleExitTimeout; service_idle_exit = 1; } else service_idle_exit = 0; #endif /* HAVE_ONDEMAND */ if ((fds = cupsdDoSelect(timeout)) < 0) { /* * Got an error from select! */ #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI) cupsd_printer_t *p; /* Current printer */ #endif /* HAVE_DNSSD || HAVE_AVAHI */ 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->number, con->file, httpGetState(con->http)); 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, "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]); #if defined(HAVE_DNSSD) || defined(HAVE_AVAHI) for (p = (cupsd_printer_t *)cupsArrayFirst(Printers); p; p = (cupsd_printer_t *)cupsArrayNext(Printers)) cupsdLogMessage(CUPSD_LOG_EMERG, "printer[%s] reg_name=\"%s\"", p->name, p->reg_name ? p->reg_name : "(null)"); #endif /* HAVE_DNSSD || HAVE_AVAHI */ break; } current_time = time(NULL); /* * Write dirty config/state files... */ if (DirtyCleanTime && current_time >= DirtyCleanTime) cupsdCleanDirty(); #ifdef __APPLE__ /* * If we are going to sleep and still have pending jobs, stop them after * a period of time... */ if (SleepJobs > 0 && current_time >= SleepJobs && cupsArrayCount(PrintingJobs) > 0) { SleepJobs = 0; cupsdStopAllJobs(CUPSD_JOB_DEFAULT, 5); } #endif /* __APPLE__ */ #ifndef __APPLE__ /* * Update the network interfaces once a minute... */ if ((current_time - netif_time) >= 60) { netif_time = current_time; NetIFUpdate = 1; } #endif /* !__APPLE__ */ #ifdef HAVE_ONDEMAND /* * If no other work was scheduled and we're being controlled by launchd, * systemd, or upstart then timeout after 'LaunchdTimeout' seconds of * inactivity... */ if (!fds && service_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_ONDEMAND */ /* * 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; } #ifndef HAVE_AUTHORIZATION_H /* * 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", cupsdDefaultAuthType()); } #endif /* !HAVE_AUTHORIZATION_H */ /* * 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 (httpGetReady(con->http)) { cupsdReadClient(con); continue; } /* * Check the activity and close old clients... */ activity = current_time - Timeout; if (httpGetActivity(con->http) < activity && !con->pipe_pid) { cupsdLogMessage(CUPSD_LOG_DEBUG, "Closing client %d after %d seconds of inactivity.", con->number, Timeout); cupsdCloseClient(con); continue; } } /* * Update any pending multi-file documents... */ if ((current_time - senddoc_time) >= 10) { cupsdCheckJobs(); senddoc_time = current_time; } /* * Clean job history... */ if (JobHistoryUpdate && current_time >= JobHistoryUpdate) cupsdCleanJobs(); /* * 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)); 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."); cupsdAddEvent(CUPSD_EVENT_SERVER_STOPPED, NULL, NULL, "Scheduler shutting down normally."); } else { cupsdLogMessage(CUPSD_LOG_ERROR, "Scheduler shutting down due to program error."); cupsdAddEvent(CUPSD_EVENT_SERVER_STOPPED, NULL, NULL, "Scheduler shutting down due to program error."); } /* * Close all network clients... */ DoingShutdown = 1; cupsdStopServer(); #ifdef HAVE_ONDEMAND /* * Update the keep-alive file as needed... */ if (OnDemand) service_checkout(); #endif /* HAVE_ONDEMAND */ /* * Stop all jobs... */ cupsdFreeAllJobs(); #ifdef __APPLE__ /* * Stop monitoring system event monitoring... */ if (use_sysman) cupsdStopSystemMonitor(); #endif /* __APPLE__ */ cupsdStopSelect(); return (!stop_scheduler); }
static void update_lpd(int onoff) /* - 1 = turn on, 0 = turn off */ { if (!LPDConfigFile) return; #ifdef __APPLE__ /* * Allow /etc/hostconfig CUPS_LPD service setting to override cupsd.conf * setting for backwards-compatibility. */ if (onoff && !get_hostconfig("CUPS_LPD")) onoff = 0; #endif /* __APPLE__ */ if (!strncmp(LPDConfigFile, "xinetd:///", 10)) { /* * Enable/disable LPD via the xinetd.d config file for cups-lpd... */ char newfile[1024]; /* New cups-lpd.N file */ cups_file_t *ofp, /* Original file pointer */ *nfp; /* New file pointer */ char line[1024]; /* Line from file */ snprintf(newfile, sizeof(newfile), "%s.N", LPDConfigFile + 9); if ((ofp = cupsFileOpen(LPDConfigFile + 9, "r")) == NULL) { cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to open \"%s\" - %s", LPDConfigFile + 9, strerror(errno)); return; } if ((nfp = cupsFileOpen(newfile, "w")) == NULL) { cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to create \"%s\" - %s", newfile, strerror(errno)); cupsFileClose(ofp); return; } /* * Copy all of the lines from the cups-lpd file... */ while (cupsFileGets(ofp, line, sizeof(line))) { if (line[0] == '{') { cupsFilePrintf(nfp, "%s\n", line); snprintf(line, sizeof(line), "\tdisable = %s", onoff ? "no" : "yes"); } else if (!strstr(line, "disable =")) cupsFilePrintf(nfp, "%s\n", line); } cupsFileClose(nfp); cupsFileClose(ofp); rename(newfile, LPDConfigFile + 9); } #ifdef __APPLE__ else if (!strncmp(LPDConfigFile, "launchd:///", 11)) { /* * Enable/disable LPD via the launchctl command... */ char *argv[5], /* Arguments for command */ *envp[MAX_ENV]; /* Environment for command */ int pid; /* Process ID */ cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0]))); argv[0] = (char *)"launchctl"; argv[1] = (char *)(onoff ? "load" : "unload"); argv[2] = (char *)"-w"; argv[3] = LPDConfigFile + 10; argv[4] = NULL; cupsdStartProcess("/bin/launchctl", argv, envp, -1, -1, -1, -1, -1, 1, NULL, NULL, &pid); } #endif /* __APPLE__ */ else cupsdLogMessage(CUPSD_LOG_INFO, "Unknown LPDConfigFile scheme!"); }
static void mime_load_convs( mime_t *mime, /* I - MIME database */ const char *filename, /* I - Convs file to load */ const char *filterpath, /* I - Path for filters */ cups_array_t *filtercache) /* I - Filter program cache */ { cups_file_t *fp; /* Convs file */ char line[1024], /* Input line from file */ *lineptr, /* Current position in line */ super[MIME_MAX_SUPER], /* Super-type name */ type[MIME_MAX_TYPE], /* Type name */ *temp, /* Temporary pointer */ *filter; /* Filter program */ mime_type_t *temptype, /* MIME type looping var */ *dsttype; /* Destination MIME type */ int cost; /* Cost of filter */ DEBUG_printf(("2mime_load_convs(mime=%p, filename=\"%s\", filterpath=\"%s\", " "filtercache=%p)", mime, filename, filterpath, filtercache)); /* * First try to open the file... */ if ((fp = cupsFileOpen(filename, "r")) == NULL) { DEBUG_printf(("3mime_load_convs: Unable to open \"%s\": %s", filename, strerror(errno))); _mimeError(mime, "Unable to open \"%s\": %s", filename, strerror(errno)); return; } /* * Then read each line from the file, skipping any comments in the file... */ while (cupsFileGets(fp, line, sizeof(line)) != NULL) { /* * Skip blank lines and lines starting with a #... */ if (!line[0] || line[0] == '#') continue; /* * Strip trailing whitespace... */ for (lineptr = line + strlen(line) - 1; lineptr >= line && isspace(*lineptr & 255); lineptr --) *lineptr = '\0'; /* * Extract the destination super-type and type names from the middle of * the line. */ lineptr = line; while (*lineptr != ' ' && *lineptr != '\t' && *lineptr != '\0') lineptr ++; while (*lineptr == ' ' || *lineptr == '\t') lineptr ++; temp = super; while (*lineptr != '/' && *lineptr != '\n' && *lineptr != '\0' && (temp - super + 1) < MIME_MAX_SUPER) *temp++ = tolower(*lineptr++ & 255); *temp = '\0'; if (*lineptr != '/') continue; lineptr ++; temp = type; while (*lineptr != ' ' && *lineptr != '\t' && *lineptr != '\n' && *lineptr != '\0' && (temp - type + 1) < MIME_MAX_TYPE) *temp++ = tolower(*lineptr++ & 255); *temp = '\0'; if (*lineptr == '\0' || *lineptr == '\n') continue; if ((dsttype = mimeType(mime, super, type)) == NULL) { DEBUG_printf(("3mime_load_convs: Destination type %s/%s not found.", super, type)); continue; } /* * Then get the cost and filter program... */ while (*lineptr == ' ' || *lineptr == '\t') lineptr ++; if (*lineptr < '0' || *lineptr > '9') continue; cost = atoi(lineptr); while (*lineptr != ' ' && *lineptr != '\t' && *lineptr != '\0') lineptr ++; while (*lineptr == ' ' || *lineptr == '\t') lineptr ++; if (*lineptr == '\0' || *lineptr == '\n') continue; filter = lineptr; if (strcmp(filter, "-")) { /* * Verify that the filter exists and is executable... */ if (!mime_add_fcache(filtercache, filter, filterpath)) { DEBUG_printf(("mime_load_convs: Filter %s not found in %s.", filter, filterpath)); _mimeError(mime, "Filter \"%s\" not found.", filter); continue; } } /* * Finally, get the source super-type and type names from the beginning of * the line. We do it here so we can support wildcards... */ lineptr = line; temp = super; while (*lineptr != '/' && *lineptr != '\n' && *lineptr != '\0' && (temp - super + 1) < MIME_MAX_SUPER) *temp++ = tolower(*lineptr++ & 255); *temp = '\0'; if (*lineptr != '/') continue; lineptr ++; temp = type; while (*lineptr != ' ' && *lineptr != '\t' && *lineptr != '\n' && *lineptr != '\0' && (temp - type + 1) < MIME_MAX_TYPE) *temp++ = tolower(*lineptr++ & 255); *temp = '\0'; if (!strcmp(super, "*") && !strcmp(type, "*")) { /* * Force * / * to be "application/octet-stream"... */ strlcpy(super, "application", sizeof(super)); strlcpy(type, "octet-stream", sizeof(type)); } /* * Add the filter to the MIME database, supporting wildcards as needed... */ for (temptype = (mime_type_t *)cupsArrayFirst(mime->types); temptype; temptype = (mime_type_t *)cupsArrayNext(mime->types)) if ((super[0] == '*' || !strcmp(temptype->super, super)) && (type[0] == '*' || !strcmp(temptype->type, type))) mimeAddFilter(mime, temptype, dsttype, cost, filter); } cupsFileClose(fp); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ char path[1024], /* Path to documentation */ line[1024]; /* Line from file */ help_index_t *hi; /* Help index */ cups_file_t *tokens, /* Tokens.xml file */ *fp; /* Current file */ if (argc < 4) { puts("Usage: makedocset directory revision *.tokens"); return (1); } /* * Index the help documents... */ snprintf(path, sizeof(path), "%s/Contents/Resources/Documentation", argv[1]); if ((hi = helpLoadIndex(NULL, path)) == NULL) { fputs("makedocset: Unable to index help files!\n", stderr); return (1); } snprintf(path, sizeof(path), "%s/Contents/Resources/Documentation/index.html", argv[1]); write_index(path, hi); snprintf(path, sizeof(path), "%s/Contents/Resources/Nodes.xml", argv[1]); write_nodes(path, hi); /* * Write the Info.plist file... */ snprintf(path, sizeof(path), "%s/Contents/Info.plist", argv[1]); write_info(path, argv[2]); /* * Merge the Tokens.xml files... */ snprintf(path, sizeof(path), "%s/Contents/Resources/Tokens.xml", argv[1]); if ((tokens = cupsFileOpen(path, "w")) == NULL) { fprintf(stderr, "makedocset: Unable to create \"%s\": %s\n", path, strerror(errno)); return (1); } cupsFilePuts(tokens, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); cupsFilePuts(tokens, "<Tokens version=\"1.0\">\n"); for (i = 3; i < argc; i ++) { if ((fp = cupsFileOpen(argv[i], "r")) == NULL) { fprintf(stderr, "makedocset: Unable to open \"%s\": %s\n", argv[i], strerror(errno)); return (1); } if (!cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "<?xml ", 6) || !cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "<Tokens ", 8)) { fprintf(stderr, "makedocset: Bad Tokens.xml file \"%s\"!\n", argv[i]); return (1); } while (cupsFileGets(fp, line, sizeof(line))) { if (strcmp(line, "</Tokens>")) cupsFilePrintf(tokens, "%s\n", line); } cupsFileClose(fp); } cupsFilePuts(tokens, "</Tokens>\n"); cupsFileClose(tokens); /* * Return with no errors... */ return (0); }
static int /* O - Status */ read_write_tests(int compression) /* I - Use compression? */ { int i; /* Looping var */ cups_file_t *fp; /* File */ int status; /* Exit status */ char line[1024], /* Line from file */ *value; /* Directive value from line */ int linenum; /* Line number */ unsigned char readbuf[8192], /* Read buffer */ writebuf[8192]; /* Write buffer */ int byte; /* Byte from file */ off_t length; /* Length of file */ static const char *partial_line = "partial line"; /* Partial line */ /* * No errors so far... */ status = 0; /* * Initialize the write buffer with random data... */ CUPS_SRAND((unsigned)time(NULL)); for (i = 0; i < (int)sizeof(writebuf); i ++) writebuf[i] = CUPS_RAND(); /* * cupsFileOpen(write) */ printf("cupsFileOpen(write%s): ", compression ? " compressed" : ""); fp = cupsFileOpen(compression ? "testfile.dat.gz" : "testfile.dat", compression ? "w9" : "w"); if (fp) { puts("PASS"); /* * cupsFileCompression() */ fputs("cupsFileCompression(): ", stdout); if (cupsFileCompression(fp) == compression) puts("PASS"); else { printf("FAIL (Got %d, expected %d)\n", cupsFileCompression(fp), compression); status ++; } /* * cupsFilePuts() */ fputs("cupsFilePuts(): ", stdout); if (cupsFilePuts(fp, "# Hello, World\n") > 0) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFilePrintf() */ fputs("cupsFilePrintf(): ", stdout); for (i = 0; i < 1000; i ++) if (cupsFilePrintf(fp, "TestLine %03d\n", i) < 0) break; if (i >= 1000) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFilePutChar() */ fputs("cupsFilePutChar(): ", stdout); for (i = 0; i < 256; i ++) if (cupsFilePutChar(fp, i) < 0) break; if (i >= 256) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileWrite() */ fputs("cupsFileWrite(): ", stdout); for (i = 0; i < 10000; i ++) if (cupsFileWrite(fp, (char *)writebuf, sizeof(writebuf)) < 0) break; if (i >= 10000) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFilePuts() with partial line... */ fputs("cupsFilePuts(\"partial line\"): ", stdout); if (cupsFilePuts(fp, partial_line) > 0) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileTell() */ fputs("cupsFileTell(): ", stdout); if ((length = cupsFileTell(fp)) == 81933283) puts("PASS"); else { printf("FAIL (" CUPS_LLFMT " instead of 81933283)\n", CUPS_LLCAST length); status ++; } /* * cupsFileClose() */ fputs("cupsFileClose(): ", stdout); if (!cupsFileClose(fp)) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } } else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileOpen(read) */ fputs("\ncupsFileOpen(read): ", stdout); fp = cupsFileOpen(compression ? "testfile.dat.gz" : "testfile.dat", "r"); if (fp) { puts("PASS"); /* * cupsFileGets() */ fputs("cupsFileGets(): ", stdout); if (cupsFileGets(fp, line, sizeof(line))) { if (line[0] == '#') puts("PASS"); else { printf("FAIL (Got line \"%s\", expected comment line)\n", line); status ++; } } else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileCompression() */ fputs("cupsFileCompression(): ", stdout); if (cupsFileCompression(fp) == compression) puts("PASS"); else { printf("FAIL (Got %d, expected %d)\n", cupsFileCompression(fp), compression); status ++; } /* * cupsFileGetConf() */ linenum = 1; fputs("cupsFileGetConf(): ", stdout); for (i = 0; i < 1000; i ++) if (!cupsFileGetConf(fp, line, sizeof(line), &value, &linenum)) break; else if (_cups_strcasecmp(line, "TestLine") || !value || atoi(value) != i || linenum != (i + 2)) break; if (i >= 1000) puts("PASS"); else if (line[0]) { printf("FAIL (Line %d, directive \"%s\", value \"%s\")\n", linenum, line, value ? value : "(null)"); status ++; } else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileGetChar() */ fputs("cupsFileGetChar(): ", stdout); for (i = 0; i < 256; i ++) if ((byte = cupsFileGetChar(fp)) != i) break; if (i >= 256) puts("PASS"); else if (byte >= 0) { printf("FAIL (Got %d, expected %d)\n", byte, i); status ++; } else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileRead() */ fputs("cupsFileRead(): ", stdout); for (i = 0; i < 10000; i ++) if ((byte = cupsFileRead(fp, (char *)readbuf, sizeof(readbuf))) < 0) break; else if (memcmp(readbuf, writebuf, sizeof(readbuf))) break; if (i >= 10000) puts("PASS"); else if (byte > 0) { printf("FAIL (Pass %d, ", i); for (i = 0; i < (int)sizeof(readbuf); i ++) if (readbuf[i] != writebuf[i]) break; printf("match failed at offset %d - got %02X, expected %02X)\n", i, readbuf[i], writebuf[i]); } else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * cupsFileGetChar() with partial line... */ fputs("cupsFileGetChar(partial line): ", stdout); for (i = 0; i < (int)strlen(partial_line); i ++) if ((byte = cupsFileGetChar(fp)) < 0) break; else if (byte != partial_line[i]) break; if (!partial_line[i]) puts("PASS"); else { printf("FAIL (got '%c', expected '%c')\n", byte, partial_line[i]); status ++; } /* * cupsFileTell() */ fputs("cupsFileTell(): ", stdout); if ((length = cupsFileTell(fp)) == 81933283) puts("PASS"); else { printf("FAIL (" CUPS_LLFMT " instead of 81933283)\n", CUPS_LLCAST length); status ++; } /* * cupsFileClose() */ fputs("cupsFileClose(): ", stdout); if (!cupsFileClose(fp)) puts("PASS"); else { printf("FAIL (%s)\n", strerror(errno)); status ++; } } else { printf("FAIL (%s)\n", strerror(errno)); status ++; } /* * Remove the test file... */ unlink(compression ? "testfile.dat.gz" : "testfile.dat"); /* * Return the test status... */ return (status); }
help_index_t * /* O - Index pointer or NULL */ helpLoadIndex(const char *hifile, /* I - Index filename */ const char *directory) /* I - Directory that is indexed */ { help_index_t *hi; /* Help index */ cups_file_t *fp; /* Current file */ char line[2048], /* Line from file */ *ptr, /* Pointer into line */ *filename, /* Filename in line */ *anchor, /* Anchor in line */ *sectptr, /* Section pointer in line */ section[1024], /* Section name */ *text; /* Text in line */ time_t mtime; /* Modification time */ off_t offset; /* Offset into file */ size_t length; /* Length in bytes */ int update; /* Update? */ help_node_t *node; /* Current node */ help_word_t *word; /* Current word */ DEBUG_printf(("helpLoadIndex(hifile=\"%s\", directory=\"%s\")", hifile, directory)); /* * Create a new, empty index. */ if ((hi = (help_index_t *)calloc(1, sizeof(help_index_t))) == NULL) return (NULL); hi->nodes = cupsArrayNew((cups_array_func_t)help_sort_by_name, NULL); hi->sorted = cupsArrayNew((cups_array_func_t)help_sort_by_score, NULL); if (!hi->nodes || !hi->sorted) { cupsArrayDelete(hi->nodes); cupsArrayDelete(hi->sorted); free(hi); return (NULL); } /* * Try loading the existing index file... */ if ((fp = cupsFileOpen(hifile, "r")) != NULL) { /* * Lock the file and then read the first line... */ cupsFileLock(fp, 1); if (cupsFileGets(fp, line, sizeof(line)) && !strcmp(line, "HELPV2")) { /* * Got a valid header line, now read the data lines... */ node = NULL; while (cupsFileGets(fp, line, sizeof(line))) { /* * Each line looks like one of the following: * * filename mtime offset length "section" "text" * filename#anchor offset length "text" * SP count word */ if (line[0] == ' ') { /* * Read a word in the current node... */ if (!node || (ptr = strrchr(line, ' ')) == NULL) continue; if ((word = help_add_word(node, ptr + 1)) != NULL) word->count = atoi(line + 1); } else { /* * Add a node... */ filename = line; if ((ptr = strchr(line, ' ')) == NULL) break; while (isspace(*ptr & 255)) *ptr++ = '\0'; if ((anchor = strrchr(filename, '#')) != NULL) { *anchor++ = '\0'; mtime = 0; } else mtime = strtol(ptr, &ptr, 10); offset = strtoll(ptr, &ptr, 10); length = strtoll(ptr, &ptr, 10); while (isspace(*ptr & 255)) ptr ++; if (!anchor) { /* * Get section... */ if (*ptr != '\"') break; ptr ++; sectptr = ptr; while (*ptr && *ptr != '\"') ptr ++; if (*ptr != '\"') break; *ptr++ = '\0'; strlcpy(section, sectptr, sizeof(section)); while (isspace(*ptr & 255)) ptr ++; } if (*ptr != '\"') break; ptr ++; text = ptr; while (*ptr && *ptr != '\"') ptr ++; if (*ptr != '\"') break; *ptr++ = '\0'; if ((node = help_new_node(filename, anchor, section, text, mtime, offset, length)) == NULL) break; node->score = -1; cupsArrayAdd(hi->nodes, node); } } } cupsFileClose(fp); } /* * Scan for new/updated files... */ update = help_load_directory(hi, directory, NULL); /* * Remove any files that are no longer installed... */ for (node = (help_node_t *)cupsArrayFirst(hi->nodes); node; node = (help_node_t *)cupsArrayNext(hi->nodes)) if (node->score < 0) { /* * Delete this node... */ cupsArrayRemove(hi->nodes, node); help_delete_node(node); } /* * Add nodes to the sorted array... */ for (node = (help_node_t *)cupsArrayFirst(hi->nodes); node; node = (help_node_t *)cupsArrayNext(hi->nodes)) cupsArrayAdd(hi->sorted, node); /* * Save the index if we updated it... */ if (update) helpSaveIndex(hi, hifile); /* * Return the index... */ return (hi); }
static int /* O - 0 on success, -1 on error */ get_device(cupsd_backend_t *backend) /* I - Backend to read from */ { char line[2048], /* Line from backend */ temp[2048], /* Copy of line */ *ptr, /* Pointer into line */ *dclass, /* Device class */ *uri, /* Device URI */ *make_model, /* Make and model */ *info, /* Device info */ *device_id, /* 1284 device ID */ *location; /* Physical location */ if (cupsFileGets(backend->pipe, line, sizeof(line))) { /* * Each line is of the form: * * class URI "make model" "name" ["1284 device ID"] ["location"] */ strlcpy(temp, line, sizeof(temp)); /* * device-class */ dclass = temp; for (ptr = temp; *ptr; ptr ++) if (isspace(*ptr & 255)) break; while (isspace(*ptr & 255)) *ptr++ = '\0'; /* * device-uri */ if (!*ptr) goto error; for (uri = ptr; *ptr; ptr ++) if (isspace(*ptr & 255)) break; while (isspace(*ptr & 255)) *ptr++ = '\0'; /* * device-make-and-model */ if (*ptr != '\"') goto error; for (ptr ++, make_model = ptr; *ptr && *ptr != '\"'; ptr ++) { if (*ptr == '\\' && ptr[1]) _cups_strcpy(ptr, ptr + 1); } if (*ptr != '\"') goto error; for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0'); /* * device-info */ if (*ptr != '\"') goto error; for (ptr ++, info = ptr; *ptr && *ptr != '\"'; ptr ++) { if (*ptr == '\\' && ptr[1]) _cups_strcpy(ptr, ptr + 1); } if (*ptr != '\"') goto error; for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0'); /* * device-id */ if (*ptr == '\"') { for (ptr ++, device_id = ptr; *ptr && *ptr != '\"'; ptr ++) { if (*ptr == '\\' && ptr[1]) _cups_strcpy(ptr, ptr + 1); } if (*ptr != '\"') goto error; for (*ptr++ = '\0'; isspace(*ptr & 255); *ptr++ = '\0'); /* * device-location */ if (*ptr == '\"') { for (ptr ++, location = ptr; *ptr && *ptr != '\"'; ptr ++) { if (*ptr == '\\' && ptr[1]) _cups_strcpy(ptr, ptr + 1); } if (*ptr != '\"') goto error; *ptr = '\0'; } else location = NULL; } else { device_id = NULL; location = NULL; } /* * Add the device to the array of available devices... */ if (!add_device(dclass, make_model, info, uri, device_id, location)) fprintf(stderr, "DEBUG: [cups-deviced] Found device \"%s\"...\n", uri); return (0); } /* * End of file... */ cupsFileClose(backend->pipe); backend->pipe = NULL; return (-1); /* * Bad format; strip trailing newline and write an error message. */ error: if (line[strlen(line) - 1] == '\n') line[strlen(line) - 1] = '\0'; fprintf(stderr, "ERROR: [cups-deviced] Bad line from \"%s\": %s\n", backend->name, line); return (0); }
static int /* O - 0 on success, 1 on fail */ set_printer_options( http_t *http, /* I - Server connection */ char *printer, /* I - Printer */ int num_options, /* I - Number of options */ cups_option_t *options, /* I - Options */ char *file) /* I - PPD file/interface script */ { ipp_t *request; /* IPP Request */ const char *ppdfile; /* PPD filename */ int ppdchanged; /* PPD changed? */ ppd_file_t *ppd; /* PPD file */ ppd_choice_t *choice; /* Marked choice */ char uri[HTTP_MAX_URI], /* URI for printer/class */ line[1024], /* Line from PPD file */ keyword[1024], /* Keyword from Default line */ *keyptr, /* Pointer into keyword... */ tempfile[1024]; /* Temporary filename */ cups_file_t *in, /* PPD file */ *out; /* Temporary file */ const char *protocol, /* Old protocol option */ *customval, /* Custom option value */ *boolval; /* Boolean value */ int wrote_ipp_supplies = 0, /* Wrote cupsIPPSupplies keyword? */ wrote_snmp_supplies = 0;/* Wrote cupsSNMPSupplies keyword? */ DEBUG_printf(("set_printer_options(http=%p, printer=\"%s\", num_options=%d, " "options=%p, file=\"%s\")\n", http, printer, num_options, options, file)); /* * Build a CUPS_ADD_MODIFY_PRINTER or CUPS_ADD_MODIFY_CLASS request, which * requires the following attributes: * * attributes-charset * attributes-natural-language * printer-uri * requesting-user-name * other options */ if (get_printer_type(http, printer, uri, sizeof(uri)) & CUPS_PRINTER_CLASS) request = ippNewRequest(CUPS_ADD_MODIFY_CLASS); else request = ippNewRequest(CUPS_ADD_MODIFY_PRINTER); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri); ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name", NULL, cupsUser()); /* * Add the options... */ cupsEncodeOptions2(request, num_options, options, IPP_TAG_PRINTER); if ((protocol = cupsGetOption("protocol", num_options, options)) != NULL) { if (!_cups_strcasecmp(protocol, "bcp")) ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor", NULL, "bcp"); else if (!_cups_strcasecmp(protocol, "tbcp")) ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "port-monitor", NULL, "tbcp"); } if (file) ppdfile = file; else if (request->request.op.operation_id == CUPS_ADD_MODIFY_PRINTER) ppdfile = cupsGetPPD(printer); else ppdfile = NULL; if (ppdfile != NULL) { /* * Set default options in the PPD file... */ ppd = ppdOpenFile(ppdfile); ppdMarkDefaults(ppd); cupsMarkOptions(ppd, num_options, options); if ((out = cupsTempFile2(tempfile, sizeof(tempfile))) == NULL) { _cupsLangPrintError(NULL, _("lpadmin: Unable to create temporary file")); ippDelete(request); if (ppdfile != file) unlink(ppdfile); return (1); } if ((in = cupsFileOpen(ppdfile, "r")) == NULL) { _cupsLangPrintf(stderr, _("lpadmin: Unable to open PPD file \"%s\" - %s"), ppdfile, strerror(errno)); ippDelete(request); if (ppdfile != file) unlink(ppdfile); cupsFileClose(out); unlink(tempfile); return (1); } ppdchanged = 0; while (cupsFileGets(in, line, sizeof(line))) { if (!strncmp(line, "*cupsIPPSupplies:", 17) && (boolval = cupsGetOption("cupsIPPSupplies", num_options, options)) != NULL) { wrote_ipp_supplies = 1; cupsFilePrintf(out, "*cupsIPPSupplies: %s\n", (!_cups_strcasecmp(boolval, "true") || !_cups_strcasecmp(boolval, "yes") || !_cups_strcasecmp(boolval, "on")) ? "True" : "False"); } else if (!strncmp(line, "*cupsSNMPSupplies:", 18) && (boolval = cupsGetOption("cupsSNMPSupplies", num_options, options)) != NULL) { wrote_snmp_supplies = 1; cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n", (!_cups_strcasecmp(boolval, "true") || !_cups_strcasecmp(boolval, "yes") || !_cups_strcasecmp(boolval, "on")) ? "True" : "False"); } else if (strncmp(line, "*Default", 8)) cupsFilePrintf(out, "%s\n", line); else { /* * Get default option name... */ strlcpy(keyword, line + 8, sizeof(keyword)); for (keyptr = keyword; *keyptr; keyptr ++) if (*keyptr == ':' || isspace(*keyptr & 255)) break; *keyptr++ = '\0'; while (isspace(*keyptr & 255)) keyptr ++; if (!strcmp(keyword, "PageRegion") || !strcmp(keyword, "PageSize") || !strcmp(keyword, "PaperDimension") || !strcmp(keyword, "ImageableArea")) { if ((choice = ppdFindMarkedChoice(ppd, "PageSize")) == NULL) choice = ppdFindMarkedChoice(ppd, "PageRegion"); } else choice = ppdFindMarkedChoice(ppd, keyword); if (choice && strcmp(choice->choice, keyptr)) { if (strcmp(choice->choice, "Custom")) { cupsFilePrintf(out, "*Default%s: %s\n", keyword, choice->choice); ppdchanged = 1; } else if ((customval = cupsGetOption(keyword, num_options, options)) != NULL) { cupsFilePrintf(out, "*Default%s: %s\n", keyword, customval); ppdchanged = 1; } else cupsFilePrintf(out, "%s\n", line); } else cupsFilePrintf(out, "%s\n", line); } } if (!wrote_ipp_supplies && (boolval = cupsGetOption("cupsIPPSupplies", num_options, options)) != NULL) { cupsFilePrintf(out, "*cupsIPPSupplies: %s\n", (!_cups_strcasecmp(boolval, "true") || !_cups_strcasecmp(boolval, "yes") || !_cups_strcasecmp(boolval, "on")) ? "True" : "False"); } if (!wrote_snmp_supplies && (boolval = cupsGetOption("cupsSNMPSupplies", num_options, options)) != NULL) { cupsFilePrintf(out, "*cupsSNMPSupplies: %s\n", (!_cups_strcasecmp(boolval, "true") || !_cups_strcasecmp(boolval, "yes") || !_cups_strcasecmp(boolval, "on")) ? "True" : "False"); } cupsFileClose(in); cupsFileClose(out); ppdClose(ppd); /* * Do the request... */ ippDelete(cupsDoFileRequest(http, request, "/admin/", ppdchanged ? tempfile : file)); /* * Clean up temp files... (TODO: catch signals in case we CTRL-C during * lpadmin) */ if (ppdfile != file) unlink(ppdfile); unlink(tempfile); } else { /* * No PPD file - just set the options... */ ippDelete(cupsDoRequest(http, request, "/admin/")); } /* * Check the response... */ if (cupsLastError() > IPP_OK_CONFLICT) { _cupsLangPrintf(stderr, _("%s: %s"), "lpadmin", cupsLastErrorString()); return (1); } else return (0); }
static void backend_init_supplies( int snmp_fd, /* I - SNMP socket */ http_addr_t *addr) /* I - Printer address */ { int i, /* Looping var */ type; /* Current marker type */ cups_file_t *cachefile; /* Cache file */ const char *cachedir; /* CUPS_CACHEDIR value */ char addrstr[1024], /* Address string */ cachefilename[1024], /* Cache filename */ description[CUPS_SNMP_MAX_STRING], /* Device description string */ value[CUPS_MAX_SUPPLIES * (CUPS_SNMP_MAX_STRING * 4 + 3)], /* Value string */ *ptr, /* Pointer into value string */ *name_ptr; /* Pointer into name string */ cups_snmp_t packet; /* SNMP response packet */ ppd_file_t *ppd; /* PPD file for this queue */ ppd_attr_t *ppdattr; /* cupsSNMPSupplies attribute */ static const char * const types[] = /* Supply types */ { "other", "unknown", "toner", "waste-toner", "ink", "ink-cartridge", "ink-ribbon", "waste-ink", "opc", "developer", "fuser-oil", "solid-wax", "ribbon-wax", "waste-wax", "fuser", "corona-wire", "fuser-oil-wick", "cleaner-unit", "fuser-cleaning-pad", "transfer-unit", "toner-cartridge", "fuser-oiler", "water", "waste-water", "glue-water-additive", "waste-paper", "binding-supply", "banding-supply", "stitching-wire", "shrink-wrap", "paper-wrap", "staples", "inserts", "covers" }; /* * Reset state information... */ current_addr = *addr; current_state = -1; num_supplies = -1; charset = -1; memset(supplies, 0, sizeof(supplies)); /* * See if we should be getting supply levels via SNMP... */ if ((ppd = ppdOpenFile(getenv("PPD"))) == NULL || ((ppdattr = ppdFindAttr(ppd, "cupsSNMPSupplies", NULL)) != NULL && ppdattr->value && _cups_strcasecmp(ppdattr->value, "true"))) { ppdClose(ppd); return; } if ((ppdattr = ppdFindAttr(ppd, "cupsSNMPQuirks", NULL)) != NULL) { if (!_cups_strcasecmp(ppdattr->value, "capacity")) quirks |= CUPS_SNMP_CAPACITY; } ppdClose(ppd); /* * Get the device description... */ if (!_cupsSNMPWrite(snmp_fd, addr, CUPS_SNMP_VERSION_1, _cupsSNMPDefaultCommunity(), CUPS_ASN1_GET_REQUEST, 1, hrDeviceDescr)) return; if (!_cupsSNMPRead(snmp_fd, &packet, CUPS_SUPPLY_TIMEOUT) || packet.object_type != CUPS_ASN1_OCTET_STRING) { strlcpy(description, "Unknown", sizeof(description)); num_supplies = 0; } else strlcpy(description, (char *)packet.object_value.string.bytes, sizeof(description)); fprintf(stderr, "DEBUG2: hrDeviceDesc=\"%s\"\n", description); /* * See if we have already queried this device... */ httpAddrString(addr, addrstr, sizeof(addrstr)); if ((cachedir = getenv("CUPS_CACHEDIR")) == NULL) cachedir = CUPS_CACHEDIR; snprintf(cachefilename, sizeof(cachefilename), "%s/%s.snmp", cachedir, addrstr); if ((cachefile = cupsFileOpen(cachefilename, "r")) != NULL) { /* * Yes, read the cache file: * * 3 num_supplies charset * device description * supply structures... */ if (cupsFileGets(cachefile, value, sizeof(value))) { if (sscanf(value, "3 %d%d", &num_supplies, &charset) == 2 && num_supplies <= CUPS_MAX_SUPPLIES && cupsFileGets(cachefile, value, sizeof(value))) { if (!strcmp(description, value)) cupsFileRead(cachefile, (char *)supplies, (size_t)num_supplies * sizeof(backend_supplies_t)); else { num_supplies = -1; charset = -1; } } else { num_supplies = -1; charset = -1; } } cupsFileClose(cachefile); } /* * If the cache information isn't correct, scan for supplies... */ if (charset < 0) { /* * Get the configured character set... */ int oid[CUPS_SNMP_MAX_OID]; /* OID for character set */ if (!_cupsSNMPWrite(snmp_fd, ¤t_addr, CUPS_SNMP_VERSION_1, _cupsSNMPDefaultCommunity(), CUPS_ASN1_GET_REQUEST, 1, prtGeneralCurrentLocalization)) return; if (!_cupsSNMPRead(snmp_fd, &packet, CUPS_SUPPLY_TIMEOUT) || packet.object_type != CUPS_ASN1_INTEGER) { fprintf(stderr, "DEBUG: prtGeneralCurrentLocalization type is %x, expected %x!\n", packet.object_type, CUPS_ASN1_INTEGER); return; } fprintf(stderr, "DEBUG2: prtGeneralCurrentLocalization=%d\n", packet.object_value.integer); _cupsSNMPCopyOID(oid, prtLocalizationCharacterSet, CUPS_SNMP_MAX_OID); oid[prtLocalizationCharacterSetOffset - 2] = packet.object_value.integer; if (!_cupsSNMPWrite(snmp_fd, ¤t_addr, CUPS_SNMP_VERSION_1, _cupsSNMPDefaultCommunity(), CUPS_ASN1_GET_REQUEST, 1, oid)) return; if (!_cupsSNMPRead(snmp_fd, &packet, CUPS_SUPPLY_TIMEOUT) || packet.object_type != CUPS_ASN1_INTEGER) { fprintf(stderr, "DEBUG: prtLocalizationCharacterSet type is %x, expected %x!\n", packet.object_type, CUPS_ASN1_INTEGER); return; } fprintf(stderr, "DEBUG2: prtLocalizationCharacterSet=%d\n", packet.object_value.integer); charset = packet.object_value.integer; } if (num_supplies < 0) { /* * Walk the printer configuration information... */ _cupsSNMPWalk(snmp_fd, ¤t_addr, CUPS_SNMP_VERSION_1, _cupsSNMPDefaultCommunity(), prtMarkerSuppliesEntry, CUPS_SUPPLY_TIMEOUT, backend_walk_cb, NULL); } /* * Save the cached information... */ if (num_supplies < 0) num_supplies = 0; if ((cachefile = cupsFileOpen(cachefilename, "w")) != NULL) { cupsFilePrintf(cachefile, "3 %d %d\n", num_supplies, charset); cupsFilePrintf(cachefile, "%s\n", description); if (num_supplies > 0) cupsFileWrite(cachefile, (char *)supplies, (size_t)num_supplies * sizeof(backend_supplies_t)); cupsFileClose(cachefile); } if (num_supplies <= 0) return; /* * Get the colors... */ for (i = 0; i < num_supplies; i ++) strlcpy(supplies[i].color, "none", sizeof(supplies[i].color)); _cupsSNMPWalk(snmp_fd, ¤t_addr, CUPS_SNMP_VERSION_1, _cupsSNMPDefaultCommunity(), prtMarkerColorantValue, CUPS_SUPPLY_TIMEOUT, backend_walk_cb, NULL); /* * Output the marker-colors attribute... */ for (i = 0, ptr = value; i < num_supplies; i ++, ptr += strlen(ptr)) { if (i) *ptr++ = ','; strlcpy(ptr, supplies[i].color, sizeof(value) - (size_t)(ptr - value)); } fprintf(stderr, "ATTR: marker-colors=%s\n", value); /* * Output the marker-names attribute (the double quoting is necessary to deal * with embedded quotes and commas in the marker names...) */ for (i = 0, ptr = value; i < num_supplies; i ++) { if (i) *ptr++ = ','; *ptr++ = '\''; *ptr++ = '\"'; for (name_ptr = supplies[i].name; *name_ptr;) { if (*name_ptr == '\\' || *name_ptr == '\"' || *name_ptr == '\'') { *ptr++ = '\\'; *ptr++ = '\\'; *ptr++ = '\\'; } *ptr++ = *name_ptr++; } *ptr++ = '\"'; *ptr++ = '\''; } *ptr = '\0'; fprintf(stderr, "ATTR: marker-names=%s\n", value); /* * Output the marker-types attribute... */ for (i = 0, ptr = value; i < num_supplies; i ++, ptr += strlen(ptr)) { if (i) *ptr++ = ','; type = supplies[i].type; if (type < CUPS_TC_other || type > CUPS_TC_covers) strlcpy(ptr, "unknown", sizeof(value) - (size_t)(ptr - value)); else strlcpy(ptr, types[type - CUPS_TC_other], sizeof(value) - (size_t)(ptr - value)); } fprintf(stderr, "ATTR: marker-types=%s\n", value); }
int /* O - 0 on success, -1 on error */ httpLoadCredentials( const char *path, /* I - Keychain/PKCS#12 path */ cups_array_t **credentials, /* IO - Credentials */ const char *common_name) /* I - Common name for credentials */ { cups_file_t *fp; /* Certificate file */ char filename[1024], /* filename.crt */ temp[1024], /* Temporary string */ line[256]; /* Base64-encoded line */ unsigned char *data = NULL; /* Buffer for cert data */ size_t alloc_data = 0, /* Bytes allocated */ num_data = 0; /* Bytes used */ int decoded; /* Bytes decoded */ if (!credentials || !common_name) return (-1); if (!path) path = http_gnutls_default_path(temp, sizeof(temp)); if (!path) return (-1); http_gnutls_make_path(filename, sizeof(filename), path, common_name, "crt"); if ((fp = cupsFileOpen(filename, "r")) == NULL) return (-1); while (cupsFileGets(fp, line, sizeof(line))) { if (!strcmp(line, "-----BEGIN CERTIFICATE-----")) { if (num_data) { /* * Missing END CERTIFICATE... */ httpFreeCredentials(*credentials); *credentials = NULL; break; } } else if (!strcmp(line, "-----END CERTIFICATE-----")) { if (!num_data) { /* * Missing data... */ httpFreeCredentials(*credentials); *credentials = NULL; break; } if (!*credentials) *credentials = cupsArrayNew(NULL, NULL); if (httpAddCredential(*credentials, data, num_data)) { httpFreeCredentials(*credentials); *credentials = NULL; break; } num_data = 0; } else { if (alloc_data == 0) { data = malloc(2048); alloc_data = 2048; if (!data) break; } else if ((num_data + strlen(line)) >= alloc_data) { unsigned char *tdata = realloc(data, alloc_data + 1024); /* Expanded buffer */ if (!tdata) { httpFreeCredentials(*credentials); *credentials = NULL; break; } data = tdata; alloc_data += 1024; } decoded = alloc_data - num_data; httpDecode64_2((char *)data + num_data, &decoded, line); num_data += (size_t)decoded; } } cupsFileClose(fp); if (num_data) { /* * Missing END CERTIFICATE... */ httpFreeCredentials(*credentials); *credentials = NULL; } if (data) free(data); return (*credentials ? 0 : -1); }
void email_message(const char *to, /* I - Recipient of message */ const char *subject, /* I - Subject of message */ const char *text) /* I - Text of message */ { cups_file_t *fp; /* Pipe/socket to mail server */ const char *nl; /* Newline to use */ char response[1024]; /* SMTP response buffer */ /* * Connect to the mail server... */ if (mailtoSendmail[0]) { /* * Use the sendmail command... */ fp = pipe_sendmail(to); if (!fp) return; nl = "\n"; } else { /* * Use an SMTP server... */ char hostbuf[1024]; /* Local hostname */ if (strchr(mailtoSMTPServer, ':')) fp = cupsFileOpen(mailtoSMTPServer, "s"); else { char spec[1024]; /* Host:service spec */ snprintf(spec, sizeof(spec), "%s:smtp", mailtoSMTPServer); fp = cupsFileOpen(spec, "s"); } if (!fp) { fprintf(stderr, "ERROR: Unable to connect to SMTP server \"%s\"!\n", mailtoSMTPServer); return; } fprintf(stderr, "DEBUG: Connected to \"%s\"...\n", mailtoSMTPServer); cupsFilePrintf(fp, "HELO %s\r\n", httpGetHostname(NULL, hostbuf, sizeof(hostbuf))); fprintf(stderr, "DEBUG: >>> HELO %s\n", hostbuf); if (!cupsFileGets(fp, response, sizeof(response)) || atoi(response) >= 500) goto smtp_error; fprintf(stderr, "DEBUG: <<< %s\n", response); cupsFilePrintf(fp, "MAIL FROM:%s\r\n", mailtoFrom); fprintf(stderr, "DEBUG: >>> MAIL FROM:%s\n", mailtoFrom); if (!cupsFileGets(fp, response, sizeof(response)) || atoi(response) >= 500) goto smtp_error; fprintf(stderr, "DEBUG: <<< %s\n", response); cupsFilePrintf(fp, "RCPT TO:%s\r\n", to); fprintf(stderr, "DEBUG: >>> RCPT TO:%s\n", to); if (!cupsFileGets(fp, response, sizeof(response)) || atoi(response) >= 500) goto smtp_error; fprintf(stderr, "DEBUG: <<< %s\n", response); cupsFilePuts(fp, "DATA\r\n"); fputs("DEBUG: DATA\n", stderr); if (!cupsFileGets(fp, response, sizeof(response)) || atoi(response) >= 500) goto smtp_error; fprintf(stderr, "DEBUG: <<< %s\n", response); nl = "\r\n"; } /* * Send the message... */ cupsFilePrintf(fp, "Date: %s%s", httpGetDateString(time(NULL)), nl); cupsFilePrintf(fp, "From: %s%s", mailtoFrom, nl); cupsFilePrintf(fp, "Subject: %s %s%s", mailtoSubject, subject, nl); if (mailtoReplyTo[0]) { cupsFilePrintf(fp, "Sender: %s%s", mailtoReplyTo, nl); cupsFilePrintf(fp, "Reply-To: %s%s", mailtoReplyTo, nl); } cupsFilePrintf(fp, "To: %s%s", to, nl); if (mailtoCc[0]) cupsFilePrintf(fp, "Cc: %s%s", mailtoCc, nl); cupsFilePrintf(fp, "Content-Type: text/plain%s", nl); cupsFilePuts(fp, nl); cupsFilePrintf(fp, "%s%s", text, nl); cupsFilePrintf(fp, ".\n", nl); /* * Close the connection to the mail server... */ if (mailtoSendmail[0]) { /* * Close the pipe and wait for the sendmail command to finish... */ int status; /* Exit status */ cupsFileClose(fp); if (wait(&status)) status = errno << 8; /* * Report any non-zero status... */ if (status) { if (WIFEXITED(status)) fprintf(stderr, "ERROR: Sendmail command returned status %d!\n", WEXITSTATUS(status)); else fprintf(stderr, "ERROR: Sendmail command crashed on signal %d!\n", WTERMSIG(status)); } } else { /* * Finish up the SMTP submission and close the connection... */ if (!cupsFileGets(fp, response, sizeof(response)) || atoi(response) >= 500) goto smtp_error; fprintf(stderr, "DEBUG: <<< %s\n", response); /* * Process SMTP errors here... */ smtp_error: cupsFilePuts(fp, "QUIT\r\n"); fputs("DEBUG: QUIT\n", stderr); if (!cupsFileGets(fp, response, sizeof(response)) || atoi(response) >= 500) goto smtp_error; fprintf(stderr, "DEBUG: <<< %s\n", response); cupsFileClose(fp); fprintf(stderr, "DEBUG: Closed connection to \"%s\"...\n", mailtoSMTPServer); } }
int /* O - Exit status */ main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { int status; /* Exit status */ char filename[1024]; /* Filename buffer */ cups_file_t *fp; /* File pointer */ #ifndef WIN32 int fds[2]; /* Open file descriptors */ cups_file_t *fdfile; /* File opened with cupsFileOpenFd() */ #endif /* !WIN32 */ int count; /* Number of lines in file */ if (argc == 1) { /* * Do uncompressed file tests... */ status = read_write_tests(0); #ifdef HAVE_LIBZ /* * Do compressed file tests... */ putchar('\n'); status += read_write_tests(1); #endif /* HAVE_LIBZ */ /* * Do uncompressed random I/O tests... */ status += random_tests(); #ifndef WIN32 /* * Test fdopen and close without reading... */ pipe(fds); close(fds[1]); fputs("\ncupsFileOpenFd(fd, \"r\"): ", stdout); fflush(stdout); if ((fdfile = cupsFileOpenFd(fds[0], "r")) == NULL) { puts("FAIL"); status ++; } else { /* * Able to open file, now close without reading. If we don't return * before the alarm fires, that is a failure and we will crash on the * alarm signal... */ puts("PASS"); fputs("cupsFileClose(no read): ", stdout); fflush(stdout); alarm(5); cupsFileClose(fdfile); alarm(0); puts("PASS"); } #endif /* !WIN32 */ /* * Count lines in psglyphs, rewind, then count again. */ fputs("\ncupsFileOpen(\"../data/media.defs\", \"r\"): ", stdout); if ((fp = cupsFileOpen("../data/media.defs", "r")) == NULL) { puts("FAIL"); status ++; } else { puts("PASS"); fputs("cupsFileGets: ", stdout); if ((count = count_lines(fp)) != 208) { printf("FAIL (got %d lines, expected 208)\n", count); status ++; } else { puts("PASS"); fputs("cupsFileRewind: ", stdout); if (cupsFileRewind(fp) != 0) { puts("FAIL"); status ++; } else { puts("PASS"); fputs("cupsFileGets: ", stdout); if ((count = count_lines(fp)) != 208) { printf("FAIL (got %d lines, expected 208)\n", count); status ++; } else puts("PASS"); } } cupsFileClose(fp); } /* * Test path functions... */ fputs("\ncupsFileFind: ", stdout); #ifdef WIN32 if (cupsFileFind("notepad.exe", "C:/WINDOWS", 1, filename, sizeof(filename)) && cupsFileFind("notepad.exe", "C:/WINDOWS;C:/WINDOWS/SYSTEM32", 1, filename, sizeof(filename))) #else if (cupsFileFind("cat", "/bin", 1, filename, sizeof(filename)) && cupsFileFind("cat", "/bin:/usr/bin", 1, filename, sizeof(filename))) #endif /* WIN32 */ printf("PASS (%s)\n", filename); else { puts("FAIL"); status ++; } /* * Summarize the results and return... */ if (!status) puts("\nALL TESTS PASSED!"); else printf("\n%d TEST(S) FAILED!\n", status); } else { /* * Cat the filename on the command-line... */ char line[1024]; /* Line from file */ if ((fp = cupsFileOpen(argv[1], "r")) == NULL) { perror(argv[1]); status = 1; } else { status = 0; while (cupsFileGets(fp, line, sizeof(line))) puts(line); if (!cupsFileEOF(fp)) perror(argv[1]); cupsFileClose(fp); } } return (status); }
char * /* O - Line read or @code NULL@ on end of file or error */ cupsFileGetConf(cups_file_t *fp, /* I - CUPS file */ char *buf, /* O - String buffer */ size_t buflen, /* I - Size of string buffer */ char **value, /* O - Pointer to value */ int *linenum) /* IO - Current line number */ { char *ptr; /* Pointer into line */ /* * Range check input... */ DEBUG_printf(("2cupsFileGetConf(fp=%p, buf=%p, buflen=" CUPS_LLFMT ", value=%p, linenum=%p)", fp, buf, CUPS_LLCAST buflen, value, linenum)); if (!fp || (fp->mode != 'r' && fp->mode != 's') || !buf || buflen < 2 || !value) { if (value) *value = NULL; return (NULL); } /* * Read the next non-comment line... */ *value = NULL; while (cupsFileGets(fp, buf, buflen)) { (*linenum) ++; /* * Strip any comments... */ if ((ptr = strchr(buf, '#')) != NULL) { if (ptr > buf && ptr[-1] == '\\') { // Unquote the #... _cups_strcpy(ptr - 1, ptr); } else { // Strip the comment and any trailing whitespace... while (ptr > buf) { if (!_cups_isspace(ptr[-1])) break; ptr --; } *ptr = '\0'; } } /* * Strip leading whitespace... */ for (ptr = buf; _cups_isspace(*ptr); ptr ++); if (ptr > buf) _cups_strcpy(buf, ptr); /* * See if there is anything left... */ if (buf[0]) { /* * Yes, grab any value and return... */ for (ptr = buf; *ptr; ptr ++) if (_cups_isspace(*ptr)) break; if (*ptr) { /* * Have a value, skip any other spaces... */ while (_cups_isspace(*ptr)) *ptr++ = '\0'; if (*ptr) *value = ptr; /* * Strip trailing whitespace and > for lines that begin with <... */ ptr += strlen(ptr) - 1; if (buf[0] == '<' && *ptr == '>') *ptr-- = '\0'; else if (buf[0] == '<' && *ptr != '>') { /* * Syntax error... */ *value = NULL; return (buf); } while (ptr > *value && _cups_isspace(*ptr)) *ptr-- = '\0'; } /* * Return the line... */ return (buf); } } return (NULL); }
static int /* O - 0 = success, -1 = error */ help_load_file( help_index_t *hi, /* I - Index */ const char *filename, /* I - Filename */ const char *relative, /* I - Relative path */ time_t mtime) /* I - Modification time */ { cups_file_t *fp; /* HTML file */ help_node_t *node; /* Current node */ char line[1024], /* Line from file */ temp[1024], /* Temporary word */ section[1024], /* Section */ *ptr, /* Pointer into line */ *anchor, /* Anchor name */ *text; /* Text for anchor */ off_t offset; /* File offset */ char quote; /* Quote character */ help_word_t *word; /* Current word */ int wordlen; /* Length of word */ DEBUG_printf(("2help_load_file(hi=%p, filename=\"%s\", relative=\"%s\", " "mtime=%ld)", hi, filename, relative, mtime)); if ((fp = cupsFileOpen(filename, "r")) == NULL) return (-1); node = NULL; offset = 0; strlcpy(section, "Other", sizeof(section)); while (cupsFileGets(fp, line, sizeof(line))) { /* * Look for "<TITLE>", "<A NAME", or "<!-- SECTION:" prefix... */ if (!_cups_strncasecmp(line, "<!-- SECTION:", 13)) { /* * Got section line, copy it! */ for (ptr = line + 13; isspace(*ptr & 255); ptr ++); strlcpy(section, ptr, sizeof(section)); if ((ptr = strstr(section, "-->")) != NULL) { /* * Strip comment stuff from end of line... */ for (*ptr-- = '\0'; ptr > line && isspace(*ptr & 255); *ptr-- = '\0'); if (isspace(*ptr & 255)) *ptr = '\0'; } continue; } for (ptr = line; (ptr = strchr(ptr, '<')) != NULL;) { ptr ++; if (!_cups_strncasecmp(ptr, "TITLE>", 6)) { /* * Found the title... */ anchor = NULL; ptr += 6; } else if (!_cups_strncasecmp(ptr, "A NAME=", 7)) { /* * Found an anchor... */ ptr += 7; if (*ptr == '\"' || *ptr == '\'') { /* * Get quoted anchor... */ quote = *ptr; anchor = ptr + 1; if ((ptr = strchr(anchor, quote)) != NULL) *ptr++ = '\0'; else break; } else { /* * Get unquoted anchor... */ anchor = ptr + 1; for (ptr = anchor; *ptr && *ptr != '>' && !isspace(*ptr & 255); ptr ++); if (*ptr) *ptr++ = '\0'; else break; } /* * Got the anchor, now lets find the end... */ while (*ptr && *ptr != '>') ptr ++; if (*ptr != '>') break; ptr ++; } else continue; /* * Now collect text for the link... */ text = ptr; while ((ptr = strchr(text, '<')) == NULL) { ptr = text + strlen(text); if (ptr >= (line + sizeof(line) - 2)) break; *ptr++ = ' '; if (!cupsFileGets(fp, ptr, sizeof(line) - (ptr - line) - 1)) break; } *ptr = '\0'; if (node) node->length = offset - node->offset; if (!*text) { node = NULL; break; } if ((node = helpFindNode(hi, relative, anchor)) != NULL) { /* * Node already in the index, so replace the text and other * data... */ cupsArrayRemove(hi->nodes, node); if (node->section) free(node->section); if (node->text) free(node->text); if (node->words) { for (word = (help_word_t *)cupsArrayFirst(node->words); word; word = (help_word_t *)cupsArrayNext(node->words)) help_delete_word(word); cupsArrayDelete(node->words); node->words = NULL; } node->section = section[0] ? strdup(section) : NULL; node->text = strdup(text); node->mtime = mtime; node->offset = offset; node->score = 0; } else { /* * New node... */ node = help_new_node(relative, anchor, section, text, mtime, offset, 0); } /* * Go through the text value and replace tabs and newlines with * whitespace and eliminate extra whitespace... */ for (ptr = node->text, text = node->text; *ptr;) if (isspace(*ptr & 255)) { while (isspace(*ptr & 255)) ptr ++; *text++ = ' '; } else if (text != ptr) *text++ = *ptr++; else { text ++; ptr ++; } *text = '\0'; /* * (Re)add the node to the array... */ cupsArrayAdd(hi->nodes, node); if (!anchor) node = NULL; break; } if (node) { /* * Scan this line for words... */ for (ptr = line; *ptr; ptr ++) { /* * Skip HTML stuff... */ if (*ptr == '<') { if (!strncmp(ptr, "<!--", 4)) { /* * Skip HTML comment... */ if ((text = strstr(ptr + 4, "-->")) == NULL) ptr += strlen(ptr) - 1; else ptr = text + 2; } else { /* * Skip HTML element... */ for (ptr ++; *ptr && *ptr != '>'; ptr ++) { if (*ptr == '\"' || *ptr == '\'') { for (quote = *ptr++; *ptr && *ptr != quote; ptr ++); if (!*ptr) ptr --; } } if (!*ptr) ptr --; } continue; } else if (*ptr == '&') { /* * Skip HTML entity... */ for (ptr ++; *ptr && *ptr != ';'; ptr ++); if (!*ptr) ptr --; continue; } else if (!isalnum(*ptr & 255)) continue; /* * Found the start of a word, search until we find the end... */ for (text = ptr, ptr ++; *ptr && isalnum(*ptr & 255); ptr ++); wordlen = ptr - text; memcpy(temp, text, wordlen); temp[wordlen] = '\0'; ptr --; if (wordlen > 1 && !bsearch(temp, help_common_words, (sizeof(help_common_words) / sizeof(help_common_words[0])), sizeof(help_common_words[0]), (int (*)(const void *, const void *)) _cups_strcasecmp)) help_add_word(node, temp); } } /* * Get the offset of the next line... */ offset = cupsFileTell(fp); } cupsFileClose(fp); if (node) node->length = offset - node->offset; return (0); }
int /* O - Exit code */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ const char *pofile, /* .po filename */ *stringsfile; /* .strings filename */ cups_file_t *po, /* .po file */ *strings; /* .strings file */ char s[4096], /* String buffer */ *ptr, /* Pointer into buffer */ *temp, /* New string */ *msgid, /* msgid string */ *msgstr, /* msgstr string */ normalized[8192];/* Normalized msgid string */ size_t length; /* Length of combined strings */ int use_msgid; /* Use msgid strings for msgstr? */ /* * Process command-line arguments... */ pofile = NULL; stringsfile = NULL; use_msgid = 0; for (i = 1; i < argc; i ++) { if (!strcmp(argv[i], "-m")) use_msgid = 1; else if (argv[i][0] == '-') { puts("Usage: po2strings [-m] filename.po filename.strings"); return (1); } else if (!pofile) pofile = argv[i]; else if (!stringsfile) stringsfile = argv[i]; else { puts("Usage: po2strings [-m] filename.po filename.strings"); return (1); } } if (!pofile || !stringsfile) { puts("Usage: po2strings [-m] filename.po filename.strings"); return (1); } /* * Read strings from the .po file and write to the .strings file... */ if ((po = cupsFileOpen(pofile, "r")) == NULL) { perror(pofile); return (1); } if ((strings = cupsFileOpen(stringsfile, "w")) == NULL) { perror(stringsfile); cupsFileClose(po); return (1); } msgid = msgstr = NULL; while (cupsFileGets(po, s, sizeof(s)) != NULL) { if (s[0] == '#' && s[1] == '.') { /* * Copy comment string... */ if (msgid && msgstr) { /* * First output the last localization string... */ if (*msgid) cupsFilePrintf(strings, "\"%s\" = \"%s\";\n", msgid, (use_msgid || !*msgstr) ? msgid : msgstr); free(msgid); free(msgstr); msgid = msgstr = NULL; } cupsFilePrintf(strings, "//%s\n", s + 2); } else if (s[0] == '#' || !s[0]) { /* * Skip blank and file comment lines... */ continue; } else { /* * Strip the trailing quote... */ if ((ptr = strrchr(s, '\"')) == NULL) continue; *ptr = '\0'; /* * Find start of value... */ if ((ptr = strchr(s, '\"')) == NULL) continue; ptr ++; /* * Create or add to a message... */ if (!strncmp(s, "msgid", 5)) { /* * Output previous message as needed... */ if (msgid && msgstr) { if (*msgid) cupsFilePrintf(strings, "\"%s\" = \"%s\";\n", msgid, normalize_string((use_msgid || !*msgstr) ? msgid : msgstr, normalized, sizeof(normalized))); } if (msgid) free(msgid); if (msgstr) free(msgstr); msgid = strdup(ptr); msgstr = NULL; } else if (s[0] == '\"' && (msgid || msgstr)) { /* * Append to current string... */ size_t ptrlen = strlen(ptr); /* Length of string */ length = strlen(msgstr ? msgstr : msgid); if ((temp = realloc(msgstr ? msgstr : msgid, length + ptrlen + 1)) == NULL) { free(msgid); if (msgstr) free(msgstr); perror("Unable to allocate string"); return (1); } if (msgstr) { /* * Copy the new portion to the end of the msgstr string - safe * to use strcpy because the buffer is allocated to the correct * size... */ msgstr = temp; memcpy(msgstr + length, ptr, ptrlen + 1); } else { /* * Copy the new portion to the end of the msgid string - safe * to use strcpy because the buffer is allocated to the correct * size... */ msgid = temp; memcpy(msgid + length, ptr, ptrlen + 1); } } else if (!strncmp(s, "msgstr", 6) && msgid) { /* * Set the string... */ if (msgstr) free(msgstr); if ((msgstr = strdup(ptr)) == NULL) { free(msgid); perror("Unable to allocate msgstr"); return (1); } } } } if (msgid && msgstr) { if (*msgid) cupsFilePrintf(strings, "\"%s\" = \"%s\";\n", msgid, normalize_string((use_msgid || !*msgstr) ? msgid : msgstr, normalized, sizeof(normalized))); } if (msgid) free(msgid); if (msgstr) free(msgstr); cupsFileClose(po); cupsFileClose(strings); return (0); }
static void mime_load_types(mime_t *mime, /* I - MIME database */ const char *filename) /* I - Types file to load */ { cups_file_t *fp; /* Types file */ int linelen; /* Length of line */ char line[32768], /* Input line from file */ *lineptr, /* Current position in line */ super[MIME_MAX_SUPER], /* Super-type name */ type[MIME_MAX_TYPE], /* Type name */ *temp; /* Temporary pointer */ mime_type_t *typeptr; /* New MIME type */ DEBUG_printf(("2mime_load_types(mime=%p, filename=\"%s\")", mime, filename)); /* * First try to open the file... */ if ((fp = cupsFileOpen(filename, "r")) == NULL) { DEBUG_printf(("3mime_load_types: Unable to open \"%s\": %s", filename, strerror(errno))); _mimeError(mime, "Unable to open \"%s\": %s", filename, strerror(errno)); return; } /* * Then read each line from the file, skipping any comments in the file... */ while (cupsFileGets(fp, line, sizeof(line)) != NULL) { /* * Skip blank lines and lines starting with a #... */ if (!line[0] || line[0] == '#') continue; /* * While the last character in the line is a backslash, continue on to the * next line (and the next, etc.) */ linelen = strlen(line); while (line[linelen - 1] == '\\') { linelen --; if (cupsFileGets(fp, line + linelen, sizeof(line) - linelen) == NULL) line[linelen] = '\0'; else linelen += strlen(line + linelen); } /* * Extract the super-type and type names from the beginning of the line. */ lineptr = line; temp = super; while (*lineptr != '/' && *lineptr != '\n' && *lineptr != '\0' && (temp - super + 1) < MIME_MAX_SUPER) *temp++ = tolower(*lineptr++ & 255); *temp = '\0'; if (*lineptr != '/') continue; lineptr ++; temp = type; while (*lineptr != ' ' && *lineptr != '\t' && *lineptr != '\n' && *lineptr != '\0' && (temp - type + 1) < MIME_MAX_TYPE) *temp++ = tolower(*lineptr++ & 255); *temp = '\0'; /* * Add the type and rules to the MIME database... */ typeptr = mimeAddType(mime, super, type); mimeAddTypeRule(typeptr, lineptr); } cupsFileClose(fp); }
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); }