Comparar commits

...

277 Commits

Autor SHA1 Mensagem Data
Michael R Sweet 8b4e44a962 Bump versions. 2018-11-08 08:49:36 -05:00
Michael R Sweet e3bf09e5ab Bump dates and versions. 2018-11-08 08:48:37 -05:00
Michael R Sweet 2bc91b0fde Fix build/test suite errors on Linux. 2018-11-07 15:51:10 -05:00
Michael R Sweet 9dd00ac572 Drop shared libraries for internal libraries (mirror change from master). 2018-11-07 14:21:03 -05:00
Michael R Sweet 2c48abc6c8 Move away from redefining __attribute__ (Issue #5349) 2018-11-07 14:06:29 -05:00
Michael R Sweet e7e33bf642 Fix stuck multi-file jobs (Issue #5359, Issue #5413) 2018-11-07 11:33:45 -05:00
Michael R Sweet 37665f15b9 Localization updates (Issue #5408) 2018-11-07 10:40:43 -05:00
Michael R Sweet 3cc99f971d Add USB quirks rule for Lexmark MS317dn (Issue #5420) 2018-11-07 10:37:50 -05:00
Michael R Sweet bd93b0f997 Mirror changes from master. 2018-11-06 16:28:08 -05:00
Michael R Sweet abfac4cc2c More changes to VS projects. 2018-10-17 13:54:23 -04:00
Michael R Sweet 69d30da202 Update VS project files. 2018-10-17 13:29:43 -04:00
Michael R Sweet 0313a59eaa Switch to _WIN32 for Windows test. 2018-10-17 13:09:57 -04:00
Michael R Sweet ceaf5639b6 Mirror zlib cleanup changes. 2018-10-17 13:00:16 -04:00
Michael R Sweet bef1d6257e Search for codesign/true, use LDFLAGS for shared libraries (Issue #5411) 2018-10-15 23:21:02 -04:00
Michael R Sweet 3451d5e03c Fix support for Authentication-Info header. 2018-10-11 18:47:19 -04:00
Michael R Sweet 1c37b4f842 Add code signing to 2.2 branch.
Fix test suite with dylibs.
2018-10-11 18:09:12 -04:00
Michael R Sweet b5283eea53 Merge test suite changes from CUPS master. 2018-10-11 14:54:36 -04:00
Michael R Sweet 3c8cc0956c Fix lpadmin error reporting for IPP Everywhere printers (Issue #5370) 2018-09-28 11:22:57 -04:00
Michael R Sweet fe1fac1444 Support face-up printers (Issue #5345) 2018-09-28 11:16:02 -04:00
Michael R Sweet b485551a77 Log actual location of error_log (Issue #5398) 2018-09-18 11:42:08 -04:00
Michael R Sweet 1110512341 Make sure clean is clean. 2018-09-18 09:17:30 -04:00
Michael R Sweet 598bfaad43 Mirror Digest changes from master. 2018-09-14 14:58:46 -04:00
Michael R Sweet 49639d132d Mirror Digest fixes from master. 2018-09-11 12:25:32 -04:00
Michael R Sweet f02e6549b7 Add digest debugging and fix a small bug in the HTTP unit test. 2018-08-29 18:20:28 -04:00
Michael R Sweet 0ae115b3c8 Further simplify the logic in ippCopyAttribute. 2018-08-29 11:52:16 -04:00
Michael R Sweet 0945b205af Simplify the logic in ippCopyAttribute. 2018-08-29 11:43:25 -04:00
Michael R Sweet 7f68222311 Fix issue with HTTP Digest authentication, add unit tests (rdar://41709086) 2018-08-28 22:50:20 -04:00
Michael R Sweet 56ee8bc2c7 Fix a scheduler crash bug (rdar://42198057) 2018-08-27 16:45:04 -04:00
Michael R Sweet 7882a850af Add checks for missing/bad CloseUI/JCLCloseUI keywords (Issue #5381) 2018-08-27 15:14:55 -04:00
Michael R Sweet 215b547e0f Fix JCL option support in PPD compiler (Issue #5379) 2018-08-27 10:29:32 -04:00
Michael R Sweet 655237ebfa Changelog. 2018-08-21 10:00:02 -04:00
Michael R Sweet 1a3ff20f73 Fix memory leaks found by Coverity (Issue #5375) 2018-08-21 09:59:39 -04:00
Michael R Sweet ace9aea063 Fix regression in fix for rdar://40436080. 2018-08-19 09:15:40 -04:00
Michael R Sweet b42427212d Update lpadmin man page (Issue #5369) 2018-08-19 09:06:16 -04:00
Michael R Sweet 9e7efee57b Fix localization of IPP Everywhere PPD (Issue #5362) 2018-08-19 08:54:48 -04:00
Michael R Sweet b7297655b6 Fix shared printing using the IPP Everywhere driver (Issue #5361) 2018-08-19 07:49:55 -04:00
Michael R Sweet 918d2b0748 Validate attribute group for initial request attributes (rdar://41098178) 2018-08-18 08:50:24 -04:00
Michael R Sweet aca718a423 Update copyright in web interface files. 2018-07-18 15:15:16 -04:00
Michael R Sweet d21d96219e Merge localization changes (Issue #5348) 2018-07-18 14:30:33 -04:00
Michael R Sweet 436a2c7363 Merge label driver changes (Issue #5350) 2018-07-18 14:24:27 -04:00
Michael R Sweet 7b94c45550 Mirror backgrounding fix for macOS. 2018-07-17 23:54:43 -04:00
Michael R Sweet a83658fac5 Fix regression in lpadmin fix (Issue #5305) 2018-07-17 22:03:19 -04:00
Michael R Sweet 4aa44fb14d Drop non-working RSS subscription UI from web interface. 2018-06-29 14:11:17 -04:00
Michael R Sweet 7927b44a2e Mirror macOS web interface authentication fix from master. 2018-06-29 13:45:52 -04:00
Michael R Sweet ae9f0b239f Fix auto-debug logging of job errors with systemd (Issue #5337) 2018-06-18 21:46:55 -04:00
Michael R Sweet dfe5192691 Fix crash when AccessLog is NULL (Issue #5309) 2018-06-18 21:37:34 -04:00
Michael R Sweet 2b4e4ed7d8 Use Enable-Printer and Resume-Printer operations so we don't create a bogus printer (Issue #5305) 2018-06-18 21:28:53 -04:00
Michael R Sweet 0dd6c36be9 Fix A4 crash in Epson 24-pin driver (Issue #5323) 2018-06-18 16:39:30 -04:00
Michael R Sweet db837b4742 Ignore bogus cups-version attribute. 2018-06-18 14:33:07 -04:00
Michael R Sweet b74abe7ec1 More tweaks for IPP Everywhere support in web interface. 2018-06-18 14:31:00 -04:00
Michael R Sweet 24a5ffa61b Support IPP Everywhere driver in web interface (Issue #5338) 2018-06-18 13:15:55 -04:00
Michael R Sweet 05bb584270 Add options to force a TLS version. 2018-06-15 15:16:31 -04:00
Michael R Sweet 91f20f1695 Mirror TLS changes from master. 2018-06-15 11:26:36 -04:00
Michael R Sweet 18545a5e7a Fix regressions in ippValidateAttribute (Issue #5322, Issue #5330) 2018-06-11 09:37:55 -04:00
Michael R Sweet c7dee40123 Update paths for PWG raster sample files. 2018-06-07 16:50:25 -04:00
Michael R Sweet b0dcb3094c Specify GPG signing user. 2018-06-06 09:02:08 -04:00
Michael R Sweet 8268b593b0 Bump version, mirror fix from master, changelog. 2018-06-05 13:51:15 -04:00
Michael R Sweet ca0eb73820 Fix link to CUPS Programming Manual. 2018-06-05 12:31:43 -04:00
Michael R Sweet 4ebeb20c50 Update README and INSTALL 2018-06-05 12:06:54 -04:00
Michael R Sweet 26e33331ce Update HTML man pages. 2018-06-05 12:04:24 -04:00
Michael R Sweet 2e913c4b4e Update documentation and localization files for CUPS 2.2.8 release. 2018-06-05 11:59:09 -04:00
Michael R Sweet b764f49b0c Mirror localization changes (Issue #5317) 2018-06-05 11:50:47 -04:00
Michael R Sweet 6ff5bbedb9 Fix a parsing bug in the pstops filter (Issue #5321) 2018-06-05 11:36:42 -04:00
Michael R Sweet ff52b652cf Added a USB quirks rule for the HP LaserJet P1102 (Issue #5310) 2018-06-05 11:27:53 -04:00
Michael R Sweet fc19457093 Fix iOS compile warning. 2018-06-05 09:19:13 -04:00
Michael R Sweet 2dbebbaa23 Update changelog. 2018-06-05 08:54:34 -04:00
Michael R Sweet 97cb566568 Fix local privilege escalation to root and sandbox bypasses in scheduler
(rdar://37836779, rdar://37836995, rdar://37837252, rdar://37837581)
2018-06-05 08:52:17 -04:00
Michael R Sweet 7c7f431a26 Mirror change from master. 2018-06-05 08:51:41 -04:00
Michael R Sweet 22716a21f7 Mirror change from master. 2018-06-04 16:19:55 -04:00
Michael R Sweet 3f8d6023ed Mirror smb change from master. 2018-05-18 15:38:03 -04:00
Michael R Sweet 4c975abbc7 Add more URI validation for scheme. 2018-05-14 15:24:47 -07:00
Michael R Sweet d66aa76457 Mirror documentation updates from master. 2018-05-14 10:27:59 -07:00
Michael R Sweet 4c37eb9f77 Generalize the input validation of some kinds of attributes.
cups/ipp.c:
- ippValidateAttribute: Do C0/DEL checks for name and text values, per IPP
  Everywhere.

cups/testhttp.c:
- Add URI test case containing a newline.

scheduler/ipp.c:
- create_subscriptions: Validate notify-user-data for mailto:.
- hold_job: Validate job-hold-until.
- set_job_attrs: Validate all attributes, specific checks for job-hold-until.
- validate_job: Add missing job-hold-until validation, move job-name validation
  to ippValidateAttribute function.
2018-05-11 12:02:27 -07:00
Michael R Sweet 66021bfa90 Mirror mailto changes from master (Issue #5312) 2018-05-11 10:27:24 -07:00
Michael R Sweet d3cc15d4b2 Always use Negotiate or PeerCred for Kerberized printing. 2018-05-10 16:33:07 -04:00
Michael R Sweet f58657f987 Mirror spec-command.html typo fix (Issue #5306) 2018-05-01 08:37:54 -04:00
Michael R Sweet 8c2150d186 Use -m everywhere for manual sharing. 2018-04-24 20:45:21 -04:00
Michael R Sweet 5c7df4f0e0 Fix 360dpi typo (Issue #5300) 2018-04-24 20:34:29 -04:00
Michael R Sweet 9135aedbb4 Update ErrorPolicy in cupsd.conf man page (Issue #5301) 2018-04-24 20:32:10 -04:00
Michael R Sweet 90a97dd7b6 Fix systemd restart policy (Issue #5297) 2018-04-18 08:50:59 -04:00
Michael R Sweet 417d0e1635 Fix policy limits using All (Issue #5296) 2018-04-17 16:55:14 -04:00
Michael R Sweet 4440da10e5 Map , to p in phone numbers. 2018-04-17 14:22:46 -04:00
Michael R Sweet 4b55f9f3c1 Add support for pause and wait characters in fax numbers (rdar://39212256) 2018-04-17 12:47:14 -04:00
Michael R Sweet bb10adda6f Try again to mirror fix (Issue #5289) 2018-04-16 19:19:13 -04:00
Michael R Sweet 2390f1d9eb Added a workaround for certain web browsers that do not support multiple authentication schemes in a single response header (Issue #5289) 2018-04-16 17:19:04 -04:00
Michael R Sweet b643d6ba92 Fix cups_auth_find for schemes without parameters. 2018-04-11 22:03:57 -04:00
Michael R Sweet 1f679daf00 Fix a parsing bug in the new authentication code. 2018-04-11 13:10:51 -04:00
Michael R Sweet 0612a04d5d Fix lpoptions man page (Issue #5286) 2018-04-10 15:41:59 -04:00
Michael R Sweet f6d93318e0 Fix another CUPS-Create-Local-Printer crash (Issue #5290) 2018-04-09 15:30:52 -04:00
Michael R Sweet 821b3cc956 Mirror changes to legacy CUPS print APIs from master (Issue #5288) 2018-04-09 09:54:16 -04:00
Michael R Sweet b757529b6f Fix ippfind _regtype 2018-04-05 17:26:05 -04:00
Michael R Sweet 566d5c707e Backport ippfind --literal-name option. 2018-04-03 18:29:52 -04:00
Michael R Sweet a922c92cd0 Bump version. 2018-04-03 15:57:28 -04:00
Michael R Sweet aefefc3539 Backport changes for attribute substitution (Issue #5229) 2018-04-03 15:57:19 -04:00
Michael R Sweet 0e41e1ca5d Changelog. 2018-04-02 20:19:22 -04:00
Michael R Sweet d2e90eb7c7 The ipptool program no longer checks for duplicate attributes when running
in list or CSV mode (Issue #5278)
2018-04-02 20:15:07 -04:00
Michael R Sweet 570933a6a3 Fix builds without PAM (Issue #5283) 2018-04-02 20:05:13 -04:00
Michael R Sweet 84c97c051d Update VisualStudio Project 2018-03-22 23:48:36 -04:00
Michael R Sweet 5f67be43fa Changelog 2018-03-22 11:43:05 -04:00
Michael R Sweet b59756883a Update documentation. 2018-03-22 09:50:29 -04:00
Michael R Sweet 6daeebb5ac Fix test script to account for unpredictability of Test3 page counts. 2018-03-22 09:32:58 -04:00
Michael R Sweet 2bad6aac2f Changelog 2018-03-22 09:02:27 -04:00
Michael R Sweet 9d72065fa9 Try another fix for Avahi crash (Issue #5268) 2018-03-21 18:00:18 -04:00
Michael R Sweet 75d3f11945 Fix 'make check' script. 2018-03-19 18:51:36 -04:00
Michael R Sweet 6bebebe247 Cleanup man page updates. 2018-03-19 18:41:46 -04:00
Michael R Sweet 1d598e87db Changelog and localizations. 2018-03-19 18:36:48 -04:00
Michael R Sweet 3645e5efa7 Deprecate raw print queues. 2018-03-19 18:35:34 -04:00
Michael R Sweet e8953be355 Include cupsJobPassword keyword in generated PPDs (Issue #5265) 2018-03-19 13:18:28 -04:00
Michael R Sweet 782bcf6974 Fix _cupsCondWait again. 2018-03-14 18:06:52 -04:00
Michael R Sweet 3d7ece43ea Fix definition of IPP_DSTATE_ enums. 2018-03-12 21:58:11 -04:00
Michael R Sweet 290404655f Fix implementation of _cupsCondWait with timeout. 2018-03-12 21:56:51 -04:00
Michael R Sweet c59948f6fb Use setuid for Kerberized IPP printing (Issue #5233) 2018-03-12 21:51:47 -04:00
Michael R Sweet b237ae81d2 Fix printing to some IPP Everywhere printers (Issue #5238) 2018-03-12 21:48:04 -04:00
Michael R Sweet 82c4785a4c Fix systemd integration with cupsd (Issue #5263) 2018-03-12 13:33:45 -04:00
Michael R Sweet 9113651bca Fix the Windows export file. 2018-03-09 18:48:39 -05:00
Michael R Sweet 3034dcc946 Bump shared library version to account for new functions. 2018-03-09 18:47:34 -05:00
Michael R Sweet 2aee052bf5 Fix Kerberized IPP printing (Issue #5233) 2018-03-09 15:41:19 -05:00
Michael R Sweet 8e47ac0199 The scheduler could crash while adding an IPP Everywhere printer (Issue #5258) 2018-03-08 11:48:43 -05:00
Michael R Sweet 30c8d1abb2 Disable SNMP supplies for all label printers (Issue #5256) 2018-03-08 11:09:38 -05:00
Michael R Sweet 5e18690298 Add USB quirk rule for Lexmark Optra E310 printers (Issue #5259) 2018-03-08 11:04:56 -05:00
Michael R Sweet bec850697a Fix stray space/tab. 2018-03-07 09:32:04 -05:00
Michael R Sweet 4ffdbc48d8 Bump versions in config headers. 2018-03-07 09:14:57 -05:00
Michael R Sweet accd26d222 Temporary files are now placed in the correct directory for sandboxed
applications on macOS (rdar://problem/37789645)
2018-03-07 09:03:24 -05:00
Michael R Sweet 08b48df256 Update documentation for cupsHashString. 2018-03-07 08:57:12 -05:00
Michael R Sweet bb4172dade Fix crash bug in HTTP field handling - regression in the backported change for
Issue #4862.
2018-03-06 23:21:40 -05:00
Michael R Sweet afe94dff9d Remainder of patches for backporting 2.3 changes to 2.2.x (Issue #5255) 2018-03-06 23:18:26 -05:00
Michael R Sweet 1f71721001 Backport CUPS 2.3.x changes to 2.2.x (Issue #5255)
- Fixed a compile issue when PAM is not available (Issue #5253)
- Documentation fixes (Issue #5252)
- Star Micronics printers need the "unidir" USB quirk rule (Issue #5251)
- The scheduler now supports using temporary print queues for older IPP/1.1 print queues like those shared by CUPS 1.3 and earlier (Issue #5241)
- The `cupsRasterWritePixels` function did not correctly swap bytes for some formats (Issue #5225)
- Added a USB quirk rule for Canon MP280 series printers (Issue #5221)
- The `ppdInstallableConflict` tested too many constraints (Issue #5213)
- More fixes for printing to old CUPS servers (Issue #5211)
- The `cupsCopyDest` function now correctly copies the `is_default` value (Issue #5208)
- The scheduler did not work with older versions of uClibc (Issue #5188)
- The scheduler now substitutes default values for invalid job attributes when running in "relaxed conformance" mode (Issue #5186)
- Fixed PAM module detection and added support for the common PAM definitions (Issue #5185)
- Fixed a journald support bug in the scheduler (Issue #5181)
- The cups-driverd program incorrectly stopped scanning PPDs as soon as a loop was seen (Issue #5170)
- Fixed group validation on OpenBSD (Issue #5166)
- Fixed the `ippserver` sample code when threading is disabled or unavailable (Issue #5154)
- The `cupsEnumDests` function did not include options from the lpoptions files (Issue #5144)
- The `SSLOptions` directive now supports `MinTLS` and `MaxTLS` options to control the minimum and maximum TLS versions that will be allowed, respectively (Issue #5119)
- The scheduler did not write out dirty configuration and state files if there were open client connections (Issue #5118)
- The `lpadmin` command now provides a better error message when an unsupported System V interface script is used (Issue #5111)
- The `lp` and `lpr` commands now provide better error messages when the default printer cannot be found (Issue #5096)
- No longer support backslash, question mark, or quotes in printer names (Issue #4966)
- The CUPS library now supports the latest HTTP Digest authentication specification including support for SHA-256 (Issue #4862)
- The `lpstat` command now reports when new jobs are being held (Issue #4761)
- The `lpoptions` command incorrectly saved default options (Issue #4717)
- The `ppdLocalizeIPPReason` function incorrectly returned a localized version of "none" (rdar://36566269)
- TLS connections now properly timeout (rdar://34938533)
- The IPP backend did not properly detect failed PDF prints (rdar://34055474)
2018-03-06 22:53:41 -05:00
Michael R Sweet 18a1649286 Need to look further down in CHANGES.md, fix messages to use .md suffix. 2017-11-01 10:59:53 -04:00
Michael R Sweet 58c3683023 Update version check to reflect new changelog title format. 2017-11-01 10:57:53 -04:00
Michael R Sweet 303be29243 Bump versions... 2017-11-01 10:56:47 -04:00
Michael R Sweet 275af5ac7b Update CUPS programming manual. 2017-11-01 10:51:16 -04:00
Michael R Sweet d821d89415 Revert change in cupsDoIORequest, which caused problems. 2017-11-01 10:22:12 -04:00
Michael R Sweet 6579c998c4 Fix handling of "yue" language. 2017-10-30 12:20:12 -04:00
Michael R Sweet 1377fb858c Merge pull request #5155 from DavieV/check-printer-first
Rearranging order of null checks in lpadmin
2017-10-30 12:04:06 -04:00
DavieV f9ee3b81e1 Rearranging order of null checks in lpadmin 2017-10-25 22:29:01 -07:00
Michael Sweet 7e50a735a8 Changelog. 2017-10-25 13:36:33 -04:00
Michael R Sweet 56b62a3b54 Merge pull request #5152 from michaelweghorn/michaelweghorn/add_missing_space_in_localization
Add missing space in German localization
2017-10-25 10:04:41 -04:00
Michael Weghorn 02773ede84 Add missing space in German localization 2017-10-25 15:03:23 +02:00
Michael Sweet ec9996719f Update fanfold sizes. 2017-10-23 17:48:40 -04:00
Michael Sweet affaf0737f Update message catalogs. 2017-10-23 17:29:15 -04:00
Michael Sweet 49fa4983f2 DBUS notifications could crash the scheduler (Issue #5143)
- scheduler/ipp.c: Make sure requesting-user-name string is valid UTF-8.
2017-10-23 16:23:43 -04:00
Michael R Sweet 34be0e8038 Merge pull request #5150 from hardfalcon/master
Fix AllowRC4 and AllowSSL3 on GnuTLS platforms
2017-10-23 16:07:45 -04:00
Pascal Ernster ce0d9679a4 Fix indention 2017-10-22 23:33:07 +02:00
Pascal Ernster fad821594f Fix AllowRC4 and AllowSSL3 on GnuTLS platforms 2017-10-22 22:34:42 +02:00
Pascal Ernster f8913c6d2c Merge branch 'master' of https://github.com/apple/cups 2017-10-22 22:13:10 +02:00
Pascal Ernster a75c0e5961 Revert "Clean up implementation for SSLOptions"
This reverts commit c61b78bd84.
2017-10-22 22:12:51 +02:00
Pascal Ernster 5ee613bbc6 Revert "Changed AllowDH to no-op on gnutls platforms, explicitly disabled ANON-DH and ANON-ECDH ciphersuites on gnutls"
This reverts commit 46a7b416ee.
2017-10-22 22:12:18 +02:00
Michael Sweet 02c88e673e Fix cipher suite selection with GNU TLS (Issue #5145)
Also make sure that client.conf SSLOptions do not override cupsd.conf
SSLOptions, and document the (hopefully obvious) fact that Allow* is less
secure and Deny* is more secure.

- cups/http-private.h: Add "_HTTP_TLS_SET_DEFAULT" flag for options set from
  client.conf.
- cups/tls-*.c: Use new flag.
- cups/tls-gnutls.c: Fix CBC cipher suite exclusion logic, and always disable
  anonymous DH.
- cups/usersys.c: Pass new flag when calling _httpTLSSetOptions.
- man/*: Update documentation.
2017-10-19 22:44:12 -04:00
Pascal Ernster 46a7b416ee Changed AllowDH to no-op on gnutls platforms, explicitly disabled ANON-DH and ANON-ECDH ciphersuites on gnutls 2017-10-20 03:23:01 +02:00
Pascal Ernster c61b78bd84 Clean up implementation for SSLOptions 2017-10-20 00:37:43 +02:00
Michael R Sweet 0ae5b012b2 Merge pull request #5146 from DavieV/fix-ifs
Remove unnecessary nesting in if statements.
2017-10-19 10:52:59 -04:00
Michael Sweet 15bba96c30 Update configure script. 2017-10-19 10:52:21 -04:00
Michael Sweet bea3713442 Changelog and bump CUPS version. 2017-10-19 10:52:21 -04:00
Michael R Sweet 5639a7b41c Merge pull request #5148 from zdohnal/quirks
add usb quirks for canon mp540 and Samsung ML-2160 Series
2017-10-19 10:49:48 -04:00
Zdenek Dohnal 360e815a88 add usb quirks for canon mp540 and Samsung ML-2160 Series 2017-10-17 18:28:39 +02:00
DavieV c00282bb43 Remove unnecessary nesting in if statements. 2017-10-16 14:24:13 -07:00
Michael R Sweet 3a16bd9c9d Packaging changes for newer localizations. 2017-10-13 14:22:26 -04:00
Michael Sweet a7cdcd19b8 More updates to the README file. 2017-10-12 20:37:36 -04:00
Michael Sweet 79424d8b9a Prep for 2.2.5 release. 2017-10-12 20:16:09 -04:00
Michael R Sweet 5889fea75a Merge pull request #5139 from kant/patch-1
Clean up README markup(down).
2017-10-12 19:39:22 -04:00
Darío Hereñú 16389be3ba Minor fixes (proposals) 2017-10-12 16:53:46 -03:00
Michael Sweet f97678f279 Ignore new test programs. 2017-10-12 14:46:02 -04:00
Michael Sweet 979804902c Fix "make check" for restricted environments (Issue #5099) 2017-10-12 14:27:18 -04:00
Michael Sweet b889560c05 Fixed the script interpreter detection in the configure script (Issue #5122) 2017-10-12 10:43:35 -04:00
Michael Sweet c9e9d0e810 Changlog + remove generated web interface header template (Issue #5134) 2017-10-12 10:26:09 -04:00
Michael R Sweet a5dd746bd0 Merge pull request #5134 from LAfricain/master
Creation of template/fr and French translation of all the template files
2017-10-12 10:23:44 -04:00
Michael Sweet 6b33281c3e One further fix for cupsGetDests2 - don't show network printers when the server
is remote.
2017-10-12 08:31:03 -04:00
Michael Sweet 9554d4e748 cupsGetDests2 was not using the supplied HTTP connection (Issue #5135)
- Make a local cups_enum_dests function that accepts a http_t *.
- Have both cupsEnumDests and cupsGetDests2 call cups_enum_dests.
2017-10-11 13:27:36 -04:00
Michael Sweet c0a47c1101 Fix crash in debug printf. 2017-10-11 13:23:27 -04:00
Michael Sweet 4cf66fef48 The network backends now retry on more error conditions (Issue #5123) 2017-10-05 15:04:19 -04:00
Lafricain b17b635a37 Correction of a bad translation 2017-10-05 13:00:42 +01:00
Michael Sweet 5d8b7d2665 Add support for Japanese Kaku 1 envelope size (rdar://34774110)
- Add jpn_kaku1_270x382mm size to table.
2017-10-02 19:29:52 -04:00
Michael Sweet e4e371946b The scheduler did not run with a high enough priority, causing problems on
busy systems (rdar://33789342)

- Change ProcessType to Adaptive for both cupsd and cups-lpd
- Add "working" parameter to cupsdSetBusyState
- Call cupsdSetBusyState on startup to boost the priority on startup.
2017-10-02 19:14:25 -04:00
Lafricain 46d22fe908 Creation of Template/fr and French translation of all the template files 2017-10-02 13:56:19 +01:00
Michael R Sweet 9d4ae311cb Merge pull request #5112 from paulmenzel/remove-libgcrypt-detection
Remove Libgcrypt detection
2017-09-28 13:12:01 -04:00
Michael Sweet 2cf3a36a4e One more thing for macOS (Issue #5116) 2017-09-25 10:55:27 -04:00
Michael Sweet fd2f0a7af7 Update INSTALL.md (Issue #5116) 2017-09-25 10:54:36 -04:00
Michael Sweet aa2a77dec8 Add USB quirk for HP LaserJet 1160 (Issue #1160) 2017-09-25 10:19:17 -04:00
Michael Sweet f0f4e0366c Update configure script. 2017-09-24 11:51:48 -04:00
Michael Sweet 4279822fe4 Suppress new GCC warning about snprintf truncation (Issue #5110) 2017-09-24 11:51:07 -04:00
Michael Sweet c6990c1ed5 Re-document that file devices do not work with raw queues, and move FileDevice
to the list of deprecated configuration directives (Issue #5117)
2017-09-21 22:47:04 -04:00
Michael Sweet c31737b031 Bump Xcode CUPS version. 2017-09-21 22:39:52 -04:00
Michael Sweet 2d947886ad Fix Windows builds. 2017-09-14 14:20:07 -04:00
Michael Sweet 116c301f23 Detach worker threads to prevent memory leaks. 2017-09-14 14:19:00 -04:00
Michael Sweet b908d72cac Fix memory leaks. 2017-09-14 14:12:49 -04:00
Michael Sweet 2cb1fda9fe Allow DELAY values of 0. 2017-09-12 12:21:00 -04:00
Paul Menzel 0728c89bcf config-scripts/cups-ssl.m4: Remove Libgcrypt detection
Upstream a change from the book *Beyond Linux From Scratch* [1].

> Prevent configure script from searching libgcrypt-config, because
> libgcrypt is not used anywere else in the package.

[1] http://www.linuxfromscratch.org/blfs/view/svn/pst/cups.html
2017-09-12 13:18:21 +02:00
Michael Sweet 123cfe0202 The scheduler (incorrectly) woke up once per second to remove stale temporary
queues (Issue #5100).

- scheduler/main.c: Update local_timeout to start at 0 and only get updated as
  needed.

Fixes: #5100
2017-09-11 17:08:17 -04:00
Michael Sweet d2123aee55 Fix mapping and defaulting of print-quality/cupsPrintQuality (Issue #5090)
- cups/dest.c: Don't include empty default media or print-quality in dest
  options.
- cups/options.c: When setting cupsPrintQuality, clear print-quality and vise-
  versa.
- cups/testipp.c: Use current API to show attribute values.
- scheduler/ipp.c: Log request attributes, defaults.
- scheduler/job.c: Add/map print-quality/cupsPrintQuality, log mapped options.

Fixes: #5090
2017-09-11 16:22:45 -04:00
Michael Sweet ea4dcf9ff4 The ipptool program did not compare URI scheme or hostname components
correctly for the WITH-ALL-HOSTNAMES, WITH-ALL-SCHEMES, WITH-HOSTNAME, or
WITH-SCHEME predicates.

Also fix EXPECT reporting for the URI component WITH predicates.
2017-09-07 10:36:09 -04:00
Michael Sweet b39dd420c6 Fix builds without Bonjour/Avahi (Issue #5105) 2017-09-05 17:03:10 -04:00
Michael Sweet 5614f45d77 Changelog. 2017-09-05 16:59:06 -04:00
Michael R Sweet 5229ea1a41 Merge pull request #5103 from michaelweghorn/issue5102
Add a USB quirk rule for the Kyocera Ecosys P6130cdn (Issue #5102)
2017-09-05 16:57:36 -04:00
Michael Weghorn b72c5bf2ed Add a USB quirk rule for the Kyocera Ecosys P6130cdn (Issue #5102) 2017-09-01 13:37:36 +02:00
Michael Sweet befbadcef6 Fix ipptool -P output (some was going to stdout...) 2017-08-31 08:38:39 -04:00
Michael Sweet 7b0a28e38f httpAddrConnect leaked sockets in certain circumstances, causing some
printers to hang (rdar://31965686)
2017-08-29 20:42:05 -04:00
Michael Sweet e78c14f7ea Fix create-job.test file to use filename on command-line. 2017-08-29 20:30:46 -04:00
Michael Sweet e146105294 Always use chunking unless it is a simple request. 2017-08-29 20:30:27 -04:00
Michael Sweet e37405ea8e Add verbosity option. 2017-08-29 20:29:54 -04:00
Michael Sweet 5535551fd9 Add -d (document-format) option to override which format is used. 2017-08-29 19:56:08 -04:00
Michael Sweet 7f14a29798 Fix output to write a full page.
Add "force grayscale" option.
2017-08-29 19:44:10 -04:00
Michael Sweet 4b16c717e5 Move test client program to filter directory, finish initial implementation. 2017-08-29 17:27:49 -04:00
Michael Sweet 240a27f93b Save work on client code. 2017-08-29 14:15:00 -04:00
Michael Sweet 75e1a17cad Add client simulator for testing basic client functionality from a single
program.
2017-08-29 12:06:23 -04:00
Michael Sweet 40cc612af4 Fix the interactions between the "print-quality" and "cupsPrintQuality"
options (Issue #5090)

- Make sure print-quality-default does not override cupsPrintQuality
- Make sure print-quality overrides cupsPrintQuality
2017-08-29 09:33:48 -04:00
Michael Sweet 9449dd948a The CUPS library did not reuse domain sockets (Issue #5098) 2017-08-28 17:59:13 -04:00
Michael Sweet 2793a478d0 The web interface did not support newer language identifiers used by Microsoft
web browsers (Issue #5803)

Make sure cupsLangGet supports region codes and that the scheduler uses
cupsLangGet when mapping IPP naturalLanguage values to POSIX locales.
2017-08-28 16:18:18 -04:00
Michael R Sweet 5b6caf71b8 More changes for localization unit test (Issue #5097) 2017-07-25 19:57:31 -04:00
Michael Sweet b10aebb1d3 Update localization information.
Create English locale file from cups.pot for unit tests.
2017-08-28 12:29:22 -04:00
Michael Sweet 9964a31a77 Fix the localization unit test on Linux (Issue #5097)
Makefile needed to create locale directory for tests.

Also, localization test needs to allow string pointers to match for the POSIX
locale and differ for other languages.
2017-08-28 12:19:58 -04:00
Michael Sweet 7c7347a346 Update the cups-files.conf and cupsd.conf file documentation for missing
directives (Issue #5084)
2017-08-28 10:39:18 -04:00
Michael Sweet b337f966e8 Fix an Avahi-related crash bug in the scheduler (Issue #5085, Issue #5086)
Add NULL pointer check to avoid Avahi assertion in production code.
2017-08-28 10:04:29 -04:00
Michael Sweet e9b2d701da Fix compile issue for PID file stuff when no systemd/launchd/upstart is
available.

Also restructure code slightly so it isn't so convoluted.
2017-08-27 10:59:38 -04:00
Michael Sweet 91d748b919 Fix sorting bug. 2017-08-27 10:58:06 -04:00
Michael Sweet fa76bc3dc0 The IPP Everywhere PPD generator now sorts the supported resolutions before
choosing them for draft, normal, and best quality modes (Issue #5091)

Also prefer urf-supported values over pwg-raster-document-xxx-supported values
since the former is more reliable than the latter.
2017-08-27 10:40:30 -04:00
Michael Sweet 4f272af7bb Support internal "only TLS/1.0" option for tlscheck.
Expand CBC filter on macOS.

Add support for --tls10 and --no-cbc options with tlscheck.
2017-08-25 16:39:50 -04:00
Michael R Sweet b770b18d0f Merge pull request #5081 from sblondon/master
Update french translations
2017-08-25 00:56:08 -04:00
Michael Sweet b0a1b229b3 Update changelog. 2017-08-09 13:45:19 -04:00
Michael Sweet 997db40489 Fix the localization fallback code on macOS (rdar://33583699) 2017-08-09 13:43:08 -04:00
Stephane Blondon 07911378c0 Update french translations 2017-08-06 21:58:53 +02:00
Michael Sweet 345e10ca71 Add header validation option to ipptool.
Update HTML versions of man pages.
2017-08-04 12:52:43 -04:00
Michael Sweet 41c0a57318 Fix compiler warning. 2017-08-03 14:00:17 -04:00
Michael Sweet 10f9350b7e The ippCopyAttribute function did not copy out-of-band values correctly
(rdar://33688003)
2017-08-02 19:53:50 -04:00
Michael Sweet 03bc3ef4c2 The scheduler now creates a PID file when not running on demand with a modern
service launcher (Issue #5080)
2017-08-01 19:16:25 -04:00
Michael Sweet 7e7a13a32e Update localizations yet again based on IPP sample strings. 2017-08-01 17:09:33 -04:00
Michael Sweet 60716f946c Update copyright. 2017-08-01 00:29:21 -04:00
Michael Sweet e34d348250 Fix default language for multi-language PPDs. 2017-07-31 21:39:13 -04:00
Michael Sweet ada3421240 Fix the adminurl field in the TXT record for fully-qualified ServerName
values (Issue #5074)
2017-07-31 21:29:20 -04:00
Michael Sweet a2a13afb48 Fix the default ServerAlias value (Issue #5072) 2017-07-31 17:55:01 -04:00
Michael Sweet 259b03bc46 Update localization files with corrections for IPP strings. 2017-07-31 17:34:11 -04:00
Michael Sweet a375587b8c Fix localizations of some media sizes and remove localizations of operation
names.
2017-07-31 14:59:06 -04:00
Michael Sweet 0bc1a539f4 Clean up unit test. 2017-07-25 18:26:20 -04:00
Michael Sweet 86390cbf57 Add unit test that loops calling cupsGetDests. 2017-07-25 18:18:14 -04:00
Michael Sweet ced9dda826 Add error checking for all Bonjour browsing in cupsEnumDests.
Clean up testcups unit tests.
2017-07-25 18:11:01 -04:00
Michael Sweet e9faaeef18 Changelog. 2017-07-24 22:45:46 -04:00
Michael Sweet c9dbe83d17 Remove old API documentation files. 2017-07-24 22:45:08 -04:00
Michael R Sweet e3b9d1f520 Use a 250ms delay for cupsGetDests - not perfect, but usually gets the full
list of local network printers (Issue #5049)
2017-07-24 22:43:56 -04:00
Michael Sweet 9f573d7be9 Try a much shorter enum time for cupsGetDests (Issue #5049) 2017-07-24 18:05:39 -04:00
Michael Sweet 5cc8588e8c Fix the ServerTokens None option (Issue #5065) 2017-07-24 17:29:07 -04:00
Michael R Sweet f198f7e1e7 Merge pull request #5066 from sblondon/master
Update french translations
2017-07-24 11:21:14 -04:00
Michael R Sweet 5e59cd062f Fix "DenyCBC" priority string with GNU TLS. 2017-07-23 20:02:57 -04:00
Stéphane Blondon bee711586d Update french translations 2017-07-22 15:52:10 +02:00
Michael Sweet e7729c5a14 The scheduler's -t option did not force all errors to the standard error
file, making debugging of configuration problems hard (Issue #5041)
2017-07-19 15:37:30 -04:00
Michael Sweet 9eb416ee89 Fix logging when "-t" is used (always to stderr). 2017-07-19 15:29:01 -04:00
Michael Sweet b74b285e47 Lower maximum poll()/select() time to 100ms (possible fix for Issue #5049) 2017-07-19 14:28:11 -04:00
Michael Sweet 48dfd9a9a2 Update changelog. 2017-07-19 14:26:08 -04:00
Michael Sweet 4174429905 Changelog. 2017-07-19 14:19:40 -04:00
Michael Sweet 13be9452da Fix a build issue with --enable-mallinfo (Issue #5051) 2017-07-19 14:12:41 -04:00
Michael Sweet a9357c9da4 Implement standard localizations in cupsLocalizeDest* (Issue #5056)
Add standard media size names to the localizations, too, since the PPD names
are not the right ones.
2017-07-19 13:55:32 -04:00
Michael Sweet 44b3f16133 Add base IPP attribute/value localizations (Issue #5056) 2017-07-19 12:35:41 -04:00
Michael Sweet c536b6c583 The cupsGetNamedDest function did not use the local default printer
(rdar://33228500)
2017-07-19 08:15:08 -04:00
Michael Sweet 03d3907a33 Changelog for Issue #5054. 2017-07-19 07:40:41 -04:00
Michael Sweet 76ae98d657 CUPS now sends the Date HTTP header in IPP requests (rdar://33302034) 2017-07-18 11:55:15 -04:00
Michael Sweet 6d086e08e4 Fix the cups.strings file generation (bug in code that generates the Unicode
quotes), and add support for .strings files in checkpo so that we can validate
the results from now on (rdar://33287650)
2017-07-18 11:33:03 -04:00
Michael Sweet 49f495c32e The IPP backend incorrectly sent the "job-pages-per-set" attribute to PDF
printers (rdar://33250434)

Need to save the original number of copies and only send "job-pages-per-set"
when the copy count is reset to 1 (as happens when printing with a raster
format...)
2017-07-18 10:10:16 -04:00
Michael R Sweet f8a5ad9bde Merge pull request #5054 from sanbrother/master
Fix : dead lock when there is already an active job
2017-07-18 08:31:49 -04:00
Michael R Sweet 07cb72471a Fix builds without libtool. 2017-07-17 20:44:20 -04:00
Michael R Sweet b94f7488e8 Fix more issues with libtool support (Issue #5050) 2017-07-17 19:58:53 -04:00
Michael R Sweet d2d605ff77 Fix authorization checks on macOS (no longer /etc/authorization, but now we don't need
to look for the old names from 10.5...)
2017-07-17 19:49:27 -04:00
Michael R Sweet 6eda776e8a Update help text so everything lines up properly and is consistent and spelled correctly. 2017-07-17 18:28:27 -04:00
Michael R Sweet a621d151e7 Update libtool support to include --mode=foo stuff - surprise, libtool changed in
incompatible ways again...  (Issue #5050)
2017-07-17 18:23:00 -04:00
Michael R Sweet 3a1e6b10c5 Merge pull request #5062 from rohieb/libtool-fixes
configure: don't accidentally set @LIBTOOL@ to 'yes'

I'll also be updating the help string to make this clearer as well.
2017-07-17 18:03:35 -04:00
Roland Hieber 7a0e5acde2 configure: don't accidentally set @LIBTOOL@ to 'yes'
Substituting @LIBTOOL@ with 'yes' would result in a lot of console
output (34 GB in my case, before SIGKILL), without getting anything
compiled at all.

Signed-off-by: Roland Hieber <r.hieber@pengutronix.de>
2017-07-17 14:23:39 +02:00
sanbrother c5755caf42 Fix : dead lock when there is already an active job 2017-07-11 14:28:23 +08:00
Michael R Sweet e44bdfe7e3 The IPP backend now always sends the "finishings" attribute for printers that
support it because otherwise the client cannot override printer defaults
(rdar://33169732)
2017-07-07 16:12:11 -04:00
Michael R Sweet b2f85109da The cupsGetDests function incorrectly returned an empty list of printers if there was
no default printer (Issue #5046)
2017-07-07 14:23:21 -04:00
Michael R Sweet fb963b8dd1 Add some more debug printfs to figure out Issue #5046... 2017-07-07 14:12:09 -04:00
Michael Sweet fdc80a913f Fix Apple language ID parsing to support three-letter language codes. 2017-07-04 19:34:12 -04:00
Michael Sweet 1a9743f9d7 Update language unit test to iterate over all macOS language IDs to validate
that libcups can handle them all (which it currently does not...)
2017-07-04 18:10:34 -04:00
Michael Sweet 534dfe8e94 Implement "default" command (show_default) function for media and other options. 2017-07-04 12:17:37 -04:00
Michael Sweet f1175a5a9d Bump CUPS Programming Manual version. 2017-07-04 09:59:01 -04:00
Michael Sweet db5424ea51 Fix a typo in the CUPS Programming Manual (Issue #5042) 2017-07-04 09:57:33 -04:00
Michael Sweet cac6b6562c Update changelog, remove reference to issue number in spec file. 2017-07-04 09:46:28 -04:00
Michael R Sweet b67c2dd202 Merge pull request #5044 from kesterriley/patch-1
Update cups.spec.in
2017-07-04 09:45:01 -04:00
kesterriley b3f6f8d202 Update cups.spec.in
To fix issue 5043.

Checking for unpackaged file(s): /usr/lib/rpm/check-files /root/rpmbuild/BUILDROOT/cups-2.2.4-0.x86_64
error: Installed (but unpackaged) file(s) found:
   /usr/share/locale/zh_CN/cups_zh_CN.po


RPM build errors:
    Installed (but unpackaged) file(s) found:
   /usr/share/locale/zh_CN/cups_zh_CN.po
2017-07-04 07:34:04 +01:00
Michael Sweet 4fac83763d Add some additional debug messages for, um, debugging purposes... 2017-07-03 19:21:42 -04:00
Michael R Sweet 2650d637dc Update Apple language ID mapping to POSIX locale IDs (rdar://32419311) 2017-06-30 16:34:05 -04:00
359 arquivos alterados com 96397 adições e 9748 exclusões
+18 -7
Ver Arquivo
@@ -1,12 +1,7 @@
*.a
*.bck
*.cgi
*.dylib
*.gz
*.o
*.so
*.so.*
*.tokens
.buildrev
autom4te.cache
config.h
@@ -29,7 +24,11 @@ berkeley/lpc
berkeley/lpq
berkeley/lpr
berkeley/lprm
cgi-bin/makedocset
cgi-bin/admin.cgi
cgi-bin/classes.cgi
cgi-bin/help.cgi
cgi-bin/jobs.cgi
cgi-bin/printers.cgi
cgi-bin/testcgi
cgi-bin/testhi
cgi-bin/testhi.index
@@ -39,6 +38,10 @@ conf/cupsd.conf
conf/mime.convs
conf/pam.std
conf/snmp.conf
cups/libcups.2.dylib
cups/libcups.dylib
cups/libcups.so
cups/libcups.so.2
cups/locale/
cups/test.pwg
cups/testadmin
@@ -49,6 +52,7 @@ cups/testcreds
cups/testcups
cups/testdest
cups/testfile
cups/testgetdests
cups/testhttp
cups/testi18n
cups/testipp
@@ -63,6 +67,10 @@ doc/index.html
doc/*/index.html
filter/commandtops
filter/gziptoany
filter/libcupsimage.2.dylib
filter/libcupsimage.dylib
filter/libcupsimage.so
filter/libcupsimage.so.2
filter/pstops
filter/rasterbench
filter/rastertoepson
@@ -70,6 +78,7 @@ filter/rastertohp
filter/rastertolabel
filter/rastertopwg
filter/test.raster
filter/testclient
filter/testraster
locale/checkpo
locale/po2strings
@@ -151,6 +160,8 @@ test/ippserver
test/ippserver-shared
test/ipptool
test/ipptool-static
vcnet/.vs
vcnet/packages
vcnet/x64
xcode/CUPS.xcodeproj/project.xcworkspace/
xcode/CUPS.xcodeproj/xcuserdata/
+229 -9
Ver Arquivo
@@ -1,7 +1,227 @@
CHANGES - 2.2.4 - 2017-06-30
CHANGES - 2.2.9 - 2018-11-09
============================
CHANGES IN CUPS V2.2.4
Changes in CUPS v2.2.9
----------------------
- Localization changes (Issue #5348, Issue #5362, Issue #5408)
- Documentation updates (Issue #5369)
- The lpadmin command would create a non-working printer in some error cases
(Issue #5305)
- The scheduler would crash if an empty `AccessLog` directive was specified
(Issue #5309)
- Fixed a regression in the changes to ippValidateAttribute (Issue #5322,
Issue #5330)
- Fixed a crash bug in the Epson dot matrix driver (Issue #5323)
- Automatic debug logging of job errors did not work with systemd (Issue #5337)
- The web interface did not list the IPP Everywhere "driver" (Issue #5338)
- The IPP Everywhere "driver" now properly supports face-up printers
(Issue #5345)
- Fixed some typos in the label printer drivers (Issue #5350)
- Multi-file jobs could get stuck if the backend failed (Issue #5359,
Issue #5413)
- The IPP Everywhere "driver" no longer does local filtering when printing to
a shared CUPS printer (Issue #5361)
- The lpadmin command now correctly reports IPP errors when configuring an
IPP Everywhere printer (Issue #5370)
- Fixed some memory leaks discovered by Coverity (Issue #5375)
- The PPD compiler incorrectly terminated JCL options (Issue #5379)
- The cupstestppd utility did not generate errors for missing/mismatched
CloseUI/JCLCloseUI keywords (Issue #5381)
- The scheduler now reports the actual location of the log file (Issue #5398)
- Added a USB quirk rule (Issue #5420)
- The scheduler was being backgrounded on macOS, causing applications to spin
(rdar://40436080)
- The scheduler did not validate that required initial request attributes were
in the operation group (rdar://41098178)
- Authentication in the web interface did not work on macOS (rdar://41444473)
- Fixed an issue with HTTP Digest authentication (rdar://41709086)
- The scheduler could crash when job history was purged (rdar://42198057)
- Dropped non-working RSS subscriptions UI from web interface templates.
- Fixed a memory leak for some IPP (extension) syntaxes.
Changes in CUPS v2.2.8
----------------------
- Additional changes for the scheduler to substitute default values for invalid
job attributes when running in "relaxed conformance" mode (Issue #5229)
- The `ipptool` program no longer checks for duplicate attributes when running
in list or CSV mode (Issue #5278)
- Fixed builds without PAM (Issue #5283)
- Fixed `lpoptions` man page (Issue #5286)
- The `cupsCreateJob`, `cupsPrintFile2`, and `cupsPrintFiles2` APIs did not use
the supplied HTTP connection (Issue #5288)
- Fixed another crash in the scheduler when adding an IPP Everywhere printer
(Issue #5290)
- Added a workaround for certain web browsers that do not support multiple
authentication schemes in a single response header (Issue #5289)
- Fixed policy limits containing the `All` operation (Issue #5296)
- The scheduler was always restarted after idle-exit with systemd (Issue #5297)
- Added a USB quirks rule for the HP LaserJet P1102 (Issue #5310)
- The mailto notifier did not wait for the welcome message (Issue #5312)
- Fixed a parsing bug in the pstops filter (Issue #5321)
- Documentation updates (Issue #5299, Issue #5301, Issue #5306)
- Localization updates (Issue #5317)
- The scheduler allowed environment variables to be specified in the
`cupsd.conf` file (rdar://37836779, rdar://37836995, rdar://37837252,
rdar://37837581)
- Fax queues did not support pause (p) or wait-for-dialtone (w) characters
(rdar://39212256)
- The scheduler did not validate notify-recipient-uri values properly
(rdar://40068936)
- The IPP parser allowed invalid group tags (rdar://40442124)
- Fixed a parsing bug in the new authentication code.
Changes in CUPS v2.2.7
----------------------
- NOTICE: Raw print queues are now deprecated (Issue #5269)
- Fixed an Avahi crash bug in the scheduler (Issue #5268)
- The IPP Everywhere PPD generator did not include the `cupsJobPassword`
keyword, when supported (Issue #5265)
- Systemd did not restart cupsd when configuration changes were made that
required a restart (Issue #5263)
- The Lexmark Optra E310 printer needs the "no-reattach" USB quirk rule
(Issue #5259)
- The scheduler could crash while adding an IPP Everywhere printer (Issue #5258)
- Label printers supported by the rastertolabel driver don't support SNMP, so
don't delay printing to test it (Issue #5256)
- Fixed a compile issue when PAM is not available (Issue #5253)
- Documentation fixes (Issue #5252)
- Star Micronics printers need the "unidir" USB quirk rule (Issue #5251)
- The scheduler now supports using temporary print queues for older IPP/1.1
print queues like those shared by CUPS 1.3 and earlier (Issue #5241)
- Fixed printing to some IPP Everywhere printers (Issue #5238)
- Kerberized printing to another CUPS server did not work correctly
(Issue #5233)
- The `cupsRasterWritePixels` function did not correctly swap bytes for some
formats (Issue #5225)
- Added a USB quirk rule for Canon MP280 series printers (Issue #5221)
- The `ppdInstallableConflict` tested too many constraints (Issue #5213)
- More fixes for printing to old CUPS servers (Issue #5211)
- The `cupsCopyDest` function now correctly copies the `is_default` value
(Issue #5208)
- The scheduler did not work with older versions of uClibc (Issue #5188)
- The scheduler now substitutes default values for invalid job attributes when
running in "relaxed conformance" mode (Issue #5186)
- Fixed PAM module detection and added support for the common PAM definitions
(Issue #5185)
- Fixed a journald support bug in the scheduler (Issue #5181)
- The cups-driverd program incorrectly stopped scanning PPDs as soon as a loop
was seen (Issue #5170)
- Fixed group validation on OpenBSD (Issue #5166)
- Fixed the `ippserver` sample code when threading is disabled or unavailable
(Issue #5154)
- The `cupsEnumDests` function did not include options from the lpoptions files
(Issue #5144)
- The `SSLOptions` directive now supports `MinTLS` and `MaxTLS` options to
control the minimum and maximum TLS versions that will be allowed,
respectively (Issue #5119)
- The scheduler did not write out dirty configuration and state files if there
were open client connections (Issue #5118)
- The `lpadmin` command now provides a better error message when an unsupported
System V interface script is used (Issue #5111)
- The `lp` and `lpr` commands now provide better error messages when the default
printer cannot be found (Issue #5096)
- No longer support backslash, question mark, or quotes in printer names
(Issue #4966)
- The CUPS library now supports the latest HTTP Digest authentication
specification including support for SHA-256 (Issue #4862)
- The `lpstat` command now reports when new jobs are being held (Issue #4761)
- The `lpoptions` command incorrectly saved default options (Issue #4717)
- The `ppdLocalizeIPPReason` function incorrectly returned a localized version
of "none" (rdar://36566269)
- TLS connections now properly timeout (rdar://34938533)
- The IPP backend did not properly detect failed PDF prints (rdar://34055474)
- Temporary files are now placed in the correct directory for sandboxed
applications on macOS (rdar://problem/37789645)
Changes in CUPS v2.2.6
----------------------
- DBUS notifications could crash the scheduler (Issue #5143)
- Added USB quirks rules for Canon MP540 and Samsung ML-2160 (Issue #5148)
- Fixed TLS cipher suite selection with GNU TLS (Issue #5145, Issue #5150)
- Localization updates (Issue #5152)
Changes in CUPS v2.2.5
----------------------
- The scheduler's `-t` option did not force all errors to the standard error
file, making debugging of configuration problems hard (Issue #5041)
- Fixed a typo in the CUPS Programming Manual (Issue #5042)
- Fixed RPM packaging issue (Issue #5043, Issue #5044)
- The `cupsGetDests` function incorrectly returned an empty list of printers if
there was no default printer (Issue #5046)
- The `cupsGetDests` function waited too long for network printers (Issue #5049)
- Libtool support was completely broken with current libtool versions that use
an incompatible command-line syntax (Issue #5050)
- Fixed a build issue with `--enable-mallinfo` (Issue #5051)
- The ippserver test program contained a deadlock issue (Issue #5054)
- The `cupsLocalizeDest*` functions did not provide base localizations for
all registered IPP attributes and values (Issue #5056)
- The --enable-libtool configure option requires a path to the libtool program,
but doesn't document or check for it (Issue #5062)
- Fixed the `SSLOptions DenyCBC` option when using GNU TLS (Issue #5065)
- Fixed the `ServerTokens None` option (Issue #5065)
- Fixed the default `ServerAlias` value from `ServerName` (Issue #5072)
- Fixed the adminurl field in the TXT record for fully-qualified `ServerName`
values (Issue #5074)
- The scheduler now creates a PID file when not running on demand with a modern
service launcher (Issue #5080)
- The web interface did not support newer language identifiers used by Microsoft
web browsers (Issue #5803)
- Updated the cups-files.conf and cupsd.conf file documentation for missing
directives (Issue #5084)
- Fixed an Avahi-related crash bug in the scheduler (Issue #5085, Issue #5086)
- Fixed the interactions between the "print-quality" and "cupsPrintQuality"
options (Issue #5090)
- The IPP Everywhere PPD generator now sorts the supported resolutions before
choosing them for draft, normal, and best quality modes (Issue #5091)
- Fixed the localization unit test on Linux (Issue #5097)
- The CUPS library did not reuse domain sockets (Issue #5098)
- Fixed the "make check" target for some environments (Issue #5099)
- The scheduler woke up once per second to remove old temporary queues
(Issue #5100)
- Added USB quirk rule for Kyocera printer (Issue #5102, Issue #5103)
- Re-documented the limits of `file:///...` device URIs and moved the FileDevice
directive in `cups-files.conf` to the list of deprecated configuration
directives (Issue #5117)
- Added USB quirk rule for HP LaserJet 1160 printer (Issue #5121)
- Fixed the script interpreter detection in the configure script (Issue #5122)
- The network backends now retry on more error conditions (Issue #5123)
- Added a French translation of the web interface (Issue #5134)
- `cupsGetDests2` was not using the supplied HTTP connection (Issue #5135)
- `httpAddrConnect` leaked sockets in certain circumstances, causing some
printers to hang (rdar://31965686)
- Fixed an issue with Chinese localizations on macOS (rdar://32419311)
- The IPP backend now always sends the "finishings" attribute for printers that
support it because otherwise the client cannot override printer defaults
(rdar://33169732)
- The `cupsGetNamedDest` function did not use the local default printer
(rdar://33228500)
- The IPP backend incorrectly sent the "job-pages-per-set" attribute to PDF
printers (rdar://33250434)
- Fixed the `cups.strings` file that is used on macOS (rdar://33287650)
- CUPS now sends the `Date` HTTP header in IPP requests (rdar://33302034)
- The `ippCopyAttribute` function did not copy out-of-band values correctly
(rdar://33688003)
- Fixed the localization fallback code on macOS (rdar://33583699)
- The scheduler did not run with a high enough priority, causing problems on
busy systems (rdar://33789342)
- Added support for Japanese Kaku 1 envelope size (rdar://34774110)
- The `ipptool` program's `-P` option did not work correctly.
- The `ipptool` program did not compare URI scheme or hostname components
correctly for the WITH-ALL-HOSTNAMES, WITH-ALL-SCHEMES, WITH-HOSTNAME, or
WITH-SCHEME predicates.
Changes in CUPS v2.2.4
----------------------
- The scheduler did not remove old job files (Issue #4987)
@@ -39,7 +259,7 @@ CHANGES IN CUPS V2.2.4
`DenyCBC` and `DenyTLS1.0` options (Issue #5037)
CHANGES IN CUPS V2.2.3
Changes in CUPS v2.2.3
----------------------
- The IPP backend could get into an infinite loop for certain errors, causing a
@@ -67,7 +287,7 @@ CHANGES IN CUPS V2.2.3
- Fixed some localization issues on macOS (<rdar://problem/27245567>)
CHANGES IN CUPS V2.2.2
Changes in CUPS v2.2.2
----------------------
- Fixed some issues with the Zebra ZPL printer driver (Issue #4898)
@@ -97,7 +317,7 @@ CHANGES IN CUPS V2.2.2
- Updated packaging files (Issue #4940)
CHANGES IN CUPS V2.2.1
Changes in CUPS v2.2.1
----------------------
- Added "CreateSelfSignedCerts" directive for cups-files.conf to control whether
@@ -111,7 +331,7 @@ CHANGES IN CUPS V2.2.1
- Updated localizations (PR #4877, PR #4886)
CHANGES IN CUPS V2.2.0
Changes in CUPS v2.2.0
----------------------
- Normalized the TLS certificate validation code and added additional error
@@ -122,7 +342,7 @@ CHANGES IN CUPS V2.2.0
- http*Connect did not return early when all addresses failed (Issue #4870)
CHANGES IN CUPS V2.2rc1
Changes in CUPS v2.2rc1
-----------------------
- Updated the list of supported IPP Everywhere media types.
@@ -135,14 +355,14 @@ CHANGES IN CUPS V2.2rc1
- Updated localizations (Issue #4846, PR #4858)
CHANGES IN CUPS V2.2b2
Changes in CUPS v2.2b2
----------------------
- Added Upstart support (PR #4825)
- CUPS now supports Let's Encrypt certificates on Linux.
CHANGES IN CUPS V2.2b1
Changes in CUPS v2.2b1
----------------------
- All CUPS commands now support POSIX options (Issue #4813)
+34 -22
Ver Arquivo
@@ -1,14 +1,28 @@
INSTALL - CUPS v2.2.4 - 2017-06-30
INSTALL - CUPS v2.2.9 - 2018-11-08
==================================
This file describes how to compile and install CUPS from source code. For more
information on CUPS see the file called "README.txt". A complete change log can
be found in "CHANGES.txt".
information on CUPS see the file called "README.md". A complete change log can
be found in "CHANGES.md".
> USING CUPS REQUIRES ADDITIONAL THIRD-PARTY SUPPORT SOFTWARE AND PRINTER
> DRIVERS. THESE ARE TYPICALLY INCLUDED WITH YOUR OPERATING SYSTEM
> DISTRIBUTION. APPLE DOES NOT ENDORSE OR SUPPORT THIRD-PARTY SUPPORT SOFTWARE
> FOR CUPS.
Using CUPS requires additional third-party support software and printer drivers.
These are typically included with your operating system distribution. Apple
does not endorse or support third-party support software for CUPS.
> Note: Current versions of macOS DO NOT allow installation to /usr with the
> default System Integrity Protection (SIP) settings. In addition, we do not
> recommend replacing the CUPS supplied with macOS because:
>
> a. not all versions of CUPS are compatible with every macOS release,
>
> b. code signing prevents replacement of system libraries and access to the
> system keychain (needed for encrypted printer sharing), and
>
> c. software updates will often replace parts of your local installation,
> potentially rendering your system unusable.
>
> Apple only supports using the compiler supplied with Xcode to build CUPS on
> macOS.
BEFORE YOU BEGIN
@@ -52,12 +66,15 @@ main CUPS source directory. To configure CUPS for your system, type:
The default installation will put the CUPS software in the "/etc", "/usr", and
"/var" directories on your system, which will overwrite any existing printing
commands on your system. Use the "--prefix" option to install the CUPS software
commands on your system. Use the `--prefix` option to install the CUPS software
in another location:
./configure --prefix=/some/directory
To see a complete list of configuration options, use the --help option:
> Note: Current versions of macOS DO NOT allow installation to /usr with the
> default System Integrity Protection (SIP) settings.
To see a complete list of configuration options, use the `--help` option:
./configure --help
@@ -82,26 +99,20 @@ or:
LDFLAGS="-L/some/directory" \
./configure ...
The "--enable-debug" option compiles CUPS with debugging information enabled.
The `--enable-debug` option compiles CUPS with debugging information enabled.
Additional debug logging support can be enabled using the
"--enable-debug-printfs" option - these debug messages are enabled using the
CUPS_DEBUG_LOG environment variable at run-time.
`--enable-debug-printfs` option - these debug messages are enabled using the
`CUPS_DEBUG_xxx` environment variables at run-time.
CUPS also includes an extensive set of unit tests that can be used to find and
diagnose a variety of common problems - use the "--enable-unit-tests" configure
option to run them at build time.
On macOS, use the "--with-archflags" option to build with the correct set of
On macOS, use the `--with-archflags` option to build with the correct set of
architectures:
./configure --with-archflags="-arch i386 -arch x86_64" ...
> Note: Current versions of macOS DO NOT allow installation to /usr with the
> default system integrity settings. In addition, we do not recommend replacing
> the CUPS supplied with macOS because not all versions of CUPS are compatible
> with every macOS release, and because software updates will replace parts
> of your local installation potentially rendering your system unusable.
Once you have configured things, just type:
make ENTER
@@ -184,7 +195,7 @@ for FreeBSD, NetBSD, and OpenBSD. The <format> target is one of the following:
GETTING DEBUG LOGGING FROM CUPS
-------------------------------
When configured with the "--enable-debug-printfs" option, CUPS compiles in
When configured with the `--enable-debug-printfs` option, CUPS compiles in
additional debug logging support in the scheduler, CUPS API, and CUPS Imaging
API. The following environment variables are used to enable and control debug
logging:
@@ -195,13 +206,14 @@ logging:
the logging. The default level is 1.
- `CUPS_DEBUG_LOG`: Specifies a log file to use. Specify the name "-" to send
the messages to stderr. Prefix a filename with "+" to append to an existing
file.
file. You can include a single "%d" in the filename to embed the current
process ID.
REPORTING PROBLEMS
------------------
If you have problems, READ THE DOCUMENTATION FIRST! If the documentation does
If you have problems, *read the documentation first*! If the documentation does
not solve your problems, please post a message on the users forum at:
https://www.cups.org/
+22 -8
Ver Arquivo
@@ -1,7 +1,7 @@
#
# Common makefile definitions for CUPS.
#
# Copyright 2007-2017 by Apple Inc.
# Copyright 2007-2018 by Apple Inc.
# Copyright 1997-2007 by Easy Software Products, all rights reserved.
#
# These coded instructions, statements, and computer programs are the
@@ -11,22 +11,32 @@
# missing or damaged, see the license at "http://www.cups.org/".
#
#
# CUPS version...
#
CUPS_VERSION = @CUPS_VERSION@
#
# Programs...
#
AR = @AR@
AWK = @AWK@
CC = @LIBTOOL@ @CC@
CC = @LIBTOOL_CC@ @CC@
CHMOD = @CHMOD@
CXX = @LIBTOOL@ @CXX@
CXX = @LIBTOOL_CXX@ @CXX@
DSO = @DSO@
DSOXX = @DSOXX@
GZIP = @GZIP@
INSTALL = @INSTALL@
LD = @LD@
LD_CC = @LD_CC@
LD_CXX = @LD_CXX@
LIBTOOL = @LIBTOOL@
LN = @LN@ -sf
MKDIR = @MKDIR@ -p
MV = @MV@
RANLIB = @RANLIB@
RM = @RM@ -f
@@ -38,12 +48,12 @@ SHELL = /bin/sh
# Installation programs...
#
INSTALL_BIN = $(LIBTOOL) $(INSTALL) -c -m @CUPS_EXE_FILE_PERM@ @INSTALL_STRIP@
INSTALL_BIN = @LIBTOOL_INSTALL@ $(INSTALL) -c -m @CUPS_EXE_FILE_PERM@ @INSTALL_STRIP@
INSTALL_COMPDATA = $(INSTALL) -c -m 444 @INSTALL_GZIP@
INSTALL_CONFIG = $(INSTALL) -c -m @CUPS_CONFIG_FILE_PERM@
INSTALL_DATA = $(INSTALL) -c -m 444
INSTALL_DIR = $(INSTALL) -d
INSTALL_LIB = $(LIBTOOL) $(INSTALL) -c -m @CUPS_EXE_FILE_PERM@ @INSTALL_STRIP@
INSTALL_LIB = @LIBTOOL_INSTALL@ $(INSTALL) -c -m @CUPS_EXE_FILE_PERM@ @INSTALL_STRIP@
INSTALL_MAN = $(INSTALL) -c -m 444
INSTALL_SCRIPT = $(INSTALL) -c -m @CUPS_EXE_FILE_PERM@
@@ -85,10 +95,7 @@ LOCALTARGET = @LOCALTARGET@
#
LIBCUPS = @LIBCUPS@
LIBCUPSCGI = @LIBCUPSCGI@
LIBCUPSIMAGE = @LIBCUPSIMAGE@
LIBCUPSMIME = @LIBCUPSMIME@
LIBCUPSPPDC = @LIBCUPSPPDC@
LIBCUPSSTATIC = @LIBCUPSSTATIC@
LIBGSSAPI = @LIBGSSAPI@
LIBMALLOC = @LIBMALLOC@
@@ -116,6 +123,13 @@ IPPALIASES = @IPPALIASES@
INSTALLXPC = @INSTALLXPC@
#
# Code signing...
#
CODE_SIGN = @CODE_SIGN@
CODE_SIGN_IDENTITY = -
#
# Program options...
#
+1 -27
Ver Arquivo
@@ -1,7 +1,7 @@
#
# Top-level Makefile for CUPS.
#
# Copyright 2007-2016 by Apple Inc.
# Copyright 2007-2018 by Apple Inc.
# Copyright 1997-2007 by Easy Software Products, all rights reserved.
#
# These coded instructions, statements, and computer programs are the
@@ -272,32 +272,6 @@ apihelp:
done
#
# Create an Xcode docset using Mini-XML's mxmldoc (http://www.msweet.org/)...
#
docset: apihelp
echo Generating docset directory tree...
$(RM) -r org.cups.docset
mkdir -p org.cups.docset/Contents/Resources/Documentation/help
mkdir -p org.cups.docset/Contents/Resources/Documentation/images
cd man; $(MAKE) $(MFLAGS) html
cd doc; $(MAKE) $(MFLAGS) docset
cd cgi-bin; $(MAKE) $(MFLAGS) makedocset
cgi-bin/makedocset org.cups.docset \
`svnversion . | sed -e '1,$$s/[a-zA-Z]//g'` \
doc/help/api-*.tokens
$(RM) doc/help/api-*.tokens
echo Indexing docset...
/Applications/Xcode.app/Contents/Developer/usr/bin/docsetutil index org.cups.docset
echo Generating docset archive and feed...
$(RM) org.cups.docset.atom
/Applications/Xcode.app/Contents/Developer/usr/bin/docsetutil package --output org.cups.docset.xar \
--atom org.cups.docset.atom \
--download-url http://www.cups.org/org.cups.docset.xar \
org.cups.docset
#
# Lines of code computation...
#
+33 -33
Ver Arquivo
@@ -1,7 +1,7 @@
README - CUPS v2.2.4 - 2017-06-30
README - CUPS v2.2.9 - 2018-11-08
=================================
Looking for compile instructions? Read the file "INSTALL.md" instead...
Looking for compile instructions? Read the file `INSTALL.md` instead...
INTRODUCTION
@@ -30,12 +30,10 @@ READING THE DOCUMENTATION
-------------------------
Once you have installed the software you can access the documentation (and a
bunch of other stuff) online at:
http://localhost:631/
bunch of other stuff) online at <http://localhost:631/>.
If you're having trouble getting that far, the documentation is located under
the "doc/help" directory.
the `doc/help` and `man` directories.
Please read the documentation before asking questions.
@@ -43,10 +41,8 @@ Please read the documentation before asking questions.
GETTING SUPPORT AND OTHER RESOURCES
-----------------------------------
If you have problems, READ THE DOCUMENTATION FIRST! We also provide two mailing
lists which are available at:
https://lists.cups.org/mailman/listinfo
If you have problems, *read the documentation first!* We also provide two
mailing lists which are available at <https://lists.cups.org/mailman/listinfo>.
See the CUPS web site at <https://www.cups.org/> for other resources.
@@ -55,14 +51,12 @@ SETTING UP PRINTER QUEUES USING YOUR WEB BROWSER
------------------------------------------------
CUPS includes a web-based administration tool that allows you to manage
printers, classes, and jobs on your server. Open the following URL in your
browser to access the printer administration tools:
http://localhost:631/admin/
printers, classes, and jobs on your server. Open <http://localhost:631/admin/>
in your browser to access the printer administration tools:
*Do not* use the hostname for your machine - it will not work with the default
CUPS configuration. To enable administration access on other addresses, check
the "Allow Remote Administration" box and click on the "Change Settings" button.
the `Allow Remote Administration` box and click on the `Change Settings button.
You will be asked for the administration password (root or any other user in the
sys/system/root/admin/lpadmin group on your system) when performing any
@@ -72,10 +66,15 @@ administrative function.
SETTING UP PRINTER QUEUES FROM THE COMMAND-LINE
-----------------------------------------------
CUPS works best with PPD (PostScript Printer Description) files. In a pinch you
can also use System V style printer interface scripts.
CUPS currently uses PPD (PostScript Printer Description) files that describe
printer capabilities and driver programs needed for each printer. The
`everywhere` PPD is used for nearly all modern networks printers sold since
about 2009. For example, the following command creates a print queue for a
printer at address 11.22.33.44:
CUPS includes several sample PPD files you can use:
lpadmin -p printername -E -v ipp://11.22.33.44/ipp/print -m everywhere
CUPS also includes several sample PPD files you can use for "legacy" printers:
Driver PPD Name
----------------------------- ------------------------------
@@ -94,41 +93,42 @@ CUPS includes several sample PPD files you can use:
Zebra EPL2 Label Printer drv:///sample.drv/zebraep2.ppd
Zebra ZPL Label Printer drv:///sample.drv/zebra.ppd
Run the "lpinfo -m" command to list the available drivers:
You can run the `lpinfo -m` command to list all of the available drivers:
lpinfo -m
Run the "lpinfo -v" command to list the available printers:
Run the `lpinfo -v` command to list the available printers:
lpinfo -v
Then use the correct URI to add the printer using the "lpadmin" command:
Then use the correct URI to add the printer using the `lpadmin` command:
lpadmin -p printername -E -v device-uri -m ppd-name
Network printers typically use "socket" or "lpd" URIs:
Current network printers typically use `ipp` or `ipps` URIS:
lpadmin -p printername -E -v ipp://11.22.33.44/ipp/print -m everywhere
lpadmin -p printername -E -v ipps://11.22.33.44/ipp/print -m everywhere
Older network printers typically use `socket` or `lpd` URIs:
lpadmin -p printername -E -v socket://11.22.33.44 -m ppd-name
lpadmin -p printername -E -v lpd://11.22.33.44/ -m ppd-name
The sample drivers provide basic printing capabilities, but generally do not
exercise the full potential of the printers or CUPS.
CUPS also supports IPP Everywhere printers using the "everywhere" model, for
example:
lpadmin -p printername -E -v ipp://11.22.33.44/ipp/print -m everywhere
exercise the full potential of the printers or CUPS. Other drivers provide
greater printing capabilities.
PRINTING FILES
--------------
CUPS provides both the System V "lp" and Berkeley "lpr" commands for printing:
CUPS provides both the System V `lp` and Berkeley `lpr` commands for printing:
lp filename
lpr filename
Both the "lp" and "lpr" commands support printing options for the driver:
Both the `lp` and `lpr` commands support printing options for the driver:
lp -o media=A4 -o resolution=600dpi filename
lpr -o media=A4 -o resolution=600dpi filename
@@ -137,7 +137,7 @@ CUPS recognizes many types of images files as well as PDF, PostScript, and text
files, so you can print those files directly rather than through an application.
If you have an application that generates output specifically for your printer
then you need to use the "-oraw" or "-l" options:
then you need to use the `-oraw` or `-l` options:
lp -o raw filename
lpr -l filename
@@ -148,7 +148,7 @@ This will prevent the filters from misinterpreting your print file.
LEGAL STUFF
-----------
CUPS is copyright © 2007-2017 by Apple Inc. CUPS and the CUPS logo are
CUPS is copyright © 2007-2018 by Apple Inc. CUPS and the CUPS logo are
trademarks of Apple Inc.
The MD5 Digest code is Copyright 1999 Aladdin Enterprises.
@@ -157,4 +157,4 @@ CUPS is provided under the terms of version 2 of the GNU General Public License
and GNU Library General Public License. This program is distributed in the hope
that it will be useful, but WITHOUT ANY WARRANTY; without even the implied
warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
"doc/help/license.html" or "LICENSE.txt" files for more information.
`doc/help/license.html` or `LICENSE.txt` files for more information.
+19 -12
Ver Arquivo
@@ -1,7 +1,7 @@
#
# Backend makefile for CUPS.
#
# Copyright 2007-2016 by Apple Inc.
# Copyright 2007-2017 by Apple Inc.
# Copyright 1997-2007 by Easy Software Products, all rights reserved.
#
# These coded instructions, statements, and computer programs are the
@@ -24,7 +24,7 @@ include ../Makedefs
# UBACKENDS and ULBACKENDS are installed mode 0755 so cupsd will run them as
# an unprivileged user...
#
# See http://www.cups.org/documentation.php/api-filter.html for more info...
# See http://www.cups.org/doc/api-filter.html for more info...
RBACKENDS = \
ipp \
lpd \
@@ -207,7 +207,7 @@ uninstall:
test1284: test1284.o ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o test1284 test1284.o ../cups/$(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o test1284 test1284.o ../cups/$(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
@@ -217,7 +217,7 @@ test1284: test1284.o ../cups/$(LIBCUPSSTATIC)
testbackend: testbackend.o ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o testbackend testbackend.o ../cups/$(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o testbackend testbackend.o ../cups/$(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
@@ -227,7 +227,7 @@ testbackend: testbackend.o ../cups/$(LIBCUPSSTATIC)
testsupplies: testsupplies.o libbackend.a ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o testsupplies testsupplies.o libbackend.a \
$(LD_CC) $(LDFLAGS) -o testsupplies testsupplies.o libbackend.a \
../cups/$(LIBCUPSSTATIC) $(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) \
$(COMMONLIBS) $(LIBZ)
@@ -249,7 +249,8 @@ libbackend.a: $(LIBOBJS)
dnssd: dnssd.o ../cups/$(LIBCUPS) libbackend.a
echo Linking $@...
$(CC) $(LDFLAGS) -o dnssd dnssd.o libbackend.a $(LIBS)
$(LD_CC) $(LDFLAGS) -o dnssd dnssd.o libbackend.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
if test `uname` = Darwin; then \
$(RM) mdns; \
$(LN) dnssd mdns; \
@@ -262,7 +263,8 @@ dnssd: dnssd.o ../cups/$(LIBCUPS) libbackend.a
ipp: ipp.o ../cups/$(LIBCUPS) libbackend.a
echo Linking $@...
$(CC) $(LDFLAGS) -o ipp ipp.o libbackend.a $(LIBS)
$(LD_CC) $(LDFLAGS) -o ipp ipp.o libbackend.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
$(RM) http
$(LN) ipp http
@@ -273,7 +275,8 @@ ipp: ipp.o ../cups/$(LIBCUPS) libbackend.a
lpd: lpd.o ../cups/$(LIBCUPS) libbackend.a
echo Linking $@...
$(CC) $(LDFLAGS) -o lpd lpd.o libbackend.a $(LIBS)
$(LD_CC) $(LDFLAGS) -o lpd lpd.o libbackend.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -282,7 +285,8 @@ lpd: lpd.o ../cups/$(LIBCUPS) libbackend.a
snmp: snmp.o ../cups/$(LIBCUPS) libbackend.a
echo Linking $@...
$(CC) $(LDFLAGS) -o snmp snmp.o libbackend.a $(LIBS)
$(LD_CC) $(LDFLAGS) -o snmp snmp.o libbackend.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -291,13 +295,15 @@ snmp: snmp.o ../cups/$(LIBCUPS) libbackend.a
socket: socket.o ../cups/$(LIBCUPS) libbackend.a
echo Linking $@...
$(CC) $(LDFLAGS) -o socket socket.o libbackend.a $(LIBS)
$(LD_CC) $(LDFLAGS) -o socket socket.o libbackend.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
socket-static: socket.o ../cups/$(LIBCUPSSTATIC) libbackend.a
echo Linking $@...
$(CC) $(LDFLAGS) -o socket-static socket.o libbackend.a \
$(LD_CC) $(LDFLAGS) -o socket-static socket.o libbackend.a \
../cups/$(LIBCUPSSTATIC) $(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) \
$(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -306,8 +312,9 @@ socket-static: socket.o ../cups/$(LIBCUPSSTATIC) libbackend.a
usb: usb.o ../cups/$(LIBCUPS) libbackend.a
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o usb usb.o libbackend.a $(LIBUSB) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o usb usb.o libbackend.a $(LIBUSB) \
$(BACKLIBS) $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
usb.o: usb.c usb-darwin.c usb-libusb.c usb-unix.c
+14 -7
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* DNS-SD discovery backend for CUPS.
*
* Copyright 2008-2017 by Apple Inc.
* Copyright 2008-2018 by Apple Inc.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -94,7 +94,7 @@ static void browse_callback(DNSServiceRef sdRef,
const char *serviceName,
const char *regtype,
const char *replyDomain, void *context)
__attribute__((nonnull(1,5,6,7,8)));
_CUPS_NONNULL((1,5,6,7,8));
static void browse_local_callback(DNSServiceRef sdRef,
DNSServiceFlags flags,
uint32_t interfaceIndex,
@@ -103,7 +103,7 @@ static void browse_local_callback(DNSServiceRef sdRef,
const char *regtype,
const char *replyDomain,
void *context)
__attribute__((nonnull(1,5,6,7,8)));
_CUPS_NONNULL((1,5,6,7,8));
#endif /* HAVE_DNSSD */
#ifdef HAVE_AVAHI
static void browse_callback(AvahiServiceBrowser *browser,
@@ -121,12 +121,12 @@ static void client_callback(AvahiClient *client,
#endif /* HAVE_AVAHI */
static int compare_devices(cups_device_t *a, cups_device_t *b);
static void exec_backend(char **argv) __attribute__((noreturn));
static void exec_backend(char **argv) _CUPS_NORETURN;
static cups_device_t *get_device(cups_array_t *devices,
const char *serviceName,
const char *regtype,
const char *replyDomain)
__attribute__((nonnull(1,2,3,4)));
_CUPS_NONNULL((1,2,3,4));
#ifdef HAVE_DNSSD
static void query_callback(DNSServiceRef sdRef,
DNSServiceFlags flags,
@@ -136,7 +136,7 @@ static void query_callback(DNSServiceRef sdRef,
uint16_t rrclass, uint16_t rdlen,
const void *rdata, uint32_t ttl,
void *context)
__attribute__((nonnull(1,5,9,11)));
_CUPS_NONNULL((1,5,9,11));
#elif defined(HAVE_AVAHI)
static int poll_callback(struct pollfd *pollfds,
unsigned int num_pollfds, int timeout,
@@ -153,7 +153,7 @@ static void query_callback(AvahiRecordBrowser *browser,
#endif /* HAVE_DNSSD */
static void sigterm_handler(int sig);
static void unquote(char *dst, const char *src, size_t dstsize)
__attribute__((nonnull(1,2)));
_CUPS_NONNULL((1,2));
/*
@@ -1257,6 +1257,13 @@ query_callback(
strlcat(make_and_model, " ", sizeof(make_and_model));
strlcat(make_and_model, model, sizeof(make_and_model));
if (!_cups_strncasecmp(make_and_model, "EPSON EPSON ", 12))
_cups_strcpy(make_and_model, make_and_model + 6);
else if (!_cups_strncasecmp(make_and_model, "HP HP ", 6))
_cups_strcpy(make_and_model, make_and_model + 3);
else if (!_cups_strncasecmp(make_and_model, "Lexmark International Lexmark ", 30))
_cups_strcpy(make_and_model, make_and_model + 22);
device->make_and_model = strdup(make_and_model);
}
else
+166 -131
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* IPP backend for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -47,6 +47,8 @@ extern void xpc_connection_set_target_uid(xpc_connection_t connection,
#define _CUPS_JSR_ACCOUNT_LIMIT_REACHED 0x08
#define _CUPS_JSR_JOB_PASSWORD_WAIT 0x10
#define _CUPS_JSR_JOB_RELEASE_WAIT 0x20
#define _CUPS_JSR_DOCUMENT_FORMAT_ERROR 0x40
#define _CUPS_JSR_DOCUMENT_UNPRINTABLE 0x80
/*
@@ -69,6 +71,7 @@ typedef struct _cups_monitor_s /**** Monitoring data ****/
http_encryption_t encryption; /* Use encryption? */
ipp_jstate_t job_state; /* Current job state */
ipp_pstate_t printer_state; /* Current printer state */
int retryable; /* Is this a job that should be retried? */
} _cups_monitor_t;
@@ -357,8 +360,7 @@ main(int argc, /* I - Number of command-line args */
* that way.
*/
if (!getuid() && (value = getenv("AUTH_UID")) != NULL &&
!getenv("AUTH_PASSWORD"))
if (!getuid() && (value = getenv("AUTH_UID")) != NULL)
{
uid_t uid = (uid_t)atoi(value);
/* User ID */
@@ -392,7 +394,7 @@ main(int argc, /* I - Number of command-line args */
# else /* No XPC, just try to run as the user ID */
if (uid > 0)
seteuid(uid);
setuid(uid);
# endif /* HAVE_XPC */
}
#endif /* HAVE_GSSAPI */
@@ -424,9 +426,9 @@ main(int argc, /* I - Number of command-line args */
port = IPP_PORT; /* Default to port 631 */
if (!strcmp(scheme, "https") || !strcmp(scheme, "ipps"))
cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
cupsSetEncryption(HTTP_ENCRYPTION_ALWAYS);
else
cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
cupsSetEncryption(HTTP_ENCRYPTION_IF_REQUESTED);
/*
* See if there are any options...
@@ -513,13 +515,13 @@ main(int argc, /* I - Number of command-line args */
*/
if (!_cups_strcasecmp(value, "always"))
cupsSetEncryption(HTTP_ENCRYPT_ALWAYS);
cupsSetEncryption(HTTP_ENCRYPTION_ALWAYS);
else if (!_cups_strcasecmp(value, "required"))
cupsSetEncryption(HTTP_ENCRYPT_REQUIRED);
cupsSetEncryption(HTTP_ENCRYPTION_REQUIRED);
else if (!_cups_strcasecmp(value, "never"))
cupsSetEncryption(HTTP_ENCRYPT_NEVER);
cupsSetEncryption(HTTP_ENCRYPTION_NEVER);
else if (!_cups_strcasecmp(value, "ifrequested"))
cupsSetEncryption(HTTP_ENCRYPT_IF_REQUESTED);
cupsSetEncryption(HTTP_ENCRYPTION_IF_REQUESTED);
else
{
_cupsLangPrintFilter(stderr, "ERROR",
@@ -707,11 +709,11 @@ main(int argc, /* I - Number of command-line args */
fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
_cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
if (httpReconnect(http))
if (httpReconnect2(http, 30000, NULL))
{
int error = errno; /* Connection error */
if (http->status == HTTP_PKI_ERROR)
if (http->status == HTTP_STATUS_CUPS_PKI_ERROR)
update_reasons(NULL, "+cups-certificate-error");
if (job_canceled)
@@ -743,8 +745,7 @@ main(int argc, /* I - Number of command-line args */
fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(errno));
if (errno == ECONNREFUSED || errno == EHOSTDOWN ||
errno == EHOSTUNREACH)
if (errno == ECONNREFUSED || errno == EHOSTDOWN || errno == EHOSTUNREACH || errno == ETIMEDOUT || errno == ENOTCONN)
{
if (contimeout && (time(NULL) - start_time) > contimeout)
{
@@ -763,13 +764,13 @@ main(int argc, /* I - Number of command-line args */
break;
case EHOSTUNREACH :
default :
_cupsLangPrintFilter(stderr, "WARNING",
_("The printer is unreachable at this "
"time."));
break;
case ECONNREFUSED :
default :
_cupsLangPrintFilter(stderr, "WARNING",
_("The printer is in use."));
break;
@@ -915,7 +916,7 @@ main(int argc, /* I - Number of command-line args */
* Build the IPP request...
*/
request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
ippSetVersion(request, version / 10, version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
@@ -930,7 +931,7 @@ main(int argc, /* I - Number of command-line args */
fputs("DEBUG: Getting supported attributes...\n", stderr);
if (http->version < HTTP_1_1)
if (http->version < HTTP_VERSION_1_1)
{
fprintf(stderr, "DEBUG: Printer responded with HTTP version %d.%d.\n",
http->version / 100, http->version % 100);
@@ -944,15 +945,15 @@ main(int argc, /* I - Number of command-line args */
fprintf(stderr, "DEBUG: Get-Printer-Attributes: %s (%s)\n",
ippErrorString(ipp_status), cupsLastErrorString());
if (ipp_status <= IPP_OK_CONFLICT)
if (ipp_status <= IPP_STATUS_OK_CONFLICTING)
password_tries = 0;
else
{
fprintf(stderr, "DEBUG: Get-Printer-Attributes returned %s.\n",
ippErrorString(ipp_status));
if (ipp_status == IPP_PRINTER_BUSY ||
ipp_status == IPP_SERVICE_UNAVAILABLE)
if (ipp_status == IPP_STATUS_ERROR_BUSY ||
ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE)
{
if (contimeout && (time(NULL) - start_time) > contimeout)
{
@@ -969,8 +970,8 @@ main(int argc, /* I - Number of command-line args */
delay = _cupsNextDelay(delay, &prev_delay);
}
else if ((ipp_status == IPP_BAD_REQUEST ||
ipp_status == IPP_VERSION_NOT_SUPPORTED) && version > 10)
else if ((ipp_status == IPP_STATUS_ERROR_BAD_REQUEST ||
ipp_status == IPP_STATUS_ERROR_VERSION_NOT_SUPPORTED) && version > 10)
{
/*
* Switch to IPP/1.1 or IPP/1.0...
@@ -993,9 +994,9 @@ main(int argc, /* I - Number of command-line args */
version = 10;
}
httpReconnect(http);
httpReconnect2(http, 30000, NULL);
}
else if (ipp_status == IPP_NOT_FOUND)
else if (ipp_status == IPP_STATUS_ERROR_NOT_FOUND)
{
_cupsLangPrintFilter(stderr, "ERROR",
_("The printer configuration is incorrect or the "
@@ -1005,8 +1006,8 @@ main(int argc, /* I - Number of command-line args */
return (CUPS_BACKEND_STOP);
}
else if (ipp_status == IPP_FORBIDDEN ||
ipp_status == IPP_AUTHENTICATION_CANCELED)
else if (ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
{
const char *www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
/* WWW-Authenticate field value */
@@ -1019,13 +1020,13 @@ main(int argc, /* I - Number of command-line args */
fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
return (CUPS_BACKEND_AUTH_REQUIRED);
}
else if (ipp_status != IPP_NOT_AUTHORIZED)
else if (ipp_status != IPP_STATUS_ERROR_NOT_AUTHORIZED)
{
_cupsLangPrintFilter(stderr, "ERROR",
_("Unable to get printer status."));
sleep(10);
httpReconnect(http);
httpReconnect2(http, 30000, NULL);
}
ippDelete(supported);
@@ -1139,7 +1140,14 @@ main(int argc, /* I - Number of command-line args */
copies_sup = NULL; /* No */
}
cups_version = ippFindAttribute(supported, "cups-version", IPP_TAG_TEXT);
if ((cups_version = ippFindAttribute(supported, "cups-version", IPP_TAG_TEXT)) != NULL)
{
const char *version = ippGetString(cups_version, 0, NULL);
fprintf(stderr, "DEBUG: cups-version = \"%s\"\n", version);
if (!strcmp(version, "cups-version"))
cups_version = NULL; /* Bogus cups-version value returned by buggy printers! */
}
encryption_sup = ippFindAttribute(supported, "job-password-encryption-supported", IPP_TAG_KEYWORD);
@@ -1175,7 +1183,7 @@ main(int argc, /* I - Number of command-line args */
ippOpString(operations_sup->values[i].integer));
for (i = 0; i < operations_sup->num_values; i ++)
if (operations_sup->values[i].integer == IPP_PRINT_JOB)
if (operations_sup->values[i].integer == IPP_OP_PRINT_JOB)
break;
if (i >= operations_sup->num_values)
@@ -1183,7 +1191,7 @@ main(int argc, /* I - Number of command-line args */
"cups-ipp-missing-print-job");
for (i = 0; i < operations_sup->num_values; i ++)
if (operations_sup->values[i].integer == IPP_CANCEL_JOB)
if (operations_sup->values[i].integer == IPP_OP_CANCEL_JOB)
break;
if (i >= operations_sup->num_values)
@@ -1191,7 +1199,7 @@ main(int argc, /* I - Number of command-line args */
"cups-ipp-missing-cancel-job");
for (i = 0; i < operations_sup->num_values; i ++)
if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
if (operations_sup->values[i].integer == IPP_OP_GET_JOB_ATTRIBUTES)
break;
if (i >= operations_sup->num_values)
@@ -1199,7 +1207,7 @@ main(int argc, /* I - Number of command-line args */
"cups-ipp-missing-get-job-attributes");
for (i = 0; i < operations_sup->num_values; i ++)
if (operations_sup->values[i].integer == IPP_GET_PRINTER_ATTRIBUTES)
if (operations_sup->values[i].integer == IPP_OP_GET_PRINTER_ATTRIBUTES)
break;
if (i >= operations_sup->num_values)
@@ -1208,13 +1216,13 @@ main(int argc, /* I - Number of command-line args */
for (i = 0; i < operations_sup->num_values; i ++)
{
if (operations_sup->values[i].integer == IPP_VALIDATE_JOB)
if (operations_sup->values[i].integer == IPP_OP_VALIDATE_JOB)
validate_job = 1;
else if (operations_sup->values[i].integer == IPP_CREATE_JOB)
else if (operations_sup->values[i].integer == IPP_OP_CREATE_JOB)
create_job = 1;
else if (operations_sup->values[i].integer == IPP_SEND_DOCUMENT)
else if (operations_sup->values[i].integer == IPP_OP_SEND_DOCUMENT)
send_document = 1;
else if (operations_sup->values[i].integer == IPP_GET_JOB_ATTRIBUTES)
else if (operations_sup->values[i].integer == IPP_OP_GET_JOB_ATTRIBUTES)
get_job_attrs = 1;
}
@@ -1242,7 +1250,7 @@ main(int argc, /* I - Number of command-line args */
report_printer_state(supported);
}
while (!job_canceled && ipp_status > IPP_OK_CONFLICT);
while (!job_canceled && ipp_status > IPP_STATUS_OK_CONFLICTING);
if (job_canceled)
return (CUPS_BACKEND_OK);
@@ -1260,7 +1268,7 @@ main(int argc, /* I - Number of command-line args */
IPP_TAG_BOOLEAN);
if (printer_state == NULL ||
(printer_state->values[0].integer > IPP_PRINTER_PROCESSING &&
(printer_state->values[0].integer > IPP_PSTATE_PROCESSING &&
waitprinter) ||
printer_accepting == NULL ||
!printer_accepting->values[0].boolean)
@@ -1386,7 +1394,7 @@ main(int argc, /* I - Number of command-line args */
* (I hate compatibility hacks!)
*/
if (http->version < HTTP_1_1 && num_files == 0)
if (http->version < HTTP_VERSION_1_1 && num_files == 0)
{
if ((fd = cupsTempFd(tmpfilename, sizeof(tmpfilename))) < 0)
{
@@ -1414,7 +1422,7 @@ main(int argc, /* I - Number of command-line args */
files = &compatfile;
num_files = 1;
}
else if (http->version < HTTP_1_1 && num_files == 1)
else if (http->version < HTTP_VERSION_1_1 && num_files == 1)
{
struct stat fileinfo; /* File information */
@@ -1447,8 +1455,9 @@ main(int argc, /* I - Number of command-line args */
monitor.create_job = create_job;
monitor.get_job_attrs = get_job_attrs;
monitor.encryption = cupsEncryption();
monitor.job_state = IPP_JOB_PENDING;
monitor.printer_state = IPP_PRINTER_IDLE;
monitor.job_state = IPP_JSTATE_PENDING;
monitor.printer_state = IPP_PSTATE_IDLE;
monitor.retryable = argc == 6 && document_format && strcmp(document_format, "image/pwg-raster") && strcmp(document_format, "image/urf");
if (create_job)
{
@@ -1530,10 +1539,10 @@ main(int argc, /* I - Number of command-line args */
"cups-ipp-missing-validate-job");
break;
}
else if (ipp_status < IPP_REDIRECTION_OTHER_SITE ||
ipp_status == IPP_BAD_REQUEST)
else if (ipp_status < IPP_STATUS_REDIRECTION_OTHER_SITE ||
ipp_status == IPP_STATUS_ERROR_BAD_REQUEST)
break;
else if (job_auth == NULL && ipp_status > IPP_BAD_REQUEST)
else if (job_auth == NULL && ipp_status > IPP_STATUS_ERROR_BAD_REQUEST)
goto cleanup;
}
@@ -1558,8 +1567,8 @@ main(int argc, /* I - Number of command-line args */
if (job_canceled)
break;
request = new_request((num_files > 1 || create_job) ? IPP_CREATE_JOB :
IPP_PRINT_JOB,
request = new_request((num_files > 1 || create_job) ? IPP_OP_CREATE_JOB :
IPP_OP_PRINT_JOB,
version, uri, argv[2], monitor.job_name, num_options,
options, compression, copies_sup ? copies : 1,
document_format, pc, ppd, media_col_sup,
@@ -1584,7 +1593,7 @@ main(int argc, /* I - Number of command-line args */
fputs("DEBUG: Sending file using HTTP/1.1 chunking...\n", stderr);
http_status = cupsSendRequest(http, request, resource, length);
if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
if (http_status == HTTP_STATUS_CONTINUE && request->state == IPP_STATE_DATA)
{
if (compression && strcmp(compression, "none"))
httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
@@ -1603,7 +1612,7 @@ main(int argc, /* I - Number of command-line args */
http_status = cupsWriteRequestData(http, buffer, (size_t)bytes);
}
while (http_status == HTTP_CONTINUE &&
while (http_status == HTTP_STATUS_CONTINUE &&
(!job_canceled || compatsize > 0))
{
/*
@@ -1628,7 +1637,7 @@ main(int argc, /* I - Number of command-line args */
fprintf(stderr, "DEBUG: Read %d bytes...\n", (int)bytes);
if ((http_status = cupsWriteRequestData(http, buffer, (size_t)bytes))
!= HTTP_CONTINUE)
!= HTTP_STATUS_CONTINUE)
break;
}
else if (bytes == 0 || (errno != EINTR && errno != EAGAIN))
@@ -1636,7 +1645,7 @@ main(int argc, /* I - Number of command-line args */
}
}
if (http_status == HTTP_ERROR)
if (http_status == HTTP_STATUS_ERROR)
fprintf(stderr, "DEBUG: Error writing document data for "
"Print-Job: %s\n", strerror(httpError(http)));
@@ -1655,7 +1664,7 @@ main(int argc, /* I - Number of command-line args */
ippErrorString(ipp_status), cupsLastErrorString());
debug_attributes(response);
if (ipp_status > IPP_OK_CONFLICT)
if (ipp_status > IPP_STATUS_OK_CONFLICTING)
{
job_id = 0;
@@ -1707,7 +1716,7 @@ main(int argc, /* I - Number of command-line args */
else if (www_auth[0])
auth_info_required = "username,password";
}
else if (ipp_status == IPP_REQUEST_VALUE)
else if (ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE)
{
/*
* Print file is too large, abort this job...
@@ -1763,7 +1772,7 @@ main(int argc, /* I - Number of command-line args */
* Send the next file in the job...
*/
request = ippNewRequest(IPP_SEND_DOCUMENT);
request = ippNewRequest(IPP_OP_SEND_DOCUMENT);
ippSetVersion(request, version / 10, version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
@@ -1792,7 +1801,7 @@ main(int argc, /* I - Number of command-line args */
debug_attributes(request);
http_status = cupsSendRequest(http, request, resource, 0);
if (http_status == HTTP_CONTINUE && request->state == IPP_DATA)
if (http_status == HTTP_STATUS_CONTINUE && request->state == IPP_STATE_DATA)
{
if (compression && strcmp(compression, "none"))
httpSetField(http, HTTP_FIELD_CONTENT_ENCODING, compression);
@@ -1816,11 +1825,11 @@ main(int argc, /* I - Number of command-line args */
if (fd >= 0)
{
while (!job_canceled && http_status == HTTP_CONTINUE &&
while (!job_canceled && http_status == HTTP_STATUS_CONTINUE &&
(bytes = read(fd, buffer, sizeof(buffer))) > 0)
{
if ((http_status = cupsWriteRequestData(http, buffer, (size_t)bytes))
!= HTTP_CONTINUE)
!= HTTP_STATUS_CONTINUE)
break;
else
{
@@ -1836,7 +1845,7 @@ main(int argc, /* I - Number of command-line args */
close(fd);
}
if (http_status == HTTP_ERROR)
if (http_status == HTTP_STATUS_ERROR)
fprintf(stderr, "DEBUG: Error writing document data for "
"Send-Document: %s\n", strerror(httpError(http)));
@@ -1848,7 +1857,7 @@ main(int argc, /* I - Number of command-line args */
debug_attributes(response);
ippDelete(response);
if (cupsLastError() > IPP_OK_CONFLICT && !job_canceled)
if (cupsLastError() > IPP_STATUS_OK_CONFLICTING && !job_canceled)
{
ipp_status = cupsLastError();
@@ -1869,12 +1878,12 @@ main(int argc, /* I - Number of command-line args */
if (job_canceled)
break;
if (ipp_status <= IPP_OK_CONFLICT && argc > 6)
if (ipp_status <= IPP_STATUS_OK_CONFLICTING && argc > 6)
{
fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
copies_remaining --;
}
else if ((ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_ERROR || ipp_status == IPP_STATUS_ERROR_DOCUMENT_UNPRINTABLE) &&
else if ((ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED || ipp_status == IPP_STATUS_ERROR_DOCUMENT_UNPRINTABLE) &&
argc == 6 &&
document_format && strcmp(document_format, "image/pwg-raster") && strcmp(document_format, "image/urf"))
{
@@ -1888,9 +1897,9 @@ main(int argc, /* I - Number of command-line args */
goto cleanup;
}
else if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
ipp_status == IPP_NOT_POSSIBLE ||
ipp_status == IPP_PRINTER_BUSY)
else if (ipp_status == IPP_STATUS_ERROR_SERVICE_UNAVAILABLE ||
ipp_status == IPP_STATUS_ERROR_NOT_POSSIBLE ||
ipp_status == IPP_STATUS_ERROR_BUSY)
{
if (argc == 6)
{
@@ -1906,14 +1915,14 @@ main(int argc, /* I - Number of command-line args */
}
continue;
}
else if (ipp_status == IPP_REQUEST_VALUE ||
ipp_status == IPP_ERROR_JOB_CANCELED ||
ipp_status == IPP_NOT_AUTHORIZED ||
else if (ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE ||
ipp_status == IPP_STATUS_ERROR_JOB_CANCELED ||
ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED ||
ipp_status == IPP_INTERNAL_ERROR)
ipp_status == IPP_STATUS_ERROR_INTERNAL)
{
/*
* Print file is too large, job was canceled, we need new
@@ -1943,7 +1952,7 @@ main(int argc, /* I - Number of command-line args */
goto cleanup;
}
else if (ipp_status == IPP_NOT_FOUND)
else if (ipp_status == IPP_STATUS_ERROR_NOT_FOUND)
{
/*
* Printer does not actually implement support for Create-Job/
@@ -1957,7 +1966,7 @@ main(int argc, /* I - Number of command-line args */
update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
"cups-ipp-missing-send-document");
ipp_status = IPP_INTERNAL_ERROR; /* Force queue to stop */
ipp_status = IPP_STATUS_ERROR_INTERNAL; /* Force queue to stop */
goto cleanup;
}
@@ -1989,14 +1998,14 @@ main(int argc, /* I - Number of command-line args */
check_printer_state(http, uri, resource, argv[2], version);
if (cupsLastError() <= IPP_OK_CONFLICT)
if (cupsLastError() <= IPP_STATUS_OK_CONFLICTING)
password_tries = 0;
/*
* Build an IPP_GET_JOB_ATTRIBUTES request...
* Build an IPP_OP_GET_JOB_ATTRIBUTES request...
*/
request = ippNewRequest(IPP_GET_JOB_ATTRIBUTES);
request = ippNewRequest(IPP_OP_GET_JOB_ATTRIBUTES);
ippSetVersion(request, version / 10, version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
@@ -2020,11 +2029,11 @@ main(int argc, /* I - Number of command-line args */
* Do the request...
*/
httpReconnect(http);
httpReconnect2(http, 30000, NULL);
response = cupsDoRequest(http, request, resource);
ipp_status = cupsLastError();
if (ipp_status == IPP_NOT_FOUND || ipp_status == IPP_NOT_POSSIBLE)
if (ipp_status == IPP_STATUS_ERROR_NOT_FOUND || ipp_status == IPP_STATUS_ERROR_NOT_POSSIBLE)
{
/*
* Job has gone away and/or the server has no job history...
@@ -2034,7 +2043,7 @@ main(int argc, /* I - Number of command-line args */
"cups-ipp-missing-job-history");
ippDelete(response);
ipp_status = IPP_OK;
ipp_status = IPP_STATUS_OK;
break;
}
@@ -2042,25 +2051,25 @@ main(int argc, /* I - Number of command-line args */
ippErrorString(ipp_status), cupsLastErrorString());
debug_attributes(response);
if (ipp_status <= IPP_OK_CONFLICT)
if (ipp_status <= IPP_STATUS_OK_CONFLICTING)
password_tries = 0;
else
{
if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
ipp_status != IPP_PRINTER_BUSY)
if (ipp_status != IPP_STATUS_ERROR_SERVICE_UNAVAILABLE &&
ipp_status != IPP_STATUS_ERROR_BUSY)
{
ippDelete(response);
ipp_status = IPP_OK;
ipp_status = IPP_STATUS_OK;
break;
}
else if (ipp_status == IPP_INTERNAL_ERROR)
else if (ipp_status == IPP_STATUS_ERROR_INTERNAL)
{
waitjob_tries ++;
if (waitjob_tries > 4)
{
ippDelete(response);
ipp_status = IPP_OK;
ipp_status = IPP_STATUS_OK;
break;
}
}
@@ -2076,11 +2085,11 @@ main(int argc, /* I - Number of command-line args */
*/
if (cups_version &&
job_state->values[0].integer >= IPP_JOB_PENDING &&
job_state->values[0].integer <= IPP_JOB_COMPLETED)
job_state->values[0].integer >= IPP_JSTATE_PENDING &&
job_state->values[0].integer <= IPP_JSTATE_COMPLETED)
update_reasons(NULL,
remote_job_states[job_state->values[0].integer -
IPP_JOB_PENDING]);
IPP_JSTATE_PENDING]);
if ((job_sheets = ippFindAttribute(response, "job-impressions-completed", IPP_TAG_INTEGER)) == NULL)
job_sheets = ippFindAttribute(response, "job-media-sheets-completed", IPP_TAG_INTEGER);
@@ -2100,9 +2109,9 @@ main(int argc, /* I - Number of command-line args */
break;
}
}
else if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
ipp_status != IPP_NOT_POSSIBLE &&
ipp_status != IPP_PRINTER_BUSY)
else if (ipp_status != IPP_STATUS_ERROR_SERVICE_UNAVAILABLE &&
ipp_status != IPP_STATUS_ERROR_NOT_POSSIBLE &&
ipp_status != IPP_STATUS_ERROR_BUSY)
{
/*
* If the printer does not return a job-state attribute, it does not
@@ -2112,7 +2121,7 @@ main(int argc, /* I - Number of command-line args */
update_reasons(NULL, "+cups-ipp-conformance-failure-report,"
"cups-ipp-missing-job-state");
ipp_status = IPP_INTERNAL_ERROR;
ipp_status = IPP_STATUS_ERROR_INTERNAL;
break;
}
}
@@ -2137,7 +2146,7 @@ main(int argc, /* I - Number of command-line args */
{
cancel_job(http, uri, job_id, resource, argv[2], version);
if (cupsLastError() > IPP_OK_CONFLICT)
if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
_cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
}
@@ -2147,7 +2156,7 @@ main(int argc, /* I - Number of command-line args */
check_printer_state(http, uri, resource, argv[2], version);
if (cupsLastError() <= IPP_OK_CONFLICT)
if (cupsLastError() <= IPP_STATUS_OK_CONFLICTING)
password_tries = 0;
/*
@@ -2194,9 +2203,9 @@ main(int argc, /* I - Number of command-line args */
* Return the queue status...
*/
if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
ipp_status == IPP_AUTHENTICATION_CANCELED ||
ipp_status <= IPP_OK_CONFLICT)
if (ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED || ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED ||
ipp_status <= IPP_STATUS_OK_CONFLICTING)
fprintf(stderr, "ATTR: auth-info-required=%s\n", auth_info_required);
if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED)
@@ -2208,25 +2217,25 @@ main(int argc, /* I - Number of command-line args */
else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
fputs("JOBSTATE: account-authorization-failed\n", stderr);
if (ipp_status == IPP_NOT_AUTHORIZED || ipp_status == IPP_FORBIDDEN ||
ipp_status == IPP_AUTHENTICATION_CANCELED)
if (ipp_status == IPP_STATUS_ERROR_NOT_AUTHORIZED || ipp_status == IPP_STATUS_ERROR_FORBIDDEN ||
ipp_status == IPP_STATUS_ERROR_CUPS_AUTHENTICATION_CANCELED)
return (CUPS_BACKEND_AUTH_REQUIRED);
else if (ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_LIMIT_REACHED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_INFO_NEEDED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_CLOSED ||
ipp_status == IPP_STATUS_ERROR_CUPS_ACCOUNT_AUTHORIZATION_FAILED)
return (CUPS_BACKEND_HOLD);
else if (ipp_status == IPP_INTERNAL_ERROR)
else if (ipp_status == IPP_STATUS_ERROR_INTERNAL)
return (CUPS_BACKEND_STOP);
else if (ipp_status == IPP_CONFLICT || ipp_status == IPP_STATUS_ERROR_REQUEST_ENTITY || ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE)
else if (ipp_status == IPP_STATUS_ERROR_CONFLICTING || ipp_status == IPP_STATUS_ERROR_REQUEST_ENTITY || ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE)
return (CUPS_BACKEND_FAILED);
else if (ipp_status == IPP_REQUEST_VALUE ||
else if (ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE ||
ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES ||
ipp_status == IPP_DOCUMENT_FORMAT || job_canceled < 0)
ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED || job_canceled < 0)
{
if (ipp_status == IPP_REQUEST_VALUE)
if (ipp_status == IPP_STATUS_ERROR_REQUEST_VALUE)
_cupsLangPrintFilter(stderr, "ERROR", _("Print job too large."));
else if (ipp_status == IPP_DOCUMENT_FORMAT)
else if (ipp_status == IPP_STATUS_ERROR_DOCUMENT_FORMAT_NOT_SUPPORTED)
_cupsLangPrintFilter(stderr, "ERROR",
_("Printer cannot print supplied content."));
else if (ipp_status == IPP_STATUS_ERROR_ATTRIBUTES_OR_VALUES)
@@ -2237,7 +2246,7 @@ main(int argc, /* I - Number of command-line args */
return (CUPS_BACKEND_CANCEL);
}
else if (ipp_status > IPP_OK_CONFLICT && ipp_status != IPP_ERROR_JOB_CANCELED)
else if (ipp_status > IPP_STATUS_OK_CONFLICTING && ipp_status != IPP_STATUS_ERROR_JOB_CANCELED)
return (CUPS_BACKEND_RETRY_CURRENT);
else
return (CUPS_BACKEND_OK);
@@ -2261,7 +2270,7 @@ cancel_job(http_t *http, /* I - HTTP connection */
_cupsLangPrintFilter(stderr, "INFO", _("Canceling print job."));
request = ippNewRequest(IPP_CANCEL_JOB);
request = ippNewRequest(IPP_OP_CANCEL_JOB);
ippSetVersion(request, version / 10, version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
@@ -2295,7 +2304,7 @@ check_printer_state(
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* Attribute in response */
ipp_pstate_t printer_state = IPP_PRINTER_STOPPED;
ipp_pstate_t printer_state = IPP_PSTATE_STOPPED;
/* Current printer-state */
@@ -2303,7 +2312,7 @@ check_printer_state(
* Send a Get-Printer-Attributes request and log the results...
*/
request = ippNewRequest(IPP_GET_PRINTER_ATTRIBUTES);
request = ippNewRequest(IPP_OP_GET_PRINTER_ATTRIBUTES);
ippSetVersion(request, version / 10, version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
@@ -2429,14 +2438,14 @@ monitor_printer(
monitor->job_reasons = 0;
while (monitor->job_state < IPP_JOB_CANCELED && !job_canceled)
while (monitor->job_state < IPP_JSTATE_CANCELED && !job_canceled)
{
/*
* Reconnect to the printer as needed...
*/
if (httpGetFd(http) < 0)
httpReconnect(http);
httpReconnect2(http, 30000, NULL);
if (httpGetFd(http) >= 0)
{
@@ -2448,7 +2457,7 @@ monitor_printer(
monitor->resource,
monitor->user,
monitor->version);
if (cupsLastError() <= IPP_OK_CONFLICT)
if (cupsLastError() <= IPP_STATUS_OK_CONFLICTING)
password_tries = 0;
if (monitor->job_id == 0 && monitor->create_job)
@@ -2465,13 +2474,13 @@ monitor_printer(
*/
job_op = (monitor->job_id > 0 && monitor->get_job_attrs) ?
IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS;
IPP_OP_GET_JOB_ATTRIBUTES : IPP_OP_GET_JOBS;
request = ippNewRequest(job_op);
ippSetVersion(request, monitor->version / 10, monitor->version % 10);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, monitor->uri);
if (job_op == IPP_GET_JOB_ATTRIBUTES)
if (job_op == IPP_OP_GET_JOB_ATTRIBUTES)
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
monitor->job_id);
@@ -2492,16 +2501,16 @@ monitor_printer(
fprintf(stderr, "DEBUG: (monitor) %s: %s (%s)\n", ippOpString(job_op),
ippErrorString(cupsLastError()), cupsLastErrorString());
if (cupsLastError() <= IPP_OK_CONFLICT)
if (cupsLastError() <= IPP_STATUS_OK_CONFLICTING)
password_tries = 0;
if (job_op == IPP_GET_JOB_ATTRIBUTES)
if (job_op == IPP_OP_GET_JOB_ATTRIBUTES)
{
if ((attr = ippFindAttribute(response, "job-state",
IPP_TAG_ENUM)) != NULL)
monitor->job_state = (ipp_jstate_t)attr->values[0].integer;
else
monitor->job_state = IPP_JOB_COMPLETED;
monitor->job_state = IPP_JSTATE_COMPLETED;
}
else if (response)
{
@@ -2509,7 +2518,7 @@ monitor_printer(
{
job_id = 0;
job_name = NULL;
job_state = IPP_JOB_PENDING;
job_state = IPP_JSTATE_PENDING;
job_user = NULL;
while (attr && attr->group_tag != IPP_TAG_JOB)
@@ -2555,8 +2564,8 @@ monitor_printer(
ippEnumString("job-state", monitor->job_state));
if (!job_canceled &&
(monitor->job_state == IPP_JOB_CANCELED ||
monitor->job_state == IPP_JOB_ABORTED))
(monitor->job_state == IPP_JSTATE_CANCELED ||
monitor->job_state == IPP_JSTATE_ABORTED))
{
job_canceled = -1;
fprintf(stderr, "DEBUG: (monitor) job_canceled = -1\n");
@@ -2569,22 +2578,24 @@ monitor_printer(
for (i = 0; i < attr->num_values; i ++)
{
if (!strcmp(attr->values[i].string.text,
"account-authorization-failed"))
if (!strcmp(attr->values[i].string.text, "account-authorization-failed"))
new_reasons |= _CUPS_JSR_ACCOUNT_AUTHORIZATION_FAILED;
else if (!strcmp(attr->values[i].string.text, "account-closed"))
new_reasons |= _CUPS_JSR_ACCOUNT_CLOSED;
else if (!strcmp(attr->values[i].string.text, "account-info-needed"))
new_reasons |= _CUPS_JSR_ACCOUNT_INFO_NEEDED;
else if (!strcmp(attr->values[i].string.text,
"account-limit-reached"))
else if (!strcmp(attr->values[i].string.text, "account-limit-reached"))
new_reasons |= _CUPS_JSR_ACCOUNT_LIMIT_REACHED;
else if (!strcmp(attr->values[i].string.text, "job-password-wait"))
new_reasons |= _CUPS_JSR_JOB_PASSWORD_WAIT;
else if (!strcmp(attr->values[i].string.text, "job-release-wait"))
new_reasons |= _CUPS_JSR_JOB_RELEASE_WAIT;
if (!job_canceled &&
(!strncmp(attr->values[i].string.text, "job-canceled-", 13) || !strcmp(attr->values[i].string.text, "aborted-by-system")))
else if (!strcmp(attr->values[i].string.text, "document-format-error"))
new_reasons |= _CUPS_JSR_DOCUMENT_FORMAT_ERROR;
else if (!strcmp(attr->values[i].string.text, "document-unprintable"))
new_reasons |= _CUPS_JSR_DOCUMENT_UNPRINTABLE;
if (!job_canceled && (!strncmp(attr->values[i].string.text, "job-canceled-", 13) || !strcmp(attr->values[i].string.text, "aborted-by-system")))
job_canceled = 1;
}
@@ -2602,6 +2613,26 @@ monitor_printer(
fputs("JOBSTATE: job-password-wait\n", stderr);
else if (new_reasons & _CUPS_JSR_JOB_RELEASE_WAIT)
fputs("JOBSTATE: job-release-wait\n", stderr);
else if (new_reasons & (_CUPS_JSR_DOCUMENT_FORMAT_ERROR | _CUPS_JSR_DOCUMENT_UNPRINTABLE))
{
if (monitor->retryable)
{
/*
* Can't print this, so retry as raster...
*/
job_canceled = 1;
fputs("JOBSTATE: cups-retry-as-raster\n", stderr);
}
else if (new_reasons & _CUPS_JSR_DOCUMENT_FORMAT_ERROR)
{
fputs("JOBSTATE: document-format-error\n", stderr);
}
else
{
fputs("JOBSTATE: document-unprintable\n", stderr);
}
}
else
fputs("JOBSTATE: job-printing\n", stderr);
@@ -2615,8 +2646,8 @@ monitor_printer(
ippEnumString("job-state", monitor->job_state));
if (!job_canceled &&
(monitor->job_state == IPP_JOB_CANCELED ||
monitor->job_state == IPP_JOB_ABORTED))
(monitor->job_state == IPP_JSTATE_CANCELED ||
monitor->job_state == IPP_JSTATE_ABORTED))
job_canceled = -1;
}
@@ -2638,14 +2669,14 @@ monitor_printer(
if (job_canceled > 0 && monitor->job_id > 0)
{
if (httpGetFd(http) < 0)
httpReconnect(http);
httpReconnect2(http, 30000, NULL);
if (httpGetFd(http) >= 0)
{
cancel_job(http, monitor->uri, monitor->job_id, monitor->resource,
monitor->user, monitor->version);
if (cupsLastError() > IPP_OK_CONFLICT)
if (cupsLastError() > IPP_STATUS_OK_CONFLICTING)
{
fprintf(stderr, "DEBUG: (monitor) cancel_job() = %s\n", cupsLastErrorString());
_cupsLangPrintFilter(stderr, "ERROR", _("Unable to cancel print job."));
@@ -2721,7 +2752,7 @@ new_request(
fprintf(stderr, "DEBUG: job-name=\"%s\"\n", title);
}
if (format && op != IPP_CREATE_JOB)
if (format && op != IPP_OP_CREATE_JOB)
{
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format", NULL, format);
fprintf(stderr, "DEBUG: document-format=\"%s\"\n", format);
@@ -2761,7 +2792,7 @@ new_request(
char phone[1024], /* Phone number string */
*ptr, /* Pointer into string */
tel_uri[1024]; /* tel: URI */
static const char * const allowed = "0123456789#*-+.()";
static const char * const allowed = "0123456789#*-+.()pw";
/* Allowed characters */
destination = ippNew();
@@ -2774,7 +2805,9 @@ new_request(
_httpDecodeURI(phone, keyword, sizeof(phone));
for (ptr = phone; *ptr;)
{
if (!strchr(allowed, *ptr))
if (*ptr == ',')
*ptr = 'p';
else if (!strchr(allowed, *ptr))
_cups_strcpy(ptr, ptr + 1);
else
ptr ++;
@@ -3560,6 +3593,8 @@ update_reasons(ipp_attribute_t *attr, /* I - printer-state-reasons or NULL */
}
}
cupsArrayDelete(new_reasons);
_cupsMutexUnlock(&report_mutex);
/*
+10 -11
Ver Arquivo
@@ -24,14 +24,14 @@
#include <sys/stat.h>
#include <stdio.h>
#ifdef WIN32
#ifdef _WIN32
# include <winsock.h>
#else
# include <sys/socket.h>
# include <netinet/in.h>
# include <arpa/inet.h>
# include <netdb.h>
#endif /* WIN32 */
#endif /* _WIN32 */
#ifdef __APPLE__
# include <CoreFoundation/CFNumber.h>
# include <CoreFoundation/CFPreferences.h>
@@ -623,11 +623,11 @@ cups_rresvport(int *port, /* IO - Port number to bind to */
* -1...
*/
#ifdef WIN32
#ifdef _WIN32
closesocket(fd);
#else
close(fd);
#endif /* WIN32 */
#endif /* _WIN32 */
return (-1);
}
@@ -735,11 +735,11 @@ lpd_queue(const char *hostname, /* I - Host to connect to */
ssize_t nbytes; /* Number of bytes written */
off_t tbytes; /* Total bytes written */
char buffer[32768]; /* Output buffer */
#ifdef WIN32
#ifdef _WIN32
DWORD tv; /* Timeout in milliseconds */
#else
struct timeval tv; /* Timeout in secs and usecs */
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -867,8 +867,7 @@ lpd_queue(const char *hostname, /* I - Host to connect to */
fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(error));
if (error == ECONNREFUSED || error == EHOSTDOWN ||
error == EHOSTUNREACH)
if (errno == ECONNREFUSED || errno == EHOSTDOWN || errno == EHOSTUNREACH || errno == ETIMEDOUT || errno == ENOTCONN)
{
if (contimeout && (time(NULL) - start_time) > contimeout)
{
@@ -886,13 +885,13 @@ lpd_queue(const char *hostname, /* I - Host to connect to */
break;
case EHOSTUNREACH :
default :
_cupsLangPrintFilter(stderr, "WARNING",
_("The printer is unreachable at "
"this time."));
break;
case ECONNREFUSED :
default :
_cupsLangPrintFilter(stderr, "WARNING",
_("The printer is in use."));
break;
@@ -923,7 +922,7 @@ lpd_queue(const char *hostname, /* I - Host to connect to */
* Set the timeout...
*/
#ifdef WIN32
#ifdef _WIN32
tv = (DWORD)(timeout * 1000);
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(tv));
@@ -934,7 +933,7 @@ lpd_queue(const char *hostname, /* I - Host to connect to */
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv));
setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv));
#endif /* WIN32 */
#endif /* _WIN32 */
fputs("STATE: -connecting-to-device\n", stderr);
_cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
+35 -1
Ver Arquivo
@@ -8,10 +8,17 @@
# delay-close Delay close/reset of selected interface
# no-reattach Do no re-attach usblp kernel module after printing.
# soft-reset Do a soft reset after printing for cleanup.
# unidir Only supported unidirectional I/O
# unidir Only supports unidirectional I/O
# usb-init Needs vendor USB initialization string.
# vendor-class Uses vendor-specific class or subclass.
# whitelist The printer is functional with the USB backend.
#
# To get the USB vendor and product IDs for a given printer, run the "lsusb"
# command, which will show something like the following:
#
# Bus 002 Device 003: ID ab21:34dc Acme Example Printer
#
# The "ab21:34dc" is the vendor and product ID, separated by a colon.
# HP DeskJet 895C
0x03f0 0x0004 unidir
@@ -76,6 +83,9 @@
# Canon, Inc. MP510 Printer (https://bugs.launchpad.net/bugs/1050009)
0x04a9 0x1717 unidir
# Canon, Inc. MP540 Printer, https://bugzilla.redhat.com/967873
0x04a9 0x1730 unidir
# Canon, Inc. MP550 Printer (Issue #4155)
0x04a9 0x173d unidir
@@ -127,6 +137,9 @@
# All Samsung devices (https://bugs.launchpad.net/bugs/1032456)
0x04e8 soft-reset
# Samsung ML-2160 Series (https://bugzilla.redhat.com/show_bug.cgi?id=873123)
0x04e8 0x330f unidir
# All Zebra devices (https://bugs.launchpad.net/bugs/1001028)
0x0a5f unidir
@@ -251,5 +264,26 @@
# Kyocera Ecosys P6026cdn (Issue #4900)
0x0482 0x063f no-reattach
# Kyocera Ecosys P6130cdn (Issue #5102)
0x0482 0x0677 no-reattach
# Lexmark E260dn (Issue #4994)
0x043d 0x0123 no-reattach
# HP LaserJet 1160 (Issue #5121)
0x03f0 0x1e17 delay-close
# Canon, Inc. MP280 series (Issue #5221)
0x04a9 0x1746 unidir
# Star Micronics printers (Issue #5251)
0x0519 unidir
# Lexmark Optra E310 (Issue #5259)
0x043d 0x000c no-reattach
# HP LaserJet P1102 (Issue #5310)
0x03F0 0x002A no-reattach
# Lexmark MS317dn
0x043d 0x0226 no-reattach
+11 -10
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* AppSocket backend for CUPS.
*
* Copyright 2007-2016 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -23,7 +23,7 @@
#include <sys/types.h>
#include <sys/stat.h>
#ifdef WIN32
#ifdef _WIN32
# include <winsock.h>
#else
# include <unistd.h>
@@ -32,7 +32,7 @@
# include <netinet/in.h>
# include <arpa/inet.h>
# include <netdb.h>
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -330,8 +330,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(error));
if (error == ECONNREFUSED || error == EHOSTDOWN ||
error == EHOSTUNREACH)
if (errno == ECONNREFUSED || errno == EHOSTDOWN || errno == EHOSTUNREACH || errno == ETIMEDOUT || errno == ENOTCONN)
{
if (contimeout && (time(NULL) - start_time) > contimeout)
{
@@ -349,13 +348,13 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
break;
case EHOSTUNREACH :
default :
_cupsLangPrintFilter(stderr, "WARNING",
_("The printer is unreachable at this "
"time."));
break;
case ECONNREFUSED :
default :
_cupsLangPrintFilter(stderr, "WARNING",
_("The printer is in use."));
break;
@@ -403,8 +402,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
lseek(print_fd, 0, SEEK_SET);
}
tbytes = backendRunLoop(print_fd, device_fd, snmp_fd, &(addrlist->addr), 1,
0, backendNetworkSideCB);
if ((bytes = backendRunLoop(print_fd, device_fd, snmp_fd, &(addrlist->addr), 1, 0, backendNetworkSideCB)) < 0)
tbytes = -1;
else
tbytes = bytes;
if (print_fd != 0 && tbytes >= 0)
_cupsLangPrintFilter(stderr, "INFO", _("Print file sent."));
@@ -412,7 +413,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fputs("STATE: +cups-waiting-for-job-completed\n", stderr);
if (waiteof)
if (waiteof && tbytes >= 0)
{
/*
* Shutdown the socket and wait for the other end to finish...
@@ -449,7 +450,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
if (print_fd != 0)
close(print_fd);
return (CUPS_BACKEND_OK);
return (tbytes >= 0 ? CUPS_BACKEND_OK : CUPS_BACKEND_FAILED);
}
+2 -2
Ver Arquivo
@@ -18,12 +18,12 @@
*/
#include <cups/string-private.h>
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
#else
# include <unistd.h>
# include <fcntl.h>
#endif /* WIN32 */
#endif /* _WIN32 */
#include "ieee1284.c"
+2 -2
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Backend test program for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2005 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -38,7 +38,7 @@ static int job_canceled = 0;
*/
static void sigterm_handler(int sig);
static void usage(void) __attribute__((noreturn));
static void usage(void) _CUPS_NORETURN;
static void walk_cb(const char *oid, const char *data, int datalen,
void *context);
+2 -2
Ver Arquivo
@@ -290,10 +290,10 @@ static void status_timer_cb(CFRunLoopTimerRef timer, void *info);
#if defined(__i386__) || defined(__x86_64__)
static pid_t child_pid; /* Child PID */
static void run_legacy_backend(int argc, char *argv[], int fd) __attribute__((noreturn)); /* Starts child backend process running as a ppc executable */
static void run_legacy_backend(int argc, char *argv[], int fd) _CUPS_NORETURN; /* Starts child backend process running as a ppc executable */
#endif /* __i386__ || __x86_64__ */
static void sigterm_handler(int sig); /* SIGTERM handler */
static void sigquit_handler(int sig, siginfo_t *si, void *unused) __attribute__((noreturn));
static void sigquit_handler(int sig, siginfo_t *si, void *unused) _CUPS_NORETURN;
#ifdef PARSE_PS_ERRORS
static const char *next_line (const char *buffer);
+2 -2
Ver Arquivo
@@ -24,13 +24,13 @@
#include "backend-private.h"
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
#else
# include <unistd.h>
# include <fcntl.h>
# include <termios.h>
#endif /* WIN32 */
#endif /* _WIN32 */
/*
+9 -5
Ver Arquivo
@@ -1,7 +1,7 @@
#
# Berkeley commands makefile for CUPS.
#
# Copyright 2007-2012 by Apple Inc.
# Copyright 2007-2017 by Apple Inc.
# Copyright 1997-2006 by Easy Software Products, all rights reserved.
#
# These coded instructions, statements, and computer programs are the
@@ -124,7 +124,8 @@ uninstall:
lpc: lpc.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpc lpc.o $(LIBS)
$(LD_CC) $(LDFLAGS) -o lpc lpc.o $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -133,7 +134,8 @@ lpc: lpc.o ../cups/$(LIBCUPS)
lpq: lpq.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpq lpq.o $(LIBS)
$(LD_CC) $(LDFLAGS) -o lpq lpq.o $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -142,7 +144,8 @@ lpq: lpq.o ../cups/$(LIBCUPS)
lpr: lpr.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpr lpr.o $(LIBS)
$(LD_CC) $(LDFLAGS) -o lpr lpr.o $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -151,7 +154,8 @@ lpr: lpr.o ../cups/$(LIBCUPS)
lprm: lprm.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lprm lprm.o $(LIBS)
$(LD_CC) $(LDFLAGS) -o lprm lprm.o $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
+2 -2
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* "lpq" command for CUPS.
*
* Copyright 2007-2016 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -26,7 +26,7 @@ static http_t *connect_server(const char *, http_t *);
static int show_jobs(const char *, http_t *, const char *,
const char *, const int, const int);
static void show_printer(const char *, http_t *, const char *);
static void usage(void) __attribute__((noreturn));
static void usage(void) _CUPS_NORETURN;
/*
+4 -28
Ver Arquivo
@@ -32,8 +32,7 @@ main(int argc, /* I - Number of command-line arguments */
char *printer, /* Destination printer or class */
*instance, /* Instance */
*opt; /* Option pointer */
const char *title, /* Job title */
*val; /* Environment variable name */
const char *title; /* Job title */
int num_copies; /* Number of copies per file */
int num_files; /* Number of files to print */
const char *files[1000]; /* Files to print */
@@ -345,33 +344,10 @@ main(int argc, /* I - Number of command-line arguments */
if (printer == NULL)
{
val = NULL;
if ((printer = getenv("LPDEST")) == NULL)
{
if ((printer = getenv("PRINTER")) != NULL)
{
if (!strcmp(printer, "lp"))
printer = NULL;
else
val = "PRINTER";
}
}
if (!cupsGetNamedDest(NULL, NULL, NULL) && cupsLastError() == IPP_STATUS_ERROR_NOT_FOUND)
_cupsLangPrintf(stderr, _("%s: Error - %s"), argv[0], cupsLastErrorString());
else
val = "LPDEST";
if (printer && !cupsGetNamedDest(NULL, printer, NULL))
_cupsLangPrintf(stderr,
_("%s: Error - %s environment variable names "
"non-existent destination \"%s\"."), argv[0], val,
printer);
else if (cupsLastError() == IPP_NOT_FOUND)
_cupsLangPrintf(stderr,
_("%s: Error - no default destination available."),
argv[0]);
else
_cupsLangPrintf(stderr, _("%s: Error - scheduler not responding."),
argv[0]);
_cupsLangPrintf(stderr, _("%s: Error - scheduler not responding."), argv[0]);
return (1);
}
+25 -108
Ver Arquivo
@@ -1,7 +1,7 @@
#
# CGI makefile for CUPS.
#
# Copyright 2007-2016 by Apple Inc.
# Copyright 2007-2018 by Apple Inc.
# Copyright 1997-2006 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
@@ -26,7 +26,6 @@ OBJS = \
classes.o \
help.o \
jobs.o \
makedocset.o \
printers.o \
testcgi.o \
testhi.o \
@@ -38,8 +37,7 @@ CGIS = \
jobs.cgi \
printers.cgi
LIBTARGETS = \
libcupscgi.a \
$(LIBCUPSCGI)
libcupscgi.a
UNITTARGETS = \
testcgi \
@@ -77,8 +75,7 @@ unittests: $(UNITTARGETS)
#
clean:
$(RM) $(OBJS) $(TARGETS) $(UNITTARGETS) makedocset
$(RM) libcupscgi.so libcupscgi.dylib
$(RM) $(OBJS) $(TARGETS) $(UNITTARGETS)
#
@@ -126,42 +123,13 @@ install-exec:
#
install-headers:
if test "x$(privateinclude)" != x; then \
echo Installing private header files into $(PRIVATEINCLUDE)...; \
$(INSTALL_DIR) -m 755 $(PRIVATEINCLUDE); \
for file in cgi.h help-index.h; do \
$(INSTALL_DATA) $$file $(PRIVATEINCLUDE); \
done; \
fi
#
# Install libraries...
#
install-libs: $(INSTALLSTATIC)
echo Installing libraries in $(LIBDIR)...
$(INSTALL_DIR) -m 755 $(LIBDIR)
$(INSTALL_LIB) $(LIBCUPSCGI) $(LIBDIR)
if test $(LIBCUPSCGI) = "libcupscgi.so.1"; then \
$(RM) $(LIBDIR)/`basename $(LIBCUPSCGI) .1`; \
$(LN) $(LIBCUPSCGI) $(LIBDIR)/`basename $(LIBCUPSCGI) .1`; \
fi
if test $(LIBCUPSCGI) = "libcupscgi.1.dylib"; then \
$(RM) $(LIBDIR)/libcupscgi.dylib; \
$(LN) $(LIBCUPSCGI) $(LIBDIR)/libcupscgi.dylib; \
fi
if test "x$(SYMROOT)" != "x"; then \
$(INSTALL_DIR) $(SYMROOT); \
cp $(LIBCUPSCGI) $(SYMROOT); \
dsymutil $(SYMROOT)/$(LIBCUPSCGI); \
fi
installstatic:
$(INSTALL_DIR) -m 755 $(LIBDIR)
$(INSTALL_LIB) -m 755 libcupscgi.a $(LIBDIR)
$(RANLIB) $(LIBDIR)/libcupscgi.a
$(CHMOD) 555 $(LIBDIR)/libcupscgi.a
install-libs:
#
@@ -173,54 +141,6 @@ uninstall:
$(RM) $(SERVERBIN)/cgi-bin/$$file; \
done
-$(RMDIR) $(SERVERBIN)/cgi-bin
$(RM) $(LIBDIR)/libcupscgi.1.dylib
$(RM) $(LIBDIR)/libcupscgi.a
$(RM) $(LIBDIR)/libcupscgi.dylib
$(RM) $(LIBDIR)/libcupscgi.so
$(RM) $(LIBDIR)/libcupscgi.so.1
-$(RMDIR) $(LIBDIR)
-if test "x$(privateinclude)" != x; then \
$(RM) $(PRIVATEINCLUDE)/cgi.h; \
$(RM) $(PRIVATEINCLUDE)/help-index.h; \
$(RMDIR) $(PRIVATEINCLUDE); \
fi
#
# libcupscgi.so.1
#
libcupscgi.so.1: $(LIBOBJS)
echo Linking $@...
$(DSO) $(ARCHFLAGS) $(DSOFLAGS) -o $@ $(LIBOBJS) $(LIBS)
$(RM) `basename $@ .1`
$(LN) $@ `basename $@ .1`
#
# libcupscgi.1.dylib
#
libcupscgi.1.dylib: $(LIBOBJS) libcupscgi.exp
echo Linking $@...
$(DSO) $(ARCHFLAGS) $(DSOFLAGS) -o $@ \
-install_name $(libdir)/$@ \
-current_version 1.0.0 \
-compatibility_version 1.0.0 \
-exported_symbols_list libcupscgi.exp \
$(LIBOBJS) $(LIBS)
$(RM) libcupscgi.dylib
$(LN) $@ libcupscgi.dylib
#
# libcupscgi.la
#
libcupscgi.la: $(LIBOBJS)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(DSOFLAGS) -o $@ $(LIBOBJS:.o=.lo) -rpath $(LIBDIR) \
-version-info 1:0 $(LIBS)
#
@@ -238,56 +158,50 @@ libcupscgi.a: $(LIBOBJS)
# admin.cgi
#
admin.cgi: admin.o ../Makedefs ../cups/$(LIBCUPS) $(LIBCUPSCGI)
admin.cgi: admin.o ../Makedefs ../cups/$(LIBCUPS) libcupscgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ admin.o -lcupscgi $(LIBS)
$(LD_CC) $(LDFLAGS) -o $@ admin.o libcupscgi.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
# classes.cgi
#
classes.cgi: classes.o ../Makedefs ../cups/$(LIBCUPS) $(LIBCUPSCGI)
classes.cgi: classes.o ../Makedefs ../cups/$(LIBCUPS) libcupscgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ classes.o -lcupscgi $(LIBS)
$(LD_CC) $(LDFLAGS) -o $@ classes.o libcupscgi.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
# help.cgi
#
help.cgi: help.o ../Makedefs ../cups/$(LIBCUPS) $(LIBCUPSCGI)
help.cgi: help.o ../Makedefs ../cups/$(LIBCUPS) libcupscgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ help.o -lcupscgi $(LIBS)
$(LD_CC) $(LDFLAGS) -o $@ help.o libcupscgi.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
# jobs.cgi
#
jobs.cgi: jobs.o ../Makedefs ../cups/$(LIBCUPS) $(LIBCUPSCGI)
jobs.cgi: jobs.o ../Makedefs ../cups/$(LIBCUPS) libcupscgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ jobs.o -lcupscgi $(LIBS)
#
# makedocset
#
makedocset: makedocset.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ makedocset.o libcupscgi.a \
../cups/$(LIBCUPSSTATIC) $(COMMONLIBS) $(SSLLIBS) $(DNSSDLIBS) \
$(LIBZ) $(LIBGSSAPI)
$(LD_CC) $(LDFLAGS) -o $@ jobs.o libcupscgi.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
# printers.cgi
#
printers.cgi: printers.o ../Makedefs ../cups/$(LIBCUPS) $(LIBCUPSCGI)
printers.cgi: printers.o ../Makedefs ../cups/$(LIBCUPS) libcupscgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ printers.o -L. -lcupscgi $(LIBS)
$(LD_CC) $(LDFLAGS) -o $@ printers.o -L. libcupscgi.a $(LIBS)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -296,9 +210,10 @@ printers.cgi: printers.o ../Makedefs ../cups/$(LIBCUPS) $(LIBCUPSCGI)
testcgi: testcgi.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testcgi.o libcupscgi.a \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testcgi.o libcupscgi.a \
../cups/$(LIBCUPSSTATIC) $(COMMONLIBS) $(SSLLIBS) $(DNSSDLIBS) \
$(LIBZ) $(LIBGSSAPI)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Testing CGI API...
./testcgi
@@ -309,9 +224,10 @@ testcgi: testcgi.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC)
testhi: testhi.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testhi.o libcupscgi.a \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testhi.o libcupscgi.a \
../cups/$(LIBCUPSSTATIC) $(COMMONLIBS) $(SSLLIBS) $(DNSSDLIBS) \
$(LIBZ) $(LIBGSSAPI)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Testing help index API...
./testhi
@@ -322,8 +238,9 @@ testhi: testhi.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC)
testtemplate: testtemplate.o ../Makedefs libcupscgi.a ../cups/$(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testtemplate.o libcupscgi.a ../cups/$(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testtemplate.o libcupscgi.a ../cups/$(LIBCUPSSTATIC) \
$(COMMONLIBS) $(SSLLIBS) $(DNSSDLIBS) $(LIBZ) $(LIBGSSAPI)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
+5 -4
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Administration CGI for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -1137,6 +1137,8 @@ do_am_printer(http_t *http, /* I - HTTP connection */
else if (!file &&
(!cgiGetVariable("PPD_NAME") || cgiGetVariable("SELECT_MAKE")))
{
int ipp_everywhere = !strncmp(var, "ipp://", 6) || !strncmp(var, "ipps://", 7) || (!strncmp(var, "dnssd://", 8) && (strstr(var, "_ipp._tcp") || strstr(var, "_ipps._tcp")));
if (modify && !cgiGetVariable("SELECT_MAKE"))
{
/*
@@ -1282,9 +1284,8 @@ do_am_printer(http_t *http, /* I - HTTP connection */
cgiStartHTML(title);
if (!cgiGetVariable("PPD_MAKE"))
cgiSetVariable("PPD_MAKE", cgiGetVariable("CURRENT_MAKE"));
if (!modify)
cgiSetVariable("CURRENT_MAKE_AND_MODEL",
cgiGetArray("PPD_MAKE_AND_MODEL", 0));
if (ipp_everywhere)
cgiSetVariable("SHOW_IPP_EVERYWHERE", "1");
cgiCopyTemplateLang("choose-model.tmpl");
cgiEndHTML();
}
+2 -2
Ver Arquivo
@@ -19,12 +19,12 @@
# include <time.h>
# include <sys/stat.h>
# ifdef WIN32
# ifdef _WIN32
# include <direct.h>
# include <io.h>
# else
# include <unistd.h>
# endif /* WIN32 */
# endif /* _WIN32 */
# include <cups/cups.h>
# include <cups/array.h>
+2 -6
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Online help index routines for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -138,11 +138,7 @@ static int help_load_file(help_index_t *hi,
const char *filename,
const char *relative,
time_t mtime);
static help_node_t *help_new_node(const char *filename, const char *anchor,
const char *section, const char *text,
time_t mtime, off_t offset,
size_t length)
__attribute__((nonnull(1,3,4)));
static help_node_t *help_new_node(const char *filename, const char *anchor, const char *section, const char *text, time_t mtime, off_t offset, size_t length) _CUPS_NONNULL((1, 3, 4));
static int help_sort_by_name(help_node_t *p1, help_node_t *p2);
static int help_sort_by_score(help_node_t *p1, help_node_t *p2);
static int help_sort_words(help_word_t *w1, help_word_t *w2);
-469
Ver Arquivo
@@ -1,469 +0,0 @@
/*
* Xcode documentation set generator.
*
* Copyright 2007-2012 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
* law. Distribution and use rights are outlined in the file "LICENSE.txt"
* which should have been included with this file. If this file is
* missing or damaged, see the license at "http://www.cups.org/".
*
* Usage:
*
* makedocset directory *.tokens
*/
/*
* Include necessary headers...
*/
#include "cgi-private.h"
#include <errno.h>
/*
* Local structures...
*/
typedef struct _cups_html_s /**** Help file ****/
{
char *path; /* Path to help file */
char *title; /* Title of help file */
} _cups_html_t;
typedef struct _cups_section_s /**** Help section ****/
{
char *name; /* Section name */
cups_array_t *files; /* Files in this section */
} _cups_section_t;
/*
* Local functions...
*/
static int compare_html(_cups_html_t *a, _cups_html_t *b);
static int compare_sections(_cups_section_t *a, _cups_section_t *b);
static int compare_sections_files(_cups_section_t *a, _cups_section_t *b);
static void write_index(const char *path, help_index_t *hi);
static void write_info(const char *path, const char *revision);
static void write_nodes(const char *path, help_index_t *hi);
/*
* 'main()' - Test the help index code.
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line args */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
char path[1024], /* Path to documentation */
line[1024]; /* Line from file */
help_index_t *hi; /* Help index */
cups_file_t *tokens, /* Tokens.xml file */
*fp; /* Current file */
if (argc < 4)
{
puts("Usage: makedocset directory revision *.tokens");
return (1);
}
/*
* Index the help documents...
*/
snprintf(path, sizeof(path), "%s/Contents/Resources/Documentation", argv[1]);
if ((hi = helpLoadIndex(NULL, path)) == NULL)
{
fputs("makedocset: Unable to index help files!\n", stderr);
return (1);
}
snprintf(path, sizeof(path), "%s/Contents/Resources/Documentation/index.html",
argv[1]);
write_index(path, hi);
snprintf(path, sizeof(path), "%s/Contents/Resources/Nodes.xml", argv[1]);
write_nodes(path, hi);
/*
* Write the Info.plist file...
*/
snprintf(path, sizeof(path), "%s/Contents/Info.plist", argv[1]);
write_info(path, argv[2]);
/*
* Merge the Tokens.xml files...
*/
snprintf(path, sizeof(path), "%s/Contents/Resources/Tokens.xml", argv[1]);
if ((tokens = cupsFileOpen(path, "w")) == NULL)
{
fprintf(stderr, "makedocset: Unable to create \"%s\": %s\n", path,
strerror(errno));
return (1);
}
cupsFilePuts(tokens, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
cupsFilePuts(tokens, "<Tokens version=\"1.0\">\n");
for (i = 3; i < argc; i ++)
{
if ((fp = cupsFileOpen(argv[i], "r")) == NULL)
{
fprintf(stderr, "makedocset: Unable to open \"%s\": %s\n", argv[i],
strerror(errno));
return (1);
}
if (!cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "<?xml ", 6) ||
!cupsFileGets(fp, line, sizeof(line)) || strncmp(line, "<Tokens ", 8))
{
fprintf(stderr, "makedocset: Bad Tokens.xml file \"%s\"!\n", argv[i]);
return (1);
}
while (cupsFileGets(fp, line, sizeof(line)))
{
if (strcmp(line, "</Tokens>"))
cupsFilePrintf(tokens, "%s\n", line);
}
cupsFileClose(fp);
}
cupsFilePuts(tokens, "</Tokens>\n");
cupsFileClose(tokens);
/*
* Return with no errors...
*/
return (0);
}
/*
* 'compare_html()' - Compare the titles of two HTML files.
*/
static int /* O - Result of comparison */
compare_html(_cups_html_t *a, /* I - First file */
_cups_html_t *b) /* I - Second file */
{
return (_cups_strcasecmp(a->title, b->title));
}
/*
* 'compare_sections()' - Compare the names of two help sections.
*/
static int /* O - Result of comparison */
compare_sections(_cups_section_t *a, /* I - First section */
_cups_section_t *b) /* I - Second section */
{
return (_cups_strcasecmp(a->name, b->name));
}
/*
* 'compare_sections_files()' - Compare the number of files and section names.
*/
static int /* O - Result of comparison */
compare_sections_files(
_cups_section_t *a, /* I - First section */
_cups_section_t *b) /* I - Second section */
{
int ret = cupsArrayCount(b->files) - cupsArrayCount(a->files);
if (ret)
return (ret);
else
return (_cups_strcasecmp(a->name, b->name));
}
/*
* 'write_index()' - Write an index file for the CUPS help.
*/
static void
write_index(const char *path, /* I - File to write */
help_index_t *hi) /* I - Index of files */
{
cups_file_t *fp; /* Output file */
help_node_t *node; /* Current help node */
_cups_section_t *section, /* Current section */
key; /* Section search key */
_cups_html_t *html; /* Current HTML file */
cups_array_t *sections, /* Sections in index */
*sections_files,/* Sections sorted by size */
*columns[3]; /* Columns in final HTML file */
int column, /* Current column */
lines[3], /* Number of lines in each column */
min_column, /* Smallest column */
min_lines; /* Smallest number of lines */
/*
* Build an array of sections and their files.
*/
sections = cupsArrayNew((cups_array_func_t)compare_sections, NULL);
for (node = (help_node_t *)cupsArrayFirst(hi->nodes);
node;
node = (help_node_t *)cupsArrayNext(hi->nodes))
{
if (node->anchor)
continue;
key.name = node->section ? node->section : "Miscellaneous";
if ((section = (_cups_section_t *)cupsArrayFind(sections, &key)) == NULL)
{
section = (_cups_section_t *)calloc(1, sizeof(_cups_section_t));
section->name = key.name;
section->files = cupsArrayNew((cups_array_func_t)compare_html, NULL);
cupsArrayAdd(sections, section);
}
html = (_cups_html_t *)calloc(1, sizeof(_cups_html_t));
html->path = node->filename;
html->title = node->text;
cupsArrayAdd(section->files, html);
}
/*
* Build a sorted list of sections based on the number of files in each section
* and the section name...
*/
sections_files = cupsArrayNew((cups_array_func_t)compare_sections_files,
NULL);
for (section = (_cups_section_t *)cupsArrayFirst(sections);
section;
section = (_cups_section_t *)cupsArrayNext(sections))
cupsArrayAdd(sections_files, section);
/*
* Then build three columns to hold everything, trying to balance the number of
* lines in each column...
*/
for (column = 0; column < 3; column ++)
{
columns[column] = cupsArrayNew((cups_array_func_t)compare_sections, NULL);
lines[column] = 0;
}
for (section = (_cups_section_t *)cupsArrayFirst(sections_files);
section;
section = (_cups_section_t *)cupsArrayNext(sections_files))
{
for (min_column = 0, min_lines = lines[0], column = 1;
column < 3;
column ++)
{
if (lines[column] < min_lines)
{
min_column = column;
min_lines = lines[column];
}
}
cupsArrayAdd(columns[min_column], section);
lines[min_column] += cupsArrayCount(section->files) + 2;
}
/*
* Write the HTML file...
*/
if ((fp = cupsFileOpen(path, "w")) == NULL)
{
fprintf(stderr, "makedocset: Unable to create %s: %s\n", path,
strerror(errno));
exit(1);
}
cupsFilePuts(fp, "<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 "
"Transitional//EN\" "
"\"http://www.w3.org/TR/html4/loose.dtd\">\n"
"<html>\n"
"<head>\n"
"<title>CUPS Documentation</title>\n"
"<link rel='stylesheet' type='text/css' "
"href='cups-printable.css'>\n"
"</head>\n"
"<body>\n"
"<h1 class='title'>CUPS Documentation</h1>\n"
"<table width='100%' summary=''>\n"
"<tr>\n");
for (column = 0; column < 3; column ++)
{
if (column)
cupsFilePuts(fp, "<td>&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</td>\n");
cupsFilePuts(fp, "<td valign='top' width='33%'>");
for (section = (_cups_section_t *)cupsArrayFirst(columns[column]);
section;
section = (_cups_section_t *)cupsArrayNext(columns[column]))
{
cupsFilePrintf(fp, "<h2 class='title'>%s</h2>\n", section->name);
for (html = (_cups_html_t *)cupsArrayFirst(section->files);
html;
html = (_cups_html_t *)cupsArrayNext(section->files))
cupsFilePrintf(fp, "<p class='compact'><a href='%s'>%s</a></p>\n",
html->path, html->title);
}
cupsFilePuts(fp, "</td>\n");
}
cupsFilePuts(fp, "</tr>\n"
"</table>\n"
"</body>\n"
"</html>\n");
cupsFileClose(fp);
}
/*
* 'write_info()' - Write the Info.plist file.
*/
static void
write_info(const char *path, /* I - File to write */
const char *revision) /* I - Subversion revision number */
{
cups_file_t *fp; /* File */
if ((fp = cupsFileOpen(path, "w")) == NULL)
{
fprintf(stderr, "makedocset: Unable to create %s: %s\n", path,
strerror(errno));
exit(1);
}
cupsFilePrintf(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" "
"\"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n"
"<plist version=\"1.0\">\n"
"<dict>\n"
"\t<key>CFBundleIdentifier</key>\n"
"\t<string>org.cups.docset</string>\n"
"\t<key>CFBundleName</key>\n"
"\t<string>CUPS Documentation</string>\n"
"\t<key>CFBundleVersion</key>\n"
"\t<string>%d.%d.%s</string>\n"
"\t<key>CFBundleShortVersionString</key>\n"
"\t<string>%d.%d.%d</string>\n"
"\t<key>DocSetFeedName</key>\n"
"\t<string>cups.org</string>\n"
"\t<key>DocSetFeedURL</key>\n"
"\t<string>http://www.cups.org/org.cups.docset.atom"
"</string>\n"
"\t<key>DocSetPublisherIdentifier</key>\n"
"\t<string>org.cups</string>\n"
"\t<key>DocSetPublisherName</key>\n"
"\t<string>CUPS</string>\n"
"</dict>\n"
"</plist>\n",
CUPS_VERSION_MAJOR, CUPS_VERSION_MINOR, revision,
CUPS_VERSION_MAJOR, CUPS_VERSION_MINOR, CUPS_VERSION_PATCH);
cupsFileClose(fp);
}
/*
* 'write_nodes()' - Write the Nodes.xml file.
*/
static void
write_nodes(const char *path, /* I - File to write */
help_index_t *hi) /* I - Index of files */
{
cups_file_t *fp; /* Output file */
int id; /* Current node ID */
help_node_t *node; /* Current help node */
int subnodes; /* Currently in Subnodes for file? */
int needclose; /* Need to close the current node? */
if ((fp = cupsFileOpen(path, "w")) == NULL)
{
fprintf(stderr, "makedocset: Unable to create %s: %s\n", path,
strerror(errno));
exit(1);
}
cupsFilePuts(fp, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
"<DocSetNodes version=\"1.0\">\n"
"<TOC>\n"
"<Node id=\"0\">\n"
"<Name>CUPS Documentation</Name>\n"
"<Path>Documentation/index.html</Path>\n"
"</Node>\n");
for (node = (help_node_t *)cupsArrayFirst(hi->nodes), id = 1, subnodes = 0,
needclose = 0;
node;
node = (help_node_t *)cupsArrayNext(hi->nodes), id ++)
{
if (node->anchor)
{
if (!subnodes)
{
cupsFilePuts(fp, "<Subnodes>\n");
subnodes = 1;
}
cupsFilePrintf(fp, "<Node id=\"%d\">\n"
"<Path>Documentation/%s</Path>\n"
"<Anchor>%s</Anchor>\n"
"<Name>%s</Name>\n"
"</Node>\n", id, node->filename, node->anchor,
node->text);
}
else
{
if (subnodes)
{
cupsFilePuts(fp, "</Subnodes>\n");
subnodes = 0;
}
if (needclose)
cupsFilePuts(fp, "</Node>\n");
cupsFilePrintf(fp, "<Node id=\"%d\">\n"
"<Path>Documentation/%s</Path>\n"
"<Name>%s</Name>\n", id, node->filename, node->text);
needclose = 1;
}
}
if (subnodes)
cupsFilePuts(fp, "</Subnodes>\n");
if (needclose)
cupsFilePuts(fp, "</Node>\n");
cupsFilePuts(fp, "</TOC>\n"
"</DocSetNodes>\n");
cupsFileClose(fp);
}
+2 -1
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Search routines for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -365,4 +365,5 @@ void
cgiFreeSearch(void *search) /* I - Search context */
{
regfree((regex_t *)search);
free(search);
}
+2 -6
Ver Arquivo
@@ -18,7 +18,6 @@
/*#define DEBUG*/
#include "cgi-private.h"
#include <cups/http.h>
#include <cups/md5-private.h>
/*
@@ -1204,7 +1203,6 @@ cgi_set_sid(void)
{
char buffer[512], /* SID data */
sid[33]; /* SID string */
_cups_md5_state_t md5; /* MD5 state */
unsigned char sum[16]; /* MD5 sum */
const char *remote_addr, /* REMOTE_ADDR */
*server_name, /* SERVER_NAME */
@@ -1225,11 +1223,9 @@ cgi_set_sid(void)
(unsigned)CUPS_RAND() & 255, (unsigned)CUPS_RAND() & 255,
(unsigned)CUPS_RAND() & 255, (unsigned)CUPS_RAND() & 255,
(unsigned)CUPS_RAND() & 255, (unsigned)CUPS_RAND() & 255);
_cupsMD5Init(&md5);
_cupsMD5Append(&md5, (unsigned char *)buffer, (int)strlen(buffer));
_cupsMD5Finish(&md5, sum);
cupsHashData("md5", (unsigned char *)buffer, strlen(buffer), sum, sizeof(sum));
cgiSetCookie(CUPS_SID, httpMD5String(sum, sid), "/", NULL, 0, 0);
cgiSetCookie(CUPS_SID, cupsHashString(sum, sizeof(sum), sid, sizeof(sid)), "/", NULL, 0, 0);
return (cupsGetOption(CUPS_SID, num_cookies, cookies));
}
+4 -8
Ver Arquivo
@@ -45,6 +45,7 @@ AC_PATH_PROG(CHMOD,chmod)
AC_PATH_PROG(GZIP,gzip)
AC_PATH_PROG(LD,ld)
AC_PATH_PROG(LN,ln)
AC_PATH_PROG(MKDIR,mkdir)
AC_PATH_PROG(MV,mv)
AC_PATH_PROG(RM,rm)
AC_PATH_PROG(RMDIR,rmdir)
@@ -305,7 +306,7 @@ fi
LIBS="$SAVELIBS"
dnl Check for DBUS support
AC_ARG_ENABLE(dbus, [ --disable-dbus build without DBUS support])
AC_ARG_ENABLE(dbus, [ --disable-dbus build without DBUS support])
AC_ARG_WITH(dbusdir, [ --with-dbusdir set DBUS configuration directory ],
DBUSDIR="$withval")
@@ -388,20 +389,15 @@ case $host_os_name in
if test "x$default_adminkey" != xdefault; then
CUPS_SYSTEM_AUTHKEY="SystemGroupAuthKey $default_adminkey"
CUPS_DEFAULT_SYSTEM_AUTHKEY="$default_adminkey"
elif grep -q system.print.operator /etc/authorization; then
else
CUPS_SYSTEM_AUTHKEY="SystemGroupAuthKey system.print.admin"
CUPS_DEFAULT_SYSTEM_AUTHKEY="system.print.admin"
else
CUPS_SYSTEM_AUTHKEY="SystemGroupAuthKey system.preferences"
CUPS_DEFAULT_SYSTEM_AUTHKEY="system.preferences"
fi
if test "x$default_operkey" != xdefault; then
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY($default_operkey) @admin @lpadmin"
elif grep -q system.print.operator /etc/authorization; then
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY(system.print.operator) @admin @lpadmin"
else
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY(system.print.admin) @admin @lpadmin"
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY(system.print.operator) @admin @lpadmin"
fi])
AC_CHECK_HEADER(Security/SecBasePriv.h,AC_DEFINE(HAVE_SECBASEPRIV_H))
+11 -29
Ver Arquivo
@@ -1,7 +1,7 @@
dnl
dnl Compiler stuff for CUPS.
dnl
dnl Copyright 2007-2017 by Apple Inc.
dnl Copyright 2007-2018 by Apple Inc.
dnl Copyright 1997-2007 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
@@ -156,37 +156,19 @@ if test -n "$GCC"; then
if test "x$with_optim" = x; then
# Add useful warning options for tracking down problems...
OPTIM="-Wall -Wno-format-y2k -Wunused $OPTIM"
OPTIM="-Wall -Wno-format-y2k -Wunused -Wno-unused-result -Wsign-conversion $OPTIM"
AC_MSG_CHECKING(whether compiler supports -Wno-unused-result)
OLDCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror -Wno-unused-result"
AC_TRY_COMPILE(,,
[OPTIM="$OPTIM -Wno-unused-result"
AC_MSG_RESULT(yes)],
AC_MSG_RESULT(no))
CFLAGS="$OLDCFLAGS"
AC_MSG_CHECKING(whether compiler supports -Wsign-conversion)
OLDCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror -Wsign-conversion"
AC_TRY_COMPILE(,,
[OPTIM="$OPTIM -Wsign-conversion"
AC_MSG_RESULT(yes)],
AC_MSG_RESULT(no))
CFLAGS="$OLDCFLAGS"
AC_MSG_CHECKING(whether compiler supports -Wno-tautological-compare)
OLDCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror -Wno-tautological-compare"
AC_TRY_COMPILE(,,
[OPTIM="$OPTIM -Wno-tautological-compare"
AC_MSG_RESULT(yes)],
AC_MSG_RESULT(no))
CFLAGS="$OLDCFLAGS"
# Test GCC version for certain warning flags since -Werror
# doesn't trigger...
gccversion=`$CC --version | head -1 | awk '{print $NF}'`
case "$gccversion" in
7.*)
OPTIM="$OPTIM -Wno-format-truncation -Wno-tautological-compare"
;;
esac
# Additional warning options for development testing...
if test -d .svn; then
if test -d .git; then
OPTIM="-Werror $OPTIM"
fi
fi
+1 -1
Ver Arquivo
@@ -38,7 +38,7 @@ if test "x$CUPS_BUNDLEDIR" != x; then
fi
dnl Default executable file permissions
AC_ARG_WITH(exe_file_perm, [ --with-exe-file-perm set default exectuable permissions value, default=0555],
AC_ARG_WITH(exe_file_perm, [ --with-exe-file-perm set default executable permissions value, default=0555],
CUPS_EXE_FILE_PERM="$withval",
[case "$host_os_name" in
linux* | gnu*)
+36 -5
Ver Arquivo
@@ -1,7 +1,7 @@
dnl
dnl Libtool stuff for CUPS.
dnl
dnl Copyright 2007-2011 by Apple Inc.
dnl Copyright 2007-2017 by Apple Inc.
dnl Copyright 1997-2005 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
@@ -11,9 +11,12 @@ dnl which should have been included with this file. If this file is
dnl missing or damaged, see the license at "http://www.cups.org/".
dnl
AC_ARG_ENABLE(libtool_unsupported, [ --enable-libtool-unsupported
AC_ARG_ENABLE(libtool_unsupported, [ --enable-libtool-unsupported=/path/to/libtool
build with libtool (UNSUPPORTED!)],
[if test x$enable_libtool_unsupported != xno; then
if test x$enable_libtool_unsupported == xyes; then
AC_MSG_ERROR([Use --enable-libtool-unsupported=/path/to/libtool.])
fi
LIBTOOL="$enable_libtool_unsupported"
enable_shared=no
echo "WARNING: libtool is not supported or endorsed by Apple Inc."
@@ -22,12 +25,40 @@ AC_ARG_ENABLE(libtool_unsupported, [ --enable-libtool-unsupported
LIBTOOL=""
fi])
AC_SUBST(LIBTOOL)
if test x$LIBTOOL != x; then
DSO="\$(LIBTOOL) --mode=link --tag=CC ${CC}"
DSOXX="\$(LIBTOOL) --mode=link --tag=CXX ${CXX}"
LD_CC="\$(LIBTOOL) --mode=link --tag=CC ${CC}"
LD_CXX="\$(LIBTOOL) --mode=link --tag=CXX ${CXX}"
LIBCUPS="libcups.la"
LIBCUPSSTATIC="libcups.la"
LIBCUPSCGI="libcupscgi.la"
LIBCUPSIMAGE="libcupsimage.la"
LIBCUPSMIME="libcupsmime.la"
LIBCUPSPPDC="libcupsppdc.la"
LIBTOOL_CC="\$(LIBTOOL) --mode=compile --tag=CC"
LIBTOOL_CXX="\$(LIBTOOL) --mode=compile --tag=CXX"
LIBTOOL_INSTALL="\$(LIBTOOL) --mode=install"
LINKCUPS="../cups/\$(LIBCUPS)"
LINKCUPSIMAGE="../filter/\$(LIBCUPSIMAGE)"
DSO="\$(CC)"
else
LD_CC="\$(CC)"
LD_CXX="\$(CXX)"
LIBTOOL_CC=""
LIBTOOL_CXX=""
LIBTOOL_INSTALL=""
fi
AC_SUBST(LD_CC)
AC_SUBST(LD_CXX)
AC_SUBST(LIBTOOL)
AC_SUBST(LIBTOOL_CC)
AC_SUBST(LIBTOOL_CXX)
AC_SUBST(LIBTOOL_INSTALL)
+3 -1
Ver Arquivo
@@ -1,7 +1,7 @@
dnl
dnl Operating system stuff for CUPS.
dnl
dnl Copyright 2007-2017 by Apple Inc.
dnl Copyright 2007-2018 by Apple Inc.
dnl Copyright 1997-2006 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
@@ -35,3 +35,5 @@ else
LOCALTARGET=""
fi
AC_SUBST(LOCALTARGET)
AC_PATH_PROGS(CODE_SIGN, codesign true)
+1 -1
Ver Arquivo
@@ -12,7 +12,7 @@ dnl missing or damaged, see the license at "http://www.cups.org/".
dnl
AC_ARG_ENABLE(pam, [ --disable-pam disable PAM support])
AC_ARG_WITH(pam_module, [ --with-pam-module specify the PAM module to use])
AC_ARG_WITH(pam_module, [ --with-pam-module set the PAM module to use])
PAMDIR=""
PAMFILE="pam.std"
+17 -9
Ver Arquivo
@@ -1,7 +1,7 @@
dnl
dnl Scripting configuration stuff for CUPS.
dnl
dnl Copyright 2007-2010 by Apple Inc.
dnl Copyright 2007-2017 by Apple Inc.
dnl Copyright 1997-2006 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
@@ -14,11 +14,13 @@ dnl
dnl Do we have Java?
AC_ARG_WITH(java, [ --with-java set Java interpreter for web interfaces ],
CUPS_JAVA="$withval",
CUPS_JAVA="")
CUPS_JAVA="auto")
if test "x$CUPS_JAVA" = x; then
if test "x$CUPS_JAVA" = xauto; then
AC_PATH_PROG(JAVA,java)
CUPS_JAVA="$JAVA"
elif test "x$CUPS_JAVA" = xno; then
CUPS_JAVA=""
fi
AC_DEFINE_UNQUOTED(CUPS_JAVA, "$CUPS_JAVA")
@@ -30,11 +32,13 @@ fi
dnl Do we have Perl?
AC_ARG_WITH(perl, [ --with-perl set Perl interpreter for web interfaces ],
CUPS_PERL="$withval",
CUPS_PERL="")
CUPS_PERL="auto")
if test "x$CUPS_PERL" = x; then
if test "x$CUPS_PERL" = xauto; then
AC_PATH_PROG(PERL,perl)
CUPS_PERL="$PERL"
elif test "x$CUPS_PERL" = xno; then
CUPS_PERL=""
fi
AC_DEFINE_UNQUOTED(CUPS_PERL, "$CUPS_PERL")
@@ -46,9 +50,9 @@ fi
dnl Do we have PHP?
AC_ARG_WITH(php, [ --with-php set PHP interpreter for web interfaces ],
CUPS_PHP="$withval",
CUPS_PHP="")
CUPS_PHP="auto")
if test "x$CUPS_PHP" = x; then
if test "x$CUPS_PHP" = xauto; then
AC_PATH_PROG(PHPCGI,php-cgi)
if test "x$PHPCGI" = x; then
AC_PATH_PROG(PHP,php)
@@ -56,6 +60,8 @@ if test "x$CUPS_PHP" = x; then
else
CUPS_PHP="$PHPCGI"
fi
elif test "x$CUPS_PHP" = xno; then
CUPS_PHP=""
fi
AC_DEFINE_UNQUOTED(CUPS_PHP, "$CUPS_PHP")
@@ -69,11 +75,13 @@ fi
dnl Do we have Python?
AC_ARG_WITH(python, [ --with-python set Python interpreter for web interfaces ],
CUPS_PYTHON="$withval",
CUPS_PYTHON="")
CUPS_PYTHON="auto")
if test "x$CUPS_PYTHON" = x; then
if test "x$CUPS_PYTHON" = xauto; then
AC_PATH_PROG(PYTHON,python)
CUPS_PYTHON="$PYTHON"
elif test "x$CUPS_PYTHON" = xno; then
CUPS_PYTHON=""
fi
AC_DEFINE_UNQUOTED(CUPS_PYTHON, "$CUPS_PYTHON")
+1 -19
Ver Arquivo
@@ -1,7 +1,7 @@
dnl
dnl Shared library support for CUPS.
dnl
dnl Copyright 2007-2017 by Apple Inc.
dnl Copyright 2007-2018 by Apple Inc.
dnl Copyright 1997-2005 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
@@ -24,30 +24,21 @@ if test x$enable_shared != xno; then
case "$host_os_name" in
sunos*)
LIBCUPS="lib$cupsbase.so.2"
LIBCUPSCGI="libcupscgi.so.1"
LIBCUPSIMAGE="libcupsimage.so.2"
LIBCUPSMIME="libcupsmime.so.1"
LIBCUPSPPDC="libcupsppdc.so.1"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -Wl,-h\`basename \$@\` -G \$(OPTIM)"
;;
linux* | gnu* | *bsd*)
LIBCUPS="lib$cupsbase.so.2"
LIBCUPSCGI="libcupscgi.so.1"
LIBCUPSIMAGE="libcupsimage.so.2"
LIBCUPSMIME="libcupsmime.so.1"
LIBCUPSPPDC="libcupsppdc.so.1"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -Wl,-soname,\`basename \$@\` -shared \$(OPTIM)"
;;
darwin*)
LIBCUPS="lib$cupsbase.2.dylib"
LIBCUPSCGI="libcupscgi.1.dylib"
LIBCUPSIMAGE="libcupsimage.2.dylib"
LIBCUPSMIME="libcupsmime.1.dylib"
LIBCUPSPPDC="libcupsppdc.1.dylib"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -dynamiclib -single_module -lc"
@@ -56,10 +47,7 @@ if test x$enable_shared != xno; then
echo "Warning: shared libraries may not be supported. Trying -shared"
echo " option with compiler."
LIBCUPS="lib$cupsbase.so.2"
LIBCUPSCGI="libcupscgi.so.1"
LIBCUPSIMAGE="libcupsimage.so.2"
LIBCUPSMIME="libcupsmime.so.1"
LIBCUPSPPDC="libcupsppdc.so.1"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -Wl,-soname,\`basename \$@\` -shared \$(OPTIM)"
@@ -68,10 +56,7 @@ if test x$enable_shared != xno; then
else
PICFLAG=0
LIBCUPS="lib$cupsbase.a"
LIBCUPSCGI="libcupscgi.a"
LIBCUPSIMAGE="libcupsimage.a"
LIBCUPSMIME="libcupsmime.a"
LIBCUPSPPDC="libcupsppdc.a"
DSO=":"
DSOXX=":"
fi
@@ -81,10 +66,7 @@ AC_SUBST(DSOXX)
AC_SUBST(DSOFLAGS)
AC_SUBST(LIBCUPS)
AC_SUBST(LIBCUPSBASE)
AC_SUBST(LIBCUPSCGI)
AC_SUBST(LIBCUPSIMAGE)
AC_SUBST(LIBCUPSMIME)
AC_SUBST(LIBCUPSPPDC)
AC_SUBST(LIBCUPSSTATIC)
if test x$enable_shared = xno; then
-1
Ver Arquivo
@@ -61,7 +61,6 @@ if test x$enable_ssl != xno; then
dnl Then look for GNU TLS...
if test $have_ssl = 0 -a "x$enable_gnutls" != "xno" -a "x$PKGCONFIG" != x; then
AC_PATH_TOOL(LIBGNUTLSCONFIG,libgnutls-config)
AC_PATH_TOOL(LIBGCRYPTCONFIG,libgcrypt-config)
if $PKGCONFIG --exists gnutls; then
have_ssl=1
SSLLIBS=`$PKGCONFIG --libs gnutls`
+1 -1
Ver Arquivo
@@ -78,7 +78,7 @@ if test x$enable_systemd != xno; then
fi
dnl Upstart is also used on Linux (e.g., Chrome OS)
AC_ARG_ENABLE(upstart, [ --enable-upstart enable upstart support])
AC_ARG_ENABLE(upstart, [ --enable-upstart enable upstart support])
if test "x$enable_upstart" = "xyes"; then
if test "x$have_systemd" = "xyes"; then
AC_MSG_ERROR(Cannot support both systemd and upstart.)
externo
+170 -232
Ver Arquivo
@@ -1,6 +1,6 @@
#! /bin/sh
# Guess values for system-dependent variables and create Makefiles.
# Generated by GNU Autoconf 2.68 for CUPS 2.2.4.
# Generated by GNU Autoconf 2.68 for CUPS 2.2.9.
#
# Report bugs to <https://github.com/apple/cups/issues>.
#
@@ -560,8 +560,8 @@ MAKEFLAGS=
# Identity of this package.
PACKAGE_NAME='CUPS'
PACKAGE_TARNAME='cups'
PACKAGE_VERSION='2.2.4'
PACKAGE_STRING='CUPS 2.2.4'
PACKAGE_VERSION='2.2.9'
PACKAGE_STRING='CUPS 2.2.9'
PACKAGE_BUGREPORT='https://github.com/apple/cups/issues'
PACKAGE_URL='https://www.cups.org/'
@@ -663,7 +663,6 @@ SSLLIBS
SSLFLAGS
IPPALIASES
CUPS_SERVERKEYCHAIN
LIBGCRYPTCONFIG
LIBGNUTLSCONFIG
PTHREAD_FLAGS
CUPS_DEFAULT_GSSSERVICENAME
@@ -679,7 +678,12 @@ ARCHFLAGS
UNITTESTS
OPTIM
INSTALL_STRIP
LIBTOOL_INSTALL
LIBTOOL_CXX
LIBTOOL_CC
LIBTOOL
LD_CXX
LD_CC
EXPORT_LDFLAGS
IMGLIBS
DSOLIBS
@@ -688,10 +692,7 @@ LINKCUPS
EXTLINKCUPSIMAGE
EXTLINKCUPS
LIBCUPSSTATIC
LIBCUPSPPDC
LIBCUPSMIME
LIBCUPSIMAGE
LIBCUPSCGI
LIBCUPSBASE
LIBCUPS
DSOFLAGS
@@ -748,6 +749,7 @@ SED
RMDIR
RM
MV
MKDIR
LN
LD
GZIP
@@ -769,6 +771,7 @@ AWK
CUPS_BUILD
CUPS_REVISION
CUPS_VERSION
CODE_SIGN
LOCALTARGET
host_os
host_vendor
@@ -1459,7 +1462,7 @@ if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
\`configure' configures CUPS 2.2.4 to adapt to many kinds of systems.
\`configure' configures CUPS 2.2.9 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
@@ -1524,7 +1527,7 @@ fi
if test -n "$ac_init_help"; then
case $ac_init_help in
short | recursive ) echo "Configuration of CUPS 2.2.4:";;
short | recursive ) echo "Configuration of CUPS 2.2.9:";;
esac
cat <<\_ACEOF
@@ -1538,9 +1541,9 @@ Optional Features:
--enable-libusb use libusb for USB printing
--enable-tcp-wrappers use libwrap for TCP wrappers support
--enable-acl build with POSIX ACL support
--disable-dbus build without DBUS support
--disable-dbus build without DBUS support
--disable-shared do not create shared libraries
--enable-libtool-unsupported
--enable-libtool-unsupported=/path/to/libtool
build with libtool (UNSUPPORTED!)
--enable-debug build with debugging symbols
--enable-debug-guards build with memory allocation guards
@@ -1558,7 +1561,7 @@ Optional Features:
--disable-dnssd disable DNS Service Discovery support using mDNSResponder
--disable-launchd disable launchd support
--disable-systemd disable systemd support
--enable-upstart enable upstart support
--enable-upstart enable upstart support
--enable-page-logging enable page_log by default
--disable-browsing disable Browsing by default
--disable-default-shared
@@ -1591,7 +1594,7 @@ Optional Packages:
--with-ldarchflags set program architecture flags
--with-domainsocket set unix domain socket name
--with-gssservicename set default gss service name
--with-pam-module specify the PAM module to use
--with-pam-module set the PAM module to use
--with-dnssd-libs set directory for DNS Service Discovery library
--with-dnssd-includes set directory for DNS Service Discovery includes
--with-systemd set directory for systemd service files
@@ -1603,7 +1606,7 @@ Optional Packages:
--with-xinetd set path for xinetd config files
--with-languages set installed languages, default=all
--with-bundledir set macOS localization bundle directory
--with-exe-file-perm set default exectuable permissions value, default=0555
--with-exe-file-perm set default executable permissions value, default=0555
--with-config-file-perm set default ConfigFilePerm value, default=0640
--with-cupsd-file-perm set default cupsd permissions, default=0500
--with-log-file-perm set default LogFilePerm value, default=0644
@@ -1705,7 +1708,7 @@ fi
test -n "$ac_init_help" && exit $ac_status
if $ac_init_version; then
cat <<\_ACEOF
CUPS configure 2.2.4
CUPS configure 2.2.9
generated by GNU Autoconf 2.68
Copyright (C) 2010 Free Software Foundation, Inc.
@@ -2169,7 +2172,7 @@ cat >config.log <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
It was created by CUPS $as_me 2.2.4, which was
It was created by CUPS $as_me 2.2.9, which was
generated by GNU Autoconf 2.68. Invocation command line was
$ $0 $@
@@ -2640,11 +2643,57 @@ else
fi
for ac_prog in codesign true
do
# Extract the first word of "$ac_prog", so it can be a program name with args.
set dummy $ac_prog; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_CODE_SIGN+:} false; then :
$as_echo_n "(cached) " >&6
else
case $CODE_SIGN in
[\\/]* | ?:[\\/]*)
ac_cv_path_CODE_SIGN="$CODE_SIGN" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_path_CODE_SIGN="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
CODE_SIGN=$ac_cv_path_CODE_SIGN
if test -n "$CODE_SIGN"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODE_SIGN" >&5
$as_echo "$CODE_SIGN" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
test -n "$CODE_SIGN" && break
done
ac_config_headers="$ac_config_headers config.h"
CUPS_VERSION="2.2.4"
CUPS_VERSION="2.2.9"
CUPS_REVISION=""
CUPS_BUILD="cups-$CUPS_VERSION"
@@ -3998,6 +4047,46 @@ $as_echo "no" >&6; }
fi
# Extract the first word of "mkdir", so it can be a program name with args.
set dummy mkdir; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_MKDIR+:} false; then :
$as_echo_n "(cached) " >&6
else
case $MKDIR in
[\\/]* | ?:[\\/]*)
ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
MKDIR=$ac_cv_path_MKDIR
if test -n "$MKDIR"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
$as_echo "$MKDIR" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
# Extract the first word of "mv", so it can be a program name with args.
set dummy mv; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
@@ -5940,20 +6029,15 @@ if test "x$ac_cv_header_Security_Authorization_h" = xyes; then :
if test "x$default_adminkey" != xdefault; then
CUPS_SYSTEM_AUTHKEY="SystemGroupAuthKey $default_adminkey"
CUPS_DEFAULT_SYSTEM_AUTHKEY="$default_adminkey"
elif grep -q system.print.operator /etc/authorization; then
else
CUPS_SYSTEM_AUTHKEY="SystemGroupAuthKey system.print.admin"
CUPS_DEFAULT_SYSTEM_AUTHKEY="system.print.admin"
else
CUPS_SYSTEM_AUTHKEY="SystemGroupAuthKey system.preferences"
CUPS_DEFAULT_SYSTEM_AUTHKEY="system.preferences"
fi
if test "x$default_operkey" != xdefault; then
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY($default_operkey) @admin @lpadmin"
elif grep -q system.print.operator /etc/authorization; then
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY(system.print.operator) @admin @lpadmin"
else
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY(system.print.admin) @admin @lpadmin"
CUPS_DEFAULT_PRINTOPERATOR_AUTH="@AUTHKEY(system.print.operator) @admin @lpadmin"
fi
fi
@@ -6522,30 +6606,21 @@ if test x$enable_shared != xno; then
case "$host_os_name" in
sunos*)
LIBCUPS="lib$cupsbase.so.2"
LIBCUPSCGI="libcupscgi.so.1"
LIBCUPSIMAGE="libcupsimage.so.2"
LIBCUPSMIME="libcupsmime.so.1"
LIBCUPSPPDC="libcupsppdc.so.1"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -Wl,-h\`basename \$@\` -G \$(OPTIM)"
;;
linux* | gnu* | *bsd*)
LIBCUPS="lib$cupsbase.so.2"
LIBCUPSCGI="libcupscgi.so.1"
LIBCUPSIMAGE="libcupsimage.so.2"
LIBCUPSMIME="libcupsmime.so.1"
LIBCUPSPPDC="libcupsppdc.so.1"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -Wl,-soname,\`basename \$@\` -shared \$(OPTIM)"
;;
darwin*)
LIBCUPS="lib$cupsbase.2.dylib"
LIBCUPSCGI="libcupscgi.1.dylib"
LIBCUPSIMAGE="libcupsimage.2.dylib"
LIBCUPSMIME="libcupsmime.1.dylib"
LIBCUPSPPDC="libcupsppdc.1.dylib"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -dynamiclib -single_module -lc"
@@ -6554,10 +6629,7 @@ if test x$enable_shared != xno; then
echo "Warning: shared libraries may not be supported. Trying -shared"
echo " option with compiler."
LIBCUPS="lib$cupsbase.so.2"
LIBCUPSCGI="libcupscgi.so.1"
LIBCUPSIMAGE="libcupsimage.so.2"
LIBCUPSMIME="libcupsmime.so.1"
LIBCUPSPPDC="libcupsppdc.so.1"
DSO="\$(CC)"
DSOXX="\$(CXX)"
DSOFLAGS="$DSOFLAGS -Wl,-soname,\`basename \$@\` -shared \$(OPTIM)"
@@ -6566,10 +6638,7 @@ if test x$enable_shared != xno; then
else
PICFLAG=0
LIBCUPS="lib$cupsbase.a"
LIBCUPSCGI="libcupscgi.a"
LIBCUPSIMAGE="libcupsimage.a"
LIBCUPSMIME="libcupsmime.a"
LIBCUPSPPDC="libcupsppdc.a"
DSO=":"
DSOXX=":"
fi
@@ -6582,9 +6651,6 @@ fi
if test x$enable_shared = xno; then
LINKCUPS="../cups/lib$cupsbase.a"
LINKCUPSIMAGE="../filter/libcupsimage.a"
@@ -6656,6 +6722,9 @@ fi
# Check whether --enable-libtool_unsupported was given.
if test "${enable_libtool_unsupported+set}" = set; then :
enableval=$enable_libtool_unsupported; if test x$enable_libtool_unsupported != xno; then
if test x$enable_libtool_unsupported == xyes; then
as_fn_error $? "Use --enable-libtool-unsupported=/path/to/libtool." "$LINENO" 5
fi
LIBTOOL="$enable_libtool_unsupported"
enable_shared=no
echo "WARNING: libtool is not supported or endorsed by Apple Inc."
@@ -6666,17 +6735,45 @@ if test "${enable_libtool_unsupported+set}" = set; then :
fi
if test x$LIBTOOL != x; then
DSO="\$(LIBTOOL) --mode=link --tag=CC ${CC}"
DSOXX="\$(LIBTOOL) --mode=link --tag=CXX ${CXX}"
LD_CC="\$(LIBTOOL) --mode=link --tag=CC ${CC}"
LD_CXX="\$(LIBTOOL) --mode=link --tag=CXX ${CXX}"
LIBCUPS="libcups.la"
LIBCUPSSTATIC="libcups.la"
LIBCUPSCGI="libcupscgi.la"
LIBCUPSIMAGE="libcupsimage.la"
LIBCUPSMIME="libcupsmime.la"
LIBCUPSPPDC="libcupsppdc.la"
LIBTOOL_CC="\$(LIBTOOL) --mode=compile --tag=CC"
LIBTOOL_CXX="\$(LIBTOOL) --mode=compile --tag=CXX"
LIBTOOL_INSTALL="\$(LIBTOOL) --mode=install"
LINKCUPS="../cups/\$(LIBCUPS)"
LINKCUPSIMAGE="../filter/\$(LIBCUPSIMAGE)"
DSO="\$(CC)"
else
LD_CC="\$(CC)"
LD_CXX="\$(CXX)"
LIBTOOL_CC=""
LIBTOOL_CXX=""
LIBTOOL_INSTALL=""
fi
INSTALL_STRIP=""
OPTIM=""
@@ -6900,88 +6997,19 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
if test "x$with_optim" = x; then
# Add useful warning options for tracking down problems...
OPTIM="-Wall -Wno-format-y2k -Wunused $OPTIM"
OPTIM="-Wall -Wno-format-y2k -Wunused -Wno-unused-result -Wsign-conversion $OPTIM"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wno-unused-result" >&5
$as_echo_n "checking whether compiler supports -Wno-unused-result... " >&6; }
OLDCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror -Wno-unused-result"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
OPTIM="$OPTIM -Wno-unused-result"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
CFLAGS="$OLDCFLAGS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wsign-conversion" >&5
$as_echo_n "checking whether compiler supports -Wsign-conversion... " >&6; }
OLDCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror -Wsign-conversion"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
OPTIM="$OPTIM -Wsign-conversion"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
CFLAGS="$OLDCFLAGS"
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether compiler supports -Wno-tautological-compare" >&5
$as_echo_n "checking whether compiler supports -Wno-tautological-compare... " >&6; }
OLDCFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -Werror -Wno-tautological-compare"
cat confdefs.h - <<_ACEOF >conftest.$ac_ext
/* end confdefs.h. */
int
main ()
{
;
return 0;
}
_ACEOF
if ac_fn_c_try_compile "$LINENO"; then :
OPTIM="$OPTIM -Wno-tautological-compare"
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
$as_echo "yes" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
CFLAGS="$OLDCFLAGS"
# Test GCC version for certain warning flags since -Werror
# doesn't trigger...
gccversion=`$CC --version | head -1 | awk '{print $NF}'`
case "$gccversion" in
7.*)
OPTIM="$OPTIM -Wno-format-truncation -Wno-tautological-compare"
;;
esac
# Additional warning options for development testing...
if test -d .svn; then
if test -d .git; then
OPTIM="-Werror $OPTIM"
fi
fi
@@ -8411,104 +8439,6 @@ else
LIBGNUTLSCONFIG="$ac_cv_path_LIBGNUTLSCONFIG"
fi
if test -n "$ac_tool_prefix"; then
# Extract the first word of "${ac_tool_prefix}libgcrypt-config", so it can be a program name with args.
set dummy ${ac_tool_prefix}libgcrypt-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_LIBGCRYPTCONFIG+:} false; then :
$as_echo_n "(cached) " >&6
else
case $LIBGCRYPTCONFIG in
[\\/]* | ?:[\\/]*)
ac_cv_path_LIBGCRYPTCONFIG="$LIBGCRYPTCONFIG" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_path_LIBGCRYPTCONFIG="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
LIBGCRYPTCONFIG=$ac_cv_path_LIBGCRYPTCONFIG
if test -n "$LIBGCRYPTCONFIG"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIBGCRYPTCONFIG" >&5
$as_echo "$LIBGCRYPTCONFIG" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
fi
if test -z "$ac_cv_path_LIBGCRYPTCONFIG"; then
ac_pt_LIBGCRYPTCONFIG=$LIBGCRYPTCONFIG
# Extract the first word of "libgcrypt-config", so it can be a program name with args.
set dummy libgcrypt-config; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
$as_echo_n "checking for $ac_word... " >&6; }
if ${ac_cv_path_ac_pt_LIBGCRYPTCONFIG+:} false; then :
$as_echo_n "(cached) " >&6
else
case $ac_pt_LIBGCRYPTCONFIG in
[\\/]* | ?:[\\/]*)
ac_cv_path_ac_pt_LIBGCRYPTCONFIG="$ac_pt_LIBGCRYPTCONFIG" # Let the user override the test with a path.
;;
*)
as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
for as_dir in $PATH
do
IFS=$as_save_IFS
test -z "$as_dir" && as_dir=.
for ac_exec_ext in '' $ac_executable_extensions; do
if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then
ac_cv_path_ac_pt_LIBGCRYPTCONFIG="$as_dir/$ac_word$ac_exec_ext"
$as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
break 2
fi
done
done
IFS=$as_save_IFS
;;
esac
fi
ac_pt_LIBGCRYPTCONFIG=$ac_cv_path_ac_pt_LIBGCRYPTCONFIG
if test -n "$ac_pt_LIBGCRYPTCONFIG"; then
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_LIBGCRYPTCONFIG" >&5
$as_echo "$ac_pt_LIBGCRYPTCONFIG" >&6; }
else
{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
$as_echo "no" >&6; }
fi
if test "x$ac_pt_LIBGCRYPTCONFIG" = x; then
LIBGCRYPTCONFIG=""
else
case $cross_compiling:$ac_tool_warned in
yes:)
{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
ac_tool_warned=yes ;;
esac
LIBGCRYPTCONFIG=$ac_pt_LIBGCRYPTCONFIG
fi
else
LIBGCRYPTCONFIG="$ac_cv_path_LIBGCRYPTCONFIG"
fi
if $PKGCONFIG --exists gnutls; then
have_ssl=1
SSLLIBS=`$PKGCONFIG --libs gnutls`
@@ -10050,11 +9980,11 @@ _ACEOF
if test "${with_java+set}" = set; then :
withval=$with_java; CUPS_JAVA="$withval"
else
CUPS_JAVA=""
CUPS_JAVA="auto"
fi
if test "x$CUPS_JAVA" = x; then
if test "x$CUPS_JAVA" = xauto; then
# Extract the first word of "java", so it can be a program name with args.
set dummy java; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
@@ -10096,6 +10026,8 @@ fi
CUPS_JAVA="$JAVA"
elif test "x$CUPS_JAVA" = xno; then
CUPS_JAVA=""
fi
cat >>confdefs.h <<_ACEOF
@@ -10113,11 +10045,11 @@ fi
if test "${with_perl+set}" = set; then :
withval=$with_perl; CUPS_PERL="$withval"
else
CUPS_PERL=""
CUPS_PERL="auto"
fi
if test "x$CUPS_PERL" = x; then
if test "x$CUPS_PERL" = xauto; then
# Extract the first word of "perl", so it can be a program name with args.
set dummy perl; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
@@ -10159,6 +10091,8 @@ fi
CUPS_PERL="$PERL"
elif test "x$CUPS_PERL" = xno; then
CUPS_PERL=""
fi
cat >>confdefs.h <<_ACEOF
@@ -10176,11 +10110,11 @@ fi
if test "${with_php+set}" = set; then :
withval=$with_php; CUPS_PHP="$withval"
else
CUPS_PHP=""
CUPS_PHP="auto"
fi
if test "x$CUPS_PHP" = x; then
if test "x$CUPS_PHP" = xauto; then
# Extract the first word of "php-cgi", so it can be a program name with args.
set dummy php-cgi; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
@@ -10266,6 +10200,8 @@ fi
else
CUPS_PHP="$PHPCGI"
fi
elif test "x$CUPS_PHP" = xno; then
CUPS_PHP=""
fi
cat >>confdefs.h <<_ACEOF
@@ -10285,11 +10221,11 @@ fi
if test "${with_python+set}" = set; then :
withval=$with_python; CUPS_PYTHON="$withval"
else
CUPS_PYTHON=""
CUPS_PYTHON="auto"
fi
if test "x$CUPS_PYTHON" = x; then
if test "x$CUPS_PYTHON" = xauto; then
# Extract the first word of "python", so it can be a program name with args.
set dummy python; ac_word=$2
{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
@@ -10331,6 +10267,8 @@ fi
CUPS_PYTHON="$PYTHON"
elif test "x$CUPS_PYTHON" = xno; then
CUPS_PYTHON=""
fi
cat >>confdefs.h <<_ACEOF
@@ -10887,7 +10825,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
# report actual input values of CONFIG_FILES etc. instead of their
# values after options handling.
ac_log="
This file was extended by CUPS $as_me 2.2.4, which was
This file was extended by CUPS $as_me 2.2.9, which was
generated by GNU Autoconf 2.68. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
@@ -10950,7 +10888,7 @@ _ACEOF
cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
ac_cs_version="\\
CUPS config.status 2.2.4
CUPS config.status 2.2.9
configured by $0, generated by GNU Autoconf 2.68,
with options \\"\$ac_cs_config\\"
+2 -2
Ver Arquivo
@@ -1,7 +1,7 @@
dnl
dnl Configuration script for CUPS.
dnl
dnl Copyright 2007-2017 by Apple Inc.
dnl Copyright 2007-2018 by Apple Inc.
dnl Copyright 1997-2007 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
@@ -15,7 +15,7 @@ dnl We need at least autoconf 2.60...
AC_PREREQ(2.60)
dnl Package name and version...
AC_INIT([CUPS], [2.2.4], [https://github.com/apple/cups/issues], [cups], [https://www.cups.org/])
AC_INIT([CUPS], [2.2.9], [https://github.com/apple/cups/issues], [cups], [https://www.cups.org/])
sinclude(config-scripts/cups-opsys.m4)
sinclude(config-scripts/cups-common.m4)
+72 -28
Ver Arquivo
@@ -1,8 +1,8 @@
#
# API library Makefile for CUPS.
# Library Makefile for CUPS.
#
# Copyright 2007-2016 by Apple Inc.
# Copyright 1997-2006 by Easy Software Products, all rights reserved.
# Copyright © 2007-2018 by Apple Inc.
# Copyright © 1997-2006 by Easy Software Products, all rights reserved.
#
# These coded instructions, statements, and computer programs are the
# property of Apple Inc. and are protected by Federal copyright
@@ -89,6 +89,7 @@ TESTOBJS = \
testcups.o \
testdest.o \
testfile.o \
testgetdests.o \
testhttp.o \
testi18n.o \
testipp.o \
@@ -158,6 +159,7 @@ UNITTARGETS = \
testcups \
testdest \
testfile \
testgetdests \
testhttp \
testi18n \
testipp \
@@ -310,8 +312,9 @@ uninstall:
libcups.so.2: $(LIBOBJS)
echo Linking $@...
$(DSO) $(ARCHFLAGS) $(DSOFLAGS) -o $@ $(LIBOBJS) $(LIBGSSAPI) \
$(DSO) $(ARCHFLAGS) $(LDFLAGS) $(DSOFLAGS) -o $@ $(LIBOBJS) $(LIBGSSAPI) \
$(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
$(RM) `basename $@ .2`
$(LN) $@ `basename $@ .2`
@@ -327,13 +330,14 @@ libcups.2.dylib: $(LIBOBJS) $(LIBCUPSORDER)
grep -v -E -e '^(_cupsConnect|_cupsCharset|_cupsEncodingName|_cupsSetDefaults|_cupsSetHTTPError|_cupsUserDefault)$$' | \
sort >t.exp
echo Linking $@...
$(DSO) $(ARCHFLAGS) $(DSOFLAGS) -o $@ \
$(DSO) $(ARCHFLAGS) $(LDFLAGS) $(DSOFLAGS) -o $@ \
-install_name $(libdir)/$@ \
-current_version 2.12.0 \
-current_version 2.13.0 \
-compatibility_version 2.0.0 \
-exported_symbols_list t.exp \
$(LIBOBJS) $(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) \
$(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
$(RM) libcups.dylib t.exp
$(LN) $@ libcups.dylib
@@ -344,8 +348,8 @@ libcups.2.dylib: $(LIBOBJS) $(LIBCUPSORDER)
libcups.la: $(LIBOBJS)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(DSOFLAGS) -o $@ $(LIBOBJS:.o=.lo) \
-rpath $(LIBDIR) -version-info 2:12 $(LIBGSSAPI) $(SSLLIBS) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) $(DSOFLAGS) -o $@ $(LIBOBJS:.o=.lo) \
-rpath $(LIBDIR) -version-info 2:13 $(LIBGSSAPI) $(SSLLIBS) \
$(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
@@ -367,12 +371,12 @@ libcups.a: $(LIBOBJS)
libcups2.def: $(LIBOBJS) Makefile
echo Generating $@...
echo "LIBRARY libcups2" >libcups2.def
echo "VERSION 2.12" >>libcups2.def
echo "VERSION 2.13" >>libcups2.def
echo "EXPORTS" >>libcups2.def
(nm $(LIBOBJS) 2>/dev/null | grep "T _" | awk '{print $$3}'; \
echo __cups_strcpy; echo __cups_strlcat; echo __cups_strlcpy) | \
grep -v -E \
-e 'cups_debug|Apple|BackChannel|Backend|FileCheck|Filter|GSSService|SetNegotiate|SideChannel' \
-e 'cups_debug|Apple|BackChannel|Backend|FileCheck|Filter|GSSService|SetNegotiate|SideChannel|SNMP' \
-e 'Block$$' | \
sed -e '1,$$s/^_//' | sort >>libcups2.def
@@ -383,8 +387,9 @@ libcups2.def: $(LIBOBJS) Makefile
testadmin: testadmin.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testadmin.o $(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testadmin.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -393,8 +398,9 @@ testadmin: testadmin.o $(LIBCUPSSTATIC)
testarray: testarray.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testarray.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testarray.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running array API tests...
./testarray
@@ -405,8 +411,9 @@ testarray: testarray.o $(LIBCUPSSTATIC)
testcache: testcache.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testcache.o $(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testcache.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -415,8 +422,9 @@ testcache: testcache.o $(LIBCUPSSTATIC)
testconflicts: testconflicts.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testconflicts.o $(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testconflicts.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -425,8 +433,9 @@ testconflicts: testconflicts.o $(LIBCUPSSTATIC)
testcreds: testcreds.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testcreds.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testcreds.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -435,8 +444,9 @@ testcreds: testcreds.o $(LIBCUPSSTATIC)
testcups: testcups.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testcups.o $(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testcups.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -445,8 +455,9 @@ testcups: testcups.o $(LIBCUPSSTATIC)
testdest: testdest.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testdest.o $(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testdest.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -455,20 +466,33 @@ testdest: testdest.o $(LIBCUPSSTATIC)
testfile: testfile.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testfile.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testfile.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running file API tests...
./testfile
#
# testgetdests (dependency on static CUPS library is intentional)
#
testgetdests: testgetdests.o $(LIBCUPSSTATIC)
echo Linking $@...
$(LD_CC) $(LDFLAGS) -o $@ testgetdests.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
# testhttp (dependency on static CUPS library is intentional)
#
testhttp: testhttp.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testhttp.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testhttp.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running HTTP API tests...
./testhttp
@@ -479,8 +503,9 @@ testhttp: testhttp.o $(LIBCUPSSTATIC)
testipp: testipp.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testipp.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testipp.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running IPP API tests...
./testipp
@@ -491,8 +516,9 @@ testipp: testipp.o $(LIBCUPSSTATIC)
testi18n: testi18n.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testi18n.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testi18n.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running internationalization API tests...
./testi18n
@@ -503,10 +529,23 @@ testi18n: testi18n.o $(LIBCUPSSTATIC)
testlang: testlang.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testlang.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testlang.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Creating locale directory structure...
$(RM) -r locale
$(MKDIR) locale/en
echo 'msgid "No"' > locale/en/cups_en.po
echo 'msgstr "No"' >> locale/en/cups_en.po
echo 'msgid "Yes"' >> locale/en/cups_en.po
echo 'msgstr "Yes"' >> locale/en/cups_en.po
for po in ../locale/cups_*.po; do \
lang=`basename $$po .po | sed -e '1,$$s/^cups_//'`; \
$(MKDIR) locale/$$lang; \
$(LN) ../../$$po locale/$$lang; \
done
echo Running language API tests...
./testlang
LOCALEDIR=locale ./testlang
#
@@ -515,8 +554,9 @@ testlang: testlang.o $(LIBCUPSSTATIC)
testoptions: testoptions.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testoptions.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testoptions.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running option API tests...
./testoptions
@@ -527,8 +567,9 @@ testoptions: testoptions.o $(LIBCUPSSTATIC)
testppd: testppd.o $(LIBCUPSSTATIC) test.ppd test2.ppd
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testppd.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testppd.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running PPD API tests...
./testppd
@@ -539,8 +580,9 @@ testppd: testppd.o $(LIBCUPSSTATIC) test.ppd test2.ppd
testpwg: testpwg.o $(LIBCUPSSTATIC) test.ppd
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testpwg.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ testpwg.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
echo Running PWG API tests...
./testpwg test.ppd
@@ -551,8 +593,9 @@ testpwg: testpwg.o $(LIBCUPSSTATIC) test.ppd
testsnmp: testsnmp.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testsnmp.o $(LIBCUPSSTATIC) \
$(LD_CC) $(LDFLAGS) -o $@ testsnmp.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
@@ -561,8 +604,9 @@ testsnmp: testsnmp.o $(LIBCUPSSTATIC)
tlscheck: tlscheck.o $(LIBCUPSSTATIC)
echo Linking $@...
$(CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ tlscheck.o $(LIBCUPSSTATIC) \
$(LD_CC) $(ARCHFLAGS) $(LDFLAGS) -o $@ tlscheck.o $(LIBCUPSSTATIC) \
$(LIBGSSAPI) $(SSLLIBS) $(DNSSDLIBS) $(COMMONLIBS) $(LIBZ)
$(CODE_SIGN) -s "$(CODE_SIGN_IDENTITY)" $@
#
+8 -8
Ver Arquivo
@@ -22,11 +22,11 @@
#include "adminutil.h"
#include <fcntl.h>
#include <sys/stat.h>
#ifdef WIN32
#ifdef _WIN32
#else
# include <unistd.h>
# include <sys/wait.h>
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -2087,7 +2087,7 @@ do_samba_command(const char *command, /* I - Command to run */
const char *authfile, /* I - Samba authentication file */
FILE *logfile) /* I - Optional log file */
{
#ifdef WIN32
#ifdef _WIN32
return (1); /* Always fail on Windows... */
#else
@@ -2154,7 +2154,7 @@ do_samba_command(const char *command, /* I - Command to run */
return (WEXITSTATUS(status));
else
return (-WTERMSIG(status));
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -2172,9 +2172,9 @@ get_cupsd_conf(
int *remote) /* O - Remote file? */
{
int fd; /* Temporary file descriptor */
#ifndef WIN32
#ifndef _WIN32
struct stat info; /* cupsd.conf file information */
#endif /* WIN32 */
#endif /* _WIN32 */
http_status_t status; /* Status of getting cupsd.conf */
char host[HTTP_MAX_HOST]; /* Hostname for connection */
@@ -2191,7 +2191,7 @@ get_cupsd_conf(
snprintf(name, namesize, "%s/cupsd.conf", cg->cups_serverroot);
*remote = 0;
#ifndef WIN32
#ifndef _WIN32
if (!_cups_strcasecmp(host, "localhost") && !access(name, R_OK))
{
/*
@@ -2218,7 +2218,7 @@ get_cupsd_conf(
status = HTTP_STATUS_OK;
}
else
#endif /* !WIN32 */
#endif /* !_WIN32 */
{
/*
* Read cupsd.conf via a HTTP GET request...
-32
Ver Arquivo
@@ -1,32 +0,0 @@
<!--
Array API header for CUPS.
Copyright 2008-2011 by Apple Inc.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h1 class='title'>Array API</h1>
<div class='summary'><table summary='General Information'>
<thead>
<tr>
<th>Header</th>
<th>cups/array.h</th>
</tr>
</thead>
<tbody>
<tr>
<th>Library</th>
<td>-lcups</td>
</tr>
<tr>
<th>See Also</th>
<td>Programming: <a href='api-overview.html' target='_top'>Introduction to CUPS Programming</a></td>
</tr>
</tbody>
</table></div>
-194
Ver Arquivo
@@ -1,194 +0,0 @@
<!--
Array API introduction for CUPS.
Copyright 2007-2011 by Apple Inc.
Copyright 1997-2006 by Easy Software Products, all rights reserved.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h2 class='title'><a name='OVERVIEW'>Overview</a></h2>
<p>The CUPS array API provides a high-performance generic array container.
The contents of the array container can be sorted and the container itself is
designed for optimal speed and memory usage under a wide variety of conditions.
Sorted arrays use a binary search algorithm from the last found or inserted
element to quickly find matching elements in the array. Arrays created with the
optional hash function can often find elements with a single lookup. The
<a href='#cups_array_t'><code>cups_array_t</code></a> type is used when
referring to a CUPS array.</p>
<p>The CUPS scheduler (<tt>cupsd</tt>) and many of the CUPS API
functions use the array API to efficiently manage large lists of
data.</p>
<h3><a name='MANAGING_ARRAYS'>Managing Arrays</a></h3>
<p>Arrays are created using either the
<a href='#cupsArrayNew'><code>cupsArrayNew</code></a>,
<a href='#cupsArrayNew2'><code>cupsArrayNew2</code></a>, or
<a href='#cupsArrayNew2'><code>cupsArrayNew3</code></a> functions. The
first function creates a new array with the specified callback function
and user data pointer:</p>
<pre class='example'>
#include &lt;cups/array.h&gt;
static int compare_func(void *first, void *second, void *user_data);
void *user_data;
<a href='#cups_array_t'>cups_array_t</a> *array = <a href='#cupsArrayNew'>cupsArrayNew</a>(compare_func, user_data);
</pre>
<p>The comparison function (type
<a href="#cups_arrayfunc_t"><code>cups_arrayfunc_t</code></a>) is called
whenever an element is added to the array and can be <code>NULL</code> to
create an unsorted array. The function returns -1 if the first element should
come before the second, 0 if the first and second elements should have the same
ordering, and 1 if the first element should come after the second.</p>
<p>The "user_data" pointer is passed to your comparison function. Pass
<code>NULL</code> if you do not need to associate the elements in your array
with additional information.</p>
<p>The <a href='#cupsArrayNew2'><code>cupsArrayNew2</code></a> function adds
two more arguments to support hashed lookups, which can potentially provide
instantaneous ("O(1)") lookups in your array:</p>
<pre class='example'>
#include &lt;cups/array.h&gt;
#define HASH_SIZE 512 /* Size of hash table */
static int compare_func(void *first, void *second, void *user_data);
static int hash_func(void *element, void *user_data);
void *user_data;
<a href='#cups_array_t'>cups_array_t</a> *hash_array = <a href='#cupsArrayNew2'>cupsArrayNew2</a>(compare_func, user_data, hash_func, HASH_SIZE);
</pre>
<p>The hash function (type
<a href="#cups_ahash_func_t"><code>cups_ahash_func_t</code></a>) should return a
number from 0 to (hash_size-1) that (hopefully) uniquely identifies the
element and is called whenever you look up an element in the array with
<a href='#cupsArrayFind'><code>cupsArrayFind</code></a>. The hash size is
only limited by available memory, but generally should not be larger than
16384 to realize any performance improvement.</p>
<p>The <a href='#cupsArrayNew3'><code>cupsArrayNew3</code></a> function adds
copy and free callbacks to support basic memory management of elements:</p>
<pre class='example'>
#include &lt;cups/array.h&gt;
#define HASH_SIZE 512 /* Size of hash table */
static int compare_func(void *first, void *second, void *user_data);
static void *copy_func(void *element, void *user_data);
static void free_func(void *element, void *user_data);
static int hash_func(void *element, void *user_data);
void *user_data;
<a href='#cups_array_t'>cups_array_t</a> *array = <a href='#cupsArrayNew3'>cupsArrayNew3</a>(compare_func, user_data, NULL, 0, copy_func, free_func);
<a href='#cups_array_t'>cups_array_t</a> *hash_array = <a href='#cupsArrayNew3'>cupsArrayNew3</a>(compare_func, user_data, hash_func, HASH_SIZE, copy_func, free_func);
</pre>
<p>Once you have created the array, you add elements using the
<a href='#cupsArrayAdd'><code>cupsArrayAdd</code></a>
<a href='#cupsArrayInsert'><code>cupsArrayInsert</code></a> functions.
The first function adds an element to the array, adding the new element
after any elements that have the same order, while the second inserts the
element before others with the same order. For unsorted arrays,
<a href='#cupsArrayAdd'><code>cupsArrayAdd</code></a> appends the element to
the end of the array while
<a href='#cupsArrayInsert'><code>cupsArrayInsert</code></a> inserts the
element at the beginning of the array. For example, the following code
creates a sorted array of character strings:</p>
<pre class='example'>
#include &lt;cups/array.h&gt;
/* Use strcmp() to compare strings - it will ignore the user_data pointer */
<a href='#cups_array_t'>cups_array_t</a> *array = <a href='#cupsArrayNew'>cupsArrayNew</a>((<a href='#cups_array_func_t'>cups_array_func_t</a>)strcmp, NULL);
/* Add four strings to the array */
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "One Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Two Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Red Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Blue Fish");
</pre>
<p>Elements are removed using the
<a href='#cupsArrayRemove'><code>cupsArrayRemove</code></a> function, for
example:</p>
<pre class='example'>
#include &lt;cups/array.h&gt;
/* Use strcmp() to compare strings - it will ignore the user_data pointer */
<a href='#cups_array_t'>cups_array_t</a> *array = <a href='#cupsArrayNew'>cupsArrayNew</a>((<a href='#cups_array_func_t'>cups_array_func_t</a>)strcmp, NULL);
/* Add four strings to the array */
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "One Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Two Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Red Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Blue Fish");
/* Remove "Red Fish" */
<a href='#cupsArrayRemove'>cupsArrayRemove</a>(array, "Red Fish");
</pre>
<p>Finally, you free the memory used by the array using the
<a href='#cupsArrayDelete'><code>cupsArrayDelete</code></a> function. All
of the memory for the array and hash table (if any) is freed, however <em>CUPS
does not free the elements unless you provide copy and free functions</em>.</p>
<h3><a name='FINDING_AND_ENUMERATING'>Finding and Enumerating Elements</a></h3>
<p>CUPS provides several functions to find and enumerate elements in an
array. Each one sets or updates a "current index" into the array, such that
future lookups will start where the last one left off:</p>
<dl>
<dt><a href='#cupsArrayFind'><code>cupsArrayFind</code></a></dt>
<dd>Returns the first matching element.</dd>
<dt><a href='#cupsArrayFirst'><code>cupsArrayFirst</code></a></dt>
<dd>Returns the first element in the array.</dd>
<dt><a href='#cupsArrayIndex'><code>cupsArrayIndex</code></a></dt>
<dd>Returns the Nth element in the array, starting at 0.</dd>
<dt><a href='#cupsArrayLast'><code>cupsArrayLast</code></a></dt>
<dd>Returns the last element in the array.</dd>
<dt><a href='#cupsArrayNext'><code>cupsArrayNext</code></a></dt>
<dd>Returns the next element in the array.</dd>
<dt><a href='#cupsArrayPrev'><code>cupsArrayPrev</code></a></dt>
<dd>Returns the previous element in the array.</dd>
</dl>
<p>Each of these functions returns <code>NULL</code> when there is no
corresponding element. For example, a simple <code>for</code> loop using the
<a href='#cupsArrayFirst'><code>cupsArrayFirst</code></a> and
<a href='#cupsArrayNext'><code>cupsArrayNext</code></a> functions will
enumerate all of the strings in our previous example:</p>
<pre class='example'>
#include &lt;cups/array.h&gt;
/* Use strcmp() to compare strings - it will ignore the user_data pointer */
<a href='#cups_array_t'>cups_array_t</a> *array = <a href='#cupsArrayNew'>cupsArrayNew</a>((<a href='#cups_array_func_t'>cups_array_func_t</a>)strcmp, NULL);
/* Add four strings to the array */
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "One Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Two Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Red Fish");
<a href='#cupsArrayAdd'>cupsArrayAdd</a>(array, "Blue Fish");
/* Show all of the strings in the array */
char *s;
for (s = (char *)<a href='#cupsArrayFirst'>cupsArrayFirst</a>(array); s != NULL; s = (char *)<a href='#cupsArrayNext'>cupsArrayNext</a>(array))
puts(s);
</pre>
-38
Ver Arquivo
@@ -1,38 +0,0 @@
<!--
CUPS API header for CUPS.
Copyright 2008-2011 by Apple Inc.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h1 class='title'>CUPS API</h1>
<div class='summary'><table summary='General Information'>
<thead>
<tr>
<th>Header</th>
<th>cups/cups.h</th>
</tr>
</thead>
<tbody>
<tr>
<th>Library</th>
<td>-lcups</td>
</tr>
<tr>
<th>See Also</th>
<td>Programming: <a href='api-overview.html' target='_top'>Introduction to CUPS Programming</a><br>
Programming: <a href='api-array.html' target='_top'>Array API</a><br>
Programming: <a href='api-filedir.html' target='_top'>File and Directory APIs</a><br>
Programming: <a href='api-filter.html' target='_top'>Filter and Backend Programming</a><br>
Programming: <a href='api-httpipp.html' target='_top'>HTTP and IPP APIs</a><br>
Programming: <a href='api-ppd.html' target='_top'>PPD API</a><br>
Programming: <a href='api-raster.html' target='_top'>Raster API</a></td>
</tr>
</tbody>
</table></div>
-441
Ver Arquivo
@@ -1,441 +0,0 @@
<!--
API introduction for CUPS.
Copyright 2007-2013 by Apple Inc.
Copyright 1997-2006 by Easy Software Products, all rights reserved.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h2 class='title'><a name='OVERVIEW'>Overview</a></h2>
<p>The CUPS API provides the convenience functions needed to support
applications, filters, printer drivers, and backends that need to interface
with the CUPS scheduler.</p>
<h3><a name='CLIENTS_AND_SERVERS'>Clients and Servers</a></h3>
<p>CUPS is based on the Internet Printing Protocol ("IPP"), which allows
clients (applications) to communicate with a server (the scheduler) to get a
list of printers, send print jobs, and so forth. You identify which server
you want to communicate with using a pointer to the opaque structure
<code>http_t</code>. All of the examples in this document use the
<code>CUPS_HTTP_DEFAULT</code> constant, referring to the default connection
to the scheduler. The <a href='api-httpipp.html' target='_top'>HTTP and IPP
APIs</a> document provides more information on server connections.</p>
<h3><a name='PRINTERS_AND_CLASSES'>Printers and Classes</a></h3>
<p>Printers and classes (collections of printers) are accessed through
the <a href="#cups_dest_t"><code>cups_dest_t</code></a> structure which
includes the name (<code>name</code>), instance (<code>instance</code> -
a way of selecting certain saved options/settings), and the options and
attributes associated with that destination (<code>num_options</code> and
<code>options</code>). Destinations are created using the
<a href="#cupsGetDests"><code>cupsGetDests</code></a> function and freed
using the <a href='#cupsFreeDests'><code>cupsFreeDests</code></a> function.
The <a href='#cupsGetDest'><code>cupsGetDest</code></a> function finds a
specific destination for printing:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dests;
int num_dests = <a href='#cupsGetDests'>cupsGetDests</a>(&amp;dests);
<a href='#cups_dest_t'>cups_dest_t</a> *dest = <a href='#cupsGetDest'>cupsGetDest</a>("name", NULL, num_dests, dests);
/* do something with dest */
<a href='#cupsFreeDests'>cupsFreeDests</a>(num_dests, dests);
</pre>
<p>Passing <code>NULL</code> to
<a href='#cupsGetDest'><code>cupsGetDest</code></a> for the destination name
will return the default destination. Similarly, passing a <code>NULL</code>
instance will return the default instance for that destination.</p>
<div class='table'><table summary='Table 1: Printer Attributes' width='80%'>
<caption>Table 1: <a name='TABLE1'>Printer Attributes</a></caption>
<thead>
<tr>
<th>Attribute Name</th>
<th>Description</th>
</tr>
</thead>
<tbody>
<tr>
<td>"auth-info-required"</td>
<td>The type of authentication required for printing to this
destination: "none", "username,password", "domain,username,password",
or "negotiate" (Kerberos)</td>
</tr>
<tr>
<td>"printer-info"</td>
<td>The human-readable description of the destination such as "My
Laser Printer".</td>
</tr>
<tr>
<td>"printer-is-accepting-jobs"</td>
<td>"true" if the destination is accepting new jobs, "false" if
not.</td>
</tr>
<tr>
<td>"printer-is-shared"</td>
<td>"true" if the destination is being shared with other computers,
"false" if not.</td>
</tr>
<tr>
<td>"printer-location"</td>
<td>The human-readable location of the destination such as "Lab 4".</td>
</tr>
<tr>
<td>"printer-make-and-model"</td>
<td>The human-readable make and model of the destination such as "HP
LaserJet 4000 Series".</td>
</tr>
<tr>
<td>"printer-state"</td>
<td>"3" if the destination is idle, "4" if the destination is printing
a job, and "5" if the destination is stopped.</td>
</tr>
<tr>
<td>"printer-state-change-time"</td>
<td>The UNIX time when the destination entered the current state.</td>
</tr>
<tr>
<td>"printer-state-reasons"</td>
<td>Additional comma-delimited state keywords for the destination
such as "media-tray-empty-error" and "toner-low-warning".</td>
</tr>
<tr>
<td>"printer-type"</td>
<td>The <a href='#cups_printer_t'><code>cups_printer_t</code></a>
value associated with the destination.</td>
</tr>
</tbody>
</table></div>
<h3><a name='OPTIONS'>Options</a></h3>
<p>Options are stored in arrays of
<a href='#cups_option_t'><code>cups_option_t</code></a> structures. Each
option has a name (<code>name</code>) and value (<code>value</code>)
associated with it. The <a href='#cups_dest_t'><code>cups_dest_t</code></a>
<code>num_options</code> and <code>options</code> members contain the
default options for a particular destination, along with several informational
attributes about the destination as shown in <a href='#TABLE1'>Table 1</a>.
The <a href='#cupsGetOption'><code>cupsGetOption</code></a> function gets
the value for the named option. For example, the following code lists the
available destinations and their human-readable descriptions:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dests;
int num_dests = <a href='#cupsGetDests'>cupsGetDests</a>(&amp;dests);
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
int i;
const char *value;
for (i = num_dests, dest = dests; i > 0; i --, dest ++)
if (dest->instance == NULL)
{
value = <a href='#cupsGetOption'>cupsGetOption</a>("printer-info", dest->num_options, dest->options);
printf("%s (%s)\n", dest->name, value ? value : "no description");
}
<a href='#cupsFreeDests'>cupsFreeDests</a>(num_dests, dests);
</pre>
<p>You can create your own option arrays using the
<a href='#cupsAddOption'><code>cupsAddOption</code></a> function, which
adds a single named option to an array:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
int num_options = 0;
<a href='#cups_option_t'>cups_option_t</a> *options = NULL;
/* The returned num_options value is updated as needed */
num_options = <a href='#cupsAddOption'>cupsAddOption</a>("first", "value", num_options, &amp;options);
/* This adds a second option value */
num_options = <a href='#cupsAddOption'>cupsAddOption</a>("second", "value", num_options, &amp;options);
/* This replaces the first option we added */
num_options = <a href='#cupsAddOption'>cupsAddOption</a>("first", "new value", num_options, &amp;options);
</pre>
<p>Use a <code>for</code> loop to copy the options from a destination:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
int i;
int num_options = 0;
<a href='#cups_option_t'>cups_option_t</a> *options = NULL;
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
for (i = 0; i &lt; dest->num_options; i ++)
num_options = <a href='#cupsAddOption'>cupsAddOption</a>(dest->options[i].name, dest->options[i].value,
num_options, &amp;options);
</pre>
<p>Use the <a href='#cupsFreeOptions'><code>cupsFreeOptions</code></a>
function to free the options array when you are done using it:</p>
<pre class='example'>
<a href='#cupsFreeOptions'>cupsFreeOptions</a>(num_options, options);
</pre>
<h3><a name='PRINT_JOBS'>Print Jobs</a></h3>
<p>Print jobs are identified by a locally-unique job ID number from 1 to
2<sup>31</sup>-1 and have options and one or more files for printing to a
single destination. The <a href='#cupsPrintFile'><code>cupsPrintFile</code></a>
function creates a new job with one file. The following code prints the CUPS
test page file:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
int num_options;
<a href='#cups_option_t'>cups_option_t</a> *options;
int job_id;
/* Print a single file */
job_id = <a href='#cupsPrintFile'>cupsPrintFile</a>(dest->name, "/usr/share/cups/data/testprint.ps",
"Test Print", num_options, options);
</pre>
<p>The <a href='#cupsPrintFiles'><code>cupsPrintFiles</code></a> function
creates a job with multiple files. The files are provided in a
<code>char *</code> array:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
int num_options;
<a href='#cups_option_t'>cups_option_t</a> *options;
int job_id;
char *files[3] = { "file1.pdf", "file2.pdf", "file3.pdf" };
/* Print three files */
job_id = <a href='#cupsPrintFiles'>cupsPrintFiles</a>(dest->name, 3, files, "Test Print", num_options, options);
</pre>
<p>Finally, the <a href='#cupsCreateJob'><code>cupsCreateJob</code></a>
function creates a new job with no files in it. Files are added using the
<a href='#cupsStartDocument'><code>cupsStartDocument</code></a>,
<a href='api-httpipp.html#cupsWriteRequestData'><code>cupsWriteRequestData</code></a>,
and <a href='#cupsFinishDocument'><code>cupsFinishDocument</code></a> functions.
The following example creates a job with 10 text files for printing:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
int num_options;
<a href='#cups_option_t'>cups_option_t</a> *options;
int job_id;
int i;
char buffer[1024];
/* Create the job */
job_id = <a href='#cupsCreateJob'>cupsCreateJob</a>(CUPS_HTTP_DEFAULT, dest->name, "10 Text Files",
num_options, options);
/* If the job is created, add 10 files */
if (job_id > 0)
{
for (i = 1; i &lt;= 10; i ++)
{
snprintf(buffer, sizeof(buffer), "file%d.txt", i);
<a href='#cupsStartDocument'>cupsStartDocument</a>(CUPS_HTTP_DEFAULT, dest->name, job_id, buffer,
CUPS_FORMAT_TEXT, i == 10);
snprintf(buffer, sizeof(buffer),
"File %d\n"
"\n"
"One fish,\n"
"Two fish,\n
"Red fish,\n
"Blue fish\n", i);
/* cupsWriteRequestData can be called as many times as needed */
<a href='#cupsWriteRequestData'>cupsWriteRequestData</a>(CUPS_HTTP_DEFAULT, buffer, strlen(buffer));
<a href='#cupsFinishDocument'>cupsFinishDocument</a>(CUPS_HTTP_DEFAULT, dest->name);
}
}
</pre>
<p>Once you have created a job, you can monitor its status using the
<a href='#cupsGetJobs'><code>cupsGetJobs</code></a> function, which returns
an array of <a href='#cups_job_t'><code>cups_job_t</code></a> structures.
Each contains the job ID (<code>id</code>), destination name
(<code>dest</code>), title (<code>title</code>), and other information
associated with the job. The job array is freed using the
<a href='#cupsFreeJobs'><code>cupsFreeJobs</code></a> function. The following
example monitors a specific job ID, showing the current job state once every
5 seconds until the job is completed:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
int job_id;
int num_jobs;
<a href='#cups_job_t'>cups_job_t</a> *jobs;
int i;
ipp_jstate_t job_state = IPP_JOB_PENDING;
while (job_state &lt; IPP_JOB_STOPPED)
{
/* Get my jobs (1) with any state (-1) */
num_jobs = <a href='#cupsGetJobs'>cupsGetJobs</a>(&amp;jobs, dest->name, 1, -1);
/* Loop to find my job */
job_state = IPP_JOB_COMPLETED;
for (i = 0; i &lt; num_jobs; i ++)
if (jobs[i].id == job_id)
{
job_state = jobs[i].state;
break;
}
/* Free the job array */
<a href='#cupsFreeJobs'>cupsFreeJobs</a>(num_jobs, jobs);
/* Show the current state */
switch (job_state)
{
case IPP_JOB_PENDING :
printf("Job %d is pending.\n", job_id);
break;
case IPP_JOB_HELD :
printf("Job %d is held.\n", job_id);
break;
case IPP_JOB_PROCESSING :
printf("Job %d is processing.\n", job_id);
break;
case IPP_JOB_STOPPED :
printf("Job %d is stopped.\n", job_id);
break;
case IPP_JOB_CANCELED :
printf("Job %d is canceled.\n", job_id);
break;
case IPP_JOB_ABORTED :
printf("Job %d is aborted.\n", job_id);
break;
case IPP_JOB_COMPLETED :
printf("Job %d is completed.\n", job_id);
break;
}
/* Sleep if the job is not finished */
if (job_state &lt; IPP_JOB_STOPPED)
sleep(5);
}
</pre>
<p>To cancel a job, use the
<a href='#cupsCancelJob'><code>cupsCancelJob</code></a> function with the
job ID:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#cups_dest_t'>cups_dest_t</a> *dest;
int job_id;
<a href='#cupsCancelJob'>cupsCancelJob</a>(dest->name, job_id);
</pre>
<h3><a name='ERROR_HANDLING'>Error Handling</a></h3>
<p>If any of the CUPS API printing functions returns an error, the reason for
that error can be found by calling the
<a href='#cupsLastError'><code>cupsLastError</code></a> and
<a href='#cupsLastErrorString'><code>cupsLastErrorString</code></a> functions.
<a href='#cupsLastError'><code>cupsLastError</code></a> returns the last IPP
error code
(<a href='api-httpipp.html#ipp_status_t'><code>ipp_status_t</code></a>)
that was encountered, while
<a href='#cupsLastErrorString'><code>cupsLastErrorString</code></a> returns
a (localized) human-readable string that can be shown to the user. For example,
if any of the job creation functions returns a job ID of 0, you can use
<a href='#cupsLastErrorString'><code>cupsLastErrorString</code></a> to show
the reason why the job could not be created:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
int job_id;
if (job_id == 0)
puts(cupsLastErrorString());
</pre>
<h3><a name='PASSWORDS_AND_AUTHENTICATION'>Passwords and Authentication</a></h3>
<p>CUPS supports authentication of any request, including submission of print
jobs. The default mechanism for getting the username and password is to use the
login user and a password from the console.</p>
<p>To support other types of applications, in particular Graphical User
Interfaces ("GUIs"), the CUPS API provides functions to set the default
username and to register a callback function that returns a password string.</p>
<p>The <a href="#cupsSetPasswordCB"><code>cupsSetPasswordCB</code></a>
function is used to set a password callback in your program. Only one
function can be used at any time.</p>
<p>The <a href="#cupsSetUser"><code>cupsSetUser</code></a> function sets the
current username for authentication. This function can be called by your
password callback function to change the current username as needed.</p>
<p>The following example shows a simple password callback that gets a
username and password from the user:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
const char *
my_password_cb(const char *prompt)
{
char user[65];
puts(prompt);
/* Get a username from the user */
printf("Username: ");
if (fgets(user, sizeof(user), stdin) == NULL)
return (NULL);
/* Strip the newline from the string and set the user */
user[strlen(user) - 1] = '\0';
<a href='#cupsSetUser'>cupsSetUser</a>(user);
/* Use getpass() to ask for the password... */
return (getpass("Password: "));
}
<a href='#cupsSetPasswordCB'>cupsSetPasswordCB</a>(my_password_cb);
</pre>
<p>Similarly, a GUI could display the prompt string in a window with input
fields for the username and password. The username should default to the
string returned by the <a href="#cupsUser"><code>cupsUser</code></a>
function.</p>
-34
Ver Arquivo
@@ -1,34 +0,0 @@
<!--
File and Directory API header for CUPS.
Copyright 2008-2011 by Apple Inc.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h1 class='title'>File and Directory APIs</h1>
<div class='summary'><table summary='General Information'>
<thead>
<tr>
<th>Headers</th>
<th>cups/file.h<br>
cups/dir.h</th>
</tr>
</thead>
<tbody>
<tr>
<th>Library</th>
<td>-lcups</td>
</tr>
<tr>
<th>See Also</th>
<td>Programming: <a href='api-overview.html' target='_top'>Introduction to CUPS Programming</a><br>
Programming: <a href='api-cups.html' target='_top'>CUPS API</a></td>
</tr>
</tbody>
</table></div>
-29
Ver Arquivo
@@ -1,29 +0,0 @@
<!--
File and directory API introduction for CUPS.
Copyright 2007-2011 by Apple Inc.
Copyright 1997-2005 by Easy Software Products, all rights reserved.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h2 class='title'><a name="OVERVIEW">Overview</a></h2>
<p>The CUPS file and directory APIs provide portable interfaces
for manipulating files and listing files and directories. Unlike
stdio <code>FILE</code> streams, the <code>cupsFile</code> functions
allow you to open more than 256 files at any given time. They
also manage the platform-specific details of locking, large file
support, line endings (CR, LF, or CR LF), and reading and writing
files using Flate ("gzip") compression. Finally, you can also
connect, read from, and write to network connections using the
<code>cupsFile</code> functions.</p>
<p>The <code>cupsDir</code> functions manage the platform-specific
details of directory access/listing and provide a convenient way
to get both a list of files and the information (permissions,
size, timestamp, etc.) for each of those files.</p>
-37
Ver Arquivo
@@ -1,37 +0,0 @@
<!--
HTTP and IPP API header for CUPS.
Copyright 2007-2016 by Apple Inc.
Copyright 1997-2006 by Easy Software Products, all rights reserved.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h1 class='title'>HTTP and IPP APIs</h1>
<div class='summary'><table summary='General Information'>
<thead>
<tr>
<th>Headers</th>
<th>cups/cups.h<br>
cups/http.h<br>
cups/ipp.h</th>
</tr>
</thead>
<tbody>
<tr>
<th>Library</th>
<td>-lcups</td>
</tr>
<tr>
<th>See Also</th>
<td>Programming: <a href='api-overview.html'>Introduction to CUPS Programming</a><br>
Programming: <a href='api-cups.html'>CUPS API</a><br>
References: <a href='spec-ipp.html'>CUPS Implementation of IPP</a></td>
</tr>
</tbody>
</table></div>
-315
Ver Arquivo
@@ -1,315 +0,0 @@
<!--
HTTP and IPP API introduction for CUPS.
Copyright 2007-2012 by Apple Inc.
Copyright 1997-2006 by Easy Software Products, all rights reserved.
These coded instructions, statements, and computer programs are the
property of Apple Inc. and are protected by Federal copyright
law. Distribution and use rights are outlined in the file "LICENSE.txt"
which should have been included with this file. If this file is
file is missing or damaged, see the license at "http://www.cups.org/".
-->
<h2 class='title'><a name='OVERVIEW'>Overview</a></h2>
<p>The CUPS HTTP and IPP APIs provide low-level access to the HTTP and IPP
protocols and CUPS scheduler. They are typically used by monitoring and
administration programs to perform specific functions not supported by the
high-level CUPS API functions.</p>
<p>The HTTP APIs use an opaque structure called
<a href='#http_t'><code>http_t</code></a> to manage connections to
a particular HTTP or IPP server. The
<a href='#httpConnectEncrypt'><code>httpConnectEncrypt</code></a> function is
used to create an instance of this structure for a particular server.
The constant <code>CUPS_HTTP_DEFAULT</code> can be used with all of the
<code>cups</code> functions to refer to the default CUPS server - the functions
create a per-thread <a href='#http_t'><code>http_t</code></a> as needed.</p>
<p>The IPP APIs use two opaque structures for requests (messages sent to the CUPS scheduler) and responses (messages sent back to your application from the scheduler). The <a href='#ipp_t'><code>ipp_t</code></a> type holds a complete request or response and is allocated using the <a href='#ippNew'><code>ippNew</code></a> or <a href='#ippNewRequest'><code>ippNewRequest</code></a> functions and freed using the <a href='#ippDelete'><code>ippDelete</code></a> function.</p>
<p>The second opaque structure is called <a href='#ipp_attribute_t'><code>ipp_attribute_t</code></a> and holds a single IPP attribute which consists of a group tag (<a href='#ippGetGroupTag'><code>ippGetGroupTag</code></a>), a value type tag (<a href='#ippGetValueTag'><code>ippGetValueTag</code></a>), the attribute name (<a href='#ippGetName'><code>ippGetName</code></a>), and 1 or more values (<a href='#ippGetCount'><code>ippGetCount</code></a>, <a href='#ippGetBoolean'><code>ippGetBoolean</code></a>, <a href='#ippGetCollection'><code>ippGetCollection</code></a>, <a href='#ippGetDate'><code>ippGetDate</code></a>, <a href='#ippGetInteger'><code>ippGetInteger</code></a>, <a href='#ippGetRange'><code>ippGetRange</code></a>, <a href='#ippGetResolution'><code>ippGetResolution</code></a>, and <a href='#ippGetString'><code>ippGetString</code></a>). Attributes are added to an <a href='#ipp_t'><code>ipp_t</code></a> pointer using one of the <code>ippAdd</code> functions. For example, use <a href='#ippAddString'><code>ippAddString</code></a> to add the "printer-uri" and "requesting-user-name" string attributes to a request:</p>
<pre class='example'>
<a href='#ipp_t'>ipp_t</a> *request = <a href='#ippNewRequest'>ippNewRequest</a>(IPP_GET_JOBS);
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, "ipp://localhost/printers/");
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
</pre>
<p>Once you have created an IPP request, use the <code>cups</code> functions to send the request to and read the response from the server. For example, the <a href='#cupsDoRequest'><code>cupsDoRequest</code></a> function can be used for simple query operations that do not involve files:</p>
<pre class='example'>
#include &lt;cups/cups.h&gt;
<a href='#ipp_t'>ipp_t</a> *<a name='get_jobs'>get_jobs</a>(void)
{
<a href='#ipp_t'>ipp_t</a> *request = <a href='#ippNewRequest'>ippNewRequest</a>(IPP_GET_JOBS);
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, "ipp://localhost/printers/");
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
return (<a href='#cupsDoRequest'>cupsDoRequest</a>(CUPS_HTTP_DEFAULT, request, "/"));
}
</pre>
<p>The <a href='#cupsDoRequest'><code>cupsDoRequest</code></a> function frees the request and returns an IPP response or <code>NULL</code> pointer if the request could not be sent to the server. Once you have a response from the server, you can either use the <a href='#ippFindAttribute'><code>ippFindAttribute</code></a> and <a href='#ippFindNextAttribute'><code>ippFindNextAttribute</code></a> functions to find specific attributes, for example:</p>
<pre class='example'>
<a href='#ipp_t'>ipp_t</a> *response;
<a href='#ipp_attribute_t'>ipp_attribute_t</a> *attr;
attr = <a href='#ippFindAttribute'>ippFindAttribute</a>(response, "printer-state", IPP_TAG_ENUM);
</pre>
<p>You can also walk the list of attributes with a simple <code>for</code> loop like this:</p>
<pre class='example'>
<a href='#ipp_t'>ipp_t</a> *response;
<a href='#ipp_attribute_t'>ipp_attribute_t</a> *attr;
for (attr = <a href='#ippFirstAttribute'>ippFirstAttribute</a>(response); attr != NULL; attr = <a href='#ippNextAttribute'>ippNextAttribute</a>(response))
if (ippGetName(attr) == NULL)
puts("--SEPARATOR--");
else
puts(ippGetName(attr));
</pre>
<p>The <code>for</code> loop approach is normally used when collecting attributes for multiple objects (jobs, printers, etc.) in a response. Attributes with <code>NULL</code> names indicate a separator between the attributes of each object. For example, the following code will list the jobs returned from our previous <a href='#get_jobs'><code>get_jobs</code></a> example code:</p>
<pre class='example'>
<a href='#ipp_t'>ipp_t</a> *response = <a href='#get_jobs'>get_jobs</a>();
if (response != NULL)
{
<a href='#ipp_attribute_t'>ipp_attribute_t</a> *attr;
const char *attrname;
int job_id = 0;
const char *job_name = NULL;
const char *job_originating_user_name = NULL;
puts("Job ID Owner Title");
puts("------ ---------------- ---------------------------------");
for (attr = <a href='#ippFirstAttribute'>ippFirstAttribute</a>(response); attr != NULL; attr = <a href='#ippNextAttribute'>ippNextAttribute</a>(response))
{
/* Attributes without names are separators between jobs */
attrname = ippGetName(attr);
if (attrname == NULL)
{
if (job_id > 0)
{
if (job_name == NULL)
job_name = "(withheld)";
if (job_originating_user_name == NULL)
job_originating_user_name = "(withheld)";
printf("%5d %-16s %s\n", job_id, job_originating_user_name, job_name);
}
job_id = 0;
job_name = NULL;
job_originating_user_name = NULL;
continue;
}
else if (!strcmp(attrname, "job-id") &amp;&amp; ippGetValueTag(attr) == IPP_TAG_INTEGER)
job_id = ippGetInteger(attr, 0);
else if (!strcmp(attrname, "job-name") &amp;&amp; ippGetValueTag(attr) == IPP_TAG_NAME)
job_name = ippGetString(attr, 0, NULL);
else if (!strcmp(attrname, "job-originating-user-name") &amp;&amp;
ippGetValueTag(attr) == IPP_TAG_NAME)
job_originating_user_name = ippGetString(attr, 0, NULL);
}
if (job_id > 0)
{
if (job_name == NULL)
job_name = "(withheld)";
if (job_originating_user_name == NULL)
job_originating_user_name = "(withheld)";
printf("%5d %-16s %s\n", job_id, job_originating_user_name, job_name);
}
}
</pre>
<h3><a name='CREATING_URI_STRINGS'>Creating URI Strings</a></h3>
<p>To ensure proper encoding, the
<a href='#httpAssembleURIf'><code>httpAssembleURIf</code></a> function must be
used to format a "printer-uri" string for all printer-based requests:</p>
<pre class='example'>
const char *name = "Foo";
char uri[1024];
<a href='#ipp_t'>ipp_t</a> *request;
<a href='#httpAssembleURIf'>httpAssembleURIf</a>(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, cupsServer(),
ippPort(), "/printers/%s", name);
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
</pre>
<h3><a name='SENDING_REQUESTS_WITH_FILES'>Sending Requests with Files</a></h3>
<p>The <a href='#cupsDoFileRequest'><code>cupsDoFileRequest</code></a> and
<a href='#cupsDoIORequest'><code>cupsDoIORequest</code></a> functions are
used for requests involving files. The
<a href='#cupsDoFileRequest'><code>cupsDoFileRequest</code></a> function
attaches the named file to a request and is typically used when sending a print
file or changing a printer's PPD file:</p>
<pre class='example'>
const char *filename = "/usr/share/cups/data/testprint.ps";
const char *name = "Foo";
char uri[1024];
char resource[1024];
<a href='#ipp_t'>ipp_t</a> *request = <a href='#ippNewRequest'>ippNewRequest</a>(IPP_PRINT_JOB);
<a href='#ipp_t'>ipp_t</a> *response;
/* Use httpAssembleURIf for the printer-uri string */
<a href='#httpAssembleURIf'>httpAssembleURIf</a>(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL, cupsServer(),
ippPort(), "/printers/%s", name);
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL, uri);
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name",
NULL, "testprint.ps");
/* Use snprintf for the resource path */
snprintf(resource, sizeof(resource), "/printers/%s", name);
response = <a href='#cupsDoFileRequest'>cupsDoFileRequest</a>(CUPS_HTTP_DEFAULT, request, resource, filename);
</pre>
<p>The <a href='#cupsDoIORequest'><code>cupsDoIORequest</code></a> function
optionally attaches a file to the request and optionally saves a file in the
response from the server. It is used when using a pipe for the request
attachment or when using a request that returns a file, currently only
<code>CUPS_GET_DOCUMENT</code> and <code>CUPS_GET_PPD</code>. For example,
the following code will download the PPD file for the sample HP LaserJet
printer driver:</p>
<pre class='example'>
char tempfile[1024];
int tempfd;
<a href='#ipp_t'>ipp_t</a> *request = <a href='#ippNewRequest'>ippNewRequest</a>(CUPS_GET_PPD);
<a href='#ipp_t'>ipp_t</a> *response;
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "ppd-name",
NULL, "laserjet.ppd");
tempfd = cupsTempFd(tempfile, sizeof(tempfile));
response = <a href='#cupsDoIORequest'>cupsDoIORequest</a>(CUPS_HTTP_DEFAULT, request, "/", -1, tempfd);
</pre>
<p>The example passes <code>-1</code> for the input file descriptor to specify
that no file is to be attached to the request. The PPD file attached to the
response is written to the temporary file descriptor we created using the
<code>cupsTempFd</code> function.</p>
<h3><a name='ASYNCHRONOUS_REQUEST_PROCESSING'>Asynchronous Request Processing</a></h3>
<p>The <a href='#cupsSendRequest'><code>cupsSendRequest</code></a> and
<a href='#cupsGetResponse'><code>cupsGetResponse</code></a> support
asynchronous communications with the server. Unlike the other request
functions, the IPP request is not automatically freed, so remember to
free your request with the <a href='#ippDelete'><code>ippDelete</code></a>
function.</p>
<p>File data is attached to the request using the
<a href='#cupsWriteRequestData'><code>cupsWriteRequestData</code></a>
function, while file data returned from the server is read using the
<a href='#cupsReadResponseData'><code>cupsReadResponseData</code></a>
function. We can rewrite the previous <code>CUPS_GET_PPD</code> example
to use the asynchronous functions quite easily:</p>
<pre class='example'>
char tempfile[1024];
int tempfd;
<a href='#ipp_t'>ipp_t</a> *request = <a href='#ippNewRequest'>ippNewRequest</a>(CUPS_GET_PPD);
<a href='#ipp_t'>ipp_t</a> *response;
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "ppd-name",
NULL, "laserjet.ppd");
tempfd = cupsTempFd(tempfile, sizeof(tempfile));
if (<a href='#cupsSendRequest'>cupsSendRequest</a>(CUPS_HTTP_DEFAULT, request, "/") == HTTP_CONTINUE)
{
response = <a href='#cupsGetResponse'>cupsGetResponse</a>(CUPS_HTTP_DEFAULT, "/");
if (response != NULL)
{
ssize_t bytes;
char buffer[8192];
while ((bytes = <a href='#cupsReadResponseData'>cupsReadResponseData</a>(CUPS_HTTP_DEFAULT, buffer, sizeof(buffer))) > 0)
write(tempfd, buffer, bytes);
}
}
/* Free the request! */
<a href='#ippDelete'>ippDelete</a>(request);
</pre>
<p>The <a href='#cupsSendRequest'><code>cupsSendRequest</code></a> function
returns the initial HTTP request status, typically either
<code>HTTP_CONTINUE</code> or <code>HTTP_UNAUTHORIZED</code>. The latter status
is returned when the request requires authentication of some sort. The
<a href='#cupsDoAuthentication'><code>cupsDoAuthentication</code></a> function
must be called when your see <code>HTTP_UNAUTHORIZED</code> and the request
re-sent. We can add authentication support to our example code by using a
<code>do ... while</code> loop:</p>
<pre class='example'>
char tempfile[1024];
int tempfd;
<a href='#ipp_t'>ipp_t</a> *request = <a href='#ippNewRequest'>ippNewRequest</a>(CUPS_GET_PPD);
<a href='#ipp_t'>ipp_t</a> *response;
http_status_t status;
<a href='#ippAddString'>ippAddString</a>(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "ppd-name",
NULL, "laserjet.ppd");
tempfd = cupsTempFd(tempfile, sizeof(tempfile));
/* Loop for authentication */
do
{
status = <a href='#cupsSendRequest'>cupsSendRequest</a>(CUPS_HTTP_DEFAULT, request, "/");
if (status == HTTP_UNAUTHORIZED)
{
/* Try to authenticate, break out of the loop if that fails */
if (<a href='#cupsDoAuthentication'>cupsDoAuthentication</a>(CUPS_HTTP_DEFAULT, "POST", "/"))
break;
}
}
while (status != HTTP_CONTINUE &amp;&amp; status != HTTP_UNAUTHORIZED);
if (status == HTTP_CONTINUE)
{
response = <a href='#cupsGetResponse'>cupsGetResponse</a>(CUPS_HTTP_DEFAULT, "/");
if (response != NULL)
{
ssize_t bytes;
char buffer[8192];
while ((bytes = <a href='#cupsReadResponseData'>cupsReadResponseData</a>(CUPS_HTTP_DEFAULT, buffer, sizeof(buffer))) > 0)
write(tempfd, buffer, bytes);
}
}
/* Free the request! */
<a href='#ippDelete'>ippDelete</a>(request);
</pre>
+2 -2
Ver Arquivo
@@ -1,7 +1,7 @@
<!--
PPD API introduction for CUPS.
Copyright 2007-2012 by Apple Inc.
Copyright 2007-2018 by Apple Inc.
Copyright 1997-2006 by Easy Software Products, all rights reserved.
These coded instructions, statements, and computer programs are the
@@ -13,7 +13,7 @@
<h2 class='title'><a name='OVERVIEW'>Overview</a></h2>
<blockquote>The PPD API is deprecated starting in CUPS 1.6/macOS 10.8. Please use the new Job Ticket APIs in the <a href="api-cups.html">CUPS API</a> documentation. These functions will be removed in a future release of CUPS.</blockquote>
<blockquote>The PPD API is deprecated starting in CUPS 1.6/macOS 10.8. Please use the new Job Ticket APIs in the <a href="cupspm.html">CUPS API</a> documentation. These functions will be removed in a future release of CUPS.</blockquote>
<p>The CUPS PPD API provides read-only access the data in PostScript Printer
Description ("PPD") files which are used for all printers with a driver. With
+386 -146
Ver Arquivo
@@ -1,8 +1,8 @@
/*
* Authentication functions for CUPS.
*
* Copyright 2007-2016 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
* Copyright © 2007-2018 by Apple Inc.
* Copyright © 1997-2007 by Easy Software Products.
*
* This file contains Kerberos support code, copyright 2006 by
* Jelmer Vernooij.
@@ -23,11 +23,11 @@
#include "cups-private.h"
#include <fcntl.h>
#include <sys/stat.h>
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
#if HAVE_AUTHORIZATION_H
# include <Security/Authorization.h>
@@ -47,6 +47,10 @@ extern const char *cssmErrorString(int error);
* Local functions...
*/
static const char *cups_auth_find(const char *www_authenticate, const char *scheme);
static const char *cups_auth_param(const char *scheme, const char *name, char *value, size_t valsize);
static const char *cups_auth_scheme(const char *www_authenticate, char *scheme, size_t schemesize);
#ifdef HAVE_GSSAPI
# ifdef HAVE_GSS_ACQUIRE_CRED_EX_F
# ifdef HAVE_GSS_GSSAPI_SPI_H
@@ -112,10 +116,10 @@ cupsDoAuthentication(
const char *resource) /* I - Resource path */
{
const char *password, /* Password string */
*www_auth; /* WWW-Authenticate header */
char prompt[1024], /* Prompt for user */
realm[HTTP_MAX_VALUE], /* realm="xyz" string */
nonce[HTTP_MAX_VALUE]; /* nonce="xyz" string */
*www_auth, /* WWW-Authenticate header */
*schemedata; /* Scheme-specific data */
char scheme[256], /* Scheme name */
prompt[1024]; /* Prompt for user */
int localauth; /* Local authentication result */
_cups_globals_t *cg; /* Global data */
@@ -163,122 +167,129 @@ cupsDoAuthentication(
}
/*
* Nope, see if we should retry the current username:password...
* Nope, loop through the authentication schemes to find the first we support.
*/
www_auth = http->fields[HTTP_FIELD_WWW_AUTHENTICATE];
www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
if ((http->digest_tries > 1 || !http->userpass[0]) &&
(!_cups_strncasecmp(www_auth, "Basic", 5) ||
!_cups_strncasecmp(www_auth, "Digest", 6)))
for (schemedata = cups_auth_scheme(www_auth, scheme, sizeof(scheme)); schemedata; schemedata = cups_auth_scheme(schemedata + strlen(scheme), scheme, sizeof(scheme)))
{
/*
* Nope - get a new password from the user...
* Check the scheme name...
*/
char default_username[HTTP_MAX_VALUE];
/* Default username */
cg = _cupsGlobals();
if (!cg->lang_default)
cg->lang_default = cupsLangDefault();
if (httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "username",
default_username))
cupsSetUser(default_username);
snprintf(prompt, sizeof(prompt),
_cupsLangString(cg->lang_default, _("Password for %s on %s? ")),
cupsUser(),
http->hostname[0] == '/' ? "localhost" : http->hostname);
http->digest_tries = _cups_strncasecmp(www_auth, "Digest", 6) != 0;
http->userpass[0] = '\0';
if ((password = cupsGetPassword2(prompt, http, method, resource)) == NULL)
{
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
snprintf(http->userpass, sizeof(http->userpass), "%s:%s", cupsUser(),
password);
}
else if (http->status == HTTP_STATUS_UNAUTHORIZED)
http->digest_tries ++;
if (http->status == HTTP_STATUS_UNAUTHORIZED && http->digest_tries >= 3)
{
DEBUG_printf(("1cupsDoAuthentication: Too many authentication tries (%d)",
http->digest_tries));
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
/*
* Got a password; encode it for the server...
*/
#ifdef HAVE_GSSAPI
if (!_cups_strncasecmp(www_auth, "Negotiate", 9))
{
if (!_cups_strcasecmp(scheme, "Negotiate"))
{
/*
* Kerberos authentication...
*/
if (_cupsSetNegotiateAuthString(http, method, resource))
{
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
break;
}
else
#endif /* HAVE_GSSAPI */
if (_cups_strcasecmp(scheme, "Basic") && _cups_strcasecmp(scheme, "Digest"))
continue; /* Not supported (yet) */
/*
* Kerberos authentication...
* See if we should retry the current username:password...
*/
if (_cupsSetNegotiateAuthString(http, method, resource))
if ((http->digest_tries > 1 || !http->userpass[0]) && (!_cups_strcasecmp(scheme, "Basic") || (!_cups_strcasecmp(scheme, "Digest"))))
{
/*
* Nope - get a new password from the user...
*/
char default_username[HTTP_MAX_VALUE];
/* Default username */
cg = _cupsGlobals();
if (!cg->lang_default)
cg->lang_default = cupsLangDefault();
if (cups_auth_param(schemedata, "username", default_username, sizeof(default_username)))
cupsSetUser(default_username);
snprintf(prompt, sizeof(prompt), _cupsLangString(cg->lang_default, _("Password for %s on %s? ")), cupsUser(), http->hostname[0] == '/' ? "localhost" : http->hostname);
http->digest_tries = _cups_strncasecmp(scheme, "Digest", 6) != 0;
http->userpass[0] = '\0';
if ((password = cupsGetPassword2(prompt, http, method, resource)) == NULL)
{
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
snprintf(http->userpass, sizeof(http->userpass), "%s:%s", cupsUser(), password);
}
else if (http->status == HTTP_STATUS_UNAUTHORIZED)
http->digest_tries ++;
if (http->status == HTTP_STATUS_UNAUTHORIZED && http->digest_tries >= 3)
{
DEBUG_printf(("1cupsDoAuthentication: Too many authentication tries (%d)", http->digest_tries));
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
}
else
#endif /* HAVE_GSSAPI */
if (!_cups_strncasecmp(www_auth, "Basic", 5))
{
/*
* Basic authentication...
* Got a password; encode it for the server...
*/
char encode[256]; /* Base64 buffer */
if (!_cups_strcasecmp(scheme, "Basic"))
{
/*
* Basic authentication...
*/
char encode[256]; /* Base64 buffer */
httpEncode64_2(encode, sizeof(encode), http->userpass,
(int)strlen(http->userpass));
httpSetAuthString(http, "Basic", encode);
httpEncode64_2(encode, sizeof(encode), http->userpass, (int)strlen(http->userpass));
httpSetAuthString(http, "Basic", encode);
break;
}
else if (!_cups_strcasecmp(scheme, "Digest"))
{
/*
* Digest authentication...
*/
char nonce[HTTP_MAX_VALUE]; /* nonce="xyz" string */
cups_auth_param(schemedata, "algorithm", http->algorithm, sizeof(http->algorithm));
cups_auth_param(schemedata, "opaque", http->opaque, sizeof(http->opaque));
cups_auth_param(schemedata, "nonce", nonce, sizeof(nonce));
cups_auth_param(schemedata, "realm", http->realm, sizeof(http->realm));
if (_httpSetDigestAuthString(http, nonce, method, resource))
break;
}
}
else if (!_cups_strncasecmp(www_auth, "Digest", 6))
if (http->authstring)
{
/*
* Digest authentication...
*/
DEBUG_printf(("1cupsDoAuthentication: authstring=\"%s\"", http->authstring));
char encode[33], /* MD5 buffer */
digest[1024]; /* Digest auth data */
httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "realm", realm);
httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "nonce", nonce);
httpMD5(cupsUser(), realm, strchr(http->userpass, ':') + 1, encode);
httpMD5Final(nonce, method, resource, encode);
snprintf(digest, sizeof(digest),
"username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", "
"response=\"%s\"", cupsUser(), realm, nonce, resource, encode);
httpSetAuthString(http, "Digest", digest);
return (0);
}
else
{
DEBUG_printf(("1cupsDoAuthentication: Unknown auth type: \"%s\"",
www_auth));
DEBUG_printf(("1cupsDoAuthentication: Unknown auth type: \"%s\"", www_auth));
http->status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
return (-1);
}
DEBUG_printf(("1cupsDoAuthentication: authstring=\"%s\"", http->authstring));
return (0);
}
@@ -336,7 +347,7 @@ _cupsSetNegotiateAuthString(
GSS_C_NO_BUFFER, &http->gssmech,
&output_token, NULL, NULL);
#ifdef HAVE_GSS_ACQUIRE_CRED_EX_F
# ifdef HAVE_GSS_ACQUIRE_CRED_EX_F
if (major_status == GSS_S_NO_CRED)
{
/*
@@ -412,7 +423,7 @@ _cupsSetNegotiateAuthString(
}
}
}
#endif /* HAVE_GSS_ACQUIRED_CRED_EX_F */
# endif /* HAVE_GSS_ACQUIRED_CRED_EX_F */
if (GSS_ERROR(major_status))
{
@@ -422,11 +433,11 @@ _cupsSetNegotiateAuthString(
return (-1);
}
#ifdef DEBUG
# ifdef DEBUG
else if (major_status == GSS_S_CONTINUE_NEEDED)
cups_gss_printf(major_status, minor_status,
"_cupsSetNegotiateAuthString: Continuation needed!");
#endif /* DEBUG */
# endif /* DEBUG */
if (output_token.length > 0 && output_token.length <= 65536)
{
@@ -464,8 +475,259 @@ _cupsSetNegotiateAuthString(
return (0);
}
#endif /* HAVE_GSSAPI */
/*
* 'cups_auth_find()' - Find the named WWW-Authenticate scheme.
*
* The "www_authenticate" parameter points to the current position in the header.
*
* Returns @code NULL@ if the auth scheme is not present.
*/
static const char * /* O - Start of matching scheme or @code NULL@ if not found */
cups_auth_find(const char *www_authenticate, /* I - Pointer into WWW-Authenticate header */
const char *scheme) /* I - Authentication scheme */
{
size_t schemelen = strlen(scheme); /* Length of scheme */
DEBUG_printf(("8cups_auth_find(www_authenticate=\"%s\", scheme=\"%s\"(%d))", www_authenticate, scheme, (int)schemelen));
while (*www_authenticate)
{
/*
* Skip leading whitespace and commas...
*/
DEBUG_printf(("9cups_auth_find: Before whitespace: \"%s\"", www_authenticate));
while (isspace(*www_authenticate & 255) || *www_authenticate == ',')
www_authenticate ++;
DEBUG_printf(("9cups_auth_find: After whitespace: \"%s\"", www_authenticate));
/*
* See if this is "Scheme" followed by whitespace or the end of the string.
*/
if (!strncmp(www_authenticate, scheme, schemelen) && (isspace(www_authenticate[schemelen] & 255) || www_authenticate[schemelen] == ',' || !www_authenticate[schemelen]))
{
/*
* Yes, this is the start of the scheme-specific information...
*/
DEBUG_printf(("9cups_auth_find: Returning \"%s\".", www_authenticate));
return (www_authenticate);
}
/*
* Skip the scheme name or param="value" string...
*/
while (!isspace(*www_authenticate & 255) && *www_authenticate)
{
if (*www_authenticate == '\"')
{
/*
* Skip quoted value...
*/
www_authenticate ++;
while (*www_authenticate && *www_authenticate != '\"')
www_authenticate ++;
DEBUG_printf(("9cups_auth_find: After quoted: \"%s\"", www_authenticate));
}
www_authenticate ++;
}
DEBUG_printf(("9cups_auth_find: After skip: \"%s\"", www_authenticate));
}
DEBUG_puts("9cups_auth_find: Returning NULL.");
return (NULL);
}
/*
* 'cups_auth_param()' - Copy the value for the named authentication parameter,
* if present.
*/
static const char * /* O - Parameter value or @code NULL@ if not present */
cups_auth_param(const char *scheme, /* I - Pointer to auth data */
const char *name, /* I - Name of parameter */
char *value, /* I - Value buffer */
size_t valsize) /* I - Size of value buffer */
{
char *valptr = value, /* Pointer into value buffer */
*valend = value + valsize - 1; /* Pointer to end of buffer */
size_t namelen = strlen(name); /* Name length */
int param; /* Is this a parameter? */
DEBUG_printf(("8cups_auth_param(scheme=\"%s\", name=\"%s\", value=%p, valsize=%d)", scheme, name, (void *)value, (int)valsize));
while (!isspace(*scheme & 255) && *scheme)
scheme ++;
while (*scheme)
{
while (isspace(*scheme & 255) || *scheme == ',')
scheme ++;
if (!strncmp(scheme, name, namelen) && scheme[namelen] == '=')
{
/*
* Found the parameter, copy the value...
*/
scheme += namelen + 1;
if (*scheme == '\"')
{
scheme ++;
while (*scheme && *scheme != '\"')
{
if (valptr < valend)
*valptr++ = *scheme;
scheme ++;
}
}
else
{
while (*scheme && strchr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-._~+/=", *scheme))
{
if (valptr < valend)
*valptr++ = *scheme;
scheme ++;
}
}
*valptr = '\0';
DEBUG_printf(("9cups_auth_param: Returning \"%s\".", value));
return (value);
}
/*
* Skip the param=value string...
*/
param = 0;
while (!isspace(*scheme & 255) && *scheme)
{
if (*scheme == '=')
param = 1;
else if (*scheme == '\"')
{
/*
* Skip quoted value...
*/
scheme ++;
while (*scheme && *scheme != '\"')
scheme ++;
}
scheme ++;
}
/*
* If this wasn't a parameter, we are at the end of this scheme's
* parameters...
*/
if (!param)
break;
}
*value = '\0';
DEBUG_puts("9cups_auth_param: Returning NULL.");
return (NULL);
}
/*
* 'cups_auth_scheme()' - Get the (next) WWW-Authenticate scheme.
*
* The "www_authenticate" parameter points to the current position in the header.
*
* Returns @code NULL@ if there are no (more) auth schemes present.
*/
static const char * /* O - Start of scheme or @code NULL@ if not found */
cups_auth_scheme(const char *www_authenticate, /* I - Pointer into WWW-Authenticate header */
char *scheme, /* I - Scheme name buffer */
size_t schemesize) /* I - Size of buffer */
{
const char *start; /* Start of scheme data */
char *sptr = scheme, /* Pointer into scheme buffer */
*send = scheme + schemesize - 1;/* End of scheme buffer */
int param; /* Is this a parameter? */
DEBUG_printf(("8cups_auth_scheme(www_authenticate=\"%s\", scheme=%p, schemesize=%d)", www_authenticate, (void *)scheme, (int)schemesize));
while (*www_authenticate)
{
/*
* Skip leading whitespace and commas...
*/
while (isspace(*www_authenticate & 255) || *www_authenticate == ',')
www_authenticate ++;
/*
* Parse the scheme name or param="value" string...
*/
for (sptr = scheme, start = www_authenticate, param = 0; *www_authenticate && *www_authenticate != ',' && !isspace(*www_authenticate & 255); www_authenticate ++)
{
if (*www_authenticate == '=')
param = 1;
else if (!param && sptr < send)
*sptr++ = *www_authenticate;
else if (*www_authenticate == '\"')
{
/*
* Skip quoted value...
*/
www_authenticate ++;
while (*www_authenticate && *www_authenticate != '\"')
www_authenticate ++;
}
}
if (sptr > scheme && !param)
{
*sptr = '\0';
DEBUG_printf(("9cups_auth_scheme: Returning \"%s\".", start));
return (start);
}
}
*scheme = '\0';
DEBUG_puts("9cups_auth_scheme: Returning NULL.");
return (NULL);
}
#ifdef HAVE_GSSAPI
# ifdef HAVE_GSS_ACQUIRE_CRED_EX_F
/*
* 'cups_gss_acquire()' - Kerberos credentials callback.
@@ -639,9 +901,9 @@ static int /* O - 0 if available */
/* -1 error */
cups_local_auth(http_t *http) /* I - HTTP connection to server */
{
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
/*
* Currently WIN32 and OS-2 do not support the CUPS server...
* Currently _WIN32 and OS-2 do not support the CUPS server...
*/
return (1);
@@ -650,6 +912,8 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
FILE *fp; /* Certificate file */
char trc[16], /* Try Root Certificate parameter */
filename[1024]; /* Certificate filename */
const char *www_auth, /* WWW-Authenticate header */
*schemedata; /* Data for the named auth scheme */
_cups_globals_t *cg = _cupsGlobals(); /* Global data */
# if defined(HAVE_AUTHORIZATION_H)
OSStatus status; /* Status */
@@ -668,13 +932,14 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
* See if we are accessing localhost...
*/
if (!httpAddrLocalhost(http->hostaddr) &&
_cups_strcasecmp(http->hostname, "localhost") != 0)
if (!httpAddrLocalhost(http->hostaddr) && _cups_strcasecmp(http->hostname, "localhost") != 0)
{
DEBUG_puts("8cups_local_auth: Not a local connection!");
return (1);
}
www_auth = httpGetField(http, HTTP_FIELD_WWW_AUTHENTICATE);
# if defined(HAVE_AUTHORIZATION_H)
/*
* Delete any previous authorization reference...
@@ -686,12 +951,9 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
http->auth_ref = NULL;
}
if (!getenv("GATEWAY_INTERFACE") &&
httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "authkey",
auth_key, sizeof(auth_key)))
if (!getenv("GATEWAY_INTERFACE") && (schemedata = cups_auth_find(www_auth, "AuthRef")) != NULL && cups_auth_param(schemedata, "key", auth_key, sizeof(auth_key)))
{
status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment,
kAuthorizationFlagDefaults, &http->auth_ref);
status = AuthorizationCreate(NULL, kAuthorizationEmptyEnvironment, kAuthorizationFlagDefaults, &http->auth_ref);
if (status != errAuthorizationSuccess)
{
DEBUG_printf(("8cups_local_auth: AuthorizationCreate() returned %d (%s)",
@@ -745,6 +1007,11 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
}
# endif /* HAVE_AUTHORIZATION_H */
# ifdef HAVE_GSSAPI
if (cups_auth_find(www_auth, "Negotiate"))
return (1);
# endif /* HAVE_GSSAPI */
# if defined(SO_PEERCRED) && defined(AF_LOCAL)
/*
* See if we can authenticate using the peer credentials provided over a
@@ -752,16 +1019,9 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
* information...
*/
if (
# ifdef HAVE_GSSAPI
_cups_strncasecmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE], "Negotiate", 9) &&
# endif /* HAVE_GSSAPI */
# ifdef HAVE_AUTHORIZATION_H
!httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "authkey",
auth_key, sizeof(auth_key)) &&
# endif /* HAVE_AUTHORIZATION_H */
http->hostaddr->addr.sa_family == AF_LOCAL &&
!getenv("GATEWAY_INTERFACE")) /* Not via CGI programs... */
if (http->hostaddr->addr.sa_family == AF_LOCAL &&
!getenv("GATEWAY_INTERFACE") && /* Not via CGI programs... */
cups_auth_find(www_auth, "PeerCred"))
{
/*
* Verify that the current cupsUser() matches the current UID...
@@ -784,6 +1044,9 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
}
# endif /* SO_PEERCRED && AF_LOCAL */
if ((schemedata = cups_auth_find(www_auth, "Local")) == NULL)
return (1);
/*
* Try opening a certificate file for this PID. If that fails,
* try the root certificate...
@@ -797,33 +1060,9 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
* No certificate for this PID; see if we can get the root certificate...
*/
DEBUG_printf(("9cups_local_auth: Unable to open file %s: %s",
filename, strerror(errno)));
DEBUG_printf(("9cups_local_auth: Unable to open file \"%s\": %s", filename, strerror(errno)));
# ifdef HAVE_GSSAPI
if (!_cups_strncasecmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE], "Negotiate", 9))
{
/*
* Kerberos required, don't try the root certificate...
*/
return (1);
}
# endif /* HAVE_GSSAPI */
# ifdef HAVE_AUTHORIZATION_H
if (httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "authkey",
auth_key, sizeof(auth_key)))
{
/*
* Don't use the root certificate as a replacement for an authkey...
*/
return (1);
}
# endif /* HAVE_AUTHORIZATION_H */
if (!httpGetSubField2(http, HTTP_FIELD_WWW_AUTHENTICATE, "trc", trc,
sizeof(trc)))
if (!cups_auth_param(schemedata, "trc", trc, sizeof(trc)))
{
/*
* Scheduler doesn't want us to use the root certificate...
@@ -833,7 +1072,8 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
}
snprintf(filename, sizeof(filename), "%s/certs/0", cg->cups_statedir);
fp = fopen(filename, "r");
if ((fp = fopen(filename, "r")) == NULL)
DEBUG_printf(("9cups_local_auth: Unable to open file \"%s\": %s", filename, strerror(errno)));
}
if (fp)
@@ -864,5 +1104,5 @@ cups_local_auth(http_t *http) /* I - HTTP connection to server */
}
return (1);
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
}
+6 -6
Ver Arquivo
@@ -19,12 +19,12 @@
#include "cups.h"
#include <errno.h>
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
# include <fcntl.h>
#else
# include <sys/time.h>
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -77,11 +77,11 @@ cupsBackChannelRead(char *buffer, /* I - Buffer to read into */
* Read bytes from the pipe...
*/
#ifdef WIN32
#ifdef _WIN32
return ((ssize_t)_read(3, buffer, (unsigned)bytes));
#else
return (read(3, buffer, bytes));
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -139,11 +139,11 @@ cupsBackChannelWrite(
* Write bytes to the pipe...
*/
#ifdef WIN32
#ifdef _WIN32
count = (ssize_t)_write(3, buffer, (unsigned)(bytes - total));
#else
count = write(3, buffer, bytes - total);
#endif /* WIN32 */
#endif /* _WIN32 */
if (count < 0)
{
+8 -5
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* API definitions for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -21,12 +21,12 @@
*/
# include <sys/types.h>
# if defined(WIN32) && !defined(__CUPS_SSIZE_T_DEFINED)
# if defined(_WIN32) && !defined(__CUPS_SSIZE_T_DEFINED)
# define __CUPS_SSIZE_T_DEFINED
# include <stddef.h>
/* Windows does not support the ssize_t type, so map it to long... */
typedef long ssize_t; /* @private@ */
# endif /* WIN32 && !__CUPS_SSIZE_T_DEFINED */
# endif /* _WIN32 && !__CUPS_SSIZE_T_DEFINED */
# include "file.h"
# include "ipp.h"
@@ -47,10 +47,10 @@ extern "C" {
* Constants...
*/
# define CUPS_VERSION 2.0204
# define CUPS_VERSION 2.0209
# define CUPS_VERSION_MAJOR 2
# define CUPS_VERSION_MINOR 2
# define CUPS_VERSION_PATCH 4
# define CUPS_VERSION_PATCH 9
# define CUPS_BC_FD 3
/* Back-channel file descriptor for
@@ -606,6 +606,9 @@ extern ssize_t cupsHashData(const char *algorithm, const void *data, size_t dat
extern int cupsAddIntegerOption(const char *name, int value, int num_options, cups_option_t **options) _CUPS_API_2_2_4;
extern int cupsGetIntegerOption(const char *name, int num_options, cups_option_t *options) _CUPS_API_2_2_4;
/* New in CUPS 2.2.7 */
extern const char *cupsHashString(const unsigned char *hash, size_t hashsize, char *buffer, size_t bufsize) _CUPS_API_2_2_7;
# ifdef __cplusplus
}
# endif /* __cplusplus */
+3 -3
Ver Arquivo
@@ -2,7 +2,7 @@
title: CUPS Programming Manual
author: Michael R Sweet
copyright: Copyright © 2007-2017 by Apple Inc. All Rights Reserved.
version: 2.2.4
version: 2.2.5
...
> Please [file issues on Github](https://github.com/apple/cups/issues) to
@@ -925,7 +925,7 @@ their values:
IPP_TAG_ENUM)) != NULL)
{
printf("printer-state=%s\n",
ippTagString("printer-state", ippGetInteger(attr, 0)));
ippEnumString("printer-state", ippGetInteger(attr, 0)));
}
else
puts("printer-state=unknown");
@@ -952,7 +952,7 @@ 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 `ippTagString` function converts a enum value to its keyword (string)
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`
+7 -20
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Private debugging macros for CUPS.
*
* Copyright 2007-2012 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2005 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -67,20 +67,10 @@ extern "C" {
*/
# ifdef DEBUG
# ifdef WIN32
# ifdef LIBCUPS2_EXPORTS
# define DLLExport __declspec(dllexport)
# else
# define DLLExport
# endif /* LIBCUPS2_EXPORTS */
# else
# define DLLExport
# endif /* WIN32 */
# define DEBUG_puts(x) _cups_debug_puts(x)
# define DEBUG_printf(x) _cups_debug_printf x
# define DEBUG_set(logfile,level,filter) _cups_debug_set(logfile,level,filter,1)
# else
# define DLLExport
# define DEBUG_puts(x)
# define DEBUG_printf(x)
# define DEBUG_set(logfile,level,filter)
@@ -93,16 +83,13 @@ extern "C" {
extern int _cups_debug_fd;
extern int _cups_debug_level;
extern void DLLExport _cups_debug_printf(const char *format, ...)
__attribute__ ((__format__ (__printf__, 1, 2)));
extern void DLLExport _cups_debug_puts(const char *s);
extern void DLLExport _cups_debug_set(const char *logfile,
const char *level, const char *filter,
int force);
# ifdef WIN32
extern int _cups_gettimeofday(struct timeval *tv, void *tz);
extern void _cups_debug_printf(const char *format, ...) _CUPS_FORMAT(1, 2);
extern void _cups_debug_puts(const char *s);
extern void _cups_debug_set(const char *logfile, const char *level, const char *filter, int force) _CUPS_PRIVATE;
# ifdef _WIN32
extern int _cups_gettimeofday(struct timeval *tv, void *tz) _CUPS_PRIVATE;
# define gettimeofday(a,b) _cups_gettimeofday(a, b)
# endif /* WIN32 */
# endif /* _WIN32 */
# ifdef __cplusplus
}
+5 -5
Ver Arquivo
@@ -18,7 +18,7 @@
#include "cups-private.h"
#include "thread-private.h"
#ifdef WIN32
#ifdef _WIN32
# include <sys/timeb.h>
# include <time.h>
# include <io.h>
@@ -36,7 +36,7 @@ _cups_gettimeofday(struct timeval *tv, /* I - Timeval struct */
#else
# include <sys/time.h>
# include <unistd.h>
#endif /* WIN32 */
#endif /* _WIN32 */
#include <regex.h>
#include <fcntl.h>
@@ -83,7 +83,7 @@ debug_thread_id(void)
* '_cups_debug_printf()' - Write a formatted line to the log.
*/
void DLLExport
void
_cups_debug_printf(const char *format, /* I - Printf-style format string */
...) /* I - Additional arguments as needed */
{
@@ -168,7 +168,7 @@ _cups_debug_printf(const char *format, /* I - Printf-style format string */
* '_cups_debug_puts()' - Write a single line to the log.
*/
void DLLExport
void
_cups_debug_puts(const char *s) /* I - String to output */
{
struct timeval curtime; /* Current time */
@@ -248,7 +248,7 @@ _cups_debug_puts(const char *s) /* I - String to output */
* '_cups_debug_set()' - Enable or disable debug logging.
*/
void DLLExport
void
_cups_debug_set(const char *logfile, /* I - Log file or NULL */
const char *level, /* I - Log level or NULL */
const char *filter, /* I - Filter string or NULL */
+43 -7
Ver Arquivo
@@ -60,12 +60,15 @@ cupsLocalizeDestMedia(
*ltype; /* Localized media type */
DEBUG_printf(("cupsLocalizeDestMedia(http=%p, dest=%p, dinfo=%p, flags=%x, size=%p(\"%s\"))", (void *)http, (void *)dest, (void *)dinfo, flags, (void *)size, size ? size->media : "(null)"));
/*
* Range check input...
*/
if (!http || !dest || !dinfo || !size)
{
DEBUG_puts("1cupsLocalizeDestMedia: Returning NULL.");
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(EINVAL), 0);
return (NULL);
}
@@ -79,13 +82,24 @@ cupsLocalizeDestMedia(
key.id = size->media;
if ((match = (_cups_message_t *)cupsArrayFind(dinfo->localizations, &key)) != NULL)
{
DEBUG_printf(("1cupsLocalizeDestMedia: Returning \"%s\".", match->str));
return (match->str);
}
/*
* If not, get the localized size, source, and type strings...
*/
lang = cupsLangDefault();
snprintf(temp, sizeof(temp), "media.%s", size->media);
if ((lsize = _cupsLangString(lang, temp)) != NULL && strcmp(lsize, temp))
{
DEBUG_printf(("1cupsLocalizeDestMedia: Returning standard localization \"%s\".", lsize));
return (lsize);
}
pwg = pwgMediaForSize(size->width, size->length);
if (pwg->ppd)
@@ -101,7 +115,7 @@ cupsLocalizeDestMedia(
* Use inches since the size is a multiple of 1/4 inch.
*/
snprintf(temp, sizeof(temp), _cupsLangString(lang, _("%g x %g")), size->width / 2540.0, size->length / 2540.0);
snprintf(temp, sizeof(temp), _cupsLangString(lang, _("%g x %g \"")), size->width / 2540.0, size->length / 2540.0);
}
else
{
@@ -189,6 +203,8 @@ cupsLocalizeDestMedia(
cupsArrayAdd(dinfo->localizations, match);
DEBUG_printf(("1cupsLocalizeDestMedia: Returning \"%s\".", match->str));
return (match->str);
}
@@ -212,21 +228,23 @@ cupsLocalizeDestOption(
{
_cups_message_t key, /* Search key */
*match; /* Matching entry */
const char *localized; /* Localized string */
DEBUG_printf(("cupsLocalizeDestOption(http=%p, dest=%p, dinfo=%p, option=\"%s\")", (void *)http, (void *)dest, (void *)dinfo, option));
if (!http || !dest || !dinfo)
return (option);
if (!dinfo->localizations)
cups_create_localizations(http, dinfo);
if (cupsArrayCount(dinfo->localizations) == 0)
return (option);
key.id = (char *)option;
if ((match = (_cups_message_t *)cupsArrayFind(dinfo->localizations,
&key)) != NULL)
return (match->str);
else if ((localized = _cupsLangString(cupsLangDefault(), option)) != NULL)
return (localized);
else
return (option);
}
@@ -253,22 +271,40 @@ cupsLocalizeDestValue(
_cups_message_t key, /* Search key */
*match; /* Matching entry */
char pair[256]; /* option.value pair */
const char *localized; /* Localized string */
DEBUG_printf(("cupsLocalizeDestValue(http=%p, dest=%p, dinfo=%p, option=\"%s\", value=\"%s\")", (void *)http, (void *)dest, (void *)dinfo, option, value));
if (!http || !dest || !dinfo)
return (value);
if (!strcmp(option, "media"))
{
pwg_media_t *media = pwgMediaForPWG(value);
cups_size_t size;
strlcpy(size.media, value, sizeof(size.media));
size.width = media ? media->width : 0;
size.length = media ? media->length : 0;
size.left = 0;
size.right = 0;
size.bottom = 0;
size.top = 0;
return (cupsLocalizeDestMedia(http, dest, dinfo, CUPS_MEDIA_FLAGS_DEFAULT, &size));
}
if (!dinfo->localizations)
cups_create_localizations(http, dinfo);
if (cupsArrayCount(dinfo->localizations) == 0)
return (value);
snprintf(pair, sizeof(pair), "%s.%s", option, value);
key.id = pair;
if ((match = (_cups_message_t *)cupsArrayFind(dinfo->localizations,
&key)) != NULL)
return (match->str);
else if ((localized = _cupsLangString(cupsLangDefault(), pair)) != NULL && strcmp(localized, pair))
return (localized);
else
return (value);
}
+502 -425
Ver Arquivo
Diferenças do arquivo suprimidas por serem muito extensas Carregar Diff
+5 -5
Ver Arquivo
@@ -26,7 +26,7 @@
* Windows implementation...
*/
#ifdef WIN32
#ifdef _WIN32
# include <windows.h>
/*
@@ -145,7 +145,7 @@ cupsDirOpen(const char *directory) /* I - Directory name */
cups_dentry_t * /* O - Directory entry or @code NULL@ if there are no more */
cupsDirRead(cups_dir_t *dp) /* I - Directory pointer */
{
WIN32_FIND_DATA entry; /* Directory entry data */
WIN32_FIND_DATAA entry; /* Directory entry data */
/*
@@ -165,11 +165,11 @@ cupsDirRead(cups_dir_t *dp) /* I - Directory pointer */
* No, find the first file...
*/
dp->dir = FindFirstFile(dp->directory, &entry);
dp->dir = FindFirstFileA(dp->directory, &entry);
if (dp->dir == INVALID_HANDLE_VALUE)
return (NULL);
}
else if (!FindNextFile(dp->dir, &entry))
else if (!FindNextFileA(dp->dir, &entry))
return (NULL);
/*
@@ -422,4 +422,4 @@ cupsDirRewind(cups_dir_t *dp) /* I - Directory pointer */
rewinddir(dp->dir);
}
#endif /* WIN32 */
#endif /* _WIN32 */
+4 -30
Ver Arquivo
@@ -6,7 +6,7 @@
* our own file functions allows us to provide transparent support of
* different line endings, gzip'd print files, PPD files, etc.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -31,13 +31,10 @@
# include <stdarg.h>
# include <fcntl.h>
# ifdef HAVE_LIBZ
# include <zlib.h>
# endif /* HAVE_LIBZ */
# ifdef WIN32
# ifdef _WIN32
# include <io.h>
# include <sys/locking.h>
# endif /* WIN32 */
# endif /* _WIN32 */
/*
@@ -88,30 +85,6 @@ typedef enum /**** _cupsFileCheck file type values ****/
typedef void (*_cups_fc_func_t)(void *context, _cups_fc_result_t result,
const char *message);
struct _cups_file_s /**** CUPS file structure... ****/
{
int fd; /* File descriptor */
char mode, /* Mode ('r' or 'w') */
compressed, /* Compression used? */
is_stdio, /* stdin/out/err? */
eof, /* End of file? */
buf[4096], /* Buffer */
*ptr, /* Pointer into buffer */
*end; /* End of buffer data */
off_t pos, /* Position in file */
bufpos; /* File position for start of buffer */
#ifdef HAVE_LIBZ
z_stream stream; /* (De)compression stream */
Bytef cbuf[4096]; /* (De)compression buffer */
uLong crc; /* (De)compression CRC */
#endif /* HAVE_LIBZ */
char *printf_buffer; /* cupsFilePrintf buffer */
size_t printf_size; /* Size of cupsFilePrintf buffer */
};
/*
* Prototypes...
@@ -125,6 +98,7 @@ extern _cups_fc_result_t _cupsFileCheck(const char *filename,
extern void _cupsFileCheckFilter(void *context,
_cups_fc_result_t result,
const char *message);
extern int _cupsFilePeekAhead(cups_file_t *fp, int ch);
# ifdef __cplusplus
}
+72 -25
Ver Arquivo
@@ -6,7 +6,7 @@
* our own file functions allows us to provide transparent support of
* different line endings, gzip'd print files, PPD files, etc.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -26,6 +26,39 @@
#include <sys/stat.h>
#include <sys/types.h>
# ifdef HAVE_LIBZ
# include <zlib.h>
# endif /* HAVE_LIBZ */
/*
* Internal structures...
*/
struct _cups_file_s /**** CUPS file structure... ****/
{
int fd; /* File descriptor */
char mode, /* Mode ('r' or 'w') */
compressed, /* Compression used? */
is_stdio, /* stdin/out/err? */
eof, /* End of file? */
buf[4096], /* Buffer */
*ptr, /* Pointer into buffer */
*end; /* End of buffer data */
off_t pos, /* Position in file */
bufpos; /* File position for start of buffer */
#ifdef HAVE_LIBZ
z_stream stream; /* (De)compression stream */
Bytef cbuf[4096]; /* (De)compression buffer */
uLong crc; /* (De)compression CRC */
#endif /* HAVE_LIBZ */
char *printf_buffer; /* cupsFilePrintf buffer */
size_t printf_size; /* Size of cupsFilePrintf buffer */
};
/*
* Local functions...
@@ -40,7 +73,7 @@ static ssize_t cups_read(cups_file_t *fp, char *buf, size_t bytes);
static ssize_t cups_write(cups_file_t *fp, const char *buf, size_t bytes);
#ifndef WIN32
#ifndef _WIN32
/*
* '_cupsFileCheck()' - Check the permissions of the given filename.
*/
@@ -306,7 +339,7 @@ _cupsFileCheckFilter(
fprintf(stderr, "%s: %s\n", prefix, message);
}
#endif /* !WIN32 */
#endif /* !_WIN32 */
/*
@@ -526,22 +559,22 @@ cupsFileFind(const char *filename, /* I - File to find */
while (*path)
{
#ifdef WIN32
#ifdef _WIN32
if (*path == ';' || (*path == ':' && ((bufptr - buffer) > 1 || !isalpha(buffer[0] & 255))))
#else
if (*path == ';' || *path == ':')
#endif /* WIN32 */
#endif /* _WIN32 */
{
if (bufptr > buffer && bufptr[-1] != '/' && bufptr < bufend)
*bufptr++ = '/';
strlcpy(bufptr, filename, (size_t)(bufend - bufptr));
#ifdef WIN32
#ifdef _WIN32
if (!access(buffer, 0))
#else
if (!access(buffer, executable ? X_OK : 0))
#endif /* WIN32 */
#endif /* _WIN32 */
{
DEBUG_printf(("1cupsFileFind: Returning \"%s\"", buffer));
return (buffer);
@@ -992,11 +1025,11 @@ cupsFileLock(cups_file_t *fp, /* I - CUPS file */
* Try the lock...
*/
#ifdef WIN32
#ifdef _WIN32
return (_locking(fp->fd, block ? _LK_LOCK : _LK_NBLCK, 0));
#else
return (lockf(fp->fd, block ? F_LOCK : F_TLOCK, 0));
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -1084,11 +1117,11 @@ cupsFileOpen(const char *filename, /* I - Name of file */
}
if (fd >= 0)
#ifdef WIN32
#ifdef _WIN32
_chsize(fd, 0);
#else
ftruncate(fd, 0);
#endif /* WIN32 */
#endif /* _WIN32 */
break;
case 's' : /* Read/write socket */
@@ -1255,14 +1288,26 @@ cupsFileOpenFd(int fd, /* I - File descriptor */
* Don't pass this file to child processes...
*/
#ifndef WIN32
#ifndef _WIN32
fcntl(fp->fd, F_SETFD, fcntl(fp->fd, F_GETFD) | FD_CLOEXEC);
#endif /* !WIN32 */
#endif /* !_WIN32 */
return (fp);
}
/*
* '_cupsFilePeekAhead()' - See if the requested character is buffered up.
*/
int /* O - 1 if present, 0 otherwise */
_cupsFilePeekAhead(cups_file_t *fp, /* I - CUPS file */
int ch) /* I - Character */
{
return (fp && fp->ptr && memchr(fp->ptr, ch, (size_t)(fp->end - fp->ptr)));
}
/*
* 'cupsFilePeekChar()' - Peek at the next character from a file.
*
@@ -2019,11 +2064,11 @@ cupsFileUnlock(cups_file_t *fp) /* I - CUPS file */
* Unlock...
*/
#ifdef WIN32
#ifdef _WIN32
return (_locking(fp->fd, _LK_UNLCK, 0));
#else
return (lockf(fp->fd, F_ULOCK, 0));
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -2477,6 +2522,8 @@ cups_fill(cups_file_t *fp) /* I - CUPS file */
* file header...
*/
inflateEnd(&fp->stream);
fp->compressed = 0;
}
else if (status < Z_OK)
@@ -2551,9 +2598,9 @@ cups_open(const char *filename, /* I - Filename */
{
int fd; /* File descriptor */
struct stat fileinfo; /* File information */
#ifndef WIN32
#ifndef _WIN32
struct stat linkinfo; /* Link information */
#endif /* !WIN32 */
#endif /* !_WIN32 */
/*
@@ -2581,18 +2628,18 @@ cups_open(const char *filename, /* I - Filename */
return (-1);
}
#ifdef WIN32
#ifdef _WIN32
if (fileinfo.st_mode & _S_IFDIR)
#else
if (S_ISDIR(fileinfo.st_mode))
#endif /* WIN32 */
#endif /* _WIN32 */
{
close(fd);
errno = EISDIR;
return (-1);
}
#ifndef WIN32
#ifndef _WIN32
/*
* Then use lstat to determine whether the filename is a symlink...
*/
@@ -2620,7 +2667,7 @@ cups_open(const char *filename, /* I - Filename */
errno = EPERM;
return (-1);
}
#endif /* !WIN32 */
#endif /* !_WIN32 */
return (fd);
}
@@ -2646,7 +2693,7 @@ cups_read(cups_file_t *fp, /* I - CUPS file */
for (;;)
{
#ifdef WIN32
#ifdef _WIN32
if (fp->mode == 's')
total = (ssize_t)recv(fp->fd, buf, (unsigned)bytes, 0);
else
@@ -2656,7 +2703,7 @@ cups_read(cups_file_t *fp, /* I - CUPS file */
total = recv(fp->fd, buf, bytes, 0);
else
total = read(fp->fd, buf, bytes);
#endif /* WIN32 */
#endif /* _WIN32 */
DEBUG_printf(("9cups_read: total=" CUPS_LLFMT, CUPS_LLCAST total));
@@ -2703,7 +2750,7 @@ cups_write(cups_file_t *fp, /* I - CUPS file */
total = 0;
while (bytes > 0)
{
#ifdef WIN32
#ifdef _WIN32
if (fp->mode == 's')
count = (ssize_t)send(fp->fd, buf, (unsigned)bytes, 0);
else
@@ -2713,7 +2760,7 @@ cups_write(cups_file_t *fp, /* I - CUPS file */
count = send(fp->fd, buf, bytes, 0);
else
count = write(fp->fd, buf, bytes);
#endif /* WIN32 */
#endif /* _WIN32 */
DEBUG_printf(("9cups_write: count=" CUPS_LLFMT, CUPS_LLCAST count));
+4 -6
Ver Arquivo
@@ -6,7 +6,7 @@
* our own file functions allows us to provide transparent support of
* different line endings, gzip'd print files, PPD files, etc.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -29,11 +29,11 @@
# include "versioning.h"
# include <stddef.h>
# include <sys/types.h>
# if defined(WIN32) && !defined(__CUPS_SSIZE_T_DEFINED)
# if defined(_WIN32) && !defined(__CUPS_SSIZE_T_DEFINED)
# define __CUPS_SSIZE_T_DEFINED
/* Windows does not support the ssize_t type, so map it to off_t... */
typedef off_t ssize_t; /* @private@ */
# endif /* WIN32 && !__CUPS_SSIZE_T_DEFINED */
# endif /* _WIN32 && !__CUPS_SSIZE_T_DEFINED */
/*
@@ -85,9 +85,7 @@ extern cups_file_t *cupsFileOpen(const char *filename, const char *mode)
_CUPS_API_1_2;
extern cups_file_t *cupsFileOpenFd(int fd, const char *mode) _CUPS_API_1_2;
extern int cupsFilePeekChar(cups_file_t *fp) _CUPS_API_1_2;
extern int cupsFilePrintf(cups_file_t *fp, const char *format, ...)
__attribute__((__format__ (__printf__, 2, 3)))
_CUPS_API_1_2;
extern int cupsFilePrintf(cups_file_t *fp, const char *format, ...) _CUPS_FORMAT(2, 3) _CUPS_API_1_2;
extern int cupsFilePutChar(cups_file_t *fp, int c) _CUPS_API_1_2;
extern ssize_t cupsFilePutConf(cups_file_t *fp, const char *directive,
const char *value) _CUPS_API_1_4;
+65 -5
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Get/put file functions for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -20,11 +20,11 @@
#include "cups-private.h"
#include <fcntl.h>
#include <sys/stat.h>
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
/*
@@ -45,6 +45,8 @@ cupsGetFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
http_status_t status; /* HTTP status from server */
char if_modified_since[HTTP_MAX_VALUE];
/* If-Modified-Since header */
int new_auth = 0; /* Using new auth information? */
int digest; /* Are we using Digest authentication? */
/*
@@ -85,9 +87,33 @@ cupsGetFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
}
httpClearFields(http);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, http->authstring);
httpSetField(http, HTTP_FIELD_IF_MODIFIED_SINCE, if_modified_since);
digest = http->authstring && !strncmp(http->authstring, "Digest ", 7);
if (digest && !new_auth)
{
/*
* Update the Digest authentication string...
*/
_httpSetDigestAuthString(http, http->nextnonce, "GET", resource);
}
#ifdef HAVE_GSSAPI
if (http->authstring && !strncmp(http->authstring, "Negotiate", 9) && !new_auth)
{
/*
* Do not use cached Kerberos credentials since they will look like a
* "replay" attack...
*/
_cupsSetNegotiateAuthString(http, "GET", resource);
}
#endif /* HAVE_GSSAPI */
httpSetField(http, HTTP_FIELD_AUTHORIZATION, http->authstring);
if (httpGet(http, resource))
{
if (httpReconnect2(http, 30000, NULL))
@@ -102,6 +128,8 @@ cupsGetFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
}
}
new_auth = 0;
while ((status = httpUpdate(http)) == HTTP_STATUS_CONTINUE);
if (status == HTTP_STATUS_UNAUTHORIZED)
@@ -116,6 +144,8 @@ cupsGetFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
* See if we can do authentication...
*/
new_auth = 1;
if (cupsDoAuthentication(http, "GET", resource))
{
status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
@@ -267,6 +297,8 @@ cupsPutFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
int retries; /* Number of retries */
char buffer[8192]; /* Buffer for file */
http_status_t status; /* HTTP status from server */
int new_auth = 0; /* Using new auth information? */
int digest; /* Are we using Digest authentication? */
/*
@@ -309,10 +341,34 @@ cupsPutFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
http->authstring));
httpClearFields(http);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, http->authstring);
httpSetField(http, HTTP_FIELD_TRANSFER_ENCODING, "chunked");
httpSetExpect(http, HTTP_STATUS_CONTINUE);
digest = http->authstring && !strncmp(http->authstring, "Digest ", 7);
if (digest && !new_auth)
{
/*
* Update the Digest authentication string...
*/
_httpSetDigestAuthString(http, http->nextnonce, "PUT", resource);
}
#ifdef HAVE_GSSAPI
if (http->authstring && !strncmp(http->authstring, "Negotiate", 9) && !new_auth)
{
/*
* Do not use cached Kerberos credentials since they will look like a
* "replay" attack...
*/
_cupsSetNegotiateAuthString(http, "PUT", resource);
}
#endif /* HAVE_GSSAPI */
httpSetField(http, HTTP_FIELD_AUTHORIZATION, http->authstring);
if (httpPut(http, resource))
{
if (httpReconnect2(http, 30000, NULL))
@@ -383,6 +439,8 @@ cupsPutFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
DEBUG_printf(("2cupsPutFd: status=%d", status));
new_auth = 0;
if (status == HTTP_STATUS_UNAUTHORIZED)
{
/*
@@ -395,6 +453,8 @@ cupsPutFd(http_t *http, /* I - Connection to server or @code CUPS_HTTP_DEFA
* See if we can do authentication...
*/
new_auth = 1;
if (cupsDoAuthentication(http, "PUT", resource))
{
status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
+16 -16
Ver Arquivo
@@ -34,23 +34,23 @@ static _cups_threadkey_t cups_globals_key = _CUPS_THREADKEY_INITIALIZER;
static pthread_once_t cups_globals_key_once = PTHREAD_ONCE_INIT;
/* One-time initialization object */
#endif /* HAVE_PTHREAD_H */
#if defined(HAVE_PTHREAD_H) || defined(WIN32)
#if defined(HAVE_PTHREAD_H) || defined(_WIN32)
static _cups_mutex_t cups_global_mutex = _CUPS_MUTEX_INITIALIZER;
/* Global critical section */
#endif /* HAVE_PTHREAD_H || WIN32 */
#endif /* HAVE_PTHREAD_H || _WIN32 */
/*
* Local functions...
*/
#ifdef WIN32
#ifdef _WIN32
static void cups_fix_path(char *path);
#endif /* WIN32 */
#endif /* _WIN32 */
static _cups_globals_t *cups_globals_alloc(void);
#if defined(HAVE_PTHREAD_H) || defined(WIN32)
#if defined(HAVE_PTHREAD_H) || defined(_WIN32)
static void cups_globals_free(_cups_globals_t *g);
#endif /* HAVE_PTHREAD_H || WIN32 */
#endif /* HAVE_PTHREAD_H || _WIN32 */
#ifdef HAVE_PTHREAD_H
static void cups_globals_init(void);
#endif /* HAVE_PTHREAD_H */
@@ -65,7 +65,7 @@ _cupsGlobalLock(void)
{
#ifdef HAVE_PTHREAD_H
pthread_mutex_lock(&cups_global_mutex);
#elif defined(WIN32)
#elif defined(_WIN32)
EnterCriticalSection(&cups_global_mutex.m_criticalSection);
#endif /* HAVE_PTHREAD_H */
}
@@ -120,13 +120,13 @@ _cupsGlobalUnlock(void)
{
#ifdef HAVE_PTHREAD_H
pthread_mutex_unlock(&cups_global_mutex);
#elif defined(WIN32)
#elif defined(_WIN32)
LeaveCriticalSection(&cups_global_mutex.m_criticalSection);
#endif /* HAVE_PTHREAD_H */
}
#ifdef WIN32
#ifdef _WIN32
/*
* 'DllMain()' - Main entry for library.
*/
@@ -170,7 +170,7 @@ DllMain(HINSTANCE hinst, /* I - DLL module handle */
return (TRUE);
}
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -182,13 +182,13 @@ cups_globals_alloc(void)
{
_cups_globals_t *cg = malloc(sizeof(_cups_globals_t));
/* Pointer to global data */
#ifdef WIN32
#ifdef _WIN32
HKEY key; /* Registry key */
DWORD size; /* Size of string */
static char installdir[1024] = "", /* Install directory */
confdir[1024] = "", /* Server root directory */
localedir[1024] = ""; /* Locale directory */
#endif /* WIN32 */
#endif /* _WIN32 */
if (!cg)
@@ -219,7 +219,7 @@ cups_globals_alloc(void)
* Then set directories as appropriate...
*/
#ifdef WIN32
#ifdef _WIN32
if (!installdir[0])
{
/*
@@ -315,7 +315,7 @@ cups_globals_alloc(void)
if ((cg->localedir = getenv("LOCALEDIR")) == NULL)
cg->localedir = CUPS_LOCALEDIR;
}
#endif /* WIN32 */
#endif /* _WIN32 */
return (cg);
}
@@ -325,7 +325,7 @@ cups_globals_alloc(void)
* 'cups_globals_free()' - Free global data.
*/
#if defined(HAVE_PTHREAD_H) || defined(WIN32)
#if defined(HAVE_PTHREAD_H) || defined(_WIN32)
static void
cups_globals_free(_cups_globals_t *cg) /* I - Pointer to global data */
{
@@ -360,7 +360,7 @@ cups_globals_free(_cups_globals_t *cg) /* I - Pointer to global data */
free(cg);
}
#endif /* HAVE_PTHREAD_H || WIN32 */
#endif /* HAVE_PTHREAD_H || _WIN32 */
#ifdef HAVE_PTHREAD_H
+86 -5
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Hashing function for CUPS.
*
* Copyright 2015-2016 by Apple Inc.
* Copyright © 2015-2018 by Apple Inc.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -21,6 +21,8 @@
# include <CommonCrypto/CommonDigest.h>
#elif defined(HAVE_GNUTLS)
# include <gnutls/crypto.h>
#else
# include "md5-private.h"
#endif /* __APPLE__ */
@@ -53,7 +55,24 @@ cupsHashData(const char *algorithm, /* I - Algorithm name */
}
#ifdef __APPLE__
if (!strcmp(algorithm, "sha"))
if (!strcmp(algorithm, "md5"))
{
/*
* MD5 (deprecated but widely used...)
*/
CC_MD5_CTX ctx; /* MD5 context */
if (hashsize < CC_MD5_DIGEST_LENGTH)
goto too_small;
CC_MD5_Init(&ctx);
CC_MD5_Update(&ctx, data, (CC_LONG)datalen);
CC_MD5_Final(hash, &ctx);
return (CC_MD5_DIGEST_LENGTH);
}
else if (!strcmp(algorithm, "sha"))
{
/*
* SHA-1...
@@ -171,7 +190,9 @@ cupsHashData(const char *algorithm, /* I - Algorithm name */
unsigned char temp[64]; /* Temporary hash buffer */
size_t tempsize = 0; /* Truncate to this size? */
if (!strcmp(algorithm, "sha"))
if (!strcmp(algorithm, "md5"))
alg = GNUTLS_DIG_MD5;
else if (!strcmp(algorithm, "sha"))
alg = GNUTLS_DIG_SHA1;
else if (!strcmp(algorithm, "sha2-224"))
alg = GNUTLS_DIG_SHA224;
@@ -219,10 +240,20 @@ cupsHashData(const char *algorithm, /* I - Algorithm name */
#else
/*
* No hash support without CommonCrypto or GNU TLS...
* No hash support beyond MD5 without CommonCrypto or GNU TLS...
*/
if (hashsize < 64)
if (!strcmp(algorithm, "md5"))
{
_cups_md5_state_t state; /* MD5 state info */
_cupsMD5Init(&state);
_cupsMD5Append(&state, data, datalen);
_cupsMD5Finish(&state, hash);
return (16);
}
else if (hashsize < 64)
goto too_small;
#endif /* __APPLE__ */
@@ -243,3 +274,53 @@ cupsHashData(const char *algorithm, /* I - Algorithm name */
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Hash buffer too small."), 1);
return (-1);
}
/*
* 'cupsHashString()' - Format a hash value as a hexadecimal string.
*
* The passed buffer must be at least 2 * hashsize + 1 characters in length.
*
* @since CUPS 2.2.7@
*/
const char * /* O - Formatted string */
cupsHashString(
const unsigned char *hash, /* I - Hash */
size_t hashsize, /* I - Size of hash */
char *buffer, /* I - String buffer */
size_t bufsize) /* I - Size of string buffer */
{
char *bufptr = buffer; /* Pointer into buffer */
static const char *hex = "0123456789abcdef";
/* Hex characters (lowercase!) */
/*
* Range check input...
*/
if (!hash || hashsize < 1 || !buffer || bufsize < (2 * hashsize + 1))
{
if (buffer)
*buffer = '\0';
return (NULL);
}
/*
* Loop until we've converted the whole hash...
*/
while (hashsize > 0)
{
*bufptr++ = hex[*hash >> 4];
*bufptr++ = hex[*hash & 15];
hash ++;
hashsize --;
}
*bufptr = '\0';
return (buffer);
}
+4 -4
Ver Arquivo
@@ -69,11 +69,11 @@ int /* O - 0 on success, -1 on failure */
httpAddrClose(http_addr_t *addr, /* I - Listen address or @code NULL@ */
int fd) /* I - Socket file descriptor */
{
#ifdef WIN32
#ifdef _WIN32
if (closesocket(fd))
#else
if (close(fd))
#endif /* WIN32 */
#endif /* _WIN32 */
return (-1);
#ifdef AF_LOCAL
@@ -258,9 +258,9 @@ httpAddrListen(http_addr_t *addr, /* I - Address to bind to */
* Close on exec...
*/
#ifndef WIN32
#ifndef _WIN32
fcntl(fd, F_SETFD, fcntl(fd, F_GETFD) | FD_CLOEXEC);
#endif /* !WIN32 */
#endif /* !_WIN32 */
#ifdef SO_NOSIGPIPE
/*
+38 -20
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* HTTP address list routines for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -24,9 +24,9 @@
#ifdef HAVE_POLL
# include <poll.h>
#endif /* HAVE_POLL */
#ifndef WIN32
#ifndef _WIN32
# include <fcntl.h>
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -61,14 +61,14 @@ httpAddrConnect2(
int *cancel) /* I - Pointer to "cancel" variable */
{
int val; /* Socket option value */
#ifndef WIN32
int flags; /* Socket flags */
#endif /* !WIN32 */
int remaining; /* Remaining timeout */
int i, /* Looping var */
nfds, /* Number of file descriptors */
fds[100], /* Socket file descriptors */
#ifndef _WIN32
int i, j, /* Looping vars */
flags, /* Socket flags */
result; /* Result from select() or poll() */
#endif /* !_WIN32 */
int remaining; /* Remaining timeout */
int nfds, /* Number of file descriptors */
fds[100]; /* Socket file descriptors */
http_addrlist_t *addrs[100]; /* Addresses */
#ifndef HAVE_POLL
int max_fd = -1; /* Highest file descriptor */
@@ -84,8 +84,10 @@ httpAddrConnect2(
# endif /* HAVE_POLL */
#endif /* O_NONBLOCK */
#ifdef DEBUG
# ifndef _WIN32
socklen_t len; /* Length of value */
http_addr_t peer; /* Peer address */
# endif /* !_WIN32 */
char temp[256]; /* Temporary address string */
#endif /* DEBUG */
@@ -213,11 +215,11 @@ httpAddrConnect2(
return (addrlist);
}
#ifdef WIN32
#ifdef _WIN32
if (WSAGetLastError() != WSAEINPROGRESS && WSAGetLastError() != WSAEWOULDBLOCK)
#else
if (errno != EINPROGRESS && errno != EWOULDBLOCK)
#endif /* WIN32 */
#endif /* _WIN32 */
{
DEBUG_printf(("1httpAddrConnect2: Unable to connect to %s:%d: %s", httpAddrString(&(addrlist->addr), temp, sizeof(temp)), httpAddrPort(&(addrlist->addr)), strerror(errno)));
httpAddrClose(NULL, fds[nfds]);
@@ -225,9 +227,9 @@ httpAddrConnect2(
continue;
}
#ifndef WIN32
#ifndef _WIN32
fcntl(fds[nfds], F_SETFL, flags);
#endif /* !WIN32 */
#endif /* !_WIN32 */
#ifndef HAVE_POLL
if (fds[nfds] > max_fd)
@@ -296,11 +298,11 @@ httpAddrConnect2(
DEBUG_printf(("1httpAddrConnect2: select() returned %d (%d)", result, errno));
# endif /* HAVE_POLL */
}
# ifdef WIN32
# ifdef _WIN32
while (result < 0 && (WSAGetLastError() == WSAEINTR || WSAGetLastError() == WSAEWOULDBLOCK));
# else
while (result < 0 && (errno == EINTR || errno == EAGAIN));
# endif /* WIN32 */
# endif /* _WIN32 */
if (result > 0)
{
@@ -323,6 +325,8 @@ httpAddrConnect2(
if (!getpeername(fds[i], (struct sockaddr *)&peer, &len))
DEBUG_printf(("1httpAddrConnect2: Connected to %s:%d...", httpAddrString(&peer, temp, sizeof(temp)), httpAddrPort(&peer)));
# endif /* DEBUG */
break;
}
# ifdef HAVE_POLL
else if (pfds[i].revents & (POLLERR | POLLHUP))
@@ -346,7 +350,20 @@ httpAddrConnect2(
}
if (connaddr)
{
/*
* Connected on one address, close all of the other sockets we have so
* far and return...
*/
for (j = 0; j < i; j ++)
httpAddrClose(NULL, fds[j]);
for (j ++; j < nfds; j ++)
httpAddrClose(NULL, fds[j]);
return (connaddr);
}
}
#endif /* O_NONBLOCK */
@@ -362,11 +379,11 @@ httpAddrConnect2(
httpAddrClose(NULL, fds[nfds]);
}
#ifdef WIN32
#ifdef _WIN32
_cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, "Connection failed", 0);
#else
_cupsSetError(IPP_STATUS_ERROR_SERVICE_UNAVAILABLE, strerror(errno), 0);
#endif /* WIN32 */
#endif /* _WIN32 */
return (NULL);
}
@@ -603,6 +620,7 @@ httpAddrGetList(const char *hostname, /* I - Hostname, IP address, or NULL for p
if (!temp)
{
httpAddrFreeList(first);
freeaddrinfo(results);
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0);
return (NULL);
}
@@ -833,11 +851,11 @@ httpAddrGetList(const char *hostname, /* I - Hostname, IP address, or NULL for p
temp->addr.ipv6.sin6_family = AF_INET6;
temp->addr.ipv6.sin6_port = htons(portnum);
# ifdef WIN32
# ifdef _WIN32
temp->addr.ipv6.sin6_addr.u.Byte[15] = 1;
# else
temp->addr.ipv6.sin6_addr.s6_addr32[3] = htonl(1);
# endif /* WIN32 */
# endif /* _WIN32 */
if (!first)
first = temp;
+40 -28
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Private HTTP definitions for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -30,7 +30,7 @@
# endif /* __sun */
# include <limits.h>
# ifdef WIN32
# ifdef _WIN32
# include <io.h>
# include <winsock2.h>
# define CUPS_SOCAST (const char *)
@@ -39,7 +39,7 @@
# include <fcntl.h>
# include <sys/socket.h>
# define CUPS_SOCAST
# endif /* WIN32 */
# endif /* _WIN32 */
# ifdef HAVE_GSSAPI
# ifdef HAVE_GSS_GSSAPI_H
@@ -68,7 +68,6 @@ typedef int socklen_t;
# endif /* __APPLE__ && !_SOCKLEN_T */
# include <cups/http.h>
# include "md5-private.h"
# include "ipp-private.h"
# ifdef HAVE_GNUTLS
@@ -141,7 +140,7 @@ extern SecIdentityRef SecIdentityCreate(CFAllocatorRef allocator, SecCertificate
# include <sspi.h>
# endif /* HAVE_GNUTLS */
# ifndef WIN32
# ifndef _WIN32
# include <net/if.h>
# include <resolv.h>
# ifdef HAVE_GETIFADDRS
@@ -152,11 +151,7 @@ extern SecIdentityRef SecIdentityCreate(CFAllocatorRef allocator, SecCertificate
# include <sys/sockio.h>
# endif /* HAVE_SYS_SOCKIO_H */
# endif /* HAVE_GETIFADDRS */
# endif /* !WIN32 */
# ifdef HAVE_LIBZ
# include <zlib.h>
# endif /* HAVE_LIBZ */
# endif /* !_WIN32 */
/*
@@ -172,19 +167,24 @@ extern "C" {
* Constants...
*/
# define _HTTP_MAX_SBUFFER 65536 /* Size of (de)compression buffer */
# define _HTTP_RESOLVE_DEFAULT 0 /* Just resolve with default options */
# define _HTTP_RESOLVE_STDERR 1 /* Log resolve progress to stderr */
# define _HTTP_RESOLVE_FQDN 2 /* Resolve to a FQDN */
# define _HTTP_RESOLVE_FAXOUT 4 /* Resolve FaxOut service? */
#define _HTTP_MAX_SBUFFER 65536 /* Size of (de)compression buffer */
#define _HTTP_RESOLVE_DEFAULT 0 /* Just resolve with default options */
#define _HTTP_RESOLVE_STDERR 1 /* Log resolve progress to stderr */
#define _HTTP_RESOLVE_FQDN 2 /* Resolve to a FQDN */
#define _HTTP_RESOLVE_FAXOUT 4 /* Resolve FaxOut service? */
# define _HTTP_TLS_NONE 0 /* No TLS options */
# define _HTTP_TLS_ALLOW_RC4 1 /* Allow RC4 cipher suites */
# define _HTTP_TLS_ALLOW_DH 2 /* Allow DH/DHE key negotiation */
# define _HTTP_TLS_DENY_CBC 4 /* Deny CBC cipher suites */
# define _HTTP_TLS_SET_DEFAULT 128 /* Setting the default TLS options */
#define _HTTP_TLS_NONE 0 /* No TLS options */
#define _HTTP_TLS_ALLOW_RC4 1 /* Allow RC4 cipher suites */
#define _HTTP_TLS_ALLOW_SSL3 2 /* Allow SSL 3.0 */
#define _HTTP_TLS_ALLOW_DH 4 /* Allow DH/DHE key negotiation */
#define _HTTP_TLS_DENY_TLS10 16 /* Deny TLS 1.0 */
#define _HTTP_TLS_DENY_CBC 32 /* Deny CBC cipher suites */
# define _HTTP_TLS_SSL3 0 /* Min/max version is SSL/3.0 */
# define _HTTP_TLS_1_0 1 /* Min/max version is TLS/1.0 */
# define _HTTP_TLS_1_1 2 /* Min/max version is TLS/1.1 */
# define _HTTP_TLS_1_2 3 /* Min/max version is TLS/1.2 */
# define _HTTP_TLS_1_3 4 /* Min/max version is TLS/1.3 */
# define _HTTP_TLS_MAX 5 /* Highest known TLS version */
/*
@@ -296,10 +296,10 @@ struct _http_s /**** HTTP connection structure ****/
char buffer[HTTP_MAX_BUFFER];
/* Buffer for incoming data */
int _auth_type; /* Authentication in use (deprecated) */
_cups_md5_state_t md5_state; /* MD5 state */
unsigned char _md5_state[88]; /* MD5 state (deprecated) */
char nonce[HTTP_MAX_VALUE];
/* Nonce value */
int nonce_count; /* Nonce count */
unsigned nonce_count; /* Nonce count */
http_tls_t tls; /* TLS state information */
http_encryption_t encryption; /* Encryption requirements */
@@ -360,9 +360,20 @@ struct _http_s /**** HTTP connection structure ****/
/* Default field values */
# ifdef HAVE_LIBZ
_http_coding_t coding; /* _HTTP_CODING_xxx */
z_stream stream; /* (De)compression stream */
Bytef *sbuffer; /* (De)compression buffer */
void *stream; /* (De)compression stream */
unsigned char *sbuffer; /* (De)compression buffer */
# endif /* HAVE_LIBZ */
/**** New in CUPS 2.2.9 ****/
char *authentication_info,
/* Authentication-Info header */
algorithm[65], /* Algorithm from WWW-Authenticate */
nextnonce[HTTP_MAX_VALUE],
/* Next nonce value from Authentication-Info */
opaque[HTTP_MAX_VALUE],
/* Opaque value from WWW-Authenticate */
realm[HTTP_MAX_VALUE];
/* Realm from WWW-Authenticate */
};
# endif /* !_HTTP_NO_PRIVATE */
@@ -381,7 +392,7 @@ extern const char *_cups_hstrerror(int error);
* Some OS's don't have getifaddrs() and freeifaddrs()...
*/
# if !defined(WIN32) && !defined(HAVE_GETIFADDRS)
# if !defined(_WIN32) && !defined(HAVE_GETIFADDRS)
# ifdef ifa_dstaddr
# undef ifa_dstaddr
# endif /* ifa_dstaddr */
@@ -416,7 +427,7 @@ extern int _cups_getifaddrs(struct ifaddrs **addrs);
# define getifaddrs _cups_getifaddrs
extern void _cups_freeifaddrs(struct ifaddrs *addrs);
# define freeifaddrs _cups_freeifaddrs
# endif /* !WIN32 && !HAVE_GETIFADDRS */
# endif /* !_WIN32 && !HAVE_GETIFADDRS */
/*
@@ -436,12 +447,13 @@ extern const char *_httpResolveURI(const char *uri, char *resolved_uri,
size_t resolved_size, int options,
int (*cb)(void *context),
void *context);
extern int _httpSetDigestAuthString(http_t *http, const char *nonce, const char *method, const char *resource);
extern const char *_httpStatus(cups_lang_t *lang, http_status_t status);
extern void _httpTLSInitialize(void);
extern size_t _httpTLSPending(http_t *http);
extern int _httpTLSRead(http_t *http, char *buf, int len);
extern int _httpTLSSetCredentials(http_t *http);
extern void _httpTLSSetOptions(int options);
extern void _httpTLSSetOptions(int options, int min_version, int max_version);
extern int _httpTLSStart(http_t *http);
extern void _httpTLSStop(http_t *http);
extern int _httpTLSWrite(http_t *http, const char *buf, int len);
+156 -13
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* HTTP support routines for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -20,13 +20,13 @@
#include "cups-private.h"
#ifdef HAVE_DNSSD
# include <dns_sd.h>
# ifdef WIN32
# ifdef _WIN32
# include <io.h>
# elif defined(HAVE_POLL)
# include <poll.h>
# else
# include <sys/select.h>
# endif /* WIN32 */
# endif /* _WIN32 */
#elif defined(HAVE_AVAHI)
# include <avahi-client/client.h>
# include <avahi-client/lookup.h>
@@ -502,7 +502,6 @@ httpAssembleUUID(const char *server, /* I - Server name */
size_t bufsize) /* I - Size of buffer */
{
char data[1024]; /* Source string for MD5 */
_cups_md5_state_t md5state; /* MD5 state */
unsigned char md5sum[16]; /* MD5 digest/sum */
@@ -517,9 +516,7 @@ httpAssembleUUID(const char *server, /* I - Server name */
port, name ? name : server, number,
(unsigned)CUPS_RAND() & 0xffff, (unsigned)CUPS_RAND() & 0xffff);
_cupsMD5Init(&md5state);
_cupsMD5Append(&md5state, (unsigned char *)data, (int)strlen(data));
_cupsMD5Finish(&md5state, md5sum);
cupsHashData("md5", (unsigned char *)data, strlen(data), md5sum, sizeof(md5sum));
/*
* Generate the UUID from the MD5...
@@ -1035,7 +1032,7 @@ httpSeparateURI(
*ptr = '\0';
if (*uri != ':')
if (*uri != ':' || *scheme == '.' || !*scheme)
{
*scheme = '\0';
return (HTTP_URI_STATUS_BAD_SCHEME);
@@ -1305,6 +1302,152 @@ httpSeparateURI(
}
/*
* '_httpSetDigestAuthString()' - Calculate a Digest authentication response
* using the appropriate RFC 2068/2617/7616
* algorithm.
*/
int /* O - 1 on success, 0 on failure */
_httpSetDigestAuthString(
http_t *http, /* I - HTTP connection */
const char *nonce, /* I - Nonce value */
const char *method, /* I - HTTP method */
const char *resource) /* I - HTTP resource path */
{
char kd[65], /* Final MD5/SHA-256 digest */
ha1[65], /* Hash of username:realm:password */
ha2[65], /* Hash of method:request-uri */
username[HTTP_MAX_VALUE],
/* username:password */
*password, /* Pointer to password */
temp[1024], /* Temporary string */
digest[1024]; /* Digest auth data */
unsigned char hash[32]; /* Hash buffer */
size_t hashsize; /* Size of hash */
DEBUG_printf(("2_httpSetDigestAuthString(http=%p, nonce=\"%s\", method=\"%s\", resource=\"%s\")", http, nonce, method, resource));
if (nonce && *nonce && strcmp(nonce, http->nonce))
{
strlcpy(http->nonce, nonce, sizeof(http->nonce));
if (nonce == http->nextnonce)
http->nextnonce[0] = '\0';
http->nonce_count = 1;
}
else
http->nonce_count ++;
strlcpy(username, http->userpass, sizeof(username));
if ((password = strchr(username, ':')) != NULL)
*password++ = '\0';
else
return (0);
if (http->algorithm[0])
{
/*
* Follow RFC 2617/7616...
*/
int i; /* Looping var */
char cnonce[65]; /* cnonce value */
const char *hashalg; /* Hashing algorithm */
for (i = 0; i < 64; i ++)
cnonce[i] = "0123456789ABCDEF"[CUPS_RAND() & 15];
cnonce[64] = '\0';
if (!_cups_strcasecmp(http->algorithm, "MD5"))
{
/*
* RFC 2617 Digest with MD5
*/
hashalg = "md5";
}
else if (!_cups_strcasecmp(http->algorithm, "SHA-256"))
{
/*
* RFC 7616 Digest with SHA-256
*/
hashalg = "sha2-256";
}
else
{
/*
* Some other algorithm we don't support, skip this one...
*/
return (0);
}
/*
* Calculate digest value...
*/
/* H(A1) = H(username:realm:password) */
snprintf(temp, sizeof(temp), "%s:%s:%s", username, http->realm, password);
hashsize = (size_t)cupsHashData(hashalg, (unsigned char *)temp, strlen(temp), hash, sizeof(hash));
cupsHashString(hash, hashsize, ha1, sizeof(ha1));
/* H(A2) = H(method:uri) */
snprintf(temp, sizeof(temp), "%s:%s", method, resource);
hashsize = (size_t)cupsHashData(hashalg, (unsigned char *)temp, strlen(temp), hash, sizeof(hash));
cupsHashString(hash, hashsize, ha2, sizeof(ha2));
/* KD = H(H(A1):nonce:nc:cnonce:qop:H(A2)) */
snprintf(temp, sizeof(temp), "%s:%s:%08x:%s:%s:%s", ha1, http->nonce, http->nonce_count, cnonce, "auth", ha2);
hashsize = (size_t)cupsHashData(hashalg, (unsigned char *)temp, strlen(temp), hash, sizeof(hash));
cupsHashString(hash, hashsize, kd, sizeof(kd));
/*
* Pass the RFC 2617/7616 WWW-Authenticate header...
*/
if (http->opaque[0])
snprintf(digest, sizeof(digest), "username=\"%s\", realm=\"%s\", nonce=\"%s\", algorithm=%s, qop=auth, opaque=\"%s\", cnonce=\"%s\", nc=%08x, uri=\"%s\", response=\"%s\"", cupsUser(), http->realm, http->nonce, http->algorithm, http->opaque, cnonce, http->nonce_count, resource, kd);
else
snprintf(digest, sizeof(digest), "username=\"%s\", realm=\"%s\", nonce=\"%s\", algorithm=%s, qop=auth, cnonce=\"%s\", nc=%08x, uri=\"%s\", response=\"%s\"", username, http->realm, http->nonce, http->algorithm, cnonce, http->nonce_count, resource, kd);
}
else
{
/*
* Use old RFC 2069 Digest method...
*/
/* H(A1) = H(username:realm:password) */
snprintf(temp, sizeof(temp), "%s:%s:%s", username, http->realm, password);
hashsize = (size_t)cupsHashData("md5", (unsigned char *)temp, strlen(temp), hash, sizeof(hash));
cupsHashString(hash, hashsize, ha1, sizeof(ha1));
/* H(A2) = H(method:uri) */
snprintf(temp, sizeof(temp), "%s:%s", method, resource);
hashsize = (size_t)cupsHashData("md5", (unsigned char *)temp, strlen(temp), hash, sizeof(hash));
cupsHashString(hash, hashsize, ha2, sizeof(ha2));
/* KD = H(H(A1):nonce:H(A2)) */
snprintf(temp, sizeof(temp), "%s:%s:%s", ha1, http->nonce, ha2);
hashsize = (size_t)cupsHashData("md5", (unsigned char *)temp, strlen(temp), hash, sizeof(hash));
cupsHashString(hash, hashsize, kd, sizeof(kd));
/*
* Pass the old RFC 2069 WWW-Authenticate header...
*/
snprintf(digest, sizeof(digest), "username=\"%s\", realm=\"%s\", nonce=\"%s\", uri=\"%s\", response=\"%s\"", username, http->realm, http->nonce, resource, kd);
}
httpSetAuthString(http, "Digest", digest);
return (1);
}
/*
* 'httpStateString()' - Return the string describing a HTTP state value.
*
@@ -1360,6 +1503,9 @@ _httpStatus(cups_lang_t *lang, /* I - Language */
case HTTP_STATUS_MOVED_PERMANENTLY :
s = _("Moved Permanently");
break;
case HTTP_STATUS_FOUND :
s = _("Found");
break;
case HTTP_STATUS_SEE_OTHER :
s = _("See Other");
break;
@@ -1622,9 +1768,6 @@ _httpResolveURI(
_http_uribuf_t uribuf; /* URI buffer */
int offline = 0; /* offline-report state set? */
# ifdef HAVE_DNSSD
# ifdef WIN32
# pragma comment(lib, "dnssd.lib")
# endif /* WIN32 */
DNSServiceRef ref, /* DNS-SD master service reference */
domainref = NULL,/* DNS-SD service reference for domain */
ippref = NULL, /* DNS-SD service reference for network IPP */
@@ -1753,11 +1896,11 @@ _httpResolveURI(
FD_ZERO(&input_set);
FD_SET(DNSServiceRefSockFD(ref), &input_set);
# ifdef WIN32
# ifdef _WIN32
stimeout.tv_sec = (long)timeout;
# else
stimeout.tv_sec = timeout;
# endif /* WIN32 */
# endif /* _WIN32 */
stimeout.tv_usec = 0;
fds = select(DNSServiceRefSockFD(ref)+1, &input_set, NULL, NULL,
+269 -201
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* HTTP routines for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* This file contains Kerberos support code, copyright 2006 by
@@ -23,22 +23,26 @@
#include "cups-private.h"
#include <fcntl.h>
#include <math.h>
#ifdef WIN32
#ifdef _WIN32
# include <tchar.h>
#else
# include <signal.h>
# include <sys/time.h>
# include <sys/resource.h>
#endif /* WIN32 */
#endif /* _WIN32 */
#ifdef HAVE_POLL
# include <poll.h>
#endif /* HAVE_POLL */
# ifdef HAVE_LIBZ
# include <zlib.h>
# endif /* HAVE_LIBZ */
/*
* Local functions...
*/
static void http_add_field(http_t *http, http_field_t field, const char *value, int append);
#ifdef HAVE_LIBZ
static void http_content_coding_finish(http_t *http);
static void http_content_coding_start(http_t *http,
@@ -105,7 +109,8 @@ static const char * const http_fields[] =
"WWW-Authenticate",
"Accept-Encoding",
"Allow",
"Server"
"Server",
"Authentication-Info"
};
@@ -325,6 +330,12 @@ httpClearFields(http_t *http) /* I - HTTP connection */
http->server = NULL;
}
if (http->authentication_info)
{
_cupsStrFree(http->authentication_info);
http->authentication_info = NULL;
}
http->expect = (http_status_t)0;
}
}
@@ -969,11 +980,14 @@ httpGetField(http_t *http, /* I - HTTP connection */
case HTTP_FIELD_SERVER :
return (http->server);
case HTTP_FIELD_AUTHENTICATION_INFO :
return (http->authentication_info);
case HTTP_FIELD_AUTHORIZATION :
if (http->field_authorization)
{
/*
* Special case for WWW-Authenticate: as its contents can be
* Special case for Authorization: as its contents can be
* longer than HTTP_MAX_VALUE...
*/
@@ -1183,11 +1197,11 @@ httpGets(char *line, /* I - Line to read into */
* Pre-load the buffer as needed...
*/
#ifdef WIN32
#ifdef _WIN32
WSASetLastError(0);
#else
errno = 0;
#endif /* WIN32 */
#endif /* _WIN32 */
while (http->used == 0)
{
@@ -1201,11 +1215,11 @@ httpGets(char *line, /* I - Line to read into */
continue;
DEBUG_puts("3httpGets: Timed out!");
#ifdef WIN32
#ifdef _WIN32
http->error = WSAETIMEDOUT;
#else
http->error = ETIMEDOUT;
#endif /* WIN32 */
#endif /* _WIN32 */
return (NULL);
}
@@ -1219,7 +1233,7 @@ httpGets(char *line, /* I - Line to read into */
* Nope, can't get a line this time...
*/
#ifdef WIN32
#ifdef _WIN32
DEBUG_printf(("3httpGets: recv() error %d!", WSAGetLastError()));
if (WSAGetLastError() == WSAEINTR)
@@ -1256,7 +1270,7 @@ httpGets(char *line, /* I - Line to read into */
http->error = errno;
continue;
}
#endif /* WIN32 */
#endif /* _WIN32 */
return (NULL);
}
@@ -1523,9 +1537,9 @@ void
httpInitialize(void)
{
static int initialized = 0; /* Have we been called before? */
#ifdef WIN32
#ifdef _WIN32
WSADATA winsockdata; /* WinSock data */
#endif /* WIN32 */
#endif /* _WIN32 */
_cupsGlobalLock();
@@ -1535,7 +1549,7 @@ httpInitialize(void)
return;
}
#ifdef WIN32
#ifdef _WIN32
WSAStartup(MAKEWORD(2,2), &winsockdata);
#elif !defined(SO_NOSIGPIPE)
@@ -1557,7 +1571,7 @@ httpInitialize(void)
# else
signal(SIGPIPE, SIG_IGN);
# endif /* !SO_NOSIGPIPE */
#endif /* WIN32 */
#endif /* _WIN32 */
# ifdef HAVE_SSL
_httpTLSInitialize();
@@ -1713,7 +1727,7 @@ httpPeek(http_t *http, /* I - HTTP connection */
#ifdef HAVE_LIBZ
if (http->used == 0 &&
(http->coding == _HTTP_CODING_IDENTITY ||
(http->coding >= _HTTP_CODING_GUNZIP && http->stream.avail_in == 0)))
(http->coding >= _HTTP_CODING_GUNZIP && ((z_stream *)http->stream)->avail_in == 0)))
#else
if (http->used == 0)
#endif /* HAVE_LIBZ */
@@ -1762,16 +1776,16 @@ httpPeek(http_t *http, /* I - HTTP connection */
int zerr; /* Decompressor error */
z_stream stream; /* Copy of decompressor stream */
if (http->used > 0 && http->stream.avail_in < HTTP_MAX_BUFFER)
if (http->used > 0 && ((z_stream *)http->stream)->avail_in < HTTP_MAX_BUFFER)
{
size_t buflen = buflen = HTTP_MAX_BUFFER - http->stream.avail_in;
size_t buflen = buflen = HTTP_MAX_BUFFER - ((z_stream *)http->stream)->avail_in;
/* Number of bytes to copy */
if (http->stream.avail_in > 0 &&
http->stream.next_in > http->sbuffer)
memmove(http->sbuffer, http->stream.next_in, http->stream.avail_in);
if (((z_stream *)http->stream)->avail_in > 0 &&
((z_stream *)http->stream)->next_in > http->sbuffer)
memmove(http->sbuffer, ((z_stream *)http->stream)->next_in, ((z_stream *)http->stream)->avail_in);
http->stream.next_in = http->sbuffer;
((z_stream *)http->stream)->next_in = http->sbuffer;
if (buflen > (size_t)http->data_remaining)
buflen = (size_t)http->data_remaining;
@@ -1782,8 +1796,8 @@ httpPeek(http_t *http, /* I - HTTP connection */
DEBUG_printf(("1httpPeek: Copying %d more bytes of data into "
"decompression buffer.", (int)buflen));
memcpy(http->sbuffer + http->stream.avail_in, http->buffer, buflen);
http->stream.avail_in += buflen;
memcpy(http->sbuffer + ((z_stream *)http->stream)->avail_in, http->buffer, buflen);
((z_stream *)http->stream)->avail_in += buflen;
http->used -= (int)buflen;
http->data_remaining -= (off_t)buflen;
@@ -1792,9 +1806,9 @@ httpPeek(http_t *http, /* I - HTTP connection */
}
DEBUG_printf(("2httpPeek: length=%d, avail_in=%d", (int)length,
(int)http->stream.avail_in));
(int)((z_stream *)http->stream)->avail_in));
if (inflateCopy(&stream, &(http->stream)) != Z_OK)
if (inflateCopy(&stream, (z_stream *)http->stream) != Z_OK)
{
DEBUG_puts("2httpPeek: Unable to copy decompressor stream.");
http->error = ENOMEM;
@@ -1811,14 +1825,14 @@ httpPeek(http_t *http, /* I - HTTP connection */
{
DEBUG_printf(("2httpPeek: zerr=%d", zerr));
#ifdef DEBUG
http_debug_hex("2httpPeek", (char *)http->sbuffer, (int)http->stream.avail_in);
http_debug_hex("2httpPeek", (char *)http->sbuffer, (int)((z_stream *)http->stream)->avail_in);
#endif /* DEBUG */
http->error = EIO;
return (-1);
}
bytes = (ssize_t)(length - http->stream.avail_out);
bytes = (ssize_t)(length - ((z_stream *)http->stream)->avail_out);
# else
DEBUG_puts("2httpPeek: No inflateCopy on this platform, httpPeek does not "
@@ -1845,7 +1859,7 @@ httpPeek(http_t *http, /* I - HTTP connection */
if (bytes < 0)
{
#ifdef WIN32
#ifdef _WIN32
if (WSAGetLastError() == WSAEINTR || WSAGetLastError() == WSAEWOULDBLOCK)
bytes = 0;
else
@@ -1855,7 +1869,7 @@ httpPeek(http_t *http, /* I - HTTP connection */
bytes = 0;
else
http->error = errno;
#endif /* WIN32 */
#endif /* _WIN32 */
}
else if (bytes == 0)
{
@@ -1985,31 +1999,31 @@ httpRead2(http_t *http, /* I - HTTP connection */
{
do
{
if (http->stream.avail_in > 0)
if (((z_stream *)http->stream)->avail_in > 0)
{
int zerr; /* Decompressor error */
DEBUG_printf(("2httpRead2: avail_in=%d, avail_out=%d",
(int)http->stream.avail_in, (int)length));
(int)((z_stream *)http->stream)->avail_in, (int)length));
http->stream.next_out = (Bytef *)buffer;
http->stream.avail_out = (uInt)length;
((z_stream *)http->stream)->next_out = (Bytef *)buffer;
((z_stream *)http->stream)->avail_out = (uInt)length;
if ((zerr = inflate(&(http->stream), Z_SYNC_FLUSH)) < Z_OK)
if ((zerr = inflate((z_stream *)http->stream, Z_SYNC_FLUSH)) < Z_OK)
{
DEBUG_printf(("2httpRead2: zerr=%d", zerr));
#ifdef DEBUG
http_debug_hex("2httpRead2", (char *)http->sbuffer, (int)http->stream.avail_in);
http_debug_hex("2httpRead2", (char *)http->sbuffer, (int)((z_stream *)http->stream)->avail_in);
#endif /* DEBUG */
http->error = EIO;
return (-1);
}
bytes = (ssize_t)(length - http->stream.avail_out);
bytes = (ssize_t)(length - ((z_stream *)http->stream)->avail_out);
DEBUG_printf(("2httpRead2: avail_in=%d, avail_out=%d, bytes=%d",
http->stream.avail_in, http->stream.avail_out,
((z_stream *)http->stream)->avail_in, ((z_stream *)http->stream)->avail_out,
(int)bytes));
}
else
@@ -2017,16 +2031,16 @@ httpRead2(http_t *http, /* I - HTTP connection */
if (bytes == 0)
{
ssize_t buflen = HTTP_MAX_BUFFER - (ssize_t)http->stream.avail_in;
ssize_t buflen = HTTP_MAX_BUFFER - (ssize_t)((z_stream *)http->stream)->avail_in;
/* Additional bytes for buffer */
if (buflen > 0)
{
if (http->stream.avail_in > 0 &&
http->stream.next_in > http->sbuffer)
memmove(http->sbuffer, http->stream.next_in, http->stream.avail_in);
if (((z_stream *)http->stream)->avail_in > 0 &&
((z_stream *)http->stream)->next_in > http->sbuffer)
memmove(http->sbuffer, ((z_stream *)http->stream)->next_in, ((z_stream *)http->stream)->avail_in);
http->stream.next_in = http->sbuffer;
((z_stream *)http->stream)->next_in = http->sbuffer;
DEBUG_printf(("1httpRead2: Reading up to %d more bytes of data into "
"decompression buffer.", (int)buflen));
@@ -2036,10 +2050,10 @@ httpRead2(http_t *http, /* I - HTTP connection */
if (buflen > http->data_remaining)
buflen = (ssize_t)http->data_remaining;
bytes = http_read_buffered(http, (char *)http->sbuffer + http->stream.avail_in, (size_t)buflen);
bytes = http_read_buffered(http, (char *)http->sbuffer + ((z_stream *)http->stream)->avail_in, (size_t)buflen);
}
else if (http->data_encoding == HTTP_ENCODING_CHUNKED)
bytes = http_read_chunk(http, (char *)http->sbuffer + http->stream.avail_in, (size_t)buflen);
bytes = http_read_chunk(http, (char *)http->sbuffer + ((z_stream *)http->stream)->avail_in, (size_t)buflen);
else
bytes = 0;
@@ -2052,7 +2066,7 @@ httpRead2(http_t *http, /* I - HTTP connection */
"decompression buffer.", CUPS_LLCAST bytes));
http->data_remaining -= bytes;
http->stream.avail_in += (uInt)bytes;
((z_stream *)http->stream)->avail_in += (uInt)bytes;
if (http->data_remaining <= 0 &&
http->data_encoding == HTTP_ENCODING_CHUNKED)
@@ -2131,7 +2145,7 @@ httpRead2(http_t *http, /* I - HTTP connection */
if (
#ifdef HAVE_LIBZ
(http->coding == _HTTP_CODING_IDENTITY ||
(http->coding >= _HTTP_CODING_GUNZIP && http->stream.avail_in == 0)) &&
(http->coding >= _HTTP_CODING_GUNZIP && ((z_stream *)http->stream)->avail_in == 0)) &&
#endif /* HAVE_LIBZ */
((http->data_remaining <= 0 &&
http->data_encoding == HTTP_ENCODING_LENGTH) ||
@@ -2416,11 +2430,11 @@ httpReconnect2(http_t *http, /* I - HTTP connection */
* Unable to connect...
*/
#ifdef WIN32
#ifdef _WIN32
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 */
#endif /* _WIN32 */
http->status = HTTP_STATUS_ERROR;
DEBUG_printf(("1httpReconnect2: httpAddrConnect failed: %s",
@@ -2659,105 +2673,7 @@ httpSetField(http_t *http, /* I - HTTP connection */
value == NULL)
return;
switch (field)
{
case HTTP_FIELD_ACCEPT_ENCODING :
if (http->accept_encoding)
_cupsStrFree(http->accept_encoding);
http->accept_encoding = _cupsStrAlloc(value);
break;
case HTTP_FIELD_ALLOW :
if (http->allow)
_cupsStrFree(http->allow);
http->allow = _cupsStrAlloc(value);
break;
case HTTP_FIELD_SERVER :
if (http->server)
_cupsStrFree(http->server);
http->server = _cupsStrAlloc(value);
break;
case HTTP_FIELD_WWW_AUTHENTICATE :
/* CUPS STR #4503 - don't override WWW-Authenticate for unknown auth schemes */
if (http->fields[HTTP_FIELD_WWW_AUTHENTICATE][0] &&
_cups_strncasecmp(value, "Basic ", 6) &&
_cups_strncasecmp(value, "Digest ", 7) &&
_cups_strncasecmp(value, "Negotiate ", 10))
{
DEBUG_printf(("1httpSetField: Ignoring unknown auth scheme in \"%s\".", value));
return;
}
/* Fall through to copy */
default :
strlcpy(http->fields[field], value, HTTP_MAX_VALUE);
break;
}
if (field == HTTP_FIELD_AUTHORIZATION)
{
/*
* Special case for Authorization: as its contents can be
* longer than HTTP_MAX_VALUE
*/
if (http->field_authorization)
free(http->field_authorization);
http->field_authorization = strdup(value);
}
else if (field == HTTP_FIELD_HOST)
{
/*
* Special-case for Host: as we don't want a trailing "." on the hostname and
* need to bracket IPv6 numeric addresses.
*/
char *ptr = strchr(value, ':');
if (value[0] != '[' && ptr && strchr(ptr + 1, ':'))
{
/*
* Bracket IPv6 numeric addresses...
*
* This is slightly inefficient (basically copying twice), but is an edge
* case and not worth optimizing...
*/
snprintf(http->fields[HTTP_FIELD_HOST],
sizeof(http->fields[HTTP_FIELD_HOST]), "[%s]", value);
}
else
{
/*
* Check for a trailing dot on the hostname...
*/
ptr = http->fields[HTTP_FIELD_HOST];
if (*ptr)
{
ptr += strlen(ptr) - 1;
if (*ptr == '.')
*ptr = '\0';
}
}
}
#ifdef HAVE_LIBZ
else if (field == HTTP_FIELD_CONTENT_ENCODING &&
http->data_encoding != HTTP_ENCODING_FIELDS)
{
DEBUG_puts("1httpSetField: Calling http_content_coding_start.");
http_content_coding_start(http, value);
}
#endif /* HAVE_LIBZ */
http_add_field(http, field, value, 0);
}
@@ -2855,11 +2771,11 @@ httpShutdown(http_t *http) /* I - HTTP connection */
_httpTLSStop(http);
#endif /* HAVE_SSL */
#ifdef WIN32
#ifdef _WIN32
shutdown(http->fd, SD_RECEIVE); /* Microsoft-ism... */
#else
shutdown(http->fd, SHUT_RD);
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -3035,7 +2951,12 @@ _httpUpdate(http_t *http, /* I - HTTP connection */
httpSetCookie(http, value);
}
else if ((field = httpFieldValue(line)) != HTTP_FIELD_UNKNOWN)
httpSetField(http, field, value);
{
http_add_field(http, field, value, 1);
if (field == HTTP_FIELD_AUTHENTICATION_INFO)
httpGetSubField2(http, HTTP_FIELD_AUTHENTICATION_INFO, "nextnonce", http->nextnonce, (int)sizeof(http->nextnonce));
}
#ifdef DEBUG
else
DEBUG_printf(("1_httpUpdate: unknown field %s seen!", line));
@@ -3188,12 +3109,12 @@ _httpWait(http_t *http, /* I - HTTP connection */
DEBUG_printf(("6_httpWait: select() returned %d...", nfds));
}
# ifdef WIN32
# ifdef _WIN32
while (nfds < 0 && (WSAGetLastError() == WSAEINTR ||
WSAGetLastError() == WSAEWOULDBLOCK));
# else
while (nfds < 0 && (errno == EINTR || errno == EAGAIN));
# endif /* WIN32 */
# endif /* _WIN32 */
#endif /* HAVE_POLL */
DEBUG_printf(("5_httpWait: returning with nfds=%d, errno=%d...", nfds,
@@ -3229,7 +3150,7 @@ httpWait(http_t *http, /* I - HTTP connection */
}
#ifdef HAVE_LIBZ
if (http->coding >= _HTTP_CODING_GUNZIP && http->stream.avail_in > 0)
if (http->coding >= _HTTP_CODING_GUNZIP && ((z_stream *)http->stream)->avail_in > 0)
{
DEBUG_puts("3httpWait: Returning 1 since there is buffered data ready.");
return (1);
@@ -3325,17 +3246,17 @@ httpWrite2(http_t *http, /* I - HTTP connection */
size_t slen; /* Bytes to write */
ssize_t sret; /* Bytes written */
http->stream.next_in = (Bytef *)buffer;
http->stream.avail_in = (uInt)length;
((z_stream *)http->stream)->next_in = (Bytef *)buffer;
((z_stream *)http->stream)->avail_in = (uInt)length;
while (deflate(&(http->stream), Z_NO_FLUSH) == Z_OK)
while (deflate((z_stream *)http->stream, Z_NO_FLUSH) == Z_OK)
{
DEBUG_printf(("1httpWrite2: avail_out=%d", http->stream.avail_out));
DEBUG_printf(("1httpWrite2: avail_out=%d", ((z_stream *)http->stream)->avail_out));
if (http->stream.avail_out > 0)
if (((z_stream *)http->stream)->avail_out > 0)
continue;
slen = _HTTP_MAX_SBUFFER - http->stream.avail_out;
slen = _HTTP_MAX_SBUFFER - ((z_stream *)http->stream)->avail_out;
DEBUG_printf(("1httpWrite2: Writing intermediate chunk, len=%d", (int)slen));
@@ -3352,8 +3273,8 @@ httpWrite2(http_t *http, /* I - HTTP connection */
return (-1);
}
http->stream.next_out = (Bytef *)http->sbuffer;
http->stream.avail_out = (uInt)_HTTP_MAX_SBUFFER;
((z_stream *)http->stream)->next_out = (Bytef *)http->sbuffer;
((z_stream *)http->stream)->avail_out = (uInt)_HTTP_MAX_SBUFFER;
}
bytes = (ssize_t)length;
@@ -3689,6 +3610,125 @@ httpWriteResponse(http_t *http, /* I - HTTP connection */
}
/*
* 'http_add_field()' - Add a value for a HTTP field, appending if needed.
*/
static void
http_add_field(http_t *http, /* I - HTTP connection */
http_field_t field, /* I - HTTP field */
const char *value, /* I - Value string */
int append) /* I - Append value? */
{
char newvalue[1024]; /* New value string */
const char *oldvalue; /* Old field value */
/*
* Optionally append the new value to the existing one...
*/
if (append && field != HTTP_FIELD_ACCEPT_ENCODING && field != HTTP_FIELD_ACCEPT_LANGUAGE && field != HTTP_FIELD_ACCEPT_RANGES && field != HTTP_FIELD_ALLOW && field != HTTP_FIELD_LINK && field != HTTP_FIELD_TRANSFER_ENCODING && field != HTTP_FIELD_UPGRADE && field != HTTP_FIELD_WWW_AUTHENTICATE)
append = 0;
if (field == HTTP_FIELD_HOST)
{
/*
* Special-case for Host: as we don't want a trailing "." on the hostname and
* need to bracket IPv6 numeric addresses.
*/
char *ptr = strchr(value, ':');
if (value[0] != '[' && ptr && strchr(ptr + 1, ':'))
{
/*
* Bracket IPv6 numeric addresses...
*/
snprintf(newvalue, sizeof(newvalue), "[%s]", value);
value = newvalue;
}
else if (*value && value[strlen(value) - 1] == '.')
{
/*
* Strip the trailing dot on the hostname...
*/
strlcpy(newvalue, value, sizeof(newvalue));
newvalue[strlen(newvalue) - 1] = '\0';
value = newvalue;
}
}
else if (append && *value && (oldvalue = httpGetField(http, field)) != NULL && *oldvalue)
{
snprintf(newvalue, sizeof(newvalue), "%s, %s", oldvalue, value);
value = newvalue;
}
/*
* Save the new value...
*/
switch (field)
{
case HTTP_FIELD_ACCEPT_ENCODING :
if (http->accept_encoding)
_cupsStrFree(http->accept_encoding);
http->accept_encoding = _cupsStrAlloc(value);
break;
case HTTP_FIELD_ALLOW :
if (http->allow)
_cupsStrFree(http->allow);
http->allow = _cupsStrAlloc(value);
break;
case HTTP_FIELD_SERVER :
if (http->server)
_cupsStrFree(http->server);
http->server = _cupsStrAlloc(value);
break;
case HTTP_FIELD_AUTHENTICATION_INFO :
if (http->authentication_info)
_cupsStrFree(http->authentication_info);
http->authentication_info = _cupsStrAlloc(value);
break;
default :
strlcpy(http->fields[field], value, HTTP_MAX_VALUE);
break;
}
if (field == HTTP_FIELD_AUTHORIZATION)
{
/*
* Special case for Authorization: as its contents can be
* longer than HTTP_MAX_VALUE
*/
if (http->field_authorization)
free(http->field_authorization);
http->field_authorization = strdup(value);
}
#ifdef HAVE_LIBZ
else if (field == HTTP_FIELD_CONTENT_ENCODING &&
http->data_encoding != HTTP_ENCODING_FIELDS)
{
DEBUG_puts("1http_add_field: Calling http_content_coding_start.");
http_content_coding_start(http, value);
}
#endif /* HAVE_LIBZ */
}
#ifdef HAVE_LIBZ
/*
* 'http_content_coding_finish()' - Finish doing any content encoding.
@@ -3710,13 +3750,13 @@ http_content_coding_finish(
{
case _HTTP_CODING_DEFLATE :
case _HTTP_CODING_GZIP :
http->stream.next_in = dummy;
http->stream.avail_in = 0;
((z_stream *)http->stream)->next_in = dummy;
((z_stream *)http->stream)->avail_in = 0;
do
{
zerr = deflate(&(http->stream), Z_FINISH);
bytes = _HTTP_MAX_SBUFFER - http->stream.avail_out;
zerr = deflate((z_stream *)http->stream, Z_FINISH);
bytes = _HTTP_MAX_SBUFFER - ((z_stream *)http->stream)->avail_out;
if (bytes > 0)
{
@@ -3728,15 +3768,18 @@ http_content_coding_finish(
http_write(http, (char *)http->sbuffer, bytes);
}
http->stream.next_out = (Bytef *)http->sbuffer;
http->stream.avail_out = (uInt)_HTTP_MAX_SBUFFER;
((z_stream *)http->stream)->next_out = (Bytef *)http->sbuffer;
((z_stream *)http->stream)->avail_out = (uInt)_HTTP_MAX_SBUFFER;
}
while (zerr == Z_OK);
deflateEnd(&(http->stream));
deflateEnd((z_stream *)http->stream);
free(http->sbuffer);
free(http->stream);
http->sbuffer = NULL;
http->stream = NULL;
if (http->wused)
httpFlushWrite(http);
@@ -3744,9 +3787,13 @@ http_content_coding_finish(
case _HTTP_CODING_INFLATE :
case _HTTP_CODING_GUNZIP :
inflateEnd(&(http->stream));
inflateEnd((z_stream *)http->stream);
free(http->sbuffer);
free(http->stream);
http->sbuffer = NULL;
http->stream = NULL;
break;
default :
@@ -3816,8 +3863,6 @@ http_content_coding_start(
return;
}
memset(&(http->stream), 0, sizeof(http->stream));
switch (coding)
{
case _HTTP_CODING_DEFLATE :
@@ -3838,18 +3883,30 @@ http_content_coding_start(
* documentation.
*/
if ((zerr = deflateInit2(&(http->stream), Z_DEFAULT_COMPRESSION,
Z_DEFLATED,
coding == _HTTP_CODING_DEFLATE ? -11 : 27, 7,
Z_DEFAULT_STRATEGY)) < Z_OK)
if ((http->stream = calloc(1, sizeof(z_stream))) == NULL)
{
free(http->sbuffer);
http->sbuffer = NULL;
http->status = HTTP_STATUS_ERROR;
http->error = errno;
return;
}
if ((zerr = deflateInit2((z_stream *)http->stream, Z_DEFAULT_COMPRESSION, Z_DEFLATED, coding == _HTTP_CODING_DEFLATE ? -11 : 27, 7, Z_DEFAULT_STRATEGY)) < Z_OK)
{
http->status = HTTP_STATUS_ERROR;
http->error = zerr == Z_MEM_ERROR ? ENOMEM : EINVAL;
free(http->sbuffer);
free(http->stream);
http->sbuffer = NULL;
http->stream = NULL;
http->status = HTTP_STATUS_ERROR;
http->error = zerr == Z_MEM_ERROR ? ENOMEM : EINVAL;
return;
}
http->stream.next_out = (Bytef *)http->sbuffer;
http->stream.avail_out = (uInt)_HTTP_MAX_SBUFFER;
((z_stream *)http->stream)->next_out = (Bytef *)http->sbuffer;
((z_stream *)http->stream)->avail_out = (uInt)_HTTP_MAX_SBUFFER;
break;
case _HTTP_CODING_INFLATE :
@@ -3866,19 +3923,30 @@ http_content_coding_start(
* -15 is raw inflate, 31 is gunzip, per ZLIB documentation.
*/
if ((zerr = inflateInit2(&(http->stream),
coding == _HTTP_CODING_INFLATE ? -15 : 31))
< Z_OK)
if ((http->stream = calloc(1, sizeof(z_stream))) == NULL)
{
free(http->sbuffer);
http->sbuffer = NULL;
http->status = HTTP_STATUS_ERROR;
http->error = errno;
return;
}
if ((zerr = inflateInit2((z_stream *)http->stream, coding == _HTTP_CODING_INFLATE ? -15 : 31)) < Z_OK)
{
free(http->sbuffer);
free(http->stream);
http->sbuffer = NULL;
http->stream = NULL;
http->status = HTTP_STATUS_ERROR;
http->error = zerr == Z_MEM_ERROR ? ENOMEM : EINVAL;
return;
}
http->stream.avail_in = 0;
http->stream.next_in = http->sbuffer;
((z_stream *)http->stream)->avail_in = 0;
((z_stream *)http->stream)->next_in = http->sbuffer;
break;
default :
@@ -3944,7 +4012,7 @@ http_create(
if ((http = calloc(sizeof(http_t), 1)) == NULL)
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, strerror(errno), 0);
httpAddrFreeList(addrlist);
httpAddrFreeList(myaddrlist);
return (NULL);
}
@@ -4056,7 +4124,7 @@ http_read(http_t *http, /* I - HTTP connection */
DEBUG_printf(("http_read(http=%p, buffer=%p, length=" CUPS_LLFMT ")", (void *)http, (void *)buffer, CUPS_LLCAST length));
if (!http->blocking)
if (!http->blocking || http->timeout_value > 0.0)
{
while (!httpWait(http, http->wait_value))
{
@@ -4081,7 +4149,7 @@ http_read(http_t *http, /* I - HTTP connection */
if (bytes < 0)
{
#ifdef WIN32
#ifdef _WIN32
if (WSAGetLastError() != WSAEINTR)
{
http->error = WSAGetLastError();
@@ -4117,7 +4185,7 @@ http_read(http_t *http, /* I - HTTP connection */
http->error = errno;
return (-1);
}
#endif /* WIN32 */
#endif /* _WIN32 */
}
}
while (bytes < 0);
@@ -4131,7 +4199,7 @@ http_read(http_t *http, /* I - HTTP connection */
if (bytes < 0)
{
#ifdef WIN32
#ifdef _WIN32
if (WSAGetLastError() == WSAEINTR)
bytes = 0;
else
@@ -4141,7 +4209,7 @@ http_read(http_t *http, /* I - HTTP connection */
bytes = 0;
else
http->error = errno;
#endif /* WIN32 */
#endif /* _WIN32 */
}
else if (bytes == 0)
{
@@ -4505,7 +4573,7 @@ static void
http_set_timeout(int fd, /* I - File descriptor */
double timeout) /* I - Timeout in seconds */
{
#ifdef WIN32
#ifdef _WIN32
DWORD tv = (DWORD)(timeout * 1000);
/* Timeout in milliseconds */
@@ -4520,7 +4588,7 @@ http_set_timeout(int fd, /* I - File descriptor */
setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, CUPS_SOCAST &tv, sizeof(tv));
setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, CUPS_SOCAST &tv, sizeof(tv));
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -4651,7 +4719,7 @@ http_write(http_t *http, /* I - HTTP connection */
{
DEBUG_printf(("3http_write: About to write %d bytes.", (int)length));
if (http->timeout_cb)
if (http->timeout_value > 0.0)
{
#ifdef HAVE_POLL
struct pollfd pfd; /* Polled file descriptor */
@@ -4682,12 +4750,12 @@ http_write(http_t *http, /* I - HTTP connection */
nfds = select(http->fd + 1, NULL, &output_set, NULL, &timeout);
}
# ifdef WIN32
# ifdef _WIN32
while (nfds < 0 && (WSAGetLastError() == WSAEINTR ||
WSAGetLastError() == WSAEWOULDBLOCK));
# else
while (nfds < 0 && (errno == EINTR || errno == EAGAIN));
# endif /* WIN32 */
# endif /* _WIN32 */
#endif /* HAVE_POLL */
if (nfds < 0)
@@ -4695,13 +4763,13 @@ http_write(http_t *http, /* I - HTTP connection */
http->error = errno;
return (-1);
}
else if (nfds == 0 && !(*http->timeout_cb)(http, http->timeout_data))
else if (nfds == 0 && (!http->timeout_cb || !(*http->timeout_cb)(http, http->timeout_data)))
{
#ifdef WIN32
#ifdef _WIN32
http->error = WSAEWOULDBLOCK;
#else
http->error = EWOULDBLOCK;
#endif /* WIN32 */
#endif /* _WIN32 */
return (-1);
}
}
@@ -4720,7 +4788,7 @@ http_write(http_t *http, /* I - HTTP connection */
if (bytes < 0)
{
#ifdef WIN32
#ifdef _WIN32
if (WSAGetLastError() == WSAEINTR)
continue;
else if (WSAGetLastError() == WSAEWOULDBLOCK)
@@ -4754,7 +4822,7 @@ http_write(http_t *http, /* I - HTTP connection */
http->error = errno;
continue;
}
#endif /* WIN32 */
#endif /* _WIN32 */
DEBUG_printf(("3http_write: error writing data (%s).",
strerror(http->error)));
+11 -8
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Hyper-Text Transport Protocol definitions for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -25,7 +25,7 @@
# include <string.h>
# include <time.h>
# include <sys/types.h>
# ifdef WIN32
# ifdef _WIN32
# ifndef __CUPS_SSIZE_T_DEFINED
# define __CUPS_SSIZE_T_DEFINED
/* Windows does not support the ssize_t type, so map it to off_t... */
@@ -54,7 +54,7 @@ typedef off_t ssize_t; /* @private@ */
# if defined(LOCAL_PEERCRED) && !defined(SO_PEERCRED)
# define SO_PEERCRED LOCAL_PEERCRED
# endif /* LOCAL_PEERCRED && !SO_PEERCRED */
# endif /* WIN32 */
# endif /* _WIN32 */
/*
@@ -85,7 +85,7 @@ extern "C" {
# define s6_addr32 _S6_un._S6_u32
# elif defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__APPLE__)|| defined(__DragonFly__)
# define s6_addr32 __u6_addr.__u6_addr32
# elif defined(WIN32)
# elif defined(_WIN32)
/*
* Windows only defines byte and 16-bit word members of the union and
* requires special casing of all raw address code...
@@ -181,6 +181,7 @@ typedef enum http_field_e /**** HTTP field names ****/
HTTP_FIELD_ACCEPT_ENCODING, /* Accepting-Encoding field @since CUPS 1.7/macOS 10.9@ */
HTTP_FIELD_ALLOW, /* Allow field @since CUPS 1.7/macOS 10.9@ */
HTTP_FIELD_SERVER, /* Server field @since CUPS 1.7/macOS 10.9@ */
HTTP_FIELD_AUTHENTICATION_INFO, /* Authentication-Info field (@since CUPS 2.2.9) */
HTTP_FIELD_MAX /* Maximum field index */
} http_field_t;
@@ -248,10 +249,11 @@ typedef enum http_status_e /**** HTTP status codes ****/
HTTP_STATUS_MULTIPLE_CHOICES = 300, /* Multiple files match request */
HTTP_STATUS_MOVED_PERMANENTLY, /* Document has moved permanently */
HTTP_STATUS_MOVED_TEMPORARILY, /* Document has moved temporarily */
HTTP_STATUS_SEE_OTHER, /* See this other link... */
HTTP_STATUS_FOUND, /* Document was found at a different URI */
HTTP_STATUS_SEE_OTHER, /* See this other link */
HTTP_STATUS_NOT_MODIFIED, /* File not modified */
HTTP_STATUS_USE_PROXY, /* Must use a proxy to access this URI */
HTTP_STATUS_TEMPORARY_REDIRECT = 307, /* Temporary redirection */
HTTP_STATUS_BAD_REQUEST = 400, /* Bad request */
HTTP_STATUS_UNAUTHORIZED, /* Unauthorized to access host */
@@ -285,6 +287,8 @@ typedef enum http_status_e /**** HTTP status codes ****/
HTTP_STATUS_CUPS_PKI_ERROR, /* Error negotiating a secure connection @since CUPS 1.5/macOS 10.7@ */
HTTP_STATUS_CUPS_WEBIF_DISABLED /* Web interface is disabled @private@ */
# define HTTP_STATUS_MOVED_TEMPORARILY HTTP_STATUS_FOUND /* Renamed in RFC 7231 */
# ifndef _CUPS_NO_DEPRECATED
/* Old names for this enumeration */
# define HTTP_ERROR HTTP_STATUS_ERROR
@@ -476,8 +480,7 @@ extern int httpHead(http_t *http, const char *uri);
extern void httpInitialize(void);
extern int httpOptions(http_t *http, const char *uri);
extern int httpPost(http_t *http, const char *uri);
extern int httpPrintf(http_t *http, const char *format, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern int httpPrintf(http_t *http, const char *format, ...) _CUPS_FORMAT(2, 3);
extern int httpPut(http_t *http, const char *uri);
extern int httpRead(http_t *http, char *buffer, int length) _CUPS_DEPRECATED_MSG("Use httpRead2 instead.");
extern int httpReconnect(http_t *http) _CUPS_DEPRECATED_1_6_MSG("Use httpReconnect2 instead.");
+16 -4
Ver Arquivo
@@ -1,8 +1,8 @@
/*
* Internet Printing Protocol support functions for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
* Copyright © 2007-2018 by Apple Inc.
* Copyright © 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -960,9 +960,12 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"feed-orientation-supported",
"finishings",
"finishings-col",
"finishings-col-database",
"finishings-col-default",
"finishings-col-ready",
"finishings-col-supported",
"finishings-default",
"finishings-ready",
"finishings-supported",
"font-name-requested",
"font-name-requested-default",
@@ -1001,6 +1004,7 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"media-bottom-margin-supported",
"media-col",
"media-col-default",
"media-col-ready",
"media-col-supported",
"media-color-supported",
"media-default",
@@ -1015,6 +1019,7 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"media-left-margin-supported",
"media-order-count-supported",
"media-pre-printed-supported",
"media-ready",
"media-recycled-supported",
"media-right-margin-supported",
"media-size-supported",
@@ -1277,9 +1282,12 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"feed-orientation-supported",
"finishings",
"finishings-col",
"finishings-col-database",
"finishings-col-default",
"finishings-col-ready",
"finishings-col-supported",
"finishings-default",
"finishings-ready",
"finishings-supported",
"font-name-requested",
"font-name-requested-default",
@@ -1383,6 +1391,7 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"media-bottom-margin-supported",
"media-col",
"media-col-default",
"media-col-ready",
"media-col-supported",
"media-color-supported",
"media-default",
@@ -1397,6 +1406,7 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"media-left-margin-supported",
"media-order-count-supported",
"media-pre-printed-supported",
"media-ready",
"media-recycled-supported",
"media-right-margin-supported",
"media-size-supported",
@@ -1582,10 +1592,12 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"job-page-limit", /* CUPS extension */
"job-password-encryption-supported",
"job-password-supported",
"job-presets-supported", /* IPP Presets */
"job-quota-period", /* CUPS extension */
"job-resolvers-supported",
"job-settable-attributes-supported",
"job-spooling-supported",
"job-triggers-supported", /* IPP Presets */
"jpeg-k-octets-supported", /* CUPS extension */
"jpeg-x-dimension-supported", /* CUPS extension */
"jpeg-y-dimension-supported", /* CUPS extension */
@@ -1599,8 +1611,6 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"marker-message", /* CUPS extension */
"marker-names", /* CUPS extension */
"marker-types", /* CUPS extension */
"media-col-ready",
"media-ready",
"member-names", /* CUPS extension */
"member-uris", /* CUPS extension */
"multiple-destination-uris-supported",/* IPP FaxOut */
@@ -1623,6 +1633,8 @@ ippCreateRequestedArray(ipp_t *request) /* I - IPP request */
"printer-charge-info",
"printer-charge-info-uri",
"printer-commands", /* CUPS extension */
"printer-config-change-date-time",
"printer-config-change-time",
"printer-current-time",
"printer-detailed-status-messages",
"printer-device-id",
+124 -183
Ver Arquivo
@@ -1,8 +1,8 @@
/*
* Internet Printing Protocol functions for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
* Copyright © 2007-2018 by Apple Inc.
* Copyright © 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -19,9 +19,9 @@
#include "cups-private.h"
#include <regex.h>
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
#endif /* WIN32 */
#endif /* _WIN32 */
/*
@@ -33,12 +33,8 @@ static ipp_attribute_t *ipp_add_attr(ipp_t *ipp, const char *name,
int num_values);
static void ipp_free_values(ipp_attribute_t *attr, int element,
int count);
static char *ipp_get_code(const char *locale, char *buffer,
size_t bufsize)
__attribute__((nonnull(1,2)));
static char *ipp_lang_code(const char *locale, char *buffer,
size_t bufsize)
__attribute__((nonnull(1,2)));
static char *ipp_get_code(const char *locale, char *buffer, size_t bufsize) _CUPS_NONNULL((1, 2));
static char *ipp_lang_code(const char *locale, char *buffer, size_t bufsize) _CUPS_NONNULL((1, 2));
static size_t ipp_length(ipp_t *ipp, int collection);
static ssize_t ipp_read_http(http_t *http, ipp_uchar_t *buffer,
size_t length);
@@ -1483,6 +1479,7 @@ ippCopyAttribute(
int quickcopy) /* I - 1 for a referenced copy, 0 for normal */
{
int i; /* Looping var */
ipp_tag_t srctag; /* Source value tag */
ipp_attribute_t *dstattr; /* Destination attribute */
_ipp_value_t *srcval, /* Source value */
*dstval; /* Destination value */
@@ -1501,144 +1498,86 @@ ippCopyAttribute(
* Copy it...
*/
quickcopy = quickcopy ? IPP_TAG_CUPS_CONST : 0;
quickcopy = (quickcopy && (srcattr->value_tag & IPP_TAG_CUPS_CONST)) ? IPP_TAG_CUPS_CONST : 0;
srctag = srcattr->value_tag & IPP_TAG_CUPS_MASK;
switch (srcattr->value_tag & ~IPP_TAG_CUPS_CONST)
switch (srctag)
{
case IPP_TAG_ZERO :
dstattr = ippAddSeparator(dst);
break;
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
dstattr = ippAddIntegers(dst, srcattr->group_tag, srcattr->value_tag,
srcattr->name, srcattr->num_values, NULL);
if (!dstattr)
break;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
dstval->integer = srcval->integer;
case IPP_TAG_UNSUPPORTED_VALUE :
case IPP_TAG_DEFAULT :
case IPP_TAG_UNKNOWN :
case IPP_TAG_NOVALUE :
case IPP_TAG_NOTSETTABLE :
case IPP_TAG_DELETEATTR :
case IPP_TAG_ADMINDEFINE :
dstattr = ippAddOutOfBand(dst, srcattr->group_tag, srctag, srcattr->name);
break;
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
case IPP_TAG_BOOLEAN :
dstattr = ippAddBooleans(dst, srcattr->group_tag, srcattr->name,
srcattr->num_values, NULL);
if (!dstattr)
break;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
dstval->boolean = srcval->boolean;
case IPP_TAG_DATE :
case IPP_TAG_RESOLUTION :
case IPP_TAG_RANGE :
if ((dstattr = ipp_add_attr(dst, srcattr->name, srcattr->group_tag, srctag, srcattr->num_values)) != NULL)
memcpy(dstattr->values, srcattr->values, (size_t)srcattr->num_values * sizeof(_ipp_value_t));
break;
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_RESERVED_STRING :
case IPP_TAG_KEYWORD :
case IPP_TAG_URI :
case IPP_TAG_URISCHEME :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_MIMETYPE :
dstattr = ippAddStrings(dst, srcattr->group_tag,
(ipp_tag_t)(srcattr->value_tag | quickcopy),
srcattr->name, srcattr->num_values, NULL, NULL);
if (!dstattr)
if ((dstattr = ippAddStrings(dst, srcattr->group_tag, (ipp_tag_t)(srctag | quickcopy), srcattr->name, srcattr->num_values, NULL, NULL)) == NULL)
break;
if (quickcopy)
{
for (i = srcattr->num_values, srcval = srcattr->values,
dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
dstval->string.text = srcval->string.text;
/*
* Can safely quick-copy these string values...
*/
memcpy(dstattr->values, srcattr->values, (size_t)srcattr->num_values * sizeof(_ipp_value_t));
}
else if (srcattr->value_tag & IPP_TAG_CUPS_CONST)
{
for (i = srcattr->num_values, srcval = srcattr->values,
dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
dstval->string.text = _cupsStrAlloc(srcval->string.text);
}
else
{
for (i = srcattr->num_values, srcval = srcattr->values,
dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
dstval->string.text = _cupsStrRetain(srcval->string.text);
}
break;
/*
* Otherwise do a normal reference counted copy...
*/
case IPP_TAG_DATE :
if (srcattr->num_values != 1)
return (NULL);
dstattr = ippAddDate(dst, srcattr->group_tag, srcattr->name,
srcattr->values[0].date);
break;
case IPP_TAG_RESOLUTION :
dstattr = ippAddResolutions(dst, srcattr->group_tag, srcattr->name,
srcattr->num_values, IPP_RES_PER_INCH,
NULL, NULL);
if (!dstattr)
break;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
{
dstval->resolution.xres = srcval->resolution.xres;
dstval->resolution.yres = srcval->resolution.yres;
dstval->resolution.units = srcval->resolution.units;
}
break;
case IPP_TAG_RANGE :
dstattr = ippAddRanges(dst, srcattr->group_tag, srcattr->name,
srcattr->num_values, NULL, NULL);
if (!dstattr)
break;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
{
dstval->range.lower = srcval->range.lower;
dstval->range.upper = srcval->range.upper;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values; i > 0; i --, srcval ++, dstval ++)
dstval->string.text = _cupsStrAlloc(srcval->string.text);
}
break;
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
dstattr = ippAddStrings(dst, srcattr->group_tag,
(ipp_tag_t)(srcattr->value_tag | quickcopy),
srcattr->name, srcattr->num_values, NULL, NULL);
if (!dstattr)
if ((dstattr = ippAddStrings(dst, srcattr->group_tag, (ipp_tag_t)(srctag | quickcopy), srcattr->name, srcattr->num_values, NULL, NULL)) == NULL)
break;
if (quickcopy)
{
for (i = srcattr->num_values, srcval = srcattr->values,
dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
{
dstval->string.language = srcval->string.language;
dstval->string.text = srcval->string.text;
}
/*
* Can safely quick-copy these string values...
*/
memcpy(dstattr->values, srcattr->values, (size_t)srcattr->num_values * sizeof(_ipp_value_t));
}
else if (srcattr->value_tag & IPP_TAG_CUPS_CONST)
{
for (i = srcattr->num_values, srcval = srcattr->values,
dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
/*
* Otherwise do a normal reference counted copy...
*/
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values; i > 0; i --, srcval ++, dstval ++)
{
if (srcval == srcattr->values)
dstval->string.language = _cupsStrAlloc(srcval->string.language);
@@ -1648,32 +1587,13 @@ ippCopyAttribute(
dstval->string.text = _cupsStrAlloc(srcval->string.text);
}
}
else
{
for (i = srcattr->num_values, srcval = srcattr->values,
dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
{
if (srcval == srcattr->values)
dstval->string.language = _cupsStrRetain(srcval->string.language);
else
dstval->string.language = dstattr->values[0].string.language;
dstval->string.text = _cupsStrRetain(srcval->string.text);
}
}
break;
case IPP_TAG_BEGIN_COLLECTION :
dstattr = ippAddCollections(dst, srcattr->group_tag, srcattr->name,
srcattr->num_values, NULL);
if (!dstattr)
if ((dstattr = ippAddCollections(dst, srcattr->group_tag, srcattr->name, srcattr->num_values, NULL)) == NULL)
break;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values; i > 0; i --, srcval ++, dstval ++)
{
dstval->collection = srcval->collection;
srcval->collection->use ++;
@@ -1682,15 +1602,10 @@ ippCopyAttribute(
case IPP_TAG_STRING :
default :
/* TODO: Implement quick copy for unknown/octetString values */
dstattr = ippAddIntegers(dst, srcattr->group_tag, srcattr->value_tag,
srcattr->name, srcattr->num_values, NULL);
if (!dstattr)
if ((dstattr = ipp_add_attr(dst, srcattr->name, srcattr->group_tag, srctag, srcattr->num_values)) == NULL)
break;
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values;
i > 0;
i --, srcval ++, dstval ++)
for (i = srcattr->num_values, srcval = srcattr->values, dstval = dstattr->values; i > 0; i --, srcval ++, dstval ++)
{
dstval->unknown.length = srcval->unknown.length;
@@ -1828,12 +1743,19 @@ ippDelete(ipp_t *ipp) /* I - IPP message */
ipp->use --;
if (ipp->use > 0)
{
DEBUG_printf(("4debug_retain: %p IPP message (use=%d)", (void *)ipp, ipp->use));
return;
}
DEBUG_printf(("4debug_free: %p IPP message", (void *)ipp));
for (attr = ipp->attrs; attr != NULL; attr = next)
{
next = attr->next;
DEBUG_printf(("4debug_free: %p %s %s%s (%d values)", (void *)attr, attr->name, attr->num_values > 1 ? "1setOf " : "", ippTagString(attr->value_tag), attr->num_values));
ipp_free_values(attr, 0, attr->num_values);
if (attr->name)
@@ -1870,6 +1792,8 @@ ippDeleteAttribute(
if (!attr)
return;
DEBUG_printf(("4debug_free: %p %s %s%s (%d values)", (void *)attr, attr->name, attr->num_values > 1 ? "1setOf " : "", ippTagString(attr->value_tag), attr->num_values));
/*
* Find the attribute in the list...
*/
@@ -2705,6 +2629,8 @@ ippNew(void)
* Set default version - usually 2.0...
*/
DEBUG_printf(("4debug_alloc: %p IPP message", (void *)temp));
if (cg->server_version == 0)
_cupsSetDefaults();
@@ -3068,6 +2994,13 @@ ippReadIO(void *src, /* I - Data source */
ipp->state = IPP_STATE_DATA;
break;
}
else if (tag == IPP_TAG_ZERO || (tag == IPP_TAG_OPERATION && ipp->curtag != IPP_TAG_ZERO))
{
_cupsSetError(IPP_STATUS_ERROR_INTERNAL, _("Invalid group tag."), 1);
DEBUG_printf(("1ippReadIO: bad tag 0x%02x.", tag));
_cupsBufferRelease((char *)buffer);
return (IPP_STATE_ERROR);
}
else if (tag < IPP_TAG_UNSUPPORTED_VALUE)
{
/*
@@ -3365,7 +3298,10 @@ ippReadIO(void *src, /* I - Data source */
value->boolean = (char)buffer[0];
break;
case IPP_TAG_NOVALUE :
case IPP_TAG_UNSUPPORTED_VALUE :
case IPP_TAG_DEFAULT :
case IPP_TAG_UNKNOWN :
case IPP_TAG_NOVALUE :
case IPP_TAG_NOTSETTABLE :
case IPP_TAG_DELETEATTR :
case IPP_TAG_ADMINDEFINE :
@@ -3385,6 +3321,7 @@ ippReadIO(void *src, /* I - Data source */
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_RESERVED_STRING :
case IPP_TAG_KEYWORD :
case IPP_TAG_URI :
case IPP_TAG_URISCHEME :
@@ -4285,17 +4222,21 @@ ippSetString(ipp_t *ipp, /* I - IPP message */
{
char *temp; /* Temporary string */
_ipp_value_t *value; /* Current value */
ipp_tag_t value_tag; /* Value tag */
/*
* Range check input...
*/
if (attr && *attr)
value_tag = (*attr)->value_tag & IPP_TAG_CUPS_MASK;
else
value_tag = IPP_TAG_ZERO;
if (!ipp || !attr || !*attr ||
((*attr)->value_tag != IPP_TAG_TEXTLANG &&
(*attr)->value_tag != IPP_TAG_NAMELANG &&
((*attr)->value_tag < IPP_TAG_TEXT ||
(*attr)->value_tag > IPP_TAG_MIMETYPE)) ||
(value_tag < IPP_TAG_TEXT && value_tag != IPP_TAG_TEXTLANG &&
value_tag != IPP_TAG_NAMELANG) || value_tag > IPP_TAG_MIMETYPE ||
element < 0 || element > (*attr)->num_values || !strvalue)
return (0);
@@ -4787,21 +4728,6 @@ ippValidateAttribute(
ipp_attribute_t *colattr; /* Collection attribute */
regex_t re; /* Regular expression */
ipp_uchar_t *date; /* Current date value */
static const char * const uri_status_strings[] =
{ /* URI status strings */
"URI too large",
"Bad arguments to function",
"Bad resource in URI",
"Bad port number in URI",
"Bad hostname/address in URI",
"Bad username in URI",
"Bad scheme in URI",
"Bad/empty URI",
"OK",
"Missing scheme in URI",
"Unknown scheme in URI",
"Missing resource in URI"
};
/*
@@ -5076,16 +5002,23 @@ ippValidateAttribute(
}
else if (*ptr & 0x80)
break;
else if ((*ptr < ' ' && *ptr != '\n' && *ptr != '\r' && *ptr != '\t') || *ptr == 0x7f)
break;
}
if (*ptr)
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
_("\"%s\": Bad text value \"%s\" - bad UTF-8 "
"sequence (RFC 8011 section 5.1.2)."), attr->name,
attr->values[i].string.text);
return (0);
}
if (*ptr)
{
if (*ptr < ' ' || *ptr == 0x7f)
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST, _("\"%s\": Bad text value \"%s\" - bad control character (PWG 5100.14 section 8.3)."), attr->name, attr->values[i].string.text);
return (0);
}
else
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST, _("\"%s\": Bad text value \"%s\" - bad UTF-8 sequence (RFC 8011 section 5.1.2)."), attr->name, attr->values[i].string.text);
return (0);
}
}
if ((ptr - attr->values[i].string.text) > (IPP_MAX_TEXT - 1))
{
@@ -5134,16 +5067,23 @@ ippValidateAttribute(
}
else if (*ptr & 0x80)
break;
else if (*ptr < ' ' || *ptr == 0x7f)
break;
}
if (*ptr)
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
_("\"%s\": Bad name value \"%s\" - bad UTF-8 "
"sequence (RFC 8011 section 5.1.3)."), attr->name,
attr->values[i].string.text);
return (0);
}
if (*ptr < ' ' || *ptr == 0x7f)
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST, _("\"%s\": Bad name value \"%s\" - bad control character (PWG 5100.14 section 8.1)."), attr->name, attr->values[i].string.text);
return (0);
}
else
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST, _("\"%s\": Bad name value \"%s\" - bad UTF-8 sequence (RFC 8011 section 5.1.3)."), attr->name, attr->values[i].string.text);
return (0);
}
}
if ((ptr - attr->values[i].string.text) > (IPP_MAX_NAME - 1))
{
@@ -5198,12 +5138,7 @@ ippValidateAttribute(
if (uri_status < HTTP_URI_STATUS_OK)
{
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST,
_("\"%s\": Bad URI value \"%s\" - %s "
"(RFC 8011 section 5.1.6)."), attr->name,
attr->values[i].string.text,
uri_status_strings[uri_status -
HTTP_URI_STATUS_OVERFLOW]);
ipp_set_error(IPP_STATUS_ERROR_BAD_REQUEST, _("\"%s\": Bad URI value \"%s\" - %s (RFC 8011 section 5.1.6)."), attr->name, attr->values[i].string.text, httpURIStatusString(uri_status));
return (0);
}
@@ -6402,6 +6337,8 @@ ipp_add_attr(ipp_t *ipp, /* I - IPP message */
* Initialize attribute...
*/
DEBUG_printf(("4debug_alloc: %p %s %s%s (%d values)", (void *)attr, name, num_values > 1 ? "1setOf " : "", ippTagString(value_tag), num_values));
if (name)
attr->name = _cupsStrAlloc(name);
@@ -6479,6 +6416,7 @@ ipp_free_values(ipp_attribute_t *attr, /* I - Attribute to free values from */
}
break;
case IPP_TAG_UNSUPPORTED_VALUE :
case IPP_TAG_DEFAULT :
case IPP_TAG_UNKNOWN :
case IPP_TAG_NOVALUE :
@@ -6820,14 +6758,14 @@ ipp_read_http(http_t *http, /* I - Client connection */
if ((bytes = httpRead2(http, (char *)buffer, length - (size_t)tbytes)) < 0)
{
#ifdef WIN32
#ifdef _WIN32
break;
#else
if (errno != EAGAIN && errno != EINTR)
break;
bytes = 0;
#endif /* WIN32 */
#endif /* _WIN32 */
}
else if (bytes == 0)
break;
@@ -6855,11 +6793,11 @@ ipp_read_file(int *fd, /* I - File descriptor */
ipp_uchar_t *buffer, /* O - Read buffer */
size_t length) /* I - Number of bytes to read */
{
#ifdef WIN32
#ifdef _WIN32
return ((ssize_t)read(*fd, buffer, (unsigned)length));
#else
return (read(*fd, buffer, length));
#endif /* WIN32 */
#endif /* _WIN32 */
}
@@ -6958,6 +6896,9 @@ ipp_set_value(ipp_t *ipp, /* IO - IPP message */
* Reset pointers in the list...
*/
DEBUG_printf(("4debug_free: %p %s", (void *)*attr, temp->name));
DEBUG_printf(("4debug_alloc: %p %s %s%s (%d)", (void *)temp, temp->name, temp->num_values > 1 ? "1setOf " : "", ippTagString(temp->value_tag), temp->num_values));
if (ipp->current == *attr && ipp->prev)
{
/*
@@ -7024,9 +6965,9 @@ ipp_write_file(int *fd, /* I - File descriptor */
ipp_uchar_t *buffer, /* I - Data to write */
size_t length) /* I - Number of bytes to write */
{
#ifdef WIN32
#ifdef _WIN32
return ((ssize_t)write(*fd, buffer, (unsigned)length));
#else
return (write(*fd, buffer, length));
#endif /* WIN32 */
#endif /* _WIN32 */
}
+5 -5
Ver Arquivo
@@ -79,11 +79,11 @@ extern "C" {
typedef enum ipp_dstate_e /**** Document states @exclude all@ ****/
{
IPP_DOCUMENT_PENDING = 3, /* Document is pending */
IPP_DOCUMENT_PROCESSING = 5, /* Document is processing */
IPP_DOCUMENT_CANCELED = 7, /* Document is canceled */
IPP_DOCUMENT_ABORTED, /* Document is aborted */
IPP_DOCUMENT_COMPLETED /* Document is completed */
IPP_DSTATE_PENDING = 3, /* Document is pending */
IPP_DSTATE_PROCESSING = 5, /* Document is processing */
IPP_DSTATE_CANCELED = 7, /* Document is canceled */
IPP_DSTATE_ABORTED, /* Document is aborted */
IPP_DSTATE_COMPLETED /* Document is completed */
# ifndef _CUPS_NO_DEPRECATED
# define IPP_DOCUMENT_PENDING IPP_DSTATE_PENDING
+6 -10
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Private localization support for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -20,6 +20,7 @@
* Include necessary headers...
*/
# include "config.h"
# include <stdio.h>
# include <cups/transcode.h>
# ifdef __APPLE__
@@ -59,16 +60,11 @@ extern const char *_cupsAppleLocale(CFStringRef languageName, char *locale, size
# endif /* __APPLE__ */
extern void _cupsCharmapFlush(void);
extern const char *_cupsEncodingName(cups_encoding_t encoding);
extern void _cupsLangPrintError(const char *prefix,
const char *message);
extern int _cupsLangPrintFilter(FILE *fp, const char *prefix,
const char *message, ...)
__attribute__ ((__format__ (__printf__, 3, 4)));
extern int _cupsLangPrintf(FILE *fp, const char *message, ...)
__attribute__ ((__format__ (__printf__, 2, 3)));
extern void _cupsLangPrintError(const char *prefix, const char *message);
extern int _cupsLangPrintFilter(FILE *fp, const char *prefix, const char *message, ...) _CUPS_FORMAT(3, 4);
extern int _cupsLangPrintf(FILE *fp, const char *message, ...) _CUPS_FORMAT(2, 3);
extern int _cupsLangPuts(FILE *fp, const char *message);
extern const char *_cupsLangString(cups_lang_t *lang,
const char *message);
extern const char *_cupsLangString(cups_lang_t *lang, const char *message);
extern void _cupsMessageFree(cups_array_t *a);
extern cups_array_t *_cupsMessageLoad(const char *filename, int unquote);
extern const char *_cupsMessageLookup(cups_array_t *a, const char *m);
+67 -9
Ver Arquivo
@@ -21,11 +21,11 @@
#ifdef HAVE_LANGINFO_H
# include <langinfo.h>
#endif /* HAVE_LANGINFO_H */
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 */
#endif /* _WIN32 */
#ifdef HAVE_COREFOUNDATION_H
# include <CoreFoundation/CoreFoundation.h>
#endif /* HAVE_COREFOUNDATION_H */
@@ -123,7 +123,9 @@ static const _apple_language_locale_t apple_language_locale[] =
{ "nb", "no" },
{ "nb_NO", "no" },
{ "zh-Hans", "zh_CN" },
{ "zh_HANS", "zh_CN" },
{ "zh-Hant", "zh_TW" },
{ "zh_HANT", "zh_TW" },
{ "zh-Hant_CN", "zh_TW" }
};
#endif /* __APPLE__ */
@@ -254,8 +256,16 @@ _cupsAppleLocale(CFStringRef languageName, /* I - Apple language ID */
{
int i; /* Looping var */
CFStringRef localeName; /* Locale as a CF string */
#ifdef DEBUG
char temp[1024]; /* Temporary string */
if (!CFStringGetCString(languageName, temp, (CFIndex)sizeof(temp), kCFStringEncodingASCII))
temp[0] = '\0';
DEBUG_printf(("_cupsAppleLocale(languageName=%p(%s), locale=%p, localsize=%d)", (void *)languageName, temp, (void *)locale, (int)localesize));
#endif /* DEBUG */
localeName = CFLocaleCreateCanonicalLocaleIdentifierFromString(kCFAllocatorDefault, languageName);
if (localeName)
@@ -267,6 +277,8 @@ _cupsAppleLocale(CFStringRef languageName, /* I - Apple language ID */
if (!CFStringGetCString(localeName, locale, (CFIndex)localesize, kCFStringEncodingASCII))
*locale = '\0';
DEBUG_printf(("_cupsAppleLocale: locale=\"%s\"", locale));
CFRelease(localeName);
/*
@@ -278,8 +290,12 @@ _cupsAppleLocale(CFStringRef languageName, /* I - Apple language ID */
sizeof(apple_language_locale[0]));
i ++)
{
if (!strcmp(locale, apple_language_locale[i].language))
size_t len = strlen(apple_language_locale[i].language);
if (!strcmp(locale, apple_language_locale[i].language) ||
(!strncmp(locale, apple_language_locale[i].language, len) && (locale[len] == '_' || locale[len] == '-')))
{
DEBUG_printf(("_cupsAppleLocale: Updating locale to \"%s\".", apple_language_locale[i].locale));
strlcpy(locale, apple_language_locale[i].locale, localesize);
break;
}
@@ -296,7 +312,10 @@ _cupsAppleLocale(CFStringRef languageName, /* I - Apple language ID */
}
if (!*locale)
{
DEBUG_puts("_cupsAppleLocale: Returning NULL.");
return (NULL);
}
/*
* Convert language subtag into region subtag...
@@ -304,10 +323,14 @@ _cupsAppleLocale(CFStringRef languageName, /* I - Apple language ID */
if (locale[2] == '-')
locale[2] = '_';
else if (locale[3] == '-')
locale[3] = '_';
if (!strchr(locale, '.'))
strlcat(locale, ".UTF-8", localesize);
DEBUG_printf(("_cupsAppleLocale: Returning \"%s\".", locale));
return (locale);
}
#endif /* __APPLE__ */
@@ -669,6 +692,15 @@ cupsLangGet(const char *language) /* I - Language or locale */
*ptr++ = (char)toupper(*language & 255);
*ptr = '\0';
/*
* Map Chinese region codes to legacy country codes.
*/
if (!strcmp(language, "zh") && !strcmp(country, "HANS"))
strlcpy(country, "CN", sizeof(country));
if (!strcmp(language, "zh") && !strcmp(country, "HANT"))
strlcpy(country, "TW", sizeof(country));
}
if (*language == '.' && !charset[0])
@@ -688,7 +720,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
* Force a POSIX locale for an invalid language name...
*/
if (strlen(langname) != 2)
if (strlen(langname) != 2 && strlen(langname) != 3)
{
strlcpy(langname, "C", sizeof(langname));
country[0] = '\0';
@@ -828,6 +860,9 @@ _cupsLangString(cups_lang_t *lang, /* I - Language */
{
const char *s; /* Localized message */
DEBUG_printf(("_cupsLangString(lang=%p, message=\"%s\")", (void *)lang, message));
/*
* Range check input...
*/
@@ -1126,6 +1161,8 @@ _cupsMessageLookup(cups_array_t *a, /* I - Message array */
*match; /* Matching message */
DEBUG_printf(("_cupsMessageLookup(a=%p, m=\"%s\")", (void *)a, m));
/*
* Lookup the message string; if it doesn't exist in the catalog,
* then return the message that was passed to us...
@@ -1336,11 +1373,13 @@ appleMessageLoad(const char *locale) /* I - Locale ID */
{
char filename[1024], /* Path to cups.strings file */
applelang[256], /* Apple language ID */
baselang[3]; /* Base language */
baselang[4]; /* Base language */
CFURLRef url; /* URL to cups.strings file */
CFReadStreamRef stream = NULL; /* File stream */
CFPropertyListRef plist = NULL; /* Localization file */
#ifdef DEBUG
const char *cups_strings = getenv("CUPS_STRINGS");
/* Test strings file */
CFErrorRef error = NULL; /* Error when opening file */
#endif /* DEBUG */
@@ -1351,6 +1390,15 @@ appleMessageLoad(const char *locale) /* I - Locale ID */
* Load the cups.strings file...
*/
#ifdef DEBUG
if (cups_strings)
{
DEBUG_puts("1appleMessageLoad: Using debug CUPS_STRINGS file.");
strlcpy(filename, cups_strings, sizeof(filename));
}
else
#endif /* DEBUG */
snprintf(filename, sizeof(filename),
CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings",
_cupsAppleLanguage(locale, applelang, sizeof(applelang)));
@@ -1363,6 +1411,7 @@ appleMessageLoad(const char *locale) /* I - Locale ID */
* Try with original locale string...
*/
DEBUG_printf(("1appleMessageLoad: \"%s\": %s", filename, strerror(errno)));
snprintf(filename, sizeof(filename), CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings", locale);
}
@@ -1374,18 +1423,23 @@ appleMessageLoad(const char *locale) /* I - Locale ID */
* Try with just the language code...
*/
DEBUG_printf(("1appleMessageLoad: \"%s\": %s", filename, strerror(errno)));
strlcpy(baselang, locale, sizeof(baselang));
if (baselang[3] == '-' || baselang[3] == '_')
baselang[3] = '\0';
snprintf(filename, sizeof(filename), CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings", baselang);
}
DEBUG_printf(("1appleMessageLoad: filename=\"%s\"", filename));
if (access(filename, 0))
{
/*
* Try alternate lproj directory names...
*/
DEBUG_printf(("1appleMessageLoad: \"%s\": %s", filename, strerror(errno)));
if (!strncmp(locale, "en", 2))
locale = "English";
else if (!strncmp(locale, "nb", 2))
@@ -1402,7 +1456,7 @@ appleMessageLoad(const char *locale) /* I - Locale ID */
locale = "Japanese";
else if (!strncmp(locale, "es", 2))
locale = "Spanish";
else if (!strcmp(locale, "zh_HK") || !strncmp(locale, "zh-Hant", 7))
else if (!strcmp(locale, "zh_HK") || !strncasecmp(locale, "zh-Hant", 7) || !strncasecmp(locale, "zh_Hant", 7))
{
/*
* <rdar://problem/22130168>
@@ -1423,14 +1477,18 @@ appleMessageLoad(const char *locale) /* I - Locale ID */
*/
strlcpy(baselang, locale, sizeof(baselang));
if (baselang[2] == '-' || baselang[2] == '_')
baselang[2] = '\0';
locale = baselang;
}
snprintf(filename, sizeof(filename),
CUPS_BUNDLEDIR "/Resources/%s.lproj/cups.strings", locale);
DEBUG_printf(("1appleMessageLoad: alternate filename=\"%s\"", filename));
}
DEBUG_printf(("1appleMessageLoad: filename=\"%s\"", filename));
url = CFURLCreateFromFileSystemRepresentation(kCFAllocatorDefault,
(UInt8 *)filename,
(CFIndex)strlen(filename), false);
+7 -16
Ver Arquivo
@@ -1,5 +1,5 @@
LIBRARY libcups2
VERSION 2.12
VERSION 2.13
EXPORTS
_cupsArrayAddStrings
_cupsArrayNewStrings
@@ -13,6 +13,7 @@ _cupsConnect
_cupsConvertOptions
_cupsCreateDest
_cupsEncodingName
_cupsFilePeekAhead
_cupsGet1284Values
_cupsGetDestResource
_cupsGetDests
@@ -24,9 +25,6 @@ _cupsLangPrintError
_cupsLangPrintf
_cupsLangPuts
_cupsLangString
_cupsMD5Append
_cupsMD5Finish
_cupsMD5Init
_cupsMessageFree
_cupsMessageLoad
_cupsMessageLookup
@@ -39,18 +37,6 @@ _cupsRWInit
_cupsRWLockRead
_cupsRWLockWrite
_cupsRWUnlock
_cupsSNMPClose
_cupsSNMPCopyOID
_cupsSNMPDefaultCommunity
_cupsSNMPIsOID
_cupsSNMPIsOIDPrefixed
_cupsSNMPOIDToString
_cupsSNMPOpen
_cupsSNMPRead
_cupsSNMPSetDebug
_cupsSNMPStringToOID
_cupsSNMPWalk
_cupsSNMPWrite
_cupsSetDefaults
_cupsSetError
_cupsSetHTTPError
@@ -65,6 +51,7 @@ _cupsStrScand
_cupsStrStatistics
_cupsThreadCancel
_cupsThreadCreate
_cupsThreadDetach
_cupsThreadWait
_cupsUserDefault
_cups_safe_vsnprintf
@@ -81,6 +68,7 @@ _httpDisconnect
_httpEncodeURI
_httpFreeCredentials
_httpResolveURI
_httpSetDigestAuthString
_httpStatus
_httpTLSInitialize
_httpTLSPending
@@ -124,6 +112,7 @@ _pwgMediaTable
_pwgMediaTypeForType
_pwgPageSizeForMedia
cupsAddDest
cupsAddIntegerOption
cupsAddOption
cupsAdminCreateWindowsPPD
cupsAdminExportSamba
@@ -227,6 +216,7 @@ cupsGetDests2
cupsGetDevices
cupsGetFd
cupsGetFile
cupsGetIntegerOption
cupsGetJobs
cupsGetJobs2
cupsGetNamedDest
@@ -240,6 +230,7 @@ cupsGetPrinters
cupsGetResponse
cupsGetServerPPD
cupsHashData
cupsHashString
cupsLangDefault
cupsLangEncoding
cupsLangFlush
+86 -84
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Private MD5 implementation for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 2007-2017 by Apple Inc.
* Copyright 2005 by Easy Software Products
* Copyright (C) 1999 Aladdin Enterprises. All rights reserved.
*
@@ -43,70 +43,71 @@
#include "md5-private.h"
#include "string-private.h"
#define T1 0xd76aa478
#define T2 0xe8c7b756
#define T3 0x242070db
#define T4 0xc1bdceee
#define T5 0xf57c0faf
#define T6 0x4787c62a
#define T7 0xa8304613
#define T8 0xfd469501
#define T9 0x698098d8
#define T10 0x8b44f7af
#define T11 0xffff5bb1
#define T12 0x895cd7be
#define T13 0x6b901122
#define T14 0xfd987193
#define T15 0xa679438e
#define T16 0x49b40821
#define T17 0xf61e2562
#define T18 0xc040b340
#define T19 0x265e5a51
#define T20 0xe9b6c7aa
#define T21 0xd62f105d
#define T22 0x02441453
#define T23 0xd8a1e681
#define T24 0xe7d3fbc8
#define T25 0x21e1cde6
#define T26 0xc33707d6
#define T27 0xf4d50d87
#define T28 0x455a14ed
#define T29 0xa9e3e905
#define T30 0xfcefa3f8
#define T31 0x676f02d9
#define T32 0x8d2a4c8a
#define T33 0xfffa3942
#define T34 0x8771f681
#define T35 0x6d9d6122
#define T36 0xfde5380c
#define T37 0xa4beea44
#define T38 0x4bdecfa9
#define T39 0xf6bb4b60
#define T40 0xbebfbc70
#define T41 0x289b7ec6
#define T42 0xeaa127fa
#define T43 0xd4ef3085
#define T44 0x04881d05
#define T45 0xd9d4d039
#define T46 0xe6db99e5
#define T47 0x1fa27cf8
#define T48 0xc4ac5665
#define T49 0xf4292244
#define T50 0x432aff97
#define T51 0xab9423a7
#define T52 0xfc93a039
#define T53 0x655b59c3
#define T54 0x8f0ccc92
#define T55 0xffeff47d
#define T56 0x85845dd1
#define T57 0x6fa87e4f
#define T58 0xfe2ce6e0
#define T59 0xa3014314
#define T60 0x4e0811a1
#define T61 0xf7537e82
#define T62 0xbd3af235
#define T63 0x2ad7d2bb
#define T64 0xeb86d391
#if !defined(__APPLE__) && !defined(HAVE_GNUTLS)
# define T1 0xd76aa478
# define T2 0xe8c7b756
# define T3 0x242070db
# define T4 0xc1bdceee
# define T5 0xf57c0faf
# define T6 0x4787c62a
# define T7 0xa8304613
# define T8 0xfd469501
# define T9 0x698098d8
# define T10 0x8b44f7af
# define T11 0xffff5bb1
# define T12 0x895cd7be
# define T13 0x6b901122
# define T14 0xfd987193
# define T15 0xa679438e
# define T16 0x49b40821
# define T17 0xf61e2562
# define T18 0xc040b340
# define T19 0x265e5a51
# define T20 0xe9b6c7aa
# define T21 0xd62f105d
# define T22 0x02441453
# define T23 0xd8a1e681
# define T24 0xe7d3fbc8
# define T25 0x21e1cde6
# define T26 0xc33707d6
# define T27 0xf4d50d87
# define T28 0x455a14ed
# define T29 0xa9e3e905
# define T30 0xfcefa3f8
# define T31 0x676f02d9
# define T32 0x8d2a4c8a
# define T33 0xfffa3942
# define T34 0x8771f681
# define T35 0x6d9d6122
# define T36 0xfde5380c
# define T37 0xa4beea44
# define T38 0x4bdecfa9
# define T39 0xf6bb4b60
# define T40 0xbebfbc70
# define T41 0x289b7ec6
# define T42 0xeaa127fa
# define T43 0xd4ef3085
# define T44 0x04881d05
# define T45 0xd9d4d039
# define T46 0xe6db99e5
# define T47 0x1fa27cf8
# define T48 0xc4ac5665
# define T49 0xf4292244
# define T50 0x432aff97
# define T51 0xab9423a7
# define T52 0xfc93a039
# define T53 0x655b59c3
# define T54 0x8f0ccc92
# define T55 0xffeff47d
# define T56 0x85845dd1
# define T57 0x6fa87e4f
# define T58 0xfe2ce6e0
# define T59 0xa3014314
# define T60 0x4e0811a1
# define T61 0xf7537e82
# define T62 0xbd3af235
# define T63 0x2ad7d2bb
# define T64 0xeb86d391
static void
_cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
@@ -116,10 +117,10 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
c = pms->abcd[2], d = pms->abcd[3];
unsigned int t;
#ifndef ARCH_IS_BIG_ENDIAN
# define ARCH_IS_BIG_ENDIAN 1 /* slower, default implementation */
#endif
#if ARCH_IS_BIG_ENDIAN
# ifndef ARCH_IS_BIG_ENDIAN
# define ARCH_IS_BIG_ENDIAN 1 /* slower, default implementation */
# endif
# if ARCH_IS_BIG_ENDIAN
/*
* On big-endian machines, we must arrange the bytes in the right
@@ -133,7 +134,7 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
X[i] = (unsigned)xp[0] + ((unsigned)xp[1] << 8) +
((unsigned)xp[2] << 16) + ((unsigned)xp[3] << 24);
#else /* !ARCH_IS_BIG_ENDIAN */
# else /* !ARCH_IS_BIG_ENDIAN */
/*
* On little-endian machines, we can process properly aligned data
@@ -150,15 +151,15 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
memcpy(xbuf, data, 64);
X = xbuf;
}
#endif
# endif
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
# define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET(a, b, c, d, k, s, Ti)\
# define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
# define SET(a, b, c, d, k, s, Ti)\
t = a + F(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
@@ -178,13 +179,13 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
SET(d, a, b, c, 13, 12, T14);
SET(c, d, a, b, 14, 17, T15);
SET(b, c, d, a, 15, 22, T16);
#undef SET
# undef SET
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
# define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
# define SET(a, b, c, d, k, s, Ti)\
t = a + G(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
@@ -204,13 +205,13 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
SET(d, a, b, c, 2, 9, T30);
SET(c, d, a, b, 7, 14, T31);
SET(b, c, d, a, 12, 20, T32);
#undef SET
# undef SET
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET(a, b, c, d, k, s, Ti)\
# define H(x, y, z) ((x) ^ (y) ^ (z))
# define SET(a, b, c, d, k, s, Ti)\
t = a + H(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
@@ -230,13 +231,13 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
SET(d, a, b, c, 12, 11, T46);
SET(c, d, a, b, 15, 16, T47);
SET(b, c, d, a, 2, 23, T48);
#undef SET
# undef SET
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
# define I(x, y, z) ((y) ^ ((x) | ~(z)))
# define SET(a, b, c, d, k, s, Ti)\
t = a + I(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
@@ -256,7 +257,7 @@ _cups_md5_process(_cups_md5_state_t *pms, const unsigned char *data /*[64]*/)
SET(d, a, b, c, 11, 10, T62);
SET(c, d, a, b, 2, 15, T63);
SET(b, c, d, a, 9, 21, T64);
#undef SET
# undef SET
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
@@ -337,3 +338,4 @@ _cupsMD5Finish(_cups_md5_state_t *pms, unsigned char digest[16])
for (i = 0; i < 16; ++i)
digest[i] = (unsigned char)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}
#endif /* !__APPLE__ && !HAVE_GNUTLS */
+16 -36
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* MD5 password support for CUPS.
* MD5 password support for CUPS (deprecated).
*
* Copyright 2007-2010 by Apple Inc.
* Copyright 2007-2017 by Apple Inc.
* Copyright 1997-2005 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -17,12 +17,15 @@
* Include necessary headers...
*/
#include <cups/cups.h>
#include "http-private.h"
#include "string-private.h"
/*
* 'httpMD5()' - Compute the MD5 sum of the username:group:password.
*
* @deprecated@
*/
char * /* O - MD5 sum */
@@ -31,7 +34,6 @@ httpMD5(const char *username, /* I - User name */
const char *passwd, /* I - Password string */
char md5[33]) /* O - MD5 string */
{
_cups_md5_state_t state; /* MD5 state info */
unsigned char sum[16]; /* Sum data */
char line[256]; /* Line to sum */
@@ -41,15 +43,13 @@ httpMD5(const char *username, /* I - User name */
*/
snprintf(line, sizeof(line), "%s:%s:%s", username, realm, passwd);
_cupsMD5Init(&state);
_cupsMD5Append(&state, (unsigned char *)line, (int)strlen(line));
_cupsMD5Finish(&state, sum);
cupsHashData("md5", (unsigned char *)line, strlen(line), sum, sizeof(sum));
/*
* Return the sum...
*/
return (httpMD5String(sum, md5));
return ((char *)cupsHashString(sum, sizeof(sum), md5, 33));
}
@@ -57,6 +57,8 @@ httpMD5(const char *username, /* I - User name */
* 'httpMD5Final()' - Combine the MD5 sum of the username, group, and password
* with the server-supplied nonce value, method, and
* request-uri.
*
* @deprecated@
*/
char * /* O - New sum */
@@ -65,7 +67,6 @@ httpMD5Final(const char *nonce, /* I - Server nonce value */
const char *resource, /* I - Resource path */
char md5[33]) /* IO - MD5 sum */
{
_cups_md5_state_t state; /* MD5 state info */
unsigned char sum[16]; /* Sum data */
char line[1024]; /* Line of data */
char a2[33]; /* Hash of method and resource */
@@ -76,10 +77,8 @@ httpMD5Final(const char *nonce, /* I - Server nonce value */
*/
snprintf(line, sizeof(line), "%s:%s", method, resource);
_cupsMD5Init(&state);
_cupsMD5Append(&state, (unsigned char *)line, (int)strlen(line));
_cupsMD5Finish(&state, sum);
httpMD5String(sum, a2);
cupsHashData("md5", (unsigned char *)line, strlen(line), sum, sizeof(sum));
cupsHashString(sum, sizeof(sum), a2, sizeof(a2));
/*
* Then combine A1 (MD5 of username, realm, and password) with the nonce
@@ -88,17 +87,16 @@ httpMD5Final(const char *nonce, /* I - Server nonce value */
*/
snprintf(line, sizeof(line), "%s:%s:%s", md5, nonce, a2);
cupsHashData("md5", (unsigned char *)line, strlen(line), sum, sizeof(sum));
_cupsMD5Init(&state);
_cupsMD5Append(&state, (unsigned char *)line, (int)strlen(line));
_cupsMD5Finish(&state, sum);
return (httpMD5String(sum, md5));
return ((char *)cupsHashString(sum, sizeof(sum), md5, 33));
}
/*
* 'httpMD5String()' - Convert an MD5 sum to a character string.
*
* @deprecated@
*/
char * /* O - MD5 sum in hex */
@@ -106,23 +104,5 @@ httpMD5String(const unsigned char *sum, /* I - MD5 sum data */
char md5[33])
/* O - MD5 sum in hex */
{
int i; /* Looping var */
char *md5ptr; /* Pointer into MD5 string */
static const char hex[] = "0123456789abcdef";
/* Hex digits */
/*
* Convert the MD5 sum to hexadecimal...
*/
for (i = 16, md5ptr = md5; i > 0; i --, sum ++)
{
*md5ptr++ = hex[*sum >> 4];
*md5ptr++ = hex[*sum & 15];
}
*md5ptr = '\0';
return (md5);
return ((char *)cupsHashString(sum, 16, md5, 33));
}
+5
Ver Arquivo
@@ -80,6 +80,11 @@ cupsAddOption(const char *name, /* I - Name of option */
return (num_options);
}
if (!_cups_strcasecmp(name, "cupsPrintQuality"))
num_options = cupsRemoveOption("print-quality", num_options, options);
else if (!_cups_strcasecmp(name, "print-quality"))
num_options = cupsRemoveOption("cupsPrintQuality", num_options, options);
/*
* Look for an existing option with the same name...
*/
+283 -122
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* PPD cache implementation for CUPS.
*
* Copyright 2010-2017 by Apple Inc.
* Copyright © 2010-2018 by Apple Inc.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -78,6 +78,8 @@ _cupsConvertOptions(
int num_finishings = 0, /* Number of finishing values */
finishings[10]; /* Finishing enum values */
ppd_choice_t *choice; /* Marked choice */
int finishings_copies = copies;
/* Number of copies for finishings */
/*
@@ -366,13 +368,13 @@ _cupsConvertOptions(
{
ippAddIntegers(request, IPP_TAG_JOB, IPP_TAG_ENUM, "finishings", num_finishings, finishings);
if (copies > 1 && (keyword = cupsGetOption("job-impressions", num_options, options)) != NULL)
if (copies != finishings_copies && (keyword = cupsGetOption("job-impressions", num_options, options)) != NULL)
{
/*
* Send job-pages-per-set attribute to apply finishings correctly...
*/
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-pages-per-set", atoi(keyword) / copies);
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-pages-per-set", atoi(keyword) / finishings_copies);
}
}
@@ -2084,11 +2086,16 @@ _ppdCacheGetFinishingValues(
DEBUG_printf(("_ppdCacheGetFinishingValues(pc=%p, num_options=%d, options=%p, max_values=%d, values=%p)", pc, num_options, options, max_values, values));
if (!pc || !pc->finishings || num_options < 1 || max_values < 1 || !values)
if (!pc || max_values < 1 || !values)
{
DEBUG_puts("_ppdCacheGetFinishingValues: Bad arguments, returning 0.");
return (0);
}
else if (!pc->finishings)
{
DEBUG_puts("_ppdCacheGetFinishingValues: No finishings support, returning 0.");
return (0);
}
/*
* Go through the finishings options and see what is set...
@@ -2114,7 +2121,7 @@ _ppdCacheGetFinishingValues(
if (i == 0)
{
DEBUG_printf(("_ppdCacheGetFinishingValues: Adding %d.", f->value));
DEBUG_printf(("_ppdCacheGetFinishingValues: Adding %d (%s)", f->value, ippEnumString("finishings", f->value)));
values[num_values ++] = f->value;
@@ -2123,6 +2130,17 @@ _ppdCacheGetFinishingValues(
}
}
if (num_values == 0)
{
/*
* Always have at least "finishings" = 'none'...
*/
DEBUG_puts("_ppdCacheGetFinishingValues: Adding 3 (none).");
values[0] = IPP_FINISHINGS_NONE;
num_values ++;
}
DEBUG_printf(("_ppdCacheGetFinishingValues: Returning %d.", num_values));
return (num_values);
@@ -2949,6 +2967,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
is_pwg = 0; /* Does the printer support PWG Raster? */
pwg_media_t *pwg; /* PWG media size */
int xres, yres; /* Resolution values */
int resolutions[1000];
/* Array of resolution indices */
cups_lang_t *lang = cupsLangDefault();
/* Localization info */
struct lconv *loc = localeconv();
@@ -3085,8 +3105,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
cupsFilePrintf(fp, "*Manufacturer: \"%s\"\n", make);
cupsFilePrintf(fp, "*ModelName: \"%s\"\n", model);
cupsFilePrintf(fp, "*Product: \"(%s)\"\n", model);
cupsFilePrintf(fp, "*NickName: \"%s\"\n", model);
cupsFilePrintf(fp, "*ShortNickName: \"%s\"\n", model);
cupsFilePrintf(fp, "*NickName: \"%s - IPP Everywhere\"\n", model);
cupsFilePrintf(fp, "*ShortNickName: \"%s - IPP Everywhere\"\n", model);
if ((attr = ippFindAttribute(response, "color-supported", IPP_TAG_BOOLEAN)) != NULL && ippGetBoolean(attr, 0))
cupsFilePuts(fp, "*ColorDevice: True\n");
@@ -3097,6 +3117,41 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
cupsFilePuts(fp, "*cupsSNMPSupplies: False\n");
cupsFilePuts(fp, "*cupsLanguages: \"en\"\n");
/*
* Password/PIN printing...
*/
if ((attr = ippFindAttribute(response, "job-password-supported", IPP_TAG_INTEGER)) != NULL)
{
char pattern[33]; /* Password pattern */
int maxlen = ippGetInteger(attr, 0);
/* Maximum length */
const char *repertoire = ippGetString(ippFindAttribute(response, "job-password-repertoire-configured", IPP_TAG_KEYWORD), 0, NULL);
/* Type of password */
if (maxlen > (int)(sizeof(pattern) - 1))
maxlen = (int)sizeof(pattern) - 1;
if (!repertoire || !strcmp(repertoire, "iana_us-ascii_digits"))
memset(pattern, '1', (size_t)maxlen);
else if (!strcmp(repertoire, "iana_us-ascii_letters"))
memset(pattern, 'A', (size_t)maxlen);
else if (!strcmp(repertoire, "iana_us-ascii_complex"))
memset(pattern, 'C', (size_t)maxlen);
else if (!strcmp(repertoire, "iana_us-ascii_any"))
memset(pattern, '.', (size_t)maxlen);
else if (!strcmp(repertoire, "iana_utf-8_digits"))
memset(pattern, 'N', (size_t)maxlen);
else if (!strcmp(repertoire, "iana_utf-8_letters"))
memset(pattern, 'U', (size_t)maxlen);
else
memset(pattern, '*', (size_t)maxlen);
pattern[maxlen] = '\0';
cupsFilePrintf(fp, "*cupsPassword: \"%s\"\n", pattern);
}
/*
* Filters...
*/
@@ -3105,24 +3160,28 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
{
is_apple = ippContainsString(attr, "image/urf");
is_pdf = ippContainsString(attr, "application/pdf");
is_pwg = ippContainsString(attr, "image/pwg-raster");
is_pwg = ippContainsString(attr, "image/pwg-raster") && !is_apple;
for (i = 0, count = ippGetCount(attr); i < count; i ++)
if (ippContainsString(attr, "image/jpeg"))
cupsFilePuts(fp, "*cupsFilter2: \"image/jpeg image/jpeg 0 -\"\n");
if (ippContainsString(attr, "image/png"))
cupsFilePuts(fp, "*cupsFilter2: \"image/png image/png 0 -\"\n");
if (is_pdf)
{
const char *format = ippGetString(attr, i, NULL);
/* PDL */
/*
* Write cupsFilter2 lines for supported formats...
* Don't locally filter PDF content when printing to a CUPS shared
* printer, otherwise the options will be applied twice...
*/
if (!_cups_strcasecmp(format, "application/pdf"))
if (ippContainsString(attr, "application/vnd.cups-pdf"))
cupsFilePuts(fp, "*cupsFilter2: \"application/pdf application/pdf 0 -\"\n");
else
cupsFilePuts(fp, "*cupsFilter2: \"application/vnd.cups-pdf application/pdf 10 -\"\n");
else if (!_cups_strcasecmp(format, "image/jpeg") || !_cups_strcasecmp(format, "image/png"))
cupsFilePrintf(fp, "*cupsFilter2: \"%s %s 0 -\"\n", format, format);
else if (!_cups_strcasecmp(format, "image/pwg-raster") || !_cups_strcasecmp(format, "image/urf"))
cupsFilePrintf(fp, "*cupsFilter2: \"%s %s 100 -\"\n", format, format);
}
if (is_apple)
cupsFilePuts(fp, "*cupsFilter2: \"image/urf image/urf 100 -\"\n");
if (is_pwg)
cupsFilePuts(fp, "*cupsFilter2: \"image/pwg-raster image/pwg-raster 100 -\"\n");
}
if (!is_apple && !is_pdf && !is_pwg)
@@ -3394,7 +3453,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
for (j = 0; j < (int)(sizeof(sources) / sizeof(sources[0])); j ++)
if (!strcmp(sources[j][0], ppdname))
{
cupsFilePrintf(fp, "*InputSlot %s/%s: \"<</MediaPosition %d>>setpagedevice\"\n", ppdname, _cupsLangString(lang, sources[j][1]), j);
cupsFilePrintf(fp, "*InputSlot %s: \"<</MediaPosition %d>>setpagedevice\"\n", ppdname, j);
cupsFilePrintf(fp, "*%s.InputSlot %s/%s: \"\"\n", lang->language, ppdname, _cupsLangString(lang, sources[j][1]));
break;
}
}
@@ -3570,9 +3630,14 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
break;
if (j < (int)(sizeof(media_types) / sizeof(media_types[0])))
cupsFilePrintf(fp, "*MediaType %s/%s: \"<</MediaType(%s)>>setpagedevice\"\n", ppdname, _cupsLangString(lang, media_types[j][1]), ppdname);
{
cupsFilePrintf(fp, "*MediaType %s: \"<</MediaType(%s)>>setpagedevice\"\n", ppdname, ppdname);
cupsFilePrintf(fp, "*%s.MediaType %s/%s: \"\"\n", lang->language, ppdname, _cupsLangString(lang, media_types[j][1]));
}
else
{
cupsFilePrintf(fp, "*MediaType %s/%s: \"<</MediaType(%s)>>setpagedevice\"\n", ppdname, keyword, ppdname);
}
}
cupsFilePuts(fp, "*CloseUI: *MediaType\n");
}
@@ -3581,8 +3646,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
* ColorModel...
*/
if ((attr = ippFindAttribute(response, "pwg-raster-document-type-supported", IPP_TAG_KEYWORD)) == NULL)
if ((attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) == NULL)
if ((attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) == NULL)
if ((attr = ippFindAttribute(response, "pwg-raster-document-type-supported", IPP_TAG_KEYWORD)) == NULL)
if ((attr = ippFindAttribute(response, "print-color-mode-supported", IPP_TAG_KEYWORD)) == NULL)
attr = ippFindAttribute(response, "output-mode-supported", IPP_TAG_KEYWORD);
@@ -3598,10 +3663,11 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if (!strcasecmp(keyword, "black_1") || !strcmp(keyword, "bi-level") || !strcmp(keyword, "process-bi-level"))
{
if (!default_color)
cupsFilePrintf(fp, "*OpenUI *ColorModel/%s: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n", _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*OpenUI *ColorModel: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n"
"*%s.Translation ColorModel/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*ColorModel FastGray/%s: \"<</cupsColorSpace 3/cupsBitsPerColor 1/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n", _cupsLangString(lang, _("Fast Grayscale")));
cupsFilePrintf(fp, "*ColorModel FastGray: \"<</cupsColorSpace 3/cupsBitsPerColor 1/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n*%s.ColorModel FastGray/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Fast Grayscale")));
if (!default_color)
default_color = "FastGray";
@@ -3609,10 +3675,11 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
else if (!strcasecmp(keyword, "sgray_8") || !strcmp(keyword, "W8") || !strcmp(keyword, "monochrome") || !strcmp(keyword, "process-monochrome"))
{
if (!default_color)
cupsFilePrintf(fp, "*OpenUI *ColorModel/%s: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n", _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*OpenUI *ColorModel: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n"
"*%s.Translation ColorModel/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*ColorModel Gray/%s: \"<</cupsColorSpace 18/cupsBitsPerColor 8/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n", _cupsLangString(lang, _("Grayscale")));
cupsFilePrintf(fp, "*ColorModel Gray: \"<</cupsColorSpace 18/cupsBitsPerColor 8/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n*%s.ColorModel Gray/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Grayscale")));
if (!default_color || !strcmp(default_color, "FastGray"))
default_color = "Gray";
@@ -3620,20 +3687,22 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
else if (!strcasecmp(keyword, "srgb_8") || !strcmp(keyword, "SRGB24") || !strcmp(keyword, "color"))
{
if (!default_color)
cupsFilePrintf(fp, "*OpenUI *ColorModel/%s: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n", _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*OpenUI *ColorModel: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n"
"*%s.Translation ColorModel/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*ColorModel RGB/%s: \"<</cupsColorSpace 19/cupsBitsPerColor 8/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n", _cupsLangString(lang, _("Color")));
cupsFilePrintf(fp, "*ColorModel RGB: \"<</cupsColorSpace 19/cupsBitsPerColor 8/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n*%s.ColorModel RGB/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Color")));
default_color = "RGB";
}
else if (!strcasecmp(keyword, "adobe-rgb_16") || !strcmp(keyword, "ADOBERGB48"))
{
if (!default_color)
cupsFilePrintf(fp, "*OpenUI *ColorModel/%s: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n", _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*OpenUI *ColorModel: PickOne\n"
"*OrderDependency: 10 AnySetup *ColorModel\n"
"*%s.Translation ColorModel/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Color Mode")));
cupsFilePrintf(fp, "*ColorModel AdobeRGB/%s: \"<</cupsColorSpace 20/cupsBitsPerColor 16/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n", _cupsLangString(lang, _("Deep Color")));
cupsFilePrintf(fp, "*ColorModel AdobeRGB: \"<</cupsColorSpace 20/cupsBitsPerColor 16/cupsColorOrder 0/cupsCompression 0>>setpagedevice\"\n*%s.ColorModel AdobeRGB/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Deep Color")));
if (!default_color)
default_color = "AdobeRGB";
@@ -3653,15 +3722,48 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if ((attr = ippFindAttribute(response, "sides-supported", IPP_TAG_KEYWORD)) != NULL && ippContainsString(attr, "two-sided-long-edge"))
{
cupsFilePrintf(fp, "*OpenUI *Duplex/%s: PickOne\n"
cupsFilePrintf(fp, "*OpenUI *Duplex: PickOne\n"
"*OrderDependency: 10 AnySetup *Duplex\n"
"*%s.Translation Duplex/%s: \"\"\n"
"*DefaultDuplex: None\n"
"*Duplex None/%s: \"<</Duplex false>>setpagedevice\"\n"
"*Duplex DuplexNoTumble/%s: \"<</Duplex true/Tumble false>>setpagedevice\"\n"
"*Duplex DuplexTumble/%s: \"<</Duplex true/Tumble true>>setpagedevice\"\n"
"*CloseUI: *Duplex\n", _cupsLangString(lang, _("2-Sided Printing")), _cupsLangString(lang, _("Off (1-Sided)")), _cupsLangString(lang, _("Long-Edge (Portrait)")), _cupsLangString(lang, _("Short-Edge (Landscape)")));
"*Duplex None: \"<</Duplex false>>setpagedevice\"\n"
"*%s.Duplex None/%s: \"\"\n"
"*Duplex DuplexNoTumble: \"<</Duplex true/Tumble false>>setpagedevice\"\n"
"*%s.Duplex DuplexNoTumble/%s: \"\"\n"
"*Duplex DuplexTumble: \"<</Duplex true/Tumble true>>setpagedevice\"\n"
"*%s.Duplex DuplexTumble/%s: \"\"\n"
"*CloseUI: *Duplex\n", lang->language, _cupsLangString(lang, _("2-Sided Printing")), lang->language, _cupsLangString(lang, _("Off (1-Sided)")), lang->language, _cupsLangString(lang, _("Long-Edge (Portrait)")), lang->language, _cupsLangString(lang, _("Short-Edge (Landscape)")));
if ((attr = ippFindAttribute(response, "pwg-raster-document-sheet-back", IPP_TAG_KEYWORD)) != NULL)
if ((attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) != NULL)
{
for (i = 0, count = ippGetCount(attr); i < count; i ++)
{
const char *dm = ippGetString(attr, i, NULL);
/* DM value */
if (!_cups_strcasecmp(dm, "DM1"))
{
cupsFilePuts(fp, "*cupsBackSide: Normal\n");
break;
}
else if (!_cups_strcasecmp(dm, "DM2"))
{
cupsFilePuts(fp, "*cupsBackSide: Flipped\n");
break;
}
else if (!_cups_strcasecmp(dm, "DM3"))
{
cupsFilePuts(fp, "*cupsBackSide: Rotated\n");
break;
}
else if (!_cups_strcasecmp(dm, "DM4"))
{
cupsFilePuts(fp, "*cupsBackSide: ManualTumble\n");
break;
}
}
}
else if ((attr = ippFindAttribute(response, "pwg-raster-document-sheet-back", IPP_TAG_KEYWORD)) != NULL)
{
const char *keyword = ippGetString(attr, 0, NULL);
/* Keyword value */
@@ -3675,35 +3777,6 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
else
cupsFilePuts(fp, "*cupsBackSide: Rotated\n");
}
else if ((attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) != NULL)
{
for (i = 0, count = ippGetCount(attr); i < count; i ++)
{
const char *dm = ippGetString(attr, i, NULL);
/* DM value */
if (!_cups_strcasecmp(dm, "DM1"))
{
cupsFilePuts(fp, "*cupsBackSide: Normal\n");
break;
}
else if (!_cups_strcasecmp(dm, "DM2"))
{
cupsFilePuts(fp, "*cupsBackSide: Flipped\n");
break;
}
else if (!_cups_strcasecmp(dm, "DM3"))
{
cupsFilePuts(fp, "*cupsBackSide: Rotated\n");
break;
}
else if (!_cups_strcasecmp(dm, "DM4"))
{
cupsFilePuts(fp, "*cupsBackSide: ManualTumble\n");
break;
}
}
}
}
/*
@@ -3717,6 +3790,12 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if ((attr = ippFindAttribute(response, "output-bin-supported", IPP_TAG_ZERO)) != NULL && (count = ippGetCount(attr)) > 1)
{
ipp_attribute_t *trays = ippFindAttribute(response, "printer-output-tray", IPP_TAG_STRING);
/* printer-output-tray attribute, if any */
const char *tray_ptr; /* printer-output-tray value */
int tray_len; /* Len of printer-output-tray value */
char tray[IPP_MAX_OCTETSTRING];
/* printer-output-tray string value */
static const char * const output_bins[][2] =
{ /* "output-bin" strings */
{ "auto", _("Automatic") },
@@ -3767,6 +3846,11 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
cupsFilePrintf(fp, "*OpenUI *OutputBin: PickOne\n"
"*OrderDependency: 10 AnySetup *OutputBin\n"
"*DefaultOutputBin: %s\n", ppdname);
if (!strcmp(ppdname, "FaceUp"))
cupsFilePuts(fp, "*DefaultOutputOrder: Reverse\n");
else
cupsFilePuts(fp, "*DefaultOutputOrder: Normal\n");
for (i = 0; i < (int)(sizeof(output_bins) / sizeof(output_bins[0])); i ++)
{
if (!ippContainsString(attr, output_bins[i][0]))
@@ -3774,7 +3858,26 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
pwg_ppdize_name(output_bins[i][0], ppdname, sizeof(ppdname));
cupsFilePrintf(fp, "*OutputBin %s/%s: \"\"\n", ppdname, _cupsLangString(lang, output_bins[i][1]));
cupsFilePrintf(fp, "*OutputBin %s: \"\"\n", ppdname);
cupsFilePrintf(fp, "*%s.OutputBin %s/%s: \"\"\n", lang->language, ppdname, _cupsLangString(lang, output_bins[i][1]));
if ((tray_ptr = ippGetOctetString(trays, i, &tray_len)) != NULL)
{
if (tray_len >= (int)sizeof(tray))
tray_len = (int)sizeof(tray) - 1;
memcpy(tray, tray_ptr, (size_t)tray_len);
tray[tray_len] = '\0';
if (strstr(tray, "stackingorder=lastToFirst;"))
cupsFilePrintf(fp, "*PageStackOrder %s: Reverse\n", ppdname);
else
cupsFilePrintf(fp, "*PageStackOrder %s: Normal\n", ppdname);
}
else if (!strcmp(ppdname, "FaceUp"))
cupsFilePrintf(fp, "*PageStackOrder %s: Reverse\n", ppdname);
else
cupsFilePrintf(fp, "*PageStackOrder %s: Normal\n", ppdname);
}
cupsFilePuts(fp, "*CloseUI: *OutputBin\n");
}
@@ -3812,10 +3915,12 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if (i < count)
{
cupsFilePrintf(fp, "*OpenUI *StapleLocation/%s: PickOne\n", _cupsLangString(lang, _("Staple")));
cupsFilePuts(fp, "*OpenUI *StapleLocation: PickOne\n");
cupsFilePuts(fp, "*OrderDependency: 10 AnySetup *StapleLocation\n");
cupsFilePrintf(fp, "*%s.Translation StapleLocation/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Staple")));
cupsFilePuts(fp, "*DefaultStapleLocation: None\n");
cupsFilePrintf(fp, "*StapleLocation None/%s: \"\"\n", _cupsLangString(lang, _("None")));
cupsFilePuts(fp, "*StapleLocation None: \"\"\n");
cupsFilePrintf(fp, "*%s.StapleLocation None/%s: \"\"\n", lang->language, _cupsLangString(lang, _("None")));
for (; i < count; i ++)
{
@@ -3834,7 +3939,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
{
if (!strcmp(finishings[j][0], name))
{
cupsFilePrintf(fp, "*StapleLocation %s/%s: \"\"\n", name, _cupsLangString(lang, finishings[j][1]));
cupsFilePrintf(fp, "*StapleLocation %s: \"\"\n", name);
cupsFilePrintf(fp, "*%s.StapleLocation %s/%s: \"\"\n", lang->language, name, _cupsLangString(lang, finishings[j][1]));
cupsFilePrintf(fp, "*cupsIPPFinishings %d/%s: \"*StapleLocation %s\"\n", value, name, name);
break;
}
@@ -3859,10 +3965,12 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if (i < count)
{
cupsFilePrintf(fp, "*OpenUI *FoldType/%s: PickOne\n", _cupsLangString(lang, _("Fold")));
cupsFilePuts(fp, "*OpenUI *FoldType: PickOne\n");
cupsFilePuts(fp, "*OrderDependency: 10 AnySetup *FoldType\n");
cupsFilePrintf(fp, "*%s.Translation FoldType/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Fold")));
cupsFilePuts(fp, "*DefaultFoldType: None\n");
cupsFilePrintf(fp, "*FoldType None/%s: \"\"\n", _cupsLangString(lang, _("None")));
cupsFilePuts(fp, "*FoldType None: \"\"\n");
cupsFilePrintf(fp, "*%s.FoldType None/%s: \"\"\n", lang->language, _cupsLangString(lang, _("None")));
for (; i < count; i ++)
{
@@ -3881,7 +3989,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
{
if (!strcmp(finishings[j][0], name))
{
cupsFilePrintf(fp, "*FoldType %s/%s: \"\"\n", name, _cupsLangString(lang, finishings[j][1]));
cupsFilePrintf(fp, "*FoldType %s: \"\"\n", name);
cupsFilePrintf(fp, "*%s.FoldType %s/%s: \"\"\n", lang->language, name, _cupsLangString(lang, finishings[j][1]));
cupsFilePrintf(fp, "*cupsIPPFinishings %d/%s: \"*FoldType %s\"\n", value, name, name);
break;
}
@@ -3906,10 +4015,12 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if (i < count)
{
cupsFilePrintf(fp, "*OpenUI *PunchMedia/%s: PickOne\n", _cupsLangString(lang, _("Punch")));
cupsFilePuts(fp, "*OpenUI *PunchMedia: PickOne\n");
cupsFilePuts(fp, "*OrderDependency: 10 AnySetup *PunchMedia\n");
cupsFilePrintf(fp, "*%s.Translation PunchMedia/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Punch")));
cupsFilePuts(fp, "*DefaultPunchMedia: None\n");
cupsFilePrintf(fp, "*PunchMedia None/%s: \"\"\n", _cupsLangString(lang, _("None")));
cupsFilePuts(fp, "*PunchMedia None: \"\"\n");
cupsFilePrintf(fp, "*%s.PunchMedia None/%s: \"\"\n", lang->language, _cupsLangString(lang, _("None")));
for (i = 0; i < count; i ++)
{
@@ -3928,7 +4039,8 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
{
if (!strcmp(finishings[j][0], name))
{
cupsFilePrintf(fp, "*PunchMedia %s/%s: \"\"\n", name, _cupsLangString(lang, finishings[j][1]));
cupsFilePrintf(fp, "*PunchMedia %s: \"\"\n", name);
cupsFilePrintf(fp, "*%s.PunchMedia %s/%s: \"\"\n", lang->language, name, _cupsLangString(lang, finishings[j][1]));
cupsFilePrintf(fp, "*cupsIPPFinishings %d/%s: \"*PunchMedia %s\"\n", value, name, name);
break;
}
@@ -3944,8 +4056,9 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
if (ippContainsInteger(attr, IPP_FINISHINGS_BOOKLET_MAKER))
{
cupsFilePrintf(fp, "*OpenUI *Booklet/%s: Boolean\n", _cupsLangString(lang, _("Booklet")));
cupsFilePuts(fp, "*OpenUI *Booklet: Boolean\n");
cupsFilePuts(fp, "*OrderDependency: 10 AnySetup *Booklet\n");
cupsFilePrintf(fp, "*%s.Translation Booklet/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Booklet")));
cupsFilePuts(fp, "*DefaultBooklet: False\n");
cupsFilePuts(fp, "*Booklet False: \"\"\n");
cupsFilePuts(fp, "*Booklet True: \"\"\n");
@@ -3962,42 +4075,14 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
quality = ippFindAttribute(response, "print-quality-supported", IPP_TAG_ENUM);
if ((attr = ippFindAttribute(response, "pwg-raster-document-resolution-supported", IPP_TAG_RESOLUTION)) != NULL)
if ((attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) != NULL)
{
count = ippGetCount(attr);
pwg_ppdize_resolution(attr, count / 2, &xres, &yres, ppdname, sizeof(ppdname));
cupsFilePrintf(fp, "*DefaultResolution: %s\n", ppdname);
cupsFilePrintf(fp, "*OpenUI *cupsPrintQuality/%s: PickOne\n"
"*OrderDependency: 10 AnySetup *cupsPrintQuality\n"
"*DefaultcupsPrintQuality: Normal\n", _cupsLangString(lang, _("Print Quality")));
if (count > 2 || ippContainsInteger(quality, IPP_QUALITY_DRAFT))
{
pwg_ppdize_resolution(attr, 0, &xres, &yres, NULL, 0);
cupsFilePrintf(fp, "*cupsPrintQuality Draft/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Draft")), xres, yres);
}
pwg_ppdize_resolution(attr, count / 2, &xres, &yres, NULL, 0);
cupsFilePrintf(fp, "*cupsPrintQuality Normal/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Normal")), xres, yres);
if (count > 1 || ippContainsInteger(quality, IPP_QUALITY_HIGH))
{
if (count > 1)
pwg_ppdize_resolution(attr, count - 1, &xres, &yres, NULL, 0);
else
pwg_ppdize_resolution(attr, 0, &xres, &yres, NULL, 0);
cupsFilePrintf(fp, "*cupsPrintQuality High/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("High")), xres, yres);
}
cupsFilePuts(fp, "*CloseUI: *cupsPrintQuality\n");
}
else if ((attr = ippFindAttribute(response, "urf-supported", IPP_TAG_KEYWORD)) != NULL)
{
int lowdpi = 0, hidpi = 0; /* Lower and higher resolution */
int lowdpi = 0, hidpi = 0; /* Lower and higher resolution */
for (i = 0, count = ippGetCount(attr); i < count; i ++)
{
const char *rs = ippGetString(attr, i, NULL);
/* RS value */
/* RS value */
if (_cups_strncasecmp(rs, "RS", 2))
continue;
@@ -4026,19 +4111,92 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
cupsFilePrintf(fp, "*DefaultResolution: %ddpi\n", lowdpi);
cupsFilePrintf(fp, "*OpenUI *cupsPrintQuality/%s: PickOne\n"
cupsFilePrintf(fp, "*OpenUI *cupsPrintQuality: PickOne\n"
"*OrderDependency: 10 AnySetup *cupsPrintQuality\n"
"*DefaultcupsPrintQuality: Normal\n", _cupsLangString(lang, _("Print Quality")));
"*%s.Translation cupsPrintQuality/%s: \"\"\n"
"*DefaultcupsPrintQuality: Normal\n", lang->language, _cupsLangString(lang, _("Print Quality")));
if ((lowdpi & 1) == 0)
cupsFilePrintf(fp, "*cupsPrintQuality Draft/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Draft")), lowdpi, lowdpi / 2);
cupsFilePrintf(fp, "*cupsPrintQuality Draft: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality Draft/%s: \"\"\n", lowdpi, lowdpi / 2, lang->language, _cupsLangString(lang, _("Draft")));
else if (ippContainsInteger(quality, IPP_QUALITY_DRAFT))
cupsFilePrintf(fp, "*cupsPrintQuality Draft/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Draft")), lowdpi, lowdpi);
cupsFilePrintf(fp, "*cupsPrintQuality Normal/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Normal")), lowdpi, lowdpi);
cupsFilePrintf(fp, "*cupsPrintQuality Draft: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality Draft/%s: \"\"\n", lowdpi, lowdpi, lang->language, _cupsLangString(lang, _("Draft")));
cupsFilePrintf(fp, "*cupsPrintQuality Normal: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality Normal/%s: \"\"\n", lowdpi, lowdpi, lang->language, _cupsLangString(lang, _("Normal")));
if (hidpi > lowdpi || ippContainsInteger(quality, IPP_QUALITY_HIGH))
cupsFilePrintf(fp, "*cupsPrintQuality High/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("High")), hidpi, hidpi);
cupsFilePrintf(fp, "*cupsPrintQuality High: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality High/%s: \"\"\n", hidpi, hidpi, lang->language, _cupsLangString(lang, _("High")));
cupsFilePuts(fp, "*CloseUI: *cupsPrintQuality\n");
}
}
else if ((attr = ippFindAttribute(response, "pwg-raster-document-resolution-supported", IPP_TAG_RESOLUTION)) != NULL)
{
/*
* Make a sorted list of resolutions.
*/
count = ippGetCount(attr);
if (count > (int)(sizeof(resolutions) / sizeof(resolutions[0])))
count = (int)(sizeof(resolutions) / sizeof(resolutions[0]));
resolutions[0] = 0; /* Not in loop to silence Clang static analyzer... */
for (i = 1; i < count; i ++)
resolutions[i] = i;
for (i = 0; i < (count - 1); i ++)
{
for (j = i + 1; j < count; j ++)
{
int ix, iy, /* First X and Y resolution */
jx, jy, /* Second X and Y resolution */
temp; /* Swap variable */
ipp_res_t units; /* Resolution units */
ix = ippGetResolution(attr, resolutions[i], &iy, &units);
jx = ippGetResolution(attr, resolutions[j], &jy, &units);
if (ix > jx || (ix == jx && iy > jy))
{
/*
* Swap these two resolutions...
*/
temp = resolutions[i];
resolutions[i] = resolutions[j];
resolutions[j] = temp;
}
}
}
/*
* Generate print quality options...
*/
pwg_ppdize_resolution(attr, resolutions[count / 2], &xres, &yres, ppdname, sizeof(ppdname));
cupsFilePrintf(fp, "*DefaultResolution: %s\n", ppdname);
cupsFilePrintf(fp, "*OpenUI *cupsPrintQuality: PickOne\n"
"*OrderDependency: 10 AnySetup *cupsPrintQuality\n"
"*%s.Translation cupsPrintQuality/%s: \"\"\n"
"*DefaultcupsPrintQuality: Normal\n", lang->language, _cupsLangString(lang, _("Print Quality")));
if (count > 2 || ippContainsInteger(quality, IPP_QUALITY_DRAFT))
{
pwg_ppdize_resolution(attr, resolutions[0], &xres, &yres, NULL, 0);
cupsFilePrintf(fp, "*cupsPrintQuality Draft: \"<</HWResolution[%d %d]>>setpagedevice\"\n", xres, yres);
cupsFilePrintf(fp, "*%s.cupsPrintQuality Draft/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Draft")));
}
pwg_ppdize_resolution(attr, resolutions[count / 2], &xres, &yres, NULL, 0);
cupsFilePrintf(fp, "*cupsPrintQuality Normal: \"<</HWResolution[%d %d]>>setpagedevice\"\n", xres, yres);
cupsFilePrintf(fp, "*%s.cupsPrintQuality Normal/%s: \"\"\n", lang->language, _cupsLangString(lang, _("Normal")));
if (count > 1 || ippContainsInteger(quality, IPP_QUALITY_HIGH))
{
pwg_ppdize_resolution(attr, resolutions[count - 1], &xres, &yres, NULL, 0);
cupsFilePrintf(fp, "*cupsPrintQuality High: \"<</HWResolution[%d %d]>>setpagedevice\"\n", xres, yres);
cupsFilePrintf(fp, "*%s.cupsPrintQuality High/%s: \"\"\n", lang->language, _cupsLangString(lang, _("High")));
}
cupsFilePuts(fp, "*CloseUI: *cupsPrintQuality\n");
}
else if (is_apple || is_pwg)
goto bad_ppd;
else
@@ -4055,14 +4213,17 @@ _ppdCreateFromIPP(char *buffer, /* I - Filename buffer */
cupsFilePrintf(fp, "*DefaultResolution: %s\n", ppdname);
cupsFilePrintf(fp, "*OpenUI *cupsPrintQuality/%s: PickOne\n"
cupsFilePrintf(fp, "*OpenUI *cupsPrintQuality: PickOne\n"
"*OrderDependency: 10 AnySetup *cupsPrintQuality\n"
"*DefaultcupsPrintQuality: Normal\n", _cupsLangString(lang, _("Print Quality")));
"*%s.Translation cupsPrintQuality/%s: \"\"\n"
"*DefaultcupsPrintQuality: Normal\n", lang->language, _cupsLangString(lang, _("Print Quality")));
if (ippContainsInteger(quality, IPP_QUALITY_DRAFT))
cupsFilePrintf(fp, "*cupsPrintQuality Draft/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Draft")), xres, yres);
cupsFilePrintf(fp, "*cupsPrintQuality Normal/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("Normal")), xres, yres);
cupsFilePrintf(fp, "*cupsPrintQuality Draft: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality Draft/%s: \"\"\n", xres, yres, lang->language, _cupsLangString(lang, _("Draft")));
cupsFilePrintf(fp, "*cupsPrintQuality Normal: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality Normal/%s: \"\"\n", xres, yres, lang->language, _cupsLangString(lang, _("Normal")));
if (ippContainsInteger(quality, IPP_QUALITY_HIGH))
cupsFilePrintf(fp, "*cupsPrintQuality High/%s: \"<</HWResolution[%d %d]>>setpagedevice\"\n", _cupsLangString(lang, _("High")), xres, yres);
cupsFilePrintf(fp, "*cupsPrintQuality High: \"<</HWResolution[%d %d]>>setpagedevice\"\n*%s.cupsPrintQuality High/%s: \"\"\n", xres, yres, lang->language, _cupsLangString(lang, _("High")));
cupsFilePuts(fp, "*CloseUI: *cupsPrintQuality\n");
}
+2 -3
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Option conflict management routines for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -29,7 +29,6 @@
enum
{
_PPD_NORMAL_CONSTRAINTS,
_PPD_OPTION_CONSTRAINTS,
_PPD_INSTALLABLE_CONSTRAINTS,
_PPD_ALL_CONSTRAINTS
@@ -998,7 +997,7 @@ ppd_test_constraints(
if (!consts->installable && which == _PPD_INSTALLABLE_CONSTRAINTS)
continue; /* Skip non-installable option constraint */
if (which == _PPD_OPTION_CONSTRAINTS && option)
if ((which == _PPD_OPTION_CONSTRAINTS || which == _PPD_INSTALLABLE_CONSTRAINTS) && option)
{
/*
* Skip constraints that do not involve the current option...
+4 -4
Ver Arquivo
@@ -21,11 +21,11 @@
#include "cups-private.h"
#include "ppd.h"
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
/*
@@ -328,11 +328,11 @@ ppdEmitFd(ppd_file_t *ppd, /* I - PPD file record */
while (buflength > 0)
{
#ifdef WIN32
#ifdef _WIN32
if ((bytes = (ssize_t)write(fd, bufptr, (unsigned)buflength)) < 0)
#else
if ((bytes = write(fd, bufptr, buflength)) < 0)
#endif /* WIN32 */
#endif /* _WIN32 */
{
if (errno == EAGAIN || errno == EINTR)
continue;
+2 -2
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* PPD localization routines for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -277,7 +277,7 @@ ppdLocalizeIPPReason(
if (!locattr)
{
if (lang && (!scheme || !strcmp(scheme, "text")))
if (lang && (!scheme || !strcmp(scheme, "text")) && strcmp(reason, "none"))
{
/*
* Try to localize a standard printer-state-reason keyword...
+15 -1
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Option marking routines for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2017 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -253,6 +253,7 @@ cupsMarkOptions(
*/
for (i = num_options, optptr = options; i > 0; i --, optptr ++)
{
if (!_cups_strcasecmp(optptr->name, "media") ||
!_cups_strcasecmp(optptr->name, "output-bin") ||
!_cups_strcasecmp(optptr->name, "output-mode") ||
@@ -341,6 +342,19 @@ cupsMarkOptions(
ppd_mark_option(ppd, "MirrorPrint", optptr->value);
else
ppd_mark_option(ppd, optptr->name, optptr->value);
}
if (print_quality)
{
int pq = atoi(print_quality); /* print-quaity value */
if (pq == IPP_QUALITY_DRAFT)
ppd_mark_option(ppd, "cupsPrintQuality", "Draft");
else if (pq == IPP_QUALITY_HIGH)
ppd_mark_option(ppd, "cupsPrintQuality", "High");
else
ppd_mark_option(ppd, "cupsPrintQuality", "Normal");
}
ppd_debug_marked(ppd, "After...");
+32 -103
Ver Arquivo
@@ -1,8 +1,8 @@
/*
* PPD utilities for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
* Copyright © 2007-2018 by Apple Inc.
* Copyright © 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -21,11 +21,11 @@
#include "ppd-private.h"
#include <fcntl.h>
#include <sys/stat.h>
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
/*
@@ -171,7 +171,7 @@ cupsGetPPD3(http_t *http, /* I - HTTP connection or @code CUPS_HTTP_DEFAUL
return (HTTP_STATUS_NOT_ACCEPTABLE);
}
#ifndef WIN32
#ifndef _WIN32
/*
* See if the PPD file is available locally...
*/
@@ -216,6 +216,27 @@ cupsGetPPD3(http_t *http, /* I - HTTP connection or @code CUPS_HTTP_DEFAUL
const char *tmpdir; /* TMPDIR environment variable */
struct timeval curtime; /* Current time */
#ifdef __APPLE__
/*
* On macOS and iOS, the TMPDIR environment variable is not always the
* best location to place temporary files due to sandboxing. Instead,
* the confstr function should be called to get the proper per-user,
* per-process TMPDIR value.
*/
char tmppath[1024]; /* Temporary directory */
if ((tmpdir = getenv("TMPDIR")) != NULL && access(tmpdir, W_OK))
tmpdir = NULL;
if (!tmpdir)
{
if (confstr(_CS_DARWIN_USER_TEMP_DIR, tmppath, sizeof(tmppath)))
tmpdir = tmppath;
else
tmpdir = "/private/tmp"; /* This should never happen */
}
#else
/*
* Previously we put root temporary files in the default CUPS temporary
* directory under /var/spool/cups. However, since the scheduler cleans
@@ -224,11 +245,8 @@ cupsGetPPD3(http_t *http, /* I - HTTP connection or @code CUPS_HTTP_DEFAUL
*/
if ((tmpdir = getenv("TMPDIR")) == NULL)
# ifdef __APPLE__
tmpdir = "/private/tmp"; /* /tmp is a symlink to /private/tmp */
# else
tmpdir = "/tmp";
# endif /* __APPLE__ */
tmpdir = "/tmp";
#endif /* __APPLE__ */
/*
* Make the temporary name using the specified directory...
@@ -280,7 +298,7 @@ cupsGetPPD3(http_t *http, /* I - HTTP connection or @code CUPS_HTTP_DEFAUL
}
}
}
#endif /* !WIN32 */
#endif /* !_WIN32 */
/*
* Try finding a printer URI for this printer...
@@ -511,23 +529,16 @@ cups_get_printer_uri(
int depth) /* I - Depth of query */
{
int i; /* Looping var */
int http_port; /* Port number */
http_t *http2; /* Alternate HTTP connection */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* Current attribute */
char uri[HTTP_MAX_URI], /* printer-uri attribute */
scheme[HTTP_MAX_URI], /* Scheme name */
username[HTTP_MAX_URI], /* Username:password */
classname[255], /* Temporary class name */
http_hostname[HTTP_MAX_HOST];
/* Hostname associated with connection */
username[HTTP_MAX_URI]; /* Username:password */
static const char * const requested_attrs[] =
{ /* Requested attributes */
"device-uri",
"member-uris",
"printer-uri-supported",
"printer-type"
"printer-uri-supported"
};
@@ -549,15 +560,6 @@ cups_get_printer_uri(
DEBUG_printf(("5cups_get_printer_uri: printer-uri=\"%s\"", uri));
/*
* Get the hostname and port number we are connected to...
*/
httpGetHostname(http, http_hostname, sizeof(http_hostname));
http_port = httpAddrPort(http->hostaddr);
DEBUG_printf(("5cups_get_printer_uri: http_hostname=\"%s\"", http_hostname));
/*
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
@@ -582,31 +584,7 @@ cups_get_printer_uri(
if ((response = cupsDoRequest(http, request, resource)) != NULL)
{
const char *device_uri = NULL; /* device-uri value */
if ((attr = ippFindAttribute(response, "device-uri", IPP_TAG_URI)) != NULL)
{
device_uri = attr->values[0].string.text;
DEBUG_printf(("5cups_get_printer_uri: device-uri=\"%s\"", device_uri));
}
if (device_uri &&
(((!strncmp(device_uri, "ipp://", 6) || !strncmp(device_uri, "ipps://", 7)) &&
(strstr(device_uri, "/printers/") != NULL || strstr(device_uri, "/classes/") != NULL)) ||
((strstr(device_uri, "._ipp.") != NULL || strstr(device_uri, "._ipps.") != NULL) &&
!strcmp(device_uri + strlen(device_uri) - 5, "/cups"))))
{
/*
* Statically-configured shared printer.
*/
httpSeparateURI(HTTP_URI_CODING_ALL, _httpResolveURI(device_uri, uri, sizeof(uri), _HTTP_RESOLVE_DEFAULT, NULL, NULL), scheme, sizeof(scheme), username, sizeof(username), host, hostsize, port, resource, resourcesize);
ippDelete(response);
DEBUG_printf(("5cups_get_printer_uri: Resolved to host=\"%s\", port=%d, resource=\"%s\"", host, *port, resource));
return (1);
}
else if ((attr = ippFindAttribute(response, "member-uris", IPP_TAG_URI)) != NULL)
if ((attr = ippFindAttribute(response, "member-uris", IPP_TAG_URI)) != NULL)
{
/*
* Get the first actual printer name in the class...
@@ -631,55 +609,6 @@ cups_get_printer_uri(
return (1);
}
}
/*
* No printers in this class - try recursively looking for a printer,
* but not more than 3 levels deep...
*/
if (depth < 3)
{
for (i = 0; i < attr->num_values; i ++)
{
httpSeparateURI(HTTP_URI_CODING_ALL, attr->values[i].string.text,
scheme, sizeof(scheme), username, sizeof(username),
host, hostsize, port, resource, resourcesize);
if (!strncmp(resource, "/classes/", 9))
{
/*
* Found a class! Connect to the right server...
*/
if (!_cups_strcasecmp(http_hostname, host) && *port == http_port)
http2 = http;
else if ((http2 = httpConnect2(host, *port, NULL, AF_UNSPEC, cupsEncryption(), 1, 30000, NULL)) == NULL)
{
DEBUG_puts("8cups_get_printer_uri: Unable to connect to server");
continue;
}
/*
* Look up printers on that server...
*/
strlcpy(classname, resource + 9, sizeof(classname));
cups_get_printer_uri(http2, classname, host, hostsize, port,
resource, resourcesize, depth + 1);
/*
* Close the connection as needed...
*/
if (http2 != http)
httpClose(http2);
if (*host)
return (1);
}
}
}
}
else if ((attr = ippFindAttribute(response, "printer-uri-supported", IPP_TAG_URI)) != NULL)
{
+40 -7
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* PPD file routines for CUPS.
*
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
@@ -94,9 +94,9 @@ static ppd_group_t *ppd_get_group(ppd_file_t *ppd, const char *name,
cups_encoding_t encoding);
static ppd_option_t *ppd_get_option(ppd_group_t *group, const char *name);
static _ppd_globals_t *ppd_globals_alloc(void);
#if defined(HAVE_PTHREAD_H) || defined(WIN32)
#if defined(HAVE_PTHREAD_H) || defined(_WIN32)
static void ppd_globals_free(_ppd_globals_t *g);
#endif /* HAVE_PTHREAD_H || WIN32 */
#endif /* HAVE_PTHREAD_H || _WIN32 */
#ifdef HAVE_PTHREAD_H
static void ppd_globals_init(void);
#endif /* HAVE_PTHREAD_H */
@@ -333,7 +333,9 @@ ppdErrorString(ppd_status_t status) /* I - PPD status */
_("Bad custom parameter"),
_("Missing option keyword"),
_("Bad value string"),
_("Missing CloseGroup")
_("Missing CloseGroup"),
_("Bad CloseUI/JCLCloseUI"),
_("Missing CloseUI/JCLCloseUI")
};
@@ -1542,8 +1544,29 @@ _ppdOpen(
choice->code = _cupsStrRetain(custom_attr->value);
}
}
else if (!strcmp(keyword, "CloseUI") || !strcmp(keyword, "JCLCloseUI"))
else if (!strcmp(keyword, "CloseUI"))
{
if ((!option || option->section == PPD_ORDER_JCL) && pg->ppd_conform == PPD_CONFORM_STRICT)
{
pg->ppd_status = PPD_BAD_CLOSE_UI;
goto error;
}
option = NULL;
_cupsStrFree(string);
string = NULL;
}
else if (!strcmp(keyword, "JCLCloseUI"))
{
if ((!option || option->section != PPD_ORDER_JCL) && pg->ppd_conform == PPD_CONFORM_STRICT)
{
pg->ppd_status = PPD_BAD_CLOSE_UI;
goto error;
}
option = NULL;
_cupsStrFree(string);
@@ -2006,6 +2029,16 @@ _ppdOpen(
_cupsStrFree(string);
}
/*
* Check for a missing CloseUI/JCLCloseUI...
*/
if (option && pg->ppd_conform == PPD_CONFORM_STRICT)
{
pg->ppd_status = PPD_MISSING_CLOSE_UI;
goto error;
}
/*
* Check for a missing CloseGroup...
*/
@@ -2804,13 +2837,13 @@ ppd_globals_alloc(void)
* 'ppd_globals_free()' - Free global data.
*/
#if defined(HAVE_PTHREAD_H) || defined(WIN32)
#if defined(HAVE_PTHREAD_H) || defined(_WIN32)
static void
ppd_globals_free(_ppd_globals_t *pg) /* I - Pointer to global data */
{
free(pg);
}
#endif /* HAVE_PTHREAD_H || WIN32 */
#endif /* HAVE_PTHREAD_H || _WIN32 */
#ifdef HAVE_PTHREAD_H
+2
Ver Arquivo
@@ -132,6 +132,8 @@ typedef enum ppd_status_e /**** Status Codes @since CUPS 1.1.19/macOS 10.3@ ***
PPD_MISSING_OPTION_KEYWORD, /* Missing option keyword */
PPD_BAD_VALUE, /* Bad value string */
PPD_MISSING_CLOSE_GROUP, /* Missing CloseGroup */
PPD_BAD_CLOSE_UI, /* Bad CloseUI/JCLCloseUI */
PPD_MISSING_CLOSE_UI, /* Missing CloseUI/JCLCloseUI */
PPD_MAX_STATUS /* @private@ */
} ppd_status_t;
+1
Ver Arquivo
@@ -189,6 +189,7 @@ static pwg_media_t const cups_pwg_media[] =
_PWG_MEDIA_MM("jis_b1_728x1030mm", "jis-b1", "B1", 728, 1030),
_PWG_MEDIA_MM("jis_b0_1030x1456mm", "jis-b0", "B0", 1030, 1456),
_PWG_MEDIA_MM("jis_exec_216x330mm", NULL, "216x330mm", 216, 330),
_PWG_MEDIA_MM("jpn_kaku1_270x382mm", NULL, "EnvKaku1", 270, 382),
_PWG_MEDIA_MM("jpn_kaku2_240x332mm", NULL, "EnvKaku2", 240, 332),
_PWG_MEDIA_MM("jpn_kaku3_216x277mm", NULL, "EnvKaku3", 216, 277),
_PWG_MEDIA_MM("jpn_kaku4_197x267mm", NULL, "EnvKaku4", 197, 267),
+5 -9
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Private image library definitions for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1993-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -24,13 +24,13 @@
# include <cups/cups.h>
# include <cups/debug-private.h>
# include <cups/string-private.h>
# ifdef WIN32
# ifdef _WIN32
# include <io.h>
# include <winsock2.h> /* for htonl() definition */
# else
# include <unistd.h>
# include <fcntl.h>
# endif /* WIN32 */
# endif /* _WIN32 */
/*
@@ -49,12 +49,8 @@
* Prototypes...
*/
extern int _cupsRasterExecPS(cups_page_header2_t *h,
int *preferred_bits,
const char *code)
__attribute__((nonnull(3)));
extern void _cupsRasterAddError(const char *f, ...)
__attribute__((__format__(__printf__, 1, 2)));
extern int _cupsRasterExecPS(cups_page_header2_t *h, int *preferred_bits, const char *code) _CUPS_NONNULL((3));
extern void _cupsRasterAddError(const char *f, ...) _CUPS_FORMAT(1,2);
extern void _cupsRasterClearError(void);
#endif /* !_CUPS_RASTER_PRIVATE_H_ */
+41 -29
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* IPP utilities for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 2007-2017 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -20,11 +20,11 @@
#include "cups-private.h"
#include <fcntl.h>
#include <sys/stat.h>
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
#ifndef O_BINARY
# define O_BINARY 0
#endif /* O_BINARY */
@@ -131,13 +131,12 @@ cupsDoIORequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
* Get the default connection as needed...
*/
if (!http)
if ((http = _cupsConnect()) == NULL)
{
ippDelete(request);
if (!http && (http = _cupsConnect()) == NULL)
{
ippDelete(request);
return (NULL);
}
return (NULL);
}
/*
* See if we have a file to send...
@@ -151,43 +150,39 @@ cupsDoIORequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
* Can't get file information!
*/
_cupsSetError(errno == EBADF ? IPP_STATUS_ERROR_NOT_FOUND : IPP_STATUS_ERROR_NOT_AUTHORIZED,
NULL, 0);
_cupsSetError(errno == EBADF ? IPP_STATUS_ERROR_NOT_FOUND : IPP_STATUS_ERROR_NOT_AUTHORIZED, NULL, 0);
ippDelete(request);
return (NULL);
}
#ifdef WIN32
#ifdef _WIN32
if (fileinfo.st_mode & _S_IFDIR)
#else
if (S_ISDIR(fileinfo.st_mode))
#endif /* WIN32 */
#endif /* _WIN32 */
{
/*
* Can't send a directory...
*/
ippDelete(request);
_cupsSetError(IPP_STATUS_ERROR_NOT_POSSIBLE, strerror(EISDIR), 0);
ippDelete(request);
return (NULL);
}
#ifndef WIN32
#ifndef _WIN32
if (!S_ISREG(fileinfo.st_mode))
length = 0; /* Chunk when piping */
else
#endif /* !WIN32 */
#endif /* !_WIN32 */
length = ippLength(request) + (size_t)fileinfo.st_size;
}
else
length = ippLength(request);
DEBUG_printf(("2cupsDoIORequest: Request length=%ld, total length=%ld",
(long)ippLength(request), (long)length));
DEBUG_printf(("2cupsDoIORequest: Request length=%ld, total length=%ld", (long)ippLength(request), (long)length));
/*
* Clear any "Local" authentication data since it is probably stale...
@@ -220,9 +215,9 @@ cupsDoIORequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
* Send the file with the request...
*/
#ifndef WIN32
#ifndef _WIN32
if (S_ISREG(fileinfo.st_mode))
#endif /* WIN32 */
#endif /* _WIN32 */
lseek(infile, 0, SEEK_SET);
while ((bytes = read(infile, buffer, sizeof(buffer))) > 0)
@@ -596,6 +591,8 @@ cupsSendRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
int got_status; /* Did we get the status? */
ipp_state_t state; /* State of IPP processing */
http_status_t expect; /* Expect: header to use */
char date[256]; /* Date: header value */
int digest; /* Are we using Digest authentication? */
DEBUG_printf(("cupsSendRequest(http=%p, request=%p(%s), resource=\"%s\", length=" CUPS_LLFMT ")", (void *)http, (void *)request, request ? ippOpString(request->request.op.operation_id) : "?", resource, CUPS_LLCAST length));
@@ -615,9 +612,8 @@ cupsSendRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
* Get the default connection as needed...
*/
if (!http)
if ((http = _cupsConnect()) == NULL)
return (HTTP_STATUS_SERVICE_UNAVAILABLE);
if (!http && (http = _cupsConnect()) == NULL)
return (HTTP_STATUS_SERVICE_UNAVAILABLE);
/*
* If the prior request was not flushed out, do so now...
@@ -685,8 +681,20 @@ cupsSendRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
httpClearFields(http);
httpSetExpect(http, expect);
httpSetField(http, HTTP_FIELD_CONTENT_TYPE, "application/ipp");
httpSetField(http, HTTP_FIELD_DATE, httpGetDateString2(time(NULL), date, (int)sizeof(date)));
httpSetLength(http, length);
digest = http->authstring && !strncmp(http->authstring, "Digest ", 7);
if (digest)
{
/*
* Update the Digest authentication string...
*/
_httpSetDigestAuthString(http, http->nextnonce, "POST", resource);
}
#ifdef HAVE_GSSAPI
if (http->authstring && !strncmp(http->authstring, "Negotiate", 9))
{
@@ -771,9 +779,9 @@ cupsSendRequest(http_t *http, /* I - Connection to server or @code CUPS_HTTP
* Wait up to 1 second to get the 100-continue response as needed...
*/
if (!got_status)
if (!got_status || (digest && status == HTTP_STATUS_CONTINUE))
{
if (expect == HTTP_STATUS_CONTINUE)
if (expect == HTTP_STATUS_CONTINUE || digest)
{
DEBUG_puts("2cupsSendRequest: Waiting for 100-continue...");
@@ -996,7 +1004,11 @@ _cupsConnect(void)
*/
if (strcmp(cg->http->hostname, cg->server) ||
#ifdef AF_LOCAL
(httpAddrFamily(cg->http->hostaddr) != AF_LOCAL && cg->ipp_port != httpAddrPort(cg->http->hostaddr)) ||
#else
cg->ipp_port != httpAddrPort(cg->http->hostaddr) ||
#endif /* AF_LOCAL */
(cg->http->encryption != cg->encryption &&
cg->http->encryption == HTTP_ENCRYPTION_NEVER))
{
@@ -1016,13 +1028,13 @@ _cupsConnect(void)
char ch; /* Connection check byte */
ssize_t n; /* Number of bytes */
#ifdef WIN32
#ifdef _WIN32
if ((n = recv(cg->http->fd, &ch, 1, MSG_PEEK)) == 0 ||
(n < 0 && WSAGetLastError() != WSAEWOULDBLOCK))
#else
if ((n = recv(cg->http->fd, &ch, 1, MSG_PEEK | MSG_DONTWAIT)) == 0 ||
(n < 0 && errno != EWOULDBLOCK))
#endif /* WIN32 */
#endif /* _WIN32 */
{
/*
* Nope, close the connection...
+4 -4
Ver Arquivo
@@ -19,15 +19,15 @@
#include "sidechannel.h"
#include "cups-private.h"
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 */
#ifndef WIN32
#endif /* _WIN32 */
#ifndef _WIN32
# include <sys/select.h>
# include <sys/time.h>
#endif /* !WIN32 */
#endif /* !_WIN32 */
#ifdef HAVE_POLL
# include <poll.h>
#endif /* HAVE_POLL */
+2 -2
Ver Arquivo
@@ -395,11 +395,11 @@ _cupsSNMPRead(int fd, /* I - SNMP socket file descriptor */
ready = select(fd + 1, &input_set, NULL, NULL, &stimeout);
}
# ifdef WIN32
# ifdef _WIN32
while (ready < 0 && WSAGetLastError() == WSAEINTR);
# else
while (ready < 0 && (errno == EINTR || errno == EAGAIN));
# endif /* WIN32 */
# endif /* _WIN32 */
#endif /* HAVE_POLL */
/*
+4 -5
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* Private string definitions for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -42,12 +42,12 @@
# include <bstring.h>
# endif /* HAVE_BSTRING_H */
# if defined(WIN32) && !defined(__CUPS_SSIZE_T_DEFINED)
# if defined(_WIN32) && !defined(__CUPS_SSIZE_T_DEFINED)
# define __CUPS_SSIZE_T_DEFINED
# include <stddef.h>
/* Windows does not support the ssize_t type, so map it to long... */
typedef long ssize_t; /* @private@ */
# endif /* WIN32 && !__CUPS_SSIZE_T_DEFINED */
# endif /* _WIN32 && !__CUPS_SSIZE_T_DEFINED */
/*
@@ -175,8 +175,7 @@ extern size_t _cups_strlcpy(char *, const char *, size_t);
# endif /* !HAVE_STRLCPY */
# ifndef HAVE_SNPRINTF
extern int _cups_snprintf(char *, size_t, const char *, ...)
__attribute__ ((__format__ (__printf__, 3, 4)));
extern int _cups_snprintf(char *, size_t, const char *, ...) _CUPS_FORMAT(3, 4);
# define snprintf _cups_snprintf
# endif /* !HAVE_SNPRINTF */
+35 -17
Ver Arquivo
@@ -1,8 +1,8 @@
/*
* Temp file utilities for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
* Copyright © 2007-2018 by Apple Inc.
* Copyright © 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -21,11 +21,11 @@
#include <stdlib.h>
#include <fcntl.h>
#include <sys/stat.h>
#if defined(WIN32) || defined(__EMX__)
#if defined(_WIN32) || defined(__EMX__)
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 || __EMX__ */
#endif /* _WIN32 || __EMX__ */
/*
@@ -42,24 +42,46 @@ cupsTempFd(char *filename, /* I - Pointer to buffer */
int fd; /* File descriptor for temp file */
int tries; /* Number of tries */
const char *tmpdir; /* TMPDIR environment var */
#ifdef WIN32
char tmppath[1024]; /* Windows temporary directory */
#if defined(__APPLE__) || defined(_WIN32)
char tmppath[1024]; /* Temporary directory */
#endif /* __APPLE__ || _WIN32 */
#ifdef _WIN32
DWORD curtime; /* Current time */
#else
struct timeval curtime; /* Current time */
#endif /* WIN32 */
#endif /* _WIN32 */
/*
* See if TMPDIR is defined...
*/
#ifdef WIN32
#ifdef _WIN32
if ((tmpdir = getenv("TEMP")) == NULL)
{
GetTempPath(sizeof(tmppath), tmppath);
tmpdir = tmppath;
}
#elif defined(__APPLE__)
/*
* On macOS and iOS, the TMPDIR environment variable is not always the best
* location to place temporary files due to sandboxing. Instead, the confstr
* function should be called to get the proper per-user, per-process TMPDIR
* value.
*/
if ((tmpdir = getenv("TMPDIR")) != NULL && access(tmpdir, W_OK))
tmpdir = NULL;
if (!tmpdir)
{
if (confstr(_CS_DARWIN_USER_TEMP_DIR, tmppath, sizeof(tmppath)))
tmpdir = tmppath;
else
tmpdir = "/private/tmp"; /* This should never happen */
}
#else
/*
* Previously we put root temporary files in the default CUPS temporary
@@ -69,12 +91,8 @@ cupsTempFd(char *filename, /* I - Pointer to buffer */
*/
if ((tmpdir = getenv("TMPDIR")) == NULL)
# if defined(__APPLE__) && !TARGET_OS_IOS
tmpdir = "/private/tmp"; /* /tmp is a symlink to /private/tmp */
# else
tmpdir = "/tmp";
# endif /* __APPLE__ && !TARGET_OS_IOS */
#endif /* WIN32 */
#endif /* _WIN32 */
/*
* Make the temporary name using the specified directory...
@@ -84,7 +102,7 @@ cupsTempFd(char *filename, /* I - Pointer to buffer */
do
{
#ifdef WIN32
#ifdef _WIN32
/*
* Get the current time of day...
*/
@@ -108,21 +126,21 @@ cupsTempFd(char *filename, /* I - Pointer to buffer */
*/
snprintf(filename, (size_t)len - 1, "%s/%05x%08x", tmpdir, (unsigned)getpid(), (unsigned)(curtime.tv_sec + curtime.tv_usec + tries));
#endif /* WIN32 */
#endif /* _WIN32 */
/*
* Open the file in "exclusive" mode, making sure that we don't
* stomp on an existing file or someone's symlink crack...
*/
#ifdef WIN32
#ifdef _WIN32
fd = open(filename, _O_CREAT | _O_RDWR | _O_TRUNC | _O_BINARY,
_S_IREAD | _S_IWRITE);
#elif defined(O_NOFOLLOW)
fd = open(filename, O_RDWR | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
#else
fd = open(filename, O_RDWR | O_CREAT | O_EXCL, 0600);
#endif /* WIN32 */
#endif /* _WIN32 */
if (fd < 0 && errno != EEXIST)
break;
+2 -2
Ver Arquivo
@@ -494,7 +494,7 @@ main(void)
* 'get_seconds()' - Get the current time in seconds...
*/
#ifdef WIN32
#ifdef _WIN32
# include <windows.h>
@@ -515,7 +515,7 @@ get_seconds(void)
gettimeofday(&curtime, NULL);
return (curtime.tv_sec + 0.000001 * curtime.tv_usec);
}
#endif /* WIN32 */
#endif /* _WIN32 */
/*
+31 -16
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* CUPS API test program for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 2007-2017 by Apple Inc.
* Copyright 2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -47,7 +47,9 @@ main(int argc, /* I - Number of command-line arguments */
cups_dest_t *dests, /* Destinations */
*dest, /* Current destination */
*named_dest; /* Current named destination */
const char *ppdfile; /* PPD file */
const char *dest_name, /* Destination name */
*dval, /* Destination value */
*ppdfile; /* PPD file */
ppd_file_t *ppd; /* PPD file data */
int num_jobs; /* Number of jobs for queue */
cups_job_t *jobs; /* Jobs for queue */
@@ -360,11 +362,19 @@ main(int argc, /* I - Number of command-line arguments */
* cupsGetDest(printer)
*/
printf("cupsGetDest(\"%s\"): ", dests[num_dests / 2].name);
for (i = 0, dest_name = NULL; i < num_dests; i ++)
{
if ((dval = cupsGetOption("printer-is-temporary", dests[i].num_options, dest[i].options)) != NULL && !strcmp(dval, "false"))
{
dest_name = dests[i].name;
break;
}
}
printf("cupsGetDest(\"%s\"): ", dest_name ? dest_name : "(null)");
fflush(stdout);
if ((dest = cupsGetDest(dests[num_dests / 2].name, NULL, num_dests,
dests)) == NULL)
if ((dest = cupsGetDest(dest_name, NULL, num_dests, dests)) == NULL)
{
puts("FAIL");
return (1);
@@ -380,8 +390,7 @@ main(int argc, /* I - Number of command-line arguments */
dest->instance ? dest->instance : "(null)");
fflush(stdout);
if ((named_dest = cupsGetNamedDest(NULL, dest->name,
dest->instance)) == NULL ||
if ((named_dest = cupsGetNamedDest(NULL, dest->name, dest->instance)) == NULL ||
!dests_equal(dest, named_dest))
{
if (named_dest)
@@ -408,7 +417,7 @@ main(int argc, /* I - Number of command-line arguments */
fputs("cupsPrintFile: ", stdout);
fflush(stdout);
if (cupsPrintFile(dest->name, "../data/testprint", "Test Page",
if (cupsPrintFile(dest->name, "../test/testfile.pdf", "Test Page",
dest->num_options, dest->options) <= 0)
{
printf("FAIL (%s)\n", cupsLastErrorString());
@@ -421,7 +430,7 @@ main(int argc, /* I - Number of command-line arguments */
* cupsGetPPD(printer)
*/
fputs("cupsGetPPD(): ", stdout);
fputs("cupsGetPPD: ", stdout);
fflush(stdout);
if ((ppdfile = cupsGetPPD(dest->name)) == NULL)
@@ -436,7 +445,7 @@ main(int argc, /* I - Number of command-line arguments */
* ppdOpenFile()
*/
fputs("ppdOpenFile(): ", stdout);
fputs("ppdOpenFile: ", stdout);
fflush(stdout);
if ((ppd = ppdOpenFile(ppdfile)) == NULL)
@@ -550,33 +559,39 @@ show_diffs(cups_dest_t *a, /* I - First destination */
{
int i; /* Looping var */
cups_option_t *aoption; /* Current option */
cups_option_t *boption; /* Current option */
const char *bval; /* Option value */
if (!a || !b)
return;
puts(" Item cupsGetDest cupsGetNamedDest");
puts(" -------------------- -------------------- --------------------");
puts(" Item cupsGetDest cupsGetNamedDest");
puts(" -------------------- ------------------------ ------------------------");
if (_cups_strcasecmp(a->name, b->name))
printf(" name %-20.20s %-20.20s\n", a->name, b->name);
printf(" name %-24.24s %-24.24s\n", a->name, b->name);
if ((a->instance && !b->instance) ||
(!a->instance && b->instance) ||
(a->instance && _cups_strcasecmp(a->instance, b->instance)))
printf(" instance %-20.20s %-20.20s\n",
printf(" instance %-24.24s %-24.24s\n",
a->instance ? a->instance : "(null)",
b->instance ? b->instance : "(null)");
if (a->num_options != b->num_options)
printf(" num_options %-20d %-20d\n", a->num_options,
printf(" num_options %-24d %-24d\n", a->num_options,
b->num_options);
for (i = a->num_options, aoption = a->options; i > 0; i --, aoption ++)
if ((bval = cupsGetOption(aoption->name, b->num_options,
b->options)) == NULL ||
strcmp(aoption->value, bval))
printf(" %-20.20s %-20.20s %-20.20s\n", aoption->name,
printf(" %-20.20s %-24.24s %-24.24s\n", aoption->name,
aoption->value, bval ? bval : "(null)");
for (i = b->num_options, boption = b->options; i > 0; i --, boption ++)
if (!cupsGetOption(boption->name, a->num_options, a->options))
printf(" %-20.20s %-24.24s %-24.24s\n", boption->name,
boption->value, "(null)");
}
+54 -9
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* CUPS destination API test program for CUPS.
*
* Copyright 2012-2016 by Apple Inc.
* Copyright 2012-2018 by Apple Inc.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -32,7 +32,7 @@ static void show_conflicts(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo,
static void show_default(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, const char *option);
static void show_media(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, unsigned flags, const char *name);
static void show_supported(http_t *http, cups_dest_t *dest, cups_dinfo_t *dinfo, const char *option, const char *value);
static void usage(const char *arg) __attribute__((noreturn));
static void usage(const char *arg) _CUPS_NORETURN;
/*
@@ -105,6 +105,14 @@ main(int argc, /* I - Number of command-line arguments */
}
else if (!strncmp(argv[1], "ipp://", 6) || !strncmp(argv[1], "ipps://", 7))
dest = cupsGetDestWithURI(NULL, argv[1]);
else if (!strcmp(argv[1], "default"))
{
dest = cupsGetNamedDest(CUPS_HTTP_DEFAULT, NULL, NULL);
if (dest && dest->instance)
printf("default is \"%s/%s\".\n", dest->name, dest->instance);
else
printf("default is \"%s\".\n", dest->name);
}
else
dest = cupsGetNamedDest(CUPS_HTTP_DEFAULT, argv[1], NULL);
@@ -463,10 +471,37 @@ show_default(http_t *http, /* I - Connection to destination */
cups_dinfo_t *dinfo, /* I - Destination information */
const char *option) /* I - Option */
{
(void)http;
(void)dest;
(void)dinfo;
(void)option;
if (!strcmp(option, "media"))
{
/*
* Show default media option...
*/
cups_size_t size; /* Media size information */
if (cupsGetDestMediaDefault(http, dest, dinfo, CUPS_MEDIA_FLAGS_DEFAULT, &size))
printf("%s (%.2fx%.2fmm, margins=[%.2f %.2f %.2f %.2f])\n", size.media, size.width * 0.01, size.length * 0.01, size.left * 0.01, size.bottom * 0.01, size.right * 0.01, size.top * 0.01);
else
puts("FAILED");
}
else
{
/*
* Show default other option...
*/
ipp_attribute_t *defattr; /* Default attribute */
if ((defattr = cupsFindDestDefault(http, dest, dinfo, option)) != NULL)
{
char value[1024]; /* Value of default attribute */
ippAttributeString(defattr, value, sizeof(value));
puts(value);
}
else
puts("FAILED");
}
}
@@ -594,7 +629,7 @@ show_supported(http_t *http, /* I - Connection to destination */
}
else if (!value)
{
printf("%s (%s)\n", option, cupsCheckDestSupported(http, dest, dinfo, option, NULL) ? "supported" : "not-supported");
printf("%s (%s - %s)\n", option, cupsLocalizeDestOption(http, dest, dinfo, option), cupsCheckDestSupported(http, dest, dinfo, option, NULL) ? "supported" : "not-supported");
if ((attr = cupsFindDestSupported(http, dest, dinfo, option)) != NULL)
{
@@ -609,7 +644,13 @@ show_supported(http_t *http, /* I - Connection to destination */
case IPP_TAG_ENUM :
for (i = 0; i < count; i ++)
printf(" %s\n", ippEnumString(option, ippGetInteger(attr, i)));
{
int val = ippGetInteger(attr, i);
char valstr[256];
snprintf(valstr, sizeof(valstr), "%d", val);
printf(" %s (%s)\n", ippEnumString(option, ippGetInteger(attr, i)), cupsLocalizeDestValue(http, dest, dinfo, option, valstr));
}
break;
case IPP_TAG_RANGE :
@@ -635,11 +676,15 @@ show_supported(http_t *http, /* I - Connection to destination */
}
break;
case IPP_TAG_KEYWORD :
for (i = 0; i < count; i ++)
printf(" %s (%s)\n", ippGetString(attr, i, NULL), cupsLocalizeDestValue(http, dest, dinfo, option, ippGetString(attr, i, NULL)));
break;
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_URI :
case IPP_TAG_URISCHEME :
case IPP_TAG_CHARSET :
+9 -12
Ver Arquivo
@@ -1,7 +1,7 @@
/*
* File test program for CUPS.
*
* Copyright 2007-2015 by Apple Inc.
* Copyright 2007-2018 by Apple Inc.
* Copyright 1997-2007 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
@@ -22,14 +22,11 @@
#include "file.h"
#include <stdlib.h>
#include <time.h>
#ifdef HAVE_LIBZ
# include <zlib.h>
#endif /* HAVE_LIBZ */
#ifdef WIN32
#ifdef _WIN32
# include <io.h>
#else
# include <unistd.h>
#endif /* WIN32 */
#endif /* _WIN32 */
#include <fcntl.h>
@@ -53,10 +50,10 @@ main(int argc, /* I - Number of command-line arguments */
int status; /* Exit status */
char filename[1024]; /* Filename buffer */
cups_file_t *fp; /* File pointer */
#ifndef WIN32
#ifndef _WIN32
int fds[2]; /* Open file descriptors */
cups_file_t *fdfile; /* File opened with cupsFileOpenFd() */
#endif /* !WIN32 */
#endif /* !_WIN32 */
int count; /* Number of lines in file */
@@ -84,7 +81,7 @@ main(int argc, /* I - Number of command-line arguments */
status += random_tests();
#ifndef WIN32
#ifndef _WIN32
/*
* Test fdopen and close without reading...
*/
@@ -118,7 +115,7 @@ main(int argc, /* I - Number of command-line arguments */
puts("PASS");
}
#endif /* !WIN32 */
#endif /* !_WIN32 */
/*
* Count lines in psglyphs, rewind, then count again.
@@ -174,13 +171,13 @@ main(int argc, /* I - Number of command-line arguments */
*/
fputs("\ncupsFileFind: ", stdout);
#ifdef WIN32
#ifdef _WIN32
if (cupsFileFind("notepad.exe", "C:/WINDOWS", 1, filename, sizeof(filename)) &&
cupsFileFind("notepad.exe", "C:/WINDOWS;C:/WINDOWS/SYSTEM32", 1, filename, sizeof(filename)))
#else
if (cupsFileFind("cat", "/bin", 1, filename, sizeof(filename)) &&
cupsFileFind("cat", "/bin:/usr/bin", 1, filename, sizeof(filename)))
#endif /* WIN32 */
#endif /* _WIN32 */
printf("PASS (%s)\n", filename);
else
{
+51
Ver Arquivo
@@ -0,0 +1,51 @@
/*
* CUPS cupsGetDests API test program for CUPS.
*
* Copyright 2017 by Apple Inc.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
* law. Distribution and use rights are outlined in the file "LICENSE.txt"
* which should have been included with this file. If this file is
* missing or damaged, see the license at "http://www.cups.org/".
*
* This file is subject to the Apple OS-Developed Software exception.
*/
/*
* Include necessary headers...
*/
#include <stdio.h>
#include "cups.h"
#include <sys/time.h>
/*
* 'main()' - Loop calling cupsGetDests.
*/
int /* O - Exit status */
main(void)
{
int num_dests; /* Number of destinations */
cups_dest_t *dests; /* Destinations */
struct timeval start, end; /* Start and stop time */
double secs; /* Total seconds to run cupsGetDests */
for (;;)
{
gettimeofday(&start, NULL);
num_dests = cupsGetDests(&dests);
gettimeofday(&end, NULL);
secs = end.tv_sec - start.tv_sec + 0.000001 * (end.tv_usec - start.tv_usec);
printf("Found %d printers in %.3f seconds...\n", num_dests, secs);
cupsFreeDests(num_dests, dests);
sleep(1);
}
return (0);
}
+67 -3
Ver Arquivo
@@ -1,8 +1,8 @@
/*
* HTTP test program for CUPS.
*
* Copyright 2007-2014 by Apple Inc.
* Copyright 1997-2006 by Easy Software Products.
* Copyright © 2007-2018 by Apple Inc.
* Copyright © 1997-2006 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
* property of Apple Inc. and are protected by Federal copyright
@@ -120,6 +120,9 @@ static uri_test_t uri_tests[] = /* URI test data */
{ HTTP_URI_STATUS_OK, "ipp://%22%23%2F%3A%3C%3E%3F%40%5B%5C%5D%5E%60%7B%7C%7D/",
"ipp", "", "\"#/:<>?@[\\]^`{|}", "/", 631, 0,
HTTP_URI_CODING_MOST },
{ HTTP_URI_STATUS_UNKNOWN_SCHEME, "smb://server/Some%20Printer",
"smb", "", "server", "/Some Printer", 0, 0,
HTTP_URI_CODING_ALL },
/* Missing scheme */
{ HTTP_URI_STATUS_MISSING_SCHEME, "/path/to/file/index.html",
@@ -148,6 +151,9 @@ static uri_test_t uri_tests[] = /* URI test data */
HTTP_URI_CODING_MOST },
/* Bad scheme */
{ HTTP_URI_STATUS_BAD_SCHEME, "://server/ipp",
"", "", "", "", 0, 0,
HTTP_URI_CODING_MOST },
{ HTTP_URI_STATUS_BAD_SCHEME, "bad_scheme://server/resource",
"", "", "", "", 0, 0,
HTTP_URI_CODING_MOST },
@@ -180,6 +186,9 @@ static uri_test_t uri_tests[] = /* URI test data */
HTTP_URI_CODING_MOST },
/* Bad resource */
{ HTTP_URI_STATUS_BAD_RESOURCE, "mailto:\r\nbla",
"mailto", "", "", "", 0, 0,
HTTP_URI_CODING_MOST },
{ HTTP_URI_STATUS_BAD_RESOURCE, "http://server/index.html%",
"http", "", "server", "", 80, 0,
HTTP_URI_CODING_MOST },
@@ -332,6 +341,40 @@ main(int argc, /* I - Number of command-line arguments */
if (!j)
puts("PASS");
#if 0
/*
* _httpDigest()
*/
fputs("_httpDigest(MD5): ", stdout);
if (!_httpDigest(buffer, sizeof(buffer), "MD5", "Mufasa", "http-auth@example.org", "Circle of Life", "7ypf/xlj9XXwfDPEoM4URrv/xwf94BcCAzFZH4GiTo0v", 1, "f2/wE4q74E6zIJEtWaHKaf5wv/H5QzzpXusqGemxURZJ", "auth", "GET", "/dir/index.html"))
{
failures ++;
puts("FAIL (unable to calculate hash)");
}
else if (strcmp(buffer, "8ca523f5e9506fed4657c9700eebdbec"))
{
failures ++;
printf("FAIL (got \"%s\", expected \"8ca523f5e9506fed4657c9700eebdbec\")\n", buffer);
}
else
puts("PASS");
fputs("_httpDigest(SHA-256): ", stdout);
if (!_httpDigest(buffer, sizeof(buffer), "SHA-256", "Mufasa", "http-auth@example.org", "Circle of Life", "7ypf/xlj9XXwfDPEoM4URrv/xwf94BcCAzFZH4GiTo0v", 1, "f2/wE4q74E6zIJEtWaHKaf5wv/H5QzzpXusqGemxURZJ", "auth", "GET", "/dir/index.html"))
{
failures ++;
puts("FAIL (unable to calculate hash)");
}
else if (strcmp(buffer, "753927fa0e85d155564e2e272a28d1802ca10daf4496794697cf8db5856cb6c1"))
{
failures ++;
printf("FAIL (got \"%s\", expected \"753927fa0e85d155564e2e272a28d1802ca10daf4496794697cf8db5856cb6c1\")\n", buffer);
}
else
puts("PASS");
#endif /* 0 */
/*
* httpGetHostname()
*/
@@ -590,6 +633,8 @@ main(int argc, /* I - Number of command-line arguments */
for (i = 1; i < argc; i ++)
{
int new_auth;
if (!strcmp(argv[i], "-o"))
{
i ++;
@@ -673,6 +718,8 @@ main(int argc, /* I - Number of command-line arguments */
printf("Checking file \"%s\"...\n", resource);
new_auth = 0;
do
{
if (!_cups_strcasecmp(httpGetField(http, HTTP_FIELD_CONNECTION), "close"))
@@ -685,9 +732,13 @@ main(int argc, /* I - Number of command-line arguments */
}
}
if (http->authstring && !strncmp(http->authstring, "Digest ", 7) && !new_auth)
_httpSetDigestAuthString(http, http->nextnonce, "HEAD", resource);
httpClearFields(http);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, httpGetAuthString(http));
httpSetField(http, HTTP_FIELD_ACCEPT_LANGUAGE, "en");
if (httpHead(http, resource))
{
if (httpReconnect2(http, 30000, NULL))
@@ -704,6 +755,8 @@ main(int argc, /* I - Number of command-line arguments */
while ((status = httpUpdate(http)) == HTTP_STATUS_CONTINUE);
new_auth = 0;
if (status == HTTP_STATUS_UNAUTHORIZED)
{
/*
@@ -716,7 +769,9 @@ main(int argc, /* I - Number of command-line arguments */
* See if we can do authentication...
*/
if (cupsDoAuthentication(http, "GET", resource))
new_auth = 1;
if (cupsDoAuthentication(http, "HEAD", resource))
{
status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;
break;
@@ -764,6 +819,8 @@ main(int argc, /* I - Number of command-line arguments */
printf("Requesting file \"%s\" (Accept-Encoding: %s)...\n", resource,
encoding ? encoding : "identity");
new_auth = 0;
do
{
if (!_cups_strcasecmp(httpGetField(http, HTTP_FIELD_CONNECTION), "close"))
@@ -776,6 +833,9 @@ main(int argc, /* I - Number of command-line arguments */
}
}
if (http->authstring && !strncmp(http->authstring, "Digest ", 7) && !new_auth)
_httpSetDigestAuthString(http, http->nextnonce, "GET", resource);
httpClearFields(http);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, httpGetAuthString(http));
httpSetField(http, HTTP_FIELD_ACCEPT_LANGUAGE, "en");
@@ -797,6 +857,8 @@ main(int argc, /* I - Number of command-line arguments */
while ((status = httpUpdate(http)) == HTTP_STATUS_CONTINUE);
new_auth = 0;
if (status == HTTP_STATUS_UNAUTHORIZED)
{
/*
@@ -809,6 +871,8 @@ main(int argc, /* I - Number of command-line arguments */
* See if we can do authentication...
*/
new_auth = 1;
if (cupsDoAuthentication(http, "GET", resource))
{
status = HTTP_STATUS_CUPS_AUTHORIZATION_CANCELED;

Alguns arquivos não foram exibidos porque demasiados arquivos foram alterados neste diff Mostrar Mais