From a35eb9ae781e7c03564aa8c706d6d6b78c87d5b7 Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Wed, 27 Dec 2023 11:17:02 -0500 Subject: [PATCH 1/6] Update mailing list info. --- DEVELOPING.md | 8 ++++---- README.md | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/DEVELOPING.md b/DEVELOPING.md index b841d37fb9..9fac6ea4e2 100644 --- a/DEVELOPING.md +++ b/DEVELOPING.md @@ -8,10 +8,10 @@ contributing to the CUPS project. How To Contact The Developers ----------------------------- -The Linux Foundation's "printing-architecture" mailing list is the primary means -of asking questions and informally discussing issues and feature requests with -the OpenPrinting developers. To subscribe or see the mailing list archives, go -to . +The Linux "printing-architecture" mailing list is the primary means of asking +questions and informally discussing issues and feature requests with the +OpenPrinting developers. To subscribe or see the mailing list archives, go +to . Interfaces diff --git a/README.md b/README.md index 97dbe18bdb..a5be1493cd 100644 --- a/README.md +++ b/README.md @@ -34,7 +34,7 @@ for more information. > and iOS at . [1]: https://support.apple.com/en-us/HT201311 -[2]: https://www.pwg.org/ipp/everywhere.html +[2]: https://www.pwg.org/printers [3]: https://github.com/openprinting/cups-filters From 8f91a015945c3d9fbcdf895d864a20343da05562 Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Wed, 27 Dec 2023 16:47:16 -0500 Subject: [PATCH 2/6] Clean up. --- CHANGES.md | 8 ++++---- cups/http-addrlist.c | 3 +-- 2 files changed, 5 insertions(+), 6 deletions(-) diff --git a/CHANGES.md b/CHANGES.md index 04905ec42f..a110a01377 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -4,20 +4,20 @@ CHANGES - OpenPrinting CUPS 2.5b1 - (TBA) Changes in CUPS v2.5b1 (TBA) ---------------------------- -- Added additional check on socket if `revents` from `poll()` returns POLLHUP - together with POLLIN or POLLOUT in `httpAddrConnect2()` (Issue #839) - Added `cupsDNSSD` APIs. - Added `cupsConcatString` and `cupsCopyString` string APIs. - Added a new argument value for `lpstat` argument '-W' - `successful` - to get successfully printed jobs (Issue #830) -- Added new API for form, JSON, JWT, IPP, raster +- Added new APIs for form, JSON, JWT, IPP, and raster setup. - Added OpenSSL support for `cupsHashData` (Issue #762) - Added warning if the device has to do IPP request for 'all,media-col-database' in separate requests (Issue #829) - Added driver filter to web interface (Issue #848) - Building with TLS support is now required - CUPS supports OpenSSL, GNUTLS - and LibreSSL + and LibreSSL. - Updated `cupsArray` APIs. +- Updated `httpAddrConnect2()` to handle `POLLHUP` together with `POLLIN` or + `POLLOUT` (Issue #839) - Fixed crash in `scan_ps()` if incoming argument is NULL (Issue #831) - Fixed Digest authentication support (Issue #260) - Fixed delays in lpd backend (Issue #741) diff --git a/cups/http-addrlist.c b/cups/http-addrlist.c index 436e21f8a2..2036d92c4b 100644 --- a/cups/http-addrlist.c +++ b/cups/http-addrlist.c @@ -312,7 +312,7 @@ httpAddrConnect2( { pfds[i].revents |= POLLERR; # ifdef DEBUG - DEBUG_printf(("1httpAddrConnect2: getsockopt returned: %d with error: %s", sres, strerror(serr))); + DEBUG_printf("1httpAddrConnect2: getsockopt returned: %d with error: %s", sres, strerror(serr)); # endif } else if (pfds[i].revents && (pfds[i].revents & POLLHUP) && (pfds[i].revents & (POLLIN | POLLOUT))) @@ -321,7 +321,6 @@ httpAddrConnect2( } } - if (pfds[i].revents && !(pfds[i].revents & (POLLERR | POLLHUP))) { *sock = fds[i]; From 49e662dd20d59584ada0ca75ce34ed629e4476d6 Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Fri, 29 Dec 2023 09:02:57 -0500 Subject: [PATCH 3/6] Add media-source to media-col-ready for iOS 17+ (Issue #738) --- CHANGES.md | 43 ++++++++++++++++++++++--------------------- scheduler/printers.c | 10 +++++++++- 2 files changed, 31 insertions(+), 22 deletions(-) diff --git a/CHANGES.md b/CHANGES.md index a110a01377..398d844620 100644 --- a/CHANGES.md +++ b/CHANGES.md @@ -6,40 +6,41 @@ Changes in CUPS v2.5b1 (TBA) - Added `cupsDNSSD` APIs. - Added `cupsConcatString` and `cupsCopyString` string APIs. -- Added a new argument value for `lpstat` argument '-W' - `successful` - - to get successfully printed jobs (Issue #830) - Added new APIs for form, JSON, JWT, IPP, and raster setup. - Added OpenSSL support for `cupsHashData` (Issue #762) - Added warning if the device has to do IPP request for 'all,media-col-database' in separate requests (Issue #829) +- Added a new argument value for `lpstat` argument '-W' - `successful` - + to get successfully printed jobs (Issue #830) - Added driver filter to web interface (Issue #848) -- Building with TLS support is now required - CUPS supports OpenSSL, GNUTLS - and LibreSSL. -- Updated `cupsArray` APIs. +- Updated CUPS to require TLS support - OpenSSL, GNUTLS and LibreSSL are + supported. +- Updated CUPS to require ZLIB. +- Updated CUPS to require support for `poll` API. +- Updated `cupsArray` APIs to support modern naming and types. +- Updated `cups_enum_dests()` timeout for listing available IPP printers (Issue #751) - Updated `httpAddrConnect2()` to handle `POLLHUP` together with `POLLIN` or `POLLOUT` (Issue #839) -- Fixed crash in `scan_ps()` if incoming argument is NULL (Issue #831) +- Fixed use-after-free in `cupsdAcceptClient()` when we log warning during error + handling (fixes CVE-2023-34241) +- Fixed hanging of `lpstat` on Solaris (Issue #156) - Fixed Digest authentication support (Issue #260) -- Fixed delays in lpd backend (Issue #741) - Fixed extensive looping in scheduler (Issue #604) -- Fixed hanging of `lpstat` on IBM AIX (Issue #773) -- Fixed hanging of `lpstat` on Solaris (Issue #156) -- Fixed memory leak when creating color profiles (Issue #814) -- Fixed memory leak when unloading a job (Issue #813) +- Fixed printing multiple files on specific printers (Issue #643) - Fixed segfault in `cupsGetNamedDest()` when trying to get default printer, but the default printer is not set (Issue #719) -- Fixed setting job state reasons for successful jobs (Issue #832) -- Fixed RFC 1179 port reserving behavior in LPD backend (Issue #743) -- Fixed printing multiple files on specific printers (Issue #643) -- Fixed printing to stderr if we can't open cups-files.conf (Issue #777) +- Fixed ready media support for iOS 17+ (Issue #738) +- Fixed delays in lpd backend (Issue #741) - Fixed purging job files via `cancel -x` (Issue #742) -- Fixed use-after-free in `cupsdAcceptClient()` when we log warning during error - handling (fixes CVE-2023-34241) +- Fixed RFC 1179 port reserving behavior in LPD backend (Issue #743) - Fixed a bug in the PPD command interpretation code (Issue #768) -- Raised `cups_enum_dests()` timeout for listing available IPP printers (Issue #751) -- Removed `HAVE_LIBZ` and `HAVE_POLL` defines, making CUPS to depend - on the functionality -- Removed hash support for SHA2-512-224 and SHA2-512-256 +- Fixed hanging of `lpstat` on IBM AIX (Issue #773) +- Fixed printing to stderr if we can't open cups-files.conf (Issue #777) +- Fixed memory leak when unloading a job (Issue #813) +- Fixed memory leak when creating color profiles (Issue #814) +- Fixed crash in `scan_ps()` if incoming argument is NULL (Issue #831) +- Fixed setting job state reasons for successful jobs (Issue #832) +- Removed hash support for SHA2-512-224 and SHA2-512-256. - Removed `mantohtml` script for generating html pages (use `https://www.msweet.org/mantohtml/`) - Removed SSPI and Security.framework support (CDSA) diff --git a/scheduler/printers.c b/scheduler/printers.c index 7bca3bdc9b..fc0bc36c28 100644 --- a/scheduler/printers.c +++ b/scheduler/printers.c @@ -4485,7 +4485,8 @@ load_ppd(cupsd_printer_t *p) /* I - Printer */ for (media_col_ready = NULL, media_ready = NULL, i = p->pc->num_sizes, pwgsize = p->pc->sizes; i > 0; i --, pwgsize ++) { - ipp_t *col; // media-col-ready value + ipp_t *col; // media-col-ready value + char source[128]; // media-source value // Skip printer sizes that don't have a PPD size or aren't in the ready // sizes array... @@ -4501,6 +4502,13 @@ load_ppd(cupsd_printer_t *p) /* I - Printer */ // Add or append a media-col-ready value col = new_media_col(pwgsize); + // Add "media-source" for iOS 17 (Issue #738) + if (media_col_ready) + snprintf(source, sizeof(source), "auto.%d", ippGetCount(media_col_ready) + 1); + else + cupsCopyString(source, "auto", sizeof(source)); + ippAddString(col, IPP_TAG_PRINTER, IPP_TAG_KEYWORD, "media-source", NULL, source); + if (media_col_ready) ippSetCollection(p->ppd_attrs, &media_col_ready, ippGetCount(media_col_ready), col); else From 61a9e419eec22493f7b07d9eeee4096525465f93 Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Fri, 29 Dec 2023 09:16:00 -0500 Subject: [PATCH 4/6] Final cleanup for 'make unittests' to be separate from 'make test' (Issue #612) --- backend/Makefile | 7 +++++++ cgi-bin/Makefile | 14 ++++++++++---- scheduler/Makefile | 22 +++++++++++----------- 3 files changed, 28 insertions(+), 15 deletions(-) diff --git a/backend/Makefile b/backend/Makefile index d53e971d18..2074e4ce85 100644 --- a/backend/Makefile +++ b/backend/Makefile @@ -171,6 +171,13 @@ uninstall: -$(RMDIR) $(SERVERBIN) +# +# Run unit tests... (doesn't actually run these currently) +# + +test: unittests + + # # test1284 # diff --git a/cgi-bin/Makefile b/cgi-bin/Makefile index 5a1b4e5004..00ff4a5460 100644 --- a/cgi-bin/Makefile +++ b/cgi-bin/Makefile @@ -141,6 +141,16 @@ uninstall: -$(RMDIR) $(SERVERBIN)/cgi-bin +# +# Run unit tests... +# + +test: unittests + echo Testing CGI API... + ./testcgi + echo Testing help index API... + ./testhi + # # libcupscgi.a # @@ -211,8 +221,6 @@ testcgi: testcgi.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC) $(LD_CC) $(ARCHFLAGS) $(ALL_LDFLAGS) -o $@ testcgi.o libcupscgi.a \ $(LINKCUPSSTATIC) $(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@ - echo Testing CGI API... - ./testcgi # @@ -224,8 +232,6 @@ testhi: testhi.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC) $(LD_CC) $(ARCHFLAGS) $(ALL_LDFLAGS) -o $@ testhi.o libcupscgi.a \ $(LINKCUPSSTATIC) $(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@ - echo Testing help index API... - ./testhi # diff --git a/scheduler/Makefile b/scheduler/Makefile index e00d62c8ec..9d6f3a02b3 100644 --- a/scheduler/Makefile +++ b/scheduler/Makefile @@ -101,17 +101,6 @@ libs: unittests: $(UNITTARGETS) -# -# Run unit tests... -# - -test: unittests - echo "Tests started at $(date)..." >test.log - echo Running MIME API tests... - ./testmime >>test.log - echo "Tests finished at $(date)..." >>test.log - - # # Clean all object files... # @@ -321,6 +310,17 @@ uninstall: fi +# +# Run unit tests... +# + +test: unittests + echo "Tests started at $(date)..." >test.log + echo Running MIME API tests... + ./testmime >>test.log + echo "Tests finished at $(date)..." >>test.log + + # # Make the scheduler executable, "cupsd". # From 81a89f7c96e5eaab124e79d50cae84ebe53d907a Mon Sep 17 00:00:00 2001 From: Michael R Sweet Date: Sun, 31 Dec 2023 09:49:03 -0500 Subject: [PATCH 5/6] Update CUPS programming manual for some of the new APIs and recommendations. --- cups/cupspm.md | 1184 +++++++++++++++++++++++++----------------- doc/help/cupspm.epub | Bin 234435 -> 236961 bytes doc/help/cupspm.html | 663 +++++++++++++---------- 3 files changed, 1109 insertions(+), 738 deletions(-) diff --git a/cups/cupspm.md b/cups/cupspm.md index d963d42a21..eb326920ce 100644 --- a/cups/cupspm.md +++ b/cups/cupspm.md @@ -71,25 +71,27 @@ to compile a simple program (shown below) in two common environments. The following simple program lists the available destinations: - #include - #include +```c +#include +#include - int print_dest(void *user_data, unsigned flags, cups_dest_t *dest) - { - if (dest->instance) - printf("%s/%s\n", dest->name, dest->instance); - else - puts(dest->name); +int print_dest(void *user_data, unsigned flags, cups_dest_t *dest) +{ + if (dest->instance) + printf("%s/%s\n", dest->name, dest->instance); + else + puts(dest->name); - return (1); - } + return (1); +} - int main(void) - { - cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, 0, 0, print_dest, NULL); +int main(void) +{ + cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, 0, 0, print_dest, NULL); - return (0); - } + return (0); +} +``` ### Compiling with Xcode @@ -113,11 +115,11 @@ From the command-line, create a file called `simple.c` using your favorite editor, copy the example to this file, and save. Then run the following command to compile it with GCC and run it: - gcc -o simple `cups-config --cflags` simple.c `cups-config --libs` + gcc -o simple `pkg-config --cflags cups` simple.c `pkg-config --libs cups` ./simple -The `cups-config` command provides the compiler flags (`cups-config --cflags`) -and libraries (`cups-config --libs`) needed for the local system. +The `pkg-config` command provides the compiler flags (`pkg-config --cflags cups`) +and libraries (`pkg-config --libs cups`) needed for the local system. # Working with Destinations @@ -136,12 +138,14 @@ the current network. ## Finding Available Destinations -The `cupsEnumDests` function finds all of the available destinations: +The [`cupsEnumDests`](@@) function finds all of the available destinations: - int - cupsEnumDests(unsigned flags, int msec, int *cancel, - cups_ptype_t type, cups_ptype_t mask, - cups_dest_cb_t cb, void *user_data) +```c +int +cupsEnumDests(unsigned flags, int msec, int *cancel, + cups_ptype_t type, cups_ptype_t mask, + cups_dest_cb_t cb, void *user_data) +``` The `flags` argument specifies enumeration options, which at present must be `CUPS_DEST_FLAGS_NONE`. @@ -187,9 +191,11 @@ can be used for filtering: The `cb` argument specifies a function to call for every destination that is found: - typedef int (*cups_dest_cb_t)(void *user_data, - unsigned flags, - cups_dest_t *dest); +```c +typedef int (*cups_dest_cb_t)(void *user_data, + unsigned flags, + cups_dest_t *dest); +``` The callback function receives a copy of the `user_data` argument along with a bitfield \(`flags`) and the destination that was found. The `flags` argument @@ -199,9 +205,10 @@ can have any of the following constant (bit) values set: - `CUPS_DEST_FLAGS_REMOVED`: The destination has gone away and should be removed from the list of destinations a user can select. - `CUPS_DEST_FLAGS_ERROR`: An error occurred. The reason for the error can be - found by calling the `cupsLastError` and/or `cupsLastErrorString` functions. + found by calling the [`cupsGetError`](@@) and/or [`cupsGetErrorString`](@@) + functions. -The callback function returns 0 to stop enumeration or 1 to continue. +The callback function returns `0` to stop enumeration or `1` to continue. > **Note:** > @@ -212,71 +219,73 @@ The callback function returns 0 to stop enumeration or 1 to continue. The following example shows how to use `cupsEnumDests` to get a filtered array of destinations: - typedef struct - { - int num_dests; - cups_dest_t *dests; - } my_user_data_t; - - int - my_dest_cb(my_user_data_t *user_data, unsigned flags, - cups_dest_t *dest) - { - if (flags & CUPS_DEST_FLAGS_REMOVED) - { - /* - * Remove destination from array... - */ - - user_data->num_dests = - cupsRemoveDest(dest->name, dest->instance, - user_data->num_dests, - &(user_data->dests)); - } - else - { - /* - * Add destination to array... - */ - - user_data->num_dests = - cupsCopyDest(dest, user_data->num_dests, - &(user_data->dests)); - } - - return (1); - } - - int - my_get_dests(cups_ptype_t type, cups_ptype_t mask, - cups_dest_t **dests) - { - my_user_data_t user_data = { 0, NULL }; - - if (!cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, type, - mask, (cups_dest_cb_t)my_dest_cb, - &user_data)) - { - /* - * An error occurred, free all of the destinations and - * return... - */ - - cupsFreeDests(user_data.num_dests, user_data.dests); - - *dests = NULL; - - return (0); - } - - /* - * Return the destination array... - */ - - *dests = user_data.dests; - - return (user_data.num_dests); - } +```c +typedef struct +{ + int num_dests; + cups_dest_t *dests; +} my_user_data_t; + +int +my_dest_cb(my_user_data_t *user_data, unsigned flags, + cups_dest_t *dest) +{ + if (flags & CUPS_DEST_FLAGS_REMOVED) + { + /* + * Remove destination from array... + */ + + user_data->num_dests = + cupsRemoveDest(dest->name, dest->instance, + user_data->num_dests, + &(user_data->dests)); + } + else + { + /* + * Add destination to array... + */ + + user_data->num_dests = + cupsCopyDest(dest, user_data->num_dests, + &(user_data->dests)); + } + + return (1); +} + +int +my_get_dests(cups_ptype_t type, cups_ptype_t mask, + cups_dest_t **dests) +{ + my_user_data_t user_data = { 0, NULL }; + + if (!cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, type, + mask, (cups_dest_cb_t)my_dest_cb, + &user_data)) + { + /* + * An error occurred, free all of the destinations and + * return... + */ + + cupsFreeDests(user_data.num_dests, user_data.dests); + + *dests = NULL; + + return (0); + } + + /* + * Return the destination array... + */ + + *dests = user_data.dests; + + return (user_data.num_dests); +} +``` ## Basic Destination Information @@ -309,21 +318,25 @@ destination attributes: - "printer-uri-supported": The URI associated with the destination; if not set, this destination was discovered but is not yet setup as a local printer. -Use the `cupsGetOption` function to retrieve the value. For example, the +Use the [`cupsGetOption`](@@) function to retrieve the value. For example, the following code gets the make and model of a destination: - const char *model = cupsGetOption("printer-make-and-model", - dest->num_options, - dest->options); +```c +const char *model = cupsGetOption("printer-make-and-model", + dest->num_options, + dest->options); +``` ## Detailed Destination Information -Once a destination has been chosen, the `cupsCopyDestInfo` function can be used -to gather detailed information about the destination: +Once a destination has been chosen, the [`cupsCopyDestInfo`](@@) function can be +used to gather detailed information about the destination: - cups_dinfo_t * - cupsCopyDestInfo(http_t *http, cups_dest_t *dest); +```c +cups_dinfo_t * +cupsCopyDestInfo(http_t *http, cups_dest_t *dest); +``` The `http` argument specifies a connection to the CUPS scheduler and is typically the constant `CUPS_HTTP_DEFAULT`. The `dest` argument specifies the @@ -337,14 +350,16 @@ to resolve those constraints. ### Getting Supported Options and Values -The `cupsCheckDestSupported` function can be used to test whether a particular -option or option and value is supported: +The [`cupsCheckDestSupported`](@@) function can be used to test whether a +particular option or option and value is supported: - int - cupsCheckDestSupported(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info, - const char *option, - const char *value); +```c +int +cupsCheckDestSupported(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info, + const char *option, + const char *value); +``` The `option` argument specifies the name of the option to check. The following constants can be used to check the various standard options: @@ -386,46 +401,57 @@ If the `value` argument is `NULL`, the `cupsCheckDestSupported` function returns whether the option is supported by the destination. Otherwise, the function returns whether the specified value of the option is supported. -The `cupsFindDestSupported` function returns the IPP attribute containing the -supported values for a given option: +The [`cupsFindDestSupported`](@@) function returns the IPP attribute containing +the supported values for a given option: - ipp_attribute_t * - cupsFindDestSupported(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, - const char *option); +```c +ipp_attribute_t * +cupsFindDestSupported(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, + const char *option); +``` For example, the following code prints the supported finishing processes for a destination, if any, to the standard output: - cups_dinfo_t *info = cupsCopyDestInfo(CUPS_HTTP_DEFAULT, - dest); +```c +cups_dinfo_t *info = cupsCopyDestInfo(CUPS_HTTP_DEFAULT, + dest); - if (cupsCheckDestSupported(CUPS_HTTP_DEFAULT, dest, info, - CUPS_FINISHINGS, NULL)) - { - ipp_attribute_t *finishings = - cupsFindDestSupported(CUPS_HTTP_DEFAULT, dest, info, - CUPS_FINISHINGS); - int i, count = ippGetCount(finishings); - - puts("finishings supported:"); - for (i = 0; i < count; i ++) - printf(" %d\n", ippGetInteger(finishings, i)); - } - else - puts("finishings not supported."); +if (cupsCheckDestSupported(CUPS_HTTP_DEFAULT, dest, info, + CUPS_FINISHINGS, NULL)) +{ + ipp_attribute_t *finishings = + cupsFindDestSupported(CUPS_HTTP_DEFAULT, dest, info, + CUPS_FINISHINGS); + int i, count = ippGetCount(finishings); + + puts("finishings supported:"); + for (i = 0; i < count; i ++) + { + int val = ippGetInteger(finishings, i); + printf(" %d (%s)\n", val, + ippEnumString("finishings", val)); +} +else +{ + puts("finishings not supported."); +} +``` The "job-creation-attributes" option can be queried to get a list of supported options. For example, the following code prints the list of supported options to the standard output: - ipp_attribute_t *attrs = - cupsFindDestSupported(CUPS_HTTP_DEFAULT, dest, info, - "job-creation-attributes"); - int i, count = ippGetCount(attrs); +```c +ipp_attribute_t *attrs = + cupsFindDestSupported(CUPS_HTTP_DEFAULT, dest, info, + "job-creation-attributes"); +int i, count = ippGetCount(attrs); - for (i = 0; i < count; i ++) - puts(ippGetString(attrs, i, NULL)); +for (i = 0; i < count; i ++) + puts(ippGetString(attrs, i, NULL)); +``` ### Getting Default Values @@ -433,39 +459,43 @@ to the standard output: There are two sets of default values - user defaults that are available via the `num_options` and `options` members of the `cups_dest_t` structure, and destination defaults that available via the `cups_dinfo_t` structure and the -`cupsFindDestDefault` function which returns the IPP attribute containing the -default value(s) for a given option: - - ipp_attribute_t * - cupsFindDestDefault(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, - const char *option); - -The user defaults from `cupsGetOption` should always take preference over the -destination defaults. For example, the following code prints the default +[`cupsFindDestDefault`](@@) function which returns the IPP attribute containing +the default value(s) for a given option: + +```c +ipp_attribute_t * +cupsFindDestDefault(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, + const char *option); +``` + +The user defaults from [`cupsGetOption`](@@) should always take preference over +the destination defaults. For example, the following code prints the default finishings value(s) to the standard output: - const char *def_value = - cupsGetOption(CUPS_FINISHINGS, dest->num_options, - dest->options); - ipp_attribute_t *def_attr = - cupsFindDestDefault(CUPS_HTTP_DEFAULT, dest, info, - CUPS_FINISHINGS); - - if (def_value != NULL) - { - printf("Default finishings: %s\n", def_value); - } - else - { - int i, count = ippGetCount(def_attr); - - printf("Default finishings: %d", - ippGetInteger(def_attr, 0)); - for (i = 1; i < count; i ++) - printf(",%d", ippGetInteger(def_attr, i)); - putchar('\n'); - } +```c +const char *def_value = + cupsGetOption(CUPS_FINISHINGS, dest->num_options, + dest->options); +ipp_attribute_t *def_attr = + cupsFindDestDefault(CUPS_HTTP_DEFAULT, dest, info, + CUPS_FINISHINGS); + +if (def_value != NULL) +{ + printf("Default finishings: %s\n", def_value); +} +else +{ + int i, count = ippGetCount(def_attr); + + printf("Default finishings: %d", + ippGetInteger(def_attr, 0)); + for (i = 1; i < count; i ++) + printf(",%d", ippGetInteger(def_attr, i)); + putchar('\n'); +} +``` ### Getting Ready (Loaded) Values @@ -478,66 +508,90 @@ Similarly, a printer may support hundreds of different sizes of media but only have a single size loaded at any given time - the ready values are limited to the media that is actually in the printer. -The `cupsFindDestReady` function finds the IPP attribute containing the ready -values for a given option: +The [`cupsFindDestReady`](@@) function finds the IPP attribute containing the +ready values for a given option: - ipp_attribute_t * - cupsFindDestReady(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, const char *option); +```c +ipp_attribute_t * +cupsFindDestReady(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, const char *option); +``` For example, the following code lists the ready finishing processes: - ipp_attribute_t *ready_finishings = - cupsFindDestReady(CUPS_HTTP_DEFAULT, dest, info, - CUPS_FINISHINGS); - - if (ready_finishings != NULL) - { - int i, count = ippGetCount(ready_finishings); - - puts("finishings ready:"); - for (i = 0; i < count; i ++) - printf(" %d\n", ippGetInteger(ready_finishings, i)); - } - else - puts("no finishings are ready."); - - -### Media Size Options - -CUPS provides functions for querying the dimensions and margins for each of the -supported media size options. The `cups_size_t` structure is used to describe a -media size: - - typedef struct cups_size_s - { - char media[128]; - int width, length; - int bottom, left, right, top; - } cups_size_t; +```c +ipp_attribute_t *ready_finishings = + cupsFindDestReady(CUPS_HTTP_DEFAULT, dest, info, + CUPS_FINISHINGS); + +if (ready_finishings != NULL) +{ + int i, count = ippGetCount(ready_finishings); + + puts("finishings ready:"); + for (i = 0; i < count; i ++) + { + int val = ippGetInteger(ready_finishings, i); + printf(" %d (%s)\n", val, + ippEnumString("finishings", val)); +} +else +{ + puts("no finishings are ready."); +} +``` + + +### Media Options + +CUPS provides functions for querying the dimensions, margins, color, source +(tray/roll), and type for each of the supported media size options. The +`cups_media_t` structure is used to describe media: + +```c +typedef struct cups_media_s +{ + char media[128]; + char color[128]; + char source[128]; + char type[128]; + int width, length; + int bottom, left, right, top; +} cups_media_t; +``` + +The "media" member specifies a PWG self-describing media size name such as +"na\_letter\_8.5x11in", "iso\_a4\_210x297mm", etc. The "color" member specifies +a PWG media color name such as "white", "blue", etc. The "source" member +specifies a standard keyword for the paper tray or roll such as "tray-1", +"manual", "by-pass-tray" (multi-purpose tray), etc. The "type" member specifies +a PWG media type name such as "stationery" (plain paper), "photographic", +"envelope", "transparency", etc. The `width` and `length` members specify the dimensions of the media in hundredths of millimeters (1/2540th of an inch). The `bottom`, `left`, `right`, and `top` members specify the margins of the printable area, also in hundredths of millimeters. -The `cupsGetDestMediaByName` and `cupsGetDestMediaBySize` functions lookup the -media size information using a standard media size name or dimensions in -hundredths of millimeters: +The [`cupsGetDestMediaByName2`](@@) and [`cupsGetDestMediaBySize2`](@@) +functions lookup the media information using a standard media size name or +dimensions in hundredths of millimeters: - int - cupsGetDestMediaByName(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, - const char *media, - unsigned flags, cups_size_t *size); +```c +bool +cupsGetDestMediaByName2(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, + const char *name, + unsigned flags, cups_media_t *media); - int - cupsGetDestMediaBySize(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, - int width, int length, - unsigned flags, cups_size_t *size); +bool +cupsGetDestMediaBySize2(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, + int width, int length, + unsigned flags, cups_media_t *media); +``` -The `media`, `width`, and `length` arguments specify the size to lookup. The +The `name`, `width`, and `length` arguments specify the size to lookup. The `flags` argument specifies a bitfield controlling various lookup options: - `CUPS_MEDIA_FLAGS_DEFAULT`: Find the closest size supported by the printer. @@ -549,104 +603,150 @@ The `media`, `width`, and `length` arguments specify the size to lookup. The "ready" media. If a matching size is found for the destination, the size information is stored -in the structure pointed to by the `size` argument and 1 is returned. Otherwise -0 is returned. +in the structure pointed to by the `media` argument and `true` is returned. +Otherwise `false` is returned. For example, the following code prints the margins for two-sided printing on US Letter media: - cups_size_t size; - - if (cupsGetDestMediaByName(CUPS_HTTP_DEFAULT, dest, info, - CUPS_MEDIA_LETTER, - CUPS_MEDIA_FLAGS_DUPLEX, &size)) - { - puts("Margins for duplex US Letter:"); - printf(" Bottom: %.2fin\n", size.bottom / 2540.0); - printf(" Left: %.2fin\n", size.left / 2540.0); - printf(" Right: %.2fin\n", size.right / 2540.0); - printf(" Top: %.2fin\n", size.top / 2540.0); - } - else - puts("Margins for duplex US Letter are not available."); +```c +cups_media_t media: + +if (cupsGetDestMediaByName2(CUPS_HTTP_DEFAULT, dest, info, + CUPS_MEDIA_LETTER, + CUPS_MEDIA_FLAGS_DUPLEX, &size)) +{ + puts("Margins for duplex US Letter:"); + printf(" Bottom: %.2fin\n", media.bottom / 2540.0); + printf(" Left: %.2fin\n", media.left / 2540.0); + printf(" Right: %.2fin\n", media.right / 2540.0); + printf(" Top: %.2fin\n", media.top / 2540.0); +} +else +{ + puts("Margins for duplex US Letter are not available."); +} +``` You can also enumerate all of the sizes that match a given `flags` value using -the `cupsGetDestMediaByIndex` and `cupsGetDestMediaCount` functions: +the [`cupsGetDestMediaByIndex2`](@@) and [`cupsGetDestMediaCount`](@@) +functions: - int - cupsGetDestMediaByIndex(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, int n, - unsigned flags, cups_size_t *size); +```c +bool +cupsGetDestMediaByIndex2(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, size_t n, + unsigned flags, cups_media_t *media); - int - cupsGetDestMediaCount(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, unsigned flags); +int +cupsGetDestMediaCount(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, unsigned flags); +``` For example, the following code prints the list of ready media and corresponding margins: - cups_size_t size; - int i; - int count = cupsGetDestMediaCount(CUPS_HTTP_DEFAULT, - dest, info, - CUPS_MEDIA_FLAGS_READY); - - for (i = 0; i < count; i ++) - { - if (cupsGetDestMediaByIndex(CUPS_HTTP_DEFAULT, dest, info, - i, CUPS_MEDIA_FLAGS_READY, - &size)) - { - printf("%s:\n", size.name); - printf(" Width: %.2fin\n", size.width / 2540.0); - printf(" Length: %.2fin\n", size.length / 2540.0); - printf(" Bottom: %.2fin\n", size.bottom / 2540.0); - printf(" Left: %.2fin\n", size.left / 2540.0); - printf(" Right: %.2fin\n", size.right / 2540.0); - printf(" Top: %.2fin\n", size.top / 2540.0); - } - } - -Finally, the `cupsGetDestMediaDefault` function returns the default media size: - - int - cupsGetDestMediaDefault(http_t *http, cups_dest_t *dest, - cups_dinfo_t *dinfo, unsigned flags, - cups_size_t *size); +```c +cups_media_t media; +size_t i; +size_t count = (size_t)cupsGetDestMediaCount(CUPS_HTTP_DEFAULT, + dest, info, + CUPS_MEDIA_FLAGS_READY); + +for (i = 0; i < count; i ++) +{ + if (cupsGetDestMediaByIndex2(CUPS_HTTP_DEFAULT, dest, info, + i, CUPS_MEDIA_FLAGS_READY, + &media)) + { + printf("%s:\n", media.name); + printf(" Width: %.2fin\n", media.width / 2540.0); + printf(" Length: %.2fin\n", media.length / 2540.0); + printf(" Bottom: %.2fin\n", media.bottom / 2540.0); + printf(" Left: %.2fin\n", media.left / 2540.0); + printf(" Right: %.2fin\n", media.right / 2540.0); + printf(" Top: %.2fin\n", media.top / 2540.0); + } +} +``` + +Finally, the [`cupsGetDestMediaDefault2`](@@) function returns the default +media: + +```c +int +cupsGetDestMediaDefault2(http_t *http, cups_dest_t *dest, + cups_dinfo_t *dinfo, unsigned flags, + cups_media_t *media); +``` ### Localizing Options and Values CUPS provides three functions to get localized, human-readable strings in the -user's current locale for options and values: `cupsLocalizeDestMedia`, -`cupsLocalizeDestOption`, and `cupsLocalizeDestValue`: - - const char * - cupsLocalizeDestMedia(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info, unsigned flags, - cups_size_t *size); +user's current locale for options and values: [`cupsLocalizeDestMedia2`](@@), +[`cupsLocalizeDestOption`](@@), and [`cupsLocalizeDestValue`](@@): + +```c +const char * +cupsLocalizeDestMedia2(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info, unsigned flags, + cups_media_t *media); + +const char * +cupsLocalizeDestOption(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info, + const char *option); + +const char * +cupsLocalizeDestValue(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info, + const char *option, const char *value); +``` - const char * - cupsLocalizeDestOption(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info, - const char *option); - - const char * - cupsLocalizeDestValue(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info, - const char *option, const char *value); +> **Note:** +> +> These functions require a valid `http_t` connection to work. Use the +> [`cupsConnectDest`](@@) function to connect to the destination for its +> localization information. + +For example, the following code will list the localized media names for a +destination: + +```c +char resource[256]; +http_t *http = cupsConnectDest(dest, CUPS_DEST_FLAGS_NONE, + /*msec*/30000, /*cancel*/NULL, + resource, sizeof(resource), + /*dest_cb*/NULL, /*user_data*/NULL); + +size_t i; +size_t count = (size_t)cupsGetDestMediaCount(http, dest, info, + CUPS_MEDIA_FLAGS_DEFAULT); +cups_media_t media; +for (i = 0; i < count; i ++) +{ + if (cupsGetDestMediaByIndex2(http, dest, info, i, + CUPS_MEDIA_FLAGS_DEFAULT, &media)) + printf("%s: %s\n", media.name, + cupsLocalizeDestMedia2(http, dest, info, + CUPS_MEDIA_FLAGS_DEFAULT, &media)); +} +``` ## Submitting a Print Job Once you are ready to submit a print job, you create a job using the -`cupsCreateDestJob` function: +[`cupsCreateDestJob`](@@) function: - ipp_status_t - cupsCreateDestJob(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info, int *job_id, - const char *title, int num_options, - cups_option_t *options); +```c +ipp_status_t +cupsCreateDestJob(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info, int *job_id, + const char *title, int num_options, + cups_option_t *options); +``` The `title` argument specifies a name for the print job such as "My Document". The `num_options` and `options` arguments specify the options for the print @@ -659,54 +759,58 @@ error status is returned. For example, the following code creates a new job that will print 42 copies of a two-sided US Letter document: - int job_id = 0; - int num_options = 0; - cups_option_t *options = NULL; - - num_options = cupsAddOption(CUPS_COPIES, "42", - num_options, &options); - num_options = cupsAddOption(CUPS_MEDIA, CUPS_MEDIA_LETTER, - num_options, &options); - num_options = cupsAddOption(CUPS_SIDES, - CUPS_SIDES_TWO_SIDED_PORTRAIT, - num_options, &options); - - if (cupsCreateDestJob(CUPS_HTTP_DEFAULT, dest, info, - &job_id, "My Document", num_options, - options) == IPP_STATUS_OK) - printf("Created job: %d\n", job_id); - else - printf("Unable to create job: %s\n", - cupsLastErrorString()); +```c +int job_id = 0; +int num_options = 0; +cups_option_t *options = NULL; + +num_options = cupsAddOption(CUPS_COPIES, "42", + num_options, &options); +num_options = cupsAddOption(CUPS_MEDIA, CUPS_MEDIA_LETTER, + num_options, &options); +num_options = cupsAddOption(CUPS_SIDES, + CUPS_SIDES_TWO_SIDED_PORTRAIT, + num_options, &options); + +if (cupsCreateDestJob(CUPS_HTTP_DEFAULT, dest, info, + &job_id, "My Document", num_options, + options) == IPP_STATUS_OK) + printf("Created job: %d\n", job_id); +else + printf("Unable to create job: %s\n", + cupsGetErrorString()); +``` Once the job is created, you submit documents for the job using the -`cupsStartDestDocument`, `cupsWriteRequestData`, and `cupsFinishDestDocument` -functions: - - http_status_t - cupsStartDestDocument(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info, int job_id, - const char *docname, - const char *format, - int num_options, - cups_option_t *options, - int last_document); - - http_status_t - cupsWriteRequestData(http_t *http, const char *buffer, - size_t length); - - ipp_status_t - cupsFinishDestDocument(http_t *http, cups_dest_t *dest, - cups_dinfo_t *info); +[`cupsStartDestDocument`](@@), [`cupsWriteRequestData`](@@), and +[`cupsFinishDestDocument`](@@) functions: + +```c +http_status_t +cupsStartDestDocument(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info, int job_id, + const char *docname, + const char *format, + int num_options, + cups_option_t *options, + int last_document); + +http_status_t +cupsWriteRequestData(http_t *http, const char *buffer, + size_t length); + +ipp_status_t +cupsFinishDestDocument(http_t *http, cups_dest_t *dest, + cups_dinfo_t *info); +``` The `docname` argument specifies the name of the document, typically the original filename. The `format` argument specifies the MIME media type of the document, including the following constants: +- `CUPS_FORMAT_AUTO`: "application/octet-stream" - `CUPS_FORMAT_JPEG`: "image/jpeg" - `CUPS_FORMAT_PDF`: "application/pdf" -- `CUPS_FORMAT_POSTSCRIPT`: "application/postscript" - `CUPS_FORMAT_TEXT`: "text/plain" The `num_options` and `options` arguments specify per-document print options, @@ -716,28 +820,32 @@ whether this is the last document in the job. For example, the following code submits a PDF file to the job that was just created: - FILE *fp = fopen("filename.pdf", "rb"); - size_t bytes; - char buffer[65536]; - - if (cupsStartDestDocument(CUPS_HTTP_DEFAULT, dest, info, - job_id, "filename.pdf", 0, NULL, - 1) == HTTP_STATUS_CONTINUE) - { - while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) - if (cupsWriteRequestData(CUPS_HTTP_DEFAULT, buffer, - bytes) != HTTP_STATUS_CONTINUE) - break; - - if (cupsFinishDestDocument(CUPS_HTTP_DEFAULT, dest, - info) == IPP_STATUS_OK) - puts("Document send succeeded."); - else - printf("Document send failed: %s\n", - cupsLastErrorString()); - } - - fclose(fp); +```c +FILE *fp = fopen("filename.pdf", "rb"); +size_t bytes; +char buffer[65536]; + +if (cupsStartDestDocument(CUPS_HTTP_DEFAULT, dest, info, + job_id, "filename.pdf", 0, NULL, + 1) == HTTP_STATUS_CONTINUE) +{ + while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) + { + if (cupsWriteRequestData(CUPS_HTTP_DEFAULT, buffer, + bytes) != HTTP_STATUS_CONTINUE) + break; + } + + if (cupsFinishDestDocument(CUPS_HTTP_DEFAULT, dest, + info) == IPP_STATUS_OK) + puts("Document send succeeded."); + else + printf("Document send failed: %s\n", + cupsGetErrorString()); +} + +fclose(fp); +``` # Sending IPP Requests @@ -750,14 +858,16 @@ to send print jobs. ## Connecting to the Scheduler or Printer The connection to the scheduler or printer is represented by the HTTP connection -type `http_t`. The `cupsConnectDest` function connects to the scheduler or -printer associated with the destination: +type `http_t`. The [`cupsConnectDest`](@@) function connects to the scheduler +or printer associated with the destination: - http_t * - cupsConnectDest(cups_dest_t *dest, unsigned flags, int msec, - int *cancel, char *resource, - size_t resourcesize, cups_dest_cb_t cb, - void *user_data); +```c +http_t * +cupsConnectDest(cups_dest_t *dest, unsigned flags, int msec, + int *cancel, char *resource, + size_t resourcesize, cups_dest_cb_t cb, + void *user_data); +``` The `dest` argument specifies the destination to connect to. @@ -777,8 +887,8 @@ The `resource` and `resourcesize` arguments specify the address and size of a character string array to hold the path to use when sending an IPP request. The `cb` and `user_data` arguments specify a destination callback function that -returns 1 to continue connecting or 0 to stop. The destination callback work -the same way as the one used for the `cupsEnumDests` function. +returns 1 to continue connecting or 0 to stop. The destination callback works +the same way as the one used for the [`cupsEnumDests`](@@) function. On success, a HTTP connection is returned that can be used to send IPP requests and get IPP responses. @@ -786,10 +896,13 @@ and get IPP responses. For example, the following code connects to the printer associated with a destination with a 30 second timeout: - char resource[256]; - http_t *http = cupsConnectDest(dest, CUPS_DEST_FLAGS_DEVICE, - 30000, NULL, resource, - sizeof(resource), NULL, NULL); +```c +char resource[256]; +http_t *http = cupsConnectDest(dest, CUPS_DEST_FLAGS_DEVICE, + 30000, /*cancel*/NULL, resource, + sizeof(resource), + /*cb*/NULL, /*user_data*/NULL); +``` ## Creating an IPP Request @@ -801,13 +914,17 @@ IPP request includes an operation code (`IPP_OP_CREATE_JOB`, The `ippNewRequest` function creates a new IPP request: - ipp_t * - ippNewRequest(ipp_op_t op); +```c +ipp_t * +ippNewRequest(ipp_op_t op); +``` The `op` argument specifies the IPP operation code for the request. For example, the following code creates an IPP Get-Printer-Attributes request: - ipp_t *request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES); +```c +ipp_t *request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES); +``` The request identifier is automatically set to a unique value for the current process. @@ -820,19 +937,21 @@ add the target attribute(s). For example, the following code adds the "printer-uri" attribute to the IPP Get-Printer-Attributes request to specify which printer is being queried: - const char *printer_uri = cupsGetOption("device-uri", - dest->num_options, - dest->options); +```c +const char *printer_uri = cupsGetOption("device-uri", + dest->num_options, + dest->options); - ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, - "printer-uri", NULL, printer_uri); +ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, + "printer-uri", /*language*/NULL, printer_uri); +```c > **Note:** > > If we wanted to query the scheduler instead of the device, we would look > up the "printer-uri-supported" option instead of the "device-uri" value. -The `ippAddString` function adds the "printer-uri" attribute to the IPP +The [`ippAddString`](@@) function adds the "printer-uri" attribute to the IPP request. The `IPP_TAG_OPERATION` argument specifies that the attribute is part of the operation. The `IPP_TAG_URI` argument specifies that the value is a Universal Resource Identifier (URI) string. The `NULL` argument specifies there @@ -843,82 +962,95 @@ The IPP Get-Printer-Attributes request also supports an IPP attribute called "requested-attributes" that lists the attributes and values you are interested in. For example, the following code requests the printer state attributes: - static const char * const requested_attributes[] = - { - "printer-state", - "printer-state-message", - "printer-state-reasons" - }; - - ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, - "requested-attributes", 3, NULL, - requested_attributes); - -The `ippAddStrings` function adds an attribute with one or more strings, in this -case three. The `IPP_TAG_KEYWORD` argument specifies that the strings are -keyword values, which are used for attribute names. All strings use the same -language (`NULL`), and the attribute will contain the three strings in the -array `requested_attributes`. +```c +static const char * const requested_attributes[] = +{ + "printer-state", + "printer-state-message", + "printer-state-reasons" +}; + +ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, + "requested-attributes", 3, /*language*/NULL, + requested_attributes); +``` + +The [`ippAddStrings`](@@) function adds an attribute with one or more strings, +in this case three. The `IPP_TAG_KEYWORD` argument specifies that the strings +are keyword values, which are used for attribute names. All strings use the +same language (`NULL` for none), and the attribute will contain the three +strings in the array `requested_attributes`. CUPS provides many functions to adding attributes of different types: -- `ippAddBoolean` adds a boolean (`IPP_TAG_BOOLEAN`) attribute with one value. -- `ippAddInteger` adds an enum (`IPP_TAG_ENUM`) or integer (`IPP_TAG_INTEGER`) - attribute with one value. -- `ippAddIntegers` adds an enum or integer attribute with one or more values. -- `ippAddOctetString` adds an octetString attribute with one value. -- `ippAddOutOfBand` adds a admin-defined (`IPP_TAG_ADMINDEFINE`), default +- [`ippAddBoolean`](@@) adds a boolean (`IPP_TAG_BOOLEAN`) attribute with one + value. +- [`ippAddInteger`](@@) adds an enum (`IPP_TAG_ENUM`) or integer + (`IPP_TAG_INTEGER`) attribute with one value. +- [`ippAddIntegers`](@@) adds an enum or integer attribute with one or more + values. +- [`ippAddOctetString`](@@) adds an octetString attribute with one value. +- [`ippAddOutOfBand`](@@) adds a admin-defined (`IPP_TAG_ADMINDEFINE`), default (`IPP_TAG_DEFAULT`), delete-attribute (`IPP_TAG_DELETEATTR`), no-value (`IPP_TAG_NOVALUE`), not-settable (`IPP_TAG_NOTSETTABLE`), unknown (`IPP_TAG_UNKNOWN`), or unsupported (`IPP_TAG_UNSUPPORTED_VALUE`) out-of-band attribute. -- `ippAddRange` adds a rangeOfInteger attribute with one range. -- `ippAddRanges` adds a rangeOfInteger attribute with one or more ranges. -- `ippAddResolution` adds a resolution attribute with one resolution. -- `ippAddResolutions` adds a resolution attribute with one or more resolutions. -- `ippAddString` adds a charset (`IPP_TAG_CHARSET`), keyword (`IPP_TAG_KEYWORD`), - mimeMediaType (`IPP_TAG_MIMETYPE`), name (`IPP_TAG_NAME` and - `IPP_TAG_NAMELANG`), naturalLanguage (`IPP_TAG_NATURAL_LANGUAGE`), text +- [`ippAddRange`](@@) adds a rangeOfInteger attribute with one range. +- [`ippAddRanges`](@@) adds a rangeOfInteger attribute with one or more ranges. +- [`ippAddResolution`](@@) adds a resolution attribute with one resolution. +- [`ippAddResolutions`](@@) adds a resolution attribute with one or more + resolutions. +- [`ippAddString`](@@) adds a charset (`IPP_TAG_CHARSET`), keyword + (`IPP_TAG_KEYWORD`), mimeMediaType (`IPP_TAG_MIMETYPE`), name (`IPP_TAG_NAME` + and `IPP_TAG_NAMELANG`), naturalLanguage (`IPP_TAG_NATURAL_LANGUAGE`), text (`IPP_TAG_TEXT` and `IPP_TAG_TEXTLANG`), uri (`IPP_TAG_URI`), or uriScheme (`IPP_TAG_URISCHEME`) attribute with one value. -- `ippAddStrings` adds a charset, keyword, mimeMediaType, name, naturalLanguage, - text, uri, or uriScheme attribute with one or more values. +- [`ippAddStrings`](@@) adds a charset, keyword, mimeMediaType, name, + naturalLanguage, text, uri, or uriScheme attribute with one or more values. ## Sending the IPP Request Once you have created the IPP request, you can send it using the -`cupsDoRequest` function. For example, the following code sends the IPP +[`cupsDoRequest`](@@) function. For example, the following code sends the IPP Get-Printer-Attributes request to the destination and saves the response: - ipp_t *response = cupsDoRequest(http, request, resource); +```c +ipp_t *response = cupsDoRequest(http, request, resource); +``` -For requests like Send-Document that include a file, the `cupsDoFileRequest` -function should be used: +For requests like Send-Document that include a file, the +[`cupsDoFileRequest`](@@) function should be used: - ipp_t *response = cupsDoFileRequest(http, request, resource, - filename); +```c +ipp_t *response = cupsDoFileRequest(http, request, resource, + filename); +``` Both `cupsDoRequest` and `cupsDoFileRequest` free the IPP request. If a valid IPP response is received, it is stored in a new IPP message (`ipp_t`) and returned to the caller. Otherwise `NULL` is returned. -The status from the most recent request can be queried using the `cupsLastError` -function, for example: +The status from the most recent request can be queried using the +[`cupsGetError`](@@) function, for example: - if (cupsLastError() >= IPP_STATUS_ERROR_BAD_REQUEST) - { - /* request failed */ - } +```c +if (cupsGetError() >= IPP_STATUS_ERROR_BAD_REQUEST) +{ + /* request failed */ +} +``` -A human-readable error message is also available using the `cupsLastErrorString` +A human-readable error message is also available using the `cupsGetErrorString` function: - if (cupsLastError() >= IPP_STATUS_ERROR_BAD_REQUEST) - { - /* request failed */ - printf("Request failed: %s\n", cupsLastErrorString()); - } +```c +if (cupsGetError() >= IPP_STATUS_ERROR_BAD_REQUEST) +{ + /* request failed */ + printf("Request failed: %s\n", cupsGetErrorString()); +} +``` ## Processing the IPP Response @@ -931,70 +1063,78 @@ identifier from the request. For example, the following code finds the printer state attributes and prints their values: - ipp_attribute_t *attr; - - if ((attr = ippFindAttribute(response, "printer-state", - IPP_TAG_ENUM)) != NULL) - { - printf("printer-state=%s\n", - ippEnumString("printer-state", ippGetInteger(attr, 0))); - } - else - puts("printer-state=unknown"); - - if ((attr = ippFindAttribute(response, "printer-state-message", - IPP_TAG_TEXT)) != NULL) - { - printf("printer-state-message=\"%s\"\n", - ippGetString(attr, 0, NULL))); - } - - if ((attr = ippFindAttribute(response, "printer-state-reasons", - IPP_TAG_KEYWORD)) != NULL) - { - int i, count = ippGetCount(attr); - - puts("printer-state-reasons="); - for (i = 0; i < count; i ++) - printf(" %s\n", ippGetString(attr, i, NULL))); - } - -The `ippGetCount` function returns the number of values in an attribute. - -The `ippGetInteger` and `ippGetString` functions return a single integer or -string value from an attribute. - -The `ippEnumString` function converts a enum value to its keyword (string) +```c +ipp_attribute_t *attr; + +if ((attr = ippFindAttribute(response, "printer-state", + IPP_TAG_ENUM)) != NULL) +{ + printf("printer-state=%s\n", + ippEnumString("printer-state", ippGetInteger(attr, 0))); +} +else + puts("printer-state=unknown"); + +if ((attr = ippFindAttribute(response, "printer-state-message", + IPP_TAG_TEXT)) != NULL) +{ + printf("printer-state-message=\"%s\"\n", + ippGetString(attr, 0, NULL))); +} + +if ((attr = ippFindAttribute(response, "printer-state-reasons", + IPP_TAG_KEYWORD)) != NULL) +{ + int i, count = ippGetCount(attr); + + puts("printer-state-reasons="); + for (i = 0; i < count; i ++) + printf(" %s\n", ippGetString(attr, i, NULL))); +} +``` + +The [`ippGetCount`](@@) function returns the number of values in an attribute. + +The [`ippGetInteger`](@@) and [`ippGetString`](@@) functions return a single +integer or string value from an attribute. + +The [`ippEnumString`](@@) function converts a enum value to its keyword (string) equivalent. -Once you are done using the IPP response message, free it using the `ippDelete` -function: +Once you are done using the IPP response message, free it using the +[`ippDelete`](@@) function: - ippDelete(response); +```c +ippDelete(response); +``` ## Authentication CUPS normally handles authentication through the console. GUI applications -should set a password callback using the `cupsSetPasswordCB2` function: +should set a password callback using the [`cupsSetPasswordCB2`](@@) function: - void - cupsSetPasswordCB2(cups_password_cb2_t cb, void *user_data); +```c +void +cupsSetPasswordCB2(cups_password_cb2_t cb, void *user_data); +``` The password callback will be called when needed and is responsible for setting -the current user name using `cupsSetUser` and returning a string: +the current user name using [`cupsSetUser`](@@) and returning a string: - const char * - cups_password_cb2(const char *prompt, http_t *http, - const char *method, const char *resource, - void *user_data); +```c +const char * +cups_password_cb2(const char *prompt, http_t *http, + const char *method, const char *resource, + void *user_data); +``` The `prompt` argument is a string from CUPS that should be displayed to the user. The `http` argument is the connection hosting the request that is being -authenticated. The password callback can call the `httpGetField` and -`httpGetSubField` functions to look for additional details concerning the +authenticated. The password callback can call the [`httpGetField`](@@) and +[`httpGetSubField`](@@) functions to look for additional details concerning the authentication challenge. The `method` argument specifies the HTTP method used for the request and is @@ -1004,3 +1144,113 @@ The `resource` argument specifies the path used for the request. The `user_data` argument provides the user data pointer from the `cupsSetPasswordCB2` call. + + +# IPP Data File API + +The IPP data file API provides functions to read and write IPP attributes and +other commands or data using a common base format that supports tools such as +`ipptool` and `ippeveprinter`. + + +## Creating an IPP Data File + +The [`ippFileNew`](@@) function creates a new IPP data file (`ipp_file_t`) +object: + +```c +ipp_file_t *parent = NULL; +void *data; +ipp_file_t *file = ippFileNew(parent, attr_cb, error_cb, data); +``` + +The "parent" IPP data file pointer is typically used to support nested files and +is normally `NULL` for a new file. The "data" argument supplies your +application data to the callbacks. The "attr_cb" callback function is used to +filter IPP attributes; return `true` to include the attribute and `false` to ignore it: + +```c +bool +attr_cb(ipp_file_t *file, void *cb_data, const char *name) +{ + ... determine whether to use an attribute named "name" ... +} +``` + +The "error_cb" callback function is used to record/report errors when reading +the file: + +```c +bool +error_cb(ipp_file_t *file, void *cb_data, const char *error) +{ + ... display/record error and return `true` to continue or `false` to stop ... +} +``` + + +## Reading a Data File + +The [`ippFileOpen`](@@) function opens the specified data file and +[`ippFileRead`](@@) reads from it: + +```c +if (ippFileOpen(file, "somefile", "r")) +{ + // Opened successfully, now read it... + ippFileRead(file, token_cb, /*with_groups*/false); + ippFileClose(file); +} +``` + +The token callback function passed to `ippFileRead` handles custom directives in +your data file: + +```c +bool +token_cb(ipp_file_t *file, void *cb_data, const char *token) +{ + ... handle token, return `true` to continue or `false` to stop ... +} +``` + +The "token" parameter contains the token to be processed. The callback can use the [`ippFileReadToken`](@@) function to read additional tokens from the file +and the [`ippFileExpandToken`](@@) function to expand any variables in the token +string. Return `false` to stop reading the file and `true` to continue. The +default `NULL` callback reports an unknown token error through the error +callback end returns `false`. + +Once read, you call the [`ippFileGetAttributes`](@@) function to get the IPP +attributes from the file. + + +## Variables + +Each IPP data file object has associated variables that can be used when reading +the file. The default set of variables is: + +- "date-current": Current date in ISO-8601 format +- "date-start": Start date (when file opened) in ISO-8601 format +- "filename": Associated data/document filename, if any +- "filetype": MIME media type of associated data/document filename, if any +- "hostname": Hostname or IP address from the "uri" value, if any +- "port": Port number from the "uri" value, if any +- "resource": Resource path from the "uri" value, if any +- "scheme": URI scheme from the "uri" value, if any +- "uri": URI, if any +- "uriuser": Username from the "uri" value, if any +- "uripassword": Password from the "uri" value, if any +- "user": Current login user + +The [`ippFileGetVar`](@@), [`ippFileSetVar`](@@), and [`ippFileSetVarf`](@@) +functions get and set file variables, respectively. + + +## Writing IPP Data Files + +As when reading an IPP data file, the [`ippFileNew`](@@) function creates a new +file object, [`ippFileOpen`](@@) opens the file, and [`ippFileClose`](@@) closes +the file. However, you call [`ippFileWriteAttributes`](@@) to write the +attributes in an IPP message (`ipp_t`), [`ippFileWriteComment`](@@) to write a +comment in the file, and [`ippWriteToken`](@@) or [`ippWriteTokenf`](@@) to +write a token or value to the file. diff --git a/doc/help/cupspm.epub b/doc/help/cupspm.epub index 752b4e75bc2047381729df36652b7c10e99bec4d..30b067d48ff8991e483df06afe8c05e1430242c9 100644 GIT binary patch delta 89523 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 delta 86978 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 w84(e~UuB+%=(Tpa((C^J0CsXG#{d8T diff --git a/doc/help/cupspm.html b/doc/help/cupspm.html index ba85a94a81..1d37d912c0 100644 --- a/doc/help/cupspm.html +++ b/doc/help/cupspm.html @@ -271,6 +271,12 @@

Contents

  • Processing the IPP Response
  • Authentication
    • +
  • IPP Data File API
  • Functions
    • DllMain
    • cupsAddDest
      • @@ -945,24 +951,24 @@

      Terms Used in This DocumentCompiling Programs That Use the CUPS API

      The CUPS libraries can be used from any C, C++, or Objective-C program. The method of compiling against the libraries varies depending on the operating system and installation of CUPS. The following sections show how to compile a simple program (shown below) in two common environments.

      The following simple program lists the available destinations:

      -
      #include <stdio.h>
-#include <cups/cups.h>
+
      #include <stdio.h>
+#include <cups/cups.h>
 
-int print_dest(void *user_data, unsigned flags, cups_dest_t *dest)
+int print_dest(void *user_data, unsigned flags, cups_dest_t *dest)
 {
-  if (dest->instance)
-    printf("%s/%s\n", dest->name, dest->instance);
-  else
+  if (dest->instance)
+    printf("%s/%s\n", dest->name, dest->instance);
+  else
     puts(dest->name);
 
-  return (1);
+  return (1);
 }
 
-int main(void)
+int main(void)
 {
-  cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, 0, 0, print_dest, NULL);
+  cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, 0, 0, print_dest, NULL);
 
-  return (0);
+  return (0);
 }
 
      
 
      Compiling with Xcode
      
@@ -971,19 +977,19 @@ 
      Compiling with Xcode
      
 
      Finally, click on the main.c file in the sidebar and copy the example program to the file. Build and run (CMD+R) to see the list of destinations.
      
 
      Compiling with GCC
      
 
      From the command-line, create a file called simple.c using your favorite editor, copy the example to this file, and save. Then run the following command to compile it with GCC and run it:
      
-
      gcc -o simple `cups-config --cflags` simple.c `cups-config --libs`
+
      gcc -o simple `pkg-config --cflags cups` simple.c `pkg-config --libs cups`
 ./simple
 
      
-
      The cups-config command provides the compiler flags (cups-config --cflags) and libraries (cups-config --libs) needed for the local system.
      
+
      The pkg-config command provides the compiler flags (pkg-config --cflags cups) and libraries (pkg-config --libs cups) needed for the local system.
      
 
      Working with Destinations
      
 
      Destinations, which in CUPS represent individual printers or classes (collections or pools) of printers, are represented by the cups_dest_t structure which includes the name (name), instance (instance, saved options/settings), whether the destination is the default for the user (is_default), and the options and basic information associated with that destination (num_options and options).
      
 
      Historically destinations have been manually maintained by the administrator of a system or network, but CUPS also supports dynamic discovery of destinations on the current network.
      
 
      Finding Available Destinations
      
-
      The cupsEnumDests function finds all of the available destinations:
      
-
       int
- cupsEnumDests(unsigned flags, int msec, int *cancel,
-               cups_ptype_t type, cups_ptype_t mask,
-               cups_dest_cb_t cb, void *user_data)
+
      The cupsEnumDests function finds all of the available destinations:
      
+
      int
+cupsEnumDests(unsigned flags, int msec, int *cancel,
+              cups_ptype_t type, cups_ptype_t mask,
+              cups_dest_cb_t cb, void *user_data)
 
      
 
      The flags argument specifies enumeration options, which at present must be CUPS_DEST_FLAGS_NONE.
      
 
      The msec argument specifies the maximum amount of time that should be used for enumeration in milliseconds - interactive applications should keep this value to 5000 or less when run on the main thread.
      
@@ -1028,8 +1034,8 @@ 
      Finding Available Destinat

    The cb argument specifies a function to call for every destination that is found:

    -
    typedef int (*cups_dest_cb_t)(void *user_data,
-                              unsigned flags,
+
    typedef int (*cups_dest_cb_t)(void *user_data,
+                              unsigned flags,
                               cups_dest_t *dest);
 
    
 
    The callback function receives a copy of the user_data argument along with a bitfield (flags) and the destination that was found. The flags argument can have any of the following constant (bit) values set:
    
@@ -1038,79 +1044,79 @@ 
    Finding Available Destinat

  • CUPS_DEST_FLAGS_REMOVED: The destination has gone away and should be removed from the list of destinations a user can select.

    • -

  • CUPS_DEST_FLAGS_ERROR: An error occurred. The reason for the error can be found by calling the cupsLastError and/or cupsLastErrorString functions.

    +

  • CUPS_DEST_FLAGS_ERROR: An error occurred. The reason for the error can be found by calling the cupsGetError and/or cupsGetErrorString functions.

    • -

    The callback function returns 0 to stop enumeration or 1 to continue.

    +

    The callback function returns 0 to stop enumeration or 1 to continue.

    Note:

    The callback function will likely be called multiple times for the same destination, so it is up to the caller to suppress any duplicate destinations.

    The following example shows how to use cupsEnumDests to get a filtered array of destinations:

    -
    typedef struct
+
    typedef struct
 {
-  int num_dests;
+  int num_dests;
   cups_dest_t *dests;
 } my_user_data_t;
 
-int
-my_dest_cb(my_user_data_t *user_data, unsigned flags,
+int
+my_dest_cb(my_user_data_t *user_data, unsigned flags,
            cups_dest_t *dest)
 {
-  if (flags & CUPS_DEST_FLAGS_REMOVED)
+  if (flags & CUPS_DEST_FLAGS_REMOVED)
   {
-   /*
-    * Remove destination from array...
-    */
+   /*
+    * Remove destination from array...
+    */
 
     user_data->num_dests =
         cupsRemoveDest(dest->name, dest->instance,
                        user_data->num_dests,
                        &(user_data->dests));
   }
-  else
+  else
   {
-   /*
-    * Add destination to array...
-    */
+   /*
+    * Add destination to array...
+    */
 
     user_data->num_dests =
         cupsCopyDest(dest, user_data->num_dests,
                      &(user_data->dests));
   }
 
-  return (1);
+  return (1);
 }
 
-int
+int
 my_get_dests(cups_ptype_t type, cups_ptype_t mask,
              cups_dest_t **dests)
 {
-  my_user_data_t user_data = { 0, NULL };
+  my_user_data_t user_data = { 0, NULL };
 
-  if (!cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, type,
+  if (!cupsEnumDests(CUPS_DEST_FLAGS_NONE, 1000, NULL, type,
                      mask, (cups_dest_cb_t)my_dest_cb,
                      &user_data))
   {
-   /*
-    * An error occurred, free all of the destinations and
-    * return...
-    */
+   /*
+    * An error occurred, free all of the destinations and
+    * return...
+    */
 
     cupsFreeDests(user_data.num_dests, user_data.dests);
 
     *dests = NULL;
 
-    return (0);
+    return (0);
   }
 
- /*
-  * Return the destination array...
-  */
+ /*
+  * Return the destination array...
+  */
 
   *dests = user_data.dests;
 
-  return (user_data.num_dests);
+  return (user_data.num_dests);
 }
 
    
 
    Basic Destination Information
    
@@ -1139,25 +1145,25 @@ 
    Basic Destination Informati
 
  • "printer-uri-supported": The URI associated with the destination; if not set, this destination was discovered but is not yet setup as a local printer.
    
 
    • 
 
-
    Use the cupsGetOption function to retrieve the value. For example, the following code gets the make and model of a destination:
    
-
    const char *model = cupsGetOption("printer-make-and-model",
+
    Use the cupsGetOption function to retrieve the value. For example, the following code gets the make and model of a destination:
    
+
    const char *model = cupsGetOption("printer-make-and-model",
                                   dest->num_options,
                                   dest->options);
 
    
 
    Detailed Destination Information
    
-
    Once a destination has been chosen, the cupsCopyDestInfo function can be used to gather detailed information about the destination:
    
-
    cups_dinfo_t *
+
    Once a destination has been chosen, the cupsCopyDestInfo function can be used to gather detailed information about the destination:
    
+
    cups_dinfo_t *
 cupsCopyDestInfo(http_t *http, cups_dest_t *dest);
 
    
 
    The http argument specifies a connection to the CUPS scheduler and is typically the constant CUPS_HTTP_DEFAULT. The dest argument specifies the destination to query.
    
 
    The cups_dinfo_t structure that is returned contains a snapshot of the supported options and their supported, ready, and default values. It also can report constraints between different options and values, and recommend changes to resolve those constraints.
    
 
    Getting Supported Options and Values
    
-
    The cupsCheckDestSupported function can be used to test whether a particular option or option and value is supported:
    
-
    int
+
    The cupsCheckDestSupported function can be used to test whether a particular option or option and value is supported:
    
+
    int
 cupsCheckDestSupported(http_t *http, cups_dest_t *dest,
                        cups_dinfo_t *info,
-                       const char *option,
-                       const char *value);
+                       const char *option,
+                       const char *value);
 
    
 
    The option argument specifies the name of the option to check. The following constants can be used to check the various standard options:
    
 
      
@@ -1183,117 +1189,131 @@ 
      Getting Supported Options and Valu
 
 
    
 
    If the value argument is NULL, the cupsCheckDestSupported function returns whether the option is supported by the destination. Otherwise, the function returns whether the specified value of the option is supported.
    
-
    The cupsFindDestSupported function returns the IPP attribute containing the supported values for a given option:
    
-
     ipp_attribute_t *
- cupsFindDestSupported(http_t *http, cups_dest_t *dest,
-                       cups_dinfo_t *dinfo,
-                       const char *option);
+
    The cupsFindDestSupported function returns the IPP attribute containing the supported values for a given option:
    
+
    ipp_attribute_t *
+cupsFindDestSupported(http_t *http, cups_dest_t *dest,
+                      cups_dinfo_t *dinfo,
+                      const char *option);
 
    
 
    For example, the following code prints the supported finishing processes for a destination, if any, to the standard output:
    
-
    cups_dinfo_t *info = cupsCopyDestInfo(CUPS_HTTP_DEFAULT,
+
    cups_dinfo_t *info = cupsCopyDestInfo(CUPS_HTTP_DEFAULT,
                                       dest);
 
-if (cupsCheckDestSupported(CUPS_HTTP_DEFAULT, dest, info,
+if (cupsCheckDestSupported(CUPS_HTTP_DEFAULT, dest, info,
                            CUPS_FINISHINGS, NULL))
 {
   ipp_attribute_t *finishings =
       cupsFindDestSupported(CUPS_HTTP_DEFAULT, dest, info,
                             CUPS_FINISHINGS);
-  int i, count = ippGetCount(finishings);
+  int i, count = ippGetCount(finishings);
 
-  puts("finishings supported:");
-  for (i = 0; i < count; i ++)
-    printf("  %d\n", ippGetInteger(finishings, i));
+  puts("finishings supported:");
+  for (i = 0; i < count; i ++)
+  {
+    int val = ippGetInteger(finishings, i);
+    printf("  %d (%s)\n", val,
+           ippEnumString("finishings", val));
+}
+else
+{
+  puts("finishings not supported.");
 }
-else
-  puts("finishings not supported.");
 
    
 
    The "job-creation-attributes" option can be queried to get a list of supported options. For example, the following code prints the list of supported options to the standard output:
    
-
    ipp_attribute_t *attrs =
+
    ipp_attribute_t *attrs =
     cupsFindDestSupported(CUPS_HTTP_DEFAULT, dest, info,
-                          "job-creation-attributes");
-int i, count = ippGetCount(attrs);
+                          "job-creation-attributes");
+int i, count = ippGetCount(attrs);
 
-for (i = 0; i < count; i ++)
+for (i = 0; i < count; i ++)
   puts(ippGetString(attrs, i, NULL));
 
    
 
    Getting Default Values
    
-
    There are two sets of default values - user defaults that are available via the num_options and options members of the cups_dest_t structure, and destination defaults that available via the cups_dinfo_t structure and the cupsFindDestDefault function which returns the IPP attribute containing the default value(s) for a given option:
    
-
    ipp_attribute_t *
+
    There are two sets of default values - user defaults that are available via the num_options and options members of the cups_dest_t structure, and destination defaults that available via the cups_dinfo_t structure and the cupsFindDestDefault function which returns the IPP attribute containing the default value(s) for a given option:
    
+
    ipp_attribute_t *
 cupsFindDestDefault(http_t *http, cups_dest_t *dest,
                     cups_dinfo_t *dinfo,
-                    const char *option);
+                    const char *option);
 
    
-
    The user defaults from cupsGetOption should always take preference over the destination defaults. For example, the following code prints the default finishings value(s) to the standard output:
    
-
    const char *def_value =
+
    The user defaults from cupsGetOption should always take preference over the destination defaults. For example, the following code prints the default finishings value(s) to the standard output:
    
+
    const char *def_value =
     cupsGetOption(CUPS_FINISHINGS, dest->num_options,
                   dest->options);
 ipp_attribute_t *def_attr =
     cupsFindDestDefault(CUPS_HTTP_DEFAULT, dest, info,
                         CUPS_FINISHINGS);
 
-if (def_value != NULL)
+if (def_value != NULL)
 {
-  printf("Default finishings: %s\n", def_value);
+  printf("Default finishings: %s\n", def_value);
 }
-else
+else
 {
-  int i, count = ippGetCount(def_attr);
+  int i, count = ippGetCount(def_attr);
 
-  printf("Default finishings: %d",
-         ippGetInteger(def_attr, 0));
-  for (i = 1; i < count; i ++)
-    printf(",%d", ippGetInteger(def_attr, i));
-  putchar('\n');
+  printf("Default finishings: %d",
+         ippGetInteger(def_attr, 0));
+  for (i = 1; i < count; i ++)
+    printf(",%d", ippGetInteger(def_attr, i));
+  putchar('\n');
 }
 
    
 
    Getting Ready (Loaded) Values
    
 
    The finishings and media options also support queries for the ready, or loaded, values. For example, a printer may have punch and staple finishers installed but be out of staples - the supported values will list both punch and staple finishing processes but the ready values will only list the punch processes. Similarly, a printer may support hundreds of different sizes of media but only have a single size loaded at any given time - the ready values are limited to the media that is actually in the printer.
    
-
    The cupsFindDestReady function finds the IPP attribute containing the ready values for a given option:
    
-
    ipp_attribute_t *
+
    The cupsFindDestReady function finds the IPP attribute containing the ready values for a given option:
    
+
    ipp_attribute_t *
 cupsFindDestReady(http_t *http, cups_dest_t *dest,
-                  cups_dinfo_t *dinfo, const char *option);
+                  cups_dinfo_t *dinfo, const char *option);
 
    
 
    For example, the following code lists the ready finishing processes:
    
-
    ipp_attribute_t *ready_finishings =
+
    ipp_attribute_t *ready_finishings =
     cupsFindDestReady(CUPS_HTTP_DEFAULT, dest, info,
                       CUPS_FINISHINGS);
 
-if (ready_finishings != NULL)
+if (ready_finishings != NULL)
 {
-  int i, count = ippGetCount(ready_finishings);
+  int i, count = ippGetCount(ready_finishings);
 
-  puts("finishings ready:");
-  for (i = 0; i < count; i ++)
-    printf("  %d\n", ippGetInteger(ready_finishings, i));
+  puts("finishings ready:");
+  for (i = 0; i < count; i ++)
+  {
+    int val = ippGetInteger(ready_finishings, i);
+    printf("  %d (%s)\n", val,
+           ippEnumString("finishings", val));
+}
+else
+{
+  puts("no finishings are ready.");
 }
-else
-  puts("no finishings are ready.");
 
    
-
    Media Size Options
    
-
    CUPS provides functions for querying the dimensions and margins for each of the supported media size options. The cups_size_t structure is used to describe a media size:
    
-
    typedef struct cups_size_s
+
    Media Options
    
+
    CUPS provides functions for querying the dimensions, margins, color, source (tray/roll), and type for each of the supported media size options. The cups_media_t structure is used to describe media:
    
+
    typedef struct cups_media_s
 {
-  char media[128];
-  int width, length;
-  int bottom, left, right, top;
-} cups_size_t;
+  char media[128];
+  char color[128];
+  char source[128];
+  char type[128];
+  int width, length;
+  int bottom, left, right, top;
+} cups_media_t;
 
    
+
    The "media" member specifies a PWG self-describing media size name such as "na_letter_8.5x11in", "iso_a4_210x297mm", etc. The "color" member specifies a PWG media color name such as "white", "blue", etc. The "source" member specifies a standard keyword for the paper tray or roll such as "tray-1", "manual", "by-pass-tray" (multi-purpose tray), etc. The "type" member specifies a PWG media type name such as "stationery" (plain paper), "photographic", "envelope", "transparency", etc.
    
 
    The width and length members specify the dimensions of the media in hundredths of millimeters (1/2540th of an inch). The bottom, left, right, and top members specify the margins of the printable area, also in hundredths of millimeters.
    
-
    The cupsGetDestMediaByName and cupsGetDestMediaBySize functions lookup the media size information using a standard media size name or dimensions in hundredths of millimeters:
    
-
    int
-cupsGetDestMediaByName(http_t *http, cups_dest_t *dest,
-                       cups_dinfo_t *dinfo,
-                       const char *media,
-                       unsigned flags, cups_size_t *size);
-
-int
-cupsGetDestMediaBySize(http_t *http, cups_dest_t *dest,
-                       cups_dinfo_t *dinfo,
-                       int width, int length,
-                       unsigned flags, cups_size_t *size);
+
    The cupsGetDestMediaByName2 and cupsGetDestMediaBySize2 functions lookup the media information using a standard media size name or dimensions in hundredths of millimeters:
    
+
    bool
+cupsGetDestMediaByName2(http_t *http, cups_dest_t *dest,
+                        cups_dinfo_t *dinfo,
+                        const char *name,
+                        unsigned flags, cups_media_t *media);
+
+bool
+cupsGetDestMediaBySize2(http_t *http, cups_dest_t *dest,
+                        cups_dinfo_t *dinfo,
+                        int width, int length,
+                        unsigned flags, cups_media_t *media);
 
    
-
    The media, width, and length arguments specify the size to lookup. The flags argument specifies a bitfield controlling various lookup options:
    
+
    The name, width, and length arguments specify the size to lookup. The flags argument specifies a bitfield controlling various lookup options:
    
 
      
 
    • CUPS_MEDIA_FLAGS_DEFAULT: Find the closest size supported by the printer.
      
 
      • 
@@ -1306,95 +1326,121 @@ 
      Media Size Options
      
 
    • CUPS_MEDIA_FLAGS_READY: If the printer supports media sensing or configuration of the media in each tray/source, find the size amongst the "ready" media.
      
 
      • 
 
    
-
    If a matching size is found for the destination, the size information is stored in the structure pointed to by the size argument and 1 is returned. Otherwise 0 is returned.
    
+
    If a matching size is found for the destination, the size information is stored in the structure pointed to by the media argument and true is returned. Otherwise false is returned.
    
 
    For example, the following code prints the margins for two-sided printing on US Letter media:
    
-
    cups_size_t size;
+
    cups_media_t media:
 
-if (cupsGetDestMediaByName(CUPS_HTTP_DEFAULT, dest, info,
-                           CUPS_MEDIA_LETTER,
-                           CUPS_MEDIA_FLAGS_DUPLEX, &size))
+if (cupsGetDestMediaByName2(CUPS_HTTP_DEFAULT, dest, info,
+                            CUPS_MEDIA_LETTER,
+                            CUPS_MEDIA_FLAGS_DUPLEX, &size))
+{
+  puts("Margins for duplex US Letter:");
+  printf("  Bottom: %.2fin\n", media.bottom / 2540.0);
+  printf("    Left: %.2fin\n", media.left / 2540.0);
+  printf("   Right: %.2fin\n", media.right / 2540.0);
+  printf("     Top: %.2fin\n", media.top / 2540.0);
+}
+else
 {
-  puts("Margins for duplex US Letter:");
-  printf("  Bottom: %.2fin\n", size.bottom / 2540.0);
-  printf("    Left: %.2fin\n", size.left / 2540.0);
-  printf("   Right: %.2fin\n", size.right / 2540.0);
-  printf("     Top: %.2fin\n", size.top / 2540.0);
+  puts("Margins for duplex US Letter are not available.");
 }
-else
-  puts("Margins for duplex US Letter are not available.");
 
    
-
    You can also enumerate all of the sizes that match a given flags value using the cupsGetDestMediaByIndex and cupsGetDestMediaCount functions:
    
-
    int
-cupsGetDestMediaByIndex(http_t *http, cups_dest_t *dest,
-                        cups_dinfo_t *dinfo, int n,
-                        unsigned flags, cups_size_t *size);
+
    You can also enumerate all of the sizes that match a given flags value using the cupsGetDestMediaByIndex2 and cupsGetDestMediaCount functions:
    
+
    bool
+cupsGetDestMediaByIndex2(http_t *http, cups_dest_t *dest,
+                         cups_dinfo_t *dinfo, size_t n,
+                         unsigned flags, cups_media_t *media);
 
-int
+int
 cupsGetDestMediaCount(http_t *http, cups_dest_t *dest,
-                      cups_dinfo_t *dinfo, unsigned flags);
+                      cups_dinfo_t *dinfo, unsigned flags);
 
    
 
    For example, the following code prints the list of ready media and corresponding margins:
    
-
    cups_size_t size;
-int i;
-int count = cupsGetDestMediaCount(CUPS_HTTP_DEFAULT,
-                                  dest, info,
-                                  CUPS_MEDIA_FLAGS_READY);
+
    cups_media_t media;
+size_t i;
+size_t count = (size_t)cupsGetDestMediaCount(CUPS_HTTP_DEFAULT,
+                                             dest, info,
+                                             CUPS_MEDIA_FLAGS_READY);
 
-for (i = 0; i < count; i ++)
+for (i = 0; i < count; i ++)
 {
-  if (cupsGetDestMediaByIndex(CUPS_HTTP_DEFAULT, dest, info,
-                              i, CUPS_MEDIA_FLAGS_READY,
-                              &size))
+  if (cupsGetDestMediaByIndex2(CUPS_HTTP_DEFAULT, dest, info,
+                               i, CUPS_MEDIA_FLAGS_READY,
+                               &media))
   {
-    printf("%s:\n", size.name);
-    printf("   Width: %.2fin\n", size.width / 2540.0);
-    printf("  Length: %.2fin\n", size.length / 2540.0);
-    printf("  Bottom: %.2fin\n", size.bottom / 2540.0);
-    printf("    Left: %.2fin\n", size.left / 2540.0);
-    printf("   Right: %.2fin\n", size.right / 2540.0);
-    printf("     Top: %.2fin\n", size.top / 2540.0);
+    printf("%s:\n", media.name);
+    printf("   Width: %.2fin\n", media.width / 2540.0);
+    printf("  Length: %.2fin\n", media.length / 2540.0);
+    printf("  Bottom: %.2fin\n", media.bottom / 2540.0);
+    printf("    Left: %.2fin\n", media.left / 2540.0);
+    printf("   Right: %.2fin\n", media.right / 2540.0);
+    printf("     Top: %.2fin\n", media.top / 2540.0);
   }
 }
 
    
-
    Finally, the cupsGetDestMediaDefault function returns the default media size:
    
-
    int
-cupsGetDestMediaDefault(http_t *http, cups_dest_t *dest,
-                        cups_dinfo_t *dinfo, unsigned flags,
-                        cups_size_t *size);
+
    Finally, the cupsGetDestMediaDefault2 function returns the default media:
    
+
    int
+cupsGetDestMediaDefault2(http_t *http, cups_dest_t *dest,
+                         cups_dinfo_t *dinfo, unsigned flags,
+                         cups_media_t *media);
 
    
 
    Localizing Options and Values
    
-
    CUPS provides three functions to get localized, human-readable strings in the user's current locale for options and values: cupsLocalizeDestMedia, cupsLocalizeDestOption, and cupsLocalizeDestValue:
    
-
    const char *
-cupsLocalizeDestMedia(http_t *http, cups_dest_t *dest,
-                      cups_dinfo_t *info, unsigned flags,
-                      cups_size_t *size);
+
    CUPS provides three functions to get localized, human-readable strings in the user's current locale for options and values: cupsLocalizeDestMedia2, cupsLocalizeDestOption, and cupsLocalizeDestValue:
    
+
    const char *
+cupsLocalizeDestMedia2(http_t *http, cups_dest_t *dest,
+                       cups_dinfo_t *info, unsigned flags,
+                       cups_media_t *media);
 
-const char *
+const char *
 cupsLocalizeDestOption(http_t *http, cups_dest_t *dest,
                        cups_dinfo_t *info,
-                       const char *option);
+                       const char *option);
 
-const char *
+const char *
 cupsLocalizeDestValue(http_t *http, cups_dest_t *dest,
                       cups_dinfo_t *info,
-                      const char *option, const char *value);
+                      const char *option, const char *value);
+
    
+
    
+
    Note:
    
+
    These functions require a valid http_t connection to work. Use the cupsConnectDest function to connect to the destination for its localization information.
    
+
    
+
    For example, the following code will list the localized media names for a destination:
    
+
    char resource[256];
+http_t *http = cupsConnectDest(dest, CUPS_DEST_FLAGS_NONE,
+                               /*msec*/30000, /*cancel*/NULL,
+                               resource, sizeof(resource),
+                               /*dest_cb*/NULL, /*user_data*/NULL);
+
+size_t i;
+size_t count = (size_t)cupsGetDestMediaCount(http, dest, info,
+                                             CUPS_MEDIA_FLAGS_DEFAULT);
+cups_media_t media;
+for (i = 0; i < count; i ++)
+{
+  if (cupsGetDestMediaByIndex2(http, dest, info, i,
+                               CUPS_MEDIA_FLAGS_DEFAULT, &media))
+    printf("%s: %s\n", media.name,
+           cupsLocalizeDestMedia2(http, dest, info,
+                                  CUPS_MEDIA_FLAGS_DEFAULT, &media));
+}
 
    
 
    Submitting a Print Job
    
-
    Once you are ready to submit a print job, you create a job using the cupsCreateDestJob function:
    
-
    ipp_status_t
+
    Once you are ready to submit a print job, you create a job using the cupsCreateDestJob function:
    
+
    ipp_status_t
 cupsCreateDestJob(http_t *http, cups_dest_t *dest,
-                  cups_dinfo_t *info, int *job_id,
-                  const char *title, int num_options,
+                  cups_dinfo_t *info, int *job_id,
+                  const char *title, int num_options,
                   cups_option_t *options);
 
    
 
    The title argument specifies a name for the print job such as "My Document". The num_options and options arguments specify the options for the print job which are allocated using the cupsAddOption function.
    
 
    When successful, the job's numeric identifier is stored in the integer pointed to by the job_id argument and IPP_STATUS_OK is returned. Otherwise, an IPP error status is returned.
    
 
    For example, the following code creates a new job that will print 42 copies of a two-sided US Letter document:
    
-
    int job_id = 0;
-int num_options = 0;
+
    int job_id = 0;
+int num_options = 0;
 cups_option_t *options = NULL;
 
-num_options = cupsAddOption(CUPS_COPIES, "42",
+num_options = cupsAddOption(CUPS_COPIES, "42",
                             num_options, &options);
 num_options = cupsAddOption(CUPS_MEDIA, CUPS_MEDIA_LETTER,
                             num_options, &options);
@@ -1402,26 +1448,26 @@ 
    Submitting a Print Job
    
                             CUPS_SIDES_TWO_SIDED_PORTRAIT,
                             num_options, &options);
 
-if (cupsCreateDestJob(CUPS_HTTP_DEFAULT, dest, info,
-                      &job_id, "My Document", num_options,
+if (cupsCreateDestJob(CUPS_HTTP_DEFAULT, dest, info,
+                      &job_id, "My Document", num_options,
                       options) == IPP_STATUS_OK)
-  printf("Created job: %d\n", job_id);
-else
-  printf("Unable to create job: %s\n",
-         cupsLastErrorString());
+  printf("Created job: %d\n", job_id);
+else
+  printf("Unable to create job: %s\n",
+         cupsGetErrorString());
 
    
-
    Once the job is created, you submit documents for the job using the cupsStartDestDocument, cupsWriteRequestData, and cupsFinishDestDocument functions:
    
-
    http_status_t
+
    Once the job is created, you submit documents for the job using the cupsStartDestDocument, cupsWriteRequestData, and cupsFinishDestDocument functions:
    
+
    http_status_t
 cupsStartDestDocument(http_t *http, cups_dest_t *dest,
-                      cups_dinfo_t *info, int job_id,
-                      const char *docname,
-                      const char *format,
-                      int num_options,
+                      cups_dinfo_t *info, int job_id,
+                      const char *docname,
+                      const char *format,
+                      int num_options,
                       cups_option_t *options,
-                      int last_document);
+                      int last_document);
 
 http_status_t
-cupsWriteRequestData(http_t *http, const char *buffer,
+cupsWriteRequestData(http_t *http, const char *buffer,
                      size_t length);
 
 ipp_status_t
@@ -1430,36 +1476,38 @@ 
    Submitting a Print Job
    
 
    
 
    The docname argument specifies the name of the document, typically the original filename. The format argument specifies the MIME media type of the document, including the following constants:
    
 
      
+
    • CUPS_FORMAT_AUTO: "application/octet-stream"
      
+
      • 
 
    • CUPS_FORMAT_JPEG: "image/jpeg"
      
 
      • 
 
    • CUPS_FORMAT_PDF: "application/pdf"
      
 
      • 
-
    • CUPS_FORMAT_POSTSCRIPT: "application/postscript"
      
-
      • 
 
    • CUPS_FORMAT_TEXT: "text/plain"
      
 
      • 
 
    
 
    The num_options and options arguments specify per-document print options, which at present must be 0 and NULL. The last_document argument specifies whether this is the last document in the job.
    
 
    For example, the following code submits a PDF file to the job that was just created:
    
-
    FILE *fp = fopen("filename.pdf", "rb");
+
    FILE *fp = fopen("filename.pdf", "rb");
 size_t bytes;
-char buffer[65536];
+char buffer[65536];
 
-if (cupsStartDestDocument(CUPS_HTTP_DEFAULT, dest, info,
-                          job_id, "filename.pdf", 0, NULL,
-                          1) == HTTP_STATUS_CONTINUE)
+if (cupsStartDestDocument(CUPS_HTTP_DEFAULT, dest, info,
+                          job_id, "filename.pdf", 0, NULL,
+                          1) == HTTP_STATUS_CONTINUE)
 {
-  while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
-    if (cupsWriteRequestData(CUPS_HTTP_DEFAULT, buffer,
+  while ((bytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
+  {
+    if (cupsWriteRequestData(CUPS_HTTP_DEFAULT, buffer,
                              bytes) != HTTP_STATUS_CONTINUE)
-      break;
+      break;
+  }
 
-  if (cupsFinishDestDocument(CUPS_HTTP_DEFAULT, dest,
+  if (cupsFinishDestDocument(CUPS_HTTP_DEFAULT, dest,
                              info) == IPP_STATUS_OK)
-    puts("Document send succeeded.");
-  else
-    printf("Document send failed: %s\n",
-           cupsLastErrorString());
+    puts("Document send succeeded.");
+  else
+    printf("Document send failed: %s\n",
+           cupsGetErrorString());
 }
 
 fclose(fp);
@@ -1467,162 +1515,235 @@ 
    Submitting a Print Job
    
 
    Sending IPP Requests
    
 
    CUPS provides a rich API for sending IPP requests to the scheduler or printers, typically from management or utility applications whose primary purpose is not to send print jobs.
    
 
    Connecting to the Scheduler or Printer
    
-
    The connection to the scheduler or printer is represented by the HTTP connection type http_t. The cupsConnectDest function connects to the scheduler or printer associated with the destination:
    
-
    http_t *
-cupsConnectDest(cups_dest_t *dest, unsigned flags, int msec,
-                int *cancel, char *resource,
+
    The connection to the scheduler or printer is represented by the HTTP connection type http_t. The cupsConnectDest function connects to the scheduler or printer associated with the destination:
    
+
    http_t *
+cupsConnectDest(cups_dest_t *dest, unsigned flags, int msec,
+                int *cancel, char *resource,
                 size_t resourcesize, cups_dest_cb_t cb,
-                void *user_data);
+                void *user_data);
 
    
 
    The dest argument specifies the destination to connect to.
    
 
    The flags argument specifies whether you want to connect to the scheduler (CUPS_DEST_FLAGS_NONE) or device/printer (CUPS_DEST_FLAGS_DEVICE) associated with the destination.
    
 
    The msec argument specifies how long you are willing to wait for the connection to be established in milliseconds. Specify a value of -1 to wait indefinitely.
    
 
    The cancel argument specifies the address of an integer variable that can be set to a non-zero value to cancel the connection. Specify a value of NULL to not provide a cancel variable.
    
 
    The resource and resourcesize arguments specify the address and size of a character string array to hold the path to use when sending an IPP request.
    
-
    The cb and user_data arguments specify a destination callback function that returns 1 to continue connecting or 0 to stop. The destination callback work the same way as the one used for the cupsEnumDests function.
    
+
    The cb and user_data arguments specify a destination callback function that returns 1 to continue connecting or 0 to stop. The destination callback works the same way as the one used for the cupsEnumDests function.
    
 
    On success, a HTTP connection is returned that can be used to send IPP requests and get IPP responses.
    
 
    For example, the following code connects to the printer associated with a destination with a 30 second timeout:
    
-
    char resource[256];
+
    char resource[256];
 http_t *http = cupsConnectDest(dest, CUPS_DEST_FLAGS_DEVICE,
-                               30000, NULL, resource,
-                               sizeof(resource), NULL, NULL);
+                               30000, /*cancel*/NULL, resource,
+                               sizeof(resource),
+                               /*cb*/NULL, /*user_data*/NULL);
 
    
 
    Creating an IPP Request
    
 
    IPP requests are represented by the IPP message type ipp_t and each IPP attribute in the request is representing using the type ipp_attribute_t. Each IPP request includes an operation code (IPP_OP_CREATE_JOB, IPP_OP_GET_PRINTER_ATTRIBUTES, etc.) and a 32-bit integer identifier.
    
 
    The ippNewRequest function creates a new IPP request:
    
-
    ipp_t *
+
    ipp_t *
 ippNewRequest(ipp_op_t op);
 
    
 
    The op argument specifies the IPP operation code for the request. For example, the following code creates an IPP Get-Printer-Attributes request:
    
-
    ipp_t *request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
+
    ipp_t *request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
 
    
 
    The request identifier is automatically set to a unique value for the current process.
    
 
    Each IPP request starts with two IPP attributes, "attributes-charset" and "attributes-natural-language", followed by IPP attribute(s) that specify the target of the operation. The ippNewRequest automatically adds the correct "attributes-charset" and "attributes-natural-language" attributes, but you must add the target attribute(s). For example, the following code adds the "printer-uri" attribute to the IPP Get-Printer-Attributes request to specify which printer is being queried:
    
-
    const char *printer_uri = cupsGetOption("device-uri",
+
    const char *printer_uri = cupsGetOption("device-uri",
                                         dest->num_options,
                                         dest->options);
 
 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
-             "printer-uri", NULL, printer_uri);
+             "printer-uri", /*language*/NULL, printer_uri);
+```c
 
    
 
    
 
    Note:
    
 
    If we wanted to query the scheduler instead of the device, we would look up the "printer-uri-supported" option instead of the "device-uri" value.
    
 
    
-
    The ippAddString function adds the "printer-uri" attribute to the IPP request. The IPP_TAG_OPERATION argument specifies that the attribute is part of the operation. The IPP_TAG_URI argument specifies that the value is a Universal Resource Identifier (URI) string. The NULL argument specifies there is no language (English, French, Japanese, etc.) associated with the string, and the printer_uri argument specifies the string value.
    
+
    The ippAddString function adds the "printer-uri" attribute to the IPP request. The IPP_TAG_OPERATION argument specifies that the attribute is part of the operation. The IPP_TAG_URI argument specifies that the value is a Universal Resource Identifier (URI) string. The NULL argument specifies there is no language (English, French, Japanese, etc.) associated with the string, and the printer_uri argument specifies the string value.
    
 
    The IPP Get-Printer-Attributes request also supports an IPP attribute called "requested-attributes" that lists the attributes and values you are interested in. For example, the following code requests the printer state attributes:
    
-
    static const char * const requested_attributes[] =
+
    static const char * const requested_attributes[] =
 {
-  "printer-state",
-  "printer-state-message",
-  "printer-state-reasons"
+  "printer-state",
+  "printer-state-message",
+  "printer-state-reasons"
 };
 
 ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
-              "requested-attributes", 3, NULL,
+              "requested-attributes", 3, /*language*/NULL,
               requested_attributes);
 
    
-
    The ippAddStrings function adds an attribute with one or more strings, in this case three. The IPP_TAG_KEYWORD argument specifies that the strings are keyword values, which are used for attribute names. All strings use the same language (NULL), and the attribute will contain the three strings in the array requested_attributes.
    
+
    The ippAddStrings function adds an attribute with one or more strings, in this case three. The IPP_TAG_KEYWORD argument specifies that the strings are keyword values, which are used for attribute names. All strings use the same language (NULL for none), and the attribute will contain the three strings in the array requested_attributes.
    
 
    CUPS provides many functions to adding attributes of different types:
    
 
      
-
    • ippAddBoolean adds a boolean (IPP_TAG_BOOLEAN) attribute with one value.
      
+
    • ippAddBoolean adds a boolean (IPP_TAG_BOOLEAN) attribute with one value.
      
 
      • 
-
    • ippAddInteger adds an enum (IPP_TAG_ENUM) or integer (IPP_TAG_INTEGER) attribute with one value.
      
+
    • ippAddInteger adds an enum (IPP_TAG_ENUM) or integer (IPP_TAG_INTEGER) attribute with one value.
      
 
      • 
-
    • ippAddIntegers adds an enum or integer attribute with one or more values.
      
+
    • ippAddIntegers adds an enum or integer attribute with one or more values.
      
 
      • 
-
    • ippAddOctetString adds an octetString attribute with one value.
      
+
    • ippAddOctetString adds an octetString attribute with one value.
      
 
      • 
-
    • ippAddOutOfBand adds a admin-defined (IPP_TAG_ADMINDEFINE), default (IPP_TAG_DEFAULT), delete-attribute (IPP_TAG_DELETEATTR), no-value (IPP_TAG_NOVALUE), not-settable (IPP_TAG_NOTSETTABLE), unknown (IPP_TAG_UNKNOWN), or unsupported (IPP_TAG_UNSUPPORTED_VALUE) out-of-band attribute.
      
+
    • ippAddOutOfBand adds a admin-defined (IPP_TAG_ADMINDEFINE), default (IPP_TAG_DEFAULT), delete-attribute (IPP_TAG_DELETEATTR), no-value (IPP_TAG_NOVALUE), not-settable (IPP_TAG_NOTSETTABLE), unknown (IPP_TAG_UNKNOWN), or unsupported (IPP_TAG_UNSUPPORTED_VALUE) out-of-band attribute.
      
 
      • 
-
    • ippAddRange adds a rangeOfInteger attribute with one range.
      
+
    • ippAddRange adds a rangeOfInteger attribute with one range.
      
 
      • 
-
    • ippAddRanges adds a rangeOfInteger attribute with one or more ranges.
      
+
    • ippAddRanges adds a rangeOfInteger attribute with one or more ranges.
      
 
      • 
-
    • ippAddResolution adds a resolution attribute with one resolution.
      
+
    • ippAddResolution adds a resolution attribute with one resolution.
      
 
      • 
-
    • ippAddResolutions adds a resolution attribute with one or more resolutions.
      
+
    • ippAddResolutions adds a resolution attribute with one or more resolutions.
      
 
      • 
-
    • ippAddString adds a charset (IPP_TAG_CHARSET), keyword (IPP_TAG_KEYWORD), mimeMediaType (IPP_TAG_MIMETYPE), name (IPP_TAG_NAME and IPP_TAG_NAMELANG), naturalLanguage (IPP_TAG_NATURAL_LANGUAGE), text (IPP_TAG_TEXT and IPP_TAG_TEXTLANG), uri (IPP_TAG_URI), or uriScheme (IPP_TAG_URISCHEME) attribute with one value.
      
+
    • ippAddString adds a charset (IPP_TAG_CHARSET), keyword (IPP_TAG_KEYWORD), mimeMediaType (IPP_TAG_MIMETYPE), name (IPP_TAG_NAME and IPP_TAG_NAMELANG), naturalLanguage (IPP_TAG_NATURAL_LANGUAGE), text (IPP_TAG_TEXT and IPP_TAG_TEXTLANG), uri (IPP_TAG_URI), or uriScheme (IPP_TAG_URISCHEME) attribute with one value.
      
 
      • 
-
    • ippAddStrings adds a charset, keyword, mimeMediaType, name, naturalLanguage, text, uri, or uriScheme attribute with one or more values.
      
+
    • ippAddStrings adds a charset, keyword, mimeMediaType, name, naturalLanguage, text, uri, or uriScheme attribute with one or more values.
      
 
      • 
 
    
 
    Sending the IPP Request
    
-
    Once you have created the IPP request, you can send it using the cupsDoRequest function. For example, the following code sends the IPP Get-Printer-Attributes request to the destination and saves the response:
    
-
    ipp_t *response = cupsDoRequest(http, request, resource);
+
    Once you have created the IPP request, you can send it using the cupsDoRequest function. For example, the following code sends the IPP Get-Printer-Attributes request to the destination and saves the response:
    
+
    ipp_t *response = cupsDoRequest(http, request, resource);
 
    
-
    For requests like Send-Document that include a file, the cupsDoFileRequest function should be used:
    
-
    ipp_t *response = cupsDoFileRequest(http, request, resource,
+
    For requests like Send-Document that include a file, the cupsDoFileRequest function should be used:
    
+
    ipp_t *response = cupsDoFileRequest(http, request, resource,
                                     filename);
 
    
 
    Both cupsDoRequest and cupsDoFileRequest free the IPP request. If a valid IPP response is received, it is stored in a new IPP message (ipp_t) and returned to the caller. Otherwise NULL is returned.
    
-
    The status from the most recent request can be queried using the cupsLastError function, for example:
    
-
    if (cupsLastError() >= IPP_STATUS_ERROR_BAD_REQUEST)
+
    The status from the most recent request can be queried using the cupsGetError function, for example:
    
+
    if (cupsGetError() >= IPP_STATUS_ERROR_BAD_REQUEST)
 {
-  /* request failed */
+  /* request failed */
 }
 
    
-
    A human-readable error message is also available using the cupsLastErrorString function:
    
-
    if (cupsLastError() >= IPP_STATUS_ERROR_BAD_REQUEST)
+
    A human-readable error message is also available using the cupsGetErrorString function:
    
+
    if (cupsGetError() >= IPP_STATUS_ERROR_BAD_REQUEST)
 {
-  /* request failed */
-  printf("Request failed: %s\n", cupsLastErrorString());
+  /* request failed */
+  printf("Request failed: %s\n", cupsGetErrorString());
 }
 
    
 
    Processing the IPP Response
    
 
    Each response to an IPP request is also an IPP message (ipp_t) with its own IPP attributes (ipp_attribute_t) that includes a status code (IPP_STATUS_OK, IPP_STATUS_ERROR_BAD_REQUEST, etc.) and the corresponding 32-bit integer identifier from the request.
    
 
    For example, the following code finds the printer state attributes and prints their values:
    
-
    ipp_attribute_t *attr;
+
    ipp_attribute_t *attr;
 
-if ((attr = ippFindAttribute(response, "printer-state",
+if ((attr = ippFindAttribute(response, "printer-state",
                              IPP_TAG_ENUM)) != NULL)
 {
-  printf("printer-state=%s\n",
-         ippEnumString("printer-state", ippGetInteger(attr, 0)));
+  printf("printer-state=%s\n",
+         ippEnumString("printer-state", ippGetInteger(attr, 0)));
 }
-else
-  puts("printer-state=unknown");
+else
+  puts("printer-state=unknown");
 
-if ((attr = ippFindAttribute(response, "printer-state-message",
+if ((attr = ippFindAttribute(response, "printer-state-message",
                              IPP_TAG_TEXT)) != NULL)
 {
-  printf("printer-state-message=\"%s\"\n",
-         ippGetString(attr, 0, NULL)));
+  printf("printer-state-message=\"%s\"\n",
+         ippGetString(attr, 0, NULL)));
 }
 
-if ((attr = ippFindAttribute(response, "printer-state-reasons",
+if ((attr = ippFindAttribute(response, "printer-state-reasons",
                              IPP_TAG_KEYWORD)) != NULL)
 {
-  int i, count = ippGetCount(attr);
+  int i, count = ippGetCount(attr);
 
-  puts("printer-state-reasons=");
-  for (i = 0; i < count; i ++)
-    printf("    %s\n", ippGetString(attr, i, NULL)));
+  puts("printer-state-reasons=");
+  for (i = 0; i < count; i ++)
+    printf("    %s\n", ippGetString(attr, i, NULL)));
 }
 
    
-
    The ippGetCount function returns the number of values in an attribute.
    
-
    The ippGetInteger and ippGetString functions return a single integer or string value from an attribute.
    
-
    The ippEnumString function converts a enum value to its keyword (string) equivalent.
    
-
    Once you are done using the IPP response message, free it using the ippDelete function:
    
-
    ippDelete(response);
+
    The ippGetCount function returns the number of values in an attribute.
    
+
    The ippGetInteger and ippGetString functions return a single integer or string value from an attribute.
    
+
    The ippEnumString function converts a enum value to its keyword (string) equivalent.
    
+
    Once you are done using the IPP response message, free it using the ippDelete function:
    
+
    ippDelete(response);
 
    
 
    Authentication
    
-
    CUPS normally handles authentication through the console. GUI applications should set a password callback using the cupsSetPasswordCB2 function:
    
-
    void
-cupsSetPasswordCB2(cups_password_cb2_t cb, void *user_data);
+
    CUPS normally handles authentication through the console. GUI applications should set a password callback using the cupsSetPasswordCB2 function:
    
+
    void
+cupsSetPasswordCB2(cups_password_cb2_t cb, void *user_data);
 
    
-
    The password callback will be called when needed and is responsible for setting the current user name using cupsSetUser and returning a string:
    
-
    const char *
-cups_password_cb2(const char *prompt, http_t *http,
-                  const char *method, const char *resource,
-                  void *user_data);
+
    The password callback will be called when needed and is responsible for setting the current user name using cupsSetUser and returning a string:
    
+
    const char *
+cups_password_cb2(const char *prompt, http_t *http,
+                  const char *method, const char *resource,
+                  void *user_data);
 
    
 
    The prompt argument is a string from CUPS that should be displayed to the user.
    
-
    The http argument is the connection hosting the request that is being authenticated. The password callback can call the httpGetField and httpGetSubField functions to look for additional details concerning the authentication challenge.
    
+
    The http argument is the connection hosting the request that is being authenticated. The password callback can call the httpGetField and httpGetSubField functions to look for additional details concerning the authentication challenge.
    
 
    The method argument specifies the HTTP method used for the request and is typically "POST".
    
 
    The resource argument specifies the path used for the request.
    
 
    The user_data argument provides the user data pointer from the cupsSetPasswordCB2 call.
    
+
    IPP Data File API
    
+
    The IPP data file API provides functions to read and write IPP attributes and other commands or data using a common base format that supports tools such as ipptool and ippeveprinter.
    
+
    Creating an IPP Data File
    
+
    The ippFileNew function creates a new IPP data file (ipp_file_t) object:
    
+
    ipp_file_t *parent = NULL;
+void *data;
+ipp_file_t *file = ippFileNew(parent, attr_cb, error_cb, data);
+
    
+
    The "parent" IPP data file pointer is typically used to support nested files and is normally NULL for a new file. The "data" argument supplies your application data to the callbacks. The "attr_cb" callback function is used to filter IPP attributes; return true to include the attribute and false to ignore it:
    
+
    bool
+attr_cb(ipp_file_t *file, void *cb_data, const char *name)
+{
+  ... determine whether to use an attribute named "name" ...
+}
+
    
+
    The "error_cb" callback function is used to record/report errors when reading the file:
    
+
    bool
+error_cb(ipp_file_t *file, void *cb_data, const char *error)
+{
+  ... display/record error and return `true` to continue or `false` to stop ...
+}
+
    
+
    Reading a Data File
    
+
    The ippFileOpen function opens the specified data file and ippFileRead reads from it:
    
+
    if (ippFileOpen(file, "somefile", "r"))
+{
+  // Opened successfully, now read it...
+  ippFileRead(file, token_cb, /*with_groups*/false);
+  ippFileClose(file);
+}
+
    
+
    The token callback function passed to ippFileRead handles custom directives in your data file:
    
+
    bool
+token_cb(ipp_file_t *file, void *cb_data, const char *token)
+{
+  ... handle token, return `true` to continue or `false` to stop ...
+}
+
    
+
    The "token" parameter contains the token to be processed. The callback can use the ippFileReadToken function to read additional tokens from the file and the ippFileExpandToken function to expand any variables in the token string. Return false to stop reading the file and true to continue. The default NULL callback reports an unknown token error through the error callback end returns false.
    
+
    Once read, you call the ippFileGetAttributes function to get the IPP attributes from the file.
    
+
    Variables
    
+
    Each IPP data file object has associated variables that can be used when reading the file. The default set of variables is:
    
+
      
+
    • "date-current": Current date in ISO-8601 format
      
+
      • 
+
    • "date-start": Start date (when file opened) in ISO-8601 format
      
+
      • 
+
    • "filename": Associated data/document filename, if any
      
+
      • 
+
    • "filetype": MIME media type of associated data/document filename, if any
      
+
      • 
+
    • "hostname": Hostname or IP address from the "uri" value, if any
      
+
      • 
+
    • "port": Port number from the "uri" value, if any
      
+
      • 
+
    • "resource": Resource path from the "uri" value, if any
      
+
      • 
+
    • "scheme": URI scheme from the "uri" value, if any
      
+
      • 
+
    • "uri": URI, if any
      
+
      • 
+
    • "uriuser": Username from the "uri" value, if any
      
+
      • 
+
    • "uripassword": Password from the "uri" value, if any
      
+
      • 
+
    • "user": Current login user
      
+
      • 
+
    
+
    The ippFileGetVar, ippFileSetVar, and ippFileSetVarf functions get and set file variables, respectively.
    
+
    Writing IPP Data Files
    
+
    As when reading an IPP data file, the ippFileNew function creates a new file object, ippFileOpen opens the file, and ippFileClose closes the file. However, you call ippFileWriteAttributes to write the attributes in an IPP message (ipp_t), ippFileWriteComment to write a comment in the file, and ippWriteToken or ippWriteTokenf to write a token or value to the file.
    
 
    Functions
    
 
    DllMain
    
 
    Main entry for library.
    

From 39ab2475020f7d818f53517fdb4a1e9ec568f3a1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 1 Jan 2024 10:45:37 +0000
Subject: [PATCH 6/6] Bump github/codeql-action from 2 to 3

Bumps [github/codeql-action](https://github.com/github/codeql-action) from 2 to 3.
- [Release notes](https://github.com/github/codeql-action/releases)
- [Changelog](https://github.com/github/codeql-action/blob/main/CHANGELOG.md)
- [Commits](https://github.com/github/codeql-action/compare/v2...v3)

---
updated-dependencies:
- dependency-name: github/codeql-action
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] 
---
 .github/workflows/codeql-analysis.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/codeql-analysis.yml b/.github/workflows/codeql-analysis.yml
index 7e576c1cc4..1755642773 100644
--- a/.github/workflows/codeql-analysis.yml
+++ b/.github/workflows/codeql-analysis.yml
@@ -45,16 +45,16 @@ jobs:
         run: sudo apt-get install -y avahi-daemon cppcheck libavahi-client-dev libcups2-dev libcupsimage2-dev libgnutls28-dev libjpeg-dev libpam-dev libpng-dev libusb-1.0-0-dev zlib1g-dev
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
         with:
           languages: ${{ matrix.language }}
           config-file: ./.github/codeql.yml
           queries: +security-and-quality
 
       - name: Autobuild
-        uses: github/codeql-action/autobuild@v2
+        uses: github/codeql-action/autobuild@v3
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3
         with:
           category: "/language:${{ matrix.language }}"