static void service_checkout(void) { int fd; /* File descriptor */ /* * Create or remove the "keep-alive" file based on whether there are active * jobs or shared printers to advertise... */ if (cupsArrayCount(ActiveJobs) || /* Active jobs */ WebInterface || /* Web interface enabled */ NeedReload || /* Doing a reload */ (Browsing && BrowseLocalProtocols && cupsArrayCount(Printers))) /* Printers being shared */ { cupsdLogMessage(CUPSD_LOG_DEBUG, "Creating keep-alive file \"" CUPS_KEEPALIVE "\"."); if ((fd = open(CUPS_KEEPALIVE, O_RDONLY | O_CREAT | O_EXCL, S_IRUSR)) >= 0) close(fd); } else { cupsdLogMessage(CUPSD_LOG_DEBUG, "Removing keep-alive file \"" CUPS_KEEPALIVE "\"."); unlink(CUPS_KEEPALIVE); } }
static void launchd_checkout(void) { int fd; /* File descriptor */ /* * Create or remove the launchd KeepAlive file based on whether * there are active jobs, polling, browsing for remote printers or * shared printers to advertise... */ if (cupsArrayCount(ActiveJobs) || (Browsing && BrowseLocalProtocols && cupsArrayCount(Printers))) { cupsdLogMessage(CUPSD_LOG_DEBUG, "Creating launchd keepalive file \"" CUPS_KEEPALIVE "\"..."); if ((fd = open(CUPS_KEEPALIVE, O_RDONLY | O_CREAT | O_EXCL, S_IRUSR)) >= 0) close(fd); } else { cupsdLogMessage(CUPSD_LOG_DEBUG, "Removing launchd keepalive file \"" CUPS_KEEPALIVE "\"..."); unlink(CUPS_KEEPALIVE); } }
void cupsdPauseListening(void) { cupsd_listener_t *lis; /* Current listening socket */ if (cupsArrayCount(Listeners) < 1) return; if (cupsArrayCount(Clients) == MaxClients) cupsdLogMessage(CUPSD_LOG_WARN, "Max clients reached, holding new connections..."); else if (errno == ENFILE || errno == EMFILE) cupsdLogMessage(CUPSD_LOG_WARN, "Too many open files, holding new connections for " "30 seconds..."); cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdPauseListening: Clearing input bits..."); for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners); lis; lis = (cupsd_listener_t *)cupsArrayNext(Listeners)) cupsdRemoveSelect(lis->fd); ListeningPaused = time(NULL) + 30; }
static int /* O - Result of comparison */ compare_sections_files( _cups_section_t *a, /* I - First section */ _cups_section_t *b) /* I - Second section */ { int ret = cupsArrayCount(b->files) - cupsArrayCount(a->files); if (ret) return (ret); else return (_cups_strcasecmp(a->name, b->name)); }
const char * /* O - Localized string */ cupsLocalizeDestOption( http_t *http, /* I - Connection to destination */ cups_dest_t *dest, /* I - Destination */ cups_dinfo_t *dinfo, /* I - Destination information */ const char *option) /* I - Option to localize */ { _cups_message_t key, /* Search key */ *match; /* Matching entry */ if (!http || !dest || !dinfo) return (option); if (!dinfo->localizations) cups_create_localizations(http, dinfo); if (cupsArrayCount(dinfo->localizations) == 0) return (option); key.id = (char *)option; if ((match = (_cups_message_t *)cupsArrayFind(dinfo->localizations, &key)) != NULL) return (match->str); else return (option); }
void _cupsStrFlush(void) { _cups_sp_item_t *item; /* Current item */ // DEBUG_printf(("_cupsStrFlush(cg=%p)\n", cg)); DEBUG_printf((" %d strings in array\n", cupsArrayCount(stringpool))); #ifdef HAVE_PTHREAD_H pthread_mutex_lock(&sp_mutex); #endif /* HAVE_PTHREAD_H */ for (item = (_cups_sp_item_t *)cupsArrayFirst(stringpool); item; item = (_cups_sp_item_t *)cupsArrayNext(stringpool)) { free(item->str); free(item); } cupsArrayDelete(stringpool); stringpool = NULL; #ifdef HAVE_PTHREAD_H pthread_mutex_unlock(&sp_mutex); #endif /* HAVE_PTHREAD_H */ }
void serverCleanJobs(server_printer_t *printer) /* I - Printer */ { server_job_t *job; /* Current job */ time_t cleantime; /* Clean time */ if (cupsArrayCount(printer->jobs) == 0) return; cleantime = time(NULL) - 60; _cupsRWLockWrite(&(printer->rwlock)); for (job = (server_job_t *)cupsArrayFirst(printer->jobs); job; job = (server_job_t *)cupsArrayNext(printer->jobs)) if (job->completed && job->completed < cleantime) { cupsArrayRemove(printer->jobs, job); serverDeleteJob(job); } else break; _cupsRWUnlock(&(printer->rwlock)); }
static void list_nodes(help_index_t *hi, /* I - Help index */ const char *title, /* I - Title string */ cups_array_t *nodes) /* I - Nodes */ { help_node_t *node, /* Current node */ *file; /* File node */ printf("%d\n", cupsArrayCount(nodes)); for (node = (help_node_t *)cupsArrayFirst(nodes); node; node = (help_node_t *)cupsArrayNext(nodes)) { if (node->anchor) { file = helpFindNode(hi, node->filename, NULL); printf("%d|%s#%s|%s|%s\n", node->score, node->filename, node->anchor, node->text, file ? file->text : node->filename); } else printf("%d|%s|%s|%s\n", node->score, node->filename, node->text, node->text); } }
const char * /* O - Localized string */ cupsLocalizeDestValue( http_t *http, /* I - Connection to destination */ cups_dest_t *dest, /* I - Destination */ cups_dinfo_t *dinfo, /* I - Destination information */ const char *option, /* I - Option to localize */ const char *value) /* I - Value to localize */ { _cups_message_t key, /* Search key */ *match; /* Matching entry */ char pair[256]; /* option.value pair */ if (!http || !dest || !dinfo) return (value); if (!dinfo->localizations) cups_create_localizations(http, dinfo); if (cupsArrayCount(dinfo->localizations) == 0) return (value); snprintf(pair, sizeof(pair), "%s.%s", option, value); key.id = pair; if ((match = (_cups_message_t *)cupsArrayFind(dinfo->localizations, &key)) != NULL) return (match->str); else return (value); }
server_printer_t * /* O - Printer or NULL */ serverFindPrinter(const char *resource) /* I - Resource path */ { server_printer_t key, /* Search key */ *match = NULL; /* Matching printer */ _cupsMutexLock(&printer_mutex); if (cupsArrayCount(Printers) == 1 || !strcmp(resource, "/ipp/print")) { /* * Just use the first printer... */ match = cupsArrayFirst(Printers); if (strcmp(match->resource, resource) && strcmp(resource, "/ipp/print")) match = NULL; } else { key.resource = (char *)resource; match = (server_printer_t *)cupsArrayFind(Printers, &key); } _cupsMutexUnlock(&printer_mutex); return (match); }
int mimeNumTypes(mime_t *mime) /* I - MIME database */ { if (!mime) return (0); else return (cupsArrayCount(mime->types)); }
int mimeNumFilters(mime_t *mime) /* I - MIME database */ { if (!mime) return (0); else return (cupsArrayCount(mime->filters)); }
int mimeNumTypes(mime_t *mime) /* I - MIME database */ { DEBUG_printf(("mimeNumTypes(mime=%p)", mime)); if (!mime) { DEBUG_puts("1mimeNumTypes: Returning 0."); return (0); } else { DEBUG_printf(("1mimeNumTypes: Returning %d.", cupsArrayCount(mime->types))); return (cupsArrayCount(mime->types)); } }
int /* O - Exit code */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { FILE *strings; /* .strings file */ cups_array_t *po; /* .po file */ char iconv[1024]; /* iconv command */ _cups_message_t *msg; /* Current message */ if (argc != 3) { puts("Usage: po2strings filename.po filename.strings"); return (1); } /* * Use the CUPS .po loader to get the message strings... */ if ((po = _cupsMessageLoad(argv[1])) == NULL) { perror(argv[1]); return (1); } /* * Cheat by using iconv to write the .strings file with a UTF-16 encoding. * The .po file uses UTF-8... */ snprintf(iconv, sizeof(iconv), "iconv -f utf-8 -t utf-16 >'%s'", argv[2]); if ((strings = popen(iconv, "w")) == NULL) { perror(argv[2]); _cupsMessageFree(po); return (1); } for (msg = (_cups_message_t *)cupsArrayFirst(po); msg; msg = (_cups_message_t *)cupsArrayNext(po)) { write_string(strings, msg->id); fputs(" = ", strings); write_string(strings, msg->str); fputs(";\n", strings); } printf("%s: %d messages.\n", argv[2], cupsArrayCount(po)); pclose(strings); _cupsMessageFree(po); return (0); }
int /* O - Number of conflicts found */ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */ { int i, /* Looping variable */ conflicts; /* Number of conflicts */ cups_array_t *active; /* Active conflicts */ _ppd_cups_uiconsts_t *c; /* Current constraints */ _ppd_cups_uiconst_t *cptr; /* Current constraint */ ppd_option_t *o; /* Current option */ if (!ppd) return (0); /* * Clear all conflicts... */ cupsArraySave(ppd->options); for (o = ppdFirstOption(ppd); o; o = ppdNextOption(ppd)) o->conflicted = 0; cupsArrayRestore(ppd->options); /* * Test for conflicts... */ active = ppd_test_constraints(ppd, NULL, NULL, 0, NULL, _PPD_ALL_CONSTRAINTS); conflicts = cupsArrayCount(active); /* * Loop through all of the UI constraints and flag any options * that conflict... */ for (c = (_ppd_cups_uiconsts_t *)cupsArrayFirst(active); c; c = (_ppd_cups_uiconsts_t *)cupsArrayNext(active)) { for (i = c->num_constraints, cptr = c->constraints; i > 0; i --, cptr ++) cptr->option->conflicted = 1; } cupsArrayDelete(active); /* * Return the number of conflicts found... */ return (conflicts); }
void cupsdSetBusyState(void) { int newbusy; /* New busy state */ static int busy = 0; /* Current busy state */ static const char * const busy_text[] = { /* Text for busy states */ "Not busy", "Dirty files", "Printing jobs", "Printing jobs and dirty files", "Active clients", "Active clients and dirty files", "Active clients and printing jobs", "Active clients, printing jobs, and dirty files" }; #ifdef HAVE_VPROC_TRANSACTION_BEGIN static vproc_transaction_t vtran = 0; /* Current busy transaction */ #endif /* HAVE_VPROC_TRANSACTION_BEGIN */ newbusy = (DirtyCleanTime ? 1 : 0) | (cupsArrayCount(PrintingJobs) ? 2 : 0) | (cupsArrayCount(ActiveClients) ? 4 : 0); if (newbusy != busy) { busy = newbusy; #ifdef HAVE_VPROC_TRANSACTION_BEGIN if (busy && !vtran) vtran = vproc_transaction_begin(NULL); else if (!busy && vtran) { vproc_transaction_end(NULL, vtran); vtran = 0; } #endif /* HAVE_VPROC_TRANSACTION_BEGIN */ cupsdLogMessage(CUPSD_LOG_DEBUG, "cupsdSetBusyState: %s", busy_text[busy]); } }
static void list_nodes(const char *title, /* I - Title string */ cups_array_t *nodes) /* I - Nodes */ { int i; /* Looping var */ help_node_t *node; /* Current node */ printf("%s (%d nodes):\n", title, cupsArrayCount(nodes)); for (i = 1, node = (help_node_t *)cupsArrayFirst(nodes); node; i ++, node = (help_node_t *)cupsArrayNext(nodes)) { if (node->anchor) printf(" %d: %s#%s \"%s\"", i, node->filename, node->anchor, node->text); else printf(" %d: %s \"%s\"", i, node->filename, node->text); printf(" (%d words)\n", cupsArrayCount(node->words)); } }
int /* O - Status of call (0 = success) */ cupsSetCredentials( cups_array_t *credentials) /* I - Array of credentials */ { _cups_globals_t *cg = _cupsGlobals(); /* Pointer to library globals */ if (cupsArrayCount(credentials) < 1) return (-1); _httpFreeCredentials(cg->tls_credentials); cg->tls_credentials = _httpCreateCredentials(credentials); return (cg->tls_credentials ? 0 : -1); }
ppd_attr_t * /* O - Attribute or @code NULL@ if not found */ ppdFindNextAttr(ppd_file_t *ppd, /* I - PPD file data */ const char *name, /* I - Attribute name */ const char *spec) /* I - Specifier string or @code NULL@ */ { ppd_attr_t *attr; /* Current attribute */ /* * Range check input... */ if (!ppd || !name || ppd->num_attrs == 0) return (NULL); /* * See if there are more attributes to return... */ while ((attr = (ppd_attr_t *)cupsArrayNext(ppd->sorted_attrs)) != NULL) { /* * Check the next attribute to see if it is a match... */ if (_cups_strcasecmp(attr->name, name)) { /* * Nope, reset the current pointer to the end of the array... */ cupsArrayIndex(ppd->sorted_attrs, cupsArrayCount(ppd->sorted_attrs)); return (NULL); } if (!spec || !_cups_strcasecmp(attr->spec, spec)) break; } /* * Return the next attribute's value... */ return (attr); }
void cupsdResumeListening(void) { cupsd_listener_t *lis; /* Current listening socket */ if (cupsArrayCount(Listeners) < 1) return; cupsdLogMessage(CUPSD_LOG_INFO, "Resuming new connection processing..."); cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdResumeListening: Setting input bits..."); for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners); lis; lis = (cupsd_listener_t *)cupsArrayNext(Listeners)) cupsdAddSelect(lis->fd, (cupsd_selfunc_t)cupsdAcceptClient, NULL, lis); ListeningPaused = 0; }
void _cupsStrFlush(void) { _cups_sp_item_t *item; /* Current item */ DEBUG_printf(("4_cupsStrFlush: %d strings in array", cupsArrayCount(stringpool))); _cupsMutexLock(&sp_mutex); for (item = (_cups_sp_item_t *)cupsArrayFirst(stringpool); item; item = (_cups_sp_item_t *)cupsArrayNext(stringpool)) free(item); cupsArrayDelete(stringpool); stringpool = NULL; _cupsMutexUnlock(&sp_mutex); }
void cupsdDeleteAllListeners(void) { cupsd_listener_t *lis; /* Current listening socket */ for (lis = (cupsd_listener_t *)cupsArrayFirst(Listeners); lis; lis = (cupsd_listener_t *)cupsArrayNext(Listeners)) #if defined(HAVE_LAUNCHD) || defined(HAVE_SYSTEMD) if (!lis->on_demand) #endif /* HAVE_LAUNCHD || HAVE_SYSTEMD */ { cupsArrayRemove(Listeners, lis); free(lis); } if (cupsArrayCount(Listeners) == 0) { cupsArrayDelete(Listeners); Listeners = NULL; } }
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 arguments */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ cups_array_t *array, /* Test array */ *dup_array; /* Duplicate array */ int status; /* Exit status */ char *text; /* Text from array */ char word[256]; /* Word from file */ double start, /* Start time */ end; /* End time */ cups_dir_t *dir; /* Current directory */ cups_dentry_t *dent; /* Directory entry */ char *saved[32]; /* Saved entries */ void *data; /* User data for arrays */ /* * No errors so far... */ status = 0; /* * cupsArrayNew() */ fputs("cupsArrayNew: ", stdout); data = (void *)"testarray"; array = cupsArrayNew((cups_array_func_t)strcmp, data); if (array) puts("PASS"); else { puts("FAIL (returned NULL, expected pointer)"); status ++; } /* * cupsArrayUserData() */ fputs("cupsArrayUserData: ", stdout); if (cupsArrayUserData(array) == data) puts("PASS"); else { printf("FAIL (returned %p instead of %p!)\n", cupsArrayUserData(array), data); status ++; } /* * cupsArrayAdd() */ fputs("cupsArrayAdd: ", stdout); if (!cupsArrayAdd(array, strdup("One Fish"))) { puts("FAIL (\"One Fish\")"); status ++; } else { if (!cupsArrayAdd(array, strdup("Two Fish"))) { puts("FAIL (\"Two Fish\")"); status ++; } else { if (!cupsArrayAdd(array, strdup("Red Fish"))) { puts("FAIL (\"Red Fish\")"); status ++; } else { if (!cupsArrayAdd(array, strdup("Blue Fish"))) { puts("FAIL (\"Blue Fish\")"); status ++; } else puts("PASS"); } } } /* * cupsArrayCount() */ fputs("cupsArrayCount: ", stdout); if (cupsArrayCount(array) == 4) puts("PASS"); else { printf("FAIL (returned %d, expected 4)\n", cupsArrayCount(array)); status ++; } /* * cupsArrayFirst() */ fputs("cupsArrayFirst: ", stdout); if ((text = (char *)cupsArrayFirst(array)) != NULL && !strcmp(text, "Blue Fish")) puts("PASS"); else { printf("FAIL (returned \"%s\", expected \"Blue Fish\")\n", text); status ++; } /* * cupsArrayNext() */ fputs("cupsArrayNext: ", stdout); if ((text = (char *)cupsArrayNext(array)) != NULL && !strcmp(text, "One Fish")) puts("PASS"); else { printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text); status ++; } /* * cupsArrayLast() */ fputs("cupsArrayLast: ", stdout); if ((text = (char *)cupsArrayLast(array)) != NULL && !strcmp(text, "Two Fish")) puts("PASS"); else { printf("FAIL (returned \"%s\", expected \"Two Fish\")\n", text); status ++; } /* * cupsArrayPrev() */ fputs("cupsArrayPrev: ", stdout); if ((text = (char *)cupsArrayPrev(array)) != NULL && !strcmp(text, "Red Fish")) puts("PASS"); else { printf("FAIL (returned \"%s\", expected \"Red Fish\")\n", text); status ++; } /* * cupsArrayFind() */ fputs("cupsArrayFind: ", stdout); if ((text = (char *)cupsArrayFind(array, (void *)"One Fish")) != NULL && !strcmp(text, "One Fish")) puts("PASS"); else { printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text); status ++; } /* * cupsArrayCurrent() */ fputs("cupsArrayCurrent: ", stdout); if ((text = (char *)cupsArrayCurrent(array)) != NULL && !strcmp(text, "One Fish")) puts("PASS"); else { printf("FAIL (returned \"%s\", expected \"One Fish\")\n", text); status ++; } /* * cupsArrayDup() */ fputs("cupsArrayDup: ", stdout); if ((dup_array = cupsArrayDup(array)) != NULL && cupsArrayCount(dup_array) == 4) puts("PASS"); else { printf("FAIL (returned %p with %d elements, expected pointer with 4 elements)\n", dup_array, cupsArrayCount(dup_array)); status ++; } /* * cupsArrayRemove() */ fputs("cupsArrayRemove: ", stdout); if (cupsArrayRemove(array, (void *)"One Fish") && cupsArrayCount(array) == 3) puts("PASS"); else { printf("FAIL (returned 0 with %d elements, expected 1 with 4 elements)\n", cupsArrayCount(array)); status ++; } /* * cupsArrayClear() */ fputs("cupsArrayClear: ", stdout); cupsArrayClear(array); if (cupsArrayCount(array) == 0) puts("PASS"); else { printf("FAIL (%d elements, expected 0 elements)\n", cupsArrayCount(array)); status ++; } /* * Now load this source file and grab all of the unique words... */ fputs("Load unique words: ", stdout); fflush(stdout); start = get_seconds(); if ((dir = cupsDirOpen(".")) == NULL) { puts("FAIL (cupsDirOpen failed)"); status ++; } else { while ((dent = cupsDirRead(dir)) != NULL) { i = strlen(dent->filename) - 2; if (i > 0 && dent->filename[i] == '.' && (dent->filename[i + 1] == 'c' || dent->filename[i + 1] == 'h')) load_words(dent->filename, array); } cupsDirClose(dir); end = get_seconds(); printf("%d words in %.3f seconds (%.0f words/sec), ", cupsArrayCount(array), end - start, cupsArrayCount(array) / (end - start)); fflush(stdout); for (text = (char *)cupsArrayFirst(array); text;) { /* * Copy this word to the word buffer (safe because we strdup'd from * the same buffer in the first place... :) */ strlcpy(word, text, sizeof(word)); /* * Grab the next word and compare... */ if ((text = (char *)cupsArrayNext(array)) == NULL) break; if (strcmp(word, text) >= 0) break; } if (text) { printf("FAIL (\"%s\" >= \"%s\"!)\n", word, text); status ++; } else puts("PASS"); } /* * Test deleting with iteration... */ fputs("Delete While Iterating: ", stdout); text = (char *)cupsArrayFirst(array); cupsArrayRemove(array, text); free(text); text = (char *)cupsArrayNext(array); if (!text) { puts("FAIL (cupsArrayNext returned NULL!)"); status ++; } else puts("PASS"); /* * Test save/restore... */ fputs("cupsArraySave: ", stdout); for (i = 0, text = (char *)cupsArrayFirst(array); i < 32; i ++, text = (char *)cupsArrayNext(array)) { saved[i] = text; if (!cupsArraySave(array)) break; } if (i < 32) printf("FAIL (depth = %d)\n", i); else puts("PASS"); fputs("cupsArrayRestore: ", stdout); while (i > 0) { i --; text = cupsArrayRestore(array); if (text != saved[i]) break; } if (i) printf("FAIL (depth = %d)\n", i); else puts("PASS"); /* * Delete the arrays... */ cupsArrayDelete(array); cupsArrayDelete(dup_array); /* * Test the array with string functions... */ fputs("_cupsArrayNewStrings(\" \\t\\nfoo bar\\tboo\\nfar\", ' '): ", stdout); array = _cupsArrayNewStrings(" \t\nfoo bar\tboo\nfar", ' '); if (!array) { status = 1; puts("FAIL (unable to create array)"); } else if (cupsArrayCount(array) != 4) { status = 1; printf("FAIL (got %d elements, expected 4)\n", cupsArrayCount(array)); } else if (strcmp(text = (char *)cupsArrayFirst(array), "bar")) { status = 1; printf("FAIL (first element \"%s\", expected \"bar\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "boo")) { status = 1; printf("FAIL (first element \"%s\", expected \"boo\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "far")) { status = 1; printf("FAIL (first element \"%s\", expected \"far\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "foo")) { status = 1; printf("FAIL (first element \"%s\", expected \"foo\")\n", text); } else puts("PASS"); fputs("_cupsArrayAddStrings(array, \"foo2,bar2\", ','): ", stdout); _cupsArrayAddStrings(array, "foo2,bar2", ','); if (cupsArrayCount(array) != 6) { status = 1; printf("FAIL (got %d elements, expected 6)\n", cupsArrayCount(array)); } else if (strcmp(text = (char *)cupsArrayFirst(array), "bar")) { status = 1; printf("FAIL (first element \"%s\", expected \"bar\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "bar2")) { status = 1; printf("FAIL (first element \"%s\", expected \"bar2\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "boo")) { status = 1; printf("FAIL (first element \"%s\", expected \"boo\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "far")) { status = 1; printf("FAIL (first element \"%s\", expected \"far\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "foo")) { status = 1; printf("FAIL (first element \"%s\", expected \"foo\")\n", text); } else if (strcmp(text = (char *)cupsArrayNext(array), "foo2")) { status = 1; printf("FAIL (first element \"%s\", expected \"foo2\")\n", text); } else puts("PASS"); cupsArrayDelete(array); /* * Summarize the results and return... */ if (!status) puts("\nALL TESTS PASSED!"); else printf("\n%d TEST(S) FAILED!\n", status); return (status); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line args */ char *argv[]) /* I - Command-line arguments */ { const char *name; /* Backend name */ cups_array_t *devices; /* Device array */ cups_device_t *device; /* Current device */ char uriName[1024]; /* Unquoted fullName for URI */ #ifdef HAVE_DNSSD int fd; /* Main file descriptor */ fd_set input; /* Input set for select() */ struct timeval timeout; /* Timeout for select() */ DNSServiceRef main_ref, /* Main service reference */ fax_ipp_ref, /* IPP fax service reference */ ipp_ref, /* IPP service reference */ ipp_tls_ref, /* IPP w/TLS service reference */ ipps_ref, /* IPP service reference */ local_fax_ipp_ref, /* Local IPP fax service reference */ local_ipp_ref, /* Local IPP service reference */ local_ipp_tls_ref, /* Local IPP w/TLS service reference */ local_ipps_ref, /* Local IPP service reference */ local_printer_ref, /* Local LPD service reference */ pdl_datastream_ref, /* AppSocket service reference */ printer_ref, /* LPD service reference */ riousbprint_ref; /* Remote IO service reference */ #endif /* HAVE_DNSSD */ #ifdef HAVE_AVAHI AvahiClient *client; /* Client information */ int error; /* Error code, if any */ #endif /* HAVE_AVAHI */ #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET) struct sigaction action; /* Actions for POSIX signals */ #endif /* HAVE_SIGACTION && !HAVE_SIGSET */ /* * Don't buffer stderr, and catch SIGTERM... */ setbuf(stderr, NULL); #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */ sigset(SIGTERM, sigterm_handler); #elif defined(HAVE_SIGACTION) memset(&action, 0, sizeof(action)); sigemptyset(&action.sa_mask); action.sa_handler = sigterm_handler; sigaction(SIGTERM, &action, NULL); #else signal(SIGTERM, sigterm_handler); #endif /* HAVE_SIGSET */ /* * Check command-line... */ if (argc >= 6) exec_backend(argv); else if (argc != 1) { _cupsLangPrintf(stderr, _("Usage: %s job-id user title copies options [file]"), argv[0]); return (1); } /* * Only do discovery when run as "dnssd"... */ if ((name = strrchr(argv[0], '/')) != NULL) name ++; else name = argv[0]; if (strcmp(name, "dnssd")) return (0); /* * Create an array to track devices... */ devices = cupsArrayNew((cups_array_func_t)compare_devices, NULL); /* * Browse for different kinds of printers... */ #ifdef HAVE_DNSSD if (DNSServiceCreateConnection(&main_ref) != kDNSServiceErr_NoError) { perror("ERROR: Unable to create service connection"); return (1); } fd = DNSServiceRefSockFD(main_ref); fax_ipp_ref = main_ref; DNSServiceBrowse(&fax_ipp_ref, kDNSServiceFlagsShareConnection, 0, "_fax-ipp._tcp", NULL, browse_callback, devices); ipp_ref = main_ref; DNSServiceBrowse(&ipp_ref, kDNSServiceFlagsShareConnection, 0, "_ipp._tcp", NULL, browse_callback, devices); ipp_tls_ref = main_ref; DNSServiceBrowse(&ipp_tls_ref, kDNSServiceFlagsShareConnection, 0, "_ipp-tls._tcp", NULL, browse_callback, devices); ipps_ref = main_ref; DNSServiceBrowse(&ipps_ref, kDNSServiceFlagsShareConnection, 0, "_ipps._tcp", NULL, browse_callback, devices); local_fax_ipp_ref = main_ref; DNSServiceBrowse(&local_fax_ipp_ref, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexLocalOnly, "_fax-ipp._tcp", NULL, browse_local_callback, devices); local_ipp_ref = main_ref; DNSServiceBrowse(&local_ipp_ref, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexLocalOnly, "_ipp._tcp", NULL, browse_local_callback, devices); local_ipp_tls_ref = main_ref; DNSServiceBrowse(&local_ipp_tls_ref, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexLocalOnly, "_ipp-tls._tcp", NULL, browse_local_callback, devices); local_ipps_ref = main_ref; DNSServiceBrowse(&local_ipps_ref, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexLocalOnly, "_ipps._tcp", NULL, browse_local_callback, devices); local_printer_ref = main_ref; DNSServiceBrowse(&local_printer_ref, kDNSServiceFlagsShareConnection, kDNSServiceInterfaceIndexLocalOnly, "_printer._tcp", NULL, browse_local_callback, devices); pdl_datastream_ref = main_ref; DNSServiceBrowse(&pdl_datastream_ref, kDNSServiceFlagsShareConnection, 0, "_pdl-datastream._tcp", NULL, browse_callback, devices); printer_ref = main_ref; DNSServiceBrowse(&printer_ref, kDNSServiceFlagsShareConnection, 0, "_printer._tcp", NULL, browse_callback, devices); riousbprint_ref = main_ref; DNSServiceBrowse(&riousbprint_ref, kDNSServiceFlagsShareConnection, 0, "_riousbprint._tcp", NULL, browse_callback, devices); #endif /* HAVE_DNSSD */ #ifdef HAVE_AVAHI if ((simple_poll = avahi_simple_poll_new()) == NULL) { fputs("DEBUG: Unable to create Avahi simple poll object.\n", stderr); return (0); } avahi_simple_poll_set_func(simple_poll, poll_callback, NULL); client = avahi_client_new(avahi_simple_poll_get(simple_poll), 0, client_callback, simple_poll, &error); if (!client) { fputs("DEBUG: Unable to create Avahi client.\n", stderr); return (0); } browsers = 6; avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_fax-ipp._tcp", NULL, 0, browse_callback, devices); avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_ipp._tcp", NULL, 0, browse_callback, devices); avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_ipp-tls._tcp", NULL, 0, browse_callback, devices); avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_ipps._tcp", NULL, 0, browse_callback, devices); avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_pdl-datastream._tcp", NULL, 0, browse_callback, devices); avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, "_printer._tcp", NULL, 0, browse_callback, devices); #endif /* HAVE_AVAHI */ /* * Loop until we are killed... */ while (!job_canceled) { int announce = 0; /* Announce printers? */ #ifdef HAVE_DNSSD FD_ZERO(&input); FD_SET(fd, &input); timeout.tv_sec = 0; timeout.tv_usec = 500000; if (select(fd + 1, &input, NULL, NULL, &timeout) < 0) continue; if (FD_ISSET(fd, &input)) { /* * Process results of our browsing... */ DNSServiceProcessResult(main_ref); } else announce = 1; #elif defined(HAVE_AVAHI) got_data = 0; if ((error = avahi_simple_poll_iterate(simple_poll, 500)) > 0) { /* * We've been told to exit the loop. Perhaps the connection to * Avahi failed. */ break; } if (!got_data) announce = 1; #endif /* HAVE_DNSSD */ /* fprintf(stderr, "DEBUG: announce=%d\n", announce);*/ if (announce) { /* * Announce any devices we've found... */ #ifdef HAVE_DNSSD DNSServiceErrorType status; /* DNS query status */ #endif /* HAVE_DNSSD */ cups_device_t *best; /* Best matching device */ char device_uri[1024]; /* Device URI */ int count; /* Number of queries */ int sent; /* Number of sent */ for (device = (cups_device_t *)cupsArrayFirst(devices), best = NULL, count = 0, sent = 0; device; device = (cups_device_t *)cupsArrayNext(devices)) { if (device->sent) sent ++; if (device->ref) count ++; if (!device->ref && !device->sent) { /* * Found the device, now get the TXT record(s) for it... */ if (count < 50) { fprintf(stderr, "DEBUG: Querying \"%s\"...\n", device->fullName); #ifdef HAVE_DNSSD device->ref = main_ref; status = DNSServiceQueryRecord(&(device->ref), kDNSServiceFlagsShareConnection, 0, device->fullName, kDNSServiceType_TXT, kDNSServiceClass_IN, query_callback, device); if (status != kDNSServiceErr_NoError) fprintf(stderr, "ERROR: Unable to query \"%s\" for TXT records: %d\n", device->fullName, status); /* Users never see this */ else count ++; #else if ((device->ref = avahi_record_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, device->fullName, AVAHI_DNS_CLASS_IN, AVAHI_DNS_TYPE_TXT, 0, query_callback, device)) == NULL) fprintf(stderr, "ERROR: Unable to query \"%s\" for TXT records: %s\n", device->fullName, avahi_strerror(avahi_client_errno(client))); /* Users never see this */ else count ++; #endif /* HAVE_AVAHI */ } } else if (!device->sent) { #ifdef HAVE_DNSSD /* * Got the TXT records, now report the device... */ DNSServiceRefDeallocate(device->ref); #else avahi_record_browser_free(device->ref); #endif /* HAVE_DNSSD */ device->ref = NULL; if (!best) best = device; else if (_cups_strcasecmp(best->name, device->name) || _cups_strcasecmp(best->domain, device->domain)) { unquote(uriName, best->fullName, sizeof(uriName)); if (best->uuid) httpAssembleURIf(HTTP_URI_CODING_ALL, device_uri, sizeof(device_uri), "dnssd", NULL, uriName, 0, best->cups_shared ? "/cups?uuid=%s" : "/?uuid=%s", best->uuid); else httpAssembleURI(HTTP_URI_CODING_ALL, device_uri, sizeof(device_uri), "dnssd", NULL, uriName, 0, best->cups_shared ? "/cups" : "/"); cupsBackendReport("network", device_uri, best->make_and_model, best->name, best->device_id, NULL); best->sent = 1; best = device; sent ++; } else if (best->priority > device->priority || (best->priority == device->priority && best->type < device->type)) { best->sent = 1; best = device; sent ++; } else { device->sent = 1; sent ++; } } } if (best) { unquote(uriName, best->fullName, sizeof(uriName)); if (best->uuid) httpAssembleURIf(HTTP_URI_CODING_ALL, device_uri, sizeof(device_uri), "dnssd", NULL, uriName, 0, best->cups_shared ? "/cups?uuid=%s" : "/?uuid=%s", best->uuid); else httpAssembleURI(HTTP_URI_CODING_ALL, device_uri, sizeof(device_uri), "dnssd", NULL, uriName, 0, best->cups_shared ? "/cups" : "/"); cupsBackendReport("network", device_uri, best->make_and_model, best->name, best->device_id, NULL); best->sent = 1; sent ++; } fprintf(stderr, "DEBUG: sent=%d, count=%d\n", sent, count); #ifdef HAVE_AVAHI if (sent == cupsArrayCount(devices) && browsers == 0) #else if (sent == cupsArrayCount(devices)) #endif /* HAVE_AVAHI */ break; } } return (CUPS_BACKEND_OK); }
static long /* O - Number of seconds */ select_timeout(int fds) /* I - Number of descriptors returned */ { long timeout; /* Timeout for select */ time_t now; /* Current time */ cupsd_client_t *con; /* Client information */ cupsd_job_t *job; /* Job information */ cupsd_subscription_t *sub; /* Subscription information */ const char *why; /* Debugging aid */ cupsdLogMessage(CUPSD_LOG_DEBUG2, "select_timeout: JobHistoryUpdate=%ld", (long)JobHistoryUpdate); /* * Check to see if any of the clients have pending data to be * processed; if so, the timeout should be 0... */ for (con = (cupsd_client_t *)cupsArrayFirst(Clients); con; con = (cupsd_client_t *)cupsArrayNext(Clients)) if (con->http.used > 0) return (0); /* * If select has been active in the last second (fds > 0) or we have * many resources in use then don't bother trying to optimize the * timeout, just make it 1 second. */ if (fds > 0 || cupsArrayCount(Clients) > 50) return (1); /* * Otherwise, check all of the possible events that we need to wake for... */ now = time(NULL); timeout = now + 86400; /* 86400 == 1 day */ why = "do nothing"; #ifdef __APPLE__ /* * When going to sleep, wake up to cancel jobs that don't complete in time. */ if (SleepJobs > 0 && SleepJobs < timeout) { timeout = SleepJobs; why = "cancel jobs before sleeping"; } #endif /* __APPLE__ */ /* * Check whether we are accepting new connections... */ if (ListeningPaused > 0 && cupsArrayCount(Clients) < MaxClients && ListeningPaused < timeout) { if (ListeningPaused <= now) timeout = now; else timeout = ListeningPaused; why = "resume listening"; } /* * Check the activity and close old clients... */ for (con = (cupsd_client_t *)cupsArrayFirst(Clients); con; con = (cupsd_client_t *)cupsArrayNext(Clients)) if ((con->http.activity + Timeout) < timeout) { timeout = con->http.activity + Timeout; why = "timeout a client connection"; } /* * Write out changes to configuration and state files... */ if (DirtyCleanTime && timeout > DirtyCleanTime) { timeout = DirtyCleanTime; why = "write dirty config/state files"; } /* * Check for any job activity... */ if (JobHistoryUpdate && timeout > JobHistoryUpdate) { timeout = JobHistoryUpdate; why = "update job history"; } for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs); job; job = (cupsd_job_t *)cupsArrayNext(ActiveJobs)) { if (job->cancel_time && job->cancel_time < timeout) { timeout = job->cancel_time; why = "cancel stuck jobs"; } if (job->kill_time && job->kill_time < timeout) { timeout = job->kill_time; why = "kill unresponsive jobs"; } if (job->state_value == IPP_JOB_HELD && job->hold_until < timeout) { timeout = job->hold_until; why = "release held jobs"; } if (job->state_value == IPP_JOB_PENDING && timeout > (now + 10)) { timeout = now + 10; why = "start pending jobs"; break; } } #ifdef HAVE_MALLINFO /* * Log memory usage every minute... */ if (LogLevel >= CUPSD_LOG_DEBUG && (mallinfo_time + 60) < timeout) { timeout = mallinfo_time + 60; why = "display memory usage"; } #endif /* HAVE_MALLINFO */ /* * Expire subscriptions as needed... */ for (sub = (cupsd_subscription_t *)cupsArrayFirst(Subscriptions); sub; sub = (cupsd_subscription_t *)cupsArrayNext(Subscriptions)) if (!sub->job && sub->expire && sub->expire < timeout) { timeout = sub->expire; why = "expire subscription"; } /* * Adjust from absolute to relative time. We add 1 second to the timeout since * events occur after the timeout expires, and limit the timeout to 86400 * seconds (1 day) to avoid select() timeout limits present on some operating * systems... */ timeout = timeout - now + 1; if (timeout < 1) timeout = 1; else if (timeout > 86400) timeout = 86400; /* * Log and return the timeout value... */ cupsdLogMessage(CUPSD_LOG_DEBUG2, "select_timeout(%d): %ld seconds to %s", fds, timeout, why); return (timeout); }
static void read_snmp_conf(const char *address) /* I - Single address to probe */ { cups_file_t *fp; /* File pointer */ char filename[1024], /* Filename */ line[1024], /* Line from file */ *value; /* Value on line */ int linenum; /* Line number */ const char *cups_serverroot; /* CUPS_SERVERROOT env var */ const char *debug; /* CUPS_DEBUG_LEVEL env var */ const char *runtime; /* CUPS_MAX_RUN_TIME env var */ /* * Initialize the global address and community lists... */ Addresses = cupsArrayNew(NULL, NULL); Communities = cupsArrayNew(NULL, NULL); if (address) add_array(Addresses, address); if ((debug = getenv("CUPS_DEBUG_LEVEL")) != NULL) DebugLevel = atoi(debug); if ((runtime = getenv("CUPS_MAX_RUN_TIME")) != NULL) MaxRunTime = atoi(runtime); /* * Find the snmp.conf file... */ if ((cups_serverroot = getenv("CUPS_SERVERROOT")) == NULL) cups_serverroot = CUPS_SERVERROOT; snprintf(filename, sizeof(filename), "%s/snmp.conf", cups_serverroot); if ((fp = cupsFileOpen(filename, "r")) != NULL) { /* * Read the snmp.conf file... */ linenum = 0; while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum)) { if (!value) fprintf(stderr, "ERROR: Missing value on line %d of %s!\n", linenum, filename); else if (!_cups_strcasecmp(line, "Address")) { if (!address) add_array(Addresses, value); } else if (!_cups_strcasecmp(line, "Community")) add_array(Communities, value); else if (!_cups_strcasecmp(line, "DebugLevel")) DebugLevel = atoi(value); else if (!_cups_strcasecmp(line, "DeviceURI")) { if (*value != '\"') fprintf(stderr, "ERROR: Missing double quote for regular expression on " "line %d of %s!\n", linenum, filename); else add_device_uri(value); } else if (!_cups_strcasecmp(line, "HostNameLookups")) HostNameLookups = !_cups_strcasecmp(value, "on") || !_cups_strcasecmp(value, "yes") || !_cups_strcasecmp(value, "true") || !_cups_strcasecmp(value, "double"); else if (!_cups_strcasecmp(line, "MaxRunTime")) MaxRunTime = atoi(value); else fprintf(stderr, "ERROR: Unknown directive %s on line %d of %s!\n", line, linenum, filename); } cupsFileClose(fp); } /* * Use defaults if parameters are undefined... */ if (cupsArrayCount(Addresses) == 0) { /* * If we have no addresses, exit immediately... */ fprintf(stderr, "DEBUG: No address specified and no Address line in %s...\n", filename); exit(0); } if (cupsArrayCount(Communities) == 0) { fputs("INFO: Using default SNMP Community public\n", stderr); add_array(Communities, "public"); } }
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 fg; /* Run in the foreground */ int fds; /* Number of ready descriptors */ cupsd_client_t *con; /* Current client */ cupsd_job_t *job; /* Current job */ cupsd_listener_t *lis; /* Current listener */ time_t current_time, /* Current time */ activity, /* Client activity timer */ 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 __sgi cups_file_t *fp; /* Fake lpsched lock file */ struct stat statbuf; /* Needed for checking lpsched FIFO */ #endif /* __sgi */ int run_as_child = 0; /* Needed for background fork/exec */ #ifdef __APPLE__ int use_sysman = !getuid(); /* Use system management functions? */ #else time_t netif_time = 0; /* Time since last network update */ #endif /* __APPLE__ */ #if HAVE_LAUNCHD int launchd_idle_exit; /* Idle exit on select timeout? */ #endif /* HAVE_LAUNCHD */ #ifdef 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")) { Launchd = 1; fg = 1; } #endif /* HAVE_LAUNCHD */ for (i = 1; i < argc; i ++) if (argv[i][0] == '-') for (opt = argv[i] + 1; *opt != '\0'; opt ++) switch (*opt) { case 'C' : /* Run as child with config file */ run_as_child = 1; fg = -1; 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; break; case 'F' : /* Run in foreground, but disconnect from terminal... */ fg = -1; break; case 'h' : /* Show usage/help */ usage(0); break; case 'l' : /* Started by launchd... */ #ifdef HAVE_LAUNCHD Launchd = 1; fg = 1; #else _cupsLangPuts(stderr, _("cupsd: launchd(8) support not compiled " "in, running in normal mode.")); fg = 0; #endif /* HAVE_LAUNCHD */ 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; break; case 'P' : /* Disable security profiles */ fputs("cupsd: -P (disable security profiles) is for internal " "testing use only!\n", stderr); UseProfiles = 0; 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; 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 the user hasn't specified "-f", run in the background... */ if (!fg) { /* * Setup signal handlers for the parent... */ #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */ sigset(SIGUSR1, parent_handler); sigset(SIGCHLD, parent_handler); sigset(SIGHUP, SIG_IGN); #elif defined(HAVE_SIGACTION) memset(&action, 0, sizeof(action)); sigemptyset(&action.sa_mask); sigaddset(&action.sa_mask, SIGUSR1); action.sa_handler = parent_handler; sigaction(SIGUSR1, &action, NULL); sigaction(SIGCHLD, &action, NULL); sigemptyset(&action.sa_mask); action.sa_handler = SIG_IGN; sigaction(SIGHUP, &action, NULL); #else signal(SIGUSR1, parent_handler); signal(SIGCLD, parent_handler); signal(SIGHUP, SIG_IGN); #endif /* HAVE_SIGSET */ if (fork() > 0) { /* * OK, wait for the child to startup and send us SIGUSR1 or to crash * and the OS send us SIGCHLD... We also need to ignore SIGHUP which * might be sent by the init script to restart the scheduler... */ for (; parent_signal == 0;) sleep(1); if (parent_signal == SIGUSR1) return (0); if (wait(&i) < 0) { perror("cupsd"); return (1); } else if (WIFEXITED(i)) { fprintf(stderr, "cupsd: Child exited with status %d\n", WEXITSTATUS(i)); return (2); } else { fprintf(stderr, "cupsd: Child exited on signal %d\n", WTERMSIG(i)); return (3); } } #ifdef __OpenBSD__ /* * 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 OpenBSD. */ _thread_sys_closefrom(0); #endif /* __OpenBSD__ */ /* * Since CoreFoundation and DBUS both create fork-unsafe data on execution of * a program, and since this kind of really unfriendly behavior seems to be * more common these days in system libraries, we need to re-execute the * background cupsd with the "-C" option 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, (char *)0); exit(errno); } if (fg < 1) { /* * Make sure we aren't tying up any filesystems... */ chdir("/"); #ifndef DEBUG /* * Disable core dumps... */ getrlimit(RLIMIT_CORE, &limit); limit.rlim_cur = 0; setrlimit(RLIMIT_CORE, &limit); /* * Disconnect from the controlling terminal... */ setsid(); /* * Close all open files... */ getrlimit(RLIMIT_NOFILE, &limit); for (i = 0; i < limit.rlim_cur && i < 1024; i ++) close(i); /* * 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); } #endif /* DEBUG */ } /* * Set the timezone info... */ tzset(); #ifdef LC_TIME setlocale(LC_TIME, ""); #endif /* LC_TIME */ /* * Set the maximum number of files... */ getrlimit(RLIMIT_NOFILE, &limit); #if !defined(HAVE_POLL) && !defined(HAVE_EPOLL) && !defined(HAVE_KQUEUE) if (limit.rlim_max > FD_SETSIZE) MaxFDs = FD_SETSIZE; else #endif /* !HAVE_POLL && !HAVE_EPOLL && !HAVE_KQUEUE */ #ifdef RLIM_INFINITY if (limit.rlim_max == RLIM_INFINITY) MaxFDs = 16384; else #endif /* RLIM_INFINITY */ MaxFDs = limit.rlim_max; limit.rlim_cur = MaxFDs; setrlimit(RLIMIT_NOFILE, &limit); cupsdStartSelect(); /* * Read configuration... */ if (!cupsdReadConfiguration()) { if (TestConfigFile) printf("%s contains errors\n", ConfigurationFile); else syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting!", ConfigurationFile); return (1); } else if (TestConfigFile) { printf("%s is OK\n", ConfigurationFile); return (0); } /* * Clean out old temp files and printer cache data. */ if (!strncmp(TempDir, RequestRoot, strlen(RequestRoot))) cupsdCleanFiles(TempDir, NULL); cupsdCleanFiles(CacheDir, "*.ipp"); #if HAVE_LAUNCHD if (Launchd) { /* * If we were started by launchd get the listen sockets file descriptors... */ launchd_checkin(); launchd_checkout(); } #endif /* HAVE_LAUNCHD */ /* * 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 */ #ifdef __sgi /* * Try to create a fake lpsched lock file if one is not already there. * Some Adobe applications need it under IRIX in order to enable * printing... */ if ((fp = cupsFileOpen("/var/spool/lp/SCHEDLOCK", "w")) == NULL) { syslog(LOG_LPR, "Unable to create fake lpsched lock file " "\"/var/spool/lp/SCHEDLOCK\"\' - %s!", strerror(errno)); } else { fchmod(cupsFileNumber(fp), 0644); fchown(cupsFileNumber(fp), User, Group); cupsFileClose(fp); } #endif /* __sgi */ /* * Initialize authentication certificates... */ cupsdInitCerts(); /* * If we are running in the background, signal the parent process that * we are up and running... */ 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... */ #ifdef HAVE_LAUNCHD if (Launchd) cupsdAddEvent(CUPSD_EVENT_SERVER_STARTED, NULL, NULL, "Scheduler started via launchd."); else #endif /* HAVE_LAUNCHD */ 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 (con->http.state == 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... */ DoingShutdown = 1; cupsdStopServer(); /* * Read configuration... */ if (!cupsdReadConfiguration()) { syslog(LOG_LPR, "Unable to read configuration file \'%s\' - exiting!", ConfigurationFile); break; } #if HAVE_LAUNCHD if (Launchd) { /* * If we were started by launchd, get the listen socket file * descriptors... */ launchd_checkin(); launchd_checkout(); } #endif /* HAVE_LAUNCHD */ /* * 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; #if HAVE_LAUNCHD /* * If no other work is scheduled and we're being controlled by * launchd then timeout after 'LaunchdTimeout' seconds of * inactivity... */ if (timeout == 86400 && Launchd && LaunchdTimeout && !cupsArrayCount(ActiveJobs) && (!Browsing || !BrowseLocalProtocols || !cupsArrayCount(Printers))) { timeout = LaunchdTimeout; launchd_idle_exit = 1; } else launchd_idle_exit = 0; #endif /* HAVE_LAUNCHD */ if ((fds = cupsdDoSelect(timeout)) < 0) { /* * Got an error from select! */ #ifdef HAVE_DNSSD cupsd_printer_t *p; /* Current printer */ #endif /* HAVE_DNSSD */ if (errno == EINTR) /* Just interrupted by a signal */ continue; /* * Log all sorts of debug info to help track down the problem. */ cupsdLogMessage(CUPSD_LOG_EMERG, "cupsdDoSelect() failed - %s!", strerror(errno)); for (i = 0, con = (cupsd_client_t *)cupsArrayFirst(Clients); con; i ++, con = (cupsd_client_t *)cupsArrayNext(Clients)) cupsdLogMessage(CUPSD_LOG_EMERG, "Clients[%d] = %d, file = %d, state = %d", i, con->http.fd, con->file, con->http.state); for (i = 0, lis = (cupsd_listener_t *)cupsArrayFirst(Listeners); lis; i ++, lis = (cupsd_listener_t *)cupsArrayNext(Listeners)) cupsdLogMessage(CUPSD_LOG_EMERG, "Listeners[%d] = %d", i, lis->fd); cupsdLogMessage(CUPSD_LOG_EMERG, "CGIPipes[0] = %d", CGIPipes[0]); #ifdef __APPLE__ cupsdLogMessage(CUPSD_LOG_EMERG, "SysEventPipes[0] = %d", SysEventPipes[0]); #endif /* __APPLE__ */ for (job = (cupsd_job_t *)cupsArrayFirst(ActiveJobs); job; job = (cupsd_job_t *)cupsArrayNext(ActiveJobs)) cupsdLogMessage(CUPSD_LOG_EMERG, "Jobs[%d] = %d < [%d %d] > [%d %d]", job->id, job->status_buffer ? job->status_buffer->fd : -1, job->print_pipes[0], job->print_pipes[1], job->back_pipes[0], job->back_pipes[1]); #ifdef HAVE_DNSSD for (p = (cupsd_printer_t *)cupsArrayFirst(Printers); p; p = (cupsd_printer_t *)cupsArrayNext(Printers)) cupsdLogMessage(CUPSD_LOG_EMERG, "printer[%s] reg_name=\"%s\"", p->name, p->reg_name ? p->reg_name : "(null)"); #endif /* HAVE_DNSSD */ 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__ */ #if HAVE_LAUNCHD /* * If no other work was scheduled and we're being controlled by launchd * then timeout after 'LaunchdTimeout' seconds of inactivity... */ if (!fds && launchd_idle_exit) { cupsdLogMessage(CUPSD_LOG_INFO, "Printer sharing is off and there are no jobs pending, " "will restart on demand."); stop_scheduler = 1; break; } #endif /* HAVE_LAUNCHD */ /* * Resume listening for new connections as needed... */ if (ListeningPaused && ListeningPaused <= current_time && cupsArrayCount(Clients) < MaxClients) cupsdResumeListening(); /* * Expire subscriptions and unload completed jobs as needed... */ if (current_time > expire_time) { if (cupsArrayCount(Subscriptions) > 0) cupsdExpireSubscriptions(NULL, NULL); cupsdUnloadCompletedJobs(); expire_time = current_time; } #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", NULL); } #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 (con->http.used) { cupsdReadClient(con); continue; } /* * Check the activity and close old clients... */ activity = current_time - Timeout; if (con->http.activity < activity && !con->pipe_pid) { cupsdLogMessage(CUPSD_LOG_DEBUG, "Closing client %d after %d seconds of inactivity...", con->http.fd, Timeout); cupsdCloseClient(con); continue; } } /* * Update any pending multi-file documents... */ if ((current_time - senddoc_time) >= 10) { cupsdCheckJobs(); senddoc_time = current_time; } /* * 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_LAUNCHD /* * Update the launchd KeepAlive file as needed... */ if (Launchd) launchd_checkout(); #endif /* HAVE_LAUNCHD */ /* * Stop all jobs... */ cupsdFreeAllJobs(); #ifdef __APPLE__ /* * Stop monitoring system event monitoring... */ if (use_sysman) cupsdStopSystemMonitor(); #endif /* __APPLE__ */ #ifdef HAVE_GSSAPI /* * Free the scheduler's Kerberos context... */ # ifdef __APPLE__ /* * If the weak-linked GSSAPI/Kerberos library is not present, don't try * to use it... */ if (krb5_init_context != NULL) # endif /* __APPLE__ */ if (KerberosContext) krb5_free_context(KerberosContext); #endif /* HAVE_GSSAPI */ #ifdef __sgi /* * Remove the fake IRIX lpsched lock file, but only if the existing * file is not a FIFO which indicates that the real IRIX lpsched is * running... */ if (!stat("/var/spool/lp/FIFO", &statbuf)) if (!S_ISFIFO(statbuf.st_mode)) unlink("/var/spool/lp/SCHEDLOCK"); #endif /* __sgi */ cupsdStopSelect(); return (!stop_scheduler); }
cups_array_t * /* O - Languages array */ _ppdGetLanguages(ppd_file_t *ppd) /* I - PPD file */ { cups_array_t *languages; /* Languages array */ ppd_attr_t *attr; /* cupsLanguages attribute */ char *value, /* Copy of attribute value */ *start, /* Start of current language */ *ptr; /* Pointer into languages */ /* * See if we have a cupsLanguages attribute... */ if ((attr = ppdFindAttr(ppd, "cupsLanguages", NULL)) == NULL || !attr->value) return (NULL); /* * Yes, load the list... */ if ((languages = cupsArrayNew((cups_array_func_t)strcmp, NULL)) == NULL) return (NULL); if ((value = strdup(attr->value)) == NULL) { cupsArrayDelete(languages); return (NULL); } for (ptr = value; *ptr;) { /* * Skip leading whitespace... */ while (_cups_isspace(*ptr)) ptr ++; if (!*ptr) break; /* * Find the end of this language name... */ for (start = ptr; *ptr && !_cups_isspace(*ptr); ptr ++); if (*ptr) *ptr++ = '\0'; if (!strcmp(start, "en")) continue; cupsArrayAdd(languages, strdup(start)); } /* * Free the temporary string and return either an array with one or more * values or a NULL pointer... */ free(value); if (cupsArrayCount(languages) == 0) { cupsArrayDelete(languages); return (NULL); } else return (languages); }
void cupsdSetBusyState(void) { int i; /* Looping var */ cupsd_job_t *job; /* Current job */ cupsd_printer_t *p; /* Current printer */ int newbusy; /* New busy state */ static int busy = 0; /* Current busy state */ static const char * const busy_text[] = { /* Text for busy states */ "Not busy", "Dirty files", "Printing jobs", "Printing jobs and dirty files", "Active clients", "Active clients and dirty files", "Active clients and printing jobs", "Active clients, printing jobs, and dirty files" }; #ifdef __APPLE__ static vproc_transaction_t vtran = 0; /* Current busy transaction */ static IOPMAssertionID keep_awake = 0;/* Keep the system awake while printing */ #endif /* __APPLE__ */ /* * Figure out how busy we are... */ newbusy = (DirtyCleanTime ? 1 : 0) | (cupsArrayCount(ActiveClients) ? 4 : 0); for (job = (cupsd_job_t *)cupsArrayFirst(PrintingJobs); job; job = (cupsd_job_t *)cupsArrayNext(PrintingJobs)) { if ((p = job->printer) != NULL) { for (i = 0; i < p->num_reasons; i ++) if (!strcmp(p->reasons[i], "connecting-to-device")) break; if (!p->num_reasons || i >= p->num_reasons) break; } } if (job) newbusy |= 2; cupsdLogMessage(CUPSD_LOG_DEBUG, "cupsdSetBusyState: newbusy=\"%s\", busy=\"%s\"", busy_text[newbusy], busy_text[busy]); /* * Manage state changes... */ if (newbusy != busy) { busy = newbusy; #ifdef __APPLE__ if (busy && !vtran) vtran = vproc_transaction_begin(NULL); else if (!busy && vtran) { vproc_transaction_end(NULL, vtran); vtran = 0; } #endif /* __APPLE__ */ } #ifdef __APPLE__ if (cupsArrayCount(PrintingJobs) > 0 && !keep_awake) { cupsdLogMessage(CUPSD_LOG_DEBUG, "Asserting NetworkClientActive."); IOPMAssertionCreateWithName(kIOPMAssertNetworkClientActive, kIOPMAssertionLevelOn, CFSTR("org.cups.cupsd"), &keep_awake); } else if (cupsArrayCount(PrintingJobs) == 0 && keep_awake) { cupsdLogMessage(CUPSD_LOG_DEBUG, "Releasing power assertion."); IOPMAssertionRelease(keep_awake); keep_awake = 0; } #endif /* __APPLE__ */ }