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); }
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); }
mime_type_t * /* O - Matching file type definition */ mimeType(mime_t *mime, /* I - MIME database */ const char *super, /* I - Super-type name */ const char *type) /* I - Type name */ { mime_type_t key, /* MIME type search key */ *mt; /* Matching type */ DEBUG_printf(("mimeType(mime=%p, super=\"%s\", type=\"%s\")", mime, super, type)); /* * Range check input... */ if (!mime || !super || !type) { DEBUG_puts("1mimeType: Returning NULL."); return (NULL); } /* * Lookup the type in the array... */ strlcpy(key.super, super, sizeof(key.super)); strlcpy(key.type, type, sizeof(key.type)); mt = (mime_type_t *)cupsArrayFind(mime->types, &key); DEBUG_printf(("1mimeType: Returning %p.", mt)); return (mt); }
const char * /* O - Process name */ cupsdFinishProcess(int pid, /* I - Process ID */ char *name, /* I - Name buffer */ size_t namelen, /* I - Size of name buffer */ int *job_id) /* O - Job ID pointer or NULL */ { cupsd_proc_t key, /* Search key */ *proc; /* Matching process */ key.pid = pid; if ((proc = (cupsd_proc_t *)cupsArrayFind(process_array, &key)) != NULL) { if (job_id) *job_id = proc->job_id; strlcpy(name, proc->name, namelen); cupsArrayRemove(process_array, proc); free(proc); } else { if (job_id) *job_id = 0; strlcpy(name, "unknown", namelen); } cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdFinishProcess(pid=%d, name=%p, namelen=" CUPS_LLFMT ", job_id=%p(%d)) = \"%s\"", pid, name, CUPS_LLCAST namelen, job_id, job_id ? *job_id : 0, name); return (name); }
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); }
static const char * /* O - Full path to filter or NULL */ add_fcache(cups_array_t *filtercache, /* I - Filter cache */ const char *name, /* I - Filter name */ const char *filterpath) /* I - Filter path */ { _mime_fcache_t key, /* Search key */ *temp; /* New filter cache */ char path[1024]; /* Full path to filter */ key.name = (char *)name; if ((temp = (_mime_fcache_t *)cupsArrayFind(filtercache, &key)) != NULL) return (temp->path); if ((temp = calloc(1, sizeof(_mime_fcache_t))) == NULL) return (NULL); temp->name = strdup(name); if (cupsFileFind(name, filterpath, 1, path, sizeof(path))) temp->path = strdup(path); cupsArrayAdd(filtercache, temp); return (temp->path); }
help_node_t * /* O - Node pointer or NULL */ helpFindNode(help_index_t *hi, /* I - Index */ const char *filename, /* I - Filename */ const char *anchor) /* I - Anchor */ { help_node_t key; /* Search key */ DEBUG_printf(("helpFindNode(hi=%p, filename=\"%s\", anchor=\"%s\")", hi, filename, anchor)); /* * Range check input... */ if (!hi || !filename) return (NULL); /* * Initialize the search key... */ key.filename = (char *)filename; key.anchor = (char *)anchor; /* * Return any match... */ return ((help_node_t *)cupsArrayFind(hi->nodes, &key)); }
cupsd_subscription_t * /* O - Subscription object */ cupsdFindSubscription(int id) /* I - Subscription ID */ { cupsd_subscription_t sub; /* Subscription template */ sub.id = id; return ((cupsd_subscription_t *)cupsArrayFind(Subscriptions, &sub)); }
cupsd_location_t * /* O - Policy operation */ cupsdFindPolicyOp(cupsd_policy_t *p, /* I - Policy */ ipp_op_t op) /* I - IPP operation */ { cupsd_location_t key, /* Search key... */ *po; /* Current policy operation */ cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdFindPolicyOp(p=%p, op=%x(%s))", p, op, ippOpString(op)); /* * Range check... */ if (!p) return (NULL); /* * Check the operation against the available policies... */ key.op = op; if ((po = (cupsd_location_t *)cupsArrayFind(p->ops, &key)) != NULL) { cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdFindPolicyOp: Found exact match..."); return (po); } key.op = IPP_ANY_OPERATION; if ((po = (cupsd_location_t *)cupsArrayFind(p->ops, &key)) != NULL) { cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdFindPolicyOp: Found wildcard match..."); return (po); } cupsdLogMessage(CUPSD_LOG_DEBUG2, "cupsdFindPolicyOp: No match found!"); return (NULL); }
static dev_info_t * /* O - New device or NULL on error */ add_dev( const char *device_class, /* I - Device class */ const char *device_make_and_model, /* I - Device make and model */ const char *device_info, /* I - Device information */ const char *device_uri, /* I - Device URI */ const char *device_id) /* I - 1284 device ID */ { dev_info_t *dev, /* New device */ *temp; /* Found device */ /* * Allocate memory for the device record... */ if ((dev = calloc(1, sizeof(dev_info_t))) == NULL) { fputs("ERROR: [cups-deviced] Ran out of memory allocating a device!\n", stderr); return (NULL); } /* * Copy the strings over... */ strlcpy(dev->device_class, device_class, sizeof(dev->device_class)); strlcpy(dev->device_make_and_model, device_make_and_model, sizeof(dev->device_make_and_model)); strlcpy(dev->device_info, device_info, sizeof(dev->device_info)); strlcpy(dev->device_uri, device_uri, sizeof(dev->device_uri)); strlcpy(dev->device_id, device_id, sizeof(dev->device_id)); /* * Add the device to the array and return... */ if ((temp = cupsArrayFind(devs, dev)) != NULL) { /* * Avoid duplicates! */ free(dev); dev = temp; } else cupsArrayAdd(devs, dev); return (dev); }
ppd_cparam_t * /* O - Custom parameter or NULL */ ppdFindCustomParam(ppd_coption_t *opt, /* I - Custom option */ const char *name) /* I - Parameter name */ { ppd_cparam_t key; /* Custom parameter search key */ if (!opt) return (NULL); strlcpy(key.name, name, sizeof(key.name)); return ((ppd_cparam_t *)cupsArrayFind(opt->params, &key)); }
ppd_coption_t * /* O - Custom option or NULL */ ppdFindCustomOption(ppd_file_t *ppd, /* I - PPD file */ const char *keyword)/* I - Custom option name */ { ppd_coption_t key; /* Custom option search key */ if (!ppd) return (NULL); strlcpy(key.keyword, keyword, sizeof(key.keyword)); return ((ppd_coption_t *)cupsArrayFind(ppd->coptions, &key)); }
static help_word_t * /* O - New word */ help_add_word(help_node_t *n, /* I - Node */ const char *text) /* I - Word text */ { help_word_t *w, /* New word */ key; /* Search key */ DEBUG_printf(("2help_add_word(n=%p, text=\"%s\")", n, text)); /* * Create the words array as needed... */ if (!n->words) n->words = cupsArrayNew((cups_array_func_t)help_sort_words, NULL); /* * See if the word is already added... */ key.text = (char *)text; if ((w = (help_word_t *)cupsArrayFind(n->words, &key)) == NULL) { /* * Create a new word... */ if ((w = calloc(1, sizeof(help_word_t))) == NULL) return (NULL); if ((w->text = strdup(text)) == NULL) { free(w); return (NULL); } cupsArrayAdd(n->words, w); } /* * Bump the counter for this word and return it... */ w->count ++; return (w); }
ppd_attr_t * /* O - Attribute or @code NULL@ if not found */ ppdFindAttr(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 key, /* Search key */ *attr; /* Current attribute */ DEBUG_printf(("2ppdFindAttr(ppd=%p, name=\"%s\", spec=\"%s\")", ppd, name, spec)); /* * Range check input... */ if (!ppd || !name || ppd->num_attrs == 0) return (NULL); /* * Search for a matching attribute... */ memset(&key, 0, sizeof(key)); strlcpy(key.name, name, sizeof(key.name)); /* * Return the first matching attribute, if any... */ if ((attr = (ppd_attr_t *)cupsArrayFind(ppd->sorted_attrs, &key)) != NULL) { if (spec) { /* * Loop until we find the first matching attribute for "spec"... */ while (attr && _cups_strcasecmp(spec, attr->spec)) { if ((attr = (ppd_attr_t *)cupsArrayNext(ppd->sorted_attrs)) != NULL && _cups_strcasecmp(attr->name, name)) attr = NULL; } } } return (attr); }
ppd_option_t * /* O - Pointer to option or @code NULL@ */ ppdFindOption(ppd_file_t *ppd, /* I - PPD file data */ const char *option) /* I - Option/Keyword name */ { /* * Range check input... */ if (!ppd || !option) return (NULL); if (ppd->options) { /* * Search in the array... */ ppd_option_t key; /* Option search key */ strlcpy(key.keyword, option, sizeof(key.keyword)); return ((ppd_option_t *)cupsArrayFind(ppd->options, &key)); } else { /* * Search in each group... */ int i, j; /* Looping vars */ ppd_group_t *group; /* Current group */ ppd_option_t *optptr; /* Current option */ for (i = ppd->num_groups, group = ppd->groups; i > 0; i --, group ++) for (j = group->num_options, optptr = group->options; j > 0; j --, optptr ++) if (!_cups_strcasecmp(optptr->keyword, option)) return (optptr); return (NULL); } }
server_job_t * /* O - Job or NULL */ serverFindJob( server_client_t *client, /* I - Client */ int job_id) /* I - Job ID to find or 0 to lookup */ { ipp_attribute_t *attr; /* job-id or job-uri attribute */ server_job_t key, /* Job search key */ *job; /* Matching job, if any */ if (job_id > 0) { key.id = job_id; } else if ((attr = ippFindAttribute(client->request, "job-uri", IPP_TAG_URI)) != NULL) { const char *uri = ippGetString(attr, 0, NULL); /* job-uri value */ char scheme[32], /* URI scheme */ userpass[256], /* username:password */ host[256], /* Hostname/IP */ resource[1024]; /* Resource path */ int port; /* Port number */ if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme), userpass, sizeof(userpass), host, sizeof(host), &port, resource, sizeof(resource)) >= HTTP_URI_STATUS_OK && !strncmp(resource, client->printer->resource, client->printer->resourcelen) && resource[client->printer->resourcelen] == '/') key.id = atoi(resource + client->printer->resourcelen + 1); else return (NULL); } else if ((attr = ippFindAttribute(client->request, "job-id", IPP_TAG_INTEGER)) != NULL) { key.id = ippGetInteger(attr, 0); } _cupsRWLockRead(&(client->printer->rwlock)); job = (server_job_t *)cupsArrayFind(client->printer->jobs, &key); _cupsRWUnlock(&(client->printer->rwlock)); return (job); }
_pwg_media_t * /* O - Matching size or NULL */ _pwgMediaForLegacy( const char *legacy) /* I - Legacy size name */ { _pwg_media_t key; /* Search key */ _cups_globals_t *cg = _cupsGlobals(); /* Global data */ /* * Range check input... */ if (!legacy) return (NULL); /* * Build the lookup table for PWG names as needed... */ if (!cg->leg_size_lut) { int i; /* Looping var */ _pwg_media_t *size; /* Current size */ cg->leg_size_lut = cupsArrayNew((cups_array_func_t)pwg_compare_legacy, NULL); for (i = (int)(sizeof(cups_pwg_media) / sizeof(cups_pwg_media[0])), size = (_pwg_media_t *)cups_pwg_media; i > 0; i --, size ++) if (size->legacy) cupsArrayAdd(cg->leg_size_lut, size); } /* * Lookup the name... */ key.legacy = legacy; return ((_pwg_media_t *)cupsArrayFind(cg->leg_size_lut, &key)); }
int /* O - Non-zero if option is marked */ ppdIsMarked(ppd_file_t *ppd, /* I - PPD file data */ const char *option, /* I - Option/Keyword name */ const char *choice) /* I - Choice name */ { ppd_choice_t key, /* Search key */ *c; /* Choice pointer */ if (!ppd) return (0); if ((key.option = ppdFindOption(ppd, option)) == NULL) return (0); if ((c = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) == NULL) return (0); return (!strcmp(c->choice, choice)); }
void mimeDeleteType(mime_t *mime, /* I - MIME database */ mime_type_t *mt) /* I - Type */ { DEBUG_printf(("mimeDeleteType(mime=%p, mt=%p(%s/%s))", mime, mt, mt ? mt->super : "???", mt ? mt->type : "???")); if (!mime || !mt) return; #ifdef DEBUG if (!cupsArrayFind(mime->types, mt)) DEBUG_puts("1mimeDeleteFilter: Type not in MIME database."); #endif /* DEBUG */ cupsArrayRemove(mime->types, mt); mime_delete_rules(mt->rules); free(mt); }
cupsd_policy_t * /* O - Policy */ cupsdFindPolicy(const char *policy) /* I - Name of policy */ { cupsd_policy_t key; /* Search key */ /* * Range check... */ if (!policy) return (NULL); /* * Look it up... */ key.name = (char *)policy; return ((cupsd_policy_t *)cupsArrayFind(Policies, &key)); }
mime_filter_t * /* O - Filter for src->dst */ mimeFilterLookup(mime_t *mime, /* I - MIME database */ mime_type_t *src, /* I - Source type */ mime_type_t *dst) /* I - Destination type */ { mime_filter_t key, /* Key record for filter search */ *filter; /* Matching filter */ DEBUG_printf(("2mimeFilterLookup(mime=%p, src=%p(%s/%s), dst=%p(%s/%s))", mime, src, src ? src->super : "???", src ? src->type : "???", dst, dst ? dst->super : "???", dst ? dst->type : "???")); key.src = src; key.dst = dst; filter = (mime_filter_t *)cupsArrayFind(mime->filters, &key); DEBUG_printf(("3mimeFilterLookup: Returning %p(%s).", filter, filter ? filter->filter : "???")); return (filter); }
cupsd_netif_t * /* O - Network interface data */ cupsdNetIFFind(const char *name) /* I - Name of interface */ { cupsd_netif_t key; /* Search key */ /* * Update the interface list as needed... */ if (NetIFUpdate) cupsdNetIFUpdate(); /* * Search for the named interface... */ strlcpy(key.name, name, sizeof(key.name)); return ((cupsd_netif_t *)cupsArrayFind(NetIFList, &key)); }
cupsd_quota_t * /* O - Quota data */ cupsdFindQuota( cupsd_printer_t *p, /* I - Printer */ const char *username) /* I - User */ { cupsd_quota_t *q, /* Quota data pointer */ match; /* Search data */ char *ptr; /* Pointer into username */ if (!p || !username) return (NULL); strlcpy(match.username, username, sizeof(match.username)); if ((ptr = strchr(match.username, '@')) != NULL) *ptr = '\0'; /* Strip @domain/@KDC */ if ((q = (cupsd_quota_t *)cupsArrayFind(p->quotas, &match)) != NULL) return (q); else return (add_quota(p, username)); }
ppd_choice_t * /* O - Pointer to choice or @code NULL@ */ ppdFindMarkedChoice(ppd_file_t *ppd, /* I - PPD file */ const char *option) /* I - Keyword/option name */ { ppd_choice_t key, /* Search key for choice */ *marked; /* Marked choice */ DEBUG_printf(("2ppdFindMarkedChoice(ppd=%p, option=\"%s\")", ppd, option)); if ((key.option = ppdFindOption(ppd, option)) == NULL) { DEBUG_puts("3ppdFindMarkedChoice: Option not found, returning NULL"); return (NULL); } marked = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key); DEBUG_printf(("3ppdFindMarkedChoice: Returning %p(%s)...", marked, marked ? marked->choice : "NULL")); return (marked); }
static const char * /* O - Full path to filter or NULL */ mime_add_fcache( cups_array_t *filtercache, /* I - Filter cache */ const char *name, /* I - Filter name */ const char *filterpath) /* I - Filter path */ { _mime_fcache_t key, /* Search key */ *temp; /* New filter cache */ char path[1024]; /* Full path to filter */ DEBUG_printf(("2mime_add_fcache(filtercache=%p, name=\"%s\", " "filterpath=\"%s\")", filtercache, name, filterpath)); key.name = (char *)name; if ((temp = (_mime_fcache_t *)cupsArrayFind(filtercache, &key)) != NULL) { DEBUG_printf(("3mime_add_fcache: Returning \"%s\".", temp->path)); return (temp->path); } if ((temp = calloc(1, sizeof(_mime_fcache_t))) == NULL) { DEBUG_puts("3mime_add_fcache: Returning NULL."); return (NULL); } temp->name = strdup(name); if (cupsFileFind(name, filterpath, 1, path, sizeof(path))) temp->path = strdup(path); cupsArrayAdd(filtercache, temp); DEBUG_printf(("3mime_add_fcache: Returning \"%s\".", temp->path)); return (temp->path); }
void mimeDeleteFilter(mime_t *mime, /* I - MIME database */ mime_filter_t *filter) /* I - Filter */ { DEBUG_printf(("mimeDeleteFilter(mime=%p, filter=%p(%s/%s->%s/%s, cost=%d, " "maxsize=" CUPS_LLFMT "))", mime, filter, filter ? filter->src->super : "???", filter ? filter->src->type : "???", filter ? filter->dst->super : "???", filter ? filter->dst->super : "???", filter ? filter->cost : -1, filter ? CUPS_LLCAST filter->maxsize : CUPS_LLCAST -1)); if (!mime || !filter) return; #ifdef DEBUG if (!cupsArrayFind(mime->filters, filter)) DEBUG_puts("1mimeDeleteFilter: Filter not in MIME database."); #endif /* DEBUG */ cupsArrayRemove(mime->filters, filter); free(filter); /* * Deleting a filter invalidates the source lookup cache used by * mimeFilter()... */ if (mime->srcs) { DEBUG_puts("1mimeDeleteFilter: Deleting source lookup cache."); cupsArrayDelete(mime->srcs); mime->srcs = NULL; } }
static int /* O - 1 on success, 0 on failure */ load_words(const char *filename, /* I - File to load */ cups_array_t *array) /* I - Array to add to */ { FILE *fp; /* Test file */ char word[256]; /* Word from file */ if ((fp = fopen(filename, "r")) == NULL) { perror(filename); return (0); } while (fscanf(fp, "%255s", word) == 1) { if (!cupsArrayFind(array, word)) cupsArrayAdd(array, strdup(word)); } fclose(fp); return (1); }
static cups_device_t * /* O - Device */ get_device(cups_array_t *devices, /* I - Device array */ const char *serviceName, /* I - Name of service/device */ const char *regtype, /* I - Type of service */ const char *replyDomain) /* I - Service domain */ { cups_device_t key, /* Search key */ *device; /* Device */ char fullName[kDNSServiceMaxDomainName]; /* Full name for query */ /* * See if this is a new device... */ key.name = (char *)serviceName; key.type = device_type(regtype); for (device = cupsArrayFind(devices, &key); device; device = cupsArrayNext(devices)) if (_cups_strcasecmp(device->name, key.name)) break; else if (device->type == key.type) { if (!_cups_strcasecmp(device->domain, "local.") && _cups_strcasecmp(device->domain, replyDomain)) { /* * Update the .local listing to use the "global" domain name instead. * The backend will try local lookups first, then the global domain name. */ free(device->domain); device->domain = strdup(replyDomain); #ifdef HAVE_DNSSD DNSServiceConstructFullName(fullName, device->name, regtype, replyDomain); #else /* HAVE_AVAHI */ avahi_service_name_join(fullName, kDNSServiceMaxDomainName, serviceName, regtype, replyDomain); #endif /* HAVE_DNSSD */ free(device->fullName); device->fullName = strdup(fullName); } return (device); } /* * Yes, add the device... */ device = calloc(sizeof(cups_device_t), 1); device->name = strdup(serviceName); device->domain = strdup(replyDomain); device->type = key.type; device->priority = 50; cupsArrayAdd(devices, device); /* * Set the "full name" of this service, which is used for queries... */ #ifdef HAVE_DNSSD DNSServiceConstructFullName(fullName, serviceName, regtype, replyDomain); #else /* HAVE_AVAHI */ avahi_service_name_join(fullName, kDNSServiceMaxDomainName, serviceName, regtype, replyDomain); #endif /* HAVE_DNSSD */ device->fullName = strdup(fullName); return (device); }
static void ppd_mark_option(ppd_file_t *ppd, /* I - PPD file */ const char *option, /* I - Option name */ const char *choice) /* I - Choice name */ { int i, j; /* Looping vars */ ppd_option_t *o; /* Option pointer */ ppd_choice_t *c, /* Choice pointer */ *oldc, /* Old choice pointer */ key; /* Search key for choice */ struct lconv *loc; /* Locale data */ DEBUG_printf(("7ppd_mark_option(ppd=%p, option=\"%s\", choice=\"%s\")", ppd, option, choice)); /* * AP_D_InputSlot is the "default input slot" on MacOS X, and setting * it clears the regular InputSlot choices... */ if (!_cups_strcasecmp(option, "AP_D_InputSlot")) { cupsArraySave(ppd->options); if ((o = ppdFindOption(ppd, "InputSlot")) != NULL) { key.option = o; if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL) { oldc->marked = 0; cupsArrayRemove(ppd->marked, oldc); } } cupsArrayRestore(ppd->options); } /* * Check for custom options... */ cupsArraySave(ppd->options); o = ppdFindOption(ppd, option); cupsArrayRestore(ppd->options); if (!o) return; loc = localeconv(); if (!_cups_strncasecmp(choice, "Custom.", 7)) { /* * Handle a custom option... */ if ((c = ppdFindChoice(o, "Custom")) == NULL) return; if (!_cups_strcasecmp(option, "PageSize")) { /* * Handle custom page sizes... */ ppdPageSize(ppd, choice); } else { /* * Handle other custom options... */ ppd_coption_t *coption; /* Custom option */ ppd_cparam_t *cparam; /* Custom parameter */ char *units; /* Custom points units */ if ((coption = ppdFindCustomOption(ppd, option)) != NULL) { if ((cparam = (ppd_cparam_t *)cupsArrayFirst(coption->params)) == NULL) return; switch (cparam->type) { case PPD_CUSTOM_CURVE : case PPD_CUSTOM_INVCURVE : case PPD_CUSTOM_REAL : cparam->current.custom_real = (float)_cupsStrScand(choice + 7, NULL, loc); break; case PPD_CUSTOM_POINTS : cparam->current.custom_points = (float)_cupsStrScand(choice + 7, &units, loc); if (units) { if (!_cups_strcasecmp(units, "cm")) cparam->current.custom_points *= 72.0f / 2.54f; else if (!_cups_strcasecmp(units, "mm")) cparam->current.custom_points *= 72.0f / 25.4f; else if (!_cups_strcasecmp(units, "m")) cparam->current.custom_points *= 72.0f / 0.0254f; else if (!_cups_strcasecmp(units, "in")) cparam->current.custom_points *= 72.0f; else if (!_cups_strcasecmp(units, "ft")) cparam->current.custom_points *= 12.0f * 72.0f; } break; case PPD_CUSTOM_INT : cparam->current.custom_int = atoi(choice + 7); break; case PPD_CUSTOM_PASSCODE : case PPD_CUSTOM_PASSWORD : case PPD_CUSTOM_STRING : if (cparam->current.custom_string) _cupsStrFree(cparam->current.custom_string); cparam->current.custom_string = _cupsStrAlloc(choice + 7); break; } } } /* * Make sure that we keep the option marked below... */ choice = "Custom"; } else if (choice[0] == '{') { /* * Handle multi-value custom options... */ ppd_coption_t *coption; /* Custom option */ ppd_cparam_t *cparam; /* Custom parameter */ char *units; /* Custom points units */ int num_vals; /* Number of values */ cups_option_t *vals, /* Values */ *val; /* Value */ if ((c = ppdFindChoice(o, "Custom")) == NULL) return; if ((coption = ppdFindCustomOption(ppd, option)) != NULL) { num_vals = cupsParseOptions(choice, 0, &vals); for (i = 0, val = vals; i < num_vals; i ++, val ++) { if ((cparam = ppdFindCustomParam(coption, val->name)) == NULL) continue; switch (cparam->type) { case PPD_CUSTOM_CURVE : case PPD_CUSTOM_INVCURVE : case PPD_CUSTOM_REAL : cparam->current.custom_real = (float)_cupsStrScand(val->value, NULL, loc); break; case PPD_CUSTOM_POINTS : cparam->current.custom_points = (float)_cupsStrScand(val->value, &units, loc); if (units) { if (!_cups_strcasecmp(units, "cm")) cparam->current.custom_points *= 72.0f / 2.54f; else if (!_cups_strcasecmp(units, "mm")) cparam->current.custom_points *= 72.0f / 25.4f; else if (!_cups_strcasecmp(units, "m")) cparam->current.custom_points *= 72.0f / 0.0254f; else if (!_cups_strcasecmp(units, "in")) cparam->current.custom_points *= 72.0f; else if (!_cups_strcasecmp(units, "ft")) cparam->current.custom_points *= 12.0f * 72.0f; } break; case PPD_CUSTOM_INT : cparam->current.custom_int = atoi(val->value); break; case PPD_CUSTOM_PASSCODE : case PPD_CUSTOM_PASSWORD : case PPD_CUSTOM_STRING : if (cparam->current.custom_string) _cupsStrFree(cparam->current.custom_string); cparam->current.custom_string = _cupsStrRetain(val->value); break; } } cupsFreeOptions(num_vals, vals); } } else { for (i = o->num_choices, c = o->choices; i > 0; i --, c ++) if (!_cups_strcasecmp(c->choice, choice)) break; if (!i) return; } /* * Option found; mark it and then handle unmarking any other options. */ if (o->ui != PPD_UI_PICKMANY) { /* * Unmark all other choices... */ if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, c)) != NULL) { oldc->marked = 0; cupsArrayRemove(ppd->marked, oldc); } if (!_cups_strcasecmp(option, "PageSize") || !_cups_strcasecmp(option, "PageRegion")) { /* * Mark current page size... */ for (j = 0; j < ppd->num_sizes; j ++) ppd->sizes[j].marked = !_cups_strcasecmp(ppd->sizes[j].name, choice); /* * Unmark the current PageSize or PageRegion setting, as * appropriate... */ cupsArraySave(ppd->options); if (!_cups_strcasecmp(option, "PageSize")) { if ((o = ppdFindOption(ppd, "PageRegion")) != NULL) { key.option = o; if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL) { oldc->marked = 0; cupsArrayRemove(ppd->marked, oldc); } } } else { if ((o = ppdFindOption(ppd, "PageSize")) != NULL) { key.option = o; if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL) { oldc->marked = 0; cupsArrayRemove(ppd->marked, oldc); } } } cupsArrayRestore(ppd->options); } else if (!_cups_strcasecmp(option, "InputSlot")) { /* * Unmark ManualFeed option... */ cupsArraySave(ppd->options); if ((o = ppdFindOption(ppd, "ManualFeed")) != NULL) { key.option = o; if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL) { oldc->marked = 0; cupsArrayRemove(ppd->marked, oldc); } } cupsArrayRestore(ppd->options); } else if (!_cups_strcasecmp(option, "ManualFeed") && !_cups_strcasecmp(choice, "True")) { /* * Unmark InputSlot option... */ cupsArraySave(ppd->options); if ((o = ppdFindOption(ppd, "InputSlot")) != NULL) { key.option = o; if ((oldc = (ppd_choice_t *)cupsArrayFind(ppd->marked, &key)) != NULL) { oldc->marked = 0; cupsArrayRemove(ppd->marked, oldc); } } cupsArrayRestore(ppd->options); } } c->marked = 1; cupsArrayAdd(ppd->marked, c); }
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); }