Comparar commits

..

1 Commits

Autor SHA1 Mensagem Data
msweet 145d01c946 Import cups.org releases
git-svn-id: svn+ssh://src.apple.com/svn/cups/cups.org/tags/release-1.1b2@4306 a1ca3aef-8c08-0410-bb20-df032aa958be
2013-05-10 18:56:23 +00:00
486 arquivos alterados com 39645 adições e 192230 exclusões
+22 -744
Ver Arquivo
@@ -1,749 +1,6 @@
CHANGES.txt - 12/20/2000
CHANGES.txt - 03/13/2000
------------------------
CHANGES IN CUPS V1.1.5
- Security updates - new default configuration does
not broadcast printer information and only allows
access from the local system.
- EXPERIMENTAL encryption support - CUPS now optionally
supports TLS/SSL encryption via the OpenSSL library.
- Documentation updates.
- Makefile/configure script updates.
- The RPM spec file didn't work out-of-the-box under
RedHat or Mandrake.
- Minor code cleanup to remove extraneous compiler
warnings.
- cupsTempFile() was using %p for the temporary
filename; this should have been %08x (just 8 digit
hex)
- Deleting a printer with active print jobs would still
crash the server.
- ippWrite() and ipp_write_file() didn't send the
correct value length for name-with-language and
text-with-language attributes.
- Updated IPP code to support copied strings (that
should not be freed); this provides slightly more
efficient IPP server performance.
- Updated PDF filter to Xpdf 0.91.
- httpGets() could go into an infinite loop if a line
longer than the input buffer size was sent by a
client. This could be used in a Denial-of-Service
attack.
- The lpstat and CUPS API functions now request only the
data required when getting the list of printer or
class information. This should improve performance
with large numbers of printers on slower machines.
- The scheduler was always enforcing the FilterLimit,
even if FilterLimit was set to 0.
- Updated the Linux USB backend to support Mandrake's
/dev/usb/usblp# filenames.
- The PRINTER and LPDEST environment variables did not
override the lpoptions default printer.
- The PPD read functions incorrectly included trailing
characters (usually whitespace) after quoted string
attributes.
- The multiple-document-handling attribute handling code
did not check for the correct value for collated
copies (separate-documents-uncollated-copies).
- The EPSON driver did not work with OKIDATA printers in
EPSON emulation mode (needed change-emulation command)
- The HP-GL/2 filter did not scale the plot properly in
scale mode 2.
- Added PPD files for 9-pin and 24-pin OKIDATA printers.
- The httpSeparate() function didn't handle passwords
that started with a number.
- ippDelete() could free the character set string
multiple times in name-with-language and
text-with-language attributes.
- The scheduler would access freed memory right after
freeing it (for debug messages); these parts of the
code have been reordered to avoid this situation
which was causing sporatic errors and crashes.
- The ppdClose() function didn't free all of the strings
in the ppd_file_t structure.
- The LoadAllJobs() function in the scheduler did not
close the spool directory.
- Changed all sprintf's that use string formats to
snprintf's, even if the destination buffer is
larger than the source string(s); this protects
against buffer overflows caused outside of CUPS...
- Changed all strcpy's to strncpy's between local and
global variables, even if the destination buffer is
larger than the source string; this protects
against buffer overflows caused outside of CUPS...
- The CUPS certificate functions didn't use the
CUPS_SERVERROOT environment variable when set.
- The directory services code was copying instead of
comparing the remote printer info, resulting in
unnecessary updates of the printer attributes for
remote printers.
- Added new mime.types rules to allow automatic raw
printing of PCL and ESC/P files; PJL headers are
parsed to differentiate between PostScript and
PCL job files. This should eliminate a lot of
the reports of SAMBA printing problems due to
the missing "-oraw" or "-l" options.
- The mimeLoadType() function didn't handle the
3-argument contains() function.
- The LoadPPDs() function in the scheduler didn't
properly set the alloc_ppds variable or handle a PPD
database containing 0 printers.
- The scheduler FindAvailablePrinter() function didn't
use the same queuing logic as the CheckJobs()
function. This caused classes to stall if a remote
printer was always busy.
- Jobs are now assigned to printers in a class
round-robin style. This should prevent the first
server in the class from bearing the brunt of the
jobs.
- The scheduler's LoadAllJobs() function didn't always
restore remote printers for queued jobs on startup.
- The serial backend didn't support the higher baud
rates with the old termios interface. It now supports
57600 and 115200 baud.
- The serial backend now supports different types of
flow control; previously it ignored the flow=XYZ
option in the device URI.
- The serial backend now supports DTR/DSR flow control,
which is popular on dot-matrix printers (access with
"flow=dtrdsr" in the device URI)
- Added new job-originating-host-name attribute for
jobs. The new attribute provides the hostname or
IP address of the machine that submitted the job.
- The set-job-attributes code no longer allows read-only
job attributes to be changed.
- Expanded the click area for the navigation bar in the
web interface.
- Updated the lp and cancel commands to support all of
the Solaris print options (some are simply ignored
since they do not map)
- Updated the scheduler to limit the number of file
descriptors to the maximum select() set size. This
was causing problems on Solaris systems where the
max FD count was increased beyond 1024.
- The scheduler's LoadDevices() function was getting
interrupted by the SIGCHLD signal handler; now ignore
child signals while loading devices.
- Added quota and allow/deny user support for printers
and classes.
- Removed black/CMY adjustment code from the PS and
image file RIPs; it was interfering with some CUPS
driver dithering code.
- The lpc program stopped listing the queue statuses
after the first active printer.
- The cups-lpd program used an output format that the
Solaris printing system did not understand.
- Updated the lpq program to use the Solaris format
except under Tru64 UNIX.
- Some DEC PPD files incorrectly use "Off" for the null
value in UI constraints. Added "Off" to the list of
accepted null values.
- Changed the *BSD define constants to __*BSD__ in all
of the backends.
- Added support for "lpstat printername", which is an
undocumented feature in Solaris.
- The HP-GL/2 filter now only sets the plot size if it
is set in the plot file.
- The lpmove command wasn't sending the requesting
user name, causing it to always fail.
- Updated the cupsTempFile() code to use GetTempPath()
under Windows.
- The cups-lpd mini-daemon didn't limit the number of
data files accepted, didn't use cupsTempFile(),
didn't handle control file job information in any
order, and didn't free job options after printing
a file.
- The scheduler copy_banner() function did not
explicitly set the owner and permissions of the banner
files, which could prevent the banner pages from
printing on some systems.
- The lpstat program wasn't listing remote classes.
- The scheduler did not verify that the printer-uri
attribute was specified in all requests that required
it.
CHANGES IN CUPS v1.1.4
- Makefile and configure script fixes.
- **** Changed the default Printcap setting **** to
/etc/printcap. There are just too many people asking
why application XYZ doesn't see their printers!
- The web admin interface now displays an error if it
can't get the list of printer drivers from cupsd.
- The IPP backend was putting the copies option before
the other job options were set. This caused the IPP
request to contain attribute groups in the wrong
order, which prevented remote printing.
- Added checks in scheduler to free memory used for
IPP requests and language information when closing
a client connection.
- Fixed the duplex option in the HP LaserJet driver. It
should now work with all LaserJet printers (and
compatibles)
- The add-printer web interface didn't initialize the
"old info" data pointer, which caused random crashes
on many OS's.
- Fixed many page sizes defined in the Level 1
compatibility file "gs_statd.ps" to match reality.
- Fixed another bug in the setpagedevice "code" in
Ghostscript. It should now accept all standard
Adobe attributes on all platforms.
- Fixed pstoraster so that it reallocates memory for
color depth changes as well as size/resolution
changes. This removes an ordering constraint on
the color, page size, and resolution options in
PPD files.
- The IPP backend didn't use the job's character set
when the destination printer supported it. This
caused problems when printing text files to other
CUPS servers.
- Updated the logic used to determine when to rebuild
the PPD file database. The scheduler now checks the
dates and the number of PPD files (was just checking
the dates.)
- Updated the ippSetCGIVars() function (used by the
web interfaces) to only filter valid string values.
- The PostScript filter was scaling 2-up pages
incorrectly. This caused the edges of some pages to
be clipped.
CHANGES IN CUPS v1.1.3
- Makefile fixes.
- RPM spec file changes.
- Documentation updates.
- Enabled pstoraster debug messages for everything
(only logged when LogLevel set to "debug"...)
- Changed the Input/OutputAttributes fix in
pstoraster so that it works on all platforms.
- The HP-GL/2 filter didn't set the right green
color value in encoded polylines or text.
- Updated the "fitplot" code to handle plot sizes
specified as "PSwidth,length" and "PSlength,width".
- Updated the Linux parallel and USB backends to open
the device files prior to looking in /proc for
autoprobe info. This makes sure that loadable device
driver modules are in fact loaded...
- Added new FilterLimit directive to limit the number
of processing jobs/filters on a system.
- set-job-attributes didn't change the job-state to
held/pending when the job-hold-until attribute was
specified.
- set-job-attributes didn't save the new job attributes.
- Now change the "requesting-user-name" attribute in
requests from remote systems to "remroot" when an
unauthenticated "root" user is sent. This can be
changed using the new RemoteRoot directive in
cupsd.conf.
- The cancel-job, hold-job, release-job, and restart-job
operations didn't log the authenticated username.
- The cups-lpd mini-daemon now checks for a
document-format option before forcing raw mode with
filter mode 'l'.
- The cups-lpd mini-daemon now supports "-o" options
on the command-line (passed by inetd) to set global
defaults for all print queues.
- The pstops filter assumed that a file with a Trailer
comment would also have an EOF comment.
- Added new cupsSetPasswordCB(), cupsSetServer(),
cupsSetUser(), and ippSetPort() functions to better
support client applications (especially GUIs...)
- The CUPS-add-class and CUPS-add-printer operations
didn't reset the printer-name attribute on remote
print queues that had to be renamed when a local
printer was defined with the same name.
- The lpoptions command now supports a "-r" option to
remove options for a printer or instance.
- The lpadmin and admin.cgi programs no longer allow
class and printer names to begin with a number; this
caused the command-line utilities to become confused.
- The Linux USB backend now looks for both the parallel
and usblp driver names in the device list.
- Added a new FontPath directive to cupsd.conf, and also
a "--with-fontpath" option for the configure script to
specify alternate font paths for pstoraster.
- The CUPS-move-job operation didn't update the
job-printer-uri attribute.
- The scheduler only looked up printers and classes by
name in IPP requests, instead of using the full URI.
This caused problems with KUPS and friends with
remote printers.
- The scheduler now handles better localization of
hostnames (e.g. server is host.foo.com, remote is
host.subfoo.foo.com, localized is not host.subfoo...)
- The scheduler logging functions now use a common
log file checking/rotation function (courtesy of
Crutcher Dunnavant at Red Hat)
- The scheduler could accept more client connections
than it allocated for if more than one Port or Listen
line was present in cupsd.conf.
- Other minor scheduler performance tweeks.
- The lpq and lprm commands didn't support the default
printer set using lpoptions.
- The lpoptions command now supports a "-l" option to
list the printer-specific options and their current
settings.
- The web printer and class lists now show a link to the
default printer or class at the top of the page.
- The text filter now supports pretty printing of shell
and perl scripts as well as C/C++ source files.
- The top and bottom margins were reversed for landscape
text printing.
- The lpq and lprm commands didn't understand printer
instances.
- The scheduler only selected on the first 100 file
descriptors instead of the maximum file descriptor
limit.
- The scheduler client, listener, and mainline functions
now share code to disable and enable monitoring for
new client connections.
- The imagetoraster filter didn't support all of the
required pagedevice parameters.
- The serial backend now checks for 100 serial ports
under Linux.
- The scheduler used sscanf() to pull out the remote
printer location, description, and make/model strings,
but if any of these options was empty then sscanf()
would stop processing.
- Added "debug2" log level to provide a little less
verbose debugging information at the "debug" level.
- The scheduler would crash if you stopped a printer
that was currently printing a job.
- The scheduler incorrectly allowed jobs in the cancelled,
aborted, or completed state to be cancelled.
- The image filters did not load TIFF images properly
for bottom-to-top and right-to-left orientations.
- Added new cupsEncodeOptions() function to encode
CUPS options as IPP job attributes.
- The IPP backend, LPD mini-daemon, client commands,
and CUPS API did not properly encode multiple
option values separated by commas.
- Added new scheduler malloc logging in debug mode
(provides summary of total arena size, allocated,
and free bytes once a minute)
- The EPM-based distributions didn't install the
correct symlinks for a few man pages.
- Fixed a memory leak in the scheduler - wasn't
freeing old filters when deleting or renaming
printers.
- The scheduler now queries the primary IP address
for the name of the server and maps any incoming
requests from that address to the server name.
This fixes web admin mapping problems from
server.domain.com to localhost.
- The web printer modify interface now remembers
the previous device and driver settings (except
for serial ports.)
- The job-k-octets attribute is now stored as part of
the job attributes; this preserves the information
after a job is completed when job file history is
turned off.
- Dropped option sub-group parsing code for the moment,
since many Xerox PPD files abuse this feature in PPD
files and don't follow the hierarchy rules.
- Added new wrapper code around options so that duplex
options for some HP printers don't prevent prints.
- Added support for Digital UNIX/Tru64 UNIX/OSF/1 format
for "lpstat -v" output.
- Now show the URI for remote printers instead of
/dev/null in "lpstat -v" output.
- Creating classes and adding printers to a class with
the lpadmin command didn't work.
- The banner pages and test page should now format
correctly in both portrait and landscape orientations.
- Updated banner page substitution so that { can appear
by itself without quoting.
CHANGES IN CUPS v1.1.2
- Makefile/configure fixes
- RPM spec file and EPM list file fixes
- The cupsTempFile() function now uses a different
algorithm for generating temp files and "reserves"
them to avoid possible security exploitation.
- Now use /dev/random (if available) to seed the random
number generator for certificates.
- The /var/spool/cups and /var/spool/cups/tmp directories
were incorrectly owned by root; they are now owned by
the filter user, typically "lp".
- The scheduler now resets the permissions on the spool
and temp directories as needed to match the filter
user.
- Now expose ppdCollect() as an externally callable
function.
- The image filters now support filtering from the
standard input.
- The imagetoraster filter now collects all printer
options and job patch files and applies them to the
page header as needed.
- Added format and banner options to LPD backend.
- The send-document operation didn't start a job
immediately when last-document was true.
- The set-job-attributes operation didn't correctly
replace the current job-hold-until value.
- Removed the option wrapper code from ppdEmit() and
friends since it caused problems with Ghostscript
and many PS printers.
- Was setting TZ environment variable twice for job
filters.
- Added syslog logging in cups-lpd to aide in
debugging problems.
- The HP-UX parallel port backend did not list the
available parallel ports on some systems (printf
calling problem...)
- The lp and lpr commands overrode user options if
-d/-P were specified after -o.
- The scheduler would crash with a */* filter.
- Added support for a "default" filter for unknown file
types. The example provided in the mime.types and
mime.convs file prints unknown files as if "-oraw" was
specified for the job. This functionality is disabled
by default.
- The "compatibility" mode fix for older backends did not
work for smbspool. Added a workaround for it.
- The HP-GL/2 filter didn't perform the right pen scaling
with some files and the "fitplot" option.
- New Software Performance Specification document that
describes the memory, disk, and CPU usage of all the
CUPS software.
CHANGES IN CUPS v1.1.1
- The pstoraster Makefile still referenced one of the
old PDF filter files.
- The filter Makefile used INSTALL_DATA instead of
INSTALL_LIB to install the CUPS image library.
- The administration CGI didn't work properly with
network devices.
- The BrowseACL variable was not updated after the
cupsd.conf file was loaded.
- The lpd mini-daemon didn't support printer instances.
- Now use a default umask of 077 for child processes.
- Now put temp files in /var/spool/cups/tmp for child
processes and the root user, unless TMPDIR or TempDir
is defined otherwise.
- cupsGetPPD() no longer uses easy-to-guess filenames.
- The CUPS-Delete-Class and CUPS-Delete-Printer
operations now save classes.conf file as needed.
- The lppasswd command wouldn't add a user.
- The ppdOpen() function could cause a segfault if a
0-length PPD file was read.
- The image filters were not handling images with
different X and Y resolutions properly.
- The imagetoraster filter defaulted to RGB output
instead of black output like pstoraster.
- The pstops filter didn't handle binary data properly.
- The pstops filter didn't handle copies properly for
PS files lacking DSC comments.
- The pstops filter now appends %%EOF to the end of
documents if they don't have it.
- The cupsGetPPD() function didn't work with remote
printers lacking the @server in the name.
- The configure script didn't work right when only
--prefix was specified.
- The ppdEmit() code now wraps all printer commands so
that buggy PostScript printers will still print a file
after receiving an option that isn't available.
- Fixed the DeskJet margin bug, and disabled 600dpi
color mode until it can be fixed.
- The cupsAddDest() function didn't sort instances
correctly in all cases.
- The time-at-xyz attributes now expand to the date and
time in banner files.
CHANGES IN CUPS v1.1
- Documentation updates.
- Configuration script updates.
- Didn't map charset and language value strings to lowercase
and _ to - as required by SLP and IPP.
- ppdLoadXYZ() didn't add the list of available fonts to the
ppd_file_t structure.
- The text filter common code was freeing the PPD file data
before it was used.
- The text filter now embeds missing fonts.
- The CGI interface now maps local access to the server to
the localhost address.
- The HP-GL/2 filter didn't use the specified (or default)
color ranges, resulting in strange colors.
- The HP-GL/2 filter didn't default to no input window, which
caused unnecessary clipping of plots.
- Integrated Xpdf's pdftops filter into CUPS, which is a
lightweight and reliable replacement for Ghostscript's
PDF support.
- Removed all PDF support from Ghostscript.
- Updated HP driver to set top margin; this seems to fix
the offset problem seen on HP DeskJet printers.
- Fixed dependencies on the ZLIB and JPEG libraries in
pstoraster.
- The lpr command wasn't using the lpoptions defined by
the user.
- The lpr command would segfault if the CUPS server was
not running.
- The top-level makefile was not installing the CUPS
initialization script. It now does so if it sees there
is an init.d directory in /sbin, /etc/rc.d, or /etc.
- "lpstat -v all" didn't work.
- pstoraster would crash on some platforms doing the
setpagedevice operator.
- The web administration interface now allows you to set
the default banner pages.
- Images can now be positioned on the page using the new
"position" option.
- The AccessLog, ErrorLog, and PageLog directives now
support "%s" to insert the server name.
- Added a new BrowseShortNames directive to allow for
short remote printer names ("printer" instead of
"printer@server") when possible.
- The scheduler could crash if given an invalid PPD file
with no PageSize attributes.
- Updated the serial, parallel, and usb backends to do
multiple writes and ignore ioctl() errors as needed;
this should fix problems with serial printing on old
serial drivers and with the UltraSPARC parallel port
driver under Solaris 2.7.
- Now propagate LD_LIBRARY_PATH to child processes from
cupsd.
- New DataDir directive for installing in alternate
locations.
- New CUPS_SERVERROOT and CUPS_DATADIR environment
variables to specify installation directories as
needed.
- Queued remote jobs recreate remote printers as needed
when the scheduler is started.
- Deleting a printer also purges all jobs on that
printer.
- Old job and control files that don't belong to a
printer are automatically deleted.
- Wasn't updating time-at-processing and
time-at-completed attributes in job.
- Didn't send required multiple-operation-time-out
attribute in response to a get-printer-attributes
request.
- cups-lpd now supports options set with lpoptions.
- The job-hold-until attribute is now provided with all
jobs. For jobs that are not currently held the value
is "no-hold".
- The scheduler was not sending "unknown" values in IPP
responses.
- The lpoptions command now accumulates options from
previous runs rather than replacing all options for a
printer.
- The IPP backend now switches to IPP/1.0 if a 1.1
request fails.
- The lpadmin and admin.cgi programs now validate new
printer and class names.
- The access_log file now includes the number of IPP bytes
received in a POST request.
CHANGES IN CUPS v1.1b5
- Documentation updates.
- The pstoraster filter didn't compile without the JPEG library.
- The cupsd server didn't support the HTTP OPTIONS request
method.
- Dropped the "CLOSE" method supported by the cupsd server.
(not defined in HTTP specification)
- Makefile/configure script fixes.
- Missing the job-restart template.
- Added IPP test suite for testing.
- Missing IPP documentation from binary distributions.
- Fixed multiple-document handling code when last-document
not specified.
- Added more checks to IPP requests to prevent bad requests
from getting through.
- Not all of the Ghostscript error output was being sent to
stderr.
- The PostScript filter now added PJL commands to set the
job name and display string, if supported.
- The scheduler would crash if the browse socket could not
be bound. Now disables browsing if port 631 (reserved for
IPP) is being used by a misbehaving daemon.
- The USB backend now looks for the older Linux 2.2.x USB
printer device filenames as well as the newer ones.
- The IPP backend now uses the UTF-8 charset exclusively,
since apparently only CUPS handles more than US-ASCII and
UTF-8...
- Wasn't quoting ( in PostScript banners...
- Send-document requests with no document-format attribute
could cause cupsd to crash.
- Old jobs in the spool directory might cause cupsd to
crash.
- CUPS now supports all of the recommended job-hold-until
keywords as well as name values of the form "HH:MM" and
"HH:MM:SS".
- Added placeholder pointer for TLS encryption to the HTTP
connection structure.
- Fixed the "fast poll" bug reported by DISA - the
status pipe wasn't being closed for multi-file jobs.
- Revamped put_params code in pstoraster to fix bitmap
allocation bug with FrameMaker output.
- Ripped out filename, etc. code from pstoraster as it
is a potential security hole.
- Added support for RIP_CACHE environment variable in the
new pstoraster.
- Fixed USB device filenames for Linux; now support new
pre-2.4 devices (/dev/usb/lp#) and 2.2 devices
(/dev/usblp#)
- Fixed accept-jobs crash with classes.
- Didn't include dot-matrix EPSON drivers in previous
release.
CHANGES IN CUPS v1.1b4
- Documentation updates.
- Many makefile and configuration script fixes (should
now compile better under *BSD.)
- The MediaPosition attribute was being mishandled by
GhostScript, causing the RIP to fail whenever a paper
tray was selected.
- The scheduler now logs the final line of log information
from a filter, even if it doesn't end with a newline; this
primarily affects GhostScript error output.
- The scheduler was saving implicit classes, so after a few
restarts you'll end up with AnyPrinter, AnyAnyPrinter, etc.
- The JPEG autodetection didn't work with some JPEG files that
came from digital cameras (JPEG but not JFIF); the new
magic types should work with all images that the JPEG library
can handle.
- Fixed a bug in the new contains() MIME type rule that could
cause cupsd to crash.
- Switched to using strtol() in the MIME type code so that you
can use hex, octal, or decimal constants as desired in the
mime.types file.
- Banner files are now treated as templates, allowing any type
of file to be used as a banner.
- Added a 30-second timeout to backend device reports so that a
hung backend will not prevent the scheduler from starting.
- Backends are once again terminated when jobs are stopped; the
CUPS-supplied backends will stay alive until the downstream
filters have had a chance to clear out old page data.
- The charset lookup in the CUPS localization support was wrong
(iso8859-x instead of iso-8859-x)
- Changed the "cpNNNN" code page files to "windows-NNNN" to match
the IANA registrations.
- New PostScript banner pages.
- Added Windows BMP and Alias PIX image file support to the image
filter.
- The PNG reading coded didn't free all of its buffers.
- Added Digest authentication support to the client and server
code.
- Added Solaris options to System V commands.
- Now support the output-bin job template attribute.
- Now log the job-billing attribute in the page_log file, and
keep track of the total number of pages in the
job-media-sheets-completed attribute.
- The penwidth option is now in micrometers to support more
accurate width specification.
- The image filters now support interlaced and transparent PNG
files.
- Didn't handle Keep-Alive for HTTP/1.0 clients.
- The BrowsePoll support didn't handle when BrowseInterval
was set to 0 (now uses 30 seconds if BrowseInterval is 0)
- The DeskJet driver now supports 600 DPI color for printers
that support it.
- New lpinfo and lpmove commands.
- The lpq command now supports the Digital UNIX output format.
- The LPD mini-daemon now supports all required LPD operations.
- Implemented timeouts for multi-file documents.
- New cupsPrintFiles() function in the CUPS API library to
print multiple files using create-job and send-document
requests (1 job ID for multiple files)
- The lp command now sends multiple files as a single job,
matching the behavior of the System V command.
- The "cancel -a" command now purges job history files.
CHANGES IN CUPS v1.1b3
- Documentation updates.
- The startup script redirected stderr before stdout,
which caused problems with some versions of Bourne
shell and Bash.
- Fixed a bug in the scheduler's PPD language reading
code.
- Fixed a bug in the scheduler's check for the
manufacturer in the PPD.
- The pstoraster filter didn't allow some input and
output attributes to be set.
- Added banner page support.
- Added missing PAM configuration file.
- Configuration script fixes for Linux and *BSD.
- The log file code was using the wrong sign for the
timezone offset.
- The default printcap file is now empty (no printcap
file is generated).
- The scheduler did not start jobs destined for remote
printers when they became available.
- The scheduler now sends jobs to remote printers
immediately. (when sending jobs to a class, the remote
printer is only used when it becomes available)
- The scheduler now supports printing of banner pages
via the job-sheets attribute (banner files go in
/usr/share/cups/banners)
- The cupsd process now forks itself into the background
(override with -f)
- Added several *BSD enhancements.
- Added UNSUPPORTED libtool option to configuration
script to allow the use of libtool. Note that this is
UNSUPPORTED by us, but added by request of the *BSD
folks.
- The parallel, serial, and usb backends now retry the
opening of their ports. This allows multiple print
queues to be associated with a single physical port,
and will allow CUPS to support several types of
parallel port auto-switches in the near future.
- Set-Job-Attributes now supports adding, changing, and
deleting job template attributes, and no longer allows
job-printer-uri to be set (see CUPS-Move-Job)
- Added CUPS-Move-Job operation to support moving of jobs.
- The CGI template functionality now supports multiple
languages (still only have templates for English)
- The CUPS-Get-Printers and CUPS-Get-Classes operations
now support filtering as defined in the IDD.
- The Get-Jobs, CUPS-Get-Printers, and CUPS-Get-Classes
operations no longer limit themselves to 1000 jobs,
printers, or classes (believe it or not, this is
needed for some sites)
- The web interfaces now support language-specific
templates.
- The web admin interface now supports class management.
- The web admin interface now shows a list of
manufacturers before selecting the PPD/driver for a
specific printer.
- The web admin interface now supports configuration of
the default printer options in the PPD file.
- The web interface now uses printer/class
authentication for the test page instead of admin
authentication.
- Updated the RPM spec file for the current release.
- Updated language support for Windows code pages.
- 8-bit character set files can now use multiple fonts
(needed for Arabic, Greek, Hebrew, etc.)
- Added basic right-to-left text support in the text
filter.
- The POSIX locale now uses ISO-8859-1 instead of
US-ASCII.
- Fixed PDF printing problems.
- Fixed PostScript RIP page device dictionary elements
that weren't getting passed in cups_get_params().
- Added a new "contains" rule for the magic file typing.
- The "printable" rule now accepts characters from 128 to 255
(needed for Microsoft character sets)
- Added support for ~/.cupsrc as well as /etc/cups/client.conf
so that the default server can be configured on a per-user
basis without environment variables.
- Added LPD mini-daemon to support incoming LPD jobs.
CHANGES IN CUPS v1.1b2
- Documentation updates.
@@ -976,46 +233,67 @@ CHANGES IN CUPS v1.0.2
CHANGES IN CUPS v1.0.1
- Documentation updates.
- Fixed a bunch of possible buffer-overflow conditions.
- The scheduler now supports authentication using PAM.
- Updated the Italian message file.
- httpEncode64() didn't add an extra "=" if there was
only one byte in the last three-byte group.
- Now drop any trailing character set from the locale
string (e.g. "en_US.ISO_8859-1" becomes "en_US")
- Fixed "timezone" vs "tm_gmtoff" usage for BSD-based
operating systems.
- Updated IPP security so that "get" operations can be
done from any resource name; this allows the CGIs to
work with printer authentication enabled so long as
authentication isn't turned on for the whole "site".
- The IPP code didn't properly handle the "unsupported"
group; this caused problems with the HP JetDirect since
it doesn't seem to support the "copies" attribute.
- The HTTP chunking code was missing a CR LF pair at the
end of a 0-length chunk.
- The httpSeparate() function didn't handle embedded
usernames and passwords in the URI properly.
- Doing "lpadmin -p printer -E" didn't restart printing
if there were pending jobs.
- The cancel-job operation now requires either a
requesting-user-name attribute or an authenticated
username.
- The add-printer code did not report errors if the
interface script or PPD file could not be renamed.
- Request files are now created without world read
permissions.
- Added a cupsLastError() function to the CUPS API to
retrieve the IPP error code from the last request.
- Options are now case-insensitive.
- The lpq command now provides 10 characters for the
username instead of the original (Berkeley standard)
7.
- The cancel command needed a local CUPS server to work
(or the appropriate ServerName in cupsd.conf)
- The cancel and lprm commands didn't report the IPP
error if the job could not be cancelled.
- The lp and lpr commands didn't intercept SIGTERM to
remove temporary files when printing from stdin.
- The lp and lpr commands didn't report the IPP error if
the job could not be printed.
-129
Ver Arquivo
@@ -1,129 +0,0 @@
ENCRYPTION - CUPS v1.1.5 - 12/20/2000
-------------------------------------
This file describes the encryption support provided by CUPS.
WARNING: CLIENTS CURRENTLY TRUST ALL CERTIFICATES FROM SERVERS.
This makes the CUPS client applications vulnerable to "man in
the middle" attacks, so we don't recommend using this to do
remote administration over WANs at this time.
Future versions of CUPS will keep track of server certificates
and provide a callback/confirmation interface for accepting new
certificates and warning when a certificate has changed.
LEGAL STUFF
BEFORE USING THE ENCRYPTION SUPPORT, PLEASE VERIFY THAT IT IS
LEGAL TO DO SO IN YOUR COUNTRY. CUPS by itself doesn't include
any encryption code, but it can link against the OpenSSL library
which does.
OVERVIEW OF ENCRYPTION SUPPORT IN CUPS
CUPS supports SSL/2.0, SSL/3.0, and TLS/1.0 encryption using
keys as large as 128-bits. Encryption support is provided via
the OpenSSL library and some new hooks in the CUPS code.
CUPS provides support for dedicated (https) and "upgrade" (TLS)
encryption of sessions. The "HTTP Upgrade" method is described
in RFC 2817; basically, the client can be secure or unsecure,
and the client or server initiates an upgrade to a secure
connection via some new HTTP fields and status codes. The HTTP
Upgrade method is new and no browsers we know of support it yet.
Stick with "https" for web browsers.
The current implementation is very basic. The CUPS client
software (lp, lpr, etc.) uses encryption as requested by the
server and/or as specified by the Encryption directive in the
client.conf file or in the CUPS_ENCRYPTION environment
variable:
Never
Never do encryption.
Always
Always do SSL/TLS encryption using the https scheme.
IfRequested
Upgrade to TLS encryption if the server asks for it.
This is the default setting.
Required
Always upgrade to TLS encryption as soon as the
connection is made. This is different than the "Always"
mode above since the connection is initially unsecure
and the client initiates the upgrade to TLS encryption.
These keywords are also used in the cupsd.conf file to secure
particular locations. To secure all traffic on the server, listen
on port 443 (https port) instead of port 631 and change the "ipp"
service listing (or add it if you don't have one) in /etc/services
to 443.
BEFORE YOU BEGIN
You'll need the OpenSSL library from:
http://www.openssl.org
CONFIGURING WITH ENCRYPTION SUPPORT
Once you have the OpenSSL library installed, you'll need to
configure CUPS to use it with the "--enable-ssl" option:
./configure --enable-ssl
If the OpenSSL stuff is not in a standard location, make sure to
define the CFLAGS, CXXFLAGS, and LDFLAGS environment variables
with the appropriate compiler and linker options first.
GENERATING A SERVER CERTIFICATE AND KEY
The following OpenSSL command will generate a server certificate
and key that you can play with. Since the certificate is not
properly signed it will generate all kinds of warnings in
Netscape and MSIE:
openssl req -new -x509 -keyout /etc/cups/ssl/server.key \
-out /etc/cups/ssl/server.crt -days 365 -nodes
chmod 600 /etc/cups/ssl/server.*
The "-nodes" option prevents the certificate and key from being
encrypted. The cupsd process runs in the background, detached
from any input source; if you encrypt these files then cupsd
will not be able to load them!
Send all rants about non-encrypted certificate and key files to
/dev/null. It makes sense to encrypt user files, but not for
files used by system processes/daemons...
REPORTING PROBLEMS
If you have problems, READ THE DOCUMENTATION FIRST! If the
documentation does not solve your problems please send an email
to "cups-support@cups.org". Include your operating system and
version, compiler and version, and any errors or problems you've
run into. The "/var/log/cups/error_log" file should also be sent,
as it often helps to determine the cause of your problem.
If you are running a version of Linux, be sure to provide the
Linux distribution you have, too.
Please note that the "cups-support@cups.org" email address goes
to the CUPS developers; they are busy people, so your email may
go unanswered for days or weeks. In general, only general build
or distribution problems will actually get answered - for
end-user support see the "README.txt" for a summary of the
resources available.
-154
Ver Arquivo
@@ -1,154 +0,0 @@
INSTALL - CUPS v1.1.5 - 12/20/2000
----------------------------------
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".
BEFORE YOU BEGIN
You'll need ANSI-compliant C and C++ compilers, plus a make
program and Bourne shell. The GNU compiler tools work well -
we've tested the current CUPS code against GCC 2.95.x with
excellent results.
The makefiles used by the project should work with all versions
of make. We've tested them with GNU make as well as the make
programs shipped by Compaq, HP, SGI, and Sun. FreeBSD users
should use GNU make (gmake).
Besides these tools you'll want the following libraries:
- JPEG 6b or higher
- PNG 1.0.6 or higher
- TIFF 3.4 or higher
- ZLIB 1.1.3 or higher
CUPS will compile and run without these, however you'll miss out on
many of the features provided by CUPS.
CONFIGURATION
CUPS uses GNU autoconf, so you should find the usual "configure"
script in the main CUPS source directory. To configure CUPS for
your system, type:
./configure ENTER
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 in
another location:
./configure --prefix=/some/directory ENTER
If the PNG, JPEG, TIFF, and ZLIB libraries are not installed in
a system default location (typically "/usr/include" and
"/usr/lib") you'll need to set the CFLAGS, CXXFLAGS, and LDFLAGS
environment variables prior to running configure:
setenv CFLAGS "-I/some/directory" ENTER
setenv CXXFLAGS "-I/some/directory" ENTER
setenv LDFLAGS "-L/some/directory" ENTER
./configure ... ENTER
or:
CFLAGS="-I/some/directory"; export CFLAGS ENTER
CXXFLAGS="-I/some/directory"; export CXXFLAGS ENTER
LDFLAGS="-L/some/directory"; export LDFLAGS ENTER
./configure ... ENTER
To enable support for encryption, you'll also want to add the
"--enable-ssl" option:
./configure --enable-ssl
SSL and TLS support require the OpenSSL library, available at:
http://www.openssl.org
Once you have configured things, just type:
make ENTER
or if you have FreeBSD:
gmake ENTER
to build the software.
INSTALLING THE SOFTWARE
Once you have built the software you need to install it. The
"install" target provides a quick way to install the software on
your local system:
make install ENTER
or for FreeBSD:
gmake install ENTER
You can also build binary packages that can be installed on other
machines using the RPM spec file ("cups.spec") or EPM list file
("cups.list"). The latter also supports building of binary RPMs,
so it may be more convenient to use - we use EPM to build all of
our binary distributions.
You can find the RPM software at:
http://www.rpm.org
The RPM software is at:
http://www.easysw.com/epm
CREATING BINARY DISTRIBUTIONS WITH EPM
The top level makefile supports generation of many types of binary
distributions using EPM. To build a binary distribution type:
make <format> ENTER
or
gmake <format> ENTER
for FreeBSD, where <format> is one of the following:
epm - Builds a portable shell script and tar file based
distribution. This format will also backup your
existing printing system if you decide to remove
CUPS at some future time.
rpm - Builds a RPM binary distribution.
deb - Builds a Debian binary distribution.
depot - Builds a HP-UX binary distribution.
pkg - Builds a Solaris binary distribution.
tardist - Builds an IRIX binary distribution.
REPORTING PROBLEMS
If you have problems, READ THE DOCUMENTATION FIRST! If the
documentation does not solve your problems please send an email
to "cups-support@cups.org". Include your operating system and
version, compiler and version, and any errors or problems you've
run into. The "/var/log/cups/error_log" file should also be sent,
as it often helps to determine the cause of your problem.
If you are running a version of Linux, be sure to provide the
Linux distribution you have, too.
Please note that the "cups-support@cups.org" email address goes
to the CUPS developers; they are busy people, so your email may
go unanswered for days or weeks. In general, only general build
or distribution problems will actually get answered - for
end-user support see the "README.txt" for a summary of the
resources available.
+42 -551
Ver Arquivo
@@ -3,36 +3,26 @@
<TITLE>Software License Agreement - Common UNIX Printing System</TITLE>
</HEAD>
<BODY BGCOLOR="#ffffff" TEXT="#000000">
<BODY BGCOLOR=#ffffff>
<H2 ALIGN="CENTER">Common UNIX Printing System License Agreement</H2>
<P ALIGN="CENTER">Copyright 1997-2000 by Easy Software Products<BR>
<P ALIGN="CENTER">Copyright 1997-1999 by Easy Software Products<BR>
44141 AIRPORT VIEW DR STE 204<BR>
HOLLYWOOD, MARYLAND 20636-3111 USA<BR>
<BR>
Voice: +1.301.373.9603<BR>
Email: <A HREF="mailto:cups-info@cups.org">cups-info@cups.org</A><BR>
WWW: <A HREF="http://www.cups.org">http://www.cups.org</A>
Email: cups-info@cups.org<BR>
WWW: http://www.cups.org
<H3>Introduction</H3>
<P>The Common UNIX Printing System<SUP>TM</SUP>, ("CUPS<SUP>TM</SUP>"),
is provided under the GNU General Public License ("GPL") and GNU
Library General Public License ("LGPL"), Version 2. A copy of these
licenses follow this introduction.
<P>The Common UNIX Printing System<SUP>TM</SUP>, or CUPS<SUP>TM</SUP>,
is provided under the GNU General Public License, Version 2. A copy of
this license follows this introduction.
<P>The GNU LGPL applies to the CUPS API library, located in the "cups"
subdirectory of the CUPS source distribution and in the
"/usr/include/cups" directory and "libcups.a", "libcups.sl", or
"libcups.so" files in the binary distributions.
<P>The GNU GPL applies to the remainder of the CUPS distribution,
including the "pstoraster" filter which is based upon GNU Ghostscript
5.50 and the "pdftops" filter which is based upon Xpdf 0.90.
<P>For those not familiar with the GNU GPL, the license basically
allows you to:
<P>For those not familiar with the GNU General Public License, the license
basically allows you to:
<UL>
@@ -44,88 +34,66 @@ allows you to:
<LI>Sell verbatim copies of the software for a media fee, or
sell support for the software.
<LI>Distribute or sell printer drivers and filters that use
CUPS so long as source code is made available under the GPL.
<LI>Distribute or sell printer drivers and filters that use the
CUPS API so long as source code is made available under the GPL.
</UL>
<P>What this license <B>does not</B> allow you to do is make changes or
add features to CUPS and then sell a binary distribution without source
code. You must provide source for any new drivers, changes, or
additions to the software, and all code must be provided under the GPL
or LGPL as appropriate.
code. You have to provide source for any new drivers, changes, or
additions to the software, and all code must be provided under the GPL.
<P>The GNU LGPL relaxes the "link-to" restriction, allowing you to
develop applications that use the CUPS API library under other licenses
and/or conditions as appropriate for your application.
<H3>Trademarks</H3>
<P>Easy Software Products has trademarked the Common UNIX Printing
System, CUPS, and CUPS logo. These names and logos may be used freely
in any direct port or binary distribution of CUPS. To use them in
derivative products, please contract Easy Software Products for written
permission. Our intention is to protect the value of these trademarks and
ensure that any derivative product meets the same high-quality
standards as the original.
<P>Also, since we have trademarked the Common UNIX Printing System, CUPS,
and CUPS logo, you may not release a derivative product using those names
without permission from Easy Software Products.
<H3>Binary Distribution Rights</H3>
<P>Easy Software Products also sells rights to the CUPS source code
under a binary distribution license for vendors that are unable to
release source code for their drivers, additions, and modifications to
CUPS under the GNU GPL and LGPL. For information please contact us at
the address shown above.
release source code for their drivers or additions and modifications to
CUPS under the GPL. For pricing information please contact us at the
address shown above.
<P>The Common UNIX Printing System provides a "pstoraster" filter that
utilizes the GNU GhostScript 5.50 core to convert PostScript files into
a stream of raster images. For binary distribution licensing of this
software, please contact:
<P>The Common UNIX Printing System utilizes GNU GhostScript 4.03 to
convert PostScript files into a stream of raster images. For binary
distribution licensing of this software, please contact:
<BLOCKQUOTE>
Miles Jones<BR>
<BLOCKQUOTE>Miles Jones<BR>
Director of Marketing<BR>
Artifex Software Inc.<BR>
454 Las Gallinas Ave., Suite 108<BR>
San Rafael, CA 94903 USA<BR>
Voice: +1.415.492.9861<BR>
Fax: +1.415.492.9862<BR>
EMail: <A HREF="mailto:info@arsoft.com">info@arsoft.com</A>
</BLOCKQUOTE>
<P>The "pdftops" filter is based on the Xpdf 0.90 software. For binary
distribution licensing of this software, please contact:
<BLOCKQUOTE>
Derek B. Noonburg<BR>
Email: <A HREF="mailto:derekn@foolabs.com">derekn@foolabs.com</A><BR>
WWW: <A HREF="http://www.foolabs.com/xpdf/">http://www.foolabs.com/xpdf/</A>
EMail: info@arsoft.com
</BLOCKQUOTE>
<H3>Support</H3>
<P>Easy Software Products sells software support for CUPS as well as a
commercial printing product based on CUPS called ESP Print Pro. You can
find out more at our web site:
<P>Easy Software Products sells software support for distributors and
resellers of CUPS. Support for users of CUPS is available from Easy
Software Products through our ESP Print software.
<UL><PRE>
<A HREF="http://www.easysw.com">http://www.easysw.com</A>
</PRE></UL>
<H3>Trademarks</H3>
<!-- NEW PAGE -->
<H2>GNU GENERAL PUBLIC LICENSE</H2>
<P>The Common UNIX Printing System, CUPS, and the CUPS logo are the
trademark property of Easy Software Products. Any derivative of this
software may not use any of these trademarks without the expressed
written consent of Easy Software Products.
<P>Version 2, June 1991
<H2 ALIGN="CENTER">GNU General Public License</H2>
<PRE>
Copyright 1989, 1991 Free Software Foundation, Inc.
<P ALIGN="CENTER">Version 2, June 1991<BR>
<BR>
Copyright 1989, 1991 Free Software Foundation, Inc.<BR>
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim
<P ALIGN="CENTER">Everyone is permitted to copy and distribute verbatim
copies of this license document, but changing it is not allowed.
<PRE>
<H4>Preamble</H4>
<H3>Preamble</H3>
<P>The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
@@ -175,8 +143,8 @@ patent must be licensed for everyone's free use or not licensed at all.
<P>The precise terms and conditions for copying, distribution and
modification follow.
<H4>GNU GENERAL PUBLIC LICENSE<BR>
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</H4>
<H3>GNU GENERAL PUBLIC LICENSE<BR>
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</H3>
<OL START="0">
@@ -386,7 +354,7 @@ of promoting the sharing and reuse of software generally.
</OL>
<H4>NO WARRANTY</H4>
<H3>NO WARRANTY</H3>
<OL START="11">
@@ -412,484 +380,7 @@ POSSIBILITY OF SUCH DAMAGES.
</OL>
<H4>END OF TERMS AND CONDITIONS</H4>
<!-- NEW PAGE -->
<H2>GNU LIBRARY GENERAL PUBLIC LICENSE</H2>
<P>Version 2, June 1991
<PRE>
Copyright (C) 1991 Free Software Foundation, Inc.
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
[This is the first released version of the library GPL. It is
numbered 2 because it goes with version 2 of the ordinary GPL.]
</PRE>
<H4>Preamble</H4>
<P>The licenses for most software are designed to take away your
freedom to share and change it. By contrast, the GNU General Public
Licenses are intended to guarantee your freedom to share and change
free software--to make sure the software is free for all its users.
<P>This license, the Library General Public License, applies to some
specially designated Free Software Foundation software, and to any
other libraries whose authors decide to use it. You can use it for
your libraries, too.
<P>When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
this service if you wish), that you receive source code or can get it
if you want it, that you can change the software or use pieces of it
in new free programs; and that you know you can do these things.
<P>To protect your rights, we need to make restrictions that forbid
anyone to deny you these rights or to ask you to surrender the rights.
These restrictions translate to certain responsibilities for you if
you distribute copies of the library, or if you modify it.
<P>For example, if you distribute copies of the library, whether gratis
or for a fee, you must give the recipients all the rights that we gave
you. You must make sure that they, too, receive or can get the source
code. If you link a program with the library, you must provide
complete object files to the recipients so that they can relink them
with the library, after making changes to the library and recompiling
it. And you must show them these terms so they know their rights.
<P>Our method of protecting your rights has two steps: (1) copyright
the library, and (2) offer you this license which gives you legal
permission to copy, distribute and/or modify the library.
<P>Also, for each distributor's protection, we want to make certain
that everyone understands that there is no warranty for this free
library. If the library is modified by someone else and passed on, we
want its recipients to know that what they have is not the original
version, so that any problems introduced by others will not reflect on
the original authors' reputations.
<P>Finally, any free program is threatened constantly by software
patents. We wish to avoid the danger that companies distributing free
software will individually obtain patent licenses, thus in effect
transforming the program into proprietary software. To prevent this,
we have made it clear that any patent must be licensed for everyone's
free use or not licensed at all.
<P>Most GNU software, including some libraries, is covered by the ordinary
GNU General Public License, which was designed for utility programs. This
license, the GNU Library General Public License, applies to certain
designated libraries. This license is quite different from the ordinary
one; be sure to read it in full, and don't assume that anything in it is
the same as in the ordinary license.
<P>The reason we have a separate public license for some libraries is that
they blur the distinction we usually make between modifying or adding to a
program and simply using it. Linking a program with a library, without
changing the library, is in some sense simply using the library, and is
analogous to running a utility program or application program. However, in
a textual and legal sense, the linked executable is a combined work, a
derivative of the original library, and the ordinary General Public License
treats it as such.
<P>Because of this blurred distinction, using the ordinary General
Public License for libraries did not effectively promote software
sharing, because most developers did not use the libraries. We
concluded that weaker conditions might promote sharing better.
<P>However, unrestricted linking of non-free programs would deprive the
users of those programs of all benefit from the free status of the
libraries themselves. This Library General Public License is intended to
permit developers of non-free programs to use free libraries, while
preserving your freedom as a user of such programs to change the free
libraries that are incorporated in them. (We have not seen how to achieve
this as regards changes in header files, but we have achieved it as regards
changes in the actual functions of the Library.) The hope is that this
will lead to faster development of free libraries.
<P>The precise terms and conditions for copying, distribution and
modification follow. Pay close attention to the difference between a
"work based on the library" and a "work that uses the library". The
former contains code derived from the library, while the latter only
works together with the library.
<P>Note that it is possible for a library to be covered by the ordinary
General Public License rather than by this special one.
<H4>TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</H4>
<P><STRONG>0.</STRONG>
This License Agreement applies to any software library which
contains a notice placed by the copyright holder or other authorized
party saying it may be distributed under the terms of this Library
General Public License (also called "this License"). Each licensee is
addressed as "you".
<P>A "library" means a collection of software functions and/or data
prepared so as to be conveniently linked with application programs
(which use some of those functions and data) to form executables.
<P>The "Library", below, refers to any such software library or work
which has been distributed under these terms. A "work based on the
Library" means either the Library or any derivative work under
copyright law: that is to say, a work containing the Library or a
portion of it, either verbatim or with modifications and/or translated
straightforwardly into another language. (Hereinafter, translation is
included without limitation in the term "modification".)
<P>"Source code" for a work means the preferred form of the work for
making modifications to it. For a library, complete source code means
all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation
and installation of the library.
<P>Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of
running a program using the Library is not restricted, and output from
such a program is covered only if its contents constitute a work based
on the Library (independent of the use of the Library in a tool for
writing it). Whether that is true depends on what the Library does
and what the program that uses the Library does.
<P><STRONG>1.</STRONG>
You may copy and distribute verbatim copies of the Library's
complete source code as you receive it, in any medium, provided that
you conspicuously and appropriately publish on each copy an
appropriate copyright notice and disclaimer of warranty; keep intact
all the notices that refer to this License and to the absence of any
warranty; and distribute a copy of this License along with the
Library.
<P>You may charge a fee for the physical act of transferring a copy,
and you may at your option offer warranty protection in exchange for a
fee.
<P><STRONG>2.</STRONG>
You may modify your copy or copies of the Library or any portion
of it, thus forming a work based on the Library, and copy and
distribute such modifications or work under the terms of Section 1
above, provided that you also meet all of these conditions:
<OL TYPE="a">
<LI>The modified work must itself be a software library.
<P>
<LI>You must cause the files modified to carry prominent notices
stating that you changed the files and the date of any change.
<P>
<LI>You must cause the whole of the work to be licensed at no
charge to all third parties under the terms of this License.
<P>
<LI>If a facility in the modified Library refers to a function or a
table of data to be supplied by an application program that uses
the facility, other than as an argument passed when the facility
is invoked, then you must make a good faith effort to ensure that,
in the event an application does not supply such function or
table, the facility still operates, and performs whatever part of
its purpose remains meaningful.
<P>(For example, a function in a library to compute square roots has
a purpose that is entirely well-defined independent of the
application. Therefore, Subsection 2d requires that any
application-supplied function or table used by this function must
be optional: if the application does not supply it, the square
root function must still compute square roots.)
</OL>
<P>These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Library,
and can be reasonably considered independent and separate works in
themselves, then this License, and its terms, do not apply to those
sections when you distribute them as separate works. But when you
distribute the same sections as part of a whole which is a work based
on the Library, the distribution of the whole must be on the terms of
this License, whose permissions for other licensees extend to the
entire whole, and thus to each and every part regardless of who wrote
it.
<P>Thus, it is not the intent of this section to claim rights or contest
your rights to work written entirely by you; rather, the intent is to
exercise the right to control the distribution of derivative or
collective works based on the Library.
<P>In addition, mere aggregation of another work not based on the Library
with the Library (or with a work based on the Library) on a volume of
a storage or distribution medium does not bring the other work under
the scope of this License.
<P><STRONG>3.</STRONG>
You may opt to apply the terms of the ordinary GNU General Public
License instead of this License to a given copy of the Library. To do
this, you must alter all the notices that refer to this License, so
that they refer to the ordinary GNU General Public License, version 2,
instead of to this License. (If a newer version than version 2 of the
ordinary GNU General Public License has appeared, then you can specify
that version instead if you wish.) Do not make any other change in
these notices.
<P>Once this change is made in a given copy, it is irreversible for
that copy, so the ordinary GNU General Public License applies to all
subsequent copies and derivative works made from that copy.
<P>This option is useful when you wish to copy part of the code of
the Library into a program that is not a library.
<P><STRONG>4.</STRONG>
You may copy and distribute the Library (or a portion or
derivative of it, under Section 2) in object code or executable form
under the terms of Sections 1 and 2 above provided that you accompany
it with the complete corresponding machine-readable source code, which
must be distributed under the terms of Sections 1 and 2 above on a
medium customarily used for software interchange.
<P>If distribution of object code is made by offering access to copy
from a designated place, then offering equivalent access to copy the
source code from the same place satisfies the requirement to
distribute the source code, even though third parties are not
compelled to copy the source along with the object code.
<P><STRONG>5.</STRONG>
A program that contains no derivative of any portion of the
Library, but is designed to work with the Library by being compiled or
linked with it, is called a "work that uses the Library". Such a
work, in isolation, is not a derivative work of the Library, and
therefore falls outside the scope of this License.
<P>However, linking a "work that uses the Library" with the Library
creates an executable that is a derivative of the Library (because it
contains portions of the Library), rather than a "work that uses the
library". The executable is therefore covered by this License.
Section 6 states terms for distribution of such executables.
<P>When a "work that uses the Library" uses material from a header file
that is part of the Library, the object code for the work may be a
derivative work of the Library even though the source code is not.
Whether this is true is especially significant if the work can be
linked without the Library, or if the work is itself a library. The
threshold for this to be true is not precisely defined by law.
<P>If such an object file uses only numerical parameters, data
structure layouts and accessors, and small macros and small inline
functions (ten lines or less in length), then the use of the object
file is unrestricted, regardless of whether it is legally a derivative
work. (Executables containing this object code plus portions of the
Library will still fall under Section 6.)
<P>Otherwise, if the work is a derivative of the Library, you may
distribute the object code for the work under the terms of Section 6.
Any executables containing that work also fall under Section 6,
whether or not they are linked directly with the Library itself.
<P><STRONG>6.</STRONG>
As an exception to the Sections above, you may also compile or
link a "work that uses the Library" with the Library to produce a
work containing portions of the Library, and distribute that work
under terms of your choice, provided that the terms permit
modification of the work for the customer's own use and reverse
engineering for debugging such modifications.
<P>You must give prominent notice with each copy of the work that the
Library is used in it and that the Library and its use are covered by
this License. You must supply a copy of this License. If the work
during execution displays copyright notices, you must include the
copyright notice for the Library among them, as well as a reference
directing the user to the copy of this License. Also, you must do one
of these things:
<OL TYPE="a">
<LI>Accompany the work with the complete corresponding
machine-readable source code for the Library including whatever
changes were used in the work (which must be distributed under
Sections 1 and 2 above); and, if the work is an executable linked
with the Library, with the complete machine-readable "work that
uses the Library", as object code and/or source code, so that the
user can modify the Library and then relink to produce a modified
executable containing the modified Library. (It is understood
that the user who changes the contents of definitions files in the
Library will not necessarily be able to recompile the application
to use the modified definitions.)
<P>
<LI>Accompany the work with a written offer, valid for at
least three years, to give the same user the materials
specified in Subsection 6a, above, for a charge no more
than the cost of performing this distribution.
<P>
<LI>If distribution of the work is made by offering access to copy
from a designated place, offer equivalent access to copy the above
specified materials from the same place.
<P>
<LI>Verify that the user has already received a copy of these
materials or that you have already sent this user a copy.
</OL>
<P>For an executable, the required form of the "work that uses the
Library" must include any data and utility programs needed for
reproducing the executable from it. However, as a special exception,
the source code distributed need not include anything that is normally
distributed (in either source or binary form) with the major
components (compiler, kernel, and so on) of the operating system on
which the executable runs, unless that component itself accompanies
the executable.
<P>It may happen that this requirement contradicts the license
restrictions of other proprietary libraries that do not normally
accompany the operating system. Such a contradiction means you cannot
use both them and the Library together in an executable that you
distribute.
<P><STRONG>7.</STRONG>
You may place library facilities that are a work based on the
Library side-by-side in a single library together with other library
facilities not covered by this License, and distribute such a combined
library, provided that the separate distribution of the work based on
the Library and of the other library facilities is otherwise
permitted, and provided that you do these two things:
<OL TYPE="a">
<LI>Accompany the combined library with a copy of the same work
based on the Library, uncombined with any other library
facilities. This must be distributed under the terms of the
Sections above.
<P>
<LI>Give prominent notice with the combined library of the fact
that part of it is a work based on the Library, and explaining
where to find the accompanying uncombined form of the same work.
</OL>
<P><STRONG>8.</STRONG>
You may not copy, modify, sublicense, link with, or distribute
the Library except as expressly provided under this License. Any
attempt otherwise to copy, modify, sublicense, link with, or
distribute the Library is void, and will automatically terminate your
rights under this License. However, parties who have received copies,
or rights, from you under this License will not have their licenses
terminated so long as such parties remain in full compliance.
<P><STRONG>9.</STRONG>
You are not required to accept this License, since you have not
signed it. However, nothing else grants you permission to modify or
distribute the Library or its derivative works. These actions are
prohibited by law if you do not accept this License. Therefore, by
modifying or distributing the Library (or any work based on the
Library), you indicate your acceptance of this License to do so, and
all its terms and conditions for copying, distributing or modifying
the Library or works based on it.
<P><STRONG>10.</STRONG>
Each time you redistribute the Library (or any work based on the
Library), the recipient automatically receives a license from the
original licensor to copy, distribute, link with or modify the Library
subject to these terms and conditions. You may not impose any further
restrictions on the recipients' exercise of the rights granted herein.
You are not responsible for enforcing compliance by third parties to
this License.
<P><STRONG>11.</STRONG>
If, as a consequence of a court judgment or allegation of patent
infringement or for any other reason (not limited to patent issues),
conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot
distribute so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you
may not distribute the Library at all. For example, if a patent
license would not permit royalty-free redistribution of the Library by
all those who receive copies directly or indirectly through you, then
the only way you could satisfy both it and this License would be to
refrain entirely from distribution of the Library.
<P>If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply,
and the section as a whole is intended to apply in other circumstances.
<P>It is not the purpose of this section to induce you to infringe any
patents or other property right claims or to contest validity of any
such claims; this section has the sole purpose of protecting the
integrity of the free software distribution system which is
implemented by public license practices. Many people have made
generous contributions to the wide range of software distributed
through that system in reliance on consistent application of that
system; it is up to the author/donor to decide if he or she is willing
to distribute software through any other system and a licensee cannot
impose that choice.
<P>This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
<P><STRONG>12.</STRONG>
If the distribution and/or use of the Library is restricted in
certain countries either by patents or by copyrighted interfaces, the
original copyright holder who places the Library under this License may add
an explicit geographical distribution limitation excluding those countries,
so that distribution is permitted only in or among countries not thus
excluded. In such case, this License incorporates the limitation as if
written in the body of this License.
<P><STRONG>13.</STRONG>
The Free Software Foundation may publish revised and/or new
versions of the Library General Public License from time to time.
Such new versions will be similar in spirit to the present version,
but may differ in detail to address new problems or concerns.
<P>Each version is given a distinguishing version number. If the Library
specifies a version number of this License which applies to it and
"any later version", you have the option of following the terms and
conditions either of that version or of any later version published by
the Free Software Foundation. If the Library does not specify a
license version number, you may choose any version ever published by
the Free Software Foundation.
<P><STRONG>14.</STRONG>
If you wish to incorporate parts of the Library into other free
programs whose distribution conditions are incompatible with these,
write to the author to ask for permission. For software which is
copyrighted by the Free Software Foundation, write to the Free
Software Foundation; we sometimes make exceptions for this. Our
decision will be guided by the two goals of preserving the free status
of all derivatives of our free software and of promoting the sharing
and reuse of software generally.
<P><STRONG>NO WARRANTY</STRONG>
<P><STRONG>15.</STRONG>
BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
<P><STRONG>16.</STRONG>
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
DAMAGES.
<H4>END OF TERMS AND CONDITIONS</H4>
<H3>END OF TERMS AND CONDITIONS</H3>
</BODY>
</HTML>
+5 -40
Ver Arquivo
@@ -28,14 +28,11 @@
AR = @AR@
AWK = @AWK@
CC = @LIBTOOL@ @CC@
CC = @CC@
CHMOD = @CHMOD@
CHOWN = @CHOWN@
CP = @CP@
CXX = @LIBTOOL@ @CXX@
DSO = @DSO@
HTMLDOC = @HTMLDOC@
LIBTOOL = @LIBTOOL@
LN = /bin/ln -sf
MKDIR = @MKDIR@ -p
MV = @MV@
@@ -45,17 +42,6 @@ RM = @RM@ -f
SED = @SED@
SHELL = /bin/sh
#
# Installation programs...
#
INSTALL_BIN = $(LIBTOOL) $(CP)
INSTALL_DATA = $(CP)
INSTALL_LIB = $(LIBTOOL) $(CP)
INSTALL_MAN = $(CP)
INSTALL_SCRIPT = $(CP)
INSTALL_SYSV = @INSTALL_SYSV@
#
# Libraries...
#
@@ -63,7 +49,6 @@ INSTALL_SYSV = @INSTALL_SYSV@
LIBCUPS = @LIBCUPS@
LIBCUPSIMAGE = @LIBCUPSIMAGE@
LIBJPEG = @LIBJPEG@
LIBMALLOC = @LIBMALLOC@
LIBPNG = @LIBPNG@
LIBTIFF = @LIBTIFF@
LIBZ = @LIBZ@
@@ -78,17 +63,13 @@ LIBZ = @LIBZ@
ARFLAGS = crvs
CFLAGS = @CFLAGS@ $(OPTIM) -I.. $(OPTIONS)
CXXFLAGS = @CXXFLAGS@ $(OPTIM) -I.. $(OPTIONS)
DSOLIBS = @DSOLIBS@
IMGLIBS = @IMGLIBS@ -lm
LDFLAGS = @LDFLAGS@ $(OPTIM)
LINKCUPS = @LINKCUPS@
LINKCUPSIMAGE = @LINKCUPSIMAGE@
LIBS = $(LINKCUPS) $(NETLIBS) @LIBS@
LIBS = -L../cups -lcups $(NETLIBS) @LIBS@
NETLIBS = @NETLIBS@
OPTIM = @OPTIM@
OPTIONS =
SSLLIBS = @SSLLIBS@
#
# Directories...
@@ -121,46 +102,30 @@ top_srcdir = @top_srcdir@
BINDIR = @bindir@
DATADIR = @CUPS_DATADIR@
DOCDIR = @CUPS_DOCROOT@
DOCDIR = @CUPS_DOCDIR@
INCLUDEDIR = $(includedir)
INITDIR = @INITDIR@
INITDDIR = @INITDDIR@
LIBDIR = $(libdir)
LOCALEDIR = @CUPS_LOCALEDIR@
LOGDIR = @CUPS_LOGDIR@
MANDIR = @mandir@
PAMDIR = @PAMDIR@
REQUESTS = @CUPS_REQUESTS@
SBINDIR = @sbindir@
SERVERBIN = @CUPS_SERVERBIN@
SERVERROOT = @CUPS_SERVERROOT@
CAT1EXT = @CAT1EXT@
CAT5EXT = @CAT5EXT@
CAT8EXT = @CAT8EXT@
#
# Rules...
#
.SILENT:
.SUFFIXES: .a .c .cxx .h .man .o .0 .1 .5 .8 .z
.SUFFIXES: .a .c .h .man .o .1 .5 .8
.c.o:
echo Compiling $<...
$(CC) $(CFLAGS) -c $<
.cxx.o:
echo Compiling $<...
$(CXX) $(CXXFLAGS) -c $<
.man.0 .man.1 .man.5 .man.8:
.man.1 .man.5 .man.8:
echo Formatting $<...
$(RM) $@
$(NROFF) -man $< >$@
.man.z:
echo Formatting $<...
$(RM) $@ t.z
$(NROFF) -man $< >t
pack -f t
$(MV) t.z $@
#
# End of "$Id$"
+16 -49
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Top-level Makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-2000 by Easy Software Products, all rights reserved.
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -28,7 +28,7 @@ include Makedefs
# Directories to make...
#
DIRS = cups backend berkeley cgi-bin filter man pdftops pstoraster \
DIRS = cups backend berkeley cgi-bin filter man pstoraster \
scheduler systemv
#
@@ -38,7 +38,7 @@ DIRS = cups backend berkeley cgi-bin filter man pdftops pstoraster \
all:
for dir in $(DIRS); do\
echo Making all in $$dir... ;\
(cd $$dir ; $(MAKE) $(MFLAGS)) || exit 1;\
(cd $$dir; $(MAKE) -$(MAKEFLAGS)) || break;\
done
#
@@ -48,7 +48,7 @@ all:
clean:
for dir in $(DIRS); do\
echo Cleaning in $$dir... ;\
(cd $$dir; $(MAKE) $(MFLAGS) clean) || exit 1;\
(cd $$dir; $(MAKE) -$(MAKEFLAGS) clean) || break;\
done
#
@@ -58,69 +58,36 @@ clean:
install:
for dir in $(DIRS); do\
echo Installing in $$dir... ;\
(cd $$dir; $(MAKE) $(MFLAGS) install) || exit 1;\
(cd $$dir; $(MAKE) -$(MAKEFLAGS) install) || break;\
done
echo Installing in conf...
(cd conf; $(MAKE) $(MFLAGS) install)
(cd conf; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in data...
(cd data; $(MAKE) $(MFLAGS) install)
(cd data; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in doc...
(cd doc; $(MAKE) $(MFLAGS) install)
(cd doc; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in fonts...
(cd fonts; $(MAKE) $(MFLAGS) install)
echo Installing in locale...
(cd locale; $(MAKE) $(MFLAGS) install)
(cd fonts; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in ppd...
(cd ppd; $(MAKE) $(MFLAGS) install)
(cd ppd; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in templates...
(cd templates; $(MAKE) $(MFLAGS) install)
echo Installing startup script...
if test "x$INITDIR" != "x"; then \
$(MKDIR) $(prefix)/$(INITDIR)/init.d; \
$(RM) $(prefix)/$(INITDIR)/init.d/cups; \
$(INSTALL_SCRIPT) cups.sh $(prefix)/$(INITDIR)/init.d/cups; \
$(CHMOD) ugo+rx $(prefix)/$(INITDIR)/init.d/cups; \
$(MKDIR) $(prefix)/$(INITDIR)/rc0.d; \
$(RM) $(prefix)/$(INITDIR)/rc0.d/K00cups; \
ln -s $(INITDDIR)/cups $(prefix)/$(INITDIR)/rc0.d/K00cups; \
$(MKDIR) $(prefix)/$(INITDIR)/rc3.d; \
$(RM) $(prefix)/$(INITDIR)/rc3.d/S99cups; \
ln -s $(INITDDIR)/cups $(prefix)/$(INITDIR)/rc3.d/S99cups; \
$(MKDIR) $(prefix)/$(INITDIR)/rc5.d; \
$(RM) $(prefix)/$(INITDIR)/rc5.d/S99cups; \
ln -s $(INITDDIR)/cups $(prefix)/$(INITDIR)/rc5.d/S99cups; \
fi
(cd templates; $(MAKE) -$(MAKEFLAGS) install)
#
# Make software distributions using EPM (http://www.easysw.com/epm)...
# Make a software distribution...
#
EPMFLAGS = -v \
BINDIR=$(BINDIR) DATADIR=$(DATADIR) \
DOCDIR=$(DOCDIR) INCLUDEDIR=$(INCLUDEDIR) \
LIBDIR=$(LIBDIR) LOCALEDIR=$(LOCALEDIR) \
LOGDIR=$(LOGDIR) MANDIR=$(MANDIR) \
PAMDIR=$(PAMDIR) REQUESTS=$(REQUESTS) \
SBINDIR=$(SBINDIR) SERVERBIN=$(SERVERBIN) \
SERVERROOT=$(SERVERROOT)
epm:
epm $(EPMFLAGS) cups
epm -v cups
rpm:
epm $(EPMFLAGS) -f rpm cups
epm -v -f rpm cups
deb:
epm $(EPMFLAGS) -f deb cups
depot:
epm $(EPMFLAGS) -f depot cups
pkg:
epm $(EPMFLAGS) -f pkg cups
epm -v -f deb cups
tardist:
epm $(EPMFLAGS) -f tardist cups
epm -v -f tardist cups
#
# End of "$Id$".
+122 -153
Ver Arquivo
@@ -1,59 +1,70 @@
README - CUPS v1.1.5 - 12/20/2000
README - CUPS v1.1b2 - 03/13/2000
---------------------------------
Looking for compile instructions? Read the file "INSTALL.txt"
instead...
************************************************************************
************************************************************************
**** ****
**** BETA SOFTWARE BETA SOFTWARE BETA SOFTWARE BETA SOFTWARE ****
**** ****
************************************************************************
************************************************************************
This is an official public beta release for the Common UNIX Printing
System. Since this is a beta release, we do not recommend that you
use this software on a production system. Instead, please use the
current 1.0.x release for your production systems.
Also, currently we are only providing source code for the beta releases.
As we approach a final production ("gold") release of CUPS 1.1 we will
provide binary distributions as well.
Please report all problems in the CUPS 1.1 beta releases to
"cups-beta@cups.org" or to the CUPS mailing list.
Thanks for using CUPS!
INTRODUCTION
CUPS provides a portable printing layer for UNIX(r)-based
operating systems. It has been developed by Easy Software
Products to promote a standard printing solution for all UNIX
vendors and users. CUPS provides the System V and Berkeley
command-line interfaces.
The Common UNIX Printing System provides a portable printing layer for
UNIX® operating systems. It has been developed by Easy Software
Products to promote a standard printing solution for all UNIX vendors
and users. CUPS provides the System V and Berkeley command-line
interfaces.
CUPS uses the Internet Printing Protocol ("IPP") as the basis
for managing print jobs and queues. The Line Printer Daemon
("LPD") Server Message Block ("SMB"), and AppSocket (a.k.a.
JetDirect) protocols are also supported with reduced
functionality. CUPS adds network printer browsing and
PostScript Printer Description ("PPD") based printing options to
support real-world printing under UNIX.
CUPS uses the Internet Printing Protocol (IETF-IPP) as the basis for
managing print jobs and queues. The Line Printer Daemon (LPD, RFC1179)
and AppSocket protocols are also supported with reduced functionality.
CUPS also includes a customized version of GNU Ghostscript
(currently based off GNU Ghostscript 5.50) and an image file RIP
that are used to support non-PostScript printers. Sample
drivers for HP and EPSON printers are included that use these
filters.
CUPS adds network printer browsing and PostScript Printer Description
("PPD")-based printing options to support real world applications under
UNIX.
Drivers for over 2300 printers are provided with our ESP Print
Pro software, available at:
CUPS also includes a customized version of GNU GhostScript (currently
based off GNU GhostScript 5.50) and an image file RIP that can be used
to support non-PostScript printers.
http://www.easysw.com/printpro
CUPS is licensed under the GNU General Public License and GNU
Library General Public License. Please contact Easy Software
Products for commercial support and "binary distribution"
rights.
CUPS is Copyright 1993-2000 by Easy Software Products, All Rights
Reserved. CUPS is currently licensed under the terms of the GNU
General Public License. Please see the license file for details.
SYSTEM REQUIREMENTS
Binary distributions require a minimum of 10MB of free disk
space. We do not recommend using CUPS on a workstation with less
than 32MB of RAM or a PC with less than 16MB of RAM.
Binary distributions require a minimum of 10MB of free disk space. We
do not recommend using CUPS on a workstation with less than 32MB of RAM
or a PC with less than 16MB of RAM.
If you are installing from source you'll need ANSI-compliant C
and C++ compilers and optionally one or more image file support
libraries. Complete source installation instructions can be
found in the file "INSTALL.txt".
If you are installing from source you'll need an ANSI C compiler and
optionally one or more image file support libraries. Complete source
installation instructions can be found in the CUPS System
Administrator's Manual in the files "doc/sam.html" or "doc/sam.pdf".
SOFTWARE REQUIREMENTS
The following operating system software is required to install
one of the binary distributions from Easy Software Products:
The following operating system software is required to install one of
the binary distributions from Easy Software Products:
- Digital UNIX (aka OSF1 aka Compaq Tru64 UNIX) 4.0 or higher
- HP-UX 10.20 or higher
@@ -62,106 +73,70 @@ one of the binary distributions from Easy Software Products:
- Solaris 2.5 or higher (SPARC or Intel)
INSTALLING "PORTABLE" CUPS DISTRIBUTIONS
INSTALLING CUPS
We are currently distributing "portable" CUPS binary
distributions in TAR format with installation and removal
scripts generated by our ESP Package Manager (EPM) software,
which is available from:
We are currently distributing CUPS binary distributions in TAR format
with installation and removal scripts generated by our ESP Package
Manager (EPM) software, which is available from:
http://www.easysw.com/epm
WARNING: Installing CUPS will overwrite your existing printing
system. Backup files are made by the installation script and
restored by the removal script, so if you experience problems
you should be able to remove the CUPS software to restore your
previous configuration. However, Easy Software Products makes
no warranty for this and will not be liable for any lost
revenues, etc.
WARNING: Installing CUPS will overwrite your existing printing system.
Backup files are made by the installation script and restored by the
removal script, so if you experience problems you should be able to
remove the CUPS software to restore your previous configuration.
However, Easy Software Products makes no warranty for this and will not
be liable for any lost revenues, etc.
To install the CUPS software you will need to be logged in as
root (doing an "su" is good enough). Once you are the root
user, run the installation script with:
To install the CUPS software you will need to be logged in as root
(doing an "su" is good enough). Once you are the root user, run the
installation script with:
./cups.install ENTER
After asking you a few yes/no questions the CUPS software will
be installed and the scheduler will be started automatically.
INSTALLING HOST-SPECIFIC (RPM, DEBIAN, ETC.) DISTRIBUTIONS
The host-specific distributions use the operating system
software installation tools. To install a host-specific
distribution please consult the CUPS Software Administrators
Manual or your operating system documentation.
After asking you a few yes/no questions the CUPS software will be
installed and the scheduler will be started automatically.
READING THE DOCUMENTATION
Once you have installed the software you can access the
documentation (and a bunch of other stuff) on-line at:
Once you have installed the software you can access the documentation
(and a bunch of other stuff) on-line at:
http://localhost:631
If you're having trouble getting that far, the documentation is
located in the "/usr/share/doc/cups" directory in the binary
distributions, and under the "doc" directory in the source
archives.
If you're having trouble getting that far, the documentation is located
in the "/usr/share/cups/doc" directory in the binary distributions, and
under the "doc" directory in the source archives.
Please read the documentation before asking questions.
GETTING SUPPORT AND OTHER RESOURCES
If you have problems, READ THE DOCUMENTATION FIRST!
You can subscribe to the CUPS mailing list by sending a message
containing "subscribe cups" to majordomo@cups.org. This list is
provided to discuss problems, questions, and improvements to the
CUPS software. New releases of CUPS are announced to this list
as well.
Commercial support (with a guaranteed response time) is
available from Easy Software Products. For more information
see:
http://www.easysw.com/cups
See the CUPS web site at "http://www.cups.org" for other site
links.
SETTING UP PRINTER QUEUES USING YOUR WEB BROWSER
CUPS 1.1 includes a new web-based administration tool that
allows you to manage printers, classes, and jobs on your
server. To access the printer administration tools open the
following URL in your browser:
CUPS 1.1 includes a new web-based administration tool that allows you
to manage printers, classes, and jobs on your server. To access the
printer administration tools open the following URL in your browser:
http://localhost:631/admin
You will be asked for the administration password (root or any
other user in the sys/system/root group on your system) and then
shown a menu of available functions.
You will be asked for the administration password (root or any other
user in the sys/system/root group on your system) and then shown a
menu of available functions.
DO NOT use the hostname for your machine - it will not work with
the default CUPS configuration. To enable administration access
on other addresses, consult the CUPS Software Administrators
Manual.
[note: adding, deleting, and modifying classes has not been implemented in
beta 2]
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 works best with PPD (PostScript Printer Description) files. In a
pinch you can also use System V style printer interface scripts.
Six sample PPD files are provided with this distribution that
utilize the PostScript and image file RIPs and the sample EPSON
and HP printer drivers. To add the sample DeskJet driver to the
system for a printer connected to the parallel port, use one of
the following commands:
Six sample PPD files are provided with this distribution that utilize
the PostScript and image file RIPs and the sample EPSON and HP printer
drivers. To add the sample DeskJet driver to the system for a printer
connected to the parallel port, use one of the following commands:
Digital UNIX:
@@ -194,72 +169,71 @@ Similarly, for the other sample drivers you can use:
HP LaserJet Series laserjet.ppd
EPSON Stylus Color Series stcolor.ppd
EPSON Stylus Photo Series stphoto.ppd
EPSON 9-pin Series epson9.ppd
EPSON 24-pin Series epson24.ppd
EPSON 9-pin Series epson9.ppd [not in beta 2]
EPSON 24-pin Series epson24.ppd [not in beta 2]
These sample drivers provide basic printing capabilities, but
generally do not exercise the full potential of the printers or
CUPS. For commercial printer drivers check out our ESP Print
Pro software at:
These sample drivers provide basic printing capabilities, but generally
do not exercise the full potential of the printers or CUPS. For
commercial printer drivers check out our ESP Print Pro software at:
http://www.easysw.com/printpro
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 -omedia=A4 -oresolution=600dpi filename
lpr -omedia=A4 -oresolution=600dpi filename
CUPS recognizes many types of images files as well as PDF,
PostScript, HP-GL/2, and text files, so you can print those
files directly rather than through an application.
CUPS recognizes many types of images files as well as PostScript, HP-GL/2,
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:
If you have an application that generates output specifically for your
printer then you need to use the "-oraw" or "-l" options:
lp -oraw filename
lpr -l filename
This will prevent the filters from misinterpreting your print
file.
This will prevent the filters from misinterpreting your print file.
REPORTING PROBLEMS
If you have problems, please send an email to cups-support@cups.org.
Include your operating system and version, compiler and version, and
any errors or problems you've run into. If you are running a version
of Linux, be sure to provide the Linux distribution you have, too.
OTHER RESOURCES
See the CUPS web site at "http://www.cups.org" for other site links.
You can subscribe to the CUPS mailing list by sending a message
containing "subscribe cups" to majordomo@cups.org. This list is
provided to discuss problems, questions, and improvements to the CUPS
software. New releases of CUPS are announced to this list as well.
LEGAL STUFF
CUPS is Copyright 1993-2000 by Easy Software Products. CUPS,
the CUPS logo, and the Common UNIX Printing System are the
trademark property of Easy Software Products.
CUPS is Copyright 1993-2000 by Easy Software Products. CUPS, the CUPS
logo, and the Common UNIX Printing System are the trademark property of
Easy Software Products.
The MD5 Digest code is Copyright 1999 Aladdin Enterprises.
The PostScript RIP software (pstoraster) is based on the GNU
Ghostscript 5.50 core, Copyright 1986-1998 by Aladdin
Enterprises.
The PDF filter (pdftops) is based on the Xpdf 0.90 software,
Copyright 1996-1999 by Derek B. Noonburg.
This software is based in part on the work of the Independent
JPEG Group.
CUPS is provided under the terms 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 "LICENSE.html",
"LICENSE.txt", or "cups.license" files for more information.
For commercial licensing information, please contact:
CUPS is provided under the terms of the GNU General Public License
which is located in the files "LICENSE.html" and "LICENSE.txt" (or the
file "cups.license" for a binary distribution.) For commercial
licensing information, please contact:
Attn: CUPS Licensing Information
Easy Software Products
@@ -269,8 +243,3 @@ For commercial licensing information, please contact:
Voice: +1.301.373.9603
Email: cups-info@cups.org
WWW: http://www.cups.org
Note that commercial licensors may also require a license from
Artifex Software Inc. which handles commercial licensing of the
Ghostscript software, and from Derek B. Noonburg who developed
the Xpdf software used to print PDF files.
+2 -4
Ver Arquivo
@@ -41,7 +41,7 @@ all: $(TARGETS)
#
clean:
$(RM) $(OBJS) $(TARGETS) http
$(RM) $(OBJS) $(TARGETS)
#
@@ -50,9 +50,7 @@ clean:
install:
-$(MKDIR) $(SERVERBIN)/backend
$(CHMOD) ugo+rx $(SERVERBIN)
$(CHMOD) ugo+rx $(SERVERBIN)/backend
$(INSTALL_BIN) $(BACKENDS) $(SERVERBIN)/backend
$(CP) $(BACKENDS) $(SERVERBIN)/backend
$(RM) $(SERVERBIN)/backend/http
$(LN) ipp $(SERVERBIN)/backend/http
+120 -111
Ver Arquivo
@@ -38,7 +38,6 @@
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/string.h>
#include <signal.h>
/*
@@ -54,6 +53,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
int n, n2; /* Attribute values */
char *option, /* Name of option */
*val, /* Pointer to option value */
*s; /* Pointer into option value */
int num_options; /* Number of printer options */
cups_option_t *options; /* Printer options */
char method[255], /* Method in URI */
@@ -72,8 +75,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*response; /* IPP response */
ipp_attribute_t *job_id; /* job-id attribute */
ipp_attribute_t *copies_sup; /* copies-supported attribute */
ipp_attribute_t *charset_sup; /* charset-supported attribute */
const char *charset; /* Character set to use */
cups_lang_t *language; /* Default language */
struct stat fileinfo; /* File statistics */
size_t nbytes, /* Number of bytes written */
@@ -81,16 +82,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
char buffer[8192]; /* Output buffer */
int copies; /* Number of copies remaining */
const char *content_type; /* CONTENT_TYPE environment variable */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
int version; /* IPP version */
if (argc == 1)
{
char *s;
if ((s = strrchr(argv[0], '/')) != NULL)
s ++;
else
@@ -173,7 +168,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fprintf(stderr, "INFO: Connecting to %s...\n", hostname);
if ((http = httpConnect(hostname, port)) == NULL)
{
if (errno == ECONNREFUSED)
{
fprintf(stderr, "INFO: Network host \'%s\' is busy; will retry in 30 seconds...",
@@ -185,7 +179,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
perror("ERROR: Unable to connect to IPP host");
sleep(30);
}
}
}
while (http == NULL);
@@ -203,10 +196,8 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* don't support the copies attribute...
*/
language = cupsLangDefault();
charset_sup = NULL;
copies_sup = NULL;
version = 1;
language = cupsLangDefault();
copies_sup = NULL;
do
{
@@ -215,16 +206,15 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
request = ippNew();
request->request.op.version[1] = version;
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, "utf-8");
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language != NULL ? language->language : "en");
language != NULL ? language->language : "C");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
@@ -248,7 +238,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Do the request...
*/
for (response = NULL, ipp_status = IPP_ERROR;;)
for (;;)
{
/*
* POST the request, retrying as needed...
@@ -291,7 +281,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
ippRead(http, response);
ipp_status = response->request.status.status_code;
if (ipp_status > IPP_OK_CONFLICT)
{
if (ipp_status == IPP_PRINTER_BUSY ||
@@ -300,20 +290,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fputs("INFO: Printer busy; will retry in 10 seconds...\n", stderr);
sleep(10);
}
else if (ipp_status == IPP_BAD_REQUEST && version == 1)
{
/*
* Switch to IPP/1.0...
*/
fputs("INFO: Printer does not support IPP/1.1, trying IPP/1.0...\n", stderr);
version = 0;
}
else
{
fprintf(stderr, "ERROR: Printer will not accept print file (%x)!\n",
ipp_status);
fprintf(stderr, "ERROR: %s\n", ippErrorString(ipp_status));
status = HTTP_ERROR;
}
}
@@ -329,13 +309,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
copies_sup = NULL; /* No */
}
charset_sup = ippFindAttribute(response, "charset-supported",
IPP_TAG_CHARSET);
ippDelete(response);
}
else
{
response = NULL;
if (status == HTTP_ERROR)
{
fprintf(stderr, "WARNING: Did not receive the IPP response (%d)\n",
@@ -344,11 +321,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
ipp_status = IPP_PRINTER_BUSY;
}
else
{
fprintf(stderr, "ERROR: Validate request was not accepted (%d)!\n",
status);
ipp_status = IPP_FORBIDDEN;
}
fprintf(stderr, "ERROR: Validate request was not accepted (%d)!\n", status);
}
httpFlush(http);
@@ -365,29 +338,9 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
return (1);
}
else if (ipp_status > IPP_OK_CONFLICT)
httpReconnect(http);
}
while (ipp_status > IPP_OK_CONFLICT);
/*
* Now that we are "connected" to the port, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, SIG_IGN);
#endif /* HAVE_SIGSET */
/*
* See if the printer supports multiple copies...
*/
@@ -397,46 +350,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
else
copies = atoi(argv[4]);
/*
* Figure out the character set to use...
*/
charset = language ? cupsLangEncoding(language) : "us-ascii";
if (charset_sup)
{
/*
* See if IPP server supports the requested character set...
*/
for (i = 0; i < charset_sup->num_values; i ++)
if (strcasecmp(charset, charset_sup->values[i].string.text) == 0)
break;
/*
* If not, choose us-ascii or utf-8...
*/
if (i >= charset_sup->num_values)
{
/*
* See if us-ascii is supported...
*/
for (i = 0; i < charset_sup->num_values; i ++)
if (strcasecmp("us-ascii", charset_sup->values[i].string.text) == 0)
break;
if (i < charset_sup->num_values)
charset = "us-ascii";
else
charset = "utf-8";
}
}
if (response)
ippDelete(response);
/*
* Then issue the print-job request...
*/
@@ -448,16 +361,15 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
request = ippNew();
request->request.op.version[1] = version;
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, charset);
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language != NULL ? language->language : "en");
language != NULL ? language->language : "C");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
@@ -481,16 +393,116 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
options = NULL;
num_options = cupsParseOptions(argv[5], 0, &options);
if ((content_type = getenv("CONTENT_TYPE")) != NULL &&
strcasecmp(content_type, "application/vnd.cups-raw") == 0)
num_options = cupsAddOption("raw", "", num_options, &options);
cupsEncodeOptions(request, num_options, options);
cupsFreeOptions(num_options, options);
if (cupsGetOption("raw", num_options, options) ||
((content_type = getenv("CONTENT_TYPE")) != NULL &&
strcasecmp(content_type, "application/vnd.cups-raw") == 0))
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
if (copies_sup)
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", atoi(argv[4]));
for (i = 0; i < num_options; i ++)
{
/*
* Skip the "raw" option - handled above...
*/
if (strcasecmp(options[i].name, "raw") == 0)
continue;
/*
* See what the option value is; for compatibility with older interface
* scripts, we have to support single-argument options as well as
* option=value, option=low-high, and option=MxN.
*/
option = options[i].name;
val = options[i].value;
if (*val == '\0')
val = NULL;
if (val != NULL)
{
if (strcasecmp(val, "true") == 0 ||
strcasecmp(val, "on") == 0 ||
strcasecmp(val, "yes") == 0)
{
/*
* Boolean value - true...
*/
n = 1;
val = "";
}
else if (strcasecmp(val, "false") == 0 ||
strcasecmp(val, "off") == 0 ||
strcasecmp(val, "no") == 0)
{
/*
* Boolean value - false...
*/
n = 0;
val = "";
}
n = strtol(val, &s, 0);
}
else
{
if (strncasecmp(option, "no", 2) == 0)
{
option += 2;
n = 0;
}
else
n = 1;
s = "";
}
if (*s != '\0' && *s != '-' && (*s != 'x' || s == val))
/*
* String value(s)...
*/
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
else if (val != NULL)
{
/*
* Numeric value, range, or resolution...
*/
if (*s == '-')
{
n2 = strtol(s + 1, NULL, 0);
ippAddRange(request, IPP_TAG_JOB, option, n, n2);
}
else if (*s == 'x')
{
n2 = strtol(s + 1, &s, 0);
if (strcasecmp(s, "dpc") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_CM, n, n2);
else if (strcasecmp(s, "dpi") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_INCH, n, n2);
else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
}
else
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, option, n);
}
else
/*
* Boolean value...
*/
ippAddBoolean(request, IPP_TAG_JOB, option, (char)n);
}
/*
* Now fill in the HTTP request stuff...
*/
@@ -584,11 +596,8 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
sleep(10);
}
else
{
fprintf(stderr, "ERROR: Print file was not accepted (%04x)!\n",
response->request.status.status_code);
fprintf(stderr, "ERROR: %s\n", ippErrorString(ipp_status));
}
}
else if ((job_id = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) == NULL)
fputs("INFO: Print file accepted - job ID unknown.\n", stderr);
+9 -131
Ver Arquivo
@@ -40,7 +40,6 @@
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#if defined(WIN32) || defined(__EMX__)
# include <winsock.h>
@@ -60,8 +59,7 @@ extern int rresvport(int *port); /* Hello? No prototype for this... */
static int lpd_command(int lpd_fd, char *format, ...);
static int lpd_queue(char *hostname, char *printer, char *filename,
char *user, char *title, int copies, int banner,
int format);
char *user, int copies);
/*
@@ -80,15 +78,9 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
hostname[1024], /* Hostname */
username[255], /* Username info (not used) */
resource[1024], /* Resource info (printer name) */
*options, /* Pointer to options */
name[255], /* Name of option */
value[255], /* Value of option */
*ptr, /* Pointer into name or value */
filename[1024]; /* File to print */
int port; /* Port number (not used) */
int status; /* Status of LPD job */
int banner; /* Print banner page? */
int format; /* Print format */
if (argc == 1)
@@ -149,83 +141,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
httpSeparate(argv[0], method, username, hostname, &port, resource);
/*
* See if there are any options...
*/
banner = 0;
format = 'l';
if ((options = strchr(resource, '?')) != NULL)
{
/*
* Yup, terminate the device name string and move to the first
* character of the options...
*/
*options++ = '\0';
/*
* Parse options...
*/
while (*options)
{
/*
* Get the name...
*/
for (ptr = name; *options && *options != '=';)
*ptr++ = *options++;
*ptr = '\0';
if (*options == '=')
{
/*
* Get the value...
*/
options ++;
for (ptr = value; *options && *options != '+';)
*ptr++ = *options++;
*ptr = '\0';
if (*options == '+')
options ++;
}
else
value[0] = '\0';
/*
* Process the option...
*/
if (strcasecmp(name, "banner") == 0)
{
/*
* Set the banner...
*/
banner = !value[0] ||
strcasecmp(value, "on") == 0 ||
strcasecmp(value, "yes") == 0 ||
strcasecmp(value, "true") == 0;
}
else if (strcasecmp(name, "format") == 0 && value[0])
{
/*
* Set output format...
*/
if (strchr("cdfglnoprtv", value[0]) != NULL)
format = value[0];
else
fprintf(stderr, "ERROR: Unknown format character \"%c\"\n", value[0]);
}
}
}
/*
* Queue the job...
*/
@@ -233,16 +148,14 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
if (argc > 6)
{
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, argv[3] /* title */,
atoi(argv[4]) /* copies */, banner, format);
argv[2] /* user */, atoi(argv[4]) /* copies */);
if (!status)
fprintf(stderr, "PAGE: 1 %d\n", atoi(argv[4]));
}
else
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, argv[3] /* title */, 1,
banner, format);
argv[2] /* user */, 1);
/*
* Remove the temporary file if necessary...
@@ -282,14 +195,12 @@ lpd_command(int fd, /* I - Socket connection to LPD host */
bytes = vsnprintf(buf, sizeof(buf), format, ap);
va_end(ap);
fprintf(stderr, "DEBUG: lpd_command %2.2x %s", buf[0], buf + 1);
fprintf(stderr, "DEBUG: lpd_command %02.2x %s", buf[0], buf + 1);
/*
* Send the command...
*/
fprintf(stderr, "DEBUG: Sending command string (%d bytes)...\n", bytes);
if (send(fd, buf, bytes, 0) < bytes)
return (-1);
@@ -297,8 +208,6 @@ lpd_command(int fd, /* I - Socket connection to LPD host */
* Read back the status from the command and return it...
*/
fprintf(stderr, "DEBUG: Reading command status...\n");
if (recv(fd, &status, 1, 0) < 1)
return (-1);
@@ -317,10 +226,7 @@ lpd_queue(char *hostname, /* I - Host to connect to */
char *printer, /* I - Printer/queue name */
char *filename, /* I - File to print */
char *user, /* I - Requesting user */
char *title, /* I - Job title */
int copies, /* I - Number of copies */
int banner, /* I - Print LPD banner? */
int format) /* I - Format specifier */
int copies) /* I - Number of copies */
{
FILE *fp; /* Job file */
char localhost[255]; /* Local host name */
@@ -336,9 +242,6 @@ lpd_queue(char *hostname, /* I - Host to connect to */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total bytes written */
char buffer[8192]; /* Output buffer */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
/*
@@ -397,26 +300,6 @@ lpd_queue(char *hostname, /* I - Host to connect to */
break;
}
fprintf(stderr, "INFO: Connected on port %d...\n", port);
/*
* Now that we are "connected" to the port, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, SIG_IGN);
#endif /* HAVE_SIGSET */
/*
* Next, open the print file and figure out its size...
*/
@@ -443,25 +326,20 @@ lpd_queue(char *hostname, /* I - Host to connect to */
gethostname(localhost, sizeof(localhost));
localhost[31] = '\0'; /* RFC 1179, Section 7.2 - host name < 32 chars */
snprintf(control, sizeof(control), "H%s\nP%s\nJ%s\n", localhost, user, title);
snprintf(control, sizeof(control), "H%s\nP%s\n", localhost, user);
cptr = control + strlen(control);
if (banner)
{
snprintf(cptr, sizeof(control) - (cptr - control), "L%s\n", user);
cptr += strlen(cptr);
}
while (copies > 0)
{
snprintf(cptr, sizeof(control) - (cptr - control), "%cdfA%03d%s\n", format,
snprintf(cptr, sizeof(control) - (cptr - control), "ldfA%03.3d%s\n",
getpid() % 1000, localhost);
cptr += strlen(cptr);
copies --;
}
snprintf(cptr, sizeof(control) - (cptr - control),
"UdfA%03d%s\nNdfA%03d%s\n",
"UdfA%03.3d%s\nNdfA%03.3d%s\n",
getpid() % 1000, localhost,
getpid() % 1000, localhost);
+31 -106
Ver Arquivo
@@ -34,9 +34,7 @@
#include <cups/cups.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <cups/string.h>
#include <signal.h>
#if defined(WIN32) || defined(__EMX__)
# include <io.h>
@@ -86,15 +84,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
FILE *fp; /* Print file */
int copies; /* Number of copies to print */
int fd; /* Parallel device */
int wbytes; /* Number of bytes written */
size_t nbytes, /* Number of bytes read */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total number of bytes written */
char buffer[8192], /* Output buffer */
*bufptr; /* Pointer into buffer */
char buffer[8192]; /* Output buffer */
struct termios opts; /* Parallel port options */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
if (argc == 1)
@@ -157,23 +150,11 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Open the parallel port device...
*/
do
if ((fd = open(resource, O_WRONLY)) == -1)
{
if ((fd = open(resource, O_WRONLY | O_EXCL)) == -1)
{
if (errno == EBUSY)
{
fputs("INFO: Parallel port busy; will retry in 30 seconds...\n", stderr);
sleep(30);
}
else
{
perror("ERROR: Unable to open parallel port device file");
return (1);
}
}
perror("ERROR: Unable to open parallel port device file");
return (1);
}
while (fd < 0);
/*
* Set any options provided...
@@ -187,24 +168,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
tcsetattr(fd, TCSANOW, &opts);
/*
* Now that we are "connected" to the port, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, SIG_IGN);
#endif /* HAVE_SIGSET */
/*
* Finally, send the print file...
*/
@@ -226,24 +189,13 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Write the print data to the printer...
*/
tbytes += nbytes;
bufptr = buffer;
while (nbytes > 0)
if (write(fd, buffer, nbytes) < nbytes)
{
if ((wbytes = write(fd, bufptr, nbytes)) < 0)
if (errno == ENOTTY)
wbytes = write(fd, bufptr, nbytes);
if (wbytes < 0)
{
perror("ERROR: Unable to send print file to printer");
break;
}
nbytes -= wbytes;
bufptr += wbytes;
perror("ERROR: Unable to send print file to printer");
break;
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
@@ -269,16 +221,13 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
void
list_devices(void)
{
#if defined(__hpux) || defined(__sgi) || defined(__sun)
static char *funky_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
/* Funky hex numbering used for some devices */
#endif /* __hpux || __sgi || __sun */
#ifdef __linux
int i; /* Looping var */
int fd; /* File descriptor */
char device[255], /* Device filename */
probefile[255]; /* Probe filename */
char device[255]; /* Device filename */
FILE *probe; /* /proc/parport/n/autoprobe file */
char line[1024], /* Line from file */
*delim, /* Delimiter in file */
@@ -288,41 +237,9 @@ list_devices(void)
for (i = 0; i < 4; i ++)
{
/*
* First open the device to make sure the driver module is loaded...
*/
sprintf(device, "/dev/lp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
close(fd);
else
sprintf(device, "/proc/parport/%d/autoprobe", i);
if ((probe = fopen(device, "r")) != NULL)
{
sprintf(device, "/dev/par%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
close(fd);
}
/*
* Then try looking at the probe file...
*/
sprintf(probefile, "/proc/parport/%d/autoprobe", i);
if ((probe = fopen(probefile, "r")) == NULL)
{
/*
* Linux 2.4 kernel has different path...
*/
sprintf(probefile, "/proc/sys/dev/parport/parport%d/autoprobe", i);
probe = fopen(probefile, "r");
}
if (probe != NULL)
{
/*
* Found a probe file!
*/
memset(make, 0, sizeof(make));
memset(model, 0, sizeof(model));
strcpy(model, "Unknown");
@@ -359,13 +276,23 @@ list_devices(void)
printf("direct parallel:/dev/lp%d \"%s\" \"Parallel Port #%d\"\n",
i, model, i + 1);
}
else if (fd >= 0)
else
{
/*
* No probe file, but we know the port is there...
*/
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
sprintf(device, "/dev/lp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
else
{
sprintf(device, "/dev/par%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
}
}
}
#elif defined(__sgi)
@@ -522,8 +449,7 @@ list_devices(void)
{
sprintf(device, "/dev/c%dt%dd0_lp", i, j);
if (access(device, 0) == 0)
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d,%d\"\n",
device, i, j);
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d,%d\"\n", i, j);
}
/*
@@ -565,9 +491,8 @@ list_devices(void)
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
}
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
#elif defined(FreeBSD) || defined(OpenBSD) || defined(NetBSD)
int i; /* Looping var */
int fd; /* File descriptor */
char device[255]; /* Device filename */
+20 -173
Ver Arquivo
@@ -23,8 +23,7 @@
*
* Contents:
*
* main() - Send a file to the printer or server.
* list_devices() - List all serial devices.
* main() - Send a file to the printer or server.
*/
/*
@@ -34,13 +33,7 @@
#include <cups/cups.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <cups/string.h>
#include <signal.h>
#ifdef __hpux
# include <sys/modem.h>
#endif /* __hpux */
#if defined(WIN32) || defined(__EMX__)
# include <io.h>
@@ -48,9 +41,6 @@
# include <unistd.h>
# include <fcntl.h>
# include <termios.h>
# ifdef __linux
# include <sys/ioctl.h>
# endif /* __linux */
#endif /* WIN32 || __EMX__ */
#ifdef __sgi
@@ -64,14 +54,6 @@
# endif /* !INV_EPP_ECP_PLP */
#endif /* __sgi */
#ifndef CRTSCTS
# ifdef CNEW_RTSCTS
# define CRTSCTS CNEW_RTSCTS
# else
# define CRTSCTS 0
# endif /* CNEW_RTSCTS */
#endif /* !CRTSCTS */
/*
* Local functions...
@@ -104,17 +86,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
FILE *fp; /* Print file */
int copies; /* Number of copies to print */
int fd; /* Parallel device */
int wbytes; /* Number of bytes written */
size_t nbytes, /* Number of bytes read */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total number of bytes written */
int dtrdsr; /* Do dtr/dsr flow control? */
int bufsize; /* Size of output buffer for writes */
char buffer[8192], /* Output buffer */
*bufptr; /* Pointer into buffer */
char buffer[8192]; /* Output buffer */
struct termios opts; /* Parallel port options */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
if (argc == 1)
@@ -177,23 +152,11 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Open the serial port device...
*/
do
if ((fd = open(resource, O_WRONLY | O_NOCTTY)) == -1)
{
if ((fd = open(resource, O_WRONLY | O_NOCTTY | O_EXCL)) == -1)
{
if (errno == EBUSY)
{
fputs("INFO: Serial port busy; will retry in 30 seconds...\n", stderr);
sleep(30);
}
else
{
perror("ERROR: Unable to open serial port device file");
return (1);
}
}
perror("ERROR: Unable to open serial port device file");
return (1);
}
while (fd < 0);
/*
* Set any options provided...
@@ -203,9 +166,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
opts.c_lflag &= ~(ICANON | ECHO | ISIG); /* Raw mode */
bufsize = 480; /* 9600 baud / 10 bits/char / 2Hz */
dtrdsr = 0; /* No dtr/dsr flow control */
if (options != NULL)
while (*options)
{
@@ -245,8 +205,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Set the baud rate...
*/
bufsize = atoi(value) / 20;
#if B19200 == 19200
cfsetispeed(&opts, atoi(value));
cfsetospeed(&opts, atoi(value));
@@ -277,18 +235,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
cfsetispeed(&opts, B38400);
cfsetospeed(&opts, B38400);
break;
#ifdef B57600
case 57600 :
cfsetispeed(&opts, B57600);
cfsetospeed(&opts, B57600);
break;
#endif /* B57600 */
#ifdef B115200
case 115200 :
cfsetispeed(&opts, B115200);
cfsetospeed(&opts, B115200);
break;
#endif /* B115200 */
default :
fprintf(stderr, "WARNING: Unsupported baud rate %s!\n", value);
break;
@@ -335,65 +281,14 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
else if (strcasecmp(value, "none") == 0)
opts.c_cflag &= ~PARENB;
}
else if (strcasecmp(name, "flow") == 0)
{
/*
* Set flow control...
*/
if (strcasecmp(value, "none") == 0)
{
opts.c_iflag &= ~(IXON | IXOFF | IXANY);
opts.c_cflag &= ~CRTSCTS;
}
else if (strcasecmp(value, "soft") == 0)
{
opts.c_iflag |= IXON | IXOFF | IXANY;
opts.c_cflag &= ~CRTSCTS;
}
else if (strcasecmp(value, "hard") == 0 ||
strcasecmp(value, "rtscts") == 0)
{
opts.c_iflag &= ~(IXON | IXOFF | IXANY);
opts.c_cflag |= CRTSCTS;
}
else if (strcasecmp(value, "dtrdsr") == 0)
{
opts.c_iflag &= ~(IXON | IXOFF | IXANY);
opts.c_cflag &= ~CRTSCTS;
dtrdsr = 1;
}
}
}
tcsetattr(fd, TCSANOW, &opts);
/*
* Now that we are "connected" to the port, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, SIG_IGN);
#endif /* HAVE_SIGSET */
/*
* Finally, send the print file...
*/
if (bufsize > sizeof(buffer))
bufsize = sizeof(buffer);
while (copies > 0)
{
copies --;
@@ -404,61 +299,20 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
rewind(fp);
}
if (dtrdsr)
{
/*
* Check the port and sleep until DSR is set...
*/
int status;
if (!ioctl(fd, TIOCMGET, &status))
if (!(status & TIOCM_DSR))
{
/*
* Wait for DSR to go high...
*/
fputs("DEBUG: DSR is low; waiting for device...\n", stderr);
do
{
sleep(1);
if (ioctl(fd, TIOCMGET, &status))
break;
}
while (!(status & TIOCM_DSR));
fputs("DEBUG: DSR is high; writing to device...\n", stderr);
}
}
tbytes = 0;
while ((nbytes = fread(buffer, 1, bufsize, fp)) > 0)
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
/*
* Write the print data to the printer...
*/
tbytes += nbytes;
bufptr = buffer;
while (nbytes > 0)
if (write(fd, buffer, nbytes) < nbytes)
{
if ((wbytes = write(fd, bufptr, nbytes)) < 0)
if (errno == ENOTTY)
wbytes = write(fd, bufptr, nbytes);
if (wbytes < 0)
{
perror("ERROR: Unable to send print file to printer");
break;
}
nbytes -= wbytes;
bufptr += wbytes;
perror("ERROR: Unable to send print file to printer");
break;
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
@@ -484,10 +338,8 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
void
list_devices(void)
{
#if defined(__hpux) || defined(__sgi) || defined(__sun) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
static char *funky_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
/* Funky hex numbering used for some devices */
#endif /* __hpux || __sgi || __sun || __FreeBSD__ || __NetBSD__ || __OpenBSD__ */
#ifdef __linux
int i; /* Looping var */
@@ -495,10 +347,10 @@ list_devices(void)
char device[255]; /* Device filename */
for (i = 0; i < 100; i ++)
for (i = 0; i < 4; i ++)
{
sprintf(device, "/dev/ttyS%d", i);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
@@ -616,13 +468,8 @@ list_devices(void)
{
sprintf(device, "/dev/cua/%c", 'a' + i);
if (access(device, 0) == 0)
#ifdef B115200
printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
#else
printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
#endif /* B115200 */
}
/*
@@ -718,7 +565,7 @@ list_devices(void)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
}
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
#elif defined(FreeBSD) || defined(OpenBSD) || defined(NetBSD)
int i, j; /* Looping vars */
int fd; /* File descriptor */
char device[255]; /* Device filename */
@@ -731,7 +578,7 @@ list_devices(void)
for (i = 0; i < 32; i ++)
{
sprintf(device, "/dev/ttyd%c", funky_hex[i]);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Standard Serial Port #%d\"\n",
@@ -747,7 +594,7 @@ list_devices(void)
for (j = 0; j < 32; j ++)
{
sprintf(device, "/dev/ttyc%d%c", i, funky_hex[j]);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Port #%d\"\n",
@@ -763,7 +610,7 @@ list_devices(void)
for (j = 0; j < 32; j ++)
{
sprintf(device, "/dev/ttyD%d%c", i, funky_hex[j]);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Digiboard #%d Serial Port #%d\"\n",
@@ -778,7 +625,7 @@ list_devices(void)
for (i = 0; i < 32; i ++)
{
sprintf(device, "/dev/ttyE%c", funky_hex[i]);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Stallion Serial Port #%d\"\n",
@@ -793,7 +640,7 @@ list_devices(void)
for (i = 0; i < 128; i ++)
{
sprintf(device, "/dev/ttyA%d", i + 1);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"SX Serial Port #%d\"\n",
+1 -23
Ver Arquivo
@@ -38,7 +38,6 @@
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#if defined(WIN32) || defined(__EMX__)
# include <winsock.h>
@@ -80,9 +79,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*bufptr; /* Pointer into buffer */
struct timeval timeout; /* Timeout for select() */
fd_set input; /* Input set for select() */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
if (argc == 1)
@@ -137,7 +133,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
if ((hostaddr = gethostbyname(hostname)) == NULL)
{
fprintf(stderr, "ERROR: Unable to locate printer \'%s\' - %s\n",
fprintf(stderr, "ERROR: Unable to locate printer \'%s\' - %s",
hostname, strerror(errno));
return (1);
}
@@ -182,24 +178,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
break;
}
/*
* Now that we are "connected" to the port, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, SIG_IGN);
#endif /* HAVE_SIGSET */
/*
* Finally, send the print file...
*/
+15 -125
Ver Arquivo
@@ -34,9 +34,7 @@
#include <cups/cups.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <cups/string.h>
#include <signal.h>
#if defined(WIN32) || defined(__EMX__)
# include <io.h>
@@ -75,15 +73,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
FILE *fp; /* Print file */
int copies; /* Number of copies to print */
int fd; /* Parallel device */
int wbytes; /* Number of bytes written */
size_t nbytes, /* Number of bytes read */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total number of bytes written */
char buffer[8192], /* Output buffer */
*bufptr; /* Pointer into buffer */
char buffer[8192]; /* Output buffer */
struct termios opts; /* Parallel port options */
#if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
struct sigaction action; /* Actions for POSIX signals */
#endif /* HAVE_SIGACTION && !HAVE_SIGSET */
if (argc == 1)
@@ -146,23 +139,11 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Open the USB port device...
*/
do
if ((fd = open(resource, O_WRONLY)) == -1)
{
if ((fd = open(resource, O_WRONLY | O_EXCL)) == -1)
{
if (errno == EBUSY)
{
fputs("INFO: USB port busy; will retry in 30 seconds...\n", stderr);
sleep(30);
}
else
{
perror("ERROR: Unable to open USB port device file");
return (1);
}
}
perror("ERROR: Unable to open USB port device file");
return (1);
}
while (fd < 0);
/*
* Set any options provided...
@@ -176,24 +157,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
tcsetattr(fd, TCSANOW, &opts);
/*
* Now that we are "connected" to the port, ignore SIGTERM so that we
* can finish out any page data the driver sends (e.g. to eject the
* current page...
*/
#ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
sigset(SIGTERM, SIG_IGN);
#elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
action.sa_handler = SIG_IGN;
sigaction(SIGTERM, &action, NULL);
#else
signal(SIGTERM, SIG_IGN);
#endif /* HAVE_SIGSET */
/*
* Finally, send the print file...
*/
@@ -215,24 +178,13 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Write the print data to the printer...
*/
tbytes += nbytes;
bufptr = buffer;
while (nbytes > 0)
if (write(fd, buffer, nbytes) < nbytes)
{
if ((wbytes = write(fd, bufptr, nbytes)) < 0)
if (errno == ENOTTY)
wbytes = write(fd, bufptr, nbytes);
if (wbytes < 0)
{
perror("ERROR: Unable to send print file to printer");
break;
}
nbytes -= wbytes;
bufptr += wbytes;
perror("ERROR: Unable to send print file to printer");
break;
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
@@ -262,35 +214,15 @@ list_devices(void)
int i; /* Looping var */
int fd; /* File descriptor */
char device[255]; /* Device filename */
FILE *probe; /* /proc/bus/usb/devices file */
FILE *probe; /* /proc/parport/n/autoprobe file */
char line[1024], /* Line from file */
*delim, /* Delimiter in file */
make[IPP_MAX_NAME], /* Make from file */
model[IPP_MAX_NAME]; /* Model from file */
/*
* First try opening one of the USB devices to load the driver
* module as needed...
*/
if ((fd = open("/dev/usb/lp0", O_WRONLY)) >= 0)
close(fd); /* 2.3.x and 2.4.x */
else if ((fd = open("/dev/usb/usblp0", O_WRONLY)) >= 0)
close(fd); /* Mandrake 7.x */
else if ((fd = open("/dev/usblp0", O_WRONLY)) >= 0)
close(fd); /* 2.2.x */
/*
* Then look at the device list for the USB bus...
*/
if ((probe = fopen("/proc/bus/usb/devices", "r")) != NULL)
{
/*
* Scan the device list...
*/
i = 0;
memset(make, 0, sizeof(make));
@@ -325,25 +257,15 @@ list_devices(void)
strncpy(model, line + 12, sizeof(model) - 1);
}
else if (strncmp(line, "I:", 2) == 0 &&
(strstr(line, "Driver=printer") != NULL ||
strstr(line, "Driver=usblp") != NULL) &&
strstr(line, "Driver=printer") != NULL &&
make[0] && model[0])
{
/*
* We were processing a printer device; send the info out...
*/
sprintf(device, "/dev/usb/lp%d", i);
if (access(device, 0))
{
sprintf(device, "/dev/usb/usblp%d", i);
if (access(device, 0))
sprintf(device, "/dev/usblp%d", i);
}
printf("direct usb:%s \"%s %s\" \"USB Printer #%d\"\n",
device, make, model, i + 1);
printf("direct usb:/dev/usb/usblp%d \"%s %s\" \"USB Printer #%d\"\n",
i, make, model, i + 1);
i ++;
@@ -356,53 +278,21 @@ list_devices(void)
}
else
{
/*
* Just probe manually for USB devices...
*/
for (i = 0; i < 8; i ++)
{
sprintf(device, "/dev/usb/lp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct usb:%s \"Unknown\" \"USB Printer #%d\"\n", device, i + 1);
}
sprintf(device, "/dev/usb/usblp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct usb:%s \"Unknown\" \"USB Printer #%d\"\n", device, i + 1);
}
sprintf(device, "/dev/usblp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct usb:%s \"Unknown\" \"USB Printer #%d\"\n", device, i + 1);
}
}
}
#elif defined(__sgi)
#elif defined(__sun)
#elif defined(__hpux)
#elif defined(__osf)
#elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__)
int i; /* Looping var */
int fd; /* File descriptor */
char device[255]; /* Device filename */
for (i = 0; i < 3; i ++)
{
sprintf(device, "/dev/ulpt%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct usb:%s \"Unknown\" \"USB Port #%d\"\n", device, i + 1);
}
}
#elif defined(FreeBSD) || defined(OpenBSD) || defined(NetBSD)
#endif
}
+2 -12
Ver Arquivo
@@ -27,14 +27,12 @@ include ../Makedefs
TARGETS = lpc lpq lpr lprm
OBJS = lpc.o lpq.o lpr.o lprm.o
#
# Make all targets...
#
all: $(TARGETS)
#
# Clean all object files...
#
@@ -42,19 +40,15 @@ all: $(TARGETS)
clean:
$(RM) $(OBJS) $(TARGETS)
#
# Install all targets...
#
install:
-$(MKDIR) $(BINDIR)
$(CHMOD) ugo+rx $(BINDIR)
$(INSTALL_BIN) lpq lpr lprm $(BINDIR)
$(CP) lpq lpr lprm $(BINDIR)
-$(MKDIR) $(SBINDIR)
$(CHMOD) ugo+rx $(SBINDIR)
$(INSTALL_BIN) lpc $(SBINDIR)
$(CP) lpc $(SBINDIR)
#
# lpc
@@ -66,7 +60,6 @@ lpc: lpc.o ../cups/$(LIBCUPS)
lpc.o: ../cups/cups.h ../Makedefs
#
# lpq
#
@@ -77,7 +70,6 @@ lpq: lpq.o ../cups/$(LIBCUPS)
lpq.o: ../cups/cups.h ../Makedefs
#
# lpr
#
@@ -88,7 +80,6 @@ lpr: lpr.o ../cups/$(LIBCUPS)
lpr.o: ../cups/cups.h ../Makedefs
#
# lprm
#
@@ -99,7 +90,6 @@ lprm: lprm.o ../cups/$(LIBCUPS)
lprm.o: ../cups/cups.h ../Makedefs
#
# End of "$Id$".
#
+9 -24
Ver Arquivo
@@ -216,8 +216,7 @@ show_status(http_t *http, /* I - HTTP connection to server */
ipp_t *request, /* IPP Request */
*response, /* IPP Response */
*jobs; /* IPP Get Jobs response */
ipp_attribute_t *attr, /* Current attribute */
*jattr; /* Current job attribute */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Default language */
char *printer, /* Printer name */
*device; /* Device URI */
@@ -229,13 +228,6 @@ show_status(http_t *http, /* I - HTTP connection to server */
int match; /* Non-zero if this job matches */
char printer_uri[HTTP_MAX_URI];
/* Printer URI */
static const char *requested[] =
{ /* Requested attributes */
"printer-name",
"device-uri",
"printer-state",
"printer-is-accepting-jobs"
};
DEBUG_printf(("show_status(%08x, %08x)\n", http, dests));
@@ -258,15 +250,11 @@ show_status(http_t *http, /* I - HTTP connection to server */
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", sizeof(requested) / sizeof(requested[0]),
NULL, requested);
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
/*
* Do the request and get back a response...
@@ -424,16 +412,13 @@ show_status(http_t *http, /* I - HTTP connection to server */
snprintf(printer_uri, sizeof(printer_uri),
"ipp://localhost/printers/%s", printer);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", NULL, "job-id");
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
if ((jobs = cupsDoRequest(http, request, "/jobs/")) != NULL)
{
for (jattr = jobs->attrs; jattr != NULL; jattr = jattr->next)
if (jattr->name && strcmp(jattr->name, "job-id") == 0)
for (attr = jobs->attrs; attr != NULL; attr = attr->next)
if (strcmp(attr->name, "job-id") == 0)
jobcount ++;
ippDelete(jobs);
+14 -43
Ver Arquivo
@@ -23,9 +23,8 @@
*
* Contents:
*
* main() - Parse options and commands.
* show_jobs() - Show jobs.
* show_printer() - Show printer status.
* main() - Parse options and commands.
* show_jobs() - Show jobs.
*/
/*
@@ -65,13 +64,9 @@ main(int argc, /* I - Number of command-line arguments */
http_t *http; /* Connection to server */
const char *dest, /* Desired printer */
*user; /* Desired user */
char *instance; /* Printer instance */
int id, /* Desired job ID */
interval, /* Reporting interval */
longstatus; /* Show file details */
int num_dests; /* Number of destinations */
cups_dest_t *dests; /* Destinations */
/*
* Connect to the scheduler...
@@ -83,18 +78,12 @@ main(int argc, /* I - Number of command-line arguments */
* Check for command-line options...
*/
dest = NULL;
dest = cupsGetDefault();
user = NULL;
id = 0;
interval = 0;
longstatus = 0;
num_dests = cupsGetDests(&dests);
for (i = 0; i < num_dests; i ++)
if (dests[i].is_default)
dest = dests[i].name;
for (i = 1; i < argc; i ++)
if (argv[i][0] == '+')
interval = atoi(argv[i] + 1);
@@ -110,9 +99,6 @@ main(int argc, /* I - Number of command-line arguments */
i ++;
dest = argv[i];
}
if ((instance = strchr(dest, '/')) != NULL)
*instance = '\0';
break;
case 'l' : /* Long status */
@@ -121,8 +107,6 @@ main(int argc, /* I - Number of command-line arguments */
default :
fputs("Usage: lpq [-P dest] [-l] [+interval]\n", stderr);
httpClose(http);
cupsFreeDests(num_dests, dests);
return (1);
}
}
@@ -155,7 +139,6 @@ main(int argc, /* I - Number of command-line arguments */
* Close the connection to the server and return...
*/
cupsFreeDests(num_dests, dests);
httpClose(http);
return (0);
@@ -249,7 +232,7 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
{
snprintf(resource, sizeof(resource), "ipp://localhost/printers/%s", dest);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
NULL, resource);
}
@@ -266,7 +249,7 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
jobcount = 0;
if ((response = cupsDoRequest(http, request, "/")) != NULL)
if ((response = cupsDoRequest(http, request, "/jobs/")) != NULL)
{
if (response->request.status.status_code > IPP_OK_CONFLICT)
{
@@ -361,12 +344,9 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
continue;
}
/**** TODO - support OSF/1 and Berkeley formats ****/
if (!longstatus && jobcount == 0)
#ifdef __osf__
puts("Rank Owner Pri Job Files Total Size");
#else
puts("Rank Owner Job File(s) Total Size");
#endif /* __osf__ */
puts("Rank Owner Job Files Total Size");
jobcount ++;
@@ -378,7 +358,7 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
strcpy(rankstr, "active");
else
{
snprintf(rankstr, sizeof(rankstr), "%d%s", rank, ranks[rank % 10]);
sprintf(rankstr, "%d%s\t", rank, ranks[rank % 10]);
rank ++;
}
@@ -387,25 +367,16 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
puts("");
if (jobcopies > 1)
snprintf(namestr, sizeof(namestr), "%d copies of %s", jobcopies,
jobname);
sprintf(namestr, "%d copies of %s", jobcopies, jobname);
else
{
strncpy(namestr, jobname, sizeof(namestr) - 1);
namestr[sizeof(namestr) - 1] = '\0';
}
strcpy(namestr, jobname);
printf("%s: %-34.34s[job %d localhost]\n", jobuser, rankstr, jobid);
printf(" %-40.40s%d bytes\n", namestr, jobsize);
printf("%s: %-31s [job %d localhost]\n", jobuser, rankstr, jobid);
printf(" %-31.31s %d bytes\n", namestr, jobsize);
}
else
#ifdef __osf__
printf("%-6s %-10.10s %-4d %-10d %-27.27s %d bytes\n", rankstr, jobuser,
jobpriority, jobid, jobname, jobsize);
#else
printf("%-7s %-8.8s%-8d%-32.32s%d bytes\n", rankstr, jobuser,
printf("%-6s %-10.10s %-15d %-27.27s %d bytes\n", rankstr, jobuser,
jobid, jobname, jobsize);
#endif /* __osf */
if (attr == NULL)
break;
@@ -468,7 +439,7 @@ show_printer(http_t *http, /* I - HTTP connection to server */
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", dest);
sprintf(uri, "ipp://localhost/printers/%s", dest);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, uri);
+51 -93
Ver Arquivo
@@ -63,17 +63,12 @@ int
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i, j; /* Looping var */
int i; /* Looping var */
int job_id; /* Job ID */
char *printer, /* Destination printer or class */
*instance; /* Instance */
const char *dest; /* Destination printer */
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 */
int num_dests; /* Number of destinations */
cups_dest_t *dests, /* Destinations */
*dest; /* Selected destination */
int num_files; /* Number of files printed */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
int deletefile; /* Delete file after print? */
@@ -85,9 +80,7 @@ main(int argc, /* I - Number of command-line arguments */
deletefile = 0;
printer = NULL;
num_dests = 0;
dests = NULL;
dest = cupsGetDefault();
num_options = 0;
options = NULL;
num_files = 0;
@@ -123,17 +116,14 @@ main(int argc, /* I - Number of command-line arguments */
break;
case 'l' : /* Literal/raw */
num_options = cupsAddOption("raw", "", num_options, &options);
num_options = cupsParseOptions("raw", num_options, &options);
break;
case 'p' : /* Prettyprint */
num_options = cupsAddOption("prettyprint", "", num_options, &options);
num_options = cupsParseOptions("prettyprint", num_options, &options);
break;
case 'h' : /* Suppress burst page */
num_options = cupsAddOption("job-sheets", "none", num_options, &options);
break;
case 's' : /* Don't use symlinks */
break;
@@ -147,26 +137,11 @@ main(int argc, /* I - Number of command-line arguments */
case 'P' : /* Destination printer or class */
if (argv[i][2] != '\0')
printer = argv[i] + 2;
dest = argv[i] + 2;
else
{
i ++;
printer = argv[i];
}
if ((instance = strrchr(printer, '/')) != NULL)
*instance++ = '\0';
if (num_dests == 0)
num_dests = cupsGetDests(&dests);
if ((dest = cupsGetDest(printer, instance, num_dests, dests)) != NULL)
{
for (j = 0; j < dest->num_options; j ++)
if (cupsGetOption(dest->options[j].name, num_options, options) == NULL)
num_options = cupsAddOption(dest->options[j].name,
dest->options[j].value,
num_options, &options);
dest = argv[i];
}
break;
@@ -205,71 +180,54 @@ main(int argc, /* I - Number of command-line arguments */
fprintf(stderr, "lpr: Unknown option \'%c\'!\n", argv[i][1]);
return (1);
}
else if (num_files < 1000)
else
{
/*
* Print a file...
*/
files[num_files] = argv[i];
num_files ++;
if (title == NULL)
if (dest == NULL)
{
if ((title = strrchr(argv[i], '/')) != NULL)
title ++;
else
title = argv[i];
fputs("lpr: error - no default destination available.\n", stderr);
return (1);
}
num_files ++;
if (title)
job_id = cupsPrintFile(dest, argv[i], title, num_options, options);
else
{
char *filename;
if ((filename = strrchr(argv[i], '/')) != NULL)
filename ++;
else
filename = argv[i];
job_id = cupsPrintFile(dest, argv[i], filename, num_options, options);
}
if (job_id < 1)
{
fprintf(stderr, "lpr: unable to print file \'%s\' - %s.\n",
argv[i], ippErrorString(cupsLastError()));
return (1);
}
else if (deletefile)
unlink(argv[i]);
}
else
fprintf(stderr, "lpr: Too many files - \"%s\"\n", argv[i]);
/*
* See if we have any files to print; if not, print from stdin...
* See if we printed anything; if not, print from stdin...
*/
if (printer == NULL)
if (num_files == 0)
{
if (num_dests == 0)
num_dests = cupsGetDests(&dests);
for (j = 0, dest = dests; j < num_dests; j ++, dest ++)
if (dest->is_default)
{
printer = dests[j].name;
for (j = 0; j < dest->num_options; j ++)
if (cupsGetOption(dest->options[j].name, num_options, options) == NULL)
num_options = cupsAddOption(dest->options[j].name,
dest->options[j].value,
num_options, &options);
break;
}
}
if (printer == NULL)
{
fputs("lpr: error - no default destination available.\n", stderr);
return (1);
}
if (num_files > 0)
{
job_id = cupsPrintFiles(printer, num_files, files, title, num_options, options);
if (deletefile)
if (dest == NULL)
{
/*
* Delete print files after printing...
*/
for (i = 0; i < num_files; i ++)
unlink(files[i]);
fputs("lpr: error - no default destination available.\n", stderr);
return (1);
}
}
else
{
num_files = 1;
#ifndef WIN32
# if defined(HAVE_SIGSET)
@@ -306,23 +264,23 @@ main(int argc, /* I - Number of command-line arguments */
if (i == 0)
{
fputs("lpr: stdin is empty, so no job has been sent.\n", stderr);
fputs("lpr: standard input is empty, so no job has been sent.\n", stderr);
return (1);
}
if (title)
job_id = cupsPrintFile(printer, tempfile, title, num_options, options);
job_id = cupsPrintFile(dest, tempfile, title, num_options, options);
else
job_id = cupsPrintFile(printer, tempfile, "(stdin)", num_options, options);
job_id = cupsPrintFile(dest, tempfile, "(stdin)", num_options, options);
unlink(tempfile);
}
if (job_id < 1)
{
fprintf(stderr, "lpr: unable to print file: %s\n",
ippErrorString(cupsLastError()));
return (1);
if (job_id < 1)
{
fprintf(stderr, "lpr: unable to print standard input - %s.\n",
ippErrorString(cupsLastError()));
return (1);
}
}
return (0);
+1 -23
Ver Arquivo
@@ -50,14 +50,11 @@ main(int argc, /* I - Number of command-line arguments */
int i; /* Looping var */
int job_id; /* Job ID */
const char *dest; /* Destination printer */
char *instance; /* Pointer to instance name */
char uri[1024]; /* Printer or job URI */
ipp_t *request; /* IPP request */
ipp_t *response; /* IPP response */
ipp_op_t op; /* Operation */
cups_lang_t *language; /* Language */
int num_dests; /* Number of destinations */
cups_dest_t *dests; /* Destinations */
/*
@@ -66,16 +63,10 @@ main(int argc, /* I - Number of command-line arguments */
op = IPP_CANCEL_JOB;
job_id = 0;
dest = NULL;
dest = cupsGetDefault();
response = NULL;
http = NULL;
num_dests = cupsGetDests(&dests);
for (i = 0; i < num_dests; i ++)
if (dests[i].is_default)
dest = dests[i].name;
/*
* Open a connection to the server...
*/
@@ -83,7 +74,6 @@ main(int argc, /* I - Number of command-line arguments */
if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
{
fputs("lprm: Unable to contact server!\n", stderr);
cupsFreeDests(num_dests, dests);
return (1);
}
@@ -103,15 +93,10 @@ main(int argc, /* I - Number of command-line arguments */
i ++;
dest = argv[i];
}
if ((instance = strchr(dest, '/')) != NULL)
*instance = '\0';
break;
default :
fprintf(stderr, "lprm: Unknown option \'%c\'!\n", argv[i][1]);
cupsFreeDests(num_dests, dests);
httpClose(http);
return (1);
}
else
@@ -211,8 +196,6 @@ main(int argc, /* I - Number of command-line arguments */
else
{
fputs("lprm: Unable to cancel job(s)!\n", stderr);
cupsFreeDests(num_dests, dests);
httpClose(http);
return (1);
}
}
@@ -226,14 +209,9 @@ main(int argc, /* I - Number of command-line arguments */
if (!cupsCancelJob(dest, 0))
{
fputs("lprm: Unable to cancel job(s)!\n", stderr);
cupsFreeDests(num_dests, dests);
httpClose(http);
return (1);
}
cupsFreeDests(num_dests, dests);
httpClose(http);
return (0);
}
+1 -3
Ver Arquivo
@@ -50,9 +50,7 @@ clean:
install:
-$(MKDIR) $(SERVERBIN)/cgi-bin
$(CHMOD) ugo+rx $(SERVERBIN)
$(CHMOD) ugo+rx $(SERVERBIN)/cgi-bin
$(INSTALL_BIN) $(TARGETS) $(SERVERBIN)/cgi-bin
$(CP) $(TARGETS) $(SERVERBIN)/cgi-bin
#
+155 -852
Ver Arquivo
Diferenças do arquivo suprimidas por serem muito extensas Carregar Diff
+1 -7
Ver Arquivo
@@ -54,9 +54,7 @@ extern const char *cgiGetVariable(const char *name);
extern void cgiSetArray(const char *name, int element,
const char *value);
extern void cgiSetVariable(const char *name, const char *value);
extern void cgiCopyTemplateFile(FILE *out, const char *tmpl);
extern void cgiCopyTemplateLang(FILE *out, const char *directory,
const char *tmpl, const char *lang);
extern void cgiCopyTemplateFile(FILE *out, const char *template);
extern void cgiStartHTML(FILE *out, const char *author,
const char *stylesheet,
@@ -72,10 +70,6 @@ extern void cgiEMailPart(FILE *mail, const char *type,
const char *charset, const char *encoding);
extern void cgiEMailClose(FILE *mail);
extern char *cgiGetCookie(const char *name, char *buf, int buflen);
extern void cgiSetCookie(const char *name, const char *value,
const char *path, const char *domain,
time_t expires, int secure);
# define cgiGetUser() getenv("REMOTE_USER")
# define cgiGetHost() (getenv("REMOTE_HOST") == NULL ? getenv("REMOTE_ADDR") : getenv("REMOTE_HOST"))
+75 -214
Ver Arquivo
@@ -46,20 +46,16 @@ main(int argc, /* I - Number of command-line arguments */
http_t *http; /* Connection to the server */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* IPP attribute */
ipp_status_t status; /* Operation status... */
char uri[HTTP_MAX_URI];
/* Printer URI */
const char *which_jobs; /* Which jobs to show */
const char *op; /* Operation to perform, if any */
/*
* Get any form variables...
*/
cgiInitialize();
op = cgiGetVariable("OP");
/*
* Get the request language...
@@ -84,261 +80,126 @@ main(int argc, /* I - Number of command-line arguments */
* single printer...
*/
ippSetServerVersion();
pclass = argv[0];
if (strcmp(pclass, "/") == 0 || strcmp(pclass, "classes.cgi") == 0)
{
pclass = NULL;
cgiSetVariable("TITLE", cupsLangString(language, CUPS_MSG_CLASS));
cgiSetVariable("TITLE", "Classes");
}
else
cgiSetVariable("TITLE", pclass);
cgiCopyTemplateLang(stdout, TEMPLATES, "header.tmpl", getenv("LANG"));
/*
* Get the printer info...
*/
if (op == NULL || strcasecmp(op, "print-test-page") != 0)
request = ippNew();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if (pclass == NULL)
{
/*
* Get the default destination...
* Build a CUPS_GET_CLASSES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
*/
request = ippNew();
request->request.op.operation_id = CUPS_GET_DEFAULT;
request->request.op.operation_id = CUPS_GET_CLASSES;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
if ((attr = ippFindAttribute(response, "printer-name", IPP_TAG_NAME)) != NULL)
cgiSetVariable("DEFAULT_NAME", attr->values[0].string.text);
if ((attr = ippFindAttribute(response, "printer-uri-supported", IPP_TAG_URI)) != NULL)
{
char method[HTTP_MAX_URI],
username[HTTP_MAX_URI],
hostname[HTTP_MAX_URI],
resource[HTTP_MAX_URI],
uri[HTTP_MAX_URI];
int port; /* URI data */
const char *server; /* Name of server */
/*
* Map localhost access to localhost...
*/
server = getenv("SERVER_NAME");
httpSeparate(attr->values[0].string.text, method, username,
hostname, &port, resource);
if (strcasecmp(hostname, server) == 0 &&
(strcmp(getenv("REMOTE_HOST"), "127.0.0.1") == 0 ||
strcmp(getenv("REMOTE_HOST"), "localhost") == 0 ||
strcmp(getenv("REMOTE_HOST"), server) == 0))
strcpy(hostname, "localhost");
/*
* Rewrite URI with HTTP address...
*/
snprintf(uri, sizeof(uri), "http://%s:%d%s", hostname, port,
resource);
cgiSetVariable("DEFAULT_URI", uri);
}
ippDelete(response);
}
/*
* Get the class info...
*/
request = ippNew();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if (pclass == NULL)
{
/*
* Build a CUPS_GET_CLASSES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
*/
request->request.op.operation_id = CUPS_GET_CLASSES;
request->request.op.request_id = 1;
}
else
{
/*
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s/classes/%s", getenv("SERVER_NAME"),
pclass);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
}
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response, NULL, NULL);
ippDelete(response);
}
/*
* Write the report...
*/
cgiCopyTemplateLang(stdout, TEMPLATES, "classes.tmpl", getenv("LANG"));
/*
* Get jobs for the specified class if a class has been chosen...
*/
if (pclass != NULL)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
request->request.op.operation_id = IPP_GET_JOBS;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s/classes/%s", getenv("SERVER_NAME"),
pclass);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
if ((which_jobs = cgiGetVariable("which_jobs")) != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "which-jobs",
NULL, which_jobs);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response, NULL, NULL);
ippDelete(response);
cgiCopyTemplateLang(stdout, TEMPLATES, "jobs.tmpl", getenv("LANG"));
}
}
}
else
{
/*
* Print a test page...
*/
snprintf(uri, sizeof(uri), "ipp://localhost/classes/%s", pclass);
/*
* Build an IPP_PRINT_JOB request, which requires the following
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s/classes/%s", getenv("SERVER_NAME"),
pclass);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
}
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
}
/*
* Write the report...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
cgiCopyTemplateFile(stdout, TEMPLATES "/classes.tmpl");
/*
* Get jobs for the specified class if a class has been chosen...
*/
if (pclass != NULL)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* document-format
*/
request = ippNew();
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
request->request.op.operation_id = IPP_GET_JOBS;
request->request.op.request_id = 1;
if (getenv("REMOTE_USER") != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, getenv("REMOTE_USER"));
else
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, "root");
snprintf(uri, sizeof(uri), "ipp://%s/classes/%s", getenv("SERVER_NAME"),
pclass);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name",
NULL, "Test Page");
ippAddString(request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/postscript");
if ((which_jobs = cgiGetVariable("which_jobs")) != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "which-jobs",
NULL, which_jobs);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoFileRequest(http, request, uri + 15,
CUPS_DATADIR "/data/testprint.ps")) != NULL)
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
status = response->request.status.status_code;
ippSetCGIVars(response, NULL, NULL);
ippSetCGIVars(response);
ippDelete(response);
}
else
status = IPP_GONE;
cgiSetVariable("PRINTER_NAME", pclass);
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateLang(stdout, TEMPLATES, "error.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/jobs.tmpl");
}
else
cgiCopyTemplateLang(stdout, TEMPLATES, "test-page.tmpl", getenv("LANG"));
}
cgiCopyTemplateLang(stdout, TEMPLATES, "trailer.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Close the HTTP server connection...
+22 -110
Ver Arquivo
@@ -3,7 +3,7 @@
*
* IPP variable routines for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-2000 by Easy Software Products.
* Copyright 1997-1999 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
* property of Easy Software Products and are protected by Federal
@@ -23,9 +23,7 @@
*
* Contents:
*
* ippGetTemplateDir() - Get the templates directory...
* ippSetServerVersion() - Set the server name and CUPS version...
* ippSetCGIVars() - Set CGI variables from an IPP response.
* ippSetCGIVars() - Set CGI variables from an IPP response.
*/
/*
@@ -35,58 +33,15 @@
#include "ipp-var.h"
/*
* 'ippGetTemplateDir()' - Get the templates directory...
*/
char * /* O - Template directory */
ippGetTemplateDir(void)
{
const char *datadir; /* CUPS_DATADIR env var */
static char templates[1024] = ""; /* Template directory */
if (!templates[0])
{
/*
* Build the template directory pathname...
*/
if ((datadir = getenv("CUPS_DATADIR")) == NULL)
datadir = CUPS_DATADIR;
snprintf(templates, sizeof(templates), "%s/templates", datadir);
}
return (templates);
}
/*
* 'ippSetServerVersion()' - Set the server name and CUPS version...
*/
void
ippSetServerVersion(void)
{
cgiSetVariable("SERVER_NAME", getenv("SERVER_NAME"));
cgiSetVariable("REMOTE_USER", getenv("REMOTE_USER"));
cgiSetVariable("CUPS_VERSION", CUPS_SVERSION);
}
/*
* 'ippSetCGIVars()' - Set CGI variables from an IPP response.
*/
void
ippSetCGIVars(ipp_t *response, /* I - Response data to be copied... */
const char *filter_name, /* I - Filter name */
const char *filter_value) /* I - Filter value */
ippSetCGIVars(ipp_t *response) /* I - Response data to be copied... */
{
int element; /* Element in CGI array */
ipp_attribute_t *attr, /* Attribute in response... */
*filter; /* Filtering attribute */
ipp_attribute_t *attr; /* Attribute in response... */
int i; /* Looping var */
char name[1024], /* Name of attribute */
value[16384], /* Value(s) */
@@ -96,13 +51,12 @@ ippSetCGIVars(ipp_t *response, /* I - Response data to be copied... */
hostname[HTTP_MAX_URI],
resource[HTTP_MAX_URI],
uri[HTTP_MAX_URI];
int port; /* URI data */
const char *server; /* Name of server */
int port;
ippSetServerVersion();
server = getenv("SERVER_NAME");
cgiSetVariable("SERVER_NAME", getenv("SERVER_NAME"));
cgiSetVariable("REMOTE_USER", getenv("REMOTE_USER"));
cgiSetVariable("CUPS_VERSION", CUPS_SVERSION);
for (attr = response->attrs;
attr && attr->group_tag == IPP_TAG_OPERATION;
@@ -114,29 +68,7 @@ ippSetCGIVars(ipp_t *response, /* I - Response data to be copied... */
* Copy attributes to a separator...
*/
if (filter_name)
{
for (filter = attr;
filter != NULL && filter->group_tag != IPP_TAG_ZERO;
filter = filter->next)
if (filter->name && strcmp(filter->name, filter_name) == 0 &&
(filter->value_tag == IPP_TAG_STRING ||
(filter->value_tag >= IPP_TAG_TEXTLANG &&
filter->value_tag <= IPP_TAG_MIMETYPE)) &&
filter->values[0].string.text != NULL &&
strcasecmp(filter->values[0].string.text, filter_value) == 0)
break;
if (!filter)
return;
if (filter->group_tag == IPP_TAG_ZERO)
{
attr = filter;
element --;
continue;
}
}
/* puts("<HR>");*/
for (; attr != NULL && attr->group_tag != IPP_TAG_ZERO; attr = attr->next)
{
@@ -147,6 +79,8 @@ ippSetCGIVars(ipp_t *response, /* I - Response data to be copied... */
if (attr->name == NULL)
continue;
/* printf("<P>%s\n", attr->name);*/
for (i = 0; attr->name[i]; i ++)
if (attr->name[i] == '-')
name[i] = '_';
@@ -197,39 +131,20 @@ ippSetCGIVars(ipp_t *response, /* I - Response data to be copied... */
break;
case IPP_TAG_URI :
if (strchr(attr->values[i].string.text, ':') != NULL)
if (strncmp(attr->values[i].string.text, "ipp:", 4) == 0)
{
httpSeparate(attr->values[i].string.text, method, username,
httpSeparate(attr->values[i].string.text, method, username,
hostname, &port, resource);
if (username[0])
snprintf(uri, sizeof(uri), "http://%s@%s:%d%s", username,
hostname, port, resource);
else
snprintf(uri, sizeof(uri), "http://%s:%d%s", hostname, port,
resource);
if (strcmp(method, "ipp") == 0 ||
strcmp(method, "http") == 0)
{
/*
* Map localhost access to localhost...
*/
if (strcasecmp(hostname, server) == 0 &&
(strcmp(getenv("REMOTE_HOST"), "127.0.0.1") == 0 ||
strcmp(getenv("REMOTE_HOST"), "localhost") == 0 ||
strcmp(getenv("REMOTE_HOST"), server) == 0))
strcpy(hostname, "localhost");
/*
* Rewrite URI with HTTP address...
*/
if (username[0])
snprintf(uri, sizeof(uri), "http://%s@%s:%d%s", username,
hostname, port, resource);
else
snprintf(uri, sizeof(uri), "http://%s:%d%s", hostname, port,
resource);
strcat(valptr, uri);
break;
}
}
strcat(valptr, uri);
break;
}
case IPP_TAG_STRING :
case IPP_TAG_TEXT :
@@ -239,9 +154,6 @@ ippSetCGIVars(ipp_t *response, /* I - Response data to be copied... */
case IPP_TAG_LANGUAGE :
strcat(valptr, attr->values[i].string.text);
break;
default :
break; /* anti-compiler-warning-code */
}
}
+3 -4
Ver Arquivo
@@ -38,16 +38,15 @@
* Definitions...
*/
#define TEMPLATES ippGetTemplateDir()
/*#define TEMPLATES "/home/mike/c/cups/templates"*/
#define TEMPLATES CUPS_DATADIR "/templates"
/*
* Prototype...
*/
extern char *ippGetTemplateDir(void);
extern void ippSetServerVersion(void);
extern void ippSetCGIVars(ipp_t *, const char *, const char *);
extern void ippSetCGIVars(ipp_t *response);
/*
+7 -6
Ver Arquivo
@@ -73,10 +73,11 @@ main(int argc, /* I - Number of command-line arguments */
printf("Content-Type: text/html;charset=%s\n\n", cupsLangEncoding(language));
cgiSetVariable("TITLE", "Jobs");
cgiSetVariable("SERVER_NAME", getenv("SERVER_NAME"));
cgiSetVariable("REMOTE_USER", getenv("REMOTE_USER"));
cgiSetVariable("CUPS_VERSION", CUPS_SVERSION);
ippSetServerVersion();
cgiCopyTemplateLang(stdout, TEMPLATES, "header.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
/*
* Build an IPP_GET_JOBS request, which requires the following
@@ -111,13 +112,13 @@ main(int argc, /* I - Number of command-line arguments */
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response, NULL, NULL);
ippSetCGIVars(response);
ippDelete(response);
cgiCopyTemplateLang(stdout, TEMPLATES, "jobs.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/jobs.tmpl");
}
cgiCopyTemplateLang(stdout, TEMPLATES, "trailer.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Close the HTTP server connection...
+74 -213
Ver Arquivo
@@ -46,12 +46,9 @@ main(int argc, /* I - Number of command-line arguments */
http_t *http; /* Connection to the server */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* IPP attribute */
ipp_status_t status; /* Operation status... */
char uri[HTTP_MAX_URI];
/* Printer URI */
const char *which_jobs; /* Which jobs to show */
const char *op; /* Operation to perform, if any */
/*
@@ -59,7 +56,6 @@ main(int argc, /* I - Number of command-line arguments */
*/
cgiInitialize();
op = cgiGetVariable("OP");
/*
* Get the request language...
@@ -84,261 +80,126 @@ main(int argc, /* I - Number of command-line arguments */
* single printer...
*/
ippSetServerVersion();
printer = argv[0];
if (strcmp(printer, "/") == 0 || strcmp(printer, "printers.cgi") == 0)
{
printer = NULL;
cgiSetVariable("TITLE", cupsLangString(language, CUPS_MSG_PRINTER));
cgiSetVariable("TITLE", "Printers");
}
else
cgiSetVariable("TITLE", printer);
cgiCopyTemplateLang(stdout, TEMPLATES, "header.tmpl", getenv("LANG"));
/*
* Get the printer info...
*/
if (op == NULL || strcasecmp(op, "print-test-page") != 0)
request = ippNew();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if (printer == NULL)
{
/*
* Get the default destination...
* Build a CUPS_GET_PRINTERS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
*/
request = ippNew();
request->request.op.operation_id = CUPS_GET_DEFAULT;
request->request.op.operation_id = CUPS_GET_PRINTERS;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
if ((attr = ippFindAttribute(response, "printer-name", IPP_TAG_NAME)) != NULL)
cgiSetVariable("DEFAULT_NAME", attr->values[0].string.text);
if ((attr = ippFindAttribute(response, "printer-uri-supported", IPP_TAG_URI)) != NULL)
{
char method[HTTP_MAX_URI],
username[HTTP_MAX_URI],
hostname[HTTP_MAX_URI],
resource[HTTP_MAX_URI],
uri[HTTP_MAX_URI];
int port; /* URI data */
const char *server; /* Name of server */
/*
* Map localhost access to localhost...
*/
server = getenv("SERVER_NAME");
httpSeparate(attr->values[0].string.text, method, username,
hostname, &port, resource);
if (strcasecmp(hostname, server) == 0 &&
(strcmp(getenv("REMOTE_HOST"), "127.0.0.1") == 0 ||
strcmp(getenv("REMOTE_HOST"), "localhost") == 0 ||
strcmp(getenv("REMOTE_HOST"), server) == 0))
strcpy(hostname, "localhost");
/*
* Rewrite URI with HTTP address...
*/
snprintf(uri, sizeof(uri), "http://%s:%d%s", hostname, port,
resource);
cgiSetVariable("DEFAULT_URI", uri);
}
ippDelete(response);
}
/*
* Get the printer info...
*/
request = ippNew();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if (printer == NULL)
{
/*
* Build a CUPS_GET_PRINTERS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
*/
request->request.op.operation_id = CUPS_GET_PRINTERS;
request->request.op.request_id = 1;
}
else
{
/*
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s/printers/%s", getenv("SERVER_NAME"),
printer);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
}
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response, NULL, NULL);
ippDelete(response);
}
/*
* Write the report...
*/
cgiCopyTemplateLang(stdout, TEMPLATES, "printers.tmpl", getenv("LANG"));
/*
* Get jobs for the specified printer if a printer has been chosen...
*/
if (printer != NULL)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
request->request.op.operation_id = IPP_GET_JOBS;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s/printers/%s", getenv("SERVER_NAME"),
printer);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
if ((which_jobs = cgiGetVariable("which_jobs")) != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "which-jobs",
NULL, which_jobs);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response, NULL, NULL);
ippDelete(response);
cgiCopyTemplateLang(stdout, TEMPLATES, "jobs.tmpl", getenv("LANG"));
}
}
}
else
{
/*
* Print a test page...
*/
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", printer);
/*
* Build an IPP_PRINT_JOB request, which requires the following
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s/printers/%s", getenv("SERVER_NAME"),
printer);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
}
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
}
/*
* Write the report...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
cgiCopyTemplateFile(stdout, TEMPLATES "/printers.tmpl");
/*
* Get jobs for the specified printer if a printer has been chosen...
*/
if (printer != NULL)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* document-format
*/
request = ippNew();
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
request->request.op.operation_id = IPP_GET_JOBS;
request->request.op.request_id = 1;
if (getenv("REMOTE_USER") != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, getenv("REMOTE_USER"));
else
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, "root");
snprintf(uri, sizeof(uri), "ipp://%s/printers/%s", getenv("SERVER_NAME"),
printer);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri", NULL,
uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name",
NULL, "Test Page");
ippAddString(request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/postscript");
if ((which_jobs = cgiGetVariable("which_jobs")) != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "which-jobs",
NULL, which_jobs);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoFileRequest(http, request, uri + 15,
CUPS_DATADIR "/data/testprint.ps")) != NULL)
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
status = response->request.status.status_code;
ippSetCGIVars(response, NULL, NULL);
ippSetCGIVars(response);
ippDelete(response);
}
else
status = IPP_GONE;
cgiSetVariable("PRINTER_NAME", printer);
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateLang(stdout, TEMPLATES, "error.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/jobs.tmpl");
}
else
cgiCopyTemplateLang(stdout, TEMPLATES, "test-page.tmpl", getenv("LANG"));
}
cgiCopyTemplateLang(stdout, TEMPLATES, "trailer.tmpl", getenv("LANG"));
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Close the HTTP server connection...
+21 -156
Ver Arquivo
@@ -23,7 +23,6 @@
*
* cgiCopyTemplateFile() - Copy a template file and replace all the
* '{variable}' strings with the variable value.
* cgiCopyTemplateLang() - Copy a template file using a language...
* cgi_copy() - Copy the template file, substituting as needed...
* cgi_puts() - Put a string to the output file, quoting as
* needed...
@@ -46,85 +45,17 @@ static void cgi_puts(const char *s, FILE *out);
*/
void
cgiCopyTemplateFile(FILE *out, /* I - Output file */
const char *tmpl) /* I - Template file to read */
cgiCopyTemplateFile(FILE *out, /* I - Output file */
const char *template) /* I - Template file to read */
{
FILE *in; /* Input file */
/*
* Open the template file...
*/
if ((in = fopen(tmpl, "r")) == NULL)
return;
/*
* Parse the file to the end...
*/
cgi_copy(out, in, 0, 0);
/*
* Close the template file and return...
*/
fclose(in);
}
/*
* 'cgiCopyTemplateLang()' - Copy a template file using a language...
*/
void
cgiCopyTemplateLang(FILE *out, /* I - Output file */
const char *directory, /* I - Directory */
const char *tmpl, /* I - Base filename */
const char *lang) /* I - Language */
{
int i; /* Looping var */
char filename[1024], /* Filename */
locale[16]; /* Locale name */
FILE *in; /* Input file */
/*
* Convert the language to a locale name...
*/
if (lang != NULL)
{
for (i = 0; lang[i] && i < 15; i ++)
if (isalnum(lang[i]))
locale[i] = tolower(lang[i]);
else
locale[i] = '_';
locale[i] = '\0';
}
else
locale[0] = '\0';
/*
* See if we have a template file for this language...
*/
snprintf(filename, sizeof(filename), "%s/%s/%s", directory, locale, tmpl);
if (access(filename, 0))
{
locale[2] = '\0';
snprintf(filename, sizeof(filename), "%s/%s/%s", directory, locale, tmpl);
if (access(filename, 0))
snprintf(filename, sizeof(filename), "%s/%s", directory, tmpl);
}
/*
* Open the template file...
*/
if ((in = fopen(filename, "r")) == NULL)
if ((in = fopen(template, "r")) == NULL)
return;
/*
@@ -154,14 +85,12 @@ cgi_copy(FILE *out, /* I - Output file */
int ch; /* Character from file */
char op; /* Operation */
char name[255], /* Name of variable */
*nameptr, /* Pointer into name */
innername[255], /* Inner comparison name */
*innerptr, /* Pointer into inner name */
*s; /* String pointer */
const char *value; /* Value of variable */
const char *innerval; /* Inner value */
const char *outptr; /* Output string pointer */
char outval[1024], /* Formatted output string */
char outval[1024], /* Output string */
compare[1024]; /* Comparison string */
int result; /* Result of comparison */
@@ -180,26 +109,15 @@ cgi_copy(FILE *out, /* I - Output file */
*/
for (s = name; (ch = getc(in)) != EOF;)
if (strchr("}]<>=! \t\n", ch))
if (strchr("}]<>=!", ch))
break;
else if (s > name && ch == '?')
break;
else if (s < (name + sizeof(name) - 1))
else
*s++ = ch;
*s = '\0';
if (s == name && isspace(ch))
{
if (out)
{
putc('{', out);
putc(ch, out);
}
continue;
}
/*
* See if it has a value...
*/
@@ -210,25 +128,10 @@ cgi_copy(FILE *out, /* I - Output file */
* Insert value only if it exists...
*/
if ((nameptr = strrchr(name, '-')) != NULL && isdigit(nameptr[1]))
{
*nameptr++ = '\0';
if ((value = cgiGetArray(name + 1, atoi(nameptr) - 1)) != NULL)
outptr = value;
else
{
outval[0] = '\0';
outptr = outval;
}
}
if ((value = cgiGetArray(name + 1, element)) != NULL)
outptr = value;
strcpy(outval, value);
else
{
outval[0] = '\0';
outptr = outval;
}
}
else if (name[0] == '#')
{
@@ -240,8 +143,6 @@ cgi_copy(FILE *out, /* I - Output file */
sprintf(outval, "%d", cgiGetSize(name + 1));
else
sprintf(outval, "%d", element + 1);
outptr = outval;
}
else if (name[0] == '[')
{
@@ -280,24 +181,10 @@ cgi_copy(FILE *out, /* I - Output file */
* Insert variable or variable name (if element is NULL)...
*/
if ((nameptr = strrchr(name, '-')) != NULL && isdigit(nameptr[1]))
{
*nameptr++ = '\0';
if ((value = cgiGetArray(name, atoi(nameptr) - 1)) == NULL)
{
snprintf(outval, sizeof(outval), "{%s}", name);
outptr = outval;
}
else
outptr = value;
}
else if ((value = cgiGetArray(name, element)) == NULL)
{
snprintf(outval, sizeof(outval), "{%s}", name);
outptr = outval;
}
if ((value = cgiGetArray(name, element)) == NULL)
sprintf(outval, "{%s}", name);
else
outptr = value;
strcpy(outval, value);
}
/*
@@ -311,7 +198,7 @@ cgi_copy(FILE *out, /* I - Output file */
*/
if (out)
cgi_puts(outptr, out);
cgi_puts(outval, out);
continue;
}
@@ -345,8 +232,6 @@ cgi_copy(FILE *out, /* I - Output file */
for (s = compare; (ch = getc(in)) != EOF;)
if (ch == '?')
break;
else if (s >= (compare + sizeof(compare) - 1))
continue;
else if (ch == '#')
{
sprintf(s, "%d", element + 1);
@@ -360,8 +245,7 @@ cgi_copy(FILE *out, /* I - Output file */
innerptr = innername;
while ((ch = getc(in)) != EOF && ch != '}')
if (innerptr < (innername + sizeof(innername) - 1))
*innerptr++ = ch;
*innerptr++ = ch;
*innerptr = '\0';
if (innername[0] == '#')
@@ -370,31 +254,22 @@ cgi_copy(FILE *out, /* I - Output file */
isdigit(innerptr[1]))
{
*innerptr++ = '\0';
if ((innerval = cgiGetArray(innername, atoi(innerptr) - 1)) == NULL)
if ((innerval = cgiGetArray(innername, atoi(innerptr))) == NULL)
*s = '\0';
else
{
strncpy(s, innerval, sizeof(compare) - (s - compare) - 1);
compare[sizeof(compare) - 1] = '\0';
}
strcpy(s, innerval);
}
else if (innername[0] == '?')
{
if ((innerval = cgiGetArray(innername + 1, element)) == NULL)
*s = '\0';
else
{
strncpy(s, innerval, sizeof(compare) - (s - compare) - 1);
compare[sizeof(compare) - 1] = '\0';
}
strcpy(s, innerval);
}
else if ((innerval = cgiGetArray(innername, element)) == NULL)
snprintf(s, sizeof(s), "{%s}", innername);
sprintf(s, "{%s}", innername);
else
{
strncpy(s, innerval, sizeof(compare) - (s - compare) - 1);
compare[sizeof(compare) - 1] = '\0';
}
strcpy(s, innerval);
s += strlen(s);
}
@@ -415,19 +290,16 @@ cgi_copy(FILE *out, /* I - Output file */
switch (op)
{
case '<' :
result = strcasecmp(outptr, compare) < 0;
result = strcasecmp(outval, compare) < 0;
break;
case '>' :
result = strcasecmp(outptr, compare) > 0;
result = strcasecmp(outval, compare) > 0;
break;
case '=' :
result = strcasecmp(outptr, compare) == 0;
result = strcasecmp(outval, compare) == 0;
break;
case '!' :
result = strcasecmp(outptr, compare) != 0;
break;
default :
result = 1;
result = strcasecmp(outval, compare) != 0;
break;
}
}
@@ -460,13 +332,6 @@ cgi_copy(FILE *out, /* I - Output file */
}
else if (out)
putc(ch, out);
/*
* Flush any pending output...
*/
if (out)
fflush(out);
}
+1 -4
Ver Arquivo
@@ -611,11 +611,8 @@ cgi_initialize_string(const char *data) /* I - Form data string */
if ((s = strrchr(name, '-')) != NULL && isdigit(s[1]))
{
*s++ = '\0';
if (value[0])
cgiSetArray(name, atoi(s) - 1, value);
cgiSetArray(name, atoi(s) - 1, value);
}
else if (cgiGetVariable(name) != NULL)
cgiSetArray(name, cgiGetSize(name), value);
else
cgiSetVariable(name, value);
}
+6 -5
Ver Arquivo
@@ -52,21 +52,22 @@ clean:
install:
-$(MKDIR) $(SERVERROOT)
$(CHMOD) ugo+rx $(SERVERROOT)
for file in $(KEEP); do \
if test -r $(SERVERROOT)/$$file ; then \
$(INSTALL_DATA) $$file $(SERVERROOT)/$$file.N ; \
$(CP) $$file $(SERVERROOT)/$$file.N ; \
else \
$(INSTALL_DATA) $$file $(SERVERROOT) ; \
$(CP) $$file $(SERVERROOT) ; \
fi ; \
done
for file in $(REPLACE); do \
if test -r $(SERVERROOT)/$$file ; then \
$(MV) $(SERVERROOT)/$$file $(SERVERROOT)/$$file.O ; \
fi ; \
$(INSTALL_DATA) $$file $(SERVERROOT) ; \
$(CP) $$file $(SERVERROOT) ; \
done
if test -r /etc/printcap -a ! -r /etc/printcap.O; then \
$(CP) /etc/printcap /etc/printcap.O ; \
fi
#
# End of "$Id$".
+8 -2
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: classes.conf 1152 2000-06-22 18:25:29Z mike $"
# "$Id: classes.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample class configuration file for the Common UNIX Printing System
# (CUPS) scheduler.
@@ -47,6 +47,12 @@
#Info Acme LaserPrint 1000 Printers
#
# MoreInfo: a URL for more information on the printer.
#
#MoreInfo http://www.acme.com/lp1000.html
#
# Location: the location of the printer.
#
@@ -85,5 +91,5 @@
#</Class>
#
# End of "$Id: classes.conf 1152 2000-06-22 18:25:29Z mike $".
# End of "$Id: classes.conf 969 2000-03-10 16:56:46Z mike $".
#
+7 -22
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: client.conf 1485 2000-12-20 13:41:17Z mike $"
# "$Id: client.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample client configuration file for the Common UNIX Printing System
# (CUPS).
@@ -27,39 +27,24 @@
# #
# This is the CUPS client configuration file. This file is used to #
# define client-specific parameters, such as the default server or #
# default encryption settings. #
# default printer. #
# #
########################################################################
#
# ServerName: the hostname of your server. By default CUPS will use the
# hostname of the system or the value of the CUPS_SERVER environment
# variable.
# hostname of the system.
#
#ServerName myhost.domain.com
#
# Encryption: whether or not to use encryption; this depends on having
# the OpenSSL library linked into the CUPS library.
#
# Possible values:
#
# Always - Always use encryption (SSL)
# Never - Never use encryption
# Required - Use TLS encryption upgrade
# IfRequested - Use encryption if the server requests it
#
# The default value is "IfRequested". This parameter can also be set
# using the CUPS_ENCRYPTION environment variable.
# DefaultPrinter: the default printer (or class) that clients should use.
#
#Encryption Always
#Encryption Never
#Encryption Required
#Encryption IfRequested
#DefaultPrinter myprinter
#DefaultPrinter myprinter@host
#
# End of "$Id: client.conf 1485 2000-12-20 13:41:17Z mike $".
# End of "$Id: client.conf 969 2000-03-10 16:56:46Z mike $".
#
+205 -351
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: cupsd.conf 1485 2000-12-20 13:41:17Z mike $"
# "$Id: cupsd.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample configuration file for the Common UNIX Printing System (CUPS)
# scheduler.
@@ -34,16 +34,58 @@
# #
########################################################################
#
# Ports/addresses that we listen to. The default port 631 is reserved
# for the Internet Printing Protocol (IPP) and is what we use here.
#
# You can have multiple Port/Listen lines to listen to more than one
# port or address, or to restrict access:
#
# Port 80
# Port 631
# Listen hostname
# Listen hostname:80
# Listen hostname:631
# Listen 1.2.3.4
# Listen 1.2.3.4:631
#
########
######## Server Identity
########
#Port 80
Port 631
#
# MaxClients: controls the maximum number of simultaneous clients that
# will be handled. Defaults to 100.
#
#MaxClients 100
#
# User/Group: the user and group the server runs under. Normally this
# must be lp and sys, however you can configure things for another user
# or group as needed.
#
# Note: the server must be run initially as root to support the
# default IPP port of 631. It changes users whenever an external
# program is run...
#
#User lp
#Group sys
#
# SystemGroup: the group name for "System" (printer administration)
# access. The default varies depending on the operating system, but
# will be "sys", "system", or "root" (checked for in that order.)
#
#SystemGroup sys
#
# ServerName: the hostname of your server, as advertised to the world.
# By default CUPS will use the hostname of the system.
#
# To set the default server used by clients, see the client.conf file.
# To set the default server name used by clients, see the client.conf file.
#
#ServerName myhost.domain.com
@@ -55,10 +97,33 @@
#ServerAdmin root@your.domain.com
#
# ServerRoot: the root directory for the scheduler.
# By default /etc/cups.
#
########
######## Server Options
########
#ServerRoot /etc/cups
#
# ServerBin: the root directory for the scheduler executables.
# By default /usr/lib/cups.
#
#ServerBin /usr/lib/cups
#
# DocumentRoot: the root directory for the HTTP server.
# By default /usr/share/doc/cups.
#
#DocumentRoot /usr/share/doc/cups
#
# RequestRoot: the directory where request files are stored.
# By default /var/spool/cups.
#
#RequestRoot /var/spool/cups
#
# AccessLog: the access log file; if this does not start with a leading /
@@ -69,41 +134,12 @@
# syslog file or daemon.
#
#AccessLog /var/log/cups/access_log
#
# DataDir: the root directory for the CUPS data files.
# By default /usr/share/cups.
#
#DataDir /usr/share/cups
#
# DefaultCharset: the default character set to use. If not specified,
# defaults to utf-8. Note that this can also be overridden in
# HTML documents...
#
#DefaultCharset utf-8
#
# DefaultLanguage: the default language if not specified by the browser.
# If not specified, the current locale is used.
#
#DefaultLanguage en
#
# DocumentRoot: the root directory for HTTP documents that are served.
# By default the compiled in directory.
#
#DocumentRoot /usr/share/cups/doc
#AccessLog logs/access_log
#
# ErrorLog: the error log file; if this does not start with a leading /
# then it is assumed to be relative to ServerRoot. By default set to
# "/var/log/cups/error_log"
# "logs/error_log"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
@@ -112,18 +148,21 @@
#ErrorLog /var/log/cups/error_log
#
# FontPath: the path to locate all font files (currently only for pstoraster)
# By default /usr/share/cups/fonts.
# PageLog: the page log file; if this does not start with a leading /
# then it is assumed to be relative to ServerRoot. By default set to
# "logs/page_log"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
#
#FontPath /usr/share/cups/fonts
#PageLog /var/log/cups/page_log
#
# LogLevel: controls the number of messages logged to the ErrorLog
# file and can be one of the following:
#
# debug2 Log everything.
# debug Log almost everything.
# debug Log everything.
# info Log all requests and state changes.
# warn Log errors and warnings.
# error Log only errors.
@@ -140,171 +179,11 @@ LogLevel info
#MaxLogSize 0
#
# PageLog: the page log file; if this does not start with a leading /
# then it is assumed to be relative to ServerRoot. By default set to
# "/var/log/cups/page_log"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
# MaxRequestSize: controls the maximum size of HTTP requests and print files.
# Set to 0 to disable this feature (defaults to 0.)
#
#PageLog /var/log/cups/page_log
#
# PreserveJobHistory: whether or not to preserve the job history after a
# job is completed, cancelled, or stopped. Default is Yes.
#
#PreserveJobHistory Yes
#
# PreserveJobFiles: whether or not to preserve the job files after a
# job is completed, cancelled, or stopped. Default is No.
#
#PreserveJobFiles No
#
# AutoPurgeJobs: automatically purge jobs when not needed for quotas.
# Default is No.
#
#AutoPurgeJobs No
#
# MaxJobs: maximum number of jobs to keep in memory (active and completed.)
# Default is 0 (no limit.)
#
#MaxJobs 0
#
# Printcap: the name of the printcap file. Default is /etc/printcap.
# Leave blank to disable printcap file generation.
#
#Printcap /etc/printcap
#
# RequestRoot: the directory where request files are stored.
# By default /var/spool/cups.
#
#RequestRoot /var/spool/cups
#
# RemoteRoot: the name of the user assigned to unauthenticated accesses
# from remote systems. By default "remroot".
#
#RemoteRoot remroot
#
# ServerBin: the root directory for the scheduler executables.
# By default /usr/lib/cups or /usr/lib32/cups (IRIX 6.5).
#
#ServerBin /usr/lib/cups
#
# ServerRoot: the root directory for the scheduler.
# By default /etc/cups.
#
#ServerRoot /etc/cups
########
######## Encryption Support
########
#
# ServerCertificate: the file to read containing the server's certificate.
# Defaults to "/etc/cups/ssl/server.crt".
#
#ServerCertificate /etc/cups/ssl/server.crt
#
# ServerKey: the file to read containing the server's key.
# Defaults to "/etc/cups/ssl/server.key".
#
#ServerKey /etc/cups/ssl/server.key
########
######## Filter Options
########
#
# User/Group: the user and group the server runs under. Normally this
# must be lp and sys, however you can configure things for another user
# or group as needed.
#
# Note: the server must be run initially as root to support the
# default IPP port of 631. It changes users whenever an external
# program is run...
#
#User lp
#Group sys
#
# RIPCache: the amount of memory that each RIP should use to cache
# bitmaps. The value can be any real number followed by "k" for
# kilobytes, "m" for megabytes, "g" for gigabytes, or "t" for tiles
# (1 tile = 256x256 pixels.) Defaults to "8m" (8 megabytes).
#
#RIPCache 8m
#
# TempDir: the directory to put temporary files in. This directory must be
# writable by the user defined above! Defaults to "/var/spool/cups/tmp" or
# the value of the TMPDIR environment variable.
#
#TempDir /var/spool/cups/tmp
#
# FilterLimit: sets the maximum cost of all job filters that can be run
# at the same time. A limit of 0 means no limit. A typical job may need
# a filter limit of at least 200; limits less than the minimum required
# by a job force a single job to be printed at any time.
#
# The default limit is 0 (unlimited).
#
#FilterLimit 0
########
######## Network Options
########
#
# Ports/addresses that we listen to. The default port 631 is reserved
# for the Internet Printing Protocol (IPP) and is what we use here.
#
# You can have multiple Port/Listen lines to listen to more than one
# port or address, or to restrict access:
#
# Port 80
# Port 631
# Listen hostname
# Listen hostname:80
# Listen hostname:631
# Listen 1.2.3.4
# Listen 1.2.3.4:631
#
# NOTE: Unfortunately, most web browsers don't support TLS or HTTP Upgrades
# for encryption. If you want to support web-based encryption you'll
# probably need to listen on port 443 (the "https" port...)
#
#Port 80
#Port 443
Port 631
#MaxRequestSize 0
#
# HostNameLookups: whether or not to do lookups on IP addresses to get a
@@ -313,6 +192,12 @@ Port 631
#HostNameLookups On
#
# Timeout: the timeout before requests time out. Default is 300 seconds.
#
#Timeout 300
#
# KeepAlive: whether or not to support the Keep-Alive connection
# option. Default is on.
@@ -328,62 +213,80 @@ Port 631
#KeepAliveTimeout 60
#
# MaxClients: controls the maximum number of simultaneous clients that
# will be handled. Defaults to 100.
# ImplicitClasses: whether or not to use implicit classes.
#
# Printer classes can be specified explicitly in the classes.conf
# file, implicitly based upon the printers available on the LAN, or
# both.
#
# When ImplicitClasses is On, printers on the LAN with the same name
# (e.g. Acme-LaserPrint-1000) will be put into a class with the same
# name. This allows you to setup multiple redundant queues on a LAN
# without a lot of administrative difficulties. If a user sends a
# job to Acme-LaserPrint-1000, the job will go to the first available
# queue.
#
# Enabled by default.
#
#MaxClients 100
#ImplicitClasses On
#
# MaxRequestSize: controls the maximum size of HTTP requests and print files.
# Set to 0 to disable this feature (defaults to 0.)
#
#MaxRequestSize 0
#
# Timeout: the timeout before requests time out. Default is 300 seconds.
#
#Timeout 300
########
######## Browsing Options
########
#
# Browsing: whether or not to broadcast and/or listen for CUPS printer
# information on the network. Enabled by default.
# Browsing: whether or not to broadcast printer information to
# other CUPS servers. Enabled by default.
#
#Browsing On
#
# BrowseInterval: the time between browsing updates in seconds. Default
# is 30 seconds.
#
# Note that browsing information is sent whenever a printer's state changes
# as well, so this represents the maximum time between updates.
#
# Set this to 0 to disable outgoing broadcasts so your local printers are
# not advertised but you can still see printers on other hosts.
#
#BrowseInterval 30
#
# BrowseTimeout: the timeout for network printers - if we don't
# get an update within this time the printer will be removed
# from the printer list. This number definitely should not be
# less the BrowseInterval value for obvious reasons. Defaults
# to 300 seconds.
#
#BrowseTimeout 300
#
# BrowsePort: the port used for UDP broadcasts. By default this is
# the IPP port; if you change this you need to do it on all servers.
# Only one BrowsePort is recognized.
#
#BrowsePort 631
#
# BrowseAddress: specifies a broadcast address to be used. By
# default browsing information is not sent!
# default browsing information is broadcast to all active interfaces.
#
# Note: HP-UX does not properly handle broadcast unless you have a
# Class A, B, C, or D netmask (i.e. no CIDR support).
#
# Note: Using the "global" broadcast address (255.255.255.255) will
# activate a Linux demand-dial link with the default configuration.
# If you have a LAN as well as the dial-up link, use the LAN's
# broadcast address.
# Note: HP-UX 10.20 and earlier do not properly handle broadcast unless
# you have a Class A, B, C, or D netmask (i.e. no CIDR support).
#
#BrowseAddress x.y.z.255
#BrowseAddress x.y.255.255
#BrowseAddress x.255.255.255
#BrowseAddress 255.255.255.255
#
# BrowseShortNames: whether or not to use "short" names for remote printers
# when possible (e.g. "printer" instead of "printer@host".) Enabled by
# default.
# BrowseOrder: specifies the order of
#
#BrowseShortNames Yes
#BrowseOrder allow,deny
#BrowseOrder deny,allow
#
# BrowseAllow: specifies an address mask to allow for incoming browser
@@ -414,40 +317,6 @@ Port 631
#BrowseAllow address
#BrowseDeny address
#
# BrowseInterval: the time between browsing updates in seconds. Default
# is 30 seconds.
#
# Note that browsing information is sent whenever a printer's state changes
# as well, so this represents the maximum time between updates.
#
# Set this to 0 to disable outgoing broadcasts so your local printers are
# not advertised but you can still see printers on other hosts.
#
#BrowseInterval 30
#
# BrowseOrder: specifies the order of BrowseAllow/BrowseDeny comparisons.
#
#BrowseOrder allow,deny
#BrowseOrder deny,allow
#
# BrowsePoll: poll the named server(s) for printers
#
#BrowsePoll address:port
#
# BrowsePort: the port used for UDP broadcasts. By default this is
# the IPP port; if you change this you need to do it on all servers.
# Only one BrowsePort is recognized.
#
#BrowsePort 631
#
# BrowseRelay: relay browser packets from one address/network to another.
#
@@ -455,46 +324,70 @@ Port 631
#BrowseRelay source-address destination-address
#
# BrowseTimeout: the timeout for network printers - if we don't
# get an update within this time the printer will be removed
# from the printer list. This number definitely should not be
# less the BrowseInterval value for obvious reasons. Defaults
# to 300 seconds.
# BrowsePoll: poll the named server for printers
#
#BrowseTimeout 300
#BrowsePoll address:port
#
# ImplicitClasses: whether or not to use implicit classes.
#
# Printer classes can be specified explicitly in the classes.conf
# file, implicitly based upon the printers available on the LAN, or
# both.
#
# When ImplicitClasses is On, printers on the LAN with the same name
# (e.g. Acme-LaserPrint-1000) will be put into a class with the same
# name. This allows you to setup multiple redundant queues on a LAN
# without a lot of administrative difficulties. If a user sends a
# job to Acme-LaserPrint-1000, the job will go to the first available
# queue.
#
# Enabled by default.
# DocumentRoot: the root directory for HTTP documents that are served.
# By default the compiled in directory.
#
#ImplicitClasses On
########
######## Security Options
########
#DocumentRoot /usr/share/cups/doc
#
# SystemGroup: the group name for "System" (printer administration)
# access. The default varies depending on the operating system, but
# will be "sys", "system", or "root" (checked for in that order.)
# DefaultLanguage: the default language if not specified by the browser.
# If not specified, the current locale is used.
#
#SystemGroup sys
#DefaultLanguage en
#
# DefaultCharset: the default character set to use. If not specified,
# defaults to utf-8. Note that this can also be overridden in
# HTML documents...
#
#DefaultCharset utf-8
#
# RIPCache: the amount of memory that each RIP should use to cache
# bitmaps. The value can be any real number followed by "k" for
# kilobytes, "m" for megabytes, "g" for gigabytes, or "t" for tiles
# (1 tile = 256x256 pixels.) Defaults to "8m" (8 megabytes).
#
#RIPCache 8m
#
# TempDir: the directory to put temporary files in. This directory must be
# writable by the user defined above! Defaults to "/var/tmp" or the value
# of the TMPDIR environment variable.
#
#TempDir /var/tmp
#
# PreserveJobHistory: whether or not to preserve the job history after a
# job is completed, cancelled, or stopped. Default is Yes.
#
#PreserveJobHistory Yes
#
# PreserveJobFiles: whether or not to preserve the job files after a
# job is completed, cancelled, or stopped. Default is No.
#
#PreserveJobFiles No
#
# Printcap: the name of the printcap file. Default is /etc/printcap.
# Leave blank to disable printcap file generation.
#
#Printcap /etc/printcap
#
# Access permissions for each directory served by the scheduler.
@@ -507,8 +400,7 @@ Port 631
# Digest - Perform authentication using the HTTP Digest method.
#
# (Note: local certificate authentication can be substituted by
# the client for Basic or Digest when connecting to the
# localhost interface)
# the client for Basic or Digest)
#
# AuthClass: the authorization class; currently only "Anonymous", "User",
# "System" (valid user belonging to group SystemGroup), and "Group"
@@ -541,47 +433,11 @@ Port 631
# The host and domain address require that you enable hostname lookups
# with "HostNameLookups On" above.
#
# Encryption: whether or not to use encryption; this depends on having
# the OpenSSL library linked into the CUPS library and scheduler.
#
# Possible values:
#
# Always - Always use encryption (SSL)
# Never - Never use encryption
# Required - Use TLS encryption upgrade
# IfRequested - Use encryption if the server requests it
#
# The default value is "IfRequested".
#
<Location />
Order Deny,Allow
Deny From All
Allow From 127.0.0.1
</Location>
#<Location /classes>
#
# You may wish to limit access to printers and classes, either with Allow
# and Deny lines, or by requiring a username and password.
#
#</Location>
#<Location /classes/name>
#
# You may wish to limit access to printers and classes, either with Allow
# and Deny lines, or by requiring a username and password.
#
#</Location>
#<Location /printers>
#
# You may wish to limit access to printers and classes, either with Allow
# and Deny lines, or by requiring a username and password.
#
#</Location>
#<Location /printers/name>
<Location /printers>
#
# You may wish to limit access to printers and classes, either with Allow
# and Deny lines, or by requiring a username and password.
@@ -602,11 +458,11 @@ Allow From 127.0.0.1
#Order Deny,Allow
#Deny From All
#Allow From .mydomain.com
#</Location>
</Location>
<Location /admin>
#
# You definitely will want to limit access to the administration functions.
# You definitely will want to limit access to the administration tools.
# The default configuration requires a local connection from a user who
# is a member of the system group to do any admin tasks. You can change
# the group name using the SystemGroup directive.
@@ -619,10 +475,8 @@ AuthClass System
Order Deny,Allow
Deny From All
Allow From 127.0.0.1
#Encryption Required
</Location>
#
# End of "$Id: cupsd.conf 1485 2000-12-20 13:41:17Z mike $".
# End of "$Id: cupsd.conf 969 2000-03-10 16:56:46Z mike $".
#
+12 -28
Ver Arquivo
@@ -1,9 +1,9 @@
#
# "$Id: mime.convs 1340 2000-09-06 13:53:00Z mike $"
# "$Id: mime.convs 575 1999-07-30 13:57:16Z mike $"
#
# MIME converts file for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-2000 by Easy Software Products.
# Copyright 1997-1999 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -41,38 +41,22 @@
# PostScript filters
#
#application/msword application/postscript 33 mswordtops
application/pdf application/postscript 33 pdftops
application/postscript application/vnd.cups-postscript 66 pstops
application/vnd.hp-HPGL application/postscript 66 hpgltops
image/* application/vnd.cups-postscript 66 imagetops
#text/html application/postscript 33 htmltops
application/x-cshell application/postscript 33 texttops
application/x-perl application/postscript 33 texttops
application/x-shell application/postscript 33 texttops
text/html application/postscript 33 texttops
text/plain application/postscript 33 texttops
application/vnd.cups-form application/vnd.cups-postscript 33 formtops
#application/msword application/postscript 50 mswordtops
application/pdf application/postscript 50 pdftops
application/postscript application/vnd.cups-postscript 50 pstops
application/vnd.hp-HPGL application/postscript 50 hpgltops
image/* application/vnd.cups-postscript 50 imagetops
#text/html application/postscript 50 htmltops
text/plain application/postscript 50 texttops
########################################################################
#
# Raster filters...
#
image/* application/vnd.cups-raster 100 imagetoraster
application/vnd.cups-postscript application/vnd.cups-raster 100 pstoraster
########################################################################
#
# Raw filter...
#
# Uncomment the following filter and the application/octet-stream type
# in mime.types to allow printing of arbitrary files without the -oraw
# option.
#
#*/* application/vnd.cups-raw 0 -
image/* application/vnd.cups-raster 50 imagetoraster
application/vnd.cups-postscript application/vnd.cups-raster 50 pstoraster
#
# End of "$Id: mime.convs 1340 2000-09-06 13:53:00Z mike $".
# End of "$Id: mime.convs 575 1999-07-30 13:57:16Z mike $".
#
+12 -39
Ver Arquivo
@@ -1,9 +1,9 @@
#
# "$Id: mime.types 1430 2000-11-06 16:39:17Z mike $"
# "$Id: mime.types 575 1999-07-30 13:57:16Z mike $"
#
# MIME types file for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-2000 by Easy Software Products.
# Copyright 1997-1999 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -39,13 +39,12 @@
# ascii(offset,length) True if bytes are valid printable ASCII
# (CR, NL, TAB, BS, 32-126)
# printable(offset,length) True if bytes are printable 8-bit chars
# (CR, NL, TAB, BS, 32-126, 128-254)
# (CR, NL, TAB, BS, 32-126, 160-254)
# string(offset,"string") True if bytes are identical to string
# char(offset,value) True if byte is identical
# short(offset,value) True if 16-bit integer is identical
# int(offset,value) True if 32-bit integer is identical
# locale("string") True if current locale matches string
# contains(offset,range,"string") True if the range contains the string
#
# General Notes:
#
@@ -57,7 +56,7 @@
# type in the sorted list.
#
# The "printable" rule differs from the "ascii" rule in that it also
# accepts 8-bit characters in the range 128-255.
# accepts 8-bit characters in the range 160-254.
#
# String constants must be surrounded by "" if they contain whitespace.
# To instead binary data into a string, use the <hex> notation.
@@ -82,11 +81,7 @@ application/vnd.hp-HPGL hpgl string(0,<1b>%) string(0,<1b>&)\
image/gif gif string(0,GIF87a) string(0,GIF89a)
image/png png string(0,<89>PNG)
image/jpeg jpeg jpg jpe string(0,<FFD8FF>) &&\
(char(3,0xe0) char(3,0xe1) char(3,0xe2) char(3,0xe3)\
char(3,0xe4) char(3,0xe5) char(3,0xe6) char(3,0xe7)\
char(3,0xe8) char(3,0xe9) char(3,0xea) char(3,0xeb)\
char(3,0xec) char(3,0xed) char(3,0xee) char(3,0xef))
image/jpeg jpeg jpg jpe string(6,JFIF)
image/tiff tiff tif string(0,MM) string(0,II)
image/x-photocd pcd string(2048,PCD_IPI)
image/x-portable-anymap pnm
@@ -99,9 +94,10 @@ image/x-xpixmap xpm ascii(0,1024) + string(3,"XPM")
image/x-xwindowdump xwd
image/x-sun-raster ras
#image/fpx fpx
image/x-alias pix short(8,8) short(8,24)
image/x-bitmap bmp string(0,BM) && !printable(2,14)
# TODO: Add Alias, SoftImage, GIMP??? files
#image/x-alias pix
#image/x-softimage
#image/x-gimp-xcf xcf xcf.gz
########################################################################
#
@@ -110,13 +106,6 @@ image/x-bitmap bmp string(0,BM) && !printable(2,14)
text/html html htm printable(0,1024) +\
(string(0,"<HTML>") string(0,"<!DOCTYPE"))
application/x-cshell csh printable(0,1024) + string(0,#!) +\
(contains(2,80,/csh) contains(2,80,/tcsh))
application/x-perl pl printable(0,1024) + string(0,#!) +\
contains(2,80,/perl)
application/x-shell sh printable(0,1024) + string(0,#!) +\
(contains(2,80,/bash) contains(2,80,/ksh)\
contains(2,80,/sh) contains(2,80,/zsh))
text/plain txt printable(0,1024)
########################################################################
@@ -124,26 +113,10 @@ text/plain txt printable(0,1024)
# CUPS-specific types...
#
application/vnd.cups-form string(0,"<CUPSFORM>")
application/vnd.cups-postscript string(0,<1B>%-12345X) + \
contains(9,512,"LANGUAGE=POSTSCRIPT")
application/vnd.cups-postscript string(0,<1B>%-12345X)
application/vnd.cups-raster string(0,"RaSt") string(0,"tSaR")
application/vnd.cups-raw string(0,<1B>E) \
string(0,<1B>@) \
(string(0,<1B>%-12345X) + \
contains(9,512,"LANGUAGE=PCL"))
########################################################################
#
# Raw print file support...
#
# Uncomment the following type and the application/octet-stream
# filter line in mime.convs to allow raw file printing without the
# -oraw option.
#
#application/octet-stream
application/vnd.cups-raw
#
# End of "$Id: mime.types 1430 2000-11-06 16:39:17Z mike $".
# End of "$Id: mime.types 575 1999-07-30 13:57:16Z mike $".
#
+8 -2
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: printers.conf 1152 2000-06-22 18:25:29Z mike $"
# "$Id: printers.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample printer configuration file for the Common UNIX Printing System
# (CUPS) scheduler.
@@ -47,6 +47,12 @@
#Info Acme LaserPrint 1000
#
# MoreInfo: a URL for more information on the printer.
#
#MoreInfo http://www.acme.com/lp1000.html
#
# Location: the location of the printer.
#
@@ -92,5 +98,5 @@
#</Printer>
#
# End of "$Id: printers.conf 1152 2000-06-22 18:25:29Z mike $".
# End of "$Id: printers.conf 969 2000-03-10 16:56:46Z mike $".
#
+1 -16
Ver Arquivo
@@ -28,7 +28,7 @@
* Version of software...
*/
#define CUPS_SVERSION "CUPS v1.1.5"
#define CUPS_SVERSION "CUPS v1.1b2"
/*
* Where are files stored?
@@ -41,7 +41,6 @@
#define CUPS_REQUESTS "/var/spool/cups"
#define CUPS_LOGDIR "/var/logs/cups"
#define CUPS_DATADIR "/usr/share/cups"
#define CUPS_FONTPATH "/usr/share/cups/fonts"
/*
@@ -123,20 +122,6 @@
#undef HAVE_WAITPID
#undef HAVE_WAIT3
/*
* Do we have the mallinfo function and malloc.h?
*/
#undef HAVE_MALLINFO
#undef HAVE_MALLOC_H
/*
* Do we have the OpenSSL library?
*/
#undef HAVE_LIBSSL
/*
* End of "$Id$".
*/
+51 -276
Ver Arquivo
@@ -24,7 +24,7 @@ dnl
AC_INIT(cups/cups.h)
AC_CONFIG_HEADER(config.h)
AC_PREFIX_DEFAULT(/)
AC_PREFIX_DEFAULT(/usr)
dnl Get the operating system and version number...
@@ -41,24 +41,11 @@ OPTIM=""
AC_SUBST(OPTIM)
PICFLAG=1
CFLAGS="${CFLAGS:=}"
CXXFLAGS="${CXXFLAGS:=}"
AC_ARG_ENABLE(debug, [ --enable-debug turn on debugging [default=no]],[if eval "test x$enable_debug = xyes"; then
OPTIM="-g "
fi])
AC_ARG_ENABLE(shared, [ --enable-shared turn on shared libraries [default=yes]])
AC_ARG_ENABLE(ssl, [ --enable-ssl turn on SSL/TLS support [default=no]])
AC_ARG_ENABLE(libtool_unsupported, [ --enable-libtool-unsupported=LIBTOOL_PATH
turn on building with libtool (UNSUPPORTED!) [default=no]],[if eval "test x$enable_libtool_unsupported != xno"; then
LIBTOOL="$enable_libtool_unsupported"
enable_shared=no
echo "WARNING: libtool is not supported or endorsed by Easy Software Products."
echo " WE DO NOT PROVIDE TECHNICAL SUPPORT FOR LIBTOOL PROBLEMS."
echo " (even if you have a support contract)"
else
LIBTOOL=""
fi])
if test "$enable_shared" != "no"; then
case "$uname" in
SunOS* | UNIX_S*)
@@ -101,30 +88,15 @@ else
DSO=":"
fi
if test "$LIBTOOL" != ""; then
LIBCUPS="libcups.la"
LIBCUPSIMAGE="libcupsimage.la"
LINKCUPS="../cups/\$(LIBCUPS)"
LINKCUPSIMAGE="../filter/\$(LIBCUPSIMAGE)"
DSO=":"
else
LINKCUPS="-L../cups -lcups"
LINKCUPSIMAGE="-L../filter -lcupsimage"
fi
AC_ARG_ENABLE(pam, [ --enable-pam turn on PAM support [default=yes]])
AC_ARG_WITH(fontpath, [ --with-fontpath set font path for pstoraster],fontpath="$withval",fontpath="")
dnl Checks for programs...
AC_PROG_AWK
AC_PROG_CC
AC_PROG_CXX
AC_PROG_CPP
AC_PROG_RANLIB
AC_PATH_PROG(AR,ar)
AC_PATH_PROG(CHMOD,chmod)
AC_PATH_PROG(CHOWN,chown)
AC_PATH_PROG(CP,cp)
AC_PATH_PROG(MV,mv)
AC_PATH_PROG(NROFF,nroff)
@@ -145,34 +117,12 @@ dnl Architecture checks...
AC_C_BIGENDIAN
dnl Check for libraries...
AC_CHECK_LIB(c,crypt,LIBS="$LIBS")
if test "$ac_cv_lib_c_crypt" = "no"; then
AC_CHECK_LIB(crypt,crypt)
fi
AC_CHECK_LIB(c,crypt,LIBS="$LIBS",AC_CHECK_LIB(crypt,crypt))
AC_CHECK_HEADER(crypt.h, AC_DEFINE(HAVE_CRYPT_H))
AC_CHECK_LIB(sec,getspent)
LIBMALLOC=""
AC_CHECK_LIB(c,mallinfo,LIBS="$LIBS"; AC_DEFINE(HAVE_MALLINFO),LIBS="$LIBS")
if test "$ac_cv_lib_c_mallinfo" = "no"; then
AC_CHECK_LIB(malloc,mallinfo,
LIBS="$LIBS"
LIBMALLOC="-lmalloc"
AC_DEFINE(HAVE_MALLINFO),
LIBS="$LIBS")
fi
AC_SUBST(LIBMALLOC)
if test "$enable_pam" != "no"; then
OLDLIBS="$LIBS"
AC_CHECK_LIB(dl,dlopen)
AC_CHECK_LIB(pam,pam_start)
if test "$ac_cv_lib_pam_pam_start" != "no"; then
PAMDIR="/etc/pam.d"
else
PAMDIR=""
LIBS="$OLDLIBS"
fi
AC_SUBST(PAMDIR)
fi
NETLIBS=""
@@ -190,25 +140,6 @@ else
echo "Not using -lnsl since you are running IRIX."
fi)
dnl Encryption support...
SSLLIBS=""
AC_SUBST(SSLLIBS)
if test "$enable_ssl" = "yes"; then
dnl Save the current libraries so the crypto stuff isn't always
dnl included...
SAVELIBS="$LIBS"
LIBS="-lcrypto $LIBS"
AC_CHECK_LIB(ssl,SSL_new,
SSLLIBS="-lssl -lcrypto"
AC_DEFINE(HAVE_LIBSSL)
)
LIBS="$SAVELIBS"
fi
dnl Save the current libraries since we don't want the image libraries
dnl included with every program...
SAVELIBS="$LIBS"
@@ -229,7 +160,7 @@ AC_CHECK_LIB(jpeg, jpeg_destroy_decompress,
LIBJPEG="-ljpeg"
LIBS="$LIBS -ljpeg")
AC_CHECK_LIB(z, gzgets,
AC_CHECK_LIB(z, deflate,
AC_DEFINE(HAVE_LIBZ)
LIBZ="-lz"
LIBS="$LIBS -lz")
@@ -237,7 +168,7 @@ AC_CHECK_LIB(z, gzgets,
dnl PNG library uses math library functions...
AC_CHECK_LIB(m, pow)
AC_CHECK_LIB(png, png_set_tRNS_to_alpha,
AC_CHECK_LIB(png, png_read_info,
AC_DEFINE(HAVE_LIBPNG)
LIBPNG="-lpng")
@@ -251,11 +182,7 @@ LIBS="$SAVELIBS"
dnl Checks for header files.
AC_HEADER_STDC
AC_HEADER_DIRENT
AC_CHECK_HEADER(crypt.h,AC_DEFINE(HAVE_CRYPT_H))
AC_CHECK_HEADER(malloc.h,AC_DEFINE(HAVE_MALLOC_H))
AC_CHECK_HEADER(shadow.h,AC_DEFINE(HAVE_SHADOW_H))
AC_CHECK_HEADER(stddef.h,AC_DEFINE(HAVE_STDDEF_H))
AC_CHECK_HEADER(stdlib.h,AC_DEFINE(HAVE_STDLIB_H))
dnl Checks for string functions.
AC_CHECK_FUNCS(strdup)
@@ -268,10 +195,7 @@ dnl Checks for vsyslog function.
AC_CHECK_FUNCS(vsyslog)
dnl Checks for signal functions.
if test "$uname" != "Linux"; then
AC_CHECK_FUNCS(sigset)
fi
AC_CHECK_FUNCS(sigset)
AC_CHECK_FUNCS(sigaction)
dnl Checks for wait functions.
@@ -280,8 +204,6 @@ AC_CHECK_FUNCS(wait3)
dnl Update compiler options...
if test -n "$GCC"; then
GXX="gcc"
if test -z "$OPTIM"; then
OPTIM="-O2 -g3"
fi
@@ -293,7 +215,7 @@ else
case $uname in
IRIX*)
if test -z "$OPTIM"; then
OPTIM="-O2"
OPTIM="-O2 -g3"
fi
if test $uversion -ge 62; then
OPTIM="$OPTIM -n32 -mips3"
@@ -309,7 +231,7 @@ else
SunOS*)
# Solaris
if test -z "$OPTIM"; then
OPTIM="-xO4"
OPTIM="-O -g3"
fi
if test $PICFLAG = 1; then
OPTIM="-KPIC $OPTIM"
@@ -335,20 +257,16 @@ if test "$DSO" != ":"; then
DSOLIBS="\$(LIBJPEG) \$(LIBPNG) \$(LIBTIFF) \$(LIBZ)"
IMGLIBS=""
# The *BSD, HP-UX, and Solaris run-time linkers need help when
# deciding where to find a DSO. Add linker options to tell them
# where to find the DSO (usually in /usr/lib... duh!)
# The HP-UX and Solaris run-time linkers are EXTREMELY stupid when
# it comes to deciding where to find a DSO. Add linker options to
# tell them where to find the DSO (usually in /usr/lib... duh!)
case $uname in
HP-UX*)
LDFLAGS="$LDFLAGS -Wl,+b,$libdir,+fb"
;;
SunOS*)
# Solaris
LDFLAGS="$LDFLAGS -R$libdir"
;;
FreeBSD* | NetBSD* | OpenBSD*)
# *BSD
LDFLAGS="$LDFLAGS -Wl,-R$libdir"
LDFLAGS="-R$libdir"
;;
esac
else
@@ -361,179 +279,39 @@ AC_SUBST(DSOLIBS)
AC_SUBST(IMGLIBS)
AC_SUBST(LIBCUPS)
AC_SUBST(LIBCUPSIMAGE)
AC_SUBST(LIBTOOL)
AC_SUBST(LINKCUPS)
AC_SUBST(LINKCUPSIMAGE)
dnl Fix "prefix" variable if it hasn't been specified...
if test "$prefix" = "NONE"; then
prefix="/"
fi
dnl Fix "exec_prefix" variable if it hasn't been specified...
if test "$exec_prefix" = "NONE"; then
if test "$prefix" = "/"; then
exec_prefix="/usr"
else
exec_prefix="$prefix"
fi
fi
dnl Fix "sharedstatedir" variable if it hasn't been specified...
if test "$sharedstatedir" = "\${prefix}/com" -a "$prefix" = "/"; then
sharedstatedir="/usr/com"
fi
dnl Fix "infodir" variable if it hasn't been specified...
if test "$infodir" = "\${prefix}/info" -a "$prefix" = "/"; then
infodir="/usr/info"
fi
dnl Fix "datadir" variable if it hasn't been specified...
if test "$datadir" = "\${prefix}/share"; then
if test "$prefix" = "/"; then
datadir="/usr/share"
else
datadir="$prefix/share"
fi
fi
dnl Fix "includedir" variable if it hasn't been specified...
if test "$includedir" = "\${prefix}/include" -a "$prefix" = "/"; then
includedir="/usr/include"
fi
dnl Fix "localstatedir" variable if it hasn't been specified...
if test "$localstatedir" = "\${prefix}/var"; then
if test "$prefix" = "/"; then
localstatedir="/var"
else
localstatedir="$prefix/var"
fi
fi
dnl Fix "sysconfdir" variable if it hasn't been specified...
if test "$sysconfdir" = "\${prefix}/etc"; then
if test "$prefix" = "/"; then
sysconfdir="/etc"
else
sysconfdir="$prefix/etc"
fi
dnl Fix prefix as needed..
if test "$prefix" = "NONE" ; then
prefix="/usr"
fi
dnl Fix "libdir" variable for IRIX 6.x...
if test "$uname" = "IRIX" -a $uversion -ge 62; then
libdir="$exec_prefix/lib32"
if test "$uname" = "IRIX" -a $uversion -ge 65; then
libdir="${prefix}/lib32"
fi
dnl Fix "mandir" variable...
if test "$mandir" = "\${prefix}/man" -a "$prefix" = "/"; then
if test "$uname" = "IRIX"; then
mandir="/usr/share/catman"
else
mandir="/usr/man"
fi
dnl Need special attention for the default location...
if test "$prefix" = "/usr" ; then
CUPS_SERVERROOT="/etc/cups"
CUPS_LOGDIR="/var/log/cups"
CUPS_REQUESTS="/var/spool/cups"
AC_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$CUPS_SERVERROOT")
AC_DEFINE_UNQUOTED(CUPS_LOGDIR, "$CUPS_LOGDIR")
AC_DEFINE_UNQUOTED(CUPS_REQUESTS, "$CUPS_REQUESTS")
else
CUPS_SERVERROOT='${prefix}/etc/cups'
CUPS_LOGDIR='${prefix}/log/cups'
CUPS_REQUESTS='${prefix}/spool/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$prefix/etc/cups")
AC_DEFINE_UNQUOTED(CUPS_LOGDIR, "$prefix/log/cups")
AC_DEFINE_UNQUOTED(CUPS_REQUESTS, "$prefix/spool/cups")
fi
dnl Fix "fontpath" variable...
if test "x$fontpath" = "x"; then
fontpath="$datadir/cups/fonts"
fi
CUPS_SERVERBIN='${prefix}/lib/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERBIN, "$prefix/lib/cups")
dnl Setup manpage extensions...
case "$uname" in
FreeBSD* | NetBSD* | OpenBSD*)
# *BSD
CAT1EXT=0
CAT5EXT=0
CAT8EXT=0
;;
IRIX*)
# SGI IRIX
CAT1EXT=z
CAT5EXT=z
CAT8EXT=z
;;
*)
# All others
CAT1EXT=1
CAT5EXT=5
CAT8EXT=8
;;
esac
AC_SUBST(CAT1EXT)
AC_SUBST(CAT5EXT)
AC_SUBST(CAT8EXT)
dnl Setup init.d locations...
case "$uname" in
FreeBSD* | NetBSD* | OpenBSD*)
# *BSD
INITDIR=""
INITDDIR=""
;;
Linux*)
# Linux seems to choose an init.d directory at random...
if test -d /sbin/init.d; then
# SuSE
INITDIR="/sbin/init.d"
INITDDIR=".."
else
if test -d /etc/rc.d; then
# RedHat
INITDIR="/etc/rc.d"
INITDDIR="../init.d"
else
# Others
INITDIR="/etc"
INITDDIR="../init.d"
fi
fi
;;
OSF1* | HP-UX*)
INITDIR="/sbin"
INITDDIR="../init.d"
;;
*)
INITDIR="/etc"
INITDDIR="../init.d"
;;
esac
AC_SUBST(INITDIR)
AC_SUBST(INITDDIR)
dnl Setup default locations...
CUPS_SERVERROOT='${prefix}/etc/cups'
CUPS_LOGDIR='${prefix}/var/log/cups'
CUPS_REQUESTS='${prefix}/var/spool/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$prefix/etc/cups")
AC_DEFINE_UNQUOTED(CUPS_LOGDIR, "$prefix/var/log/cups")
AC_DEFINE_UNQUOTED(CUPS_REQUESTS, "$prefix/var/spool/cups")
dnl See what directory to put server executables...
case "$uname" in
FreeBSD* | NetBSD* | OpenBSD*)
# *BSD
INSTALL_SYSV=""
CUPS_SERVERBIN='${exec_prefix}/libexec/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERBIN, "$exec_prefix/libexec/cups")
;;
*)
# All others
INSTALL_SYSV="install-sysv"
CUPS_SERVERBIN='${exec_prefix}/lib/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERBIN, "$exec_prefix/lib/cups")
;;
esac
AC_SUBST(INSTALL_SYSV)
AC_SUBST(CUPS_SERVERROOT)
AC_SUBST(CUPS_SERVERBIN)
AC_SUBST(CUPS_LOGDIR)
@@ -541,39 +319,36 @@ AC_SUBST(CUPS_REQUESTS)
dnl Set the CUPS_LOCALE directory...
case "$uname" in
Linux* | FreeBSD* | NetBSD* | OpenBSD*)
CUPS_LOCALEDIR='${exec_prefix}/share/locale'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$exec_prefix/share/locale")
Linux)
CUPS_LOCALEDIR='${prefix}/share/locale'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$prefix/share/locale")
;;
OSF1*)
CUPS_LOCALEDIR='${exec_prefix}/lib/nls/msg'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$exec_prefix/lib/nls/msg")
OSF1)
CUPS_LOCALEDIR='${prefix}/lib/nls/msg'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$prefix/lib/nls/msg")
;;
*)
# This is the standard System V location...
CUPS_LOCALEDIR='${exec_prefix}/lib/locale'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$exec_prefix/lib/locale")
CUPS_LOCALEDIR='${prefix}/lib/locale'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$prefix/lib/locale")
;;
esac
AC_SUBST(CUPS_LOCALEDIR)
dnl Set the CUPS_DATADIR directory...
CUPS_DATADIR='${exec_prefix}/share/cups'
AC_DEFINE_UNQUOTED(CUPS_DATADIR, "$exec_prefix/share/cups")
CUPS_DATADIR='${datadir}/cups'
AC_DEFINE_UNQUOTED(CUPS_DATADIR, "$prefix/share/cups")
AC_SUBST(CUPS_DATADIR)
dnl Set the CUPS_DOCROOT directory...
CUPS_DOCROOT='${exec_prefix}/share/doc/cups'
AC_DEFINE_UNQUOTED(CUPS_DOCROOT, "$exec_prefix/share/doc/cups")
AC_SUBST(CUPS_DOCROOT)
dnl Set the CUPS_DOCDIR directory...
CUPS_DOCDIR='${datadir}/doc/cups'
AC_DEFINE_UNQUOTED(CUPS_DOCDIR, "$prefix/share/doc/cups")
AC_SUBST(CUPS_DOCDIR)
dnl Set the CUPS_FONTPATH directory...
AC_DEFINE_UNQUOTED(CUPS_FONTPATH, "$fontpath")
AC_OUTPUT(Makedefs cups.sh)
AC_OUTPUT(Makedefs)
dnl
dnl End of "$Id$".
+99
Ver Arquivo
@@ -15,6 +15,105 @@ Package=<4>
###############################################################################
Project: "cupsd"=.\scheduler\cupsd.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name cups
End Project Dependency
}}}
###############################################################################
Project: "hpgltops"=.\filter\hpgltops.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name cups
End Project Dependency
}}}
###############################################################################
Project: "image"=.\filter\image.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Project: "pstops"=.\filter\pstops.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Project: "testmime"=.\cups\testmime.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name cups
End Project Dependency
}}}
###############################################################################
Project: "testppd"=.\cups\testppd.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name cups
End Project Dependency
}}}
###############################################################################
Project: "texttops"=.\filter\texttops.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name cups
End Project Dependency
}}}
###############################################################################
Global:
Package=<5>
+357 -251
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: cups.list 1471 2000-12-11 04:40:31Z mike $"
# "$Id: cups.list 986 2000-03-13 18:56:08Z mike $"
#
# ESP Package Manager (EPM) file list for the Common UNIX Printing
# System (CUPS).
@@ -23,298 +23,404 @@
# WWW: http://www.cups.org
#
# Product information
%product Common UNIX Printing System
%copyright 1993-2000 by Easy Software Products, All Rights Reserved.
%vendor Easy Software Products
%license LICENSE.txt
%readme README.txt
%version 1.1.5
%version 1.1b2
%incompat printpro
# Server programs
%system all
# Server files
f 0555 root sys $SBINDIR/cupsd scheduler/cupsd
d 0555 root sys $SERVERBIN -
d 0555 root sys $SERVERBIN/backend -
f 0555 root sys $SERVERBIN/backend/ipp backend/ipp
l 0555 root sys $SERVERBIN/backend/http ipp
f 0555 root sys $SERVERBIN/backend/lpd backend/lpd
f 0555 root sys $SERVERBIN/backend/parallel backend/parallel
f 0555 root sys $SERVERBIN/backend/serial backend/serial
f 0555 root sys $SERVERBIN/backend/socket backend/socket
f 0555 root sys $SERVERBIN/backend/usb backend/usb
d 0555 root sys $SERVERBIN/cgi-bin -
f 0555 root sys $SERVERBIN/cgi-bin/admin.cgi cgi-bin/admin.cgi
f 0555 root sys $SERVERBIN/cgi-bin/classes.cgi cgi-bin/classes.cgi
f 0555 root sys $SERVERBIN/cgi-bin/jobs.cgi cgi-bin/jobs.cgi
f 0555 root sys $SERVERBIN/cgi-bin/printers.cgi cgi-bin/printers.cgi
d 0555 root sys $SERVERBIN/daemon -
f 0555 root sys $SERVERBIN/daemon/cups-lpd scheduler/cups-lpd
f 0555 root sys $SERVERBIN/daemon/cups-polld scheduler/cups-polld
d 0555 root sys $SERVERBIN/filter -
f 0555 root sys $SERVERBIN/filter/pstoraster pstoraster/pstoraster
f 0555 root sys $SERVERBIN/filter/pdftops pdftops/pdftops
f 0555 root sys $SERVERBIN/filter/imagetops filter/imagetops
f 0555 root sys $SERVERBIN/filter/pstops filter/pstops
f 0555 root sys $SERVERBIN/filter/texttops filter/texttops
f 0555 root sys $SERVERBIN/filter/rastertoepson filter/rastertoepson
f 0555 root sys $SERVERBIN/filter/rastertohp filter/rastertohp
f 0555 root sys $SERVERBIN/filter/hpgltops filter/hpgltops
f 0555 root sys $SERVERBIN/filter/imagetoraster filter/imagetoraster
f 0500 root sys /usr/sbin/cupsd scheduler/cupsd
f 0555 root sys /usr/lib/cups/backend/ipp backend/ipp
l 0555 root sys /usr/lib/cups/backend/http ipp
f 0555 root sys /usr/lib/cups/backend/lpd backend/lpd
f 0555 root sys /usr/lib/cups/backend/parallel backend/parallel
f 0555 root sys /usr/lib/cups/backend/serial backend/serial
f 0555 root sys /usr/lib/cups/backend/socket backend/socket
f 0555 root sys /usr/lib/cups/backend/usb backend/usb
f 0555 root sys /usr/lib/cups/cgi-bin/admin.cgi cgi-bin/admin.cgi
f 0555 root sys /usr/lib/cups/cgi-bin/classes.cgi cgi-bin/classes.cgi
f 0555 root sys /usr/lib/cups/cgi-bin/jobs.cgi cgi-bin/jobs.cgi
f 0555 root sys /usr/lib/cups/cgi-bin/printers.cgi cgi-bin/printers.cgi
f 0555 root sys /usr/lib/cups/daemon/cups-polld scheduler/cups-polld
f 0555 root sys /usr/lib/cups/filter/pstoraster pstoraster/pstoraster
l 0555 root sys /usr/lib/cups/filter/pdftops pstoraster
f 0555 root sys /usr/lib/cups/filter/imagetops filter/imagetops
f 0555 root sys /usr/lib/cups/filter/pstops filter/pstops
f 0555 root sys /usr/lib/cups/filter/texttops filter/texttops
f 0555 root sys /usr/lib/cups/filter/rastertoepson filter/rastertoepson
f 0555 root sys /usr/lib/cups/filter/rastertohp filter/rastertohp
f 0555 root sys /usr/lib/cups/filter/hpgltops filter/hpgltops
f 0555 root sys /usr/lib/cups/filter/imagetoraster filter/imagetoraster
# Admin commands
l 0555 root sys $BINDIR/disable $SBINDIR/accept
l 0555 root sys $BINDIR/enable $SBINDIR/accept
l 0555 root sys $LIBDIR/accept $SBINDIR/accept
l 0555 root sys $LIBDIR/lpadmin $SBINDIR/lpadmin
l 0555 root sys $LIBDIR/reject accept
f 0555 root sys $SBINDIR/accept systemv/accept
f 0555 root sys $SBINDIR/lpadmin systemv/lpadmin
f 0555 root sys $SBINDIR/lpc berkeley/lpc
f 0555 root sys $SBINDIR/lpinfo systemv/lpinfo
f 0555 root sys $SBINDIR/lpmove systemv/lpmove
l 0555 root sys $SBINDIR/reject accept
%system irix
l 0555 root sys /usr/etc/lpc $SBINDIR/lpc
%system all
l 0555 root sys /usr/bin/disable /usr/sbin/accept
l 0555 root sys /usr/bin/enable /usr/sbin/accept
l 0555 root sys /usr/lib/accept /usr/sbin/accept
l 0555 root sys /usr/lib/lpadmin /usr/sbin/lpadmin
l 0555 root sys /usr/lib/reject accept
f 0555 root sys /usr/sbin/accept systemv/accept
f 0555 root sys /usr/sbin/lpadmin systemv/lpadmin
f 0555 root sys /usr/sbin/lpc berkeley/lpc
l 0555 root sys /usr/sbin/reject accept
# User commands
f 0555 root sys $BINDIR/cancel systemv/cancel
f 0555 root sys $BINDIR/lp systemv/lp
f 0555 root sys $BINDIR/lpoptions systemv/lpoptions
f 4555 root sys $BINDIR/lppasswd systemv/lppasswd
f 0555 root sys $BINDIR/lpq berkeley/lpq
f 0555 root sys $BINDIR/lpr berkeley/lpr
f 0555 root sys $BINDIR/lprm berkeley/lprm
f 0555 root sys $BINDIR/lpstat systemv/lpstat
%system irix
l 0555 root sys /usr/bsd/lpq $BINDIR/lpq
l 0555 root sys /usr/bsd/lpr $BINDIR/lpr
l 0555 root sys /usr/bsd/lprm $BINDIR/lprm
%system all
f 0555 root sys /usr/bin/cancel systemv/cancel
f 0555 root sys /usr/bin/lp systemv/lp
f 0555 root sys /usr/bin/lpoptions systemv/lpoptions
f 4555 root sys /usr/bin/lppasswd systemv/lppasswd
f 0555 root sys /usr/bin/lpq berkeley/lpq
f 0555 root sys /usr/bin/lpr berkeley/lpr
f 0555 root sys /usr/bin/lprm berkeley/lprm
f 0555 root sys /usr/bin/lpstat systemv/lpstat
# DSOs
%system hpux
f 0555 root sys $LIBDIR/libcups.sl.2 cups/libcups.sl.2
l 0555 root sys $LIBDIR/libcups.sl libcups.sl.2
f 0555 root sys $LIBDIR/libcupsimage.sl.2 filter/libcupsimage.sl.2
l 0555 root sys $LIBDIR/libcupsimage.sl libcupsimage.sl.2
%system !hpux
f 0555 root sys $LIBDIR/libcups.so.2 cups/libcups.so.2
l 0555 root sys $LIBDIR/libcups.so libcups.so.2
f 0555 root sys $LIBDIR/libcupsimage.so.2 filter/libcupsimage.so.2
l 0555 root sys $LIBDIR/libcupsimage.so libcupsimage.so.2
f 0555 root sys /usr/lib/libcups.sl.2 cups/libcups.sl.2
l 0555 root sys /usr/lib/libcups.sl libcups.sl.2
f 0555 root sys /usr/lib/libcupsimage.sl.2 filter/libcupsimage.sl.2
l 0555 root sys /usr/lib/libcupsimage.sl libcupsimage.sl.2
%system irix-6.5
f 0555 root sys /usr/lib32/libcups.so.2 cups/libcups.so.2
l 0555 root sys /usr/lib32/libcups.so libcups.so.2
f 0555 root sys /usr/lib32/libcupsimage.so.2 filter/libcupsimage.so.2
l 0555 root sys /usr/lib32/libcupsimage.so libcupsimage.so.2
%system !irix-6.5 !hpux
f 0555 root sys /usr/lib/libcups.so.2 cups/libcups.so.2
l 0555 root sys /usr/lib/libcups.so libcups.so.2
f 0555 root sys /usr/lib/libcupsimage.so.2 filter/libcupsimage.so.2
l 0555 root sys /usr/lib/libcupsimage.so libcupsimage.so.2
%system all
# Directories
d 0755 root sys $LOGDIR -
d 0700 lp sys $REQUESTS -
d 1700 lp sys $REQUESTS/tmp -
d 0711 root sys /etc/cups/certs
d 0755 root sys /etc/cups/interfaces
d 0755 root sys /etc/cups/ppd
d 0755 root sys /var/log/cups
d 0755 root sys /var/spool/cups
# Data files
f 0444 root sys $LOCALEDIR/C/cups_C locale/C/cups_C
f 0444 root sys $LOCALEDIR/de/cups_de locale/de/cups_de
f 0444 root sys $LOCALEDIR/en/cups_en locale/en/cups_en
f 0444 root sys $LOCALEDIR/es/cups_es locale/es/cups_es
f 0444 root sys $LOCALEDIR/fr/cups_fr locale/fr/cups_fr
f 0444 root sys $LOCALEDIR/it/cups_it locale/it/cups_it
%system linux
f 0444 root sys /usr/share/locale/C/cups_C locale/C/cups_C
f 0444 root sys /usr/share/locale/de/cups_de locale/de/cups_de
f 0444 root sys /usr/share/locale/en/cups_en locale/en/cups_en
f 0444 root sys /usr/share/locale/es/cups_es locale/es/cups_es
f 0444 root sys /usr/share/locale/fr/cups_fr locale/fr/cups_fr
f 0444 root sys /usr/share/locale/it/cups_it locale/it/cups_it
d 0555 root sys $DATADIR -
%system dunix
f 0444 root sys /usr/lib/nls/msg/C/cups_C locale/C/cups_C
f 0444 root sys /usr/lib/nls/msg/de/cups_de locale/de/cups_de
f 0444 root sys /usr/lib/nls/msg/en/cups_en locale/en/cups_en
f 0444 root sys /usr/lib/nls/msg/es/cups_es locale/es/cups_es
f 0444 root sys /usr/lib/nls/msg/fr/cups_fr locale/fr/cups_fr
f 0444 root sys /usr/lib/nls/msg/it/cups_it locale/it/cups_it
d 0555 root sys $DATADIR/banners -
f 0444 root sys $DATADIR/banners/classified data/classified
f 0444 root sys $DATADIR/banners/confidential data/confidential
f 0444 root sys $DATADIR/banners/secret data/secret
f 0444 root sys $DATADIR/banners/standard data/standard
f 0444 root sys $DATADIR/banners/topsecret data/topsecret
f 0444 root sys $DATADIR/banners/unclassified data/unclassified
%system !linux dunix
f 0444 root sys /usr/lib/locale/C/cups_C locale/C/cups_C
f 0444 root sys /usr/lib/locale/de/cups_de locale/de/cups_de
f 0444 root sys /usr/lib/locale/en/cups_en locale/en/cups_en
f 0444 root sys /usr/lib/locale/es/cups_es locale/es/cups_es
f 0444 root sys /usr/lib/locale/fr/cups_fr locale/fr/cups_fr
f 0444 root sys /usr/lib/locale/it/cups_it locale/it/cups_it
d 0555 root sys $DATADIR/charsets -
f 0444 root sys $DATADIR/charsets/windows-874 data/windows-874
f 0444 root sys $DATADIR/charsets/windows-1250 data/windows-1250
f 0444 root sys $DATADIR/charsets/windows-1251 data/windows-1251
f 0444 root sys $DATADIR/charsets/windows-1252 data/windows-1252
f 0444 root sys $DATADIR/charsets/windows-1253 data/windows-1253
f 0444 root sys $DATADIR/charsets/windows-1254 data/windows-1254
f 0444 root sys $DATADIR/charsets/windows-1255 data/windows-1255
f 0444 root sys $DATADIR/charsets/windows-1256 data/windows-1256
f 0444 root sys $DATADIR/charsets/windows-1257 data/windows-1257
f 0444 root sys $DATADIR/charsets/windows-1258 data/windows-1258
f 0444 root sys $DATADIR/charsets/iso-8859-1 data/iso-8859-1
f 0444 root sys $DATADIR/charsets/iso-8859-14 data/iso-8859-14
f 0444 root sys $DATADIR/charsets/iso-8859-15 data/iso-8859-15
f 0444 root sys $DATADIR/charsets/iso-8859-2 data/iso-8859-2
f 0444 root sys $DATADIR/charsets/iso-8859-3 data/iso-8859-3
f 0444 root sys $DATADIR/charsets/iso-8859-4 data/iso-8859-4
f 0444 root sys $DATADIR/charsets/iso-8859-5 data/iso-8859-5
f 0444 root sys $DATADIR/charsets/iso-8859-6 data/iso-8859-6
f 0444 root sys $DATADIR/charsets/iso-8859-7 data/iso-8859-7
f 0444 root sys $DATADIR/charsets/iso-8859-8 data/iso-8859-8
f 0444 root sys $DATADIR/charsets/iso-8859-9 data/iso-8859-9
f 0444 root sys $DATADIR/charsets/utf-8 data/utf-8
%system all
f 0444 root sys /usr/share/cups/charsets/cp874 data/cp874
f 0444 root sys /usr/share/cups/charsets/cp1250 data/cp1250
f 0444 root sys /usr/share/cups/charsets/cp1251 data/cp1251
f 0444 root sys /usr/share/cups/charsets/cp1252 data/cp1252
f 0444 root sys /usr/share/cups/charsets/cp1253 data/cp1253
f 0444 root sys /usr/share/cups/charsets/cp1254 data/cp1254
f 0444 root sys /usr/share/cups/charsets/cp1255 data/cp1255
f 0444 root sys /usr/share/cups/charsets/cp1256 data/cp1256
f 0444 root sys /usr/share/cups/charsets/cp1257 data/cp1257
f 0444 root sys /usr/share/cups/charsets/cp1258 data/cp1258
f 0444 root sys /usr/share/cups/charsets/iso-8859-1 data/iso-8859-1
f 0444 root sys /usr/share/cups/charsets/iso-8859-14 data/iso-8859-14
f 0444 root sys /usr/share/cups/charsets/iso-8859-15 data/iso-8859-15
f 0444 root sys /usr/share/cups/charsets/iso-8859-2 data/iso-8859-2
f 0444 root sys /usr/share/cups/charsets/iso-8859-3 data/iso-8859-3
f 0444 root sys /usr/share/cups/charsets/iso-8859-4 data/iso-8859-4
f 0444 root sys /usr/share/cups/charsets/iso-8859-5 data/iso-8859-5
f 0444 root sys /usr/share/cups/charsets/iso-8859-6 data/iso-8859-6
f 0444 root sys /usr/share/cups/charsets/iso-8859-7 data/iso-8859-7
f 0444 root sys /usr/share/cups/charsets/iso-8859-8 data/iso-8859-8
f 0444 root sys /usr/share/cups/charsets/iso-8859-9 data/iso-8859-9
f 0444 root sys /usr/share/cups/charsets/utf-8 data/utf-8
d 0555 root sys $DATADIR/data -
f 0444 root sys $DATADIR/data/HPGLprolog data/HPGLprolog
f 0444 root sys $DATADIR/data/psglyphs data/psglyphs
f 0444 root sys $DATADIR/data/testprint.ps data/testprint.ps
f 0444 root sys /usr/share/cups/data/HPGLprolog data/HPGLprolog
f 0444 root sys /usr/share/cups/data/psglyphs data/psglyphs
f 0444 root sys /usr/share/cups/data/testprint.ps data/testprint.ps
f 0444 root sys /usr/share/cups/fonts/AvantGarde-Book fonts/AvantGarde-Book
f 0444 root sys /usr/share/cups/fonts/AvantGarde-BookOblique fonts/AvantGarde-BookOblique
f 0444 root sys /usr/share/cups/fonts/AvantGarde-Demi fonts/AvantGarde-Demi
f 0444 root sys /usr/share/cups/fonts/AvantGarde-DemiOblique fonts/AvantGarde-DemiOblique
f 0444 root sys /usr/share/cups/fonts/Bookman-Demi fonts/Bookman-Demi
f 0444 root sys /usr/share/cups/fonts/Bookman-DemiItalic fonts/Bookman-DemiItalic
f 0444 root sys /usr/share/cups/fonts/Bookman-Light fonts/Bookman-Light
f 0444 root sys /usr/share/cups/fonts/Bookman-LightItalic fonts/Bookman-LightItalic
f 0444 root sys /usr/share/cups/fonts/Charter-Bold fonts/Charter-Bold
f 0444 root sys /usr/share/cups/fonts/Charter-BoldItalic fonts/Charter-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Charter-Italic fonts/Charter-Italic
f 0444 root sys /usr/share/cups/fonts/Charter-Roman fonts/Charter-Roman
f 0444 root sys /usr/share/cups/fonts/Courier fonts/Courier
f 0444 root sys /usr/share/cups/fonts/Courier-Bold fonts/Courier-Bold
f 0444 root sys /usr/share/cups/fonts/Courier-BoldOblique fonts/Courier-BoldOblique
f 0444 root sys /usr/share/cups/fonts/Courier-Oblique fonts/Courier-Oblique
f 0444 root sys /usr/share/cups/fonts/Helvetica fonts/Helvetica
f 0444 root sys /usr/share/cups/fonts/Helvetica-Bold fonts/Helvetica-Bold
f 0444 root sys /usr/share/cups/fonts/Helvetica-BoldOblique fonts/Helvetica-BoldOblique
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow fonts/Helvetica-Narrow
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow-Bold fonts/Helvetica-Narrow-Bold
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow-BoldOblique fonts/Helvetica-Narrow-BoldOblique
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow-Oblique fonts/Helvetica-Narrow-Oblique
f 0444 root sys /usr/share/cups/fonts/Helvetica-Oblique fonts/Helvetica-Oblique
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-Bold fonts/NewCenturySchlbk-Bold
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-BoldItalic fonts/NewCenturySchlbk-BoldItalic
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-Italic fonts/NewCenturySchlbk-Italic
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-Roman fonts/NewCenturySchlbk-Roman
f 0444 root sys /usr/share/cups/fonts/Palatino-Bold fonts/Palatino-Bold
f 0444 root sys /usr/share/cups/fonts/Palatino-BoldItalic fonts/Palatino-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Palatino-Italic fonts/Palatino-Italic
f 0444 root sys /usr/share/cups/fonts/Palatino-Roman fonts/Palatino-Roman
f 0444 root sys /usr/share/cups/fonts/Symbol fonts/Symbol
f 0444 root sys /usr/share/cups/fonts/Times-Bold fonts/Times-Bold
f 0444 root sys /usr/share/cups/fonts/Times-BoldItalic fonts/Times-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Times-Italic fonts/Times-Italic
f 0444 root sys /usr/share/cups/fonts/Times-Roman fonts/Times-Roman
f 0444 root sys /usr/share/cups/fonts/Utopia-Bold fonts/Utopia-Bold
f 0444 root sys /usr/share/cups/fonts/Utopia-BoldItalic fonts/Utopia-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Utopia-Italic fonts/Utopia-Italic
f 0444 root sys /usr/share/cups/fonts/Utopia-Regular fonts/Utopia-Regular
f 0444 root sys /usr/share/cups/fonts/ZapfChancery-MediumItalic fonts/ZapfChancery-MediumItalic
f 0444 root sys /usr/share/cups/fonts/ZapfDingbats fonts/ZapfDingbats
f 0444 root sys /usr/share/cups/pstoraster/Fontmap pstoraster/Fontmap
f 0444 root sys /usr/share/cups/pstoraster/gs_btokn.ps pstoraster/gs_btokn.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ccfnt.ps pstoraster/gs_ccfnt.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cff.ps pstoraster/gs_cff.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cidfn.ps pstoraster/gs_cidfn.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cmap.ps pstoraster/gs_cmap.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cmdl.ps pstoraster/gs_cmdl.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dbt_e.ps pstoraster/gs_dbt_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_diskf.ps pstoraster/gs_diskf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dpnxt.ps pstoraster/gs_dpnxt.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dps1.ps pstoraster/gs_dps1.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dps2.ps pstoraster/gs_dps2.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dps.ps pstoraster/gs_dps.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_epsf.ps pstoraster/gs_epsf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_fform.ps pstoraster/gs_fform.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_fonts.ps pstoraster/gs_fonts.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_init.ps pstoraster/gs_init.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_iso_e.ps pstoraster/gs_iso_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_kanji.ps pstoraster/gs_kanji.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ksb_e.ps pstoraster/gs_ksb_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_l2img.ps pstoraster/gs_l2img.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_lev2.ps pstoraster/gs_lev2.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ll3.ps pstoraster/gs_ll3.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_mex_e.ps pstoraster/gs_mex_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_mro_e.ps pstoraster/gs_mro_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pdfwr.ps pstoraster/gs_pdfwr.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pdf_e.ps pstoraster/gs_pdf_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pfile.ps pstoraster/gs_pfile.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_res.ps pstoraster/gs_res.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_setpd.ps pstoraster/gs_setpd.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_statd.ps pstoraster/gs_statd.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_std_e.ps pstoraster/gs_std_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_sym_e.ps pstoraster/gs_sym_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ttf.ps pstoraster/gs_ttf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_typ32.ps pstoraster/gs_typ32.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_typ42.ps pstoraster/gs_typ42.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_type1.ps pstoraster/gs_type1.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wan_e.ps pstoraster/gs_wan_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wl1_e.ps pstoraster/gs_wl1_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wl2_e.ps pstoraster/gs_wl2_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wl5_e.ps pstoraster/gs_wl5_e.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf2dsc.ps pstoraster/pdf2dsc.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_base.ps pstoraster/pdf_base.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_draw.ps pstoraster/pdf_draw.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_font.ps pstoraster/pdf_font.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_main.ps pstoraster/pdf_main.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_ops.ps pstoraster/pdf_ops.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_sec.ps pstoraster/pdf_sec.ps
f 0444 root sys /usr/share/cups/model/deskjet.ppd ppd/deskjet.ppd
f 0444 root sys /usr/share/cups/model/laserjet.ppd ppd/laserjet.ppd
f 0444 root sys /usr/share/cups/model/stcolor.ppd ppd/stcolor.ppd
f 0444 root sys /usr/share/cups/model/stphoto.ppd ppd/stphoto.ppd
d 0555 root sys $DATADIR/fonts -
f 0444 root sys $DATADIR/fonts fonts/*
d 0555 root sys $DATADIR/pstoraster -
f 0444 root sys $DATADIR/pstoraster/Fontmap pstoraster/Fontmap
f 0444 root sys $DATADIR/pstoraster pstoraster/gs*.ps
d 0555 root sys $DATADIR/model -
f 0444 root sys $DATADIR/model ppd/*.ppd
d 0555 root sys $DATADIR/templates -
f 0444 root sys $DATADIR/templates templates/*.tmpl
f 0444 root sys /usr/share/cups/templates/add-class.tmpl templates/add-class.tmpl
f 0444 root sys /usr/share/cups/templates/add-printer.tmpl templates/add-printer.tmpl
f 0444 root sys /usr/share/cups/templates/admin-op.tmpl templates/admin-op.tmpl
f 0444 root sys /usr/share/cups/templates/admin.tmpl templates/admin.tmpl
f 0444 root sys /usr/share/cups/templates/choose-device.tmpl templates/choose-device.tmpl
f 0444 root sys /usr/share/cups/templates/choose-make.tmpl templates/choose-make.tmpl
f 0444 root sys /usr/share/cups/templates/choose-model.tmpl templates/choose-model.tmpl
f 0444 root sys /usr/share/cups/templates/choose-serial.tmpl templates/choose-serial.tmpl
f 0444 root sys /usr/share/cups/templates/choose-uri.tmpl templates/choose-uri.tmpl
f 0444 root sys /usr/share/cups/templates/classes.tmpl templates/classes.tmpl
f 0444 root sys /usr/share/cups/templates/error.tmpl templates/error.tmpl
f 0444 root sys /usr/share/cups/templates/header.tmpl templates/header.tmpl
f 0444 root sys /usr/share/cups/templates/job-cancel.tmpl templates/job-cancel.tmpl
f 0444 root sys /usr/share/cups/templates/job-hold.tmpl templates/job-hold.tmpl
f 0444 root sys /usr/share/cups/templates/job-release.tmpl templates/job-release.tmpl
f 0444 root sys /usr/share/cups/templates/jobs.tmpl templates/jobs.tmpl
f 0444 root sys /usr/share/cups/templates/modify-class.tmpl templates/modify-class.tmpl
f 0444 root sys /usr/share/cups/templates/modify-printer.tmpl templates/modify-printer.tmpl
f 0444 root sys /usr/share/cups/templates/option-boolean.tmpl templates/option-boolean.tmpl
f 0444 root sys /usr/share/cups/templates/option-header.tmpl templates/option-header.tmpl
f 0444 root sys /usr/share/cups/templates/option-pickmany.tmpl templates/option-pickmany.tmpl
f 0444 root sys /usr/share/cups/templates/option-pickone.tmpl templates/option-pickone.tmpl
f 0444 root sys /usr/share/cups/templates/option-trailer.tmpl templates/option-trailer.tmpl
f 0444 root sys /usr/share/cups/templates/printer-accept.tmpl templates/printer-accept.tmpl
f 0444 root sys /usr/share/cups/templates/printer-reject.tmpl templates/printer-reject.tmpl
f 0444 root sys /usr/share/cups/templates/printer-start.tmpl templates/printer-start.tmpl
f 0444 root sys /usr/share/cups/templates/printer-stop.tmpl templates/printer-stop.tmpl
f 0444 root sys /usr/share/cups/templates/printers.tmpl templates/printers.tmpl
f 0444 root sys /usr/share/cups/templates/test-page.tmpl templates/test-page.tmpl
f 0444 root sys /usr/share/cups/templates/trailer.tmpl templates/trailer.tmpl
# Config files
d 0555 root sys $SERVERROOT -
d 0711 root sys $SERVERROOT/certs -
d 0755 root sys $SERVERROOT/interfaces -
d 0755 root sys $SERVERROOT/ppd -
c 0644 root sys $SERVERROOT conf/*.conf
f 0644 root sys $SERVERROOT/mime.convs conf/mime.convs
f 0644 root sys $SERVERROOT/mime.types conf/mime.types
c 0644 root sys /etc/cups/classes.conf conf/classes.conf
c 0644 root sys /etc/cups/cupsd.conf conf/cupsd.conf
f 0644 root sys /etc/cups/mime.convs conf/mime.convs
f 0644 root sys /etc/cups/mime.types conf/mime.types
c 0644 root sys /etc/cups/printers.conf conf/printers.conf
%system linux
d 0555 root sys $PAMDIR -
c 0644 root sys $PAMDIR/cups data/cups.pam
c 0644 root sys $PAMDIR/cups.suse data/cups.suse
%install if test -f /lib/security/pam_unix.so; then
%install mv $PAMDIR/cups.suse $PAMDIR/cups
%install fi
# Dummy printcap file for Digital UNIX and Linux...
%system dunix linux
%format !rpm
f 0644 root sys /etc/printcap conf/printcap
%system all
%format all
# Developer files
d 0555 root sys $INCLUDEDIR/cups -
f 0444 root sys $INCLUDEDIR/cups/cups.h cups/cups.h
f 0444 root sys $INCLUDEDIR/cups/http.h cups/http.h
f 0444 root sys $INCLUDEDIR/cups/image.h filter/image.h
f 0444 root sys $INCLUDEDIR/cups/ipp.h cups/ipp.h
f 0444 root sys $INCLUDEDIR/cups/language.h cups/language.h
f 0444 root sys $INCLUDEDIR/cups/md5.h cups/md5.h
f 0444 root sys $INCLUDEDIR/cups/ppd.h cups/ppd.h
f 0444 root sys $INCLUDEDIR/cups/raster.h filter/raster.h
f 0444 root sys /usr/include/cups/cups.h cups/cups.h
f 0444 root sys /usr/include/cups/http.h cups/http.h
f 0444 root sys /usr/include/cups/image.h filter/image.h
f 0444 root sys /usr/include/cups/ipp.h cups/ipp.h
f 0444 root sys /usr/include/cups/language.h cups/language.h
f 0444 root sys /usr/include/cups/ppd.h cups/ppd.h
f 0444 root sys /usr/include/cups/raster.h filter/raster.h
f 0444 root sys $LIBDIR/libcups.a cups/libcups.a
%system irix-6.5
f 0444 root sys /usr/lib32/libcups.a cups/libcups.a
%system !irix-6.5
f 0444 root sys /usr/lib/libcups.a cups/libcups.a
%system all
# Documentation files
d 0555 root sys $DOCDIR -
f 0444 root sys $DOCDIR/cups.css doc/cups.css
f 0444 root sys $DOCDIR doc/*.html
f 0444 root sys $DOCDIR doc/*.pdf
d 0555 root sys $DOCDIR/images -
f 0444 root sys $DOCDIR/images doc/images/*.gif
f 0444 root sys /usr/share/doc/cups/cups.css doc/cups.css
f 0444 root sys /usr/share/doc/cups/documentation.html doc/documentation.html
f 0444 root sys /usr/share/doc/cups/index.html doc/index.html
f 0444 root sys /usr/share/doc/cups/images/accept-jobs.gif doc/images/accept-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/add-class.gif doc/images/add-class.gif
f 0444 root sys /usr/share/doc/cups/images/add-printer.gif doc/images/add-printer.gif
f 0444 root sys /usr/share/doc/cups/images/cancel-job.gif doc/images/cancel-job.gif
f 0444 root sys /usr/share/doc/cups/images/cancel-jobs.gif doc/images/cancel-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/cancel.gif doc/images/cancel.gif
f 0444 root sys /usr/share/doc/cups/images/classes.gif doc/images/classes.gif
f 0444 root sys /usr/share/doc/cups/images/continue.gif doc/images/continue.gif
f 0444 root sys /usr/share/doc/cups/images/cups-bar.gif doc/images/cups-bar.gif
f 0444 root sys /usr/share/doc/cups/images/cups-block-diagram.gif doc/images/cups-block-diagram.gif
f 0444 root sys /usr/share/doc/cups/images/cups-large.gif doc/images/cups-large.gif
f 0444 root sys /usr/share/doc/cups/images/cups-medium.gif doc/images/cups-medium.gif
f 0444 root sys /usr/share/doc/cups/images/cups-small.gif doc/images/cups-small.gif
f 0444 root sys /usr/share/doc/cups/images/delete-class.gif doc/images/delete-class.gif
f 0444 root sys /usr/share/doc/cups/images/delete-printer.gif doc/images/delete-printer.gif
f 0444 root sys /usr/share/doc/cups/images/hold-job.gif doc/images/hold-job.gif
f 0444 root sys /usr/share/doc/cups/images/left.gif doc/images/left.gif
f 0444 root sys /usr/share/doc/cups/images/logo.gif doc/images/logo.gif
f 0444 root sys /usr/share/doc/cups/images/manage-classes.gif doc/images/manage-classes.gif
f 0444 root sys /usr/share/doc/cups/images/manage-jobs.gif doc/images/manage-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/manage-printers.gif doc/images/manage-printers.gif
f 0444 root sys /usr/share/doc/cups/images/modify-class.gif doc/images/modify-class.gif
f 0444 root sys /usr/share/doc/cups/images/modify-printer.gif doc/images/modify-printer.gif
f 0444 root sys /usr/share/doc/cups/images/navbar.gif doc/images/navbar.gif
f 0444 root sys /usr/share/doc/cups/images/print-test-page.gif doc/images/print-test-page.gif
f 0444 root sys /usr/share/doc/cups/images/printer-idle.gif doc/images/printer-idle.gif
f 0444 root sys /usr/share/doc/cups/images/printer-processing.gif doc/images/printer-processing.gif
f 0444 root sys /usr/share/doc/cups/images/printer-stopped.gif doc/images/printer-stopped.gif
f 0444 root sys /usr/share/doc/cups/images/reject-jobs.gif doc/images/reject-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/release-job.gif doc/images/release-job.gif
f 0444 root sys /usr/share/doc/cups/images/restart-job.gif doc/images/restart-job.gif
f 0444 root sys /usr/share/doc/cups/images/right.gif doc/images/right.gif
f 0444 root sys /usr/share/doc/cups/images/show-active.gif doc/images/show-active.gif
f 0444 root sys /usr/share/doc/cups/images/show-completed.gif doc/images/show-completed.gif
f 0444 root sys /usr/share/doc/cups/images/start-class.gif doc/images/start-class.gif
f 0444 root sys /usr/share/doc/cups/images/start-printer.gif doc/images/start-printer.gif
f 0444 root sys /usr/share/doc/cups/images/stop-class.gif doc/images/stop-class.gif
f 0444 root sys /usr/share/doc/cups/images/stop-printer.gif doc/images/stop-printer.gif
f 0444 root sys /usr/share/doc/cups/cmp.html doc/cmp.html
f 0444 root sys /usr/share/doc/cups/cmp.pdf doc/cmp.pdf
f 0444 root sys /usr/share/doc/cups/cupsdoc.css doc/cupsdoc.css
f 0444 root sys /usr/share/doc/cups/idd.html doc/idd.html
f 0444 root sys /usr/share/doc/cups/idd.pdf doc/idd.pdf
f 0444 root sys /usr/share/doc/cups/overview.html doc/overview.html
f 0444 root sys /usr/share/doc/cups/overview.pdf doc/overview.pdf
f 0444 root sys /usr/share/doc/cups/sam.html doc/sam.html
f 0444 root sys /usr/share/doc/cups/sam.pdf doc/sam.pdf
f 0444 root sys /usr/share/doc/cups/sdd.html doc/sdd.html
f 0444 root sys /usr/share/doc/cups/sdd.pdf doc/sdd.pdf
f 0444 root sys /usr/share/doc/cups/spm.html doc/spm.html
f 0444 root sys /usr/share/doc/cups/spm.pdf doc/spm.pdf
f 0444 root sys /usr/share/doc/cups/ssr.html doc/ssr.html
f 0444 root sys /usr/share/doc/cups/ssr.pdf doc/ssr.pdf
f 0444 root sys /usr/share/doc/cups/sum.html doc/sum.html
f 0444 root sys /usr/share/doc/cups/sum.pdf doc/sum.pdf
# Man pages
%system irix
d 0555 root sys $MANDIR/a_man -
d 0555 root sys $MANDIR/a_man/cat1 -
d 0555 root sys $MANDIR/u_man -
d 0555 root sys $MANDIR/u_man/cat1 -
d 0555 root sys $MANDIR/u_man/cat5 -
f 0444 root sys $MANDIR/a_man/cat1/accept.z man/accept.z
l 0444 root sys $MANDIR/a_man/cat1/reject.z accept.z
f 0444 root sys $MANDIR/u_man/cat1/backend.z man/backend.z
f 0444 root sys $MANDIR/u_man/cat5/classes.conf.z man/classes.conf.z
f 0444 root sys $MANDIR/a_man/cat1/cups-lpd.z man/cups-lpd.z
f 0444 root sys $MANDIR/a_man/cat1/cups-polld.z man/cups-polld.z
f 0444 root sys $MANDIR/u_man/cat5/cupsd.conf.z man/cupsd.conf.z
f 0444 root sys $MANDIR/a_man/cat1/cupsd.z man/cupsd.z
f 0444 root sys $MANDIR/a_man/cat1/enable.z man/enable.z
l 0444 root sys $MANDIR/a_man/cat1/disable.z enable.z
f 0444 root sys $MANDIR/u_man/cat1/filter.z man/filter.z
f 0444 root sys $MANDIR/a_man/cat1/lpadmin.z man/lpadmin.z
f 0444 root sys $MANDIR/a_man/cat1/lpc.z man/lpc.z
f 0444 root sys $MANDIR/a_man/cat1/lpinfo.z man/lpinfo.z
f 0444 root sys $MANDIR/a_man/cat1/lpmove.z man/lpmove.z
f 0444 root sys $MANDIR/u_man/cat1/lpoptions.z man/lpoptions.z
f 0444 root sys $MANDIR/u_man/cat1/lpq.z man/lpq.z
f 0444 root sys $MANDIR/u_man/cat1/lprm.z man/lprm.z
f 0444 root sys $MANDIR/u_man/cat1/lpr.z man/lpr.z
f 0444 root sys $MANDIR/u_man/cat1/lpstat.z man/lpstat.z
f 0444 root sys $MANDIR/u_man/cat1/lp.z man/lp.z
l 0444 root sys $MANDIR/u_man/cat1/cancel.z lp.z
f 0444 root sys $MANDIR/u_man/cat5/mime.convs.z man/mime.convs.z
f 0444 root sys $MANDIR/u_man/cat5/mime.types.z man/mime.types.z
f 0444 root sys $MANDIR/u_man/cat5/printers.conf.z man/printers.conf.z
%system solaris hpux
d 0555 root sys $MANDIR/man1 -
d 0555 root sys $MANDIR/man5 -
d 0555 root sys $MANDIR/man1m -
f 0444 root sys $MANDIR/man1m/accept.1m man/accept.man
l 0444 root sys $MANDIR/man1m/reject.1m accept.1m
f 0444 root sys $MANDIR/man1/backend.1 man/backend.man
f 0444 root sys $MANDIR/man1/classes.conf.5 man/classes.conf.man
f 0444 root sys $MANDIR/man1m/cups-lpd.1m man/cups-lpd.man
f 0444 root sys $MANDIR/man1m/cups-polld.1m man/cups-polld.man
f 0444 root sys $MANDIR/man1m/cupsd.1m man/cupsd.man
f 0444 root sys $MANDIR/man5/cupsd.conf.5 man/cupsd.conf.man
f 0444 root sys $MANDIR/man1m/enable.1m man/enable.man
l 0444 root sys $MANDIR/man1m/disable.1m enable.1m
f 0444 root sys $MANDIR/man1/filter.1 man/filter.man
f 0444 root sys $MANDIR/man1m/lpadmin.1m man/lpadmin.man
f 0444 root sys $MANDIR/man1m/lpc.1m man/lpc.man
f 0444 root sys $MANDIR/man1m/lpinfo.1m man/lpinfo.man
f 0444 root sys $MANDIR/man1m/lpmove.1m man/lpmove.man
f 0444 root sys $MANDIR/man1/lpoptions.1 man/lpoptions.man
f 0444 root sys $MANDIR/man1/lpq.1 man/lpq.man
f 0444 root sys $MANDIR/man1/lprm.1 man/lprm.man
f 0444 root sys $MANDIR/man1/lpr.1 man/lpr.man
f 0444 root sys $MANDIR/man1/lpstat.1 man/lpstat.man
f 0444 root sys $MANDIR/man1/lp.1 man/lp.man
l 0444 root sys $MANDIR/man1/cancel.1 lp.1
f 0444 root sys $MANDIR/man5/mime.convs.5 man/mime.convs.man
f 0444 root sys $MANDIR/man5/mime.types.5 man/mime.types.man
f 0444 root sys $MANDIR/man5/printers.conf.5 man/printers.conf.man
%system !irix !solaris !hpux
d 0555 root sys $MANDIR/man1 -
d 0555 root sys $MANDIR/man5 -
d 0555 root sys $MANDIR/man8 -
f 0444 root sys $MANDIR/man8/accept.8 man/accept.man
l 0444 root sys $MANDIR/man8/reject.8 accept.8
f 0444 root sys $MANDIR/man1/backend.1 man/backend.man
f 0444 root sys $MANDIR/man1/classes.conf.5 man/classes.conf.man
f 0444 root sys $MANDIR/man8/cups-lpd.8 man/cups-lpd.man
f 0444 root sys $MANDIR/man8/cups-polld.8 man/cups-polld.man
f 0444 root sys $MANDIR/man8/cupsd.8 man/cupsd.man
f 0444 root sys $MANDIR/man5/cupsd.conf.5 man/cupsd.conf.man
f 0444 root sys $MANDIR/man8/enable.8 man/enable.man
l 0444 root sys $MANDIR/man8/disable.8 enable.8
f 0444 root sys $MANDIR/man1/filter.1 man/filter.man
f 0444 root sys $MANDIR/man8/lpadmin.8 man/lpadmin.man
f 0444 root sys $MANDIR/man8/lpc.8 man/lpc.man
f 0444 root sys $MANDIR/man8/lpinfo.8 man/lpinfo.man
f 0444 root sys $MANDIR/man8/lpmove.8 man/lpmove.man
f 0444 root sys $MANDIR/man1/lpoptions.1 man/lpoptions.man
f 0444 root sys $MANDIR/man1/lpq.1 man/lpq.man
f 0444 root sys $MANDIR/man1/lprm.1 man/lprm.man
f 0444 root sys $MANDIR/man1/lpr.1 man/lpr.man
f 0444 root sys $MANDIR/man1/lpstat.1 man/lpstat.man
f 0444 root sys $MANDIR/man1/lp.1 man/lp.man
l 0444 root sys $MANDIR/man1/cancel.1 lp.1
f 0444 root sys $MANDIR/man5/mime.convs.5 man/mime.convs.man
f 0444 root sys $MANDIR/man5/mime.types.5 man/mime.types.man
f 0444 root sys $MANDIR/man5/printers.conf.5 man/printers.conf.man
f 0444 root sys /usr/share/catman/a_man/cat1/accept.1 man/accept.8
l 0444 root sys /usr/share/catman/a_man/cat1/reject.1 accept.1
f 0444 root sys /usr/share/catman/u_man/cat1/backend.1 man/backend.1
f 0444 root sys /usr/share/catman/u_man/cat5/classes.conf.5 man/classes.conf.5
f 0444 root sys /usr/share/catman/u_man/cat5/cupsd.conf.5 man/cupsd.conf.5
f 0444 root sys /usr/share/catman/a_man/cat1/cupsd.1 man/cupsd.8
f 0444 root sys /usr/share/catman/a_man/cat1/enable.1 man/enable.8
l 0444 root sys /usr/share/catman/a_man/cat1/disable.1 enable.1
f 0444 root sys /usr/share/catman/u_man/cat1/filter.1 man/filter.1
f 0444 root sys /usr/share/catman/a_man/cat1/lpadmin.1 man/lpadmin.8
f 0444 root sys /usr/share/catman/a_man/cat1/lpc.1 man/lpc.8
f 0444 root sys /usr/share/catman/u_man/cat1/lpq.1 man/lpq.1
f 0444 root sys /usr/share/catman/u_man/cat1/lprm.1 man/lprm.1
f 0444 root sys /usr/share/catman/u_man/cat1/lpr.1 man/lpr.1
f 0444 root sys /usr/share/catman/u_man/cat1/lpstat.1 man/lpstat.1
f 0444 root sys /usr/share/catman/u_man/cat1/lp.1 man/lp.1
l 0444 root sys /usr/share/catman/u_man/cat1/cancel.1 lp.1
f 0444 root sys /usr/share/catman/u_man/cat5/mime.convs.5 man/mime.convs.5
f 0444 root sys /usr/share/catman/u_man/cat5/mime.types.5 man/mime.types.5
f 0444 root sys /usr/share/catman/u_man/cat5/printers.conf.5 man/printers.conf.5
%system !irix
f 0444 root sys /usr/man/man8/accept.8 man/accept.man
l 0444 root sys /usr/man/man8/reject.8 accept.man
f 0444 root sys /usr/man/man1/backend.1 man/backend.man
f 0444 root sys /usr/man/man1/classes.conf.5 man/classes.conf.man
f 0444 root sys /usr/man/man8/cupsd.8 man/cupsd.man
f 0444 root sys /usr/man/man5/cupsd.conf.5 man/cupsd.conf.man
f 0444 root sys /usr/man/man8/enable.8 man/enable.man
f 0444 root sys /usr/man/man8/esplicense.8 man/esplicense.man
l 0444 root sys /usr/man/man8/disable.8 enable.man
f 0444 root sys /usr/man/man1/filter.1 man/filter.man
f 0444 root sys /usr/man/man8/lpadmin.8 man/lpadmin.man
f 0444 root sys /usr/man/man8/lpc.8 man/lpc.man
f 0444 root sys /usr/man/man1/lpq.1 man/lpq.man
f 0444 root sys /usr/man/man1/lprm.1 man/lprm.man
f 0444 root sys /usr/man/man1/lpr.1 man/lpr.man
f 0444 root sys /usr/man/man1/lpstat.1 man/lpstat.man
f 0444 root sys /usr/man/man1/lp.1 man/lp.man
l 0444 root sys /usr/man/man1/cancel.1 lp.man
f 0444 root sys /usr/man/man5/mime.convs.5 man/mime.convs.man
f 0444 root sys /usr/man/man5/mime.types.5 man/mime.types.man
f 0444 root sys /usr/man/man5/printers.conf.5 man/printers.conf.man
# Startup script
%system all
i 0555 root sys cups cups.sh
#
# End of "$Id: cups.list 1471 2000-12-11 04:40:31Z mike $".
# End of "$Id: cups.list 986 2000-03-13 18:56:08Z mike $".
#
+8 -5
Ver Arquivo
@@ -6,7 +6,7 @@
#
# Linux chkconfig stuff:
#
# chkconfig: 0235 99 00
# chkconfig: 02345 99 00
# description: Startup/shutdown script for the Common UNIX \
# Printing System (CUPS).
#
@@ -31,7 +31,7 @@
# See what program to use for configuration stuff...
case "`uname`" in
IRIX*)
IRIX* | Linux*)
IS_ON=/sbin/chkconfig
;;
@@ -64,6 +64,11 @@ case "`uname`" in
;;
esac
# Change to the root directory first, in case we are being run from a
# CD-ROM installation script...
cd /
# Start or stop the CUPS server based upon the first argument to the script.
case $1 in
start | restart | reload)
@@ -77,9 +82,7 @@ case $1 in
fi
else
if $IS_ON cups; then
prefix=@prefix@
exec_prefix=@exec_prefix@
@sbindir@/cupsd
/usr/sbin/cupsd 2>&1 >/dev/null &
$ECHO "cups: scheduler started."
fi
fi
+21 -81
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: cups.spec 1421 2000-10-19 20:55:06Z mike $"
# "$Id: cups.spec 904 2000-02-18 17:48:09Z mike $"
#
# RPM "spec" file for the Common UNIX Printing System (CUPS).
#
@@ -26,16 +26,16 @@
Summary: Common Unix Printing System
Name: cups
Version: 1.1.5
Version: 1.1a8
Release: 0
Copyright: GPL
Group: System Environment/Daemons
Source: ftp://ftp.easysw.com/pub/cups/%{version}/cups-%{version}-source.tar.gz
Source: ftp://ftp.easysw.com/pub/cups/beta/cups-1.1a8-source.tar.gz
Url: http://www.cups.org
Packager: Michael Sweet <mike@easysw.com>
Vendor: Easy Software Products
# use buildroot so as not to disturb the version already installed
BuildRoot: /var/tmp/%{name}-root
BuildRoot: /tmp/rpmbuild
Conflicts: lpr
%package devel
@@ -67,104 +67,44 @@ make
# RPM_BUILD_ROOT exists
rm -rf $RPM_BUILD_ROOT
mkdir -p $RPM_BUILD_ROOT/etc/rc.d/init.d
mkdir -p $RPM_BUILD_ROOT/etc/rc.d/rc0.d
mkdir -p $RPM_BUILD_ROOT/etc/rc.d/rc3.d
mkdir -p $RPM_BUILD_ROOT/etc/rc.d/rc5.d
make prefix=$RPM_BUILD_ROOT \
exec_prefix=$RPM_BUILD_ROOT/usr \
BINDIR=$RPM_BUILD_ROOT/usr/bin \
DATADIR=$RPM_BUILD_ROOT/usr/share/cups \
DOCDIR=$RPM_BUILD_ROOT/usr/share/doc/cups \
INCLUDEDIR=$RPM_BUILD_ROOT/usr/include \
LIBDIR=$RPM_BUILD_ROOT/usr/lib \
LOCALEDIR=$RPM_BUILD_ROOT/usr/share/locale \
MANDIR=$RPM_BUILD_ROOT/usr/man \
PAMDIR=$RPM_BUILD_ROOT/etc/pam.d \
make prefix=$RPM_BUILD_ROOT/usr LOGDIR=$RPM_BUILD_ROOT/var/log/cups \
REQUESTS=$RPM_BUILD_ROOT/var/spool/cups \
SBINDIR=$RPM_BUILD_ROOT/usr/sbin \
SERVERBIN=$RPM_BUILD_ROOT/usr/lib/cups \
SERVERROOT=$RPM_BUILD_ROOT/etc/cups \
install
SERVERROOT=$RPM_BUILD_ROOT/etc/cups install
install -m 755 -o root -g root cups.sh $RPM_BUILD_ROOT/etc/rc.d/init.d/cups
%post
if test -x /sbin/chkconfig; then
/sbin/chkconfig --add cups
/sbin/chkconfig cups on
fi
if test -f /sbin/init.d/cups; then
/sbin/init.d/cups start
fi
if test -f /etc/rc.d/init.d/cups; then
/etc/rc.d/init.d/cups start
fi
if test -f /etc/init.d/cups; then
/etc/init.d/cups start
fi
/sbin/chkconfig --add cups
%preun
if test -f /sbin/init.d/cups; then
/sbin/init.d/cups stop
fi
if test -f /etc/rc.d/init.d/cups; then
/etc/rc.d/init.d/cups stop
fi
if test -f /etc/init.d/cups; then
/etc/init.d/cups stop
fi
if test -x /sbin/chkconfig; then
/sbin/chkconfig --del cups
fi
/sbin/chkconfig --del cups
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
%dir /etc/cups
%config /etc/cups/*.conf
/etc/rc.d/init.d/cups
%config /etc/cups/*
%dir /etc/cups/certs
%dir /etc/cups/interfaces
/etc/cups/mime.types
/etc/cups/mime.convs
%dir /etc/cups/ppd
%dir /etc/pam.d
/etc/pam.d/*
# RC dirs are a pain under Linux... Uncomment the appropriate ones if you
# don't use Red Hat or Mandrake...
/etc/rc.d/init.d/*
/etc/rc.d/rc0.d/*
/etc/rc.d/rc3.d/*
/etc/rc.d/rc5.d/*
#/etc/init.d/*
#/etc/rc0.d/*
#/etc/rc3.d/*
#/etc/rc5.d/*
#/sbin/rc.d/*
#/sbin/rc.d/rc0.d/*
#/sbin/rc.d/rc3.d/*
#/sbin/rc.d/rc5.d/*
/usr/bin/*
/usr/lib/*.so*
%dir /usr/lib/cups
/usr/lib/cups/*
%%attr(4555,root,root) /usr/bin/lppasswd
/usr/lib/*
/usr/man/*
/usr/sbin/*
%dir /usr/share/cups
/usr/share/cups/*
%dir /usr/share/doc/cups
/usr/share/doc/cups/*
%dir /usr/share/locale
/usr/share/locale/*
%attr(0700,lp,root) %dir /var/spool/cups
%attr(1700,lp,root) %dir /var/spool/cups/tmp
%dir /var/cups
/usr/lib/cups/backend/*
/usr/lib/cups/cgi-bin/*
/usr/lib/cups/filter/*
%dir /var/spool/cups
%dir /var/log/cups
%files devel
%dir /usr/include/cups
@@ -172,5 +112,5 @@ rm -rf $RPM_BUILD_ROOT
/usr/lib/*.a
#
# End of "$Id: cups.spec 1421 2000-10-19 20:55:06Z mike $".
# End of "$Id: cups.spec 904 2000-02-18 17:48:09Z mike $".
#
+11 -35
Ver Arquivo
@@ -28,24 +28,21 @@ include ../Makedefs
# Object files...
#
LIBOBJS = dest.o emit.o http.o ipp.o language.o mark.o md5.o md5passwd.o \
options.o page.o ppd.o snprintf.o string.o usersys.o util.o
LIBOBJS = dest.o emit.o http.o ipp.o language.o mark.o md5.o options.o \
page.o ppd.o snprintf.o string.o usersys.o util.o
OBJS = $(LIBOBJS) testhttp.o testppd.o
#
# Header files to install...
#
HEADERS = cups.h http.h ipp.h language.h md5.h ppd.h
HEADERS = cups.h http.h ipp.h language.h ppd.h
#
# Targets in this directory...
#
TARGETS = $(LIBCUPS) libcups.a
TARGETS = $(LIBCUPS) testhttp testppd
#
# Make all targets...
@@ -53,14 +50,12 @@ TARGETS = $(LIBCUPS) libcups.a
all: $(TARGETS)
#
# Remove object and target files...
#
clean:
$(RM) $(OBJS) $(TARGETS) `basename $(LIBCUPS) .2`
$(RM) $(OBJS) $(TARGETS)
#
# Install object and target files...
@@ -68,39 +63,24 @@ clean:
install: all
-$(MKDIR) $(INCLUDEDIR)/cups
$(CHMOD) ugo+rx $(INCLUDEDIR)
$(CHMOD) ugo+rx $(INCLUDEDIR)/cups
$(INSTALL_DATA) $(HEADERS) $(INCLUDEDIR)/cups
$(CP) $(HEADERS) $(INCLUDEDIR)/cups
-$(MKDIR) $(LIBDIR)
$(CHMOD) ugo+rx $(LIBDIR)
$(INSTALL_LIB) $(LIBCUPS) $(LIBDIR)
if test $(LIBCUPS) != "libcups.a" -a $(LIBCUPS) != "libcups.la"; then \
$(INSTALL_LIB) libcups.a $(LIBDIR); \
$(RM) $(LIBDIR)/`basename $(LIBCUPS) .2`; \
$(LN) $(LIBCUPS) $(LIBDIR)/`basename $(LIBCUPS) .2`; \
$(CP) $(LIBCUPS) $(LIBDIR)
if test $(LIBCUPS) != "libcups.a"; then \
$(RM) `basename $(LIBCUPS) .2`; \
$(LN) $(LIBCUPS) `basename $(LIBCUPS) .2`; \
fi
#
# libcups.so.2, libcups.sl.1
#
libcups.so.2 libcups.sl.2: $(LIBOBJS) ../Makedefs
echo Linking $@...
$(DSO) $@ $(LIBOBJS) $(SSLLIBS)
$(DSO) $@ $(LIBOBJS)
$(RM) `basename $@ .2`
$(LN) $@ `basename $@ .2`
#
# libcups.la
#
libcups.la: $(LIBOBJS) ../Makedefs
echo Linking $@...
$(CC) -o $@ $(LIBOBJS:.o=.lo) -rpath $(LIBDIR) -version-info 2:0
#
# libcups.a
#
@@ -111,7 +91,6 @@ libcups.a: $(LIBOBJS)
$(AR) $(ARFLAGS) $@ $(LIBOBJS)
$(RANLIB) $@
#
# cups_C.h - the default POSIX locale that is compiled in.
#
@@ -136,7 +115,6 @@ string.o: string.h
usersys.o: cups.h
util.o: cups.h http.h ipp.h
#
# testhttp (dependency on static CUPS library is intentional)
#
@@ -147,7 +125,6 @@ testhttp: testhttp.o libcups.a
testhttp.o: http.h
#
# testppd (dependency on static CUPS library is intentional)
#
@@ -160,7 +137,6 @@ testppd.o: ppd.h
$(OBJS): ../Makedefs ../config.h
#
# End of "$Id$".
#
+10 -18
Ver Arquivo
@@ -85,11 +85,11 @@ LIB32=link.exe -lib
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\dest.c
SOURCE=.\emit.c
# End Source File
# Begin Source File
SOURCE=.\emit.c
SOURCE=.\filter.c
# End Source File
# Begin Source File
@@ -109,11 +109,7 @@ SOURCE=.\mark.c
# End Source File
# Begin Source File
SOURCE=.\md5.c
# End Source File
# Begin Source File
SOURCE=.\md5passwd.c
SOURCE=.\mime.c
# End Source File
# Begin Source File
@@ -129,6 +125,10 @@ SOURCE=.\ppd.c
# End Source File
# Begin Source File
SOURCE=.\raster.c
# End Source File
# Begin Source File
SOURCE=.\snprintf.c
# End Source File
# Begin Source File
@@ -137,7 +137,7 @@ SOURCE=.\string.c
# End Source File
# Begin Source File
SOURCE=.\usersys.c
SOURCE=.\type.c
# End Source File
# Begin Source File
@@ -153,14 +153,6 @@ SOURCE=.\cups.h
# End Source File
# Begin Source File
SOURCE=.\cups_C.h
# End Source File
# Begin Source File
SOURCE=.\debug.h
# End Source File
# Begin Source File
SOURCE=.\http.h
# End Source File
# Begin Source File
@@ -173,7 +165,7 @@ SOURCE=.\language.h
# End Source File
# Begin Source File
SOURCE=.\md5.h
SOURCE=.\mime.h
# End Source File
# Begin Source File
@@ -181,7 +173,7 @@ SOURCE=.\ppd.h
# End Source File
# Begin Source File
SOURCE=.\string.h
SOURCE=.\raster.h
# End Source File
# End Group
# End Target
+4 -15
Ver Arquivo
@@ -29,8 +29,8 @@
* Include necessary headers...
*/
# include "ipp.h"
# include "ppd.h"
# include <cups/ipp.h>
# include <cups/ppd.h>
/*
@@ -46,7 +46,7 @@ extern "C" {
* Constants...
*/
# define CUPS_VERSION 1.0103
# define CUPS_VERSION 1.0
# define CUPS_DATE_ANY -1
@@ -75,7 +75,6 @@ enum /* Not a typedef'd enum so we can OR */
CUPS_PRINTER_LARGE = 0x4000, /* Can do D/E/A1/A0 */
CUPS_PRINTER_VARIABLE = 0x8000, /* Can do variable sizes */
CUPS_PRINTER_IMPLICIT = 0x10000, /* Implicit class */
CUPS_PRINTER_DEFAULT = 0x20000, /* Default printer on network */
CUPS_PRINTER_OPTIONS = 0xfffc /* ~(CLASS | REMOTE | IMPLICIT) */
};
@@ -88,7 +87,7 @@ typedef struct /**** Printer Options ****/
typedef struct /**** Destination ****/
{
char *name, /* Printer or class name */
*instance; /* Local instance name or NULL */
*instance; /* Local instance name */
int is_default; /* Is this printer the default? */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
@@ -103,7 +102,6 @@ extern int cupsCancelJob(const char *printer, int job);
#define cupsDoRequest(http,request,resource) cupsDoFileRequest((http),(request),(resource),NULL)
extern ipp_t *cupsDoFileRequest(http_t *http, ipp_t *request,
const char *resource, const char *filename);
extern http_encryption_t cupsEncryption(void);
extern int cupsGetClasses(char ***classes);
extern const char *cupsGetDefault(void);
extern const char *cupsGetPPD(const char *printer);
@@ -112,9 +110,6 @@ extern ipp_status_t cupsLastError(void);
extern int cupsPrintFile(const char *printer, const char *filename,
const char *title, int num_options,
cups_option_t *options);
extern int cupsPrintFiles(const char *printer, int num_files,
const char **files, const char *title,
int num_options, cups_option_t *options);
extern char *cupsTempFile(char *filename, int len);
extern int cupsAddDest(const char *name, const char *instance,
@@ -127,8 +122,6 @@ extern void cupsSetDests(int num_dests, cups_dest_t *dests);
extern int cupsAddOption(const char *name, const char *value,
int num_options, cups_option_t **options);
extern void cupsEncodeOptions(ipp_t *ipp, int num_options,
cups_option_t *options);
extern void cupsFreeOptions(int num_options, cups_option_t *options);
extern const char *cupsGetOption(const char *name, int num_options,
cups_option_t *options);
@@ -139,10 +132,6 @@ extern int cupsMarkOptions(ppd_file_t *ppd, int num_options,
extern const char *cupsGetPassword(const char *prompt);
extern const char *cupsServer(void);
extern void cupsSetEncryption(http_encryption_t e);
extern void cupsSetPasswordCB(const char *(*cb)(const char *));
extern void cupsSetServer(const char *server);
extern void cupsSetUser(const char *user);
extern const char *cupsUser(void);
# ifdef __cplusplus
+1 -2
Ver Arquivo
@@ -1,4 +1,4 @@
"iso-8859-1",
"us-ascii",
"OK",
"Cancel",
"Help",
@@ -124,7 +124,6 @@
"The request is too large for this server to process.",
"The request URI is too large for this server to process.",
"The request format is not understood by this server.",
"426 An upgrade to a secure connection is required. If you are seeing this message in a web browser then it does not support HTTP encryption upgrades.",
"500 The server has detected an unrecoverable error and cannot process your request.",
"The requested method is not implemented by this server.",
"The proxy server received an invalid response from an upstream server.",
+17 -66
Ver Arquivo
@@ -87,8 +87,9 @@ cupsAddDest(const char *name, /* I - Name of destination */
for (i = num_dests; i > 0; i --, dest ++)
if (strcasecmp(name, dest->name) < 0)
break;
else if (strcasecmp(name, dest->name) == 0 &&
instance != NULL && dest->instance != NULL &&
else if (instance == NULL && dest->instance != NULL)
break;
else if (instance != NULL && dest->instance != NULL &&
strcasecmp(instance, dest->instance) < 0)
break;
@@ -151,45 +152,23 @@ cupsGetDest(const char *name, /* I - Name of destination */
int comp; /* Result of comparison */
if (num_dests == 0 || dests == NULL)
if (name == NULL || num_dests == 0 || dests == NULL)
return (NULL);
if (name == NULL)
while (num_dests > 0)
{
/*
* NULL name for default printer.
*/
while (num_dests > 0)
if ((comp = strcasecmp(name, dests->name)) < 0)
return (NULL);
else if (comp == 0)
{
if (dests->is_default)
return (dests);
num_dests --;
dests ++;
if ((instance == NULL && dests->instance == NULL) ||
(instance != NULL && dests->instance != NULL &&
strcasecmp(instance, dests->instance) == 0))
return (dests);
}
}
else
{
/*
* Lookup name and optionally the instance...
*/
while (num_dests > 0)
{
if ((comp = strcasecmp(name, dests->name)) < 0)
return (NULL);
else if (comp == 0)
{
if ((instance == NULL && dests->instance == NULL) ||
(instance != NULL && dests->instance != NULL &&
strcasecmp(instance, dests->instance) == 0))
return (dests);
}
num_dests --;
dests ++;
}
num_dests --;
dests ++;
}
return (NULL);
@@ -260,13 +239,7 @@ cupsGetDests(cups_dest_t **dests) /* O - Destinations */
* Load the /etc/cups/lpoptions and ~/.lpoptions files...
*/
if ((home = getenv("CUPS_SERVERROOT")) != NULL)
{
snprintf(filename, sizeof(filename), "%s/lpoptions", home);
num_dests = cups_get_dests(filename, num_dests, dests);
}
else
num_dests = cups_get_dests(CUPS_SERVERROOT "/lpoptions", num_dests, dests);
num_dests = cups_get_dests(CUPS_SERVERROOT "/lpoptions", num_dests, dests);
if ((home = getenv("HOME")) != NULL)
{
@@ -302,24 +275,12 @@ cupsSetDests(int num_dests, /* I - Number of destinations */
* Figure out which file to write to...
*/
#ifdef WIN32
if ((home = getenv("CUPS_SERVERROOT")) == NULL)
home = CUPS_SERVERROOT;
snprintf(filename, sizeof(filename), "%s/lpoptions", home);
#else
if (getuid() == 0)
{
if ((home = getenv("CUPS_SERVERROOT")) == NULL)
home = CUPS_SERVERROOT;
snprintf(filename, sizeof(filename), "%s/lpoptions", home);
}
strcpy(filename, CUPS_SERVERROOT "/lpoptions");
else if ((home = getenv("HOME")) != NULL)
snprintf(filename, sizeof(filename), "%s/.lpoptions", home);
else
return;
#endif /* WIN32 */
/*
* Try to open the file...
@@ -376,18 +337,8 @@ cups_get_dests(const char *filename, /* I - File to read from */
*lineptr, /* Pointer into line */
*name, /* Name of destination/option */
*instance; /* Instance of destination */
const char *printer; /* PRINTER or LPDEST */
/*
* Check environment variables...
*/
if ((printer = getenv("LPDEST")) == NULL)
if ((printer = getenv("PRINTER")) != NULL)
if (strcmp(printer, "lp") == 0)
printer = NULL;
/*
* Try to open the file...
*/
@@ -497,7 +448,7 @@ cups_get_dests(const char *filename, /* I - File to read from */
* Set this as default if needed...
*/
if (strncasecmp(line, "default", 7) == 0 && printer == NULL)
if (strncasecmp(line, "default", 7) == 0)
{
for (i = 0; i < num_dests; i ++)
(*dests)[i].is_default = 0;
+171 -206
Ver Arquivo
@@ -25,10 +25,8 @@
*
* Contents:
*
* ppdCollect() - Collect all marked options that reside in the specified
* ppdEmit() - Emit code for marked options to a file.
* ppdEmitFd() - Emit code for marked options to a file.
* ppd_sort() - Sort options by ordering numbers...
* ppdEmit() - Emit code for marked options to a file.
* ppdEmitFd() - Emit code for marked options to a file.
*/
/*
@@ -51,17 +49,180 @@
*/
static int ppd_sort(ppd_choice_t **c1, ppd_choice_t **c2);
static int ppd_collect(ppd_file_t *ppd, ppd_section_t section,
ppd_choice_t ***choices);
/*
* 'ppdCollect()' - Collect all marked options that reside in the specified
* section.
* 'ppdEmit()' - Emit code for marked options to a file.
*/
int /* O - Number of options marked */
ppdCollect(ppd_file_t *ppd, /* I - PPD file data */
ppd_section_t section, /* I - Section to collect */
ppd_choice_t ***choices) /* O - Pointers to choices */
int /* O - 0 on success, -1 on failure */
ppdEmit(ppd_file_t *ppd, /* I - PPD file record */
FILE *fp, /* I - File to write to */
ppd_section_t section) /* I - Section to write */
{
int i, /* Looping var */
count; /* Number of choices */
ppd_choice_t **choices; /* Choices */
ppd_size_t *size; /* Custom page size */
if ((count = ppd_collect(ppd, section, &choices)) == 0)
return (0);
for (i = 0; i < count; i ++)
if (section != PPD_ORDER_EXIT && section != PPD_ORDER_JCL)
{
/*
* Send DSC comments with option...
*/
if (fprintf(fp, "%%%%BeginFeature: %s %s\n",
((ppd_option_t *)choices[i]->option)->keyword,
choices[i]->choice) < 0)
{
free(choices);
return (-1);
}
if (strcasecmp(((ppd_option_t *)choices[i]->option)->keyword, "PageSize") == 0 &&
strcasecmp(choices[i]->choice, "Custom") == 0)
{
/*
* Variable size; write out standard size options (this should
* eventually be changed to use the parameter positions defined
* in the PPD file...)
*/
size = ppdPageSize(ppd, "Custom");
fprintf(fp, "%.0f %.0f 0 0 0\n", size->width, size->length);
if (choices[i]->code == NULL)
{
/*
* This can happen with certain buggy PPD files that don't include
* a CustomPageSize command sequence... We just use a generic
* Level 2 command sequence...
*/
fputs("pop pop pop\n", fp);
fputs("<</PageSize[5 -2 roll]/ImagingBBox null>>setpagedevice\n", fp);
}
}
if (choices[i]->code != NULL && choices[i]->code[0] != '\0')
{
if (fputs(choices[i]->code, fp) < 0)
{
free(choices);
return (-1);
}
if (choices[i]->code[strlen(choices[i]->code) - 1] != '\n')
putc('\n', fp);
}
if (fputs("%%EndFeature\n", fp) < 0)
{
free(choices);
return (-1);
}
}
else if (fputs(choices[i]->code, fp) < 0)
{
free(choices);
return (-1);
}
free(choices);
return (0);
}
/*
* 'ppdEmitFd()' - Emit code for marked options to a file.
*/
int /* O - 0 on success, -1 on failure */
ppdEmitFd(ppd_file_t *ppd, /* I - PPD file record */
int fd, /* I - File to write to */
ppd_section_t section) /* I - Section to write */
{
int i, /* Looping var */
count; /* Number of choices */
ppd_choice_t **choices; /* Choices */
char buf[1024]; /* Output buffer for feature */
if ((count = ppd_collect(ppd, section, &choices)) == 0)
return (0);
for (i = 0; i < count; i ++)
if (section != PPD_ORDER_EXIT && section != PPD_ORDER_JCL)
{
/*
* Send DSC comments with option...
*/
sprintf(buf, "%%%%BeginFeature: %s %s\n",
((ppd_option_t *)choices[i]->option)->keyword, choices[i]->choice);
if (write(fd, buf, strlen(buf)) < 1)
{
free(choices);
return (-1);
}
if (write(fd, choices[i]->code, strlen(choices[i]->code)) < 1)
{
free(choices);
return (-1);
}
if (write(fd, "%%EndFeature\n", 13) < 1)
{
free(choices);
return (-1);
}
}
else if (write(fd, choices[i]->code, strlen(choices[i]->code)) < 1)
{
free(choices);
return (-1);
}
free(choices);
return (0);
}
/*
* 'ppd_sort()' - Sort options by ordering numbers...
*/
static int /* O - -1 if c1 < c2, 0 if equal, 1 otherwise */
ppd_sort(ppd_choice_t **c1, /* I - First choice */
ppd_choice_t **c2) /* I - Second choice */
{
if (((ppd_option_t *)(*c1)->option)->order < ((ppd_option_t *)(*c2)->option)->order)
return (-1);
else if (((ppd_option_t *)(*c1)->option)->order > ((ppd_option_t *)(*c2)->option)->order)
return (1);
else
return (0);
}
/*
* 'ppd_collect()' - Collect all marked options that reside in the specified
* section.
*/
static int /* O - Number of options marked */
ppd_collect(ppd_file_t *ppd, /* I - PPD file data */
ppd_section_t section, /* I - Section to collect */
ppd_choice_t ***choices) /* O - Pointers to choices */
{
int i, j, k, m; /* Looping vars */
ppd_group_t *g, /* Current group */
@@ -135,202 +296,6 @@ ppdCollect(ppd_file_t *ppd, /* I - PPD file data */
}
/*
* 'ppdEmit()' - Emit code for marked options to a file.
*/
int /* O - 0 on success, -1 on failure */
ppdEmit(ppd_file_t *ppd, /* I - PPD file record */
FILE *fp, /* I - File to write to */
ppd_section_t section) /* I - Section to write */
{
int i, /* Looping var */
count; /* Number of choices */
ppd_choice_t **choices; /* Choices */
ppd_size_t *size; /* Custom page size */
if ((count = ppdCollect(ppd, section, &choices)) == 0)
return (0);
for (i = 0; i < count; i ++)
if (section != PPD_ORDER_EXIT && section != PPD_ORDER_JCL)
{
/*
* Send wrapper commands to prevent printer errors for unsupported
* options...
*/
if (fputs("[{\n", fp) < 0)
{
free(choices);
return (-1);
}
/*
* Send DSC comments with option...
*/
if (fprintf(fp, "%%%%BeginFeature: %s %s\n",
((ppd_option_t *)choices[i]->option)->keyword,
choices[i]->choice) < 0)
{
free(choices);
return (-1);
}
if (strcasecmp(((ppd_option_t *)choices[i]->option)->keyword, "PageSize") == 0 &&
strcasecmp(choices[i]->choice, "Custom") == 0)
{
/*
* Variable size; write out standard size options (this should
* eventually be changed to use the parameter positions defined
* in the PPD file...)
*/
size = ppdPageSize(ppd, "Custom");
fprintf(fp, "%.0f %.0f 0 0 0\n", size->width, size->length);
if (choices[i]->code == NULL)
{
/*
* This can happen with certain buggy PPD files that don't include
* a CustomPageSize command sequence... We just use a generic
* Level 2 command sequence...
*/
fputs("pop pop pop\n", fp);
fputs("<</PageSize[5 -2 roll]/ImagingBBox null>>setpagedevice\n", fp);
}
}
if (choices[i]->code != NULL && choices[i]->code[0] != '\0')
{
if (fputs(choices[i]->code, fp) < 0)
{
free(choices);
return (-1);
}
if (choices[i]->code[strlen(choices[i]->code) - 1] != '\n')
putc('\n', fp);
}
if (fputs("%%EndFeature\n", fp) < 0)
{
free(choices);
return (-1);
}
if (fputs("} stopped cleartomark\n", fp) < 0)
{
free(choices);
return (-1);
}
}
else if (fputs(choices[i]->code, fp) < 0)
{
free(choices);
return (-1);
}
free(choices);
return (0);
}
/*
* 'ppdEmitFd()' - Emit code for marked options to a file.
*/
int /* O - 0 on success, -1 on failure */
ppdEmitFd(ppd_file_t *ppd, /* I - PPD file record */
int fd, /* I - File to write to */
ppd_section_t section) /* I - Section to write */
{
int i, /* Looping var */
count; /* Number of choices */
ppd_choice_t **choices; /* Choices */
char buf[1024]; /* Output buffer for feature */
if ((count = ppdCollect(ppd, section, &choices)) == 0)
return (0);
for (i = 0; i < count; i ++)
if (section != PPD_ORDER_EXIT && section != PPD_ORDER_JCL)
{
/*
* Send wrapper commands to prevent printer errors for unsupported
* options...
*/
if (write(fd, "[{\n", 3) < 1)
{
free(choices);
return (-1);
}
/*
* Send DSC comments with option...
*/
snprintf(buf, sizeof(buf), "%%%%BeginFeature: %s %s\n",
((ppd_option_t *)choices[i]->option)->keyword,
choices[i]->choice);
if (write(fd, buf, strlen(buf)) < 1)
{
free(choices);
return (-1);
}
if (write(fd, choices[i]->code, strlen(choices[i]->code)) < 1)
{
free(choices);
return (-1);
}
if (write(fd, "%%EndFeature\n", 13) < 1)
{
free(choices);
return (-1);
}
if (write(fd, "} stopped cleartomark\n", 22) < 1)
{
free(choices);
return (-1);
}
}
else if (write(fd, choices[i]->code, strlen(choices[i]->code)) < 1)
{
free(choices);
return (-1);
}
free(choices);
return (0);
}
/*
* 'ppd_sort()' - Sort options by ordering numbers...
*/
static int /* O - -1 if c1 < c2, 0 if equal, 1 otherwise */
ppd_sort(ppd_choice_t **c1, /* I - First choice */
ppd_choice_t **c2) /* I - Second choice */
{
if (((ppd_option_t *)(*c1)->option)->order < ((ppd_option_t *)(*c2)->option)->order)
return (-1);
else if (((ppd_option_t *)(*c1)->option)->order > ((ppd_option_t *)(*c2)->option)->order)
return (1);
else
return (0);
}
/*
* End of "$Id$".
*/
+34 -461
Ver Arquivo
@@ -5,7 +5,7 @@
*
* Copyright 1997-2000 by Easy Software Products, all rights reserved.
*
* These coded instructions, statements, and computer programs are the
* These statusd instructions, statements, and computer programs are the
* property of Easy Software Products 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
@@ -29,7 +29,6 @@
* the server.
* httpClose() - Close an HTTP connection...
* httpConnect() - Connect to a HTTP server.
* httpEncryption() - Set the required encryption on the link.
* httpReconnect() - Reconnect to a HTTP server...
* httpSeparate() - Separate a Universal Resource Identifier into its
* components.
@@ -57,7 +56,6 @@
* http_field() - Return the field index for a field name.
* http_send() - Send a request with all fields and the trailing
* blank line.
* http_upgrade() - Force upgrade to TLS encryption.
*/
/*
@@ -80,12 +78,6 @@
# include <signal.h>
#endif /* !WIN32 && !__EMX__ */
#ifdef HAVE_LIBSSL
# include <openssl/rand.h>
# include <openssl/ssl.h>
#endif /* HAVE_LIBSSL */
/*
* Some operating systems have done away with the Fxxxx constants for
* the fcntl() call; this works around that "feature"...
@@ -103,7 +95,6 @@
static http_field_t http_field(const char *name);
static int http_send(http_t *http, http_state_t request,
const char *uri);
static int http_upgrade(http_t *http);
/*
@@ -175,13 +166,6 @@ static const char *months[12] =
void
httpInitialize(void)
{
#ifdef HAVE_LIBSSL
# if defined(WIN32) || defined(__EMX__)
# else
struct timeval curtime; /* Current time in microseconds */
# endif /* WIN32 || __EMX__ */
#endif /* HAVE_LIBSSL */
#if defined(WIN32) || defined(__EMX__)
WSADATA winsockdata; /* WinSock data */
static int initialized = 0;/* Has WinSock been initialized? */
@@ -205,21 +189,6 @@ httpInitialize(void)
#else
signal(SIGPIPE, SIG_IGN);
#endif /* WIN32 || __EMX__ */
#ifdef HAVE_LIBSSL
SSL_library_init();
/*
* Using the current time is a dubious random seed, but on some systems
* it is the best we can do (on others, this seed isn't even used...)
*/
# if defined(WIN32) || defined(__EMX__)
# else
gettimeofday(&curtime, NULL);
RAND_seed(&curtime, sizeof(curtime));
# endif /* WIN32 || __EMX__ */
#endif /* HAVE_LIBSSL */
}
@@ -265,29 +234,9 @@ httpCheck(http_t *http) /* I - HTTP connection */
void
httpClose(http_t *http) /* I - Connection to close */
{
#ifdef HAVE_LIBSSL
SSL_CTX *context; /* Context for encryption */
SSL *conn; /* Connection for encryption */
#endif /* HAVE_LIBSSL */
if (!http)
if (http == NULL)
return;
#ifdef HAVE_LIBSSL
if (http->tls)
{
conn = (SSL *)(http->tls);
context = SSL_get_SSL_CTX(conn);
SSL_shutdown(conn);
SSL_CTX_free(context);
SSL_free(conn);
http->tls = NULL;
}
#endif /* HAVE_LIBSSL */
#ifdef WIN32
closesocket(http->fd);
#else
@@ -310,9 +259,6 @@ httpConnect(const char *host, /* I - Host to connect to */
struct hostent *hostaddr; /* Host address data */
if (host == NULL)
return (NULL);
httpInitialize();
/*
@@ -346,18 +292,6 @@ httpConnect(const char *host, /* I - Host to connect to */
#else
http->hostaddr.sin_port = htons(port);
#endif /* WIN32 */
/*
* Set the default encryption status...
*/
if (port == 443)
http->encryption = HTTP_ENCRYPT_ALWAYS;
/*
* Connect to the remote system...
*/
if (httpReconnect(http))
{
free(http);
@@ -368,36 +302,6 @@ httpConnect(const char *host, /* I - Host to connect to */
}
/*
* 'httpEncryption()' - Set the required encryption on the link.
*/
int /* O - -1 on error, 0 on success */
httpEncryption(http_t *http, /* I - HTTP data */
http_encryption_t e) /* I - New encryption preference */
{
#ifdef HAVE_LIBSSL
if (!http)
return (0);
http->encryption = e;
if ((http->encryption == HTTP_ENCRYPT_ALWAYS && !http->tls) ||
(http->encryption == HTTP_ENCRYPT_NEVER && http->tls))
return (httpReconnect(http));
else if (http->encryption == HTTP_ENCRYPT_REQUIRED && !http->tls)
return (http_upgrade(http));
else
return (0);
#else
if (e == HTTP_ENCRYPT_ALWAYS || e == HTTP_ENCRYPT_REQUIRED)
return (-1);
else
return (0);
#endif /* HAVE_LIBSSL */
}
/*
* 'httpReconnect()' - Reconnect to a HTTP server...
*/
@@ -405,25 +309,9 @@ httpEncryption(http_t *http, /* I - HTTP data */
int /* O - 0 on success, non-zero on failure */
httpReconnect(http_t *http) /* I - HTTP data */
{
int val; /* Socket option value */
#ifdef HAVE_LIBSSL
SSL_CTX *context; /* Context for encryption */
SSL *conn; /* Connection for encryption */
int val; /* Socket option value */
if (http->tls)
{
conn = (SSL *)(http->tls);
context = SSL_get_SSL_CTX(conn);
SSL_shutdown(conn);
SSL_CTX_free(context);
SSL_free(conn);
http->tls = NULL;
}
#endif /* HAVE_LIBSSL */
/*
* Close any previously open socket...
*/
@@ -489,44 +377,6 @@ httpReconnect(http_t *http) /* I - HTTP data */
http->error = 0;
http->status = HTTP_CONTINUE;
#ifdef HAVE_LIBSSL
if (http->encryption == HTTP_ENCRYPT_ALWAYS)
{
/*
* Always do encryption via SSL.
*/
context = SSL_CTX_new(SSLv23_method());
conn = SSL_new(context);
SSL_set_fd(conn, http->fd);
if (SSL_connect(conn) != 1)
{
SSL_CTX_free(context);
SSL_free(conn);
#if defined(WIN32) || defined(__EMX__)
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 || __EMX__ */
http->status = HTTP_ERROR;
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif
return (-1);
}
http->tls = conn;
}
else if (http->encryption == HTTP_ENCRYPT_REQUIRED)
return (http_upgrade(http));
#endif /* HAVE_LIBSSL */
return (0);
}
@@ -544,9 +394,7 @@ httpSeparate(const char *uri, /* I - Universal Resource Identifier */
int *port, /* O - Port number to use */
char *resource) /* O - Resource/filename [1024] */
{
char *ptr; /* Pointer into string... */
const char *atsign, /* @ sign */
*slash; /* Separator */
char *ptr; /* Pointer into string... */
if (uri == NULL || method == NULL || username == NULL || host == NULL ||
@@ -639,49 +487,44 @@ httpSeparate(const char *uri, /* I - Universal Resource Identifier */
}
/*
* Grab the usenname, if any...
* Grab the hostname...
*/
while (*uri == '/')
uri ++;
if ((slash = strchr(uri, '/')) == NULL)
slash = uri + strlen(uri);
if ((atsign = strchr(uri, '@')) != NULL && atsign < slash)
{
/*
* Got a username:password combo...
*/
for (ptr = username;
uri < atsign && ptr < (username + sizeof(username) - 1);
*ptr++ = *uri++);
*ptr = '\0';
uri = atsign + 1;
}
else
username[0] = '\0';
/*
* Grab the hostname...
*/
ptr = host;
while (*uri != ':' && *uri != '/' && *uri != '\0')
while (!(*uri == ':' && isdigit(uri[1])) && *uri != '@' && *uri != '/' && *uri != '\0')
*ptr ++ = *uri ++;
*ptr = '\0';
if (*uri == '@')
{
/*
* Got a username...
*/
strncpy(username, host, 31);
username[31] = '\0';
ptr = host;
uri ++;
while (*uri != ':' && *uri != '/' && *uri != '\0')
*ptr ++ = *uri ++;
*ptr = '\0';
}
else
username[0] = '\0';
if (*uri != ':')
{
if (strcasecmp(method, "http") == 0)
*port = 80;
else if (strcasecmp(method, "https") == 0)
*port = 443;
else if (strcasecmp(method, "ipp") == 0)
else if (strcasecmp(method, "ipp") == 0) /* Not registered yet... */
*port = ippPort();
else if (strcasecmp(method, "socket") == 0) /* Not registered yet... */
*port = 9100;
@@ -723,119 +566,6 @@ httpSeparate(const char *uri, /* I - Universal Resource Identifier */
}
/*
* 'httpGetSubField()' - Get a sub-field value.
*/
char * /* O - Value or NULL */
httpGetSubField(http_t *http, /* I - HTTP data */
http_field_t field, /* I - Field index */
const char *name, /* I - Name of sub-field */
char *value) /* O - Value string */
{
const char *fptr; /* Pointer into field */
char temp[HTTP_MAX_VALUE], /* Temporary buffer for name */
*ptr; /* Pointer into string buffer */
if (http == NULL ||
field < HTTP_FIELD_ACCEPT_LANGUAGE ||
field > HTTP_FIELD_WWW_AUTHENTICATE ||
name == NULL || value == NULL)
return (NULL);
for (fptr = http->fields[field]; *fptr;)
{
/*
* Skip leading whitespace...
*/
while (isspace(*fptr));
fptr ++;
if (*fptr == ',')
{
fptr ++;
continue;
}
/*
* Get the sub-field name...
*/
for (ptr = temp;
*fptr && *fptr != '=' && !isspace(*fptr) && ptr < (temp + sizeof(temp) - 1);
*ptr++ = *fptr++);
*ptr = '\0';
/*
* Skip trailing chars up to the '='...
*/
while (*fptr && *fptr != '=')
fptr ++;
if (!*fptr)
break;
/*
* Skip = and leading whitespace...
*/
fptr ++;
while (isspace(*fptr));
fptr ++;
if (*fptr == '\"')
{
/*
* Read quoted string...
*/
for (ptr = value, fptr ++;
*fptr && *fptr != '\"' && ptr < (value + HTTP_MAX_VALUE - 1);
*ptr++ = *fptr++);
*ptr = '\0';
while (*fptr && *fptr != '\"')
fptr ++;
if (*fptr)
fptr ++;
}
else
{
/*
* Read unquoted string...
*/
for (ptr = value;
*fptr && !isspace(*fptr) && *fptr != ',' && ptr < (value + HTTP_MAX_VALUE - 1);
*ptr++ = *fptr++);
*ptr = '\0';
while (*fptr && !isspace(*fptr) && *fptr != ',')
fptr ++;
}
/*
* See if this is the one...
*/
if (strcmp(name, temp) == 0)
return (value);
}
value[0] = '\0';
return (NULL);
}
/*
* 'httpSetField()' - Set the value of an HTTP header.
*/
@@ -845,12 +575,6 @@ httpSetField(http_t *http, /* I - HTTP data */
http_field_t field, /* I - Field index */
const char *value) /* I - Value */
{
if (http == NULL ||
field < HTTP_FIELD_ACCEPT_LANGUAGE ||
field > HTTP_FIELD_WWW_AUTHENTICATE ||
value == NULL)
return;
strncpy(http->fields[field], value, HTTP_MAX_VALUE - 1);
http->fields[field][HTTP_MAX_VALUE - 1] = '\0';
}
@@ -1032,10 +756,6 @@ httpRead(http_t *http, /* I - HTTP data */
if (http->used > 0)
memcpy(http->buffer, http->buffer + length, http->used);
}
#ifdef HAVE_LIBSSL
else if (http->tls)
bytes = SSL_read((SSL *)(http->tls), buffer, length);
#endif /* HAVE_LIBSSL */
else
{
DEBUG_printf(("httpRead: reading %d bytes from socket...\n", length));
@@ -1118,13 +838,7 @@ httpWrite(http_t *http, /* I - HTTP data */
while (length > 0)
{
#ifdef HAVE_LIBSSL
if (http->tls)
bytes = SSL_write((SSL *)(http->tls), buffer, length);
else
#endif /* HAVE_LIBSSL */
bytes = send(http->fd, buffer, length, 0);
if (bytes < 0)
{
DEBUG_puts("httpWrite: error writing data...\n");
@@ -1204,21 +918,13 @@ httpGets(char *line, /* I - Line to read into */
else
bufptr ++;
if (bufptr >= bufend && http->used < HTTP_MAX_BUFFER)
if (bufptr >= bufend)
{
/*
* No newline; see if there is more data to be read...
*/
#ifdef HAVE_LIBSSL
if (http->tls)
bytes = SSL_read((SSL *)(http->tls), bufend,
HTTP_MAX_BUFFER - http->used);
else
#endif /* HAVE_LIBSSL */
bytes = recv(http->fd, bufend, HTTP_MAX_BUFFER - http->used, 0);
if (bytes < 0)
if ((bytes = recv(http->fd, bufend, HTTP_MAX_BUFFER - http->used, 0)) < 0)
{
/*
* Nope, can't get a line this time...
@@ -1260,7 +966,7 @@ httpGets(char *line, /* I - Line to read into */
bufend += bytes;
}
}
while (bufptr >= bufend && http->used < HTTP_MAX_BUFFER);
while (bufptr >= bufend);
http->activity = time(NULL);
@@ -1324,17 +1030,8 @@ httpPrintf(http_t *http, /* I - HTTP data */
DEBUG_printf(("httpPrintf: %s", buf));
for (tbytes = 0, bufptr = buf; tbytes < bytes; tbytes += nbytes, bufptr += nbytes)
{
#ifdef HAVE_LIBSSL
if (http->tls)
nbytes = SSL_write((SSL *)(http->tls), bufptr, bytes - tbytes);
else
#endif /* HAVE_LIBSSL */
nbytes = send(http->fd, bufptr, bytes - tbytes, 0);
if (nbytes < 0)
if ((nbytes = send(http->fd, bufptr, bytes - tbytes, 0)) < 0)
return (-1);
}
return (bytes);
}
@@ -1349,10 +1046,6 @@ httpStatus(http_status_t status) /* I - HTTP status code */
{
switch (status)
{
case HTTP_CONTINUE :
return ("Continue");
case HTTP_SWITCHING_PROTOCOLS :
return ("Switching Protocols");
case HTTP_OK :
return ("OK");
case HTTP_CREATED :
@@ -1375,8 +1068,6 @@ httpStatus(http_status_t status) /* I - HTTP status code */
return ("Request Entity Too Large");
case HTTP_URI_TOO_LONG :
return ("URI Too Long");
case HTTP_UPGRADE_REQUIRED :
return ("Upgrade Required");
case HTTP_NOT_IMPLEMENTED :
return ("Not Implemented");
case HTTP_NOT_SUPPORTED :
@@ -1399,9 +1090,9 @@ httpGetDateString(time_t t) /* I - UNIX time */
tdate = gmtime(&t);
snprintf(datetime, sizeof(datetime), "%s, %02d %s %d %02d:%02d:%02d GMT",
days[tdate->tm_wday], tdate->tm_mday, months[tdate->tm_mon],
tdate->tm_year + 1900, tdate->tm_hour, tdate->tm_min, tdate->tm_sec);
sprintf(datetime, "%s, %02d %s %d %02d:%02d:%02d GMT",
days[tdate->tm_wday], tdate->tm_mday, months[tdate->tm_mon],
tdate->tm_year + 1900, tdate->tm_hour, tdate->tm_min, tdate->tm_sec);
return (datetime);
}
@@ -1455,10 +1146,6 @@ httpUpdate(http_t *http) /* I - HTTP data */
http_field_t field; /* Field index */
int major, minor; /* HTTP version numbers */
http_status_t status; /* Authorization status */
#ifdef HAVE_LIBSSL
SSL_CTX *context; /* Context for encryption */
SSL *conn; /* Connection for encryption */
#endif /* HAVE_LIBSSL */
DEBUG_printf(("httpUpdate(%08x)\n", http));
@@ -1492,43 +1179,6 @@ httpUpdate(http_t *http) /* I - HTTP data */
if (http->status == HTTP_CONTINUE)
return (http->status);
#ifdef HAVE_LIBSSL
if (http->status == HTTP_SWITCHING_PROTOCOLS && !http->tls)
{
context = SSL_CTX_new(SSLv23_method());
conn = SSL_new(context);
SSL_set_fd(conn, http->fd);
if (SSL_connect(conn) != 1)
{
SSL_CTX_free(context);
SSL_free(conn);
#if defined(WIN32) || defined(__EMX__)
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 || __EMX__ */
http->status = HTTP_ERROR;
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif
return (HTTP_ERROR);
}
http->tls = conn;
return (HTTP_CONTINUE);
}
else if (http->status == HTTP_UPGRADE_REQUIRED &&
http->encryption != HTTP_ENCRYPT_NEVER)
http->encryption = HTTP_ENCRYPT_REQUIRED;
#endif /* HAVE_LIBSSL */
httpGetLength(http);
switch (http->state)
@@ -1553,7 +1203,7 @@ httpUpdate(http_t *http) /* I - HTTP data */
* Got the beginning of a response...
*/
if (sscanf(line, "HTTP/%d.%d%d", &major, &minor, (int *)&status) != 3)
if (sscanf(line, "HTTP/%d.%d%d", &major, &minor, &status) != 3)
return (HTTP_ERROR);
http->version = (http_version_t)(major * 100 + minor);
@@ -1858,14 +1508,6 @@ http_send(http_t *http, /* I - HTTP data */
http->status = HTTP_CONTINUE;
#ifdef HAVE_LIBSSL
if (http->encryption == HTTP_ENCRYPT_REQUIRED && !http->tls)
{
httpSetField(http, HTTP_FIELD_CONNECTION, "Upgrade");
httpSetField(http, HTTP_FIELD_UPGRADE, "TLS/1.0,SSL/2.0,SSL/3.0");
}
#endif /* HAVE_LIBSSL */
if (httpPrintf(http, "%s %s HTTP/1.1\r\n", codes[request], buf) < 1)
{
http->status = HTTP_ERROR;
@@ -1896,75 +1538,6 @@ http_send(http_t *http, /* I - HTTP data */
}
#ifdef HAVE_LIBSSL
/*
* 'http_upgrade()' - Force upgrade to TLS encryption.
*/
static int /* O - Status of connection */
http_upgrade(http_t *http) /* I - HTTP data */
{
SSL_CTX *context; /* Context for encryption */
SSL *conn; /* Connection for encryption */
char buffer[1024]; /* Status from server... */
/*
* Send an OPTIONS request to the server, requiring SSL or TLS
* encryption on the link...
*/
if (httpPrintf(http, "OPTIONS * HTTP/1.1\r\n") < 0)
return (-1);
if (httpPrintf(http, "Host: %s\r\n", http->hostname) < 0)
return (-1);
if (httpPrintf(http, "Connection: upgrade\r\n") < 0)
return (-1);
if (httpPrintf(http, "Upgrade: TLS/1.0, SSL/2.0, SSL/3.0\r\n") < 0)
return (-1);
if (httpPrintf(http, "\r\n") < 0)
return (-1);
/*
* Wait for the response data...
*/
while (httpGets(buffer, sizeof(buffer), http) != NULL)
if (!buffer[0])
break;
context = SSL_CTX_new(SSLv23_method());
conn = SSL_new(context);
SSL_set_fd(conn, http->fd);
if (SSL_connect(conn) != 1)
{
SSL_CTX_free(context);
SSL_free(conn);
#if defined(WIN32) || defined(__EMX__)
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 || __EMX__ */
http->status = HTTP_ERROR;
#ifdef WIN32
closesocket(http->fd);
#else
close(http->fd);
#endif
return (-1);
}
http->tls = conn;
return (0);
}
#endif /* HAVE_LIBSSL */
/*
* End of "$Id$".
*/
+3 -30
Ver Arquivo
@@ -126,19 +126,6 @@ typedef enum
} http_encoding_t;
/*
* HTTP encryption values...
*/
typedef enum
{
HTTP_ENCRYPT_IF_REQUESTED, /* Encrypt if requested (TLS upgrade) */
HTTP_ENCRYPT_NEVER, /* Never encrypt */
HTTP_ENCRYPT_REQUIRED, /* Encryption is required (TLS upgrade) */
HTTP_ENCRYPT_ALWAYS /* Always encrypt (SSL) */
} http_encryption_t;
/*
* HTTP authentication types...
*/
@@ -163,7 +150,6 @@ typedef enum
HTTP_ERROR = -1, /* An error response from httpXxxx() */
HTTP_CONTINUE = 100, /* Everything OK, keep going... */
HTTP_SWITCHING_PROTOCOLS, /* HTTP upgrade to TLS/SSL */
HTTP_OK = 200, /* OPTIONS/GET/HEAD/POST/TRACE command was successful */
HTTP_CREATED, /* PUT command was successful */
@@ -196,7 +182,6 @@ typedef enum
HTTP_REQUEST_TOO_LARGE, /* Request entity too large */
HTTP_URI_TOO_LONG, /* URI too long */
HTTP_UNSUPPORTED_MEDIATYPE, /* The requested media type is unsupported */
HTTP_UPGRADE_REQUIRED = 426, /* Upgrade to SSL/TLS required */
HTTP_SERVER_ERROR = 500, /* Internal server error */
HTTP_NOT_IMPLEMENTED, /* Feature not implemented */
@@ -275,8 +260,6 @@ typedef struct
char nonce[HTTP_MAX_VALUE];
/* Nonce value */
int nonce_count; /* Nonce count */
void *tls; /* TLS state information */
http_encryption_t encryption; /* Encryption requirements */
} http_t;
@@ -291,7 +274,6 @@ extern int httpCheck(http_t *http);
extern void httpClose(http_t *http);
extern http_t *httpConnect(const char *host, int port);
extern int httpDelete(http_t *http, const char *uri);
extern int httpEncryption(http_t *http, http_encryption_t e);
# define httpError(http) ((http)->error)
extern void httpFlush(http_t *http);
extern int httpGet(http_t *http, const char *uri);
@@ -299,8 +281,6 @@ extern char *httpGets(char *line, int length, http_t *http);
extern const char *httpGetDateString(time_t t);
extern time_t httpGetDateTime(const char *s);
# define httpGetField(http,field) (http)->fields[field]
extern char *httpGetSubField(http_t *http, http_field_t field,
const char *name, char *value);
extern int httpHead(http_t *http, const char *uri);
extern void httpInitialize(void);
extern int httpOptions(http_t *http, const char *uri);
@@ -309,11 +289,9 @@ extern int httpPrintf(http_t *http, const char *format, ...);
extern int httpPut(http_t *http, const char *uri);
extern int httpRead(http_t *http, char *buffer, int length);
extern int httpReconnect(http_t *http);
extern void httpSeparate(const char *uri, char *method,
char *username, char *host, int *port,
char *resource);
extern void httpSetField(http_t *http, http_field_t field,
const char *value);
extern void httpSeparate(const char *uri, char *method, char *username,
char *host, int *port, char *resource);
extern void httpSetField(http_t *http, http_field_t field, const char *value);
extern const char *httpStatus(http_status_t status);
extern int httpTrace(http_t *http, const char *uri);
extern http_status_t httpUpdate(http_t *http);
@@ -321,11 +299,6 @@ extern int httpWrite(http_t *http, const char *buffer, int length);
extern char *httpEncode64(char *out, const char *in);
extern char *httpDecode64(char *out, const char *in);
extern int httpGetLength(http_t *http);
extern char *httpMD5(const char *, const char *, const char *,
char [33]);
extern char *httpMD5Final(const char *, const char *, const char *,
char [33]);
extern char *httpMD5String(const md5_byte_t *, char [33]);
/*
+56 -139
Ver Arquivo
@@ -41,14 +41,11 @@
* ippErrorString() - Return a textual message for the given error message.
* ippFindAttribute() - Find a named attribute in a request...
* ippLength() - Compute the length of an IPP request.
* ippNew() - Allocate a new IPP request.
* ippPort() - Return the default IPP port number.
* ippRead() - Read data for an IPP request.
* ippSetPort() - Set the default port number.
* ippTimeToDate() - Convert from UNIX time to RFC 1903 format.
* ippWrite() - Write data for an IPP request.
* _ipp_add_attr() - Add a new attribute to the request.
* _ipp_free_attr() - Free an attribute.
* _ipp_add_attr() - Add a new attribute to the request.
* ipp_read() - Semi-blocking read on a HTTP connection...
*/
@@ -63,14 +60,6 @@
#include "ipp.h"
#include "debug.h"
#include <ctype.h>
/*
* Local globals...
*/
static int ipp_port = 0;
/*
@@ -93,7 +82,7 @@ ippAddBoolean(ipp_t *ipp, /* I - IPP request */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("ippAddBoolean(%p, %02x, \'%s\', %d)\n", ipp, group, name, value));
DEBUG_printf(("ippAddBoolean(%08x, %02x, \'%s\', %d)\n", ipp, group, name, value));
if (ipp == NULL || name == NULL)
return (NULL);
@@ -125,7 +114,7 @@ ippAddBooleans(ipp_t *ipp, /* I - IPP request */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("ippAddBooleans(%p, %02x, \'%s\', %d, %p)\n", ipp,
DEBUG_printf(("ippAddBooleans(%08x, %02x, \'%s\', %d, %08x)\n", ipp,
group, name, num_values, values));
if (ipp == NULL || name == NULL)
@@ -159,7 +148,7 @@ ippAddDate(ipp_t *ipp, /* I - IPP request */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("ippAddDate(%p, %02x, \'%s\', %p)\n", ipp, group, name,
DEBUG_printf(("ippAddDate(%08x, %02x, \'%s\', %08x)\n", ipp, group, name,
value));
if (ipp == NULL || name == NULL || value == NULL)
@@ -191,7 +180,7 @@ ippAddInteger(ipp_t *ipp, /* I - IPP request */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("ippAddInteger(%p, %d, \'%s\', %d)\n", ipp, group, name,
DEBUG_printf(("ippAddInteger(%08x, %d, \'%s\', %d)\n", ipp, group, name,
value));
if (ipp == NULL || name == NULL)
@@ -268,24 +257,7 @@ ippAddString(ipp_t *ipp, /* I - IPP request */
attr->group_tag = group;
attr->value_tag = type;
attr->values[0].string.charset = charset ? strdup(charset) : NULL;
attr->values[0].string.text = value ? strdup(value) : NULL;
if ((type == IPP_TAG_LANGUAGE || type == IPP_TAG_CHARSET) &&
attr->values[0].string.text)
{
/*
* Convert to lowercase and change _ to - as needed...
*/
char *p;
for (p = attr->values[0].string.text; *p; p ++)
if (*p == '_')
*p = '-';
else
*p = tolower(*p);
}
attr->values[0].string.text = strdup(value);
return (attr);
}
@@ -481,7 +453,7 @@ ippAddSeparator(ipp_t *ipp) /* I - IPP request */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("ippAddSeparator(%p)\n", ipp));
DEBUG_printf(("ippAddSeparator(%08x)\n", ipp));
if (ipp == NULL)
return (NULL);
@@ -552,19 +524,48 @@ ippDateToTime(const ipp_uchar_t *date) /* I - RFC 1903 date info */
void
ippDelete(ipp_t *ipp) /* I - IPP request */
{
int i; /* Looping var */
ipp_attribute_t *attr, /* Current attribute */
*next; /* Next attribute */
DEBUG_printf(("ippNew(): %p\n", ipp));
if (ipp == NULL)
return;
for (attr = ipp->attrs; attr != NULL; attr = next)
{
switch (attr->value_tag)
{
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_STRING :
case IPP_TAG_URI :
case IPP_TAG_URISCHEME :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_MIMETYPE :
for (i = 0; i < attr->num_values; i ++)
free(attr->values[i].string.text);
break;
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
for (i = 0; i < attr->num_values; i ++)
{
if (attr->values[i].string.charset)
free(attr->values[i].string.charset);
free(attr->values[i].string.text);
}
break;
}
next = attr->next;
_ipp_free_attr(attr);
if (attr->name != NULL)
free(attr->name);
free(attr);
}
free(ipp);
@@ -635,18 +636,16 @@ ippErrorString(ipp_status_t error) /* I - Error status */
return (cupsLangString(language, HTTP_NOT_SUPPORTED));
case IPP_SERVICE_UNAVAILABLE :
case IPP_DEVICE_ERROR :
case IPP_DEVICE_UNAVAILABLE :
case IPP_TEMPORARY_ERROR :
case IPP_PRINTER_BUSY :
return (cupsLangString(language, HTTP_SERVICE_UNAVAILABLE));
case IPP_NOT_ACCEPTING :
return (cupsLangString(language, CUPS_MSG_NOT_ACCEPTING_JOBS));
default :
return ("ERROR");
}
return ("ERROR");
}
@@ -659,26 +658,23 @@ ippFindAttribute(ipp_t *ipp, /* I - IPP request */
const char *name, /* I - Name of attribute */
ipp_tag_t type) /* I - Type of attribute */
{
ipp_attribute_t *attr; /* Current atttribute */
ipp_tag_t value_tag; /* Value tag */
ipp_attribute_t *attr; /* Current atttribute */
DEBUG_printf(("ippFindAttribute(%p, \'%s\')\n", ipp, name));
DEBUG_printf(("ippFindAttribute(%08x, \'%s\')\n", ipp, name));
if (ipp == NULL || name == NULL)
return (NULL);
for (attr = ipp->attrs; attr != NULL; attr = attr->next)
{
DEBUG_printf(("ippFindAttribute: attr = %p, name = \'%s\'\n", attr,
DEBUG_printf(("ippFindAttribute: attr = %08x, name = \'%s\'\n", attr,
attr->name));
value_tag = attr->value_tag & ~IPP_TAG_COPY;
if (attr->name != NULL && strcasecmp(attr->name, name) == 0 &&
(value_tag == type || type == IPP_TAG_ZERO ||
(value_tag == IPP_TAG_TEXTLANG && type == IPP_TAG_TEXT) ||
(value_tag == IPP_TAG_NAMELANG && type == IPP_TAG_NAME)))
(attr->value_tag == type ||
(attr->value_tag == IPP_TAG_TEXTLANG && type == IPP_TAG_TEXT) ||
(attr->value_tag == IPP_TAG_NAMELANG && type == IPP_TAG_NAME)))
return (attr);
}
@@ -733,7 +729,7 @@ ippLength(ipp_t *ipp) /* I - IPP request */
bytes += 2 * attr->num_values; /* Name lengths */
bytes += 2 * attr->num_values; /* Value lengths */
switch (attr->value_tag & ~IPP_TAG_COPY)
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
@@ -814,8 +810,6 @@ ippNew(void)
temp->request.any.version[1] = 1;
}
DEBUG_printf(("ippNew(): %p\n", temp));
return (temp);
}
@@ -835,7 +829,7 @@ ippRead(http_t *http, /* I - HTTP data */
ipp_tag_t tag; /* Current tag */
DEBUG_printf(("ippRead(%p, %p)\n", http, ipp));
DEBUG_printf(("ippRead(%08x, %08x)\n", http, ipp));
if (http == NULL || ipp == NULL)
return (IPP_ERROR);
@@ -881,10 +875,6 @@ ippRead(http_t *http, /* I - HTTP data */
ipp->current = NULL;
ipp->curtag = IPP_TAG_ZERO;
DEBUG_printf(("ippRead: version=%d.%d\n", buffer[0], buffer[1]));
DEBUG_printf(("ippRead: op_status=%04x\n", ipp->request.any.op_status));
DEBUG_printf(("ippRead: request_id=%d\n", ipp->request.any.request_id));
/*
* If blocking is disabled, stop here...
*/
@@ -1114,9 +1104,6 @@ ippRead(http_t *http, /* I - HTTP data */
case IPP_DATA :
break;
default :
break; /* anti-compiler-warning-code */
}
return (ipp->state);
@@ -1219,10 +1206,6 @@ ippWrite(http_t *http, /* I - HTTP data */
ipp->current = ipp->attrs;
ipp->curtag = IPP_TAG_ZERO;
DEBUG_printf(("ippWrite: version=%d.%d\n", buffer[0], buffer[1]));
DEBUG_printf(("ippWrite: op_status=%04x\n", ipp->request.any.op_status));
DEBUG_printf(("ippWrite: request_id=%d\n", ipp->request.any.request_id));
/*
* If blocking is disabled, stop here...
*/
@@ -1268,7 +1251,7 @@ ippWrite(http_t *http, /* I - HTTP data */
memcpy(bufptr, attr->name, n);
bufptr += n;
switch (attr->value_tag & ~IPP_TAG_COPY)
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
@@ -1463,7 +1446,7 @@ ippWrite(http_t *http, /* I - HTTP data */
n = strlen(attr->values[i].string.charset) +
strlen(attr->values[i].string.text) +
4;
2;
if ((sizeof(buffer) - (bufptr - buffer)) < (n + 2))
{
@@ -1581,9 +1564,6 @@ ippWrite(http_t *http, /* I - HTTP data */
case IPP_DATA :
break;
default :
break; /* anti-compiler-warning-code */
}
return (ipp->state);
@@ -1601,25 +1581,12 @@ ippPort(void)
struct servent *port; /* Port number info */
if (ipp_port)
return (ipp_port);
else if ((server_port = getenv("IPP_PORT")) != NULL)
return (ipp_port = atoi(server_port));
if ((server_port = getenv("IPP_PORT")) != NULL)
return (atoi(server_port));
else if ((port = getservbyname("ipp", NULL)) == NULL)
return (ipp_port = IPP_PORT);
return (IPP_PORT);
else
return (ipp_port = ntohs(port->s_port));
}
/*
* 'ippSetPort()' - Set the default port number.
*/
void
ippSetPort(int p) /* I - Port number to use */
{
ipp_port = p;
return (ntohs(port->s_port));
}
@@ -1634,7 +1601,7 @@ _ipp_add_attr(ipp_t *ipp, /* I - IPP request */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("_ipp_add_attr(%p, %d)\n", ipp, num_values));
DEBUG_printf(("_ipp_add_attr(%08x, %d)\n", ipp, num_values));
if (ipp == NULL || num_values < 0)
return (NULL);
@@ -1654,60 +1621,10 @@ _ipp_add_attr(ipp_t *ipp, /* I - IPP request */
ipp->last = attr;
DEBUG_printf(("_ipp_add_attr(): %p\n", attr));
return (attr);
}
/*
* '_ipp_free_attr()' - Free an attribute.
*/
void
_ipp_free_attr(ipp_attribute_t *attr) /* I - Attribute to free */
{
int i; /* Looping var */
DEBUG_printf(("_ipp_free_attr(): %p\n", attr));
switch (attr->value_tag)
{
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_STRING :
case IPP_TAG_URI :
case IPP_TAG_URISCHEME :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_MIMETYPE :
for (i = 0; i < attr->num_values; i ++)
free(attr->values[i].string.text);
break;
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
for (i = 0; i < attr->num_values; i ++)
{
if (attr->values[i].string.charset && i == 0)
free(attr->values[i].string.charset);
free(attr->values[i].string.text);
}
break;
default :
break; /* anti-compiler-warning-code */
}
if (attr->name != NULL)
free(attr->name);
free(attr);
}
/*
* 'ipp_read()' - Semi-blocking read on a HTTP connection...
*/
+13 -18
Ver Arquivo
@@ -30,7 +30,7 @@
* Include necessary headers...
*/
# include "http.h"
# include <cups/http.h>
/*
@@ -80,9 +80,6 @@ typedef enum /**** Format tags for attribute formats... ****/
IPP_TAG_DEFAULT,
IPP_TAG_UNKNOWN,
IPP_TAG_NOVALUE,
IPP_TAG_NOTSETTABLE = 0x15,
IPP_TAG_DELETEATTR,
IPP_TAG_ANYVALUE,
IPP_TAG_INTEGER = 0x21,
IPP_TAG_BOOLEAN,
IPP_TAG_ENUM,
@@ -100,8 +97,7 @@ typedef enum /**** Format tags for attribute formats... ****/
IPP_TAG_URISCHEME,
IPP_TAG_CHARSET,
IPP_TAG_LANGUAGE,
IPP_TAG_MIMETYPE,
IPP_TAG_COPY = 0x80000000
IPP_TAG_MIMETYPE
} ipp_tag_t;
typedef enum /**** Resolution units... ****/
@@ -110,6 +106,14 @@ typedef enum /**** Resolution units... ****/
IPP_RES_PER_CM
} ipp_res_t;
typedef enum /**** Multiple Document Handling ****/
{
IPP_DOC_SINGLE,
IPP_DOC_UNCOLLATED,
IPP_DOC_COLLATED,
IPP_DOC_SEPARATE
} ipp_doc_t;
typedef enum /**** Finishings... ****/
{
IPP_FINISH_NONE = 3,
@@ -194,8 +198,7 @@ typedef enum /**** IPP operations... ****/
CUPS_REJECT_JOBS,
CUPS_SET_DEFAULT,
CUPS_GET_DEVICES,
CUPS_GET_PPDS,
CUPS_MOVE_JOB
CUPS_GET_PPDS
} ipp_op_t;
typedef enum /**** IPP status codes... ****/
@@ -218,20 +221,14 @@ typedef enum /**** IPP status codes... ****/
IPP_URI_SCHEME,
IPP_CHARSET,
IPP_CONFLICT,
IPP_COMPRESSION_NOT_SUPPORTED,
IPP_COMPRESSION_ERROR,
IPP_DOCUMENT_FORMAT_ERROR,
IPP_DOCUMENT_ACCESS_ERROR,
IPP_INTERNAL_ERROR = 0x0500,
IPP_OPERATION_NOT_SUPPORTED,
IPP_SERVICE_UNAVAILABLE,
IPP_VERSION_NOT_SUPPORTED,
IPP_DEVICE_ERROR,
IPP_DEVICE_UNAVAILABLE,
IPP_TEMPORARY_ERROR,
IPP_NOT_ACCEPTING,
IPP_PRINTER_BUSY,
IPP_ERROR_JOB_CANCELLED,
IPP_MULTIPLE_JOBS_NOT_SUPPORTED
IPP_PRINTER_BUSY
} ipp_status_t;
typedef unsigned char ipp_uchar_t;/**** Unsigned 8-bit integer/character ****/
@@ -343,10 +340,8 @@ extern ipp_state_t ippRead(http_t *http, ipp_t *ipp);
extern const ipp_uchar_t *ippTimeToDate(time_t t);
extern ipp_state_t ippWrite(http_t *http, ipp_t *ipp);
extern int ippPort(void);
extern void ippSetPort(int p);
extern ipp_attribute_t *_ipp_add_attr(ipp_t *, int);
extern void _ipp_free_attr(ipp_attribute_t *);
/*
+16 -33
Ver Arquivo
@@ -50,30 +50,17 @@ static char *lang_blank = ""; /* Blank constant string */
static char *lang_encodings[] = /* Encoding strings */
{
"us-ascii",
"iso-8859-1",
"iso-8859-2",
"iso-8859-3",
"iso-8859-4",
"iso-8859-5",
"iso-8859-6",
"iso-8859-7",
"iso-8859-8",
"iso-8859-9",
"iso-8859-10",
"utf-8",
"iso-8859-13",
"iso-8859-14",
"iso-8859-15",
"windows-874",
"windows-1250",
"windows-1251",
"windows-1252",
"windows-1253",
"windows-1254",
"windows-1255",
"windows-1256",
"windows-1257",
"windows-1258"
"iso8859-1",
"iso8859-2",
"iso8859-3",
"iso8859-4",
"iso8859-5",
"iso8859-6",
"iso8859-7",
"iso8859-8",
"iso8859-9",
"iso8859-10",
"utf8"
};
static char *lang_default[] = /* Default POSIX locale */
{
@@ -157,7 +144,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
/*
* Convert the language string passed in to a locale string. "C" is the
* standard POSIX locale and is copied unchanged. Otherwise the
* language string is converted from ll-cc (language-country) to ll_cc
* language string is converted from ll-cc (language-country) to ll_CC
* to match the file naming convention used by all POSIX-compliant
* operating systems. Any trailing character set specification is
* dropped.
@@ -263,10 +250,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
*/
if (fp == NULL)
{
strncpy(line, lang_default[0], sizeof(line) - 1);
line[sizeof(line) - 1] = '\0';
}
strcpy(line, lang_default[0]);
else if (fgets(line, sizeof(line), fp) == NULL)
{
/*
@@ -306,6 +290,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
lang_cache = lang;
}
/*
* Free all old strings as needed...
*/
@@ -323,8 +308,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
*/
lang->used ++;
strncpy(lang->language, langname, sizeof(lang->language) - 1);
lang->language[sizeof(lang->language) - 1] = '\0';
strcpy(lang->language, langname);
for (i = 0; i < (sizeof(lang_encodings) / sizeof(lang_encodings[0])); i ++)
if (strcmp(lang_encodings[i], line) == 0)
@@ -351,8 +335,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
if (lang_default[count] == NULL)
break;
strncpy(line, lang_default[count], sizeof(line) - 1);
/* Already set last byte to 0 above... */
strcpy(line, lang_default[count]);
}
else if (fgets(line, sizeof(line), fp) == NULL)
break;
+1 -14
Ver Arquivo
@@ -168,20 +168,7 @@ typedef enum /**** Language Encodings ****/
CUPS_ISO8859_8,
CUPS_ISO8859_9,
CUPS_ISO8859_10,
CUPS_UTF8,
CUPS_ISO8859_13,
CUPS_ISO8859_14,
CUPS_ISO8859_15,
CUPS_WINDOWS_874,
CUPS_WINDOWS_1250,
CUPS_WINDOWS_1251,
CUPS_WINDOWS_1252,
CUPS_WINDOWS_1253,
CUPS_WINDOWS_1254,
CUPS_WINDOWS_1255,
CUPS_WINDOWS_1256,
CUPS_WINDOWS_1257,
CUPS_WINDOWS_1258
CUPS_UTF8
} cups_encoding_t;
typedef struct cups_lang_str /**** Language Cache Structure ****/
+2 -12
Ver Arquivo
@@ -41,7 +41,6 @@
#include "ppd.h"
#include "string.h"
#include "debug.h"
/*
@@ -118,10 +117,7 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
if (c1->marked)
break;
if (j == 0 ||
strcasecmp(c1->choice, "None") == 0 ||
strcasecmp(c1->choice, "Off") == 0 ||
strcasecmp(c1->choice, "False") == 0)
if (j == 0 || strcasecmp(c1->choice, "None") == 0)
c1 = NULL;
}
@@ -151,10 +147,7 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
if (c2->marked)
break;
if (j == 0 ||
strcasecmp(c2->choice, "None") == 0 ||
strcasecmp(c2->choice, "Off") == 0 ||
strcasecmp(c2->choice, "False") == 0)
if (j == 0 || strcasecmp(c2->choice, "None") == 0)
c2 = NULL;
}
@@ -165,9 +158,6 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
if (c1 != NULL && c1->marked &&
c2 != NULL && c2->marked)
{
DEBUG_printf(("%s->%s conflicts with %s->%s (%s %s %s %s)\n",
o1->keyword, c1->choice, o2->keyword, c2->choice,
c->option1, c->choice1, c->option2, c->choice2));
conflicts ++;
o1->conflicted = 1;
o2->conflicted = 1;
-148
Ver Arquivo
@@ -1,148 +0,0 @@
/*
* "$Id$"
*
* MD5 password support for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-2000 by Easy Software Products.
*
* These coded instructions, statements, and computer programs are the
* property of Easy Software Products 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 please contact Easy Software Products
* at:
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
* EMail: cups-info@cups.org
* WWW: http://www.cups.org
*
* Contents:
*
* httpMD5() - Compute the MD5 sum of the username:group:password.
* httpMD5Nonce() - Combine the MD5 sum of the username, group, and password
* with the server-supplied nonce value.
* httpMD5String() - Convert an MD5 sum to a character string.
*/
/*
* Include necessary headers...
*/
#include "http.h"
#include "string.h"
/*
* 'httpMD5()' - Compute the MD5 sum of the username:group:password.
*/
char * /* O - MD5 sum */
httpMD5(const char *username, /* I - User name */
const char *realm, /* I - Realm name */
const char *passwd, /* I - Password string */
char md5[33]) /* O - MD5 string */
{
md5_state_t state; /* MD5 state info */
md5_byte_t sum[16]; /* Sum data */
char line[256]; /* Line to sum */
/*
* Compute the MD5 sum of the user name, group name, and password.
*/
snprintf(line, sizeof(line), "%s:%s:%s", username, realm, passwd);
md5_init(&state);
md5_append(&state, (md5_byte_t *)line, strlen(line));
md5_finish(&state, sum);
/*
* Return the sum...
*/
return (httpMD5String(sum, md5));
}
/*
* 'httpMD5Final()' - Combine the MD5 sum of the username, group, and password
* with the server-supplied nonce value, method, and
* request-uri.
*/
char * /* O - New sum */
httpMD5Final(const char *nonce, /* I - Server nonce value */
const char *method, /* I - METHOD (GET, POST, etc.) */
const char *resource, /* I - Resource path */
char md5[33]) /* IO - MD5 sum */
{
md5_state_t state; /* MD5 state info */
md5_byte_t sum[16]; /* Sum data */
char line[1024]; /* Line of data */
char a2[33]; /* Hash of method and resource */
/*
* First compute the MD5 sum of the method and resource...
*/
snprintf(line, sizeof(line), "%s:%s", method, resource);
md5_init(&state);
md5_append(&state, (md5_byte_t *)line, strlen(line));
md5_finish(&state, sum);
httpMD5String(sum, a2);
/*
* Then combine A1 (MD5 of username, realm, and password) with the nonce
* and A2 (method + resource) values to get the final MD5 sum for the
* request...
*/
snprintf(line, sizeof(line), "%s%s:%s", md5, nonce, a2);
md5_init(&state);
md5_append(&state, (md5_byte_t *)line, strlen(line));
md5_finish(&state, sum);
return (httpMD5String(sum, md5));
}
/*
* 'httpMD5String()' - Convert an MD5 sum to a character string.
*/
char * /* O - MD5 sum in hex */
httpMD5String(const md5_byte_t *sum, /* I - MD5 sum data */
char md5[33]) /* O - MD5 sum in hex */
{
int i; /* Looping var */
char *md5ptr; /* Pointer into MD5 string */
static 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);
}
/*
* End of "$Id$".
*/
+5 -291
Ver Arquivo
@@ -23,12 +23,11 @@
*
* Contents:
*
* cupsAddOption() - Add an option to an option array.
* cupsEncodeOptions() - Encode printer options into IPP attributes.
* cupsFreeOptions() - Free all memory used by options.
* cupsGetOption() - Get an option value.
* cupsParseOptions() - Parse options from a command-line argument.
* cupsMarkOptions() - Mark command-line options in a PPD file.
* cupsAddOption() - Add an option to an option array.
* cupsFreeOptions() - Free all memory used by options.
* cupsGetOption() - Get an option value.
* cupsParseOptions() - Parse options from a command-line argument.
* cupsMarkOptions() - Mark command-line options in a PPD file.
*/
/*
@@ -39,7 +38,6 @@
#include <stdlib.h>
#include <ctype.h>
#include "string.h"
#include "debug.h"
/*
@@ -102,274 +100,6 @@ cupsAddOption(const char *name, /* I - Name of option */
}
/*
* 'cupsEncodeOptions()' - Encode printer options into IPP attributes.
*/
void
cupsEncodeOptions(ipp_t *ipp, /* I - Request to add to */
int num_options, /* I - Number of options */
cups_option_t *options) /* I - Options */
{
int i, j; /* Looping vars */
int count; /* Number of values */
int n; /* Attribute value */
char *s, /* Pointer into option value */
*val, /* Pointer to option value */
*copy, /* Copy of option value */
*sep; /* Option separator */
ipp_attribute_t *attr; /* IPP job-id attribute */
DEBUG_printf(("cupsEncodeOptions(%p, %d, %p)\n", ipp, num_options, options));
if (ipp == NULL || num_options < 1 || options == NULL)
return;
/*
* Handle the document format stuff first...
*/
if ((val = (char *)cupsGetOption("document-format", num_options, options)) != NULL)
ippAddString(ipp, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, val);
else if (cupsGetOption("raw", num_options, options))
ippAddString(ipp, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else
ippAddString(ipp, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
/*
* Then add all other options...
*/
for (i = 0; i < num_options; i ++)
{
/*
* Skip document format options - handled above...
*/
if (strcasecmp(options[i].name, "raw") == 0 ||
strcasecmp(options[i].name, "document-format") == 0)
continue;
/*
* Count the number of values...
*/
for (count = 1, sep = options[i].value;
(sep = strchr(sep + 1, ',')) != NULL;
count ++);
DEBUG_printf(("cupsEncodeOptions: option = \'%s\', count = %d\n",
options[i].name, count));
if ((attr = _ipp_add_attr(ipp, count)) == NULL)
{
/*
* Ran out of memory!
*/
DEBUG_puts("cupsEncodeOptions: Ran out of memory for attributes!");
return;
}
attr->group_tag = IPP_TAG_JOB;
if ((attr->name = strdup(options[i].name)) == NULL)
{
/*
* Ran out of memory!
*/
DEBUG_puts("cupsEncodeOptions: Ran out of memory for name!");
return;
}
if (count > 1)
{
/*
* Make a copy of the value we can fiddle with...
*/
if ((copy = strdup(options[i].value)) == NULL)
{
/*
* Ran out of memory!
*/
DEBUG_puts("cupsEncodeOptions: Ran out of memory for value copy!");
return;
}
val = copy;
}
else
{
/*
* Since we have a single value, use the value directly...
*/
val = options[i].value;
copy = NULL;
}
/*
* See what the option value is; for compatibility with older interface
* scripts, we have to support single-argument options as well as
* option=value, option=low-high, option=MxN, and option=val1,val2,...,valN.
*/
if (*val == '\0')
{
/*
* Old-style System V boolean value...
*/
attr->value_tag = IPP_TAG_BOOLEAN;
if (strncasecmp(attr->name, "no", 2) == 0)
{
DEBUG_puts("cupsEncodeOptions: Added boolean false value...");
strcpy(attr->name, attr->name + 2);
attr->values[0].boolean = 0;
}
else
{
DEBUG_puts("cupsEncodeOptions: Added boolean true value...");
attr->values[0].boolean = 1;
}
}
else
{
/*
* Scan the value string for values...
*/
for (j = 0; *val != '\0'; val = sep, j ++)
{
/*
* Find the end of this value and mark it if needed...
*/
if ((sep = strchr(val, ',')) != NULL)
*sep++ = '\0';
else
sep = val + strlen(val);
/*
* See what kind of value it is...
*/
if (strcasecmp(val, "true") == 0 ||
strcasecmp(val, "on") == 0 ||
strcasecmp(val, "yes") == 0)
{
/*
* Boolean value - true...
*/
attr->value_tag = IPP_TAG_BOOLEAN;
attr->values[j].boolean = 1;
DEBUG_puts("cupsEncodeOptions: Added boolean true value...");
}
else if (strcasecmp(val, "false") == 0 ||
strcasecmp(val, "off") == 0 ||
strcasecmp(val, "no") == 0)
{
/*
* Boolean value - false...
*/
attr->value_tag = IPP_TAG_BOOLEAN;
attr->values[j].boolean = 0;
DEBUG_puts("cupsEncodeOptions: Added boolean false value...");
}
else
{
/*
* Number, range, resolution, or string...
*/
n = strtol(val, &s, 0);
if (*s != '\0' && *s != '-' && (*s != 'x' || s == val))
{
/*
* String value(s)...
*/
if ((attr->values[j].string.text = strdup(val)) == NULL)
{
/*
* Ran out of memory!
*/
DEBUG_puts("cupsEncodeOptions: Ran out of memory for string!");
return;
}
attr->value_tag = IPP_TAG_NAME;
DEBUG_printf(("cupsEncodeOptions: Added string value \'%s\'...\n", val));
}
else if (*s == '-')
{
attr->value_tag = IPP_TAG_RANGE;
attr->values[j].range.lower = n;
attr->values[j].range.upper = strtol(s + 1, NULL, 0);
DEBUG_printf(("cupsEncodeOptions: Added range option value %d-%d...\n",
n, attr->values[j].range.upper));
}
else if (*s == 'x')
{
attr->value_tag = IPP_TAG_RESOLUTION;
attr->values[j].resolution.xres = n;
attr->values[j].resolution.yres = strtol(s + 1, &s, 0);
if (strcasecmp(s, "dpc") == 0)
attr->values[j].resolution.units = IPP_RES_PER_CM;
else if (strcasecmp(s, "dpi") == 0)
attr->values[j].resolution.units = IPP_RES_PER_INCH;
else
{
if ((attr->values[j].string.text = strdup(val)) == NULL)
{
/*
* Ran out of memory!
*/
DEBUG_puts("cupsEncodeOptions: Ran out of memory for string!");
return;
}
attr->value_tag = IPP_TAG_NAME;
DEBUG_printf(("cupsEncodeOptions: Added string value \'%s\'...\n", val));
continue;
}
DEBUG_printf(("cupsEncodeOptions: Adding resolution option value %s...\n",
val));
}
else
{
attr->value_tag = IPP_TAG_INTEGER;
attr->values[j].integer = n;
DEBUG_printf(("cupsEncodeOptions: Adding integer option value %d...\n", n));
}
}
}
}
}
}
/*
* 'cupsFreeOptions()' - Free all memory used by options.
*/
@@ -442,17 +172,6 @@ cupsParseOptions(const char *arg, /* I - Argument to parse */
copyarg = strdup(arg);
ptr = copyarg;
/*
* Skip leading spaces...
*/
while (isspace(*ptr))
ptr ++;
/*
* Loop through the string...
*/
while (*ptr != '\0')
{
/*
@@ -648,11 +367,6 @@ cupsMarkOptions(ppd_file_t *ppd, /* I - PPD file */
if (ppdMarkOption(ppd, "CNRes_PGP", options->value)) /* Canon */
conflict = 1;
}
else if (strcasecmp(options->name, "output-bin") == 0)
{
if (ppdMarkOption(ppd, "OutputBin", options->value))
conflict = 1;
}
else if (ppdMarkOption(ppd, options->name, options->value))
conflict = 1;
+83 -171
Ver Arquivo
@@ -108,7 +108,6 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
ppd_emul_t *emul; /* Current emulation */
ppd_group_t *group; /* Current group */
char **font; /* Current font */
char **filter; /* Current filter */
/*
@@ -122,10 +121,6 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
* Free all strings at the top level...
*/
safe_free(ppd->patches);
safe_free(ppd->jcl_begin);
safe_free(ppd->jcl_ps);
safe_free(ppd->jcl_end);
safe_free(ppd->lang_encoding);
safe_free(ppd->lang_version);
safe_free(ppd->modelname);
@@ -176,18 +171,6 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
if (ppd->num_consts > 0)
safe_free(ppd->consts);
/*
* Free any filters...
*/
if (ppd->num_filters > 0)
{
for (i = ppd->num_filters, filter = ppd->filters; i > 0; i --, filter ++)
safe_free(*filter);
safe_free(ppd->filters);
}
/*
* Free any fonts...
*/
@@ -601,8 +584,6 @@ ppdOpen(FILE *fp) /* I - File to read from */
else
ppd->colorspace = PPD_CS_GRAY;
}
else if (strcmp(keyword, "cupsFlipDuplex") == 0)
ppd->flip_duplex = strcmp(string, "True") == 0;
else if (strcmp(keyword, "cupsManualCopies") == 0)
ppd->manual_copies = strcmp(string, "True") == 0;
else if (strcmp(keyword, "cupsModelNumber") == 0)
@@ -650,27 +631,6 @@ ppdOpen(FILE *fp) /* I - File to read from */
}
else if (strcmp(keyword, "Throughput") == 0)
ppd->throughput = atoi(string);
else if (strcmp(keyword, "Font") == 0)
{
/*
* Add this font to the list of available fonts...
*/
if (ppd->num_fonts == 0)
ppd->fonts = (char **)malloc(sizeof(char *));
else
ppd->fonts = (char **)realloc(ppd->fonts,
sizeof(char *) * (ppd->num_fonts + 1));
if (ppd->fonts == NULL)
{
ppdClose(ppd);
return (NULL);
}
ppd->fonts[ppd->num_fonts] = strdup(name);
ppd->num_fonts ++;
}
else if (strcmp(keyword, "VariablePaperSize") == 0 &&
strcmp(string, "True") == 0 &&
!ppd->variable_sizes)
@@ -687,26 +647,20 @@ ppdOpen(FILE *fp) /* I - File to read from */
* Add a "Custom" page size option...
*/
if ((option = ppdFindOption(ppd, "PageSize")) == NULL)
if ((group = ppd_get_group(ppd,
cupsLangString(language,
CUPS_MSG_GENERAL))) == NULL)
{
ppd_group_t *temp;
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((temp = ppd_get_group(ppd,
cupsLangString(language,
CUPS_MSG_GENERAL))) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((option = ppd_get_option(temp, "PageSize")) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((option = ppd_get_option(group, "PageSize")) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((choice = ppd_add_choice(option, "Custom")) == NULL)
@@ -718,6 +672,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
strncpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE),
sizeof(choice->text) - 1);
group = NULL;
option = NULL;
}
else if (strcmp(keyword, "MaxMediaWidth") == 0)
@@ -754,33 +709,24 @@ ppdOpen(FILE *fp) /* I - File to read from */
* Add a "Custom" page size option...
*/
if ((option = ppdFindOption(ppd, "PageSize")) == NULL)
if ((group = ppd_get_group(ppd,
cupsLangString(language,
CUPS_MSG_GENERAL))) == NULL)
{
ppd_group_t *temp;
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((temp = ppd_get_group(ppd,
cupsLangString(language,
CUPS_MSG_GENERAL))) == NULL)
{
DEBUG_puts("Unable to get general group!");
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((option = ppd_get_option(temp, "PageSize")) == NULL)
{
DEBUG_puts("Unable to get PageSize option!");
ppdClose(ppd);
safe_free(string);
return (NULL);
}
}
if ((option = ppd_get_option(group, "PageSize")) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((choice = ppd_add_choice(option, "Custom")) == NULL)
{
DEBUG_puts("Unable to add Custom choice!");
ppdClose(ppd);
safe_free(string);
return (NULL);
@@ -788,12 +734,12 @@ ppdOpen(FILE *fp) /* I - File to read from */
strncpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE),
sizeof(choice->text) - 1);
group = NULL;
option = NULL;
}
if ((option = ppdFindOption(ppd, "PageSize")) == NULL)
{
DEBUG_puts("Unable to find PageSize option!");
ppdClose(ppd);
safe_free(string);
return (NULL);
@@ -801,7 +747,6 @@ ppdOpen(FILE *fp) /* I - File to read from */
if ((choice = ppdFindChoice(option, "Custom")) == NULL)
{
DEBUG_puts("Unable to find Custom choice!");
ppdClose(ppd);
safe_free(string);
return (NULL);
@@ -1045,6 +990,43 @@ ppdOpen(FILE *fp) /* I - File to read from */
}
else if (strcmp(keyword, "CloseGroup") == 0)
group = NULL;
else if (strcmp(keyword, "OpenSubGroup") == 0)
{
/*
* Open a new sub-group...
*/
if (group == NULL || subgroup != NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if (group->num_subgroups == 0)
subgroup = malloc(sizeof(ppd_group_t));
else
subgroup = realloc(group->subgroups,
(group->num_subgroups + 1) * sizeof(ppd_group_t));
if (subgroup == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
group->subgroups = subgroup;
subgroup += group->num_subgroups;
group->num_subgroups ++;
memset(subgroup, 0, sizeof(ppd_group_t));
ppd_decode(string);
ppd_fix(string);
strncpy(subgroup->text, string, sizeof(subgroup->text) - 1);
}
else if (strcmp(keyword, "CloseSubGroup") == 0)
subgroup = NULL;
else if (strcmp(keyword, "OrderDependency") == 0 ||
strcmp(keyword, "NonUIOrderDependency") == 0)
{
@@ -1073,25 +1055,24 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (option == NULL)
{
ppd_group_t *temp;
/*
* Only valid for Non-UI options...
*/
for (i = ppd->num_groups, temp = ppd->groups; i > 0; i --, temp ++)
if (temp->text[0] == '\0')
for (i = ppd->num_groups, group = ppd->groups; i > 0; i --, group ++)
if (group->text[0] == '\0')
break;
if (i > 0)
for (i = 0; i < temp->num_options; i ++)
if (strcmp(keyword, temp->options[i].keyword) == 0)
for (i = 0; i < group->num_options; i ++)
if (strcmp(keyword, group->options[i].keyword) == 0)
{
temp->options[i].section = section;
temp->options[i].order = order;
group->options[i].section = section;
group->options[i].order = order;
break;
}
group = NULL;
}
else
{
@@ -1109,25 +1090,24 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (option == NULL)
{
ppd_group_t *temp;
/*
* Only valid for Non-UI options...
*/
for (i = ppd->num_groups, temp = ppd->groups; i > 0; i --, temp ++)
if (temp->text[0] == '\0')
for (i = ppd->num_groups, group = ppd->groups; i > 0; i --, group ++)
if (group->text[0] == '\0')
break;
if (i > 0)
for (i = 0; i < temp->num_options; i ++)
if (strcmp(keyword, temp->options[i].keyword) == 0)
for (i = 0; i < group->num_options; i ++)
if (strcmp(keyword, group->options[i].keyword) == 0)
{
strncpy(temp->options[i].defchoice, string,
sizeof(temp->options[i].defchoice) - 1);
strncpy(group->options[i].defchoice, string,
sizeof(group->options[i].defchoice) - 1);
break;
}
group = NULL;
}
else
strncpy(option->defchoice, string, sizeof(option->defchoice) - 1);
@@ -1218,8 +1198,6 @@ ppdOpen(FILE *fp) /* I - File to read from */
(mask & (PPD_KEYWORD | PPD_OPTION | PPD_STRING)) ==
(PPD_KEYWORD | PPD_OPTION | PPD_STRING))
{
DEBUG_printf(("group = %p, subgroup = %p\n", group, subgroup));
if (strcmp(keyword, "PageSize") == 0)
{
/*
@@ -1551,7 +1529,7 @@ ppd_read(FILE *fp, /* I - File to read from */
*textptr, /* Text pointer */
*strptr, /* Pointer into string */
*lineptr, /* Current position in line buffer */
line[65536]; /* Line buffer (64k) */
line[262144]; /* Line buffer (256k) */
/*
@@ -1566,8 +1544,6 @@ ppd_read(FILE *fp, /* I - File to read from */
* Now loop until we have a valid line...
*/
*string = NULL;
do
{
/*
@@ -1601,12 +1577,10 @@ ppd_read(FILE *fp, /* I - File to read from */
ungetc(ch, fp);
}
ch = '\n';
*lineptr++ = '\n';
if (!endquote) /* Continue for multi-line text */
break;
*lineptr++ = '\n';
}
else
{
@@ -1617,72 +1591,10 @@ ppd_read(FILE *fp, /* I - File to read from */
*lineptr++ = ch;
if (ch == '\"')
{
endquote = !endquote;
if (!endquote)
{
/*
* End of quoted string; ignore trailing characters...
*/
while ((ch = getc(fp)) != EOF)
if (ch == '\n')
break;
else if (ch == '\r')
{
ch = getc(fp);
if (ch != '\n')
ungetc(ch, fp);
break;
}
break;
}
}
endquote = !endquote;
}
}
if (endquote)
{
/*
* Didn't finish this quoted string...
*/
while ((ch = getc(fp)) != EOF)
if (ch == '\"')
break;
}
if (ch != '\n')
{
/*
* Didn't finish this line...
*/
while ((ch = getc(fp)) != EOF)
if (ch == '\r' || ch == '\n')
{
/*
* Line feed or carriage return...
*/
if (ch == '\r')
{
/*
* Check for a trailing line feed...
*/
if ((ch = getc(fp)) == EOF)
break;
if (ch != 0x0a)
ungetc(ch, fp);
}
break;
}
}
if (lineptr > line && lineptr[-1] == '\n')
lineptr --;
-3
Ver Arquivo
@@ -198,7 +198,6 @@ typedef struct /**** Files ****/
ppd_profile_t *profiles; /* sRGB color profiles */
int num_filters; /* Number of filters */
char **filters; /* Filter strings... */
int flip_duplex; /* 1 = Flip page for back sides */
} ppd_file_t;
@@ -207,8 +206,6 @@ typedef struct /**** Files ****/
*/
extern void ppdClose(ppd_file_t *ppd);
extern int ppdCollect(ppd_file_t *ppd, ppd_section_t section,
ppd_choice_t ***choices);
extern int ppdConflicts(ppd_file_t *ppd);
extern int ppdEmit(ppd_file_t *ppd, FILE *fp,
ppd_section_t section);
+2 -2
Ver Arquivo
@@ -46,7 +46,7 @@ main(int argc, /* I - Number of command-line arguments */
http_t *http; /* HTTP connection */
http_status_t status; /* Status of GET command */
char buffer[1024]; /* Input buffer */
long bytes; /* Number of bytes read */
int bytes; /* Number of bytes read */
FILE *out; /* Output file */
#define HOST "dns.easysw.com"
@@ -90,7 +90,7 @@ main(int argc, /* I - Number of command-line arguments */
{
fwrite(buffer, bytes, 1, out);
if (out != stdout)
printf("Read %ld bytes, %ld total...\n", bytes, ftell(out));
printf("Read %d bytes, %d total...\n", bytes, ftell(out));
}
}
-15
Ver Arquivo
@@ -171,21 +171,6 @@ main(int argc, /* I - Number of command-line arguments */
}
}
printf(" num_profiles = %d\n", ppd->num_profiles);
for (j = 0; j < ppd->num_profiles; j ++)
printf(" profiles[%d] = %s/%s %.3f %.3f [ %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f ]\n",
j, ppd->profiles[j].resolution, ppd->profiles[j].media_type,
ppd->profiles[j].gamma, ppd->profiles[j].density,
ppd->profiles[j].matrix[0][0], ppd->profiles[j].matrix[0][1],
ppd->profiles[j].matrix[0][2], ppd->profiles[j].matrix[1][0],
ppd->profiles[j].matrix[1][1], ppd->profiles[j].matrix[1][2],
ppd->profiles[j].matrix[2][0], ppd->profiles[j].matrix[2][1],
ppd->profiles[j].matrix[2][2]);
printf(" num_fonts = %d\n", ppd->num_fonts);
for (j = 0; j < ppd->num_fonts; j ++)
printf(" fonts[%d] = %s\n", j, ppd->fonts[j]);
ppdClose(ppd);
}
+85 -315
Ver Arquivo
@@ -24,15 +24,9 @@
*
* Contents:
*
* cupsEncryption() - Get the default encryption settings...
* cupsGetPassword() - Get a password from the user...
* cupsServer() - Return the hostname of the default server...
* cupsSetEncryption() - Set the encryption preference.
* cupsSetPasswordCB() - Set the password callback for CUPS.
* cupsSetServer() - Set the default server name...
* cupsSetUser() - Set the default user name...
* cupsUser() - Return the current users name.
* cups_get_password() - Get a password from the user...
* cupsUser() - Return the current users name.
* cupsGetPassword() - Get a password from the user...
* cupsServer() - Return the hostname of the default server...
*/
/*
@@ -40,278 +34,11 @@
*/
#include "cups.h"
#include "string.h"
#include <config.h>
#include <stdlib.h>
#include <ctype.h>
/*
* Local functions...
*/
static const char *cups_get_password(const char *prompt);
/*
* Local globals...
*/
static http_encryption_t cups_encryption = (http_encryption_t)-1;
static char cups_user[65] = "",
cups_server[256] = "";
static const char *(*cups_pwdcb)(const char *) = cups_get_password;
/*
* 'cupsEncryption()' - Get the default encryption settings...
*/
http_encryption_t
cupsEncryption(void)
{
FILE *fp; /* client.conf file */
char *encryption; /* CUPS_ENCRYPTION variable */
const char *home; /* Home directory of user */
static char line[1024]; /* Line from file */
/*
* First see if we have already set the encryption stuff...
*/
if (cups_encryption == (http_encryption_t)-1)
{
/*
* Then see if the CUPS_ENCRYPTION environment variable is set...
*/
if ((encryption = getenv("CUPS_ENCRYPTION")) == NULL)
{
/*
* Next check to see if we have a $HOME/.cupsrc or client.conf file...
*/
if ((home = getenv("HOME")) != NULL)
{
snprintf(line, sizeof(line), "%s/.cupsrc", home);
fp = fopen(line, "r");
}
else
fp = NULL;
if (fp == NULL)
{
if ((home = getenv("CUPS_SERVERROOT")) != NULL)
{
snprintf(line, sizeof(line), "%s/client.conf", home);
fp = fopen(line, "r");
}
else
fp = fopen(CUPS_SERVERROOT "/client.conf", "r");
}
encryption = "IfRequested";
if (fp != NULL)
{
/*
* Read the config file and look for a ServerName line...
*/
while (fgets(line, sizeof(line), fp) != NULL)
if (strncmp(line, "Encryption ", 11) == 0)
{
/*
* Got it! Drop any trailing newline and find the name...
*/
encryption = line + strlen(line) - 1;
if (*encryption == '\n')
*encryption = '\0';
for (encryption = line + 11; isspace(*encryption); encryption ++);
break;
}
fclose(fp);
}
}
/*
* Set the encryption preference...
*/
if (strcasecmp(encryption, "never") == 0)
cups_encryption = HTTP_ENCRYPT_NEVER;
else if (strcasecmp(encryption, "always") == 0)
cups_encryption = HTTP_ENCRYPT_ALWAYS;
else if (strcasecmp(encryption, "required") == 0)
cups_encryption = HTTP_ENCRYPT_REQUIRED;
else
cups_encryption = HTTP_ENCRYPT_IF_REQUESTED;
}
return (cups_encryption);
}
/*
* 'cupsGetPassword()' - Get a password from the user...
*/
const char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return ((*cups_pwdcb)(prompt));
}
/*
* 'cupsSetEncryption()' - Set the encryption preference.
*/
void
cupsSetEncryption(http_encryption_t e) /* I - New encryption preference */
{
cups_encryption = e;
}
/*
* 'cupsServer()' - Return the hostname of the default server...
*/
const char * /* O - Server name */
cupsServer(void)
{
FILE *fp; /* client.conf file */
char *server; /* Pointer to server name */
const char *home; /* Home directory of user */
static char line[1024]; /* Line from file */
/*
* First see if we have already set the server name...
*/
if (!cups_server[0])
{
/*
* Then see if the CUPS_SERVER environment variable is set...
*/
if ((server = getenv("CUPS_SERVER")) == NULL)
{
/*
* Next check to see if we have a $HOME/.cupsrc or client.conf file...
*/
if ((home = getenv("HOME")) != NULL)
{
snprintf(line, sizeof(line), "%s/.cupsrc", home);
fp = fopen(line, "r");
}
else
fp = NULL;
if (fp == NULL)
{
if ((home = getenv("CUPS_SERVERROOT")) != NULL)
{
snprintf(line, sizeof(line), "%s/client.conf", home);
fp = fopen(line, "r");
}
else
fp = fopen(CUPS_SERVERROOT "/client.conf", "r");
}
server = "localhost";
if (fp != NULL)
{
/*
* Read the config file and look for a ServerName line...
*/
while (fgets(line, sizeof(line), fp) != NULL)
if (strncmp(line, "ServerName ", 11) == 0)
{
/*
* Got it! Drop any trailing newline and find the name...
*/
server = line + strlen(line) - 1;
if (*server == '\n')
*server = '\0';
for (server = line + 11; isspace(*server); server ++);
break;
}
fclose(fp);
}
}
/*
* Copy the server name over...
*/
strncpy(cups_server, server, sizeof(cups_server) - 1);
cups_server[sizeof(cups_server) - 1] = '\0';
}
return (cups_server);
}
/*
* 'cupsSetPasswordCB()' - Set the password callback for CUPS.
*/
void
cupsSetPasswordCB(const char *(*cb)(const char *)) /* I - Callback function */
{
if (cb == (const char *(*)(const char *))0)
cups_pwdcb = cups_get_password;
else
cups_pwdcb = cb;
}
/*
* 'cupsSetServer()' - Set the default server name...
*/
void
cupsSetServer(const char *server) /* I - Server name */
{
if (server)
{
strncpy(cups_server, server, sizeof(cups_server) - 1);
cups_server[sizeof(cups_server) - 1] = '\0';
}
else
cups_server[0] = '\0';
}
/*
* 'cupsSetUser()' - Set the default user name...
*/
void
cupsSetUser(const char *user) /* I - User name */
{
if (user)
{
strncpy(cups_user, user, sizeof(cups_user) - 1);
cups_user[sizeof(cups_user) - 1] = '\0';
}
else
cups_user[0] = '\0';
}
#if defined(WIN32) || defined(__EMX__)
/*
* WIN32 and OS/2 username and password stuff...
@@ -324,19 +51,16 @@ cupsSetUser(const char *user) /* I - User name */
const char * /* O - User name */
cupsUser(void)
{
if (!cups_user[0])
strcpy(cups_user, "WindowsUser");
return (cups_user);
return ("WindowsUser");
}
/*
* 'cups_get_password()' - Get a password from the user...
* 'cupsGetPassword()' - Get a password from the user...
*/
static const char * /* O - Password */
cups_get_password(const char *prompt) /* I - Prompt string */
const char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return (NULL);
}
@@ -357,55 +81,101 @@ cupsUser(void)
struct passwd *pwd; /* User/password entry */
if (!cups_user[0])
{
/*
* Rewind the password file...
*/
/*
* Rewind the password file...
*/
setpwent();
setpwent();
/*
* Lookup the password entry for the current user.
*/
/*
* Lookup the password entry for the current user.
*/
if ((pwd = getpwuid(getuid())) == NULL)
strcpy(cups_user, "unknown"); /* Unknown user! */
else
{
/*
* Copy the username...
*/
if ((pwd = getpwuid(getuid())) == NULL)
return ("unknown"); /* Unknown user! */
setpwent();
/*
* Rewind the password file again and return the username...
*/
strncpy(cups_user, pwd->pw_name, sizeof(cups_user) - 1);
cups_user[sizeof(cups_user) - 1] = '\0';
}
setpwent();
/*
* Rewind the password file again...
*/
setpwent();
}
return (cups_user);
return (pwd->pw_name);
}
/*
* 'cups_get_password()' - Get a password from the user...
* 'cupsGetPassword()' - Get a password from the user...
*/
static const char * /* O - Password */
cups_get_password(const char *prompt) /* I - Prompt string */
const char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return (getpass(prompt));
}
#endif /* WIN32 || __EMX__ */
/*
* 'cupsServer()' - Return the hostname of the default server...
*/
const char * /* O - Server name */
cupsServer(void)
{
FILE *fp; /* client.conf file */
char *server; /* Pointer to server name */
static char line[1024]; /* Line from file */
/*
* First see if the CUPS_SERVER environment variable is set...
*/
if ((server = getenv("CUPS_SERVER")) != NULL)
return (server);
/*
* Next check to see if we have a client.conf file...
*/
if ((fp = fopen(CUPS_SERVERROOT "/client.conf", "r")) == NULL)
return ("localhost");
/*
* Read the client.conf file and look for a ServerName line...
*/
while (fgets(line, sizeof(line), fp) != NULL)
if (strncmp(line, "ServerName ", 11) == 0)
{
/*
* Got it! Drop any trailing newline and find the name...
*/
server = line + strlen(line) - 1;
if (*server == '\n')
*server = '\0';
for (server = line + 11; isspace(*server); server ++);
if (*server)
{
fclose(fp);
return (server);
}
}
/*
* Didn't see a ServerName line, so return "localhost"...
*/
fclose(fp);
return ("localhost");
}
/*
* End of "$Id$".
*/
+203 -440
Ver Arquivo
@@ -29,10 +29,7 @@
* cupsGetDefault() - Get the default printer or class.
* cupsGetPPD() - Get the PPD file for a printer.
* cupsGetPrinters() - Get a list of printers.
* cupsLastError() - Return the last IPP error that occurred.
* cupsPrintFile() - Print a file to a printer or class.
* cupsPrintFiles() - Print one or more files to a printer or class.
* cupsTempFile() - Generate a temporary filename.
* cups_connect() - Connect to the specified host...
* cups_local_auth() - Get the local authorization certificate if
* available/applicable...
@@ -50,7 +47,6 @@
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#if defined(WIN32) || defined(__EMX__)
# include <io.h>
@@ -65,7 +61,7 @@
static http_t *cups_server = NULL; /* Current server connection */
static ipp_status_t last_error = IPP_OK; /* Last IPP error */
static char authstring[1024] = ""; /* Authorization string */
static char authstring[255] = ""; /* Authorization string */
/*
@@ -165,31 +161,19 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
const char *resource, /* I - HTTP resource for POST */
const char *filename) /* I - File to send or NULL */
{
ipp_t *response; /* IPP response data */
char length[255]; /* Content-Length field */
http_status_t status; /* Status of HTTP request */
FILE *file; /* File to send */
struct stat fileinfo; /* File information */
int bytes; /* Number of bytes read/written */
char buffer[8192]; /* Output buffer */
const char *password; /* Password string */
char realm[HTTP_MAX_VALUE], /* realm="xyz" string */
nonce[HTTP_MAX_VALUE], /* nonce="xyz" string */
plain[255], /* Plaintext username:password */
encode[255]; /* Encoded username:password */
char prompt[1024]; /* Prompt string */
ipp_t *response; /* IPP response data */
char length[255]; /* Content-Length field */
http_status_t status; /* Status of HTTP request */
FILE *file; /* File to send */
struct stat fileinfo; /* File information */
int bytes; /* Number of bytes read/written */
char buffer[8192]; /* Output buffer */
const char *password; /* Password string */
char plain[255], /* Plaintext username:password */
encode[255]; /* Encoded username:password */
if (http == NULL || request == NULL || resource == NULL)
{
if (request != NULL)
ippDelete(request);
last_error = IPP_INTERNAL_ERROR;
return (NULL);
}
DEBUG_printf(("cupsDoFileRequest(%p, %08s, \'%s\', \'%s\')\n",
DEBUG_printf(("cupsDoFileRequest(%08x, %08s, \'%s\', \'%s\')\n",
http, request, resource, filename ? filename : "(null)"));
/*
@@ -220,15 +204,12 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
return (NULL);
}
}
else
file = NULL;
/*
* Loop until we can send the request without authorization problems.
*/
response = NULL;
status = HTTP_ERROR;
while (response == NULL)
{
@@ -309,10 +290,10 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
* Nope - get a password from the user...
*/
snprintf(prompt, sizeof(prompt), "Password for %s on %s? ", cupsUser(),
http->hostname);
printf("Authentication required for %s on %s...\n", cupsUser(),
http->hostname);
if ((password = cupsGetPassword(prompt)) != NULL)
if ((password = cupsGetPassword("UNIX Password: ")) != NULL)
{
/*
* Got a password; send it to the server...
@@ -320,32 +301,10 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
if (!password[0])
break;
snprintf(plain, sizeof(plain), "%s:%s", cupsUser(), password);
httpEncode64(encode, plain);
snprintf(authstring, sizeof(authstring), "Basic %s", encode);
if (strncmp(http->fields[HTTP_FIELD_WWW_AUTHENTICATE], "Basic", 5) == 0)
{
/*
* Basic authentication...
*/
snprintf(plain, sizeof(plain), "%s:%s", cupsUser(), password);
httpEncode64(encode, plain);
snprintf(authstring, sizeof(authstring), "Basic %s", encode);
}
else
{
/*
* Digest authentication...
*/
httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "realm", realm);
httpGetSubField(http, HTTP_FIELD_WWW_AUTHENTICATE, "nonce", nonce);
httpMD5(cupsUser(), realm, password, encode);
httpMD5Final(nonce, "POST", resource, encode);
snprintf(authstring, sizeof(authstring),
"Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", "
"response=\"%s\"", cupsUser(), realm, nonce, encode);
}
continue;
}
else
@@ -445,12 +404,6 @@ cupsGetClasses(char ***classes) /* O - Classes */
char **temp; /* Temporary pointer */
if (classes == NULL)
{
last_error = IPP_INTERNAL_ERROR;
return (0);
}
/*
* Try to connect to the server...
*/
@@ -467,7 +420,6 @@ cupsGetClasses(char ***classes) /* O - Classes */
*
* attributes-charset
* attributes-natural-language
* requested-attributes
*/
request = ippNew();
@@ -483,9 +435,6 @@ cupsGetClasses(char ***classes) /* O - Classes */
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", NULL, "printer-name");
/*
* Do the request and get back a response...
*/
@@ -572,12 +521,7 @@ cupsGetDefault(void)
* Next check to see if we have a client.conf file...
*/
if ((var = getenv("CUPS_SERVERROOT")) == NULL)
var = CUPS_SERVERROOT;
snprintf(line, sizeof(line), "%s/client.conf", var);
if ((fp = fopen(line, "r")) != NULL)
if ((fp = fopen(CUPS_SERVERROOT "/client.conf", "r")) != NULL)
{
/*
* Read the client.conf file and look for a DefaultPrinter line...
@@ -670,45 +614,23 @@ cupsGetDefault(void)
* 'cupsGetPPD()' - Get the PPD file for a printer.
*/
const char * /* O - Filename for PPD file */
cupsGetPPD(const char *name) /* I - Printer name */
const char * /* O - Filename for PPD file */
cupsGetPPD(const char *name) /* I - Printer name */
{
int i; /* Looping var */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Local language */
FILE *fp; /* PPD file */
int bytes; /* Number of bytes read */
char buffer[8192]; /* Buffer for file */
char printer[HTTP_MAX_URI], /* Printer name */
method[HTTP_MAX_URI], /* Method/scheme name */
username[HTTP_MAX_URI], /* Username:password */
hostname[HTTP_MAX_URI], /* Hostname */
resource[HTTP_MAX_URI]; /* Resource name */
int port; /* Port number */
char *tempdir; /* Temporary file directory */
const char *password; /* Password string */
char realm[HTTP_MAX_VALUE], /* realm="xyz" string */
nonce[HTTP_MAX_VALUE], /* nonce="xyz" string */
plain[255], /* Plaintext username:password */
char plain[255], /* Plaintext username:password */
encode[255]; /* Encoded username:password */
http_status_t status; /* HTTP status from server */
char prompt[1024]; /* Prompt string */
static char filename[HTTP_MAX_URI]; /* Local filename */
static const char *requested_attrs[] =/* Requested attributes */
{
"printer-uri-supported",
"printer-type",
"member-uris"
};
if (name == NULL)
{
last_error = IPP_INTERNAL_ERROR;
return (NULL);
}
/*
* See if we can connect to the server...
*/
@@ -720,119 +642,19 @@ cupsGetPPD(const char *name) /* I - Printer name */
}
/*
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requested-attributes
* Then check for the cache file...
*/
request = ippNew();
#if defined(WIN32) || defined(__EMX__)
tempdir = "C:/WINDOWS/TEMP";
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
snprintf(filename, sizeof(filename), "%s/%s.ppd", tempdir, printer);
#else
if ((tempdir = getenv("TMPDIR")) == NULL)
tempdir = "/tmp";
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
snprintf(buffer, sizeof(buffer), "ipp://localhost/printers/%s", name);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, buffer);
ippAddStrings(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requested-attributes",
sizeof(requested_attrs) / sizeof(requested_attrs[0]),
NULL, requested_attrs);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(cups_server, request, "/")) != NULL)
{
last_error = response->request.status.status_code;
printer[0] = '\0';
hostname[0] = '\0';
if ((attr = ippFindAttribute(response, "member-uris", IPP_TAG_URI)) != NULL)
{
/*
* Get the first actual server and printer name in the class...
*/
for (i = 0; i < attr->num_values; i ++)
{
httpSeparate(attr->values[0].string.text, method, username, hostname,
&port, resource);
if (strncmp(resource, "/printers/", 10) == 0)
{
/*
* Found a printer!
*/
strncpy(printer, resource + 10, sizeof(printer) - 1);
printer[sizeof(printer) - 1] = '\0';
break;
}
}
}
else if ((attr = ippFindAttribute(response, "printer-uri-supported",
IPP_TAG_URI)) != NULL)
{
/*
* Get the actual server and printer names...
*/
httpSeparate(attr->values[0].string.text, method, username, hostname,
&port, resource);
strncpy(printer, strrchr(resource, '/') + 1, sizeof(printer) - 1);
printer[sizeof(printer) - 1] = '\0';
}
ippDelete(response);
/*
* Remap local hostname to localhost...
*/
gethostname(buffer, sizeof(buffer));
if (strcasecmp(buffer, hostname) == 0)
strcpy(hostname, "localhost");
}
cupsLangFree(language);
if (!printer[0])
return (NULL);
/*
* Reconnect to the correct server as needed...
*/
if (strcasecmp(cups_server->hostname, hostname) != 0)
{
httpClose(cups_server);
if ((cups_server = httpConnect(hostname, ippPort())) == NULL)
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (NULL);
}
}
/*
* Get a temp file...
*/
cupsTempFile(filename, sizeof(filename));
snprintf(filename, sizeof(filename), "%s/%d.%s.ppd", tempdir, getuid(), printer);
#endif /* WIN32 || __EMX__ */
/*
* And send a request to the HTTP server...
@@ -875,10 +697,10 @@ cupsGetPPD(const char *name) /* I - Printer name */
* Nope, get a password from the user...
*/
snprintf(prompt, sizeof(prompt), "Password for %s on %s? ", cupsUser(),
cups_server->hostname);
printf("Authentication required for %s on %s...\n", cupsUser(),
cups_server->hostname);
if ((password = cupsGetPassword(prompt)) != NULL)
if ((password = cupsGetPassword("UNIX Password: ")) != NULL)
{
/*
* Got a password; send it to the server...
@@ -886,32 +708,10 @@ cupsGetPPD(const char *name) /* I - Printer name */
if (!password[0])
break;
snprintf(plain, sizeof(plain), "%s:%s", cupsUser(), password);
httpEncode64(encode, plain);
snprintf(authstring, sizeof(authstring), "Basic %s", encode);
if (strncmp(cups_server->fields[HTTP_FIELD_WWW_AUTHENTICATE], "Basic", 5) == 0)
{
/*
* Basic authentication...
*/
snprintf(plain, sizeof(plain), "%s:%s", cupsUser(), password);
httpEncode64(encode, plain);
snprintf(authstring, sizeof(authstring), "Basic %s", encode);
}
else
{
/*
* Digest authentication...
*/
httpGetSubField(cups_server, HTTP_FIELD_WWW_AUTHENTICATE, "realm", realm);
httpGetSubField(cups_server, HTTP_FIELD_WWW_AUTHENTICATE, "nonce", nonce);
httpMD5(cupsUser(), realm, password, encode);
httpMD5Final(nonce, "GET", resource, encode);
snprintf(authstring, sizeof(authstring),
"Digest username=\"%s\", realm=\"%s\", nonce=\"%s\", "
"response=\"%s\"", cupsUser(), realm, nonce, encode);
}
continue;
}
else
@@ -924,13 +724,13 @@ cupsGetPPD(const char *name) /* I - Printer name */
* OK, we need to copy the file; open the file and copy it...
*/
unlink(filename);
if ((fp = fopen(filename, "w")) == NULL)
{
/*
* Can't open file; close the server connection and return NULL...
*/
httpFlush(cups_server);
httpClose(cups_server);
cups_server = NULL;
return (NULL);
@@ -960,12 +760,6 @@ cupsGetPrinters(char ***printers) /* O - Printers */
char **temp; /* Temporary pointer */
if (printers == NULL)
{
last_error = IPP_INTERNAL_ERROR;
return (0);
}
/*
* Try to connect to the server...
*/
@@ -982,7 +776,6 @@ cupsGetPrinters(char ***printers) /* O - Printers */
*
* attributes-charset
* attributes-natural-language
* requested-attributes
*/
request = ippNew();
@@ -998,9 +791,6 @@ cupsGetPrinters(char ***printers) /* O - Printers */
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD,
"requested-attributes", NULL, "printer-name");
/*
* Do the request and get back a response...
*/
@@ -1074,28 +864,12 @@ cupsPrintFile(const char *name, /* I - Printer or class name */
const char *title, /* I - Title of job */
int num_options,/* I - Number of options */
cups_option_t *options) /* I - Options */
{
DEBUG_printf(("cupsPrintFile(\'%s\', \'%s\', %d, %p)\n",
printer, filename, num_options, options));
return (cupsPrintFiles(name, 1, &filename, title, num_options, options));
}
/*
* 'cupsPrintFiles()' - Print one or more files to a printer or class.
*/
int /* O - Job ID */
cupsPrintFiles(const char *name, /* I - Printer or class name */
int num_files, /* I - Number of files */
const char **files, /* I - File(s) to print */
const char *title, /* I - Title of job */
int num_options,/* I - Number of options */
cups_option_t *options) /* I - Options */
{
int i; /* Looping var */
const char *val; /* Pointer to option value */
int n, n2; /* Attribute values */
char *option, /* Name of option */
*val, /* Pointer to option value */
*s; /* Pointer into option value */
ipp_t *request; /* IPP request */
ipp_t *response; /* IPP response */
ipp_attribute_t *attr; /* IPP job-id attribute */
@@ -1106,40 +880,40 @@ cupsPrintFiles(const char *name, /* I - Printer or class name */
int jobid; /* New job ID */
DEBUG_printf(("cupsPrintFiles(\'%s\', %d, %p, %d, %p)\n",
printer, num_files, files, num_options, options));
DEBUG_printf(("cupsPrintFile(\'%s\', \'%s\', %d, %08x)\n",
printer, filename, num_options, options));
if (name == NULL || num_files < 1 || files == NULL)
if (name == NULL || filename == NULL)
return (0);
/*
* Setup a connection and request data...
*/
if ((request = ippNew()) == NULL)
return (0);
if (!cups_connect(name, printer, hostname))
{
DEBUG_printf(("cupsPrintFile: Unable to open connection - %s.\n",
strerror(errno)));
last_error = IPP_SERVICE_UNAVAILABLE;
ippDelete(request);
return (0);
}
language = cupsLangDefault();
/*
* Build a standard CUPS URI for the printer and fill the standard IPP
* attributes...
*/
if ((request = ippNew()) == NULL)
return (0);
request->request.op.operation_id = num_files == 1 ? IPP_PRINT_JOB :
IPP_CREATE_JOB;
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s:%d/printers/%s", hostname, ippPort(), printer);
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
@@ -1150,6 +924,17 @@ cupsPrintFiles(const char *name, /* I - Printer or class name */
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
/*
* Handle raw print files...
*/
if (cupsGetOption("raw", num_options, options))
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
@@ -1157,23 +942,136 @@ cupsPrintFiles(const char *name, /* I - Printer or class name */
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL, title);
/*
* Then add all options...
* Then add all options on the command-line...
*/
cupsEncodeOptions(request, num_options, options);
for (i = 0; i < num_options; i ++)
{
/*
* Skip the "raw" option - handled above...
*/
if (strcasecmp(options[i].name, "raw") == 0)
continue;
/*
* See what the option value is; for compatibility with older interface
* scripts, we have to support single-argument options as well as
* option=value, option=low-high, and option=MxN.
*/
option = options[i].name;
val = options[i].value;
if (*val == '\0')
val = NULL;
if (val != NULL)
{
if (strcasecmp(val, "true") == 0 ||
strcasecmp(val, "on") == 0 ||
strcasecmp(val, "yes") == 0)
{
/*
* Boolean value - true...
*/
n = 1;
val = "";
}
else if (strcasecmp(val, "false") == 0 ||
strcasecmp(val, "off") == 0 ||
strcasecmp(val, "no") == 0)
{
/*
* Boolean value - false...
*/
n = 0;
val = "";
}
n = strtol(val, &s, 0);
}
else
{
if (strncasecmp(option, "no", 2) == 0)
{
option += 2;
n = 0;
}
else
n = 1;
s = "";
}
if (*s != '\0' && *s != '-' && (*s != 'x' || s == val))
{
/*
* String value(s)...
*/
DEBUG_printf(("cupsPrintFile: Adding string option \'%s\' with value \'%s\'...\n",
option, val));
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
}
else if (val != NULL)
{
/*
* Numeric value, range, or resolution...
*/
if (*s == '-')
{
n2 = strtol(s + 1, NULL, 0);
ippAddRange(request, IPP_TAG_JOB, option, n, n2);
DEBUG_printf(("cupsPrintFile: Adding range option \'%s\' with value %d-%d...\n",
option, n, n2));
}
else if (*s == 'x')
{
n2 = strtol(s + 1, &s, 0);
if (strcasecmp(s, "dpc") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_CM, n, n2);
else if (strcasecmp(s, "dpi") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_INCH, n, n2);
else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
DEBUG_printf(("cupsPrintFile: Adding resolution option \'%s\' with value %s...\n",
option, val));
}
else
{
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, option, n);
DEBUG_printf(("cupsPrintFile: Adding integer option \'%s\' with value %d...\n",
option, n));
}
}
else
{
/*
* Boolean value...
*/
DEBUG_printf(("cupsPrintFile: Adding boolean option \'%s\' with value %d...\n",
option, n));
ippAddBoolean(request, IPP_TAG_JOB, option, (char)n);
}
}
/*
* Do the request...
* Try printing the file...
*/
snprintf(uri, sizeof(uri), "/printers/%s", printer);
if (num_files == 1)
response = cupsDoFileRequest(cups_server, request, uri, *files);
else
response = cupsDoRequest(cups_server, request, uri);
if (response == NULL)
if ((response = cupsDoFileRequest(cups_server, request, uri, filename)) == NULL)
jobid = 0;
else if (response->request.status.status_code > IPP_OK_CONFLICT)
{
@@ -1192,72 +1090,6 @@ cupsPrintFiles(const char *name, /* I - Printer or class name */
if (response != NULL)
ippDelete(response);
/*
* Handle multiple file jobs if the create-job operation worked...
*/
if (jobid > 0 && num_files > 1)
for (i = 0; i < num_files; i ++)
{
/*
* Build a standard CUPS URI for the job and fill the standard IPP
* attributes...
*/
if ((request = ippNew()) == NULL)
return (0);
request->request.op.operation_id = IPP_SEND_DOCUMENT;
request->request.op.request_id = 1;
snprintf(uri, sizeof(uri), "ipp://%s:%d/jobs/%d", hostname, ippPort(),
jobid);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language != NULL ? language->language : "C");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
NULL, uri);
/*
* Handle raw print files...
*/
if (cupsGetOption("raw", num_options, options))
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else if ((val = cupsGetOption("document-format", num_options, options)) != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, val);
else
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
/*
* Is this the last document?
*/
if (i == (num_files - 1))
ippAddBoolean(request, IPP_TAG_OPERATION, "last-document", 1);
/*
* Send the file...
*/
snprintf(uri, sizeof(uri), "/printers/%s", printer);
if ((response = cupsDoFileRequest(cups_server, request, uri,
files[i])) != NULL)
ippDelete(response);
}
return (jobid);
}
@@ -1270,14 +1102,7 @@ char * /* O - Filename */
cupsTempFile(char *filename, /* I - Pointer to buffer */
int len) /* I - Size of buffer */
{
int fd; /* File descriptor for temp file */
#ifdef WIN32
char tmpdir[1024]; /* Windows temporary directory */
DWORD curtime; /* Current time */
#else
char *tmpdir; /* TMPDIR environment var */
struct timeval curtime; /* Current time */
#endif /* WIN32 */
static char buf[1024] = ""; /* Buffer if you pass in NULL and 0 */
@@ -1295,79 +1120,27 @@ cupsTempFile(char *filename, /* I - Pointer to buffer */
* See if TMPDIR is defined...
*/
#ifdef WIN32
GetTempPath(sizeof(tmpdir), tmpdir);
#else
if ((tmpdir = getenv("TMPDIR")) == NULL)
tmpdir = "/var/tmp";
if ((int)(strlen(tmpdir) + 8) > len)
{
/*
* Put root temp files in restricted temp directory...
* The specified directory exceeds the size of the buffer; default it...
*/
if (getuid() == 0)
tmpdir = CUPS_REQUESTS "/tmp";
else
tmpdir = "/var/tmp";
strcpy(buf, "/var/tmp/XXXXXX");
return (mktemp(buf));
}
#endif /* WIN32 */
/*
* Make the temporary name using the specified directory...
*/
do
else
{
#ifdef WIN32
/*
* Get the current time of day...
* Make the temporary name using the specified directory...
*/
curtime = GetTickCount();
/*
* Format a string using the hex time values...
*/
snprintf(filename, len - 1, "%s/%08lx", tmpdir, curtime);
#else
/*
* Get the current time of day...
*/
gettimeofday(&curtime, NULL);
/*
* Format a string using the hex time values...
*/
snprintf(filename, len - 1, "%s/%08lx%05lx", tmpdir,
curtime.tv_sec, curtime.tv_usec);
#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 O_NOFOLLOW
fd = open(filename, O_WRONLY | O_CREAT | O_EXCL | O_NOFOLLOW, 0600);
#else
fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0600);
#endif /* O_NOFOLLOW */
sprintf(filename, "%s/XXXXXX", tmpdir);
return (mktemp(filename));
}
while (fd < 0);
/*
* Close the temp file - it'll be reopened later as needed...
*/
close(fd);
/*
* Return the temp filename...
*/
return (filename);
}
@@ -1428,10 +1201,7 @@ cups_connect(const char *name, /* I - Destination (printer[@host]) */
return (NULL);
}
else
{
httpEncryption(cups_server, cupsEncryption());
return (printer);
}
}
@@ -1450,11 +1220,10 @@ cups_local_auth(http_t *http) /* I - Connection */
return (0);
#else
int pid; /* Current process ID */
FILE *fp; /* Certificate file */
char filename[1024], /* Certificate filename */
certificate[33];/* Certificate string */
const char *root; /* Server root directory */
int pid; /* Current process ID */
FILE *fp; /* Certificate file */
char filename[1024], /* Certificate filename */
certificate[33]; /* Certificate string */
/*
@@ -1470,16 +1239,10 @@ cups_local_auth(http_t *http) /* I - Connection */
* try the root certificate...
*/
if ((root = getenv("CUPS_SERVERROOT")) == NULL)
root = CUPS_SERVERROOT;
pid = getpid();
snprintf(filename, sizeof(filename), "%s/certs/%d", root, pid);
sprintf(filename, CUPS_SERVERROOT "/certs/%d", pid);
if ((fp = fopen(filename, "r")) == NULL && pid > 0)
{
snprintf(filename, sizeof(filename), "%s/certs/0", root);
fp = fopen(filename, "r");
}
fp = fopen(CUPS_SERVERROOT "/certs/0", "r");
if (fp == NULL)
return (0);
@@ -1495,7 +1258,7 @@ cups_local_auth(http_t *http) /* I - Connection */
* Set the authorization string and return...
*/
snprintf(authstring, sizeof(authstring), "Local %s", certificate);
sprintf(authstring, "Local %s", certificate);
return (1);
#endif /* WIN32 || __EMX__ */
+216
Ver Arquivo
@@ -0,0 +1,216 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x00a1
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x00a4
0xa5 0x00a5
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xaa 0x00aa
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x00af
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x00b9
0xba 0x00ba
0xbb 0x00bb
0xbc 0x00bc
0xbd 0x00bd
0xbe 0x00be
0xbf 0x00bf
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x00d0
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x00dd
0xde 0x00de
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x00f0
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x00fe
0xff 0x00ff
+217
Ver Arquivo
@@ -0,0 +1,217 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x1e02
0xa2 0x1e03
0xa3 0x00a3
0xa4 0x010a
0xa5 0x010b
0xa6 0x1e0a
0xa7 0x00a7
0xa8 0x1e80
0xa9 0x00a9
0xaa 0x1e82
0xab 0x1e0b
0xac 0x1ef2
0xad 0x00ad
0xae 0x00ae
0xaf 0x0178
0xb0 0x1e1e
0xb1 0x1e1f
0xb2 0x0120
0xb3 0x0121
0xb4 0x1e40
0xb5 0x1e41
0xb6 0x00b6
0xb7 0x1e56
0xb8 0x1e81
0xb9 0x1e57
0xba 0x1e83
0xbb 0x1e60
0xbc 0x1ef3
0xbd 0x1e84
0xbe 0x1e85
0xbf 0x1e61
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x0174
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x1e6a
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x00dd
0xde 0x0176
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x0175
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x1e6b
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x0177
0xff 0x00ff
+217
Ver Arquivo
@@ -0,0 +1,217 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x00a1
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x20ac
0xa5 0x00a5
0xa6 0x0160
0xa7 0x00a7
0xa8 0x0161
0xa9 0x00a9
0xaa 0x00aa
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x00af
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x017d
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x017e
0xb9 0x00b9
0xba 0x00ba
0xbb 0x00bb
0xbc 0x0152
0xbd 0x0153
0xbe 0x0178
0xbf 0x00bf
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x00d0
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x00dd
0xde 0x00de
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x00f0
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x00fe
0xff 0x00ff
+218
Ver Arquivo
@@ -0,0 +1,218 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x015a
0x8d 0x0164
0x8e 0x017d
0x8f 0x0179
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x8c 0x015b
0x8d 0x0165
0x8e 0x017e
0x8f 0x017a
0xa0 0x00a0
0xa1 0x0104
0xa2 0x02d8
0xa3 0x0141
0xa4 0x00a4
0xa5 0x013d
0xa6 0x015a
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x0160
0xaa 0x015e
0xab 0x0164
0xac 0x0179
0xad 0x00ad
0xae 0x017d
0xaf 0x017b
0xb0 0x00b0
0xb1 0x0105
0xb2 0x02db
0xb3 0x0142
0xb4 0x00b4
0xb5 0x013e
0xb6 0x015b
0xb7 0x02c7
0xb8 0x00b8
0xb9 0x0161
0xba 0x015f
0xbb 0x0165
0xbc 0x017a
0xbd 0x02dd
0xbe 0x017e
0xbf 0x017c
0xc0 0x0154
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x0102
0xc4 0x00c4
0xc5 0x0139
0xc6 0x0106
0xc7 0x00c7
0xc8 0x010c
0xc9 0x00c9
0xca 0x0118
0xcb 0x00cb
0xcc 0x011a
0xcd 0x00cd
0xce 0x00ce
0xcf 0x010e
0xd0 0x0110
0xd1 0x0143
0xd2 0x0147
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x0150
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x0158
0xd9 0x016e
0xda 0x00da
0xdb 0x0170
0xdc 0x00dc
0xdd 0x00dd
0xde 0x0162
0xdf 0x00df
0xe0 0x0155
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x0103
0xe4 0x00e4
0xe5 0x013a
0xe6 0x0107
0xe7 0x00e7
0xe8 0x010d
0xe9 0x00e9
0xea 0x0119
0xeb 0x00eb
0xec 0x011b
0xed 0x00ed
0xee 0x00ee
0xef 0x010f
0xf0 0x0111
0xf1 0x0144
0xf2 0x0148
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x0151
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x0159
0xf9 0x016f
0xfa 0x00fa
0xfb 0x0171
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x0163
0xff 0x02d9
+209
Ver Arquivo
@@ -0,0 +1,209 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x0126
0xa2 0x02d8
0xa3 0x00a3
0xa4 0x00a4
0xa6 0x0124
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x0130
0xaa 0x015e
0xab 0x011e
0xac 0x0134
0xad 0x00ad
0xaf 0x017b
0xb0 0x00b0
0xb1 0x0127
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x0125
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x0131
0xba 0x015f
0xbb 0x011f
0xbc 0x0135
0xbd 0x00bd
0xbf 0x017c
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc4 0x00c4
0xc5 0x010a
0xc6 0x0108
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x0120
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x011c
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x016c
0xde 0x015c
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe4 0x00e4
0xe5 0x010b
0xe6 0x0109
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x0121
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x011d
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x016d
0xfe 0x015d
0xff 0x02d9
+216
Ver Arquivo
@@ -0,0 +1,216 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x0104
0xa2 0x0138
0xa3 0x0156
0xa4 0x00a4
0xa5 0x0128
0xa6 0x013b
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x0160
0xaa 0x0112
0xab 0x0122
0xac 0x0166
0xad 0x00ad
0xae 0x017d
0xaf 0x00af
0xb0 0x00b0
0xb1 0x0105
0xb2 0x02db
0xb3 0x0157
0xb4 0x00b4
0xb5 0x0129
0xb6 0x013c
0xb7 0x02c7
0xb8 0x00b8
0xb9 0x0161
0xba 0x0113
0xbb 0x0123
0xbc 0x0167
0xbd 0x014a
0xbe 0x017e
0xbf 0x014b
0xc0 0x0100
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x012e
0xc8 0x010c
0xc9 0x00c9
0xca 0x0118
0xcb 0x00cb
0xcc 0x0116
0xcd 0x00cd
0xce 0x00ce
0xcf 0x012a
0xd0 0x0110
0xd1 0x0145
0xd2 0x014c
0xd3 0x0136
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x0172
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x0168
0xde 0x016a
0xdf 0x00df
0xe0 0x0101
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x012f
0xe8 0x010d
0xe9 0x00e9
0xea 0x0119
0xeb 0x00eb
0xec 0x0117
0xed 0x00ed
0xee 0x00ee
0xef 0x012b
0xf0 0x0111
0xf1 0x0146
0xf2 0x014d
0xf3 0x0137
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x0173
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x0169
0xfe 0x016b
0xff 0x02d9
+216
Ver Arquivo
@@ -0,0 +1,216 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x0401
0xa2 0x0402
0xa3 0x0403
0xa4 0x0404
0xa5 0x0405
0xa6 0x0406
0xa7 0x0407
0xa8 0x0408
0xa9 0x0409
0xaa 0x040a
0xab 0x040b
0xac 0x040c
0xad 0x00ad
0xae 0x040e
0xaf 0x040f
0xb0 0x0410
0xb1 0x0411
0xb2 0x0412
0xb3 0x0413
0xb4 0x0414
0xb5 0x0415
0xb6 0x0416
0xb7 0x0417
0xb8 0x0418
0xb9 0x0419
0xba 0x041a
0xbb 0x041b
0xbc 0x041c
0xbd 0x041d
0xbe 0x041e
0xbf 0x041f
0xc0 0x0420
0xc1 0x0421
0xc2 0x0422
0xc3 0x0423
0xc4 0x0424
0xc5 0x0425
0xc6 0x0426
0xc7 0x0427
0xc8 0x0428
0xc9 0x0429
0xca 0x042a
0xcb 0x042b
0xcc 0x042c
0xcd 0x042d
0xce 0x042e
0xcf 0x042f
0xd0 0x0430
0xd1 0x0431
0xd2 0x0432
0xd3 0x0433
0xd4 0x0434
0xd5 0x0435
0xd6 0x0436
0xd7 0x0437
0xd8 0x0438
0xd9 0x0439
0xda 0x043a
0xdb 0x043b
0xdc 0x043c
0xdd 0x043d
0xde 0x043e
0xdf 0x043f
0xe0 0x0440
0xe1 0x0441
0xe2 0x0442
0xe3 0x0443
0xe4 0x0444
0xe5 0x0445
0xe6 0x0446
0xe7 0x0447
0xe8 0x0448
0xe9 0x0449
0xea 0x044a
0xeb 0x044b
0xec 0x044c
0xed 0x044d
0xee 0x044e
0xef 0x044f
0xf0 0x2116
0xf1 0x0451
0xf2 0x0452
0xf3 0x0453
0xf4 0x0454
0xf5 0x0455
0xf6 0x0456
0xf7 0x0457
0xf8 0x0458
0xf9 0x0459
0xfa 0x045a
0xfb 0x045b
0xfc 0x045c
0xfd 0x00a7
0xfe 0x045e
0xff 0x045f
+171
Ver Arquivo
@@ -0,0 +1,171 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0660
0x31 0x0661
0x32 0x0662
0x33 0x0663
0x34 0x0664
0x35 0x0665
0x36 0x0666
0x37 0x0667
0x38 0x0668
0x39 0x0669
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa4 0x00a4
0xac 0x060c
0xad 0x00ad
0xbb 0x061b
0xbf 0x061f
0xc1 0x0621
0xc2 0x0622
0xc3 0x0623
0xc4 0x0624
0xc5 0x0625
0xc6 0x0626
0xc7 0x0627
0xc8 0x0628
0xc9 0x0629
0xca 0x062a
0xcb 0x062b
0xcc 0x062c
0xcd 0x062d
0xce 0x062e
0xcf 0x062f
0xd0 0x0630
0xd1 0x0631
0xd2 0x0632
0xd3 0x0633
0xd4 0x0634
0xd5 0x0635
0xd6 0x0636
0xd7 0x0637
0xd8 0x0638
0xd9 0x0639
0xda 0x063a
0xe0 0x0640
0xe1 0x0641
0xe2 0x0642
0xe3 0x0643
0xe4 0x0644
0xe5 0x0645
0xe6 0x0646
0xe7 0x0647
0xe8 0x0648
0xe9 0x0649
0xea 0x064a
0xeb 0x064b
0xec 0x064c
0xed 0x064d
0xee 0x064e
0xef 0x064f
0xf0 0x0650
0xf1 0x0651
0xf2 0x0652
+210
Ver Arquivo
@@ -0,0 +1,210 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x02bd
0xa2 0x02bc
0xa3 0x00a3
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xaf 0x2015
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x0384
0xb5 0x0385
0xb6 0x0386
0xb7 0x00b7
0xb8 0x0388
0xb9 0x0389
0xba 0x038a
0xbb 0x00bb
0xbc 0x038c
0xbd 0x00bd
0xbe 0x038e
0xbf 0x038f
0xc0 0x0390
0xc1 0x0391
0xc2 0x0392
0xc3 0x0393
0xc4 0x0394
0xc5 0x0395
0xc6 0x0396
0xc7 0x0397
0xc8 0x0398
0xc9 0x0399
0xca 0x039a
0xcb 0x039b
0xcc 0x039c
0xcd 0x039d
0xce 0x039e
0xcf 0x039f
0xd0 0x03a0
0xd1 0x03a1
0xd3 0x03a3
0xd4 0x03a4
0xd5 0x03a5
0xd6 0x03a6
0xd7 0x03a7
0xd8 0x03a8
0xd9 0x03a9
0xda 0x03aa
0xdb 0x03ab
0xdc 0x03ac
0xdd 0x03ad
0xde 0x03ae
0xdf 0x03af
0xe0 0x03b0
0xe1 0x03b1
0xe2 0x03b2
0xe3 0x03b3
0xe4 0x03b4
0xe5 0x03b5
0xe6 0x03b6
0xe7 0x03b7
0xe8 0x03b8
0xe9 0x03b9
0xea 0x03ba
0xeb 0x03bb
0xec 0x03bc
0xed 0x03bd
0xee 0x03be
0xef 0x03bf
0xf0 0x03c0
0xf1 0x03c1
0xf2 0x03c2
0xf3 0x03c3
0xf4 0x03c4
0xf5 0x03c5
0xf6 0x03c6
0xf7 0x03c7
0xf8 0x03c8
0xf9 0x03c9
0xfa 0x03ca
0xfb 0x03cb
0xfc 0x03cc
0xfd 0x03cd
0xfe 0x03ce
+178
Ver Arquivo
@@ -0,0 +1,178 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x00a4
0xa5 0x00a5
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xaa 0x00d7
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x203e
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x00b9
0xba 0x00f7
0xbb 0x00bb
0xbc 0x00bc
0xbd 0x00bd
0xbe 0x00be
0xdf 0x2017
0xe0 0x05d0
0xe1 0x05d1
0xe2 0x05d2
0xe3 0x05d3
0xe4 0x05d4
0xe5 0x05d5
0xe6 0x05d6
0xe7 0x05d7
0xe8 0x05d8
0xe9 0x05d9
0xea 0x05da
0xeb 0x05db
0xec 0x05dc
0xed 0x05dd
0xee 0x05de
0xef 0x05df
0xf0 0x05e0
0xf1 0x05e1
0xf2 0x05e2
0xf3 0x05e3
0xf4 0x05e4
0xf5 0x05e5
0xf6 0x05e6
0xf7 0x05e7
0xf8 0x05e8
0xf9 0x05e9
0xfa 0x05ea
+218
Ver Arquivo
@@ -0,0 +1,218 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x00a1
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x00a4
0xa5 0x00a5
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xaa 0x00aa
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x00af
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x00b9
0xba 0x00ba
0xbb 0x00bb
0xbc 0x00bc
0xbd 0x00bd
0xbe 0x00be
0xbf 0x00bf
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x011e
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x0130
0xde 0x015e
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x011f
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x0131
0xfe 0x015f
0xff 0x00ff
+14 -35
Ver Arquivo
@@ -28,23 +28,16 @@ include ../Makedefs
# Data files...
#
BANNERS = classified \
confidential \
secret \
standard \
topsecret \
unclassified
CHARSETS = windows-874 \
windows-1250 \
windows-1251 \
windows-1252 \
windows-1253 \
windows-1254 \
windows-1255 \
windows-1256 \
windows-1257 \
windows-1258 \
CHARSETS = cp874 \
cp1250 \
cp1251 \
cp1252 \
cp1253 \
cp1254 \
cp1255 \
cp1256 \
cp1257 \
cp1258 \
iso-8859-1 \
iso-8859-2 \
iso-8859-3 \
@@ -81,25 +74,11 @@ clean:
#
install:
-$(MKDIR) $(DATADIR)/banners
$(CHMOD) ugo+rx $(DATADIR)
$(CHMOD) ugo+rx $(DATADIR)/banners
$(INSTALL_DATA) $(BANNERS) $(DATADIR)/banners
-$(MKDIR) $(DATADIR)/charsets
$(CHMOD) ugo+rx $(DATADIR)/charsets
$(INSTALL_DATA) $(CHARSETS) $(DATADIR)/charsets
-$(MKDIR) $(DATADIR)
-$(MKDIR) $(DATADIR)/data
$(CHMOD) ugo+rx $(DATADIR)/data
$(INSTALL_DATA) $(DATAFILES) $(DATADIR)/data
-if test "$(PAMDIR)" != ""; then \
$(MKDIR) $(PAMDIR); \
$(CHMOD) ugo+rx $(PAMDIR); \
if test -f /lib/security/pam_unix.so; then \
$(INSTALL_DATA) cups.suse $(PAMDIR)/cups; \
else \
$(INSTALL_DATA) cups.pam $(PAMDIR)/cups; \
fi \
fi
$(CP) $(DATAFILES) $(DATADIR)/data
-$(MKDIR) $(DATADIR)/charsets
$(CP) $(CHARSETS) $(DATADIR)/charsets
#
-267
Ver Arquivo
@@ -1,267 +0,0 @@
%!PS-Adobe-3.0
%%BoundingBox: 0 0 612 792
%%Pages: 1
%%LanguageLevel: 1
%%DocumentData: Clean7Bit
%%DocumentSuppliedResources: procset bannerprint/1.0
%%DocumentNeededResources: font Helvetica Helvetica-Bold Times-Roman
%%Creator: Michael Sweet, Easy Software Products
%%CreationDate: May 10, 2000
%%Title: Test Page
%%EndComments
%%BeginProlog
%%BeginResource procset bannerprint 1.1 0
%
% PostScript banner page for the Common UNIX Printing System ("CUPS").
%
% Copyright 1993-2000 Easy Software Products
%
% These coded instructions, statements, and computer programs contain
% unpublished proprietary information of Easy Software Products, and
% are protected by Federal copyright law. They may not be disclosed
% to third parties or copied or duplicated in any form, in whole or
% in part, without the prior written consent of Easy Software Products.
%
/CENTER { % Draw centered text
% (name) CENTER -
dup stringwidth pop % Get the width of the string
0.5 mul neg 0 rmoveto % Shift left 1/2 of the distance
show % Show the string
} bind def
/RIGHT { % Draw right-justified text
% (name) RIGHT -
dup stringwidth pop % Get the width of the string
neg 0 rmoveto % Shift left the entire distance
show % Show the string
} bind def
/NUMBER { % Draw a number
% power n NUMBER -
1 index 1 eq { % power == 1?
round cvi exch pop % Convert "n" to integer
} {
1 index mul round exch div % Truncate extra decimal places
} ifelse
100 string cvs show % Convert to a string and show it...
} bind def
/CUPSLOGO { % Draw the CUPS logo
% height CUPSLOGO
% Start with a big C...
/Helvetica findfont 1 index scalefont setfont
0 setgray
0 0 moveto
(C) show
% Then "UNIX Printing System" much smaller...
/Helvetica-Bold findfont 1 index 9 div scalefont setfont
0.25 mul
dup dup 2.0 mul moveto
(UNIX) show
dup dup 1.6 mul moveto
(Printing) show
dup 1.2 mul moveto
(System) show
} bind def
/ESPLOGO { % Draw the ESP logo
% height ESPLOGO
% Compute the size of the logo...
0 0
2 index 1.5 mul 3 index
% Do the "metallic" fill from 10% black to 40% black...
1 -0.001 0 {
dup % loopval
-0.15 mul % loopval * -0.15
0.9 add % 0.9 - loopval * 0.15
setgray % set gray shade
0 % x
1 index neg % loopval
1 add % 1 - loopval
3 index % height
mul % height * (1 - loopval)
moveto % starting point
dup % loopval
3 index % width
mul % loopval * width
2 index % height
lineto % Next point
0 % x
2 index % height
lineto % Next point
closepath
fill
dup % loopval
0.15 mul % loopval * 0.15
0.6 add % 0.6 + loopval * 0.15
setgray
dup % loopval
neg 1 add % 1 - loopval
3 index % width
mul % (1 - loopval) * width
0 % y
moveto % Starting point
2 index % width
exch % loopval
2 index % height
mul % loopval * height
lineto % Next point
1 index % width
0 % y
lineto % Next point
closepath
fill
} for
0 setgray rectstroke
/Helvetica-BoldOblique findfont 1 index 3 div scalefont setfont
dup 40 div
dup 4 mul 1 index 25 mul moveto (E) show
dup 10 mul 1 index 15 mul moveto (S) show
dup 16 mul 1 index 5 mul moveto (P) show
/Helvetica-BoldOblique findfont 2 index 5 div scalefont setfont
dup 14 mul 1 index 29 mul moveto (asy) show
dup 20 mul 1 index 19 mul moveto (oftware) show
dup 26 mul 1 index 9 mul moveto (roducts) show
pop
} bind def
%%EndResource
%%EndProlog
%%Page: 1 1
gsave
% Determine the imageable area and device resolution...
initclip newpath clippath pathbbox % Get bounding rectangle
72 div /pageTop exch def % Get top margin in inches
72 div /pageRight exch def % Get right margin in inches
72 div /pageBottom exch def % Get bottom margin in inches
72 div /pageLeft exch def % Get left margin in inches
/pageWidth pageRight pageLeft sub def % pageWidth = pageRight - pageLeft
/pageHeight pageTop pageBottom sub def% pageHeight = pageTop - pageBottom
/boxWidth % width of text box
pageWidth pageHeight lt
{ pageWidth 54 mul }
{ pageHeight 42 mul }
ifelse def
newpath % Clear bounding path
% Create fonts...
/bigFont /Helvetica-Bold findfont % bigFont = Helvetica-Bold
pageHeight 3 mul scalefont def % size = pageHeight * 3 (nominally 33)
/mediumFont /Helvetica findfont % mediumFont = Helvetica
pageHeight 1.5 mul scalefont def % size = pageHeight * 1.5 (nominally 16.5)
% Offset page to account for lower-left margin...
pageLeft 72 mul
pageBottom 72 mul
translate
% Draw the label at the top and bottom...
0 setgray % Color
pageWidth 36 mul % Center of page
pageHeight 72 mul % Top of page
pageWidth -7 mul add % - 2 lines
moveto % Position text
bigFont setfont % Font
(Classified) CENTER % Show text centered
pageWidth 36 mul % Center of page
pageHeight 6 mul % Bottom of page
moveto % Position text
bigFont setfont % Font
(Classified) CENTER % Show text centered
% Job information box...
pageWidth 36 mul 9 add % x = pageWidth * 1/2 * 72 + 9
boxWidth 0.5 mul sub % x-= 1/2 box width
pageHeight 30 mul 9 sub % y = pageHeight * 1/2 * 72 - 9
boxWidth % w = box width
pageHeight 14 mul % h = pageHeight * 1/2 * 72
0.5 setgray rectfill % Draw a shadow
pageWidth 36 mul % x = pageWidth * 1/2 * 72
boxWidth 0.5 mul sub % x-= 1/2 box width
pageHeight 30 mul % y = pageHeight * 1/4 * 72
boxWidth % w = box width
pageHeight 14 mul % h = pageHeight * 1/2 * 72
4 copy 1 setgray rectfill % Clear the box to white
0 setgray rectstroke % Draw a black box around it...
% Job information text...
mediumFont setfont % Medium sized font
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight 5 mul add % y += 2 lines
2 copy % Copy X & Y
moveto
(Job ID: ) RIGHT
moveto
({printer-name}-{job-id}) show
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight 2 mul add % y += 1 line
2 copy % Copy X & Y
moveto
(Title: ) RIGHT
moveto
({job-name}) show
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight -1 mul add % y -= 1 line
2 copy % Copy X & Y
moveto
(Requesting User: ) RIGHT
moveto
({job-originating-user-name}) show
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight -4 mul add % y -= 2 lines
2 copy % Copy X & Y
moveto
(Billing Info: ) RIGHT
moveto
({job-billing}) show
% Then the CUPS logo....
gsave
pageWidth 4 mul
pageWidth 6 mul
translate
pageWidth 9 mul CUPSLOGO
grestore
% And the ESP logo....
gsave
pageWidth 59 mul
pageWidth 6 mul
translate
pageWidth 6 mul ESPLOGO
grestore
% Show the page...
grestore
showpage
%
% End of "$Id: classified 1379 2000-09-18 17:12:42Z mike $".
%
%%EOF
-267
Ver Arquivo
@@ -1,267 +0,0 @@
%!PS-Adobe-3.0
%%BoundingBox: 0 0 612 792
%%Pages: 1
%%LanguageLevel: 1
%%DocumentData: Clean7Bit
%%DocumentSuppliedResources: procset bannerprint/1.0
%%DocumentNeededResources: font Helvetica Helvetica-Bold Times-Roman
%%Creator: Michael Sweet, Easy Software Products
%%CreationDate: May 10, 2000
%%Title: Test Page
%%EndComments
%%BeginProlog
%%BeginResource procset bannerprint 1.1 0
%
% PostScript banner page for the Common UNIX Printing System ("CUPS").
%
% Copyright 1993-2000 Easy Software Products
%
% These coded instructions, statements, and computer programs contain
% unpublished proprietary information of Easy Software Products, and
% are protected by Federal copyright law. They may not be disclosed
% to third parties or copied or duplicated in any form, in whole or
% in part, without the prior written consent of Easy Software Products.
%
/CENTER { % Draw centered text
% (name) CENTER -
dup stringwidth pop % Get the width of the string
0.5 mul neg 0 rmoveto % Shift left 1/2 of the distance
show % Show the string
} bind def
/RIGHT { % Draw right-justified text
% (name) RIGHT -
dup stringwidth pop % Get the width of the string
neg 0 rmoveto % Shift left the entire distance
show % Show the string
} bind def
/NUMBER { % Draw a number
% power n NUMBER -
1 index 1 eq { % power == 1?
round cvi exch pop % Convert "n" to integer
} {
1 index mul round exch div % Truncate extra decimal places
} ifelse
100 string cvs show % Convert to a string and show it...
} bind def
/CUPSLOGO { % Draw the CUPS logo
% height CUPSLOGO
% Start with a big C...
/Helvetica findfont 1 index scalefont setfont
0 setgray
0 0 moveto
(C) show
% Then "UNIX Printing System" much smaller...
/Helvetica-Bold findfont 1 index 9 div scalefont setfont
0.25 mul
dup dup 2.0 mul moveto
(UNIX) show
dup dup 1.6 mul moveto
(Printing) show
dup 1.2 mul moveto
(System) show
} bind def
/ESPLOGO { % Draw the ESP logo
% height ESPLOGO
% Compute the size of the logo...
0 0
2 index 1.5 mul 3 index
% Do the "metallic" fill from 10% black to 40% black...
1 -0.001 0 {
dup % loopval
-0.15 mul % loopval * -0.15
0.9 add % 0.9 - loopval * 0.15
setgray % set gray shade
0 % x
1 index neg % loopval
1 add % 1 - loopval
3 index % height
mul % height * (1 - loopval)
moveto % starting point
dup % loopval
3 index % width
mul % loopval * width
2 index % height
lineto % Next point
0 % x
2 index % height
lineto % Next point
closepath
fill
dup % loopval
0.15 mul % loopval * 0.15
0.6 add % 0.6 + loopval * 0.15
setgray
dup % loopval
neg 1 add % 1 - loopval
3 index % width
mul % (1 - loopval) * width
0 % y
moveto % Starting point
2 index % width
exch % loopval
2 index % height
mul % loopval * height
lineto % Next point
1 index % width
0 % y
lineto % Next point
closepath
fill
} for
0 setgray rectstroke
/Helvetica-BoldOblique findfont 1 index 3 div scalefont setfont
dup 40 div
dup 4 mul 1 index 25 mul moveto (E) show
dup 10 mul 1 index 15 mul moveto (S) show
dup 16 mul 1 index 5 mul moveto (P) show
/Helvetica-BoldOblique findfont 2 index 5 div scalefont setfont
dup 14 mul 1 index 29 mul moveto (asy) show
dup 20 mul 1 index 19 mul moveto (oftware) show
dup 26 mul 1 index 9 mul moveto (roducts) show
pop
} bind def
%%EndResource
%%EndProlog
%%Page: 1 1
gsave
% Determine the imageable area and device resolution...
initclip newpath clippath pathbbox % Get bounding rectangle
72 div /pageTop exch def % Get top margin in inches
72 div /pageRight exch def % Get right margin in inches
72 div /pageBottom exch def % Get bottom margin in inches
72 div /pageLeft exch def % Get left margin in inches
/pageWidth pageRight pageLeft sub def % pageWidth = pageRight - pageLeft
/pageHeight pageTop pageBottom sub def% pageHeight = pageTop - pageBottom
/boxWidth % width of text box
pageWidth pageHeight lt
{ pageWidth 54 mul }
{ pageHeight 42 mul }
ifelse def
newpath % Clear bounding path
% Create fonts...
/bigFont /Helvetica-Bold findfont % bigFont = Helvetica-Bold
pageHeight 3 mul scalefont def % size = pageHeight * 3 (nominally 33)
/mediumFont /Helvetica findfont % mediumFont = Helvetica
pageHeight 1.5 mul scalefont def % size = pageHeight * 1.5 (nominally 16.5)
% Offset page to account for lower-left margin...
pageLeft 72 mul
pageBottom 72 mul
translate
% Draw the label at the top and bottom...
0 setgray % Color
pageWidth 36 mul % Center of page
pageHeight 72 mul % Top of page
pageWidth -7 mul add % - 2 lines
moveto % Position text
bigFont setfont % Font
(Confidential) CENTER % Show text centered
pageWidth 36 mul % Center of page
pageHeight 6 mul % Bottom of page
moveto % Position text
bigFont setfont % Font
(Confidential) CENTER % Show text centered
% Job information box...
pageWidth 36 mul 9 add % x = pageWidth * 1/2 * 72 + 9
boxWidth 0.5 mul sub % x-= 1/2 box width
pageHeight 30 mul 9 sub % y = pageHeight * 1/2 * 72 - 9
boxWidth % w = box width
pageHeight 14 mul % h = pageHeight * 1/2 * 72
0.5 setgray rectfill % Draw a shadow
pageWidth 36 mul % x = pageWidth * 1/2 * 72
boxWidth 0.5 mul sub % x-= 1/2 box width
pageHeight 30 mul % y = pageHeight * 1/4 * 72
boxWidth % w = box width
pageHeight 14 mul % h = pageHeight * 1/2 * 72
4 copy 1 setgray rectfill % Clear the box to white
0 setgray rectstroke % Draw a black box around it...
% Job information text...
mediumFont setfont % Medium sized font
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight 5 mul add % y += 2 lines
2 copy % Copy X & Y
moveto
(Job ID: ) RIGHT
moveto
({printer-name}-{job-id}) show
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight 2 mul add % y += 1 line
2 copy % Copy X & Y
moveto
(Title: ) RIGHT
moveto
({job-name}) show
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight -1 mul add % y -= 1 line
2 copy % Copy X & Y
moveto
(Requesting User: ) RIGHT
moveto
({job-originating-user-name}) show
pageWidth 36 mul % x = pageWidth * 1/2 * 72
pageHeight 36 mul % y = pageHeight * 1/2 * 72
pageHeight -4 mul add % y -= 2 lines
2 copy % Copy X & Y
moveto
(Billing Info: ) RIGHT
moveto
({job-billing}) show
% Then the CUPS logo....
gsave
pageWidth 4 mul
pageWidth 6 mul
translate
pageWidth 9 mul CUPSLOGO
grestore
% And the ESP logo....
gsave
pageWidth 59 mul
pageWidth 6 mul
translate
pageWidth 6 mul ESPLOGO
grestore
% Show the page...
grestore
showpage
%
% End of "$Id: confidential 1379 2000-09-18 17:12:42Z mike $".
%
%%EOF
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -2
Ver Arquivo
@@ -22,8 +22,7 @@ charset 8bit
# printing.
#
00 9f ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
a0 ff ltor single Symbol
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff rtol single Courier Courier-Bold Courier-Italic Courier-BoldItalic
rtol single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff rtol single Courier Courier-Bold Courier-Italic Courier-BoldItalic
rtol single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
-2
Ver Arquivo
@@ -1,2 +0,0 @@
auth required /lib/security/pam_pwdb.so nullok shadow
account required /lib/security/pam_pwdb.so
-2
Ver Arquivo
@@ -1,2 +0,0 @@
auth required /lib/security/pam_unix.so nullok shadow
account required /lib/security/pam_unix.so
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -1
Ver Arquivo
@@ -22,7 +22,7 @@ charset 8bit
# printing.
#
00 ff rtol single Courier Courier-Bold Courier-Italic Courier-BoldItalic
rtol single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
+1 -2
Ver Arquivo
@@ -22,8 +22,7 @@ charset 8bit
# printing.
#
00 9f ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
a0 ff ltor single Symbol
ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to

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