Comparar commits

..

1 Commits

Autor SHA1 Mensagem Data
msweet c20b887ba5 Import cups.org releases
git-svn-id: svn+ssh://src.apple.com/svn/cups/cups.org/tags/release-1.0b4@4306 a1ca3aef-8c08-0410-bb20-df032aa958be
2013-05-10 18:56:23 +00:00
1214 arquivos alterados com 98996 adições e 373536 exclusões
-812
Ver Arquivo
@@ -1,812 +0,0 @@
CHANGES.txt - 09/18/2000
------------------------
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.
- The lp command didn't always load the user-defined
destinations, preventing it from seeing the default
printer.
- Many configure script and makefile fixes.
- The Microsoft code page files were missing from the
distribution.
- Added a workaround for the HP IPP client (which is sending
an invalid printer-uri in requests)
- Fixed the encoding of text-with-language and name-with-language
to match the IPP spec.
- Added support for unknown value tags in the IPP routines
(previously they would be ignored)
- Integrated GNU GhostScript 5.50 into the pstoraster filter.
- Client hostname resolution was broken on little-endian
machines.
- Now look at client.conf file for client's default server
and printer.
- The cupsServer() function did not close the client.conf file
if it contained a ServerName directive.
- Added BrowseAllow, BrowseDeny, BrowseOrder, BrowsePoll, and
BrowseRelay directives.
- BrowseInterval 0 disables advertising of local printers, but
still receives information on remote printers.
- New browse polling daemon (for polling servers on different
networks)
- New PPD cache file for faster startup times with large numbers
of PPD files.
- The Host: field was incorrectly required for HTTP/1.0 clients.
- New set-job-attributes operation now supported.
- The mime_load_types() and mime_load_convs() functions did not
close their input files.
CHANGES IN CUPS v1.1b1
- NEW web-based administration interface.
- NEW EPSON printer drivers.
- NEW user-defined printers and options.
- NEW persistent jobs and job history
- NEW IPP/1.1 support
- NEW template-based web interfaces.
- NEW CUPS-get-devices and CUPS-get-ppds operations.
- NEW support for create-job and send-file operations.
- NEW certificate-based authentication for local
administration.
- NEW USB backend.
- The lpr command now produces human-readable error messages.
- The lpq command now produces BSD standard format output
instead of OSF/1 output. This should resolve the SAMBA
print queue problems that have been reported.
- The IPP backend did not always detect when the "raw" option
was being used.
- The "lpstat -p" command would stop after the first active
printer.
- The "lpstat -v" command would stop before the first remote
printer.
CHANGES IN CUPS v1.0.5
- The HP-GL/2 filter did not correctly set the pen color
for pens other than #1.
- The scheduler would only accept 26 simultaneous jobs
under some OS releases (mkstemp() limitation.) It now
handles up to 2^32 simultaneous jobs.
- The PostScript filter loaded the printer's PPD file
twice.
- The PAM authentication code now uses pam_strerror() to
provide a textual error message in the error_log file.
- The scheduler now copies PPD and interface script
files instead of moving them; this fixes installations
with a separate requests directory.
- The PostScript RIP did not generate correct 6-color
output.
- Several filters were marking PPD options twice when
they didn't need to.
- The scheduler did not save the printer or class state
after an accept-jobs or reject-jobs operation.
- The cupsGetDefault() function now ignores the PRINTER
environment variable if it is set to "lp".
- New ippErrorString() function to get textual error
messages.
- Better error reporting in the System V commands.
- The lpadmin and lpstat commands always tried to
connect to the default server.
- The text filter didn't load the charset files from the
correct location.
- Wasn't sending a WWW-Authenticate: field to HTTP
clients when authentication was required.
- httpSeparate() didn't always set the default port
number for known methods.
- The HP-GL/2 filter now looks for "PSwidth,length"
instead of (the correct) "PSlength,width" as
documented by HP. It appears that many major CAD
applications are broken and this change allows the
auto-rotation to work with them.
- The IPP "printer-resolution" option was not being
translated.
- The charset files did not include the Microsoft
"standard" characters from 128 to 159 (unused by the
ISO-8859-x charsets)
- The scheduler was chunking the Content-Type field from
CGI programs; this problem was most noticeable with
Microsoft Internet Explorer 5.
- By popular demand, the printers, jobs, and classes
CGIs no longer force a reload of the page every 10/30
seconds.
- The scheduler incorrectly required that the IPP client
provide a document-format attribute for the
validate-job operation.
- Clients that sent bad IPP requests without the
required attributes-natural-language and
attributes-charset attributes would crash the
scheduler.
CHANGES IN CUPS v1.0.4
- Documentation updates.
- Jobs would get stuck in the queue and wouldn't print
until you enabled the queue.
- The lp and lpr commands now catch SIGHUP and SIGINTR.
- The lp and lpr commands now use sigaction or sigset
when available.
- CUPS library updates for WIN32/OS-2
CHANGES IN CUPS v1.0.3
- Documentation updates.
- The lpq man page was missing.
- The configure script was not properly detecting the
image libraries.
- The top-level makefile was calling "make" instead of
"$(MAKE)".
- PostScript filter fixes for number-up, OutputOrder,
and %Trailer.
- The imagetops filter didn't end the base-85 encoding
properly if the image data was not a multiple of 4
bytes in length.
- The imagetoraster filter didn't generate good banded
RGB or CMY data (was dividing the line width by 4
instead of 3...)
- The imagetoraster filter now records the bounding
box of the image on the page.
- The CUPS image library cache code wasn't working as
designed; images larger than the maximum RIP cache
would eventually thrash using the same cache tile.
- The CUPS image library TIFF loading code didn't
handle unknown resolution units properly; the fixed
code uses a default resolution of 128 PPI.
- cupsGetClasses() and cupsGetPrinters() did not free
existing strings if they ran out of memory.
- The scheduler logs incorrectly contained 3 digits for
the timezone offset instead of 4.
- The scheduler now does a lookup for the default user
and group ID; the previous hardcoded values caused
problems with the LPD backend.
- The cancel-job operation now allows any user in the
system group to cancel any job.
- The cancel-job operation stopped the print queue if
the job was being printed.
- Now only stop printers if the backend fails. If the
filter fails then the failure is noted in the
error_log and printing continues with the next file in
the queue.
- Now log whether a filter fails because of a signal
or because it returned a non-zero exit status.
- The root user now always passes the system group test.
- Printers with an interface script and remote printers
and classes didn't have a printer-make-and-model
attribute.
- Added logging of lost/timed-out remote printers.
- The HP-GL/2 filter was scaling the pen width twice.
- Updated the HP-GL/2 filter to use a single SP (Set
Pen) procedure. This makes the output smaller and is
more appropriate since the filter keeps track of the
pen states already.
- The scheduler didn't handle passwords with spaces.
- The IPP backend now does multiple copies and retries
if the destination server requires it (e.g. HP
JetDirect.)
- The disable command didn't implement the "-c" option
(cancel all jobs.)
- Changed the CMYK generation function for the image file
and PostScript RIPs.
- The lp command didn't support the "-h" option as
documented.
- The AppSocket, IPP, and LPD backends now retry on all
network errors. This should prevent stopped queues
caused by a printer being disconnected from the
network or powered off.
- The scheduler now restarts a job if the corresponding
printer is modified.
- The image RIPs now rotate the image if needed to fit
on the page.
CHANGES IN CUPS v1.0.2
- The HP-GL/2 filter didn't always scale the output
correctly.
- The HP-GL/2 filter now supports changing the page size
automatically when the "fitplot" option is not used.
- The cancel-job operation was expecting a resource name
of the form "/job/#" instead of "/jobs/#"; this
prevented the cancel and lprm commands from working.
- The backends didn't log pages when files were printed
using the "-oraw" option.
- The authorization code did not work with the Slackware
long shadow password package because its crypt() can
return NULL.
- The chunking code didn't work for reading the response
of a POST request.
- cupsGetPPD() now does authentication as needed.
- The N-up code in the PostScript filter didn't work
with some printers (grestoreall would restore the
default blank page and device settings).
- The N-up code in the PostScript filter didn't scale
the pages to fit within the imageable area of the
page.
- Wasn't doing an fchown() on the request files. This
caused problems when the default root account group
and CUPS group were not the same.
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.
-26
Ver Arquivo
@@ -1,26 +0,0 @@
CREDITS.txt - 01/27/2000
------------------------
Few projects are completed by one person, and CUPS is no exception. We'd
like to thank the following individuals for their contributions:
Nathaniel Barbour - Lots of testing and feedback.
N. Becker - setsid().
Jean-Eric Cuendet - GhostScript filters for CUPS.
Van Dang - HTTP and IPP policeman.
Dr. ZP Han - setgid()/setuid().
Guy Harris - *BSD shared libraries and lots of other fixes.
Wang Jian - CUPS RPM corrections.
Roderick Johnstone - Beta tester of the millenium.
Sergey V. Kovalyov - ESP Print Pro and CUPS beta tester.
Mark Lawrence - Microsoft interoperability testing.
Jason McMullan - Original CUPS RPM distributions.
Wes Morgan - *BSD fixes.
Ulrich Oldendorf - German locale.
Petter Reinholdtsen - HP-UX compiler stuff.
Stuart Stevens - HP JetDirect IPP information.
Kiko - Bug fixes.
L. Peter Deutsch - MD5 code.
If I've missed someone, please let me know by sending an email to
"mike@easysw.com".
+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>
+332
Ver Arquivo
@@ -0,0 +1,332 @@
Common UNIX Printing System License Agreement
Copyright 1997-1999 by Easy Software Products
44141 AIRPORT VIEW DR STE 204
HOLLYWOOD, MARYLAND 20636-3111 USA
Voice: +1.301.373.9603
Email: cups-info@cups.org
WWW: http://www.cups.org
Introduction
The Common UNIX Printing SystemTM, or CUPSTM, is provided under the GNU
General Public License, Version 2. A copy of this license follows this
introduction.
For those not familiar with the GNU General Public License, the license
basically allows you to:
* Use the CUPS software at no charge.
* Distribute verbatim copies of the software in source or binary form.
* Sell verbatim copies of the software for a media fee, or sell support
for the software.
* Distribute or sell printer drivers and filters that use the CUPS API so
long as source code is made available under the GPL.
What this license does not allow you to do is make changes or add features
to CUPS and then sell a binary distribution without source 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.
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.
Binary Distribution Rights
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 or additions and modifications to CUPS under the GPL.
For pricing information please contact us at the address shown above.
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:
Miles Jones
Director of Marketing
Artifex Software Inc.
454 Las Gallinas Ave., Suite 108
San Rafael, CA 94903 USA
Voice: +1.415.492.9861
Fax: +1.415.492.9862
EMail: info@arsoft.com
Support
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.
Trademarks
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.
GNU General Public License
Version 2, June 1991
Copyright 1989, 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.
Preamble
The licenses for most software are designed to take away your freedom to
share and change it. By contrast, the GNU General Public License is intended
to guarantee your freedom to share and change free software--to make sure
the software is free for all its users. This General Public License applies
to most of the Free Software Foundation's software and to any other program
whose authors commit to using it. (Some other Free Software Foundation
software is covered by the GNU Library General Public License instead.) You
can apply it to your programs, too.
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.
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 software, or if you modify it.
For example, if you distribute copies of such a program, whether gratis or
for a fee, you must give the recipients all the rights that you have. You
must make sure that they, too, receive or can get the source code. And you
must show them these terms so they know their rights.
We protect your rights with two steps: (1) copyright the software, and (2)
offer you this license which gives you legal permission to copy, distribute
and/or modify the software.
Also, for each author's protection and ours, we want to make certain that
everyone understands that there is no warranty for this free software. If
the software is modified by someone else and passed on, we want its
recipients to know that what they have is not the original, so that any
problems introduced by others will not reflect on the original authors'
reputations.
Finally, any free program is threatened constantly by software patents. We
wish to avoid the danger that redistributors of a free program will
individually obtain patent licenses, in effect making the program
proprietary. To prevent this, we have made it clear that any patent must be
licensed for everyone's free use or not licensed at all.
The precise terms and conditions for copying, distribution and modification
follow.
GNU GENERAL PUBLIC LICENSE
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
1. This License applies to any program or other work which contains a
notice placed by the copyright holder saying it may be distributed
under the terms of this General Public License. The "Program", below,
refers to any such program or work, and a "work based on the Program"
means either the Program or any derivative work under copyright law:
that is to say, a work containing the Program or a portion of it,
either verbatim or with modifications and/or translated into another
language. (Hereinafter, translation is included without limitation in
the term "modification".) Each licensee is addressed as "you".
Activities other than copying, distribution and modification are not
covered by this License; they are outside its scope. The act of running
the Program is not restricted, and the output from the Program is
covered only if its contents constitute a work based on the Program
(independent of having been made by running the Program). Whether that
is true depends on what the Program does.
2. You may copy and distribute verbatim copies of the Program's 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 give any other
recipients of the Program a copy of this License along with the
Program.
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.
3. You may modify your copy or copies of the Program or any portion of it,
thus forming a work based on the Program, and copy and distribute such
modifications or work under the terms of Section 1 above, provided that
you also meet all of these conditions:
a. You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
b. You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any
part thereof, to be licensed as a whole at no charge to all third
parties under the terms of this License.
c. if the modified program normally reads commands interactively when
run, you must cause it, when started running for such interactive
use in the most ordinary way, to print or display an announcement
including an appropriate copyright notice and a notice that there
is no warranty (or else, saying that you provide a warranty) and
that users may redistribute the program under these conditions,
and telling the user how to view a copy of this License.
(Exception: if the Program itself is interactive but does not
normally print such an announcement, your work based on the
Program is not required to print an announcement.)
These requirements apply to the modified work as a whole. If
identifiable sections of that work are not derived from the Program,
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 Program, 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.
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 Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume of a
storage or distribution medium does not bring the other work under the
scope of this License.
4. You may copy and distribute the Program (or a work based on it, under
Section 2) in object code or executable form under the terms of
Sections 1 and 2 above provided that you also do one of the following:
a. 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; or,
b. Accompany it with a written offer, valid for at least three years,
to give any third party, for a charge no more than your cost of
physically performing source distribution, a complete
machine-readable copy of the corresponding source code, to be
distributed under the terms of Sections 1 and 2 above on a medium
customarily used for software interchange; or,
c. Accompany it with the information you received as to the offer to
distribute corresponding source code. (This alternative is allowed
only for noncommercial distribution and only if you received the
program in object code or executable form with such an offer, in
accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, 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 executable. 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.
If distribution of executable or 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 counts as distribution of the
source code, even though third parties are not compelled to copy the
source along with the object code.
5. You may not copy, modify, sublicense, or distribute the Program except
as expressly provided under this License. Any attempt otherwise to
copy, modify, sublicense or distribute the Program 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.
6. 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 Program or its derivative works. These actions are prohibited by
law if you do not accept this License. Therefore, by modifying or
distributing the Program (or any work based on the Program), you
indicate your acceptance of this License to do so, and all its terms
and conditions for copying, distributing or modifying the Program or
works based on it.
7. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the
original licensor to copy, distribute or modify the Program 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.
8. 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 Program at all. For example, if a patent license
would not permit royalty-free redistribution of the Program 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 Program.
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.
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.
This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
9. If the distribution and/or use of the Program is restricted in certain
countries either by patents or by copyrighted interfaces, the original
copyright holder who places the Program 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.
10. The Free Software Foundation may publish revised and/or new versions of
the 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.
Each version is given a distinguishing version number. If the Program
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 Program does not specify a version
number of this License, you may choose any version ever published by
the Free Software Foundation.
11. If you wish to incorporate parts of the Program into other free
programs whose distribution conditions are different, 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.
NO WARRANTY
11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
PROVIDE THE PROGRAM "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 PROGRAM IS WITH
YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL
NECESSARY SERVICING, REPAIR OR CORRECTION.
12. 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 PROGRAM 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 PROGRAM
(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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR
OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
END OF TERMS AND CONDITIONS
+19 -62
Ver Arquivo
@@ -3,7 +3,9 @@
#
# Common makefile definitions for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-2000 by Easy Software Products, all rights reserved.
# @configure_input@
#
# 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,45 +30,19 @@
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@
NROFF = @NROFF@
PACK = @PACK@
RANLIB = @RANLIB@
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...
#
LIBCUPS = @LIBCUPS@
LIBCUPSIMAGE = @LIBCUPSIMAGE@
LIBJPEG = @LIBJPEG@
LIBMALLOC = @LIBMALLOC@
LIBPNG = @LIBPNG@
LIBTIFF = @LIBTIFF@
LIBZ = @LIBZ@
SMBCLIENT = @SMBCLIENT@
#
# Program options...
@@ -78,17 +54,18 @@ LIBZ = @LIBZ@
ARFLAGS = crvs
CFLAGS = @CFLAGS@ $(OPTIM) -I.. $(OPTIONS)
CXXFLAGS = @CXXFLAGS@ $(OPTIM) -I.. $(OPTIONS)
DSOLIBS = @DSOLIBS@
IMGLIBS = @IMGLIBS@ -lm
IMGLIBS = @IMGLIBS@ $(LIBS) -lm
LDFLAGS = @LDFLAGS@ $(OPTIM)
LINKCUPS = @LINKCUPS@
LINKCUPSIMAGE = @LINKCUPSIMAGE@
LIBS = $(LINKCUPS) $(NETLIBS) @LIBS@
NETLIBS = @NETLIBS@
LIBS = @LIBS@ -L../cups -lcups
OPTIM = @OPTIM@
OPTIONS =
#
# Formatted man page extension...
#
CAT = @CAT@
#
# Directories...
#
@@ -120,46 +97,26 @@ top_srcdir = @top_srcdir@
BINDIR = @bindir@
DATADIR = @CUPS_DATADIR@
DOCDIR = @CUPS_DOCROOT@
INCLUDEDIR = $(includedir)
INITDIR = @INITDIR@
INITDDIR = @INITDDIR@
INCLUDEDIR = $(includedir)/cups
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 .gz .h .o .z .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:
.1.z .5.z .8.z .1.gz .5.gz .8.gz:
echo Formatting $<...
$(RM) $@
$(NROFF) -man $< >$@
.man.z:
echo Formatting $<...
$(RM) $@ t.z
$(NROFF) -man $< >t
pack -f t
$(MV) t.z $@
$(PACK) t
-mv t.$(CAT) $@
#
# End of "$Id$"
+10 -58
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);\
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 clean);\
done
#
@@ -58,66 +58,18 @@ clean:
install:
for dir in $(DIRS); do\
echo Installing in $$dir... ;\
(cd $$dir; $(MAKE) $(MFLAGS) install) || exit 1;\
(cd $$dir; make install);\
done
echo Installing in conf...
(cd conf; $(MAKE) $(MFLAGS) install)
(cd conf; make install)
echo Installing in data...
(cd data; $(MAKE) $(MFLAGS) install)
(cd data; make install)
echo Installing in doc...
(cd doc; $(MAKE) $(MFLAGS) install)
(cd doc; make install)
echo Installing in fonts...
(cd fonts; $(MAKE) $(MFLAGS) install)
echo Installing in locale...
(cd locale; $(MAKE) $(MFLAGS) install)
(cd fonts; make install)
echo Installing in ppd...
(cd ppd; $(MAKE) $(MFLAGS) 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; \
fi
#
# Make software distributions using EPM (http://www.easysw.com/epm)...
#
EPMFLAGS = -v \
BINDIR=$(BINDIR) DATADIR=$(DATADIR) \
DOCDIR=$(DOCDIR) ESP_ROOT=$(ESP_ROOT) \
INCLUDEDIR=$(INCLUDEDIR) LIBDIR=$(LIBDIR) \
LOCALEDIR=$(LOCALEDIR) LOGDIR=$(LOGDIR) \
MANDIR=$(MANDIR) PAMDIR=$(PAMDIR) \
REQUESTS=$(REQUESTS) SBINDIR=$(SBINDIR) \
SERVERBIN=$(SERVERBIN) SERVERROOT=$(SERVERROOT)
epm:
epm $(EPMFLAGS) cups
rpm:
epm $(EPMFLAGS) -f rpm cups
deb:
epm $(EPMFLAGS) -f deb cups
depot:
epm $(EPMFLAGS) -f depot cups
pkg:
epm $(EPMFLAGS) -f pkg cups
tardist:
epm $(EPMFLAGS) -f tardist cups
(cd ppd; make install)
#
# End of "$Id$".
+139
Ver Arquivo
@@ -0,0 +1,139 @@
<HTML>
<HEAD>
<TITLE>README - Common UNIX Printing System</TITLE>
</HEAD>
<BODY>
<H1>README - CUPS v1.0b4</H1>
<H2>Contents</H2>
<UL>
<LI><A HREF="#intro">Introduction</A>
<LI><A HREF="#require">Requirements</A>
<LI><A HREF="#use">Using CUPS</A>
<LI><A HREF="#known">Known Problems</A>
<LI><A HREF="#report">Reporting Problems</A>
<LI><A HREF="#resources">Other Resources</A>
<LI><A HREF="#legal">Legal Stuff</A>
</UL>
<H2><A NAME="intro">Introduction</A></H2>
The Common UNIX Printing System provides a portable printing layer for
UNIX&reg; 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.
<P>CUPS uses the Internet Printing Protocol (IETF-IPP) as the basis
for managing print jobs and queues. The Line Printer Daemon (LPD,
RFC1179), Server Message Block (SMB), and AppSocket protocols are also
supported with reduced functionality.
<P>CUPS adds network printer browsing and PostScript Printer
Description (&quot;PPD&quot;)-based printing options to support real
world applications under UNIX.
<P>CUPS also includes a customized version of GNU GhostScript (currently
based off GNU GhostScript 4.03) and an image file RIP that can be used to
support non-PostScript printers.
<H2><A NAME="require">Requirements</A></H2>
You'll need an ANSI C compiler to build CUPS on your system. As its name
implies, CUPS is designed to run on the UNIX operating system, however
the CUPS interface library and most of the filters and backends supplied
with CUPS should also run under Microsoft&reg; Windows&reg;.
<P>For the image file filters you'll need the JPEG, PNG, TIFF, and ZLIB
libraries. CUPS will build without these, but with reduced functionality.
<P>If you make changes to the man pages you'll need GNU groff or another
nroff-like package.
<P>The documentation is formatted using the HTMLDOC software (again, not
needed unless you make changes.)
<H2><A NAME="use">Using CUPS</A></H2>
<P>Pre-compiled binary distributions are available for CUPS from our
web site at
<A HREF="http://www.cups.org/software.html">http://www.cups.org/software.html</A>.
If you'd like to build CUPS from the source, please read the Software
Administrator's Manual.
<P>Once you have installed CUPS, the Software Administrator's Manual and
Software User's Manual are excellent places to start setting things up.
<H2><A NAME="known">Known Problems</A></H2>
The following known problems are being worked on and should be resolved for
the fourth beta release of CUPS:
<UL>
<LI>Documentation is not completed.
<LI>The lpc command currently only supports the help and status
commands.
</UL>
CUPS has been built and tested on the following operating systems:
<UL>
<LI>Digital UNIX 4.0d
<LI>HP-UX 10.20 and 11.0
<LI>IRIX 5.3, 6.2, 6.5.3
<LI>Linux (RedHat 5.2)
<LI>Solaris 2.5.1, 2.6, 2.7 (aka 7)
</UL>
The client libraries and filters have been successfully compiled under
Microsoft Windows using Visual C++ 6.0.
<H2><A NAME="report">Reporting Problems</A></H2>
If you have problems, please send an email to
<A HREF="mailto:cups-support@cups.org">cups-support@cups.org</A>. Include
your operating system and version, compiler and version, and any errors
or problems you've run into.
<H2><A NAME="resources">Other Resources</A></H2>
See the CUPS web site at "http://www.cups.org" for other site links.
<P>You can subscribe to the CUPS mailing list by sending a message containing
"subscribe cups" to <A HREF="mailto:majordomo@cups.org">majordomo@cups.org</A>.
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.
<H2><A NAME="legal">Legal Stuff</A></H2>
CUPS is Copyright 1993-1999 by Easy Software Products. CUPS, the CUPS logo,
and the Common UNIX Printing System are the trademark property of Easy Software
Products.
<P>CUPS is provided under the terms of the
<A HREF="LICENSE.html">GNU General Public License</A>
which is located in the files "LICENSE.html" and "LICENSE.txt". For commercial
support and "binary-only" licensing information, please contact:
<UL>
Attn: CUPS Licensing Information
<BR>Easy Software Products
<BR>44141 Airport View Drive, Suite 204
<BR>Hollywood, Maryland 20636-3111 USA
<P>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>
</UL>
<P>If you're interested in a complete, commercial printing solution for UNIX,
check out our ESP Print software at <A HREF="http://www.easysw.com/print.html">
http://www.easysw.com/print.html</A>.
</BODY>
</HTML>
+80 -226
Ver Arquivo
@@ -1,266 +1,120 @@
README - CUPS v1.1.3 - 09/18/2000
---------------------------------
README - CUPS v1.0b4
--------------------
CONTENTS
* Introduction
* Requirements
* Using CUPS
* Known Problems
* Reporting Problems
* Other Resources
* Legal Stuff
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
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),
Server Message Block (SMB), 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:
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 also includes a customized version of GNU GhostScript (currently based
off GNU GhostScript 4.03) and an image file RIP that can be used to support
non-PostScript printers.
SYSTEM REQUIREMENTS
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.
You'll need an ANSI C compiler to build CUPS on your system. As its name
implies, CUPS is designed to run on the UNIX operating system, however the
CUPS interface library and most of the filters and backends supplied with
CUPS should also run under Microsoft® Windows®.
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 CUPS
System Administrator's Manual in the files "doc/sam.html" or
"doc/sam.pdf".
For the image file filters you'll need the JPEG, PNG, TIFF, and ZLIB
libraries. CUPS will build without these, but with reduced functionality.
If you make changes to the man pages you'll need GNU groff or another
nroff-like package.
The documentation is formatted using the HTMLDOC software (again, not needed
unless you make changes.)
SOFTWARE REQUIREMENTS
USING CUPS
The following operating system software is required to install one of
the binary distributions from Easy Software Products:
Pre-compiled binary distributions are available for CUPS from our web site
at http://www.cups.org/software.html. If you'd like to build CUPS from the
source, please read the Software Administrator's Manual.
- Digital UNIX (aka OSF1 aka Compaq Tru64 UNIX) 4.0 or higher
- HP-UX 10.20 or higher
- IRIX 5.3 or higher
- Linux 2.0 with glibc2 or higher
- Solaris 2.5 or higher (SPARC or Intel)
Once you have installed CUPS, the Software Administrator's Manual and
Software User's Manual are excellent places to start setting things up.
INSTALLING "PORTABLE" CUPS DISTRIBUTIONS
KNOWN PROBLEMS
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:
The following known problems are being worked on and should be resolved for
the fourth beta release of CUPS:
http://www.easysw.com/epm
* Documentation is not completed.
* The lpc command currently only supports the help and status commands.
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.
CUPS has been built and tested on the following operating systems:
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:
* Digital UNIX 4.0d
* HP-UX 10.20 and 11.0
* IRIX 5.3, 6.2, 6.5.3
* Linux (RedHat 5.2)
* Solaris 2.5.1, 2.6, 2.7 (aka 7)
./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.
READING THE DOCUMENTATION
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.
Please read the documentation before asking questions.
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:
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.
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.
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.
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:
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/lp0 -E
HP-UX:
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/c2t0d0_lp -E
IRIX:
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/plp -E
Linux:
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/lp0 -E
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/lp1 -E
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/lp2 -E
Solaris:
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/bpp0 -E
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/ecpp0 -E
Similarly, for the other sample drivers you can use:
Driver PPD File
-------------------------- ------------
HP DeskJet Series deskjet.ppd
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
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:
lp filename
lpr filename
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.
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.
The client libraries and filters have been successfully compiled under
Microsoft Windows using Visual C++ 6.0.
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/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. Commercial support (with a guaranteed response
time) is available from Easy Software Products.
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.
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.
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-1999 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.
CUPS is provided under the terms of the GNU General Public License which is
located in the files "LICENSE.html" and "LICENSE.txt". For commercial
support and "binary-only" licensing information, please contact:
The PostScript RIP software (pstoraster) is based on the GNU
Ghostscript 5.50 core, Copyright 1986-1998 by Aladdin Enterprises.
Attn: CUPS Licensing Information
Easy Software Products
44141 Airport View Drive, Suite 204
Hollywood, Maryland 20636-3111 USA
The PDF filter (pdftops) is based on the Xpdf 0.90 software, Copyright
1996-1999 by Derek B. Noonburg.
Voice: +1.301.373.9603
Email: cups-info@cups.org
WWW: http://www.cups.org
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:
Attn: CUPS Licensing Information
Easy Software Products
44141 Airport View Drive, Suite 204
Hollywood, Maryland 20636-3111 USA
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.
If you're interested in a complete, commercial printing solution for UNIX,
check out our ESP Print software at http://www.easysw.com/print.html.
+25 -47
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Backend 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
@@ -24,10 +24,8 @@
include ../Makedefs
BACKENDS = ipp lpd parallel serial socket usb
TARGETS = betest $(BACKENDS)
OBJS = betest.o ipp.o lpd.o parallel.o serial.o socket.o usb.o
TARGETS = ipp lpd parallel serial smb socket
OBJS = ipp.o lpd.o parallel.o serial.o socket.o
#
# Make all targets...
@@ -35,107 +33,87 @@ OBJS = betest.o ipp.o lpd.o parallel.o serial.o socket.o usb.o
all: $(TARGETS)
#
# Clean all object files...
#
clean:
$(RM) $(OBJS) $(TARGETS) http
rm -f $(OBJS) $(TARGETS)
#
# Install all targets...
#
install:
-$(MKDIR) $(SERVERBIN)/backend
$(CHMOD) ugo+rx $(SERVERBIN)
$(CHMOD) ugo+rx $(SERVERBIN)/backend
$(INSTALL_BIN) $(BACKENDS) $(SERVERBIN)/backend
$(RM) $(SERVERBIN)/backend/http
$(LN) ipp $(SERVERBIN)/backend/http
#
# betest
#
betest: betest.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o betest betest.o $(LIBS)
betest.o: ../cups/string.h ../Makedefs
-$(MKDIR) $(SERVERROOT)/backend
$(CP) $(TARGETS) $(SERVERROOT)/backend
$(LN) ipp $(SERVERROOT)/backend/http
$(CHMOD) u+s $(SERVERROOT)/backend/lpd
#
# ipp
#
ipp: ipp.o ../cups/$(LIBCUPS)
ipp: ipp.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o ipp ipp.o $(LIBS)
$(RM) http
$(LN) ipp http
ipp.o: ../cups/cups.h ../Makedefs
#
# lpd
#
lpd: lpd.o ../cups/$(LIBCUPS)
lpd: lpd.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o lpd lpd.o $(LIBS)
lpd.o: ../cups/cups.h ../Makedefs
#
# parallel
#
parallel: parallel.o ../cups/$(LIBCUPS)
parallel: parallel.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o parallel parallel.o $(LIBS)
parallel.o: ../cups/cups.h ../Makedefs
#
# serial
#
serial: serial.o ../cups/$(LIBCUPS)
serial: serial.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o serial serial.o $(LIBS)
serial.o: ../cups/cups.h ../Makedefs
#
# smb
#
# Note: reading through these commands is a good way to get a headache... :)
#
smb: smb.sh ../Makedefs
echo Generating $@...
$(RM) smb
sedcmd="1,\$$s/^SMBCLIENT=.\*/SMBCLIENT=`echo $(SMBCLIENT) | sed -e '1,$$s/\\//\\\\\\//g'`/" ;\
$(SED) -e "$$sedcmd" <smb.sh >smb
$(CHMOD) +x smb
#
# socket
#
socket: socket.o ../cups/$(LIBCUPS)
socket: socket.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o socket socket.o $(LIBS)
socket.o: ../cups/cups.h ../Makedefs
#
# usb
#
usb: usb.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o usb usb.o $(LIBS)
usb.o: ../cups/cups.h ../Makedefs
#
# End of "$Id$".
#
-85
Ver Arquivo
@@ -1,85 +0,0 @@
/*
* "$Id$"
*
* Backend test program for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-2000 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
* copyright law. Distribution and use rights are outlined in the file
* "LICENSE" 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:
*
* main() - Run the named backend.
*/
/*
* Include necessary headers.
*/
#include <stdio.h>
#include <stdlib.h>
#include <cups/string.h>
#include <unistd.h>
/*
* 'main()' - Run the named backend.
*
* Usage:
*
* betest device-uri job-id user title copies options [file]
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments (7 or 8) */
char *argv[]) /* I - Command-line arguments */
{
char backend[255]; /* Method in URI */
if (argc < 7 || argc > 8)
{
fputs("Usage: betest device-uri job-id user title copies options [file]\n",
stderr);
return (1);
}
/*
* Extract the method from the device-uri - that's the program we want to
* execute.
*/
if (sscanf(argv[1], "%254[^:]", backend) != 1)
{
fputs("betest: Bad device-uri - no colon!\n", stderr);
return (1);
}
/*
* Execute and return
*/
execl(backend, argv[1], argv[2], argv[3], argv[4], argv[5], argv[6], argv[7],
NULL);
return (1);
}
/*
* End of "$Id$".
*/
+201 -424
Ver Arquivo
@@ -3,7 +3,7 @@
*
* IPP backend 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
@@ -23,7 +23,6 @@
*
* Contents:
*
* main() - Send a file to the printer or server.
*/
/*
@@ -38,7 +37,6 @@
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/string.h>
#include <signal.h>
/*
@@ -53,6 +51,11 @@ int /* O - Exit status */
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 */
@@ -64,39 +67,19 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
char password[255], /* Password info */
uri[HTTP_MAX_URI];/* Updated URI without user/pass */
http_status_t status; /* Status of HTTP job */
ipp_status_t ipp_status; /* Status of IPP request */
FILE *fp; /* File to print */
http_t *http; /* HTTP connection */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *job_id; /* job-id attribute */
ipp_attribute_t *copies_sup; /* copies-supported attribute */
cups_lang_t *language; /* Default language */
struct stat fileinfo; /* File statistics */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total bytes written */
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
s = argv[0];
printf("network %s \"Unknown\" \"Internet Printing Protocol\"\n", s);
return (0);
}
else if (argc < 6 || argc > 7)
if (argc < 6 || argc > 7)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
@@ -105,55 +88,18 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
/*
* If we have 7 arguments, print the file named on the command-line.
* Otherwise, copy stdin to a temporary file and print the temporary
* file.
* Otherwise, print stdin...
*/
if (argc == 6)
{
/*
* Copy stdin to a temporary file...
*/
FILE *fp; /* Temporary file */
char buffer[8192]; /* Buffer for copying */
int bytes; /* Number of bytes read */
if ((fp = fopen(cupsTempFile(filename, sizeof(filename)), "w")) == NULL)
{
perror("ERROR: unable to create temporary file");
return (1);
}
while ((bytes = fread(buffer, 1, sizeof(buffer), stdin)) > 0)
if (fwrite(buffer, 1, bytes, fp) < bytes)
{
perror("ERROR: unable to write to temporary file");
fclose(fp);
unlink(filename);
return (1);
}
fclose(fp);
}
else
{
strncpy(filename, argv[6], sizeof(filename) - 1);
filename[sizeof(filename) - 1] = '\0';
}
/*
* Open the print file...
*/
if ((fp = fopen(filename, "rb")) == NULL)
fp = stdin;
else if ((fp = fopen(argv[6], "rb")) == NULL)
{
perror("ERROR: Unable to open print file");
return (1);
}
else
stat(filename, &fileinfo);
stat(argv[6], &fileinfo);
/*
* Extract the hostname and printer name from the URI...
@@ -165,425 +111,254 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Try connecting to the remote server...
*/
do
{
fprintf(stderr, "INFO: Connecting to %s...\n", hostname);
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...",
hostname);
sleep(30);
}
else
{
perror("ERROR: Unable to connect to IPP host");
sleep(30);
}
}
if ((http = httpConnect(hostname, port)) == NULL)
{
perror("ERROR: Unable to connect to IPP host");
if (fp != stdin)
fclose(fp);
return (1);
}
while (http == NULL);
/*
* Build a URI for the printer and fill the standard IPP attributes for
* an IPP_PRINT_FILE request. We can't use the URI in argv[0] because it
* might contain username:password information...
* an IPP_PRINT_FILE request...
*/
snprintf(uri, sizeof(uri), "%s://%s:%d%s", method, hostname, port, resource);
request = ippNew();
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
sprintf(uri, "%s://%s:%d/%s", method, hostname, port, resource);
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 != NULL ? language->language : "C");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "requesting-user-name",
NULL, argv[2]);
ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "job-name", NULL, argv[3]);
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", atoi(argv[4]));
/*
* First validate the destination and see if the device supports multiple
* copies. We have to do this because some IPP servers (e.g. HP JetDirect)
* don't support the copies attribute...
* Handle options on the command-line...
*/
language = cupsLangDefault();
copies_sup = NULL;
version = 1;
options = NULL;
num_options = cupsParseOptions(argv[5], 0, &options);
do
if (cupsGetOption("raw", num_options, options))
ippAddString(request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
for (i = 0; i < num_options; i ++)
{
/*
* Build the IPP request...
* Skip the "raw" option - handled above...
*/
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");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language != NULL ? language->language : "en");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
if (strcmp(options[i].name, "raw") == 0)
continue;
/*
* Now fill in the HTTP request stuff...
* 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.
*/
httpClearFields(http);
httpSetField(http, HTTP_FIELD_CONTENT_TYPE, "application/ipp");
if (username[0])
option = options[i].name;
val = options[i].value;
if (*val == '\0')
val = NULL;
if (val != NULL)
{
httpEncode64(password, username);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, password);
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);
}
sprintf(buffer, "%u", ippLength(request));
httpSetField(http, HTTP_FIELD_CONTENT_LENGTH, buffer);
/*
* Do the request...
*/
for (;;)
else
{
/*
* POST the request, retrying as needed...
*/
if (httpPost(http, resource))
if (strncmp(option, "no", 2) == 0)
{
fputs("INFO: Unable to POST get-printer-attributes request; retrying...\n", stderr);
sleep(10);
httpReconnect(http);
continue;
}
fputs("INFO: POST successful, sending IPP request...\n", stderr);
/*
* Send the IPP request...
*/
request->state = IPP_IDLE;
if (ippWrite(http, request) == IPP_ERROR)
{
fputs("ERROR: Unable to send IPP request!\n", stderr);
status = HTTP_ERROR;
break;
}
fputs("INFO: IPP request sent, getting status...\n", stderr);
/*
* Finally, check the status from the HTTP server...
*/
while ((status = httpUpdate(http)) == HTTP_CONTINUE);
if (status == HTTP_OK)
{
response = ippNew();
ippRead(http, response);
ipp_status = response->request.status.status_code;
if (ipp_status > IPP_OK_CONFLICT)
{
if (ipp_status == IPP_PRINTER_BUSY ||
ipp_status == IPP_SERVICE_UNAVAILABLE)
{
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;
}
}
else if ((copies_sup = ippFindAttribute(response, "copies-supported",
IPP_TAG_RANGE)) != NULL)
{
/*
* Has the "copies-supported" attribute - does it have an upper
* bound > 1?
*/
if (copies_sup->values[0].range.upper <= 1)
copies_sup = NULL; /* No */
}
ippDelete(response);
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 == '-')
{
response = NULL;
if (status == HTTP_ERROR)
{
fprintf(stderr, "WARNING: Did not receive the IPP response (%d)\n",
errno);
status = HTTP_OK;
ipp_status = IPP_PRINTER_BUSY;
}
else
{
fprintf(stderr, "ERROR: Validate request was not accepted (%d)!\n",
status);
ipp_status = IPP_FORBIDDEN;
}
n2 = strtol(s + 1, NULL, 0);
ippAddRange(request, IPP_TAG_JOB, option, n, n2);
}
else if (*s == 'x')
{
n2 = strtol(s + 1, &s, 0);
httpFlush(http);
break;
if (strcmp(s, "dpc") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_CM, n, n2);
else if (strcmp(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);
}
if (status != HTTP_OK)
{
if (fp != stdin)
fclose(fp);
httpClose(http);
return (1);
}
else if (ipp_status > IPP_OK_CONFLICT)
httpReconnect(http);
else
/*
* Boolean value...
*/
ippAddBoolean(request, IPP_TAG_JOB, option, (char)n);
}
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...
* Now fill in the HTTP request stuff...
*/
#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));
httpClearFields(http);
httpSetField(http, HTTP_FIELD_CONTENT_TYPE, "application/ipp");
httpEncode64(password, username);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, password);
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...
*/
if (copies_sup)
copies = 1;
else
copies = atoi(argv[4]);
/*
* Then issue the print-job request...
*/
while (copies > 0)
if (fp != stdin)
{
/*
* Build the IPP request...
*/
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, "utf-8");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language != NULL ? language->language : "en");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
fprintf(stderr, "DEBUG: printer-uri = \"%s\"\n", uri);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, argv[2]);
fprintf(stderr, "DEBUG: requesting-user-name = \"%s\"\n", argv[2]);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL,
argv[3]);
fprintf(stderr, "DEBUG: job-name = \"%s\"\n", argv[3]);
/*
* Handle options on the command-line...
*/
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);
if (copies_sup)
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", atoi(argv[4]));
cupsEncodeOptions(request, num_options, options);
cupsFreeOptions(num_options, options);
/*
* Now fill in the HTTP request stuff...
*/
httpClearFields(http);
httpSetField(http, HTTP_FIELD_CONTENT_TYPE, "application/ipp");
if (username[0])
{
httpEncode64(password, username);
httpSetField(http, HTTP_FIELD_AUTHORIZATION, password);
}
sprintf(buffer, "%u", ippLength(request) + (size_t)fileinfo.st_size);
httpSetField(http, HTTP_FIELD_CONTENT_LENGTH, buffer);
}
/*
* Do the request...
*/
for (;;)
{
/*
* Do the request...
* POST the request, retrying as needed...
*/
for (;;)
{
/*
* POST the request, retrying as needed...
*/
httpReconnect(http);
if (httpPost(http, resource))
if (httpPost(http, resource))
{
fputs("INFO: Unable to POST print request; retrying...\n", stderr);
fputs("INFO: Unable to POST print request; retrying...\n", stderr);
sleep(10);
continue;
}
fputs("INFO: POST successful, sending IPP request...\n", stderr);
/*
* Send the IPP request...
*/
/*
* Send the IPP request...
*/
request->state = IPP_IDLE;
request->state = IPP_IDLE;
if (ippWrite(http, request) != IPP_OK)
{
fputs("ERROR: Unable to send IPP request; retrying...\n", stderr);
status = HTTP_ERROR;
break;
}
if (ippWrite(http, request) == IPP_ERROR)
/*
* Then send the file...
*/
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
tbytes += nbytes;
fprintf(stderr, "INFO: Sending print file, %uk...\n", tbytes / 1024);
if (httpWrite(http, buffer, nbytes) < nbytes)
{
fputs("ERROR: Unable to send IPP request!\n", stderr);
perror("ERROR: Unable to send print file to printer");
status = HTTP_ERROR;
break;
break;
}
}
fputs("INFO: IPP request sent, sending print file...\n", stderr);
httpWrite(http, buffer, 0);
/*
* Then send the file...
*/
/*
* Finally, check the status from the HTTP server...
*/
rewind(fp);
while ((status = httpUpdate(http)) == HTTP_CONTINUE);
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
tbytes += nbytes;
fprintf(stderr, "INFO: Sending print file, %uk...\n", tbytes / 1024);
if (status == HTTP_OK)
{
response = ippNew();
ippRead(http, response);
if (httpWrite(http, buffer, nbytes) < nbytes)
{
perror("ERROR: Unable to send print file to printer");
status = HTTP_ERROR;
break;
}
}
fputs("INFO: Print file sent; checking status...\n", stderr);
/*
* Finally, check the status from the HTTP server...
*/
while ((status = httpUpdate(http)) == HTTP_CONTINUE);
if (status == HTTP_OK)
{
response = ippNew();
ippRead(http, response);
if ((ipp_status = response->request.status.status_code) > IPP_OK_CONFLICT)
{
if (ipp_status == IPP_SERVICE_UNAVAILABLE ||
ipp_status == IPP_PRINTER_BUSY)
{
fputs("INFO: Printer is busy; retrying print job...\n", stderr);
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);
else
fprintf(stderr, "INFO: Print file accepted - job ID %d.\n",
job_id->values[0].integer);
}
if (response->request.status.status_code > IPP_OK_CONFLICT)
fprintf(stderr, "ERROR: Print file was not accepted (%04x)!\n",
response->request.status.status_code);
else if ((job_id = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) == NULL)
fputs("INFO: Print file accepted - job ID unknown.\n", stderr);
else
{
response = NULL;
ipp_status = IPP_PRINTER_BUSY;
if (status == HTTP_ERROR)
{
fprintf(stderr, "WARNING: Did not receive the IPP response (%d)\n",
errno);
status = HTTP_OK;
}
else
fprintf(stderr, "ERROR: Print request was not accepted (%d)!\n", status);
}
fprintf(stderr, "INFO: Print file accepted - job ID %d.\n",
job_id->values[0].integer);
}
else
{
response = NULL;
httpFlush(http);
break;
fprintf(stderr, "ERROR: Print request was not accepted (%d)!\n", status);
}
if (request != NULL)
ippDelete(request);
if (response != NULL)
ippDelete(response);
if (ipp_status <= IPP_OK_CONFLICT)
{
fprintf(stderr, "PAGE: 1 %d\n", copies_sup ? atoi(argv[4]) : 1);
copies --;
}
else if (ipp_status != IPP_SERVICE_UNAVAILABLE &&
ipp_status != IPP_PRINTER_BUSY)
break;
break;
}
/*
@@ -591,15 +366,17 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
httpClose(http);
if (request != NULL)
ippDelete(request);
if (response != NULL)
ippDelete(response);
/*
* Close and remove the temporary file if necessary...
* Close the print file as needed...
*/
fclose(fp);
if (argc < 7)
unlink(filename);
if (fp != stdin)
fclose(fp);
/*
* Return the queue status...
+19 -162
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Line Printer Daemon backend 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
@@ -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,23 +78,12 @@ 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)
{
puts("network lpd \"Unknown\" \"LPD/LPR Host or Printer\"");
return (0);
}
else if (argc < 6 || argc > 7)
if (argc < 6 || argc > 7)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
@@ -120,7 +107,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
int bytes; /* Number of bytes read */
if ((fp = fopen(cupsTempFile(filename, sizeof(filename)), "w")) == NULL)
if ((fp = fopen(tmpnam(filename), "w")) == NULL)
{
perror("ERROR: unable to create temporary file");
return (1);
@@ -138,10 +125,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fclose(fp);
}
else
{
strncpy(filename, argv[6], sizeof(filename) - 1);
filename[sizeof(filename) - 1] = '\0';
}
strcpy(filename, argv[6]);
/*
* Extract the hostname and printer name from the URI...
@@ -149,100 +133,12 @@ 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...
*/
if (argc > 6)
{
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, argv[3] /* title */,
atoi(argv[4]) /* copies */, banner, format);
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);
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, atoi(argv[4]) /* copies */);
/*
* Remove the temporary file if necessary...
@@ -279,17 +175,15 @@ lpd_command(int fd, /* I - Socket connection to LPD host */
*/
va_start(ap, format);
bytes = vsnprintf(buf, sizeof(buf), format, ap);
bytes = vsprintf(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 +191,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 +209,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 +225,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 */
/*
@@ -364,9 +250,8 @@ lpd_queue(char *hostname, /* I - Host to connect to */
{
if ((fd = rresvport(&port)) < 0)
{
perror("ERROR: Unable to reserve port");
sleep(30);
continue;
perror("ERROR: Unable to connect to printer");
return (1);
}
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
@@ -390,33 +275,13 @@ lpd_queue(char *hostname, /* I - Host to connect to */
else
{
perror("ERROR: Unable to connect to printer");
sleep(30);
return (1);
}
}
else
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,27 +308,19 @@ 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);
sprintf(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,
getpid() % 1000, localhost);
sprintf(cptr, "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",
getpid() % 1000, localhost,
getpid() % 1000, localhost);
sprintf(cptr, "UdfA%03.3d%s\nNdfA%03.3d%s\n",
getpid() % 1000, localhost,
getpid() % 1000, localhost);
fprintf(stderr, "DEBUG: Control file is:\n%s", control);
@@ -488,7 +345,7 @@ lpd_queue(char *hostname, /* I - Host to connect to */
fputs("INFO: Control file sent successfully\n", stderr);
lpd_command(fd, "\003%u dfA%03.3d%s\n", (unsigned)filestats.st_size,
lpd_command(fd, "\003%d dfA%03.3d%s\n", filestats.st_size,
getpid() % 1000, localhost);
fprintf(stderr, "INFO: Sending data file (%u bytes)\n",
+21 -429
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Parallel port backend 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
@@ -23,8 +23,7 @@
*
* Contents:
*
* main() - Send a file to the specified parallel port.
* list_devices() - List all parallel devices.
* main() - Send a file to the specified parallel port.
*/
/*
@@ -34,9 +33,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>
@@ -46,24 +43,6 @@
# include <termios.h>
#endif /* WIN32 || __EMX__ */
#ifdef __sgi
# include <invent.h>
# ifndef INV_EPP_ECP_PLP
# define INV_EPP_ECP_PLP 6 /* From 6.3/6.4/6.5 sys/invent.h */
# define INV_ASO_SERIAL 14 /* serial portion of SGI ASO board */
# define INV_IOC3_DMA 16 /* DMA mode IOC3 serial */
# define INV_IOC3_PIO 17 /* PIO mode IOC3 serial */
# define INV_ISA_DMA 19 /* DMA mode ISA serial -- O2 */
# endif /* !INV_EPP_ECP_PLP */
#endif /* __sgi */
/*
* Local functions...
*/
void list_devices(void);
/*
* 'main()' - Send a file to the specified parallel port.
@@ -84,25 +63,15 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*options; /* Pointer to options */
int port; /* Port number (not used) */
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 */
int error; /* Error code (if any) */
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)
{
list_devices();
return (0);
}
else if (argc < 6 || argc > 7)
if (argc < 6 || argc > 7)
{
fputs("Usage: parallel job-id user title copies options [file]\n", stderr);
return (1);
@@ -114,10 +83,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
if (argc == 6)
{
fp = stdin;
copies = 1;
}
fp = stdin;
else
{
/*
@@ -129,8 +95,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
perror("ERROR: unable to open print file");
return (1);
}
copies = atoi(argv[4]);
}
/*
@@ -157,23 +121,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,67 +139,27 @@ 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...
*/
while (copies > 0)
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
copies --;
/*
* Write the print data to the printer...
*/
if (fp != stdin)
if (write(fd, buffer, nbytes) < nbytes)
{
fputs("PAGE: 1 1\n", stderr);
rewind(fp);
perror("ERROR: Unable to send print file to printer");
break;
}
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
/*
* Write the print data to the printer...
*/
else
tbytes += nbytes;
bufptr = buffer;
while (nbytes > 0)
{
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;
}
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
/*
@@ -262,326 +174,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
}
/*
* 'list_devices()' - List all parallel devices.
*/
void
list_devices(void)
{
static char *funky_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
/* Funky hex numbering used for some devices */
#ifdef __linux
int i; /* Looping var */
int fd; /* File descriptor */
char device[255], /* Device filename */
probefile[255]; /* Probe filename */
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 */
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, "/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");
while (fgets(line, sizeof(line), probe) != NULL)
{
/*
* Strip trailing ; and/or newline.
*/
if ((delim = strrchr(line, ';')) != NULL)
*delim = '\0';
else if ((delim = strrchr(line, '\n')) != NULL)
*delim = '\0';
/*
* Look for MODEL and MANUFACTURER lines...
*/
if (strncmp(line, "MODEL:", 6) == 0 &&
strncmp(line, "MODEL:Unknown", 13) != 0)
strncpy(model, line + 6, sizeof(model) - 1);
else if (strncmp(line, "MANUFACTURER:", 13) == 0 &&
strncmp(line, "MANUFACTURER:Unknown", 20) != 0)
strncpy(make, line + 13, sizeof(make) - 1);
}
fclose(probe);
if (make[0])
printf("direct parallel:/dev/lp%d \"%s %s\" \"Parallel Port #%d\"\n",
i, make, model, i + 1);
else
printf("direct parallel:/dev/lp%d \"%s\" \"Parallel Port #%d\"\n",
i, model, i + 1);
}
else if (fd >= 0)
{
/*
* No probe file, but we know the port is there...
*/
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
}
#elif defined(__sgi)
int i, j, n; /* Looping vars */
char device[255]; /* Device filename */
inventory_t *inv; /* Hardware inventory info */
/*
* IRIX maintains a hardware inventory of most devices...
*/
setinvent();
while ((inv = getinvent()) != NULL)
{
if (inv->inv_class == INV_PARALLEL &&
(inv->inv_type == INV_ONBOARD_PLP ||
inv->inv_type == INV_EPP_ECP_PLP))
{
/*
* Standard parallel port...
*/
puts("direct parallel:/dev/plp \"Unknown\" \"Onboard Parallel Port\"");
}
else if (inv->inv_class == INV_PARALLEL &&
inv->inv_type == INV_EPC_PLP)
{
/*
* EPC parallel port...
*/
printf("direct parallel:/dev/plp%d \"Unknown\" \"Integral EPC parallel port, Ebus slot %d\"\n",
inv->inv_controller, inv->inv_controller);
}
}
endinvent();
/*
* Central Data makes serial and parallel "servers" that can be
* connected in a number of ways. Look for ports...
*/
for (i = 0; i < 10; i ++)
for (j = 0; j < 8; j ++)
for (n = 0; n < 32; n ++)
{
if (i == 8) /* EtherLite */
sprintf(device, "/dev/lpn%d%c", j, funky_hex[n]);
else if (i == 9) /* PCI */
sprintf(device, "/dev/lpp%d%c", j, funky_hex[n]);
else /* SCSI */
sprintf(device, "/dev/lp%d%d%c", i, j, funky_hex[n]);
if (access(device, 0) == 0)
{
if (i == 8)
printf("direct parallel:%s \"Unknown\" \"Central Data EtherLite Parallel Port, ID %d, port %d\"\n",
device, j, n);
else if (i == 9)
printf("direct parallel:%s \"Unknown\" \"Central Data PCI Parallel Port, ID %d, port %d\"\n",
device, j, n);
else
printf("direct parallel:%s \"Unknown\" \"Central Data SCSI Parallel Port, logical bus %d, ID %d, port %d\"\n",
device, i, j, n);
}
}
#elif defined(__sun)
int i, j, n; /* Looping vars */
char device[255]; /* Device filename */
/*
* Standard parallel ports...
*/
for (i = 0; i < 10; i ++)
{
sprintf(device, "/dev/ecpp%d", i);
if (access(device, 0) == 0)
printf("direct parallel:%s \"Unknown\" \"Sun IEEE-1284 Parallel Port #%d\"\n",
device, i + 1);
}
for (i = 0; i < 10; i ++)
{
sprintf(device, "/dev/bpp%d", i);
if (access(device, 0) == 0)
printf("direct parallel:%s \"Unknown\" \"Sun Standard Parallel Port #%d\"\n",
device, i + 1);
}
for (i = 0; i < 3; i ++)
{
sprintf(device, "/dev/lp%d", i);
if (access(device, 0) == 0)
printf("direct parallel:%s \"Unknown\" \"PC Parallel Port #%d\"\n",
device, i + 1);
}
/*
* MAGMA parallel ports...
*/
for (i = 0; i < 40; i ++)
{
sprintf(device, "/dev/pm%02d", i);
if (access(device, 0) == 0)
printf("direct parallel:%s \"Unknown\" \"MAGMA Parallel Board #%d Port #%d\"\n",
device, (i / 10) + 1, (i % 10) + 1);
}
/*
* Central Data parallel ports...
*/
for (i = 0; i < 9; i ++)
for (j = 0; j < 8; j ++)
for (n = 0; n < 32; n ++)
{
if (i == 8) /* EtherLite */
sprintf(device, "/dev/sts/lpN%d%c", j, funky_hex[n]);
else
sprintf(device, "/dev/sts/lp%c%d%c", i + 'C', j,
funky_hex[n]);
if (access(device, 0) == 0)
{
if (i == 8)
printf("direct parallel:%s \"Unknown\" \"Central Data EtherLite Parallel Port, ID %d, port %d\"\n",
device, j, n);
else
printf("direct parallel:%s \"Unknown\" \"Central Data SCSI Parallel Port, logical bus %d, ID %d, port %d\"\n",
device, i, j, n);
}
}
#elif defined(__hpux)
int i, j, n; /* Looping vars */
char device[255]; /* Device filename */
/*
* Standard parallel ports...
*/
if (access("/dev/rlp", 0) == 0)
puts("direct parallel:/dev/rlp \"Unknown\" \"Standard Parallel Port (/dev/rlp)\"");
for (i = 0; i < 7; i ++)
for (j = 0; j < 7; j ++)
{
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);
}
/*
* Central Data parallel ports...
*/
for (i = 0; i < 9; i ++)
for (j = 0; j < 8; j ++)
for (n = 0; n < 32; n ++)
{
if (i == 8) /* EtherLite */
sprintf(device, "/dev/lpN%d%c", j, funky_hex[n]);
else
sprintf(device, "/dev/lp%c%d%c", i + 'C', j,
funky_hex[n]);
if (access(device, 0) == 0)
{
if (i == 8)
printf("direct parallel:%s \"Unknown\" \"Central Data EtherLite Parallel Port, ID %d, port %d\"\n",
device, j, n);
else
printf("direct parallel:%s \"Unknown\" \"Central Data SCSI Parallel Port, logical bus %d, ID %d, port %d\"\n",
device, i, j, n);
}
}
#elif defined(__osf__)
int i; /* Looping var */
int fd; /* File descriptor */
char device[255]; /* Device filename */
for (i = 0; i < 3; i ++)
{
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);
}
}
#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/lpt%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
}
#endif
}
/*
* End of "$Id$".
*/
+22 -430
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Serial port backend 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
@@ -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,9 +33,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>
@@ -46,24 +43,6 @@
# include <termios.h>
#endif /* WIN32 || __EMX__ */
#ifdef __sgi
# include <invent.h>
# ifndef INV_EPP_ECP_PLP
# define INV_EPP_ECP_PLP 6 /* From 6.3/6.4/6.5 sys/invent.h */
# define INV_ASO_SERIAL 14 /* serial portion of SGI ASO board */
# define INV_IOC3_DMA 16 /* DMA mode IOC3 serial */
# define INV_IOC3_PIO 17 /* PIO mode IOC3 serial */
# define INV_ISA_DMA 19 /* DMA mode ISA serial -- O2 */
# endif /* !INV_EPP_ECP_PLP */
#endif /* __sgi */
/*
* Local functions...
*/
void list_devices(void);
/*
* 'main()' - Send a file to the printer or server.
@@ -87,25 +66,15 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*ptr; /* Pointer into name or value */
int port; /* Port number (not used) */
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 */
int error; /* Error code (if any) */
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)
{
list_devices();
return (0);
}
else if (argc < 6 || argc > 7)
if (argc < 6 || argc > 7)
{
fputs("Usage: serial job-id user title copies options [file]\n", stderr);
return (1);
@@ -117,10 +86,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
if (argc == 6)
{
fp = stdin;
copies = 1;
}
fp = stdin;
else
{
/*
@@ -132,8 +98,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
perror("ERROR: unable to open print file");
return (1);
}
copies = atoi(argv[4]);
}
/*
@@ -157,26 +121,14 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
}
/*
* Open the serial port device...
* Open the parallel port device...
*/
do
if ((fd = open(resource, O_WRONLY)) == -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...
@@ -305,67 +257,27 @@ 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...
*/
while (copies > 0)
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
copies --;
/*
* Write the print data to the printer...
*/
if (fp != stdin)
if (write(fd, buffer, nbytes) < nbytes)
{
fputs("PAGE: 1 1\n", stderr);
rewind(fp);
perror("ERROR: Unable to send print file to printer");
break;
}
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
/*
* Write the print data to the printer...
*/
else
tbytes += nbytes;
bufptr = buffer;
while (nbytes > 0)
{
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;
}
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
/*
@@ -380,326 +292,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
}
/*
* 'list_devices()' - List all serial devices.
*/
void
list_devices(void)
{
static char *funky_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
/* Funky hex numbering used for some devices */
#ifdef __linux
int i; /* Looping var */
int fd; /* File descriptor */
char device[255]; /* Device filename */
for (i = 0; i < 100; i ++)
{
sprintf(device, "/dev/ttyS%d", i);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
}
}
#elif defined(__sgi)
int i, j, n; /* Looping vars */
char device[255]; /* Device filename */
inventory_t *inv; /* Hardware inventory info */
/*
* IRIX maintains a hardware inventory of most devices...
*/
setinvent();
while ((inv = getinvent()) != NULL)
{
if (inv->inv_class == INV_SERIAL)
{
/*
* Some sort of serial port...
*/
if (inv->inv_type == INV_CDSIO || inv->inv_type == INV_CDSIO_E)
{
/*
* CDSIO port...
*/
for (n = 0; n < 6; n ++)
printf("serial serial:/dev/ttyd%d?baud=19200 \"Unknown\" \"CDSIO Board %d Serial Port #%d\"\n",
n + 5 + 8 * inv->inv_controller, inv->inv_controller, n + 1);
}
else if (inv->inv_type == INV_EPC_SERIAL)
{
/*
* Everest serial port...
*/
if (inv->inv_unit == 0)
i = 1;
else
i = 41 + 4 * (int)inv->inv_controller;
for (n = 0; n < (int)inv->inv_state; n ++)
printf("serial serial:/dev/ttyd%d?baud=19200 \"Unknown\" \"EPC Serial Port %d, Ebus slot %d\"\n",
n + i, n + 1, (int)inv->inv_controller);
}
else if (inv->inv_state > 1)
{
/*
* Standard serial port under IRIX 6.4 and earlier...
*/
for (n = 0; n < (int)inv->inv_state; n ++)
printf("serial serial:/dev/ttyd%d?baud=19200 \"Unknown\" \"Onboard Serial Port %d\"\n",
n + (int)inv->inv_unit + 1, n + (int)inv->inv_unit + 1);
}
else
{
/*
* Standard serial port under IRIX 6.5 and beyond...
*/
printf("serial serial:/dev/ttyd%d?baud=115200 \"Unknown\" \"Onboard Serial Port %d\"\n",
(int)inv->inv_controller, (int)inv->inv_controller);
}
}
}
endinvent();
/*
* Central Data makes serial and parallel "servers" that can be
* connected in a number of ways. Look for ports...
*/
for (i = 0; i < 10; i ++)
for (j = 0; j < 8; j ++)
for (n = 0; n < 32; n ++)
{
if (i == 8) /* EtherLite */
sprintf(device, "/dev/ttydn%d%c", j, funky_hex[n]);
else if (i == 9) /* PCI */
sprintf(device, "/dev/ttydp%d%c", j, funky_hex[n]);
else /* SCSI */
sprintf(device, "/dev/ttyd%d%d%c", i, j, funky_hex[n]);
if (access(device, 0) == 0)
{
if (i == 8)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
device, j, n);
else if (i == 9)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data PCI Serial Port, ID %d, port %d\"\n",
device, j, n);
else
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
device, i, j, n);
}
}
#elif defined(__sun)
int i, j, n; /* Looping vars */
char device[255]; /* Device filename */
/*
* Standard serial ports...
*/
for (i = 0; i < 26; i ++)
{
sprintf(device, "/dev/cua/%c", 'a' + i);
if (access(device, 0) == 0)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
}
/*
* MAGMA serial ports...
*/
for (i = 0; i < 40; i ++)
{
sprintf(device, "/dev/term/%02d", i);
if (access(device, 0) == 0)
printf("serial serial:%s?baud=38400 \"Unknown\" \"MAGMA Serial Board #%d Port #%d\"\n",
device, (i / 10) + 1, (i % 10) + 1);
}
/*
* Central Data serial ports...
*/
for (i = 0; i < 9; i ++)
for (j = 0; j < 8; j ++)
for (n = 0; n < 32; n ++)
{
if (i == 8) /* EtherLite */
sprintf(device, "/dev/sts/ttyN%d%c", j, funky_hex[n]);
else
sprintf(device, "/dev/sts/tty%c%d%c", i + 'C', j,
funky_hex[n]);
if (access(device, 0) == 0)
{
if (i == 8)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
device, j, n);
else
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
device, i, j, n);
}
}
#elif defined(__hpux)
int i, j, n; /* Looping vars */
char device[255]; /* Device filename */
/*
* Standard serial ports...
*/
for (i = 0; i < 10; i ++)
{
sprintf(device, "/dev/tty%dp0", i);
if (access(device, 0) == 0)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
}
/*
* Central Data serial ports...
*/
for (i = 0; i < 9; i ++)
for (j = 0; j < 8; j ++)
for (n = 0; n < 32; n ++)
{
if (i == 8) /* EtherLite */
sprintf(device, "/dev/ttyN%d%c", j, funky_hex[n]);
else
sprintf(device, "/dev/tty%c%d%c", i + 'C', j,
funky_hex[n]);
if (access(device, 0) == 0)
{
if (i == 8)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
device, j, n);
else
printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
device, i, j, n);
}
}
#elif defined(__osf__)
int i; /* Looping var */
char device[255]; /* Device filename */
/*
* Standard serial ports...
*/
for (i = 0; i < 100; i ++)
{
sprintf(device, "/dev/tty%02d", i);
if (access(device, 0) == 0)
printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
device, i + 1);
}
#elif defined(FreeBSD) || defined(OpenBSD) || defined(NetBSD)
int i, j; /* Looping vars */
int fd; /* File descriptor */
char device[255]; /* Device filename */
/*
* SIO ports...
*/
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)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Standard Serial Port #%d\"\n",
device, i + 1);
}
}
/*
* Cyclades ports...
*/
for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
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)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Port #%d\"\n",
device, i, j + 1);
}
}
/*
* Digiboard ports...
*/
for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
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)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Digiboard #%d Serial Port #%d\"\n",
device, i, j + 1);
}
}
/*
* Stallion ports...
*/
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)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"Stallion Serial Port #%d\"\n",
device, i + 1);
}
}
/*
* SX ports...
*/
for (i = 0; i < 128; i ++)
{
sprintf(device, "/dev/ttyA%d", i + 1);
if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"SX Serial Port #%d\"\n",
device, i + 1);
}
}
#endif
}
/*
* End of "$Id$".
*/
Arquivo executável
+88
Ver Arquivo
@@ -0,0 +1,88 @@
#!/bin/sh
#
# "$Id$"
#
# SMB printing script for the Common UNIX Printing System (CUPS).
#
# Copyright 1993-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
# 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
# 44145 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
# EMail: cups-info@cups.org
# WWW: http://www.cups.org
#
SMBCLIENT=/usr/local/samba/bin/smbclient
#
# Usage:
#
# printer job user title copies options [filename]
#
if [ $# -lt 5 -o $# -gt 6 ]; then
# Too few or too many arguments
echo 'Usage: smb job-id user title copies options [file]' >&2
exit 1
fi
#
# If "filename" is not on the command-line, then we read the print
# data from stdin and write it to a temporary file.
#
if [ $# = 5 ]; then
# Collect all print data and put it in a temporary file...
if [ "$TMPDIR" = "" ]; then
TMPDIR=/var/tmp
fi
filename="$TMPDIR/$$.smb"
cat >$filename
else
# Use the file on the command-line...
filename="$6"
fi
#
# Take apart the URI in $0...
#
uri="$0"
host=`echo $uri | awk -F/ '{print substr($3, index($3, "@") + 1)}'`
user=`echo $uri | awk -F/ '{print substr($3, 0, index($3, "@") - 1)}'`
if [ "$user" != "" ]; then
user="-U $user"
fi
printer=`echo $uri | awk -F/ '{print $4}'`
#
# Send the file to the remote system...
#
$SMBCLIENT //$host/$printer $user -P -N <<EOF
print $filename
EOF
#
# Lastly, remove the temporary file as needed...
#
if [ $# = 5 ]; then
rm -f $filename
fi
#
# End of "$Id$".
#
+74 -123
Ver Arquivo
@@ -3,7 +3,7 @@
*
* AppSocket backend 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
@@ -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>
@@ -67,7 +66,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
username[255], /* Username info (not used) */
resource[1024]; /* Resource info (not used) */
FILE *fp; /* Print file */
int copies; /* Number of copies to print */
int port; /* Port number */
int fd; /* AppSocket */
int error; /* Error code (if any) */
@@ -80,17 +78,9 @@ 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)
{
puts("network socket \"Unknown\" \"AppSocket/HP JetDirect\"");
return (0);
}
else if (argc < 6 || argc > 7)
if (argc < 6 || argc > 7)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
@@ -103,10 +93,7 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
if (argc == 6)
{
fp = stdin;
copies = 1;
}
fp = stdin;
else
{
/*
@@ -118,8 +105,6 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
perror("ERROR: unable to open print file");
return (1);
}
copies = atoi(argv[4]);
}
/*
@@ -150,125 +135,91 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
addr.sin_family = hostaddr->h_addrtype;
addr.sin_port = htons(port);
while (copies > 0)
for (;;)
{
for (;;)
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
perror("ERROR: Unable to create socket");
return (1);
}
perror("ERROR: Unable to connect to printer");
return (1);
}
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
error = errno;
close(fd);
fd = -1;
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
{
error = errno;
close(fd);
fd = -1;
if (error == ECONNREFUSED)
{
fprintf(stderr, "INFO: Network host \'%s\' is busy; will retry in 30 seconds...\n",
hostname);
sleep(30);
}
else
{
perror("ERROR: Unable to connect to printer");
sleep(30);
}
if (error == ECONNREFUSED)
{
fprintf(stderr, "INFO: Network host \'%s\' is busy; will retry in 30 seconds...\n",
hostname);
sleep(30);
}
else
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...
*/
copies --;
if (fp != stdin)
{
fputs("PAGE: 1 1\n", stderr);
rewind(fp);
}
fputs("INFO: Connected to host, sending print job...\n", stderr);
tbytes = 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 ((wbytes = send(fd, bufptr, nbytes, 0)) < 0)
{
perror("ERROR: Unable to send print file to printer");
break;
}
nbytes -= wbytes;
bufptr += wbytes;
perror("ERROR: Unable to connect to printer");
return (1);
}
/*
* Check for possible data coming back from the printer...
*/
timeout.tv_sec = 0;
timeout.tv_usec = 0;
FD_ZERO(&input);
FD_SET(fd, &input);
if (select(fd + 1, &input, NULL, NULL, &timeout) > 0)
{
/*
* Grab the data coming back and spit it out to stderr...
*/
if ((nbytes = recv(fd, buffer, sizeof(buffer), 0)) > 0)
fprintf(stderr, "INFO: Received %u bytes of back-channel data!\n",
nbytes);
}
else if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
/*
* Close the socket connection...
*/
close(fd);
else
break;
}
/*
* Close the input file and return...
* Finally, send the print file...
*/
fputs("INFO: Connected to host, sending print job...\n", stderr);
tbytes = 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 ((wbytes = send(fd, bufptr, nbytes, 0)) < 0)
{
perror("ERROR: Unable to send print file to printer");
break;
}
nbytes -= wbytes;
bufptr += wbytes;
}
/*
* Check for possible data coming back from the printer...
*/
timeout.tv_sec = 0;
timeout.tv_usec = 0;
FD_ZERO(&input);
FD_SET(fd, &input);
if (select(fd + 1, &input, NULL, NULL, &timeout) > 0)
{
/*
* Grab the data coming back and spit it out to stderr...
*/
if ((nbytes = recv(fd, buffer, sizeof(buffer), 0)) > 0)
fprintf(stderr, "INFO: Received %u bytes of back-channel data!\n",
nbytes);
}
else if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
/*
* Close the socket connection and input file and return...
*/
close(fd);
if (fp != stdin)
fclose(fp);
-393
Ver Arquivo
@@ -1,393 +0,0 @@
/*
* "$Id$"
*
* USB port backend for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-2000 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
* copyright law. Distribution and use rights are outlined in the file
* "LICENSE" 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:
*
* main() - Send a file to the specified USB port.
* list_devices() - List all USB devices.
*/
/*
* Include necessary headers.
*/
#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>
#else
# include <unistd.h>
# include <fcntl.h>
# include <termios.h>
#endif /* WIN32 || __EMX__ */
/*
* Local functions...
*/
void list_devices(void);
/*
* 'main()' - Send a file to the specified USB port.
*
* Usage:
*
* printer-uri job-id user title copies options [file]
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments (6 or 7) */
char *argv[]) /* I - Command-line arguments */
{
char method[255], /* Method in URI */
hostname[1024], /* Hostname */
username[255], /* Username info (not used) */
resource[1024], /* Resource info (device and options) */
*options; /* Pointer to options */
int port; /* Port number (not used) */
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 */
tbytes; /* Total number of bytes written */
char buffer[8192], /* Output buffer */
*bufptr; /* Pointer into 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)
{
list_devices();
return (0);
}
else if (argc < 6 || argc > 7)
{
fputs("Usage: USB job-id user title copies options [file]\n", stderr);
return (1);
}
/*
* If we have 7 arguments, print the file named on the command-line.
* Otherwise, send stdin instead...
*/
if (argc == 6)
{
fp = stdin;
copies = 1;
}
else
{
/*
* Try to open the print file...
*/
if ((fp = fopen(argv[6], "rb")) == NULL)
{
perror("ERROR: unable to open print file");
return (1);
}
copies = atoi(argv[4]);
}
/*
* Extract the device name and options from the URI...
*/
httpSeparate(argv[0], method, username, hostname, &port, resource);
/*
* See if there are any options...
*/
if ((options = strchr(resource, '?')) != NULL)
{
/*
* Yup, terminate the device name string and move to the first
* character of the options...
*/
*options++ = '\0';
}
/*
* Open the USB port device...
*/
do
{
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);
}
}
}
while (fd < 0);
/*
* Set any options provided...
*/
tcgetattr(fd, &opts);
opts.c_lflag &= ~(ICANON | ECHO | ISIG); /* Raw mode */
/**** No options supported yet ****/
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...
*/
while (copies > 0)
{
copies --;
if (fp != stdin)
{
fputs("PAGE: 1 1\n", stderr);
rewind(fp);
}
tbytes = 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 ((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;
}
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
}
/*
* Close the socket connection and input file and return...
*/
close(fd);
if (fp != stdin)
fclose(fp);
return (0);
}
/*
* 'list_devices()' - List all USB devices.
*/
void
list_devices(void)
{
#ifdef __linux
int i; /* Looping var */
int fd; /* File descriptor */
char device[255]; /* Device filename */
FILE *probe; /* /proc/bus/usb/devices 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/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));
memset(model, 0, sizeof(model));
while (fgets(line, sizeof(line), probe) != NULL)
{
/*
* Strip trailing newline.
*/
if ((delim = strrchr(line, '\n')) != NULL)
*delim = '\0';
/*
* See if it is a printer device ("P: ...")
*/
if (strncmp(line, "S:", 2) == 0)
{
/*
* String attribute...
*/
if (strncmp(line, "S: Manufacturer=", 17) == 0)
{
strncpy(make, line + 17, sizeof(make) - 1);
if (strcmp(make, "Hewlett-Packard") == 0)
strcpy(make, "HP");
}
else if (strncmp(line, "S: Product=", 12) == 0)
strncpy(model, line + 12, sizeof(model) - 1);
}
else if (strncmp(line, "I:", 2) == 0 &&
(strstr(line, "Driver=printer") != NULL ||
strstr(line, "Driver=usblp") != NULL) &&
make[0] && model[0])
{
/*
* We were processing a printer device; send the info out...
*/
printf("direct usb:/dev/usb/lp%d \"%s %s\" \"USB Printer #%d\"\n",
i, make, model, i + 1);
i ++;
memset(make, 0, sizeof(make));
memset(model, 0, sizeof(model));
}
}
fclose(probe);
}
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/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);
}
}
#endif
}
/*
* End of "$Id$".
*/
+8 -18
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Berkeley commands 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
@@ -27,21 +27,18 @@ 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...
#
clean:
$(RM) $(OBJS) $(TARGETS)
rm -f $(OBJS) $(TARGETS)
#
# Install all targets...
@@ -49,57 +46,50 @@ clean:
install:
-$(MKDIR) $(BINDIR)
$(CHMOD) ugo+rx $(BINDIR)
$(INSTALL_BIN) lpq lpr lprm $(BINDIR)
-$(MKDIR) $(SBINDIR)
$(CHMOD) ugo+rx $(SBINDIR)
$(INSTALL_BIN) lpc $(SBINDIR)
$(CP) lpr lprm $(BINDIR)
$(CP) lpc $(SBINDIR)
#
# lpc
#
lpc: lpc.o ../cups/$(LIBCUPS)
lpc: lpc.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o lpc lpc.o $(LIBS)
lpc.o: ../cups/cups.h ../Makedefs
#
# lpq
#
lpq: lpq.o ../cups/$(LIBCUPS)
lpq: lpq.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o lpq lpq.o $(LIBS)
lpq.o: ../cups/cups.h ../Makedefs
#
# lpr
#
lpr: lpr.o ../cups/$(LIBCUPS)
lpr: lpr.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o lpr lpr.o $(LIBS)
lpr.o: ../cups/cups.h ../Makedefs
#
# lprm
#
lprm: lprm.o ../cups/$(LIBCUPS)
lprm: lprm.o ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o lprm lprm.o $(LIBS)
lprm.o: ../cups/cups.h ../Makedefs
#
# End of "$Id$".
#
+3 -11
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lpc" command 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
@@ -60,6 +60,7 @@ int
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i; /* Looping var */
http_t *http; /* Connection to server */
char line[1024], /* Input line from user */
*params; /* Pointer to parameters */
@@ -410,8 +411,7 @@ show_status(http_t *http, /* I - HTTP connection to server */
"attributes-natural-language", NULL,
language->language);
snprintf(printer_uri, sizeof(printer_uri),
"ipp://localhost/printers/%s", printer);
sprintf(printer_uri, "ipp://localhost/printers/%s", printer);
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
@@ -433,15 +433,7 @@ show_status(http_t *http, /* I - HTTP connection to server */
if (strncmp(device, "file:", 5) == 0)
printf("\tprinter is on device \'%s\' speed -1\n", device + 5);
else
{
/*
* Just show the method...
*/
*strchr(device, ':') = '\0';
printf("\tprinter is on device \'%s\' speed -1\n", device);
}
printf("\tqueuing is %sabled\n", accepting ? "en" : "dis");
printf("\tprinting is %sabled\n",
pstate == IPP_PRINTER_STOPPED ? "dis" : "en");
+35 -186
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lpq" command 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,6 @@
*
* Contents:
*
* main() - Parse options and commands.
* show_jobs() - Show jobs.
* show_printer() - Show printer status.
*/
/*
@@ -48,9 +45,7 @@
* Local functions...
*/
static int show_jobs(http_t *, const char *, const char *, const int,
const int);
static void show_printer(http_t *, const char *);
static int show_jobs(http_t *, char *, char *, int, int);
/*
@@ -63,15 +58,11 @@ main(int argc, /* I - Number of command-line arguments */
{
int i; /* Looping var */
http_t *http; /* Connection to server */
const char *dest, /* Desired printer */
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...
@@ -89,12 +80,6 @@ main(int argc, /* I - Number of command-line arguments */
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 +95,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 +103,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);
}
}
@@ -137,16 +117,10 @@ main(int argc, /* I - Number of command-line arguments */
for (;;)
{
if (dest)
show_printer(http, dest);
i = show_jobs(http, dest, user, id, longstatus);
if (i && interval)
{
fflush(stdout);
sleep(interval);
}
else
break;
}
@@ -155,7 +129,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);
@@ -163,36 +136,31 @@ main(int argc, /* I - Number of command-line arguments */
/*
* 'show_jobs()' - Show jobs.
* 'show_jobs()' - Show printers.
*/
static int /* O - Number of jobs in queue */
show_jobs(http_t *http, /* I - HTTP connection to server */
const char *dest, /* I - Destination */
const char *user, /* I - User */
const int id, /* I - Job ID */
const int longstatus)/* I - 1 if long report desired */
show_jobs(http_t *http, /* I - HTTP connection to server */
char *dest, /* I - Destination */
char *user, /* I - User */
int id, /* I - Job ID */
int longstatus) /* I - 1 if long report desired */
{
ipp_t *request, /* IPP Request */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Default language */
const char *jobdest, /* Pointer into job-printer-uri */
char *jobdest, /* Pointer into job-printer-uri */
*jobuser, /* Pointer to job-originating-user-name */
*jobname; /* Pointer to job-name */
ipp_jstate_t jobstate; /* job-state */
int jobid, /* job-id */
jobsize, /* job-k-octets */
#ifdef __osf__
jobpriority, /* job-priority */
#endif /* __osf__ */
jobcount, /* Number of jobs */
jobcopies, /* Number of copies */
rank; /* Rank of job */
char resource[1024]; /* Resource string */
char rankstr[255]; /* Rank string */
char namestr[1024]; /* Job name string */
static const char *ranks[10] =/* Ranking strings */
static char *ranks[10] = /* Ranking strings */
{
"th",
"st",
@@ -220,6 +188,7 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
* attributes-charset
* attributes-natural-language
* job-uri or printer-uri
* [
*/
request = ippNew();
@@ -247,9 +216,9 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
}
else
{
snprintf(resource, sizeof(resource), "ipp://localhost/printers/%s", dest);
sprintf(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);
}
@@ -264,18 +233,13 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
* Do the request and get back a response...
*/
if (!longstatus)
puts("Rank\tPri Owner Job Files Total Size");
jobcount = 0;
if ((response = cupsDoRequest(http, request, "/")) != NULL)
if ((response = cupsDoRequest(http, request, "/jobs/")) != NULL)
{
if (response->request.status.status_code > IPP_OK_CONFLICT)
{
fprintf(stderr, "lpq: get-jobs failed: %s\n",
ippErrorString(response->request.status.status_code));
ippDelete(response);
return (0);
}
rank = 1;
/*
@@ -300,14 +264,11 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
jobid = 0;
jobsize = 0;
#ifdef __osf__
jobpriority = 50;
#endif /* __osf__ */
jobstate = IPP_JOB_PENDING;
jobname = "untitled";
jobuser = NULL;
jobdest = NULL;
jobcopies = 1;
while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
{
@@ -319,11 +280,9 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
attr->value_tag == IPP_TAG_INTEGER)
jobsize = attr->values[0].integer * 1024;
#ifdef __osf__
if (strcmp(attr->name, "job-priority") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
jobpriority = attr->values[0].integer;
#endif /* __osf__ */
if (strcmp(attr->name, "job-state") == 0 &&
attr->value_tag == IPP_TAG_ENUM)
@@ -342,10 +301,6 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
attr->value_tag == IPP_TAG_NAME)
jobname = attr->values[0].string.text;
if (strcmp(attr->name, "copies") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
jobcopies = attr->values[0].integer;
attr = attr->next;
}
@@ -361,157 +316,51 @@ show_jobs(http_t *http, /* I - HTTP connection to server */
continue;
}
if (!longstatus && jobcount == 0)
#ifdef __osf__
puts("Rank Owner Pri Job Files Total Size");
#else
puts("Rank Owner Job Files Total Size");
#endif /* __osf__ */
jobcount ++;
/*
* Display the job...
*/
if (jobstate == IPP_JOB_PROCESSING)
strcpy(rankstr, "active");
else
{
sprintf(rankstr, "%d%s", rank, ranks[rank % 10]);
rank ++;
}
if (longstatus)
{
puts("");
if (jobcopies > 1)
snprintf(namestr, sizeof(namestr), "%d copies of %s", jobcopies,
jobname);
if (jobstate == IPP_JOB_PROCESSING)
printf("%s: active\t\t\t\t ", jobuser);
else
{
strncpy(namestr, jobname, sizeof(namestr) - 1);
namestr[sizeof(namestr) - 1] = '\0';
printf("%s: %d%s\t\t\t\t ", jobuser, rank, ranks[rank % 10]);
rank ++;
}
printf("%s: %-31s [job %d localhost]\n", jobuser, rankstr, jobid);
printf(" %-31.31s %d bytes\n", namestr, jobsize);
printf("[job %03dlocalhost]\n", jobid);
printf("\t%-33s%d bytes\n", jobname, jobsize);
}
else
#ifdef __osf__
printf("%-6s %-10.10s %-4d %-10d %-27.27s %d bytes\n", rankstr, jobuser,
jobpriority, jobid, jobname, jobsize);
#else
printf("%-6s %-10.10s %-15d %-27.27s %d bytes\n", rankstr, jobuser,
jobid, jobname, jobsize);
#endif /* __osf */
{
if (jobstate == IPP_JOB_PROCESSING)
printf("active\t");
else
{
printf("%d%s\t", rank, ranks[rank % 10]);
rank ++;
}
printf(" %-5d%-7.7s%-7d%-19s%d bytes\n", jobpriority, jobuser, jobid,
jobname, jobsize);
}
if (attr == NULL)
break;
}
ippDelete(response);
}
else
{
fprintf(stderr, "lpq: get-jobs failed: %s\n", ippErrorString(cupsLastError()));
return (0);
}
if (jobcount == 0)
puts("no entries");
return (jobcount);
}
/*
* 'show_printer()' - Show printer status.
*/
static void
show_printer(http_t *http, /* I - HTTP connection to server */
const char *dest) /* I - Destination */
{
ipp_t *request, /* IPP Request */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Default language */
ipp_pstate_t state; /* Printer state */
char uri[HTTP_MAX_URI];
/* Printer URI */
if (http == NULL)
return;
/*
* Build an IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
request->request.op.request_id = 1;
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);
sprintf(uri, "ipp://localhost/printers/%s", dest);
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)
{
if (response->request.status.status_code > IPP_OK_CONFLICT)
{
fprintf(stderr, "lpq: get-printer-attributes failed: %s\n",
ippErrorString(response->request.status.status_code));
ippDelete(response);
return;
}
if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL)
state = (ipp_pstate_t)attr->values[0].integer;
else
state = IPP_PRINTER_STOPPED;
switch (state)
{
case IPP_PRINTER_IDLE :
printf("%s is ready\n", dest);
break;
case IPP_PRINTER_PROCESSING :
printf("%s is ready and printing\n", dest);
break;
case IPP_PRINTER_STOPPED :
printf("%s is not ready\n", dest);
break;
}
ippDelete(response);
}
else
fprintf(stderr, "lpq: get-printer-attributes failed: %s\n",
ippErrorString(cupsLastError()));
}
/*
* End of "$Id$".
*/
+54 -179
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lpr" command 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,8 +23,7 @@
*
* Contents:
*
* main() - Parse options and send files for printing.
* sighandler() - Signal catcher for when we print from stdin...
* main() - Parse options and send files for printing.
*/
/*
@@ -36,25 +35,6 @@
#include <cups/cups.h>
#ifndef WIN32
# include <signal.h>
/*
* Local functions.
*/
void sighandler(int);
#endif /* !WIN32 */
/*
* Globals...
*/
char tempfile[1024]; /* Temporary file for printing from stdin */
/*
* 'main()' - Parse options and send files for printing.
*/
@@ -63,31 +43,23 @@ 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 *title; /* Job title */
char *dest; /* Destination printer */
char *title; /* Job title */
int priority; /* Job priority (1-100) */
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? */
int silent; /* Silent or verbose output? */
char tempfile[1024]; /* Temporary file for printing from stdin */
char buffer[8192]; /* Copy buffer */
FILE *temp; /* Temporary file pointer */
#ifdef HAVE_SIGACTION
struct sigaction action; /* Signal action */
#endif /* HAVE_SIGACTION */
deletefile = 0;
printer = NULL;
num_dests = 0;
dests = NULL;
silent = 0;
dest = cupsGetDefault();
num_options = 0;
options = NULL;
num_files = 0;
@@ -112,61 +84,29 @@ main(int argc, /* I - Number of command-line arguments */
argv[i][1]);
break;
case 'o' : /* Option */
if (argv[i][2] != '\0')
num_options = cupsParseOptions(argv[i] + 2, num_options, &options);
else
{
i ++;
num_options = cupsParseOptions(argv[i], num_options, &options);
}
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;
case 'm' : /* Mail on completion */
case 'm' : /* mail on completion */
fputs("Warning: email notification is not supported!\n", stderr);
break;
case 'r' : /* Remove file after printing */
deletefile = 1;
break;
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,92 +145,53 @@ 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 ++;
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
title = argv[i];
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\'.\n", argv[i]);
return (1);
}
}
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)
sigset(SIGHUP, sighandler);
sigset(SIGINT, sighandler);
sigset(SIGTERM, sighandler);
# elif defined(HAVE_SIGACTION)
memset(&action, 0, sizeof(action));
action.sa_handler = sighandler;
sigaction(SIGHUP, &action, NULL);
sigaction(SIGINT, &action, NULL);
sigaction(SIGTERM, &action, NULL);
# else
signal(SIGHUP, sighandler);
signal(SIGINT, sighandler);
signal(SIGTERM, sighandler);
# endif
#endif /* !WIN32 */
temp = fopen(cupsTempFile(tempfile, sizeof(tempfile)), "w");
temp = fopen(tmpnam(tempfile), "w");
if (temp == NULL)
{
@@ -311,47 +212,21 @@ main(int argc, /* I - Number of command-line arguments */
}
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 file \'%s\'.\n", argv[i]);
return (1);
}
}
return (0);
}
#ifndef WIN32
/*
* 'sighandler()' - Signal catcher for when we print from stdin...
*/
void
sighandler(int s) /* I - Signal number */
{
/*
* Remove the temporary file we're using to print from stdin...
*/
unlink(tempfile);
/*
* Exit...
*/
exit(s);
}
#endif /* !WIN32 */
/*
* End of "$Id$".
*/
+4 -49
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lprm" command 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
@@ -49,15 +49,12 @@ main(int argc, /* I - Number of command-line arguments */
http_t *http; /* HTTP connection to server */
int i; /* Looping var */
int job_id; /* Job ID */
const char *dest; /* Destination printer */
char *instance; /* Pointer to instance name */
char *dest; /* Destination printer */
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,15 +63,8 @@ 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 +73,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 +92,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
@@ -162,7 +146,7 @@ main(int argc, /* I - Number of command-line arguments */
if (dest)
{
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);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id",
@@ -175,9 +159,6 @@ main(int argc, /* I - Number of command-line arguments */
uri);
}
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser());
/*
* Do the request and get back a response...
*/
@@ -188,31 +169,10 @@ main(int argc, /* I - Number of command-line arguments */
response = cupsDoRequest(http, request, "/jobs/");
if (response != NULL)
{
switch (response->request.status.status_code)
{
case IPP_NOT_FOUND :
fputs("lprm: Job or printer not found!\n", stderr);
break;
case IPP_NOT_AUTHORIZED :
fputs("lprm: Not authorized to lprm job(s)!\n", stderr);
break;
case IPP_FORBIDDEN :
fprintf(stderr, "lprm: You don't own job ID %d!\n", job_id);
break;
default :
if (response->request.status.status_code > IPP_OK_CONFLICT)
fputs("lprm: Unable to lprm job(s)!\n", stderr);
break;
}
ippDelete(response);
}
else
{
fputs("lprm: Unable to cancel job(s)!\n", stderr);
cupsFreeDests(num_dests, dests);
httpClose(http);
return (1);
}
}
@@ -226,14 +186,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);
}
+14 -50
Ver Arquivo
@@ -24,10 +24,8 @@
include ../Makedefs
TARGETS = admin.cgi classes.cgi jobs.cgi printers.cgi
LIBOBJS = abort.o email.o html.o ipp-var.o template.o var.o
OBJS = $(LIBOBJS) admin.o classes.o jobs.o printers.o
TARGETS = classes.cgi jobs.cgi printers.cgi
OBJS = classes.o jobs.o printers.o
#
# Make all targets...
@@ -35,84 +33,50 @@ OBJS = $(LIBOBJS) admin.o classes.o jobs.o printers.o
all: $(TARGETS)
#
# Clean all object files...
#
clean:
$(RM) $(OBJS) libcgi.a $(TARGETS)
rm -f $(OBJS) $(TARGETS)
#
# Install all targets...
#
install:
-$(MKDIR) $(SERVERBIN)/cgi-bin
$(CHMOD) ugo+rx $(SERVERBIN)
$(CHMOD) ugo+rx $(SERVERBIN)/cgi-bin
$(INSTALL_BIN) $(TARGETS) $(SERVERBIN)/cgi-bin
#
# libcgi.a
#
libcgi.a: $(LIBOBJS)
echo Archiving $@...
$(RM) $@
$(AR) $(ARFLAGS) $@ $(LIBOBJS)
$(RANLIB) $@
$(LIBOBJS): cgi.h
ipp-var.o: ipp-var.h
#
# admin.cgi
#
admin.cgi: admin.o ../Makedefs ../cups/$(LIBCUPS) libcgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ admin.o libcgi.a $(LIBS)
admin.o: cgi.h ipp-var.h ../cups/cups.h ../cups/ipp.h ../cups/language.h
-$(MKDIR) $(SERVERROOT)/cgi-bin
$(CP) $(TARGETS) $(SERVERROOT)/cgi-bin
#
# classes.cgi
#
classes.cgi: classes.o ../Makedefs ../cups/$(LIBCUPS) libcgi.a
classes.cgi: classes.o ../Makedefs ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ classes.o libcgi.a $(LIBS)
classes.o: cgi.h ipp-var.h ../cups/cups.h ../cups/ipp.h ../cups/language.h
$(CC) $(LDFLAGS) -o $@ classes.o $(LIBS)
$(OBJS): ../Makedefs ../cups/cups.h ../cups/ipp.h ../cups/language.h
#
# jobs.cgi
#
jobs.cgi: jobs.o ../Makedefs ../cups/$(LIBCUPS) libcgi.a
jobs.cgi: jobs.o ../Makedefs ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ jobs.o libcgi.a $(LIBS)
jobs.o: cgi.h ipp-var.h ../cups/cups.h ../cups/ipp.h ../cups/language.h
$(CC) $(LDFLAGS) -o $@ jobs.o $(LIBS)
$(OBJS): ../Makedefs ../cups/cups.h ../cups/ipp.h ../cups/language.h
#
# printers.cgi
#
printers.cgi: printers.o ../Makedefs ../cups/$(LIBCUPS) libcgi.a
printers.cgi: printers.o ../Makedefs ../cups/libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ printers.o libcgi.a $(LIBS)
$(CC) $(LDFLAGS) -o $@ printers.o $(LIBS)
printers.o: cgi.h ipp-var.h ../cups/cups.h ../cups/ipp.h ../cups/language.h
$(OBJS): ../Makedefs
$(OBJS): ../Makedefs ../cups/cups.h ../cups/ipp.h ../cups/language.h
#
# End of "$Id$".
-1572
Ver Arquivo
Diferenças do arquivo suprimidas por serem muito extensas Carregar Diff
-87
Ver Arquivo
@@ -1,87 +0,0 @@
/*
* "$Id$"
*
* CGI support library definitions.
*
* Copyright 1997-2000 by Easy Software Products.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* 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 GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#ifndef _CGI_H_
# define _CGI_H_
# include <stdio.h>
# include <stdlib.h>
# include <string.h>
# include <ctype.h>
# ifdef WIN32
# include <direct.h>
# include <io.h>
# include <malloc.h>
# define strcasecmp(s,t) stricmp((s),(t))
# define strncasecmp(s,t,n) strnicmp((s),(t),(n))
# else
# include <unistd.h>
# endif /* WIN32 */
/*
* Prototypes...
*/
extern int cgiInitialize(void);
extern void cgiAbort(const char *title, const char *stylesheet,
const char *format, ...);
extern int cgiCheckVariables(const char *names);
extern const char *cgiGetArray(const char *name, int element);
extern int cgiGetSize(const char *name);
extern void cgiSetSize(const char *name, int size);
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 cgiStartHTML(FILE *out, const char *author,
const char *stylesheet,
const char *keywords,
const char *description,
const char *title, ...);
extern void cgiEndHTML(FILE *out);
extern FILE *cgiEMailOpen(const char *from, const char *to,
const char *cc, const char *subject,
int multipart);
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"))
#endif /* !_CGI_H_ */
/*
* End of "$Id$".
*/
+375 -264
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Class status CGI 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,14 +23,30 @@
*
* Contents:
*
* main() - Main entry for CGI.
* main() - Main entry for CGI.
* show_class_list() - Show a list of classes...
* show_class_info() - Show class information.
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/debug.h>
/*
* Local functions...
*/
static void show_class_list(http_t *http, cups_lang_t *language);
static void show_class_info(http_t *http, cups_lang_t *language,
char *name);
/*
@@ -42,25 +58,10 @@ main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
cups_lang_t *language; /* Language information */
char *pclass; /* Printer class name */
char *name; /* Class name */
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...
*/
@@ -80,265 +81,78 @@ main(int argc, /* I - Number of command-line arguments */
printf("Content-Type: text/html;charset=%s\n\n", cupsLangEncoding(language));
/*
* See if we need to show a list of printers or the status of a
* single printer...
* See if we need to show a list of classes or the status of a
* single class...
*/
ippSetServerVersion();
name = argv[0];
if (strcmp(name, "/") == 0 || strcmp(name, "classes.cgi") == 0)
name = NULL;
pclass = argv[0];
if (strcmp(pclass, "/") == 0 || strcmp(pclass, "classes.cgi") == 0)
{
pclass = NULL;
cgiSetVariable("TITLE", cupsLangString(language, CUPS_MSG_CLASS));
}
/*
* Print the standard header...
*/
puts("<HTML>");
puts("<HEAD>");
if (name)
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"10\">");
else
cgiSetVariable("TITLE", pclass);
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"30\">");
printf("<TITLE>%s on %s - Common UNIX Printing System</TITLE>\n",
name == NULL ? "Classes" : name, getenv("SERVER_NAME"));
puts("<LINK REL=STYLESHEET TYPE=\"text/css\" HREF=\"/cups.css\">");
puts("<MAP NAME=\"navbar\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"10,10,85,30\" HREF=\"/printers\" ALT=\"Current Printer Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"95,10,175,30\" HREF=\"/classes\" ALT=\"Current Printer Classes Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"185,10,235,30\" HREF=\"/jobs\" ALT=\"Current Jobs Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"245,10,395,30\" HREF=\"/documentation.html\" ALT=\"Read CUPS Documentation On-Line\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"405,10,490,30\" HREF=\"http://www.cups.org\" ALT=\"Download the Current CUPS Software\">");
puts("</MAP>");
puts("</HEAD>");
puts("<BODY>");
puts("<P ALIGN=CENTER>");
puts("<A HREF=\"http://www.easysw.com\" ALT=\"Easy Software Products Home Page\">");
puts("<IMG SRC=\"/images/logo.gif\" WIDTH=\"71\" HEIGHT=\"40\" BORDER=0 ALT=\"Easy Software Products Home Page\"></A>");
puts("<IMG SRC=\"/images/navbar.gif\" WIDTH=\"540\" HEIGHT=\"40\" USEMAP=\"#navbar\" BORDER=0>");
cgiCopyTemplateLang(stdout, TEMPLATES, "header.tmpl", getenv("LANG"));
printf("<H1>%s on %s</H1>\n", name == NULL ? "Classes" : name,
getenv("SERVER_NAME"));
fflush(stdout);
if (op == NULL || strcasecmp(op, "print-test-page") != 0)
{
/*
* Get the default destination...
*/
puts("<CENTER>");
puts("<TABLE WIDTH=\"90%\" BORDER=\"1\">");
puts("<TR>");
puts("<TH>Name</TH>");
puts("<TH WIDTH=\"50%\">Status</TH>");
puts("<TH WIDTH=\"25%\">Jobs</TH>");
puts("</TR>");
request = ippNew();
request->request.op.operation_id = CUPS_GET_DEFAULT;
request->request.op.request_id = 1;
/*
* Show the information...
*/
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"));
}
}
}
if (name == NULL)
show_class_list(http, language);
else
{
/*
* Print a test page...
*/
show_class_info(http, language, name);
snprintf(uri, sizeof(uri), "ipp://localhost/classes/%s", pclass);
/*
* Write a standard trailer...
*/
/*
* Build an IPP_PRINT_JOB request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* document-format
*/
puts("</TABLE>");
puts("</CENTER>");
request = ippNew();
puts("<HR>");
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
puts("<P>The Common UNIX Printing System, CUPS, and the CUPS logo are the");
puts("trademark property of <A HREF=\"http://www.easysw.com\">Easy Software");
puts("Products</A>. CUPS is copyright 1997-1999 by Easy Software Products,");
puts("All Rights Reserved.");
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);
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");
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");
/*
* Do the request and get back a response...
*/
if ((response = cupsDoFileRequest(http, request, uri + 15,
CUPS_DATADIR "/data/testprint.ps")) != NULL)
{
status = response->request.status.status_code;
ippSetCGIVars(response, NULL, NULL);
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"));
}
else
cgiCopyTemplateLang(stdout, TEMPLATES, "test-page.tmpl", getenv("LANG"));
}
cgiCopyTemplateLang(stdout, TEMPLATES, "trailer.tmpl", getenv("LANG"));
puts("</BODY>");
puts("</HTML>");
/*
* Close the HTTP server connection...
@@ -355,6 +169,303 @@ main(int argc, /* I - Number of command-line arguments */
}
/*
* 'show_class_list()' - Show a list of classes...
*/
static void
show_class_list(http_t *http, /* I - HTTP connection */
cups_lang_t *language)/* I - Client's language */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* IPP attribute */
/*
* 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_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);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/classes/")) != NULL)
{
/*
* Loop through the classes returned in the list and display
* their devices...
*/
for (attr = response->attrs; attr != NULL; attr = attr->next)
{
/*
* Skip leading attributes until we hit a job...
*/
while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
attr = attr->next;
if (attr == NULL)
break;
/*
* Show the class status for each class...
*/
while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
{
if (strcmp(attr->name, "printer-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
show_class_info(http, language, attr->values[0].string.text);
attr = attr->next;
}
if (attr == NULL)
break;
}
ippDelete(response);
}
}
/*
* 'show_class_info()' - Show class information.
*/
static void
show_class_info(http_t *http,
cups_lang_t *language,
char *name)
{
ipp_t *request, /* IPP request */
*response, /* IPP response */
*jobs; /* IPP Get Jobs response */
int jobcount; /* Number of jobs */
ipp_attribute_t *attr; /* IPP attribute */
char *message; /* Printer state message */
int accepting; /* Accepting requests? */
ipp_pstate_t pstate; /* Printer state */
char uri[HTTP_MAX_URI];/* Printer URI */
/*
* Build a IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* class-uri
*/
request = ippNew();
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, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
sprintf(uri, "ipp://localhost/classes/%s", name);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "class-uri", NULL, uri);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, uri + 15)) == NULL)
{
puts("<P>Unable to communicate with CUPS server!");
return;
}
if (response->request.status.status_code == IPP_NOT_FOUND)
{
puts("<P>Class does not exist.");
ippDelete(response);
return;
}
/*
* Grab the needed class attributes...
*/
if ((attr = ippFindAttribute(response, "class-state", IPP_TAG_ENUM)) != NULL)
pstate = (ipp_pstate_t)attr->values[0].integer;
else
pstate = IPP_PRINTER_IDLE;
if ((attr = ippFindAttribute(response, "class-state-message", IPP_TAG_TEXT)) != NULL)
message = attr->values[0].string.text;
else
message = NULL;
if ((attr = ippFindAttribute(response, "class-is-accepting-jobs",
IPP_TAG_BOOLEAN)) != NULL)
accepting = attr->values[0].boolean;
else
accepting = 1;
if ((attr = ippFindAttribute(response, "printer-uri", IPP_TAG_URI)) != NULL)
strcpy(uri, attr->values[0].string.text);
/*
* Display the class entry...
*/
puts("<TR>");
printf("<TD VALIGN=TOP><A HREF=\"/classes/%s\">%s</A></TD>\n", name, name);
puts("<TD VALIGN=TOP><IMG SRC=\"/images/classes.gif\" ALIGN=\"LEFT\">");
printf("%s: %s, %s<BR>\n",
cupsLangString(language, CUPS_MSG_PRINTER_STATE),
cupsLangString(language, pstate == IPP_PRINTER_IDLE ? CUPS_MSG_IDLE :
pstate == IPP_PRINTER_PROCESSING ?
CUPS_MSG_PROCESSING : CUPS_MSG_STOPPED),
cupsLangString(language, accepting ? CUPS_MSG_ACCEPTING_JOBS :
CUPS_MSG_NOT_ACCEPTING_JOBS));
if (message)
printf("<BR CLEAR=ALL><I>\"%s\"</I>\n", message);
else if (!accepting || pstate == IPP_PRINTER_STOPPED)
puts("<BR CLEAR=ALL><I>\"Reason Unknown\"</I>");
puts("</TD>");
/*
* Show a list of jobs as needed...
*/
if (pstate != IPP_PRINTER_IDLE)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* class-uri
*/
request = ippNew();
request->request.op.operation_id = IPP_GET_JOBS;
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,
"class-uri", NULL, uri);
jobs = cupsDoRequest(http, request, uri + 15);
}
else
jobs = NULL;
puts("<TD VALIGN=\"TOP\">");
jobcount = 0;
if (jobs != NULL)
{
char *username; /* Pointer to job-originating-user-name */
int jobid, /* job-id */
size; /* job-k-octets */
for (attr = jobs->attrs; attr != NULL; attr = attr->next)
{
/*
* Skip leading attributes until we hit a job...
*/
while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
attr = attr->next;
if (attr == NULL)
break;
/*
* Pull the needed attributes from this job...
*/
jobid = 0;
size = 0;
username = NULL;
while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
{
if (strcmp(attr->name, "job-id") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
jobid = attr->values[0].integer;
if (strcmp(attr->name, "job-k-octets") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
size = attr->values[0].integer;
if (strcmp(attr->name, "job-originating-user-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
username = attr->values[0].string.text;
attr = attr->next;
}
/*
* Display the job if it matches the current class...
*/
if (username != NULL)
{
jobcount ++;
printf("<A HREF=\"/jobs/%d\">%s-%d %s %dk</A><BR>\n", jobid, name,
jobid, username, size);
}
if (attr == NULL)
break;
}
ippDelete(jobs);
}
if (jobcount == 0)
puts("None");
puts("</TD>");
puts("</TR>");
ippDelete(response);
}
/*
* End of "$Id$".
*/
-89
Ver Arquivo
@@ -1,89 +0,0 @@
/*
* "$Id$"
*
* CGI HTML functions.
*
* Copyright 1997-2000 by Easy Software Products.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* 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 GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* Contents:
*
* cgiStartHTML() - Start an HTML document stream.
* cgiEndHTML() - End an HTML document stream.
*/
#include "cgi.h"
#include <stdarg.h>
/*
* 'cgiStartHTML()' - Start an HTML document stream.
*/
void
cgiStartHTML(FILE *out, /* I - Output file to use */
const char *stylesheet, /* I - Stylesheet to use */
const char *author, /* I - Author name */
const char *keywords, /* I - Search keywords */
const char *description, /* I - Description of document */
const char *title, /* I - Title for page */
...) /* I - Any addition args for title */
{
va_list ap; /* Argument pointer */
fputs("Content-type: text/html\n\n", out);
fputs("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.0 Transitional//EN\" "
"\"http://www.w3.org/TR/REC-html40/loose.dtd\">\n", out);
fputs("<HTML>\n", out);
fputs("<HEAD>\n", out);
fputs("\t<TITLE>\n", out);
va_start(ap, title);
vfprintf(out, title, ap);
va_end(ap);
fputs("</TITLE>\n", out);
if (stylesheet)
fprintf(out, "\t<LINK REL=\"STYLESHEET\" TYPE=\"text/css\" HREF=\"%s\">\n",
stylesheet);
if (author)
fprintf(out, "\t<META NAME=\"AUTHOR\" CONTENT=\"%s\">\n", author);
if (keywords)
fprintf(out, "\t<META NAME=\"KEYWORDS\" CONTENT=\"%s\">\n", keywords);
if (description)
fprintf(out, "\t<META NAME=\"DESCRIPTION\" CONTENT=\"%s\">\n", description);
fputs("</HEAD>\n", out);
fputs("<BODY>\n", out);
}
/*
* 'cgiEndHTML()' - End an HTML document stream.
*/
void
cgiEndHTML(FILE *out) /* I - Output file to use */
{
fputs("</BODY>\n", out);
fputs("</HTML>\n", out);
}
/*
* End of "$Id$".
*/
-258
Ver Arquivo
@@ -1,258 +0,0 @@
/*
* "$Id$"
*
* IPP variable routines 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:
*
* ippSetServerVersion() - Set the server name and CUPS version...
* ippSetCGIVars() - Set CGI variables from an IPP response.
*/
/*
* Include necessary headers...
*/
#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 */
{
int element; /* Element in CGI array */
ipp_attribute_t *attr, /* Attribute in response... */
*filter; /* Filtering attribute */
int i; /* Looping var */
char name[1024], /* Name of attribute */
value[16384], /* Value(s) */
*valptr; /* Pointer into value */
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 */
ippSetServerVersion();
server = getenv("SERVER_NAME");
for (attr = response->attrs;
attr && attr->group_tag == IPP_TAG_OPERATION;
attr = attr->next);
for (element = 0; attr != NULL; attr = attr->next, element ++)
{
/*
* 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 &&
strcasecmp(filter->values[0].string.text, filter_value) == 0)
break;
if (!filter)
return;
if (filter->group_tag == IPP_TAG_ZERO)
{
attr = filter;
element --;
continue;
}
}
for (; attr != NULL && attr->group_tag != IPP_TAG_ZERO; attr = attr->next)
{
/*
* Copy the attribute name, substituting "_" for "-"...
*/
if (attr->name == NULL)
continue;
for (i = 0; attr->name[i]; i ++)
if (attr->name[i] == '-')
name[i] = '_';
else
name[i] = attr->name[i];
name[i] = '\0';
/*
* Copy values...
*/
value[0] = '\0';
valptr = value;
for (i = 0; i < attr->num_values; i ++)
{
if (i)
strcat(valptr, ",");
valptr += strlen(valptr);
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
sprintf(valptr, "%d", attr->values[i].integer);
break;
case IPP_TAG_BOOLEAN :
sprintf(valptr, "%d", attr->values[i].boolean);
break;
case IPP_TAG_NOVALUE :
strcat(valptr, "novalue");
break;
case IPP_TAG_RANGE :
sprintf(valptr, "%d-%d", attr->values[i].range.lower,
attr->values[i].range.upper);
break;
case IPP_TAG_RESOLUTION :
sprintf(valptr, "%dx%d%s", attr->values[i].resolution.xres,
attr->values[i].resolution.yres,
attr->values[i].resolution.units == IPP_RES_PER_INCH ?
"dpi" : "dpc");
break;
case IPP_TAG_URI :
if (strchr(attr->values[i].string.text, ':') != NULL)
{
httpSeparate(attr->values[i].string.text, method, username,
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;
}
}
case IPP_TAG_STRING :
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
strcat(valptr, attr->values[i].string.text);
break;
default :
break; /* anti-compiler-warning-code */
}
}
/*
* Add the element...
*/
cgiSetArray(name, element, value);
}
if (attr == NULL)
break;
}
}
/*
* End of "$Id$".
*/
-55
Ver Arquivo
@@ -1,55 +0,0 @@
/*
* "$Id$"
*
* IPP variable definitions 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
*/
/*
* Include necessary headers...
*/
#include <ctype.h>
#include <cups/cups.h>
#include <cups/debug.h>
#include <cups/language.h>
#include <cups/string.h>
#include "cgi.h"
/*
* Definitions...
*/
#define TEMPLATES ippGetTemplateDir()
/*
* Prototype...
*/
extern char *ippGetTemplateDir(void);
extern void ippSetServerVersion(void);
extern void ippSetCGIVars(ipp_t *, const char *, const char *);
/*
* End of "$Id$".
*/
+486 -48
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Job status CGI 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,14 +23,30 @@
*
* Contents:
*
* main() - Main entry for CGI.
* main() - Main entry for CGI.
* show_job_list() - Show a list of jobs...
* show_job_info() - Show job information.
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/debug.h>
/*
* Local functions...
*/
static void show_job_list(http_t *http, cups_lang_t *language);
static void show_job_info(http_t *http, cups_lang_t *language,
char *name);
/*
@@ -42,17 +58,11 @@ main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
cups_lang_t *language; /* Language information */
char *job; /* Job name */
http_t *http; /* Connection to the server */
const char *which_jobs; /* Which jobs to show */
ipp_t *request, /* IPP request */
*response; /* IPP response */
/*
* Get any form variables...
*/
cgiInitialize();
setbuf(stdout, NULL);
/*
* Get the request language...
@@ -72,52 +82,66 @@ main(int argc, /* I - Number of command-line arguments */
printf("Content-Type: text/html;charset=%s\n\n", cupsLangEncoding(language));
cgiSetVariable("TITLE", "Jobs");
ippSetServerVersion();
cgiCopyTemplateLang(stdout, TEMPLATES, "header.tmpl", getenv("LANG"));
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* See if we need to show a list of jobs or the status of a
* single job...
*/
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;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL,
"ipp://localhost/jobs");
if ((which_jobs = cgiGetVariable("which_jobs")) != NULL)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_KEYWORD, "which-jobs",
NULL, which_jobs);
job = argv[0];
if (strcmp(job, "/") == 0 || strcmp(job, "jobs.cgi") == 0)
job = NULL;
/*
* Do the request and get back a response...
* Print the standard header...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response, NULL, NULL);
ippDelete(response);
puts("<HTML>");
puts("<HEAD>");
if (job)
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"10\">");
else
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"30\">");
printf("<TITLE>%s on %s - Common UNIX Printing System</TITLE>\n",
job == NULL ? "Jobs" : job, getenv("SERVER_NAME"));
puts("<LINK REL=STYLESHEET TYPE=\"text/css\" HREF=\"/cups.css\">");
puts("<MAP NAME=\"navbar\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"10,10,85,30\" HREF=\"/printers\" ALT=\"Current Printer Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"95,10,175,30\" HREF=\"/classes\" ALT=\"Current Printer Classes Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"185,10,235,30\" HREF=\"/jobs\" ALT=\"Current Jobs Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"245,10,395,30\" HREF=\"/documentation.html\" ALT=\"Read CUPS Documentation On-Line\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"405,10,490,30\" HREF=\"http://www.cups.org\" ALT=\"Download the Current CUPS Software\">");
puts("</MAP>");
puts("</HEAD>");
puts("<BODY>");
puts("<P ALIGN=CENTER>");
puts("<A HREF=\"http://www.easysw.com\" ALT=\"Easy Software Products Home Page\">");
puts("<IMG SRC=\"/images/logo.gif\" WIDTH=\"71\" HEIGHT=\"40\" BORDER=0 ALT=\"Easy Software Products Home Page\"></A>");
puts("<IMG SRC=\"/images/navbar.gif\" WIDTH=\"540\" HEIGHT=\"40\" USEMAP=\"#navbar\" BORDER=0>");
cgiCopyTemplateLang(stdout, TEMPLATES, "jobs.tmpl", getenv("LANG"));
}
fflush(stdout);
cgiCopyTemplateLang(stdout, TEMPLATES, "trailer.tmpl", getenv("LANG"));
/*
* Show the information...
*/
if (job == NULL)
show_job_list(http, language);
else
show_job_info(http, language, job);
/*
* Write a standard trailer...
*/
puts("<HR>");
puts("<P>The Common UNIX Printing System, CUPS, and the CUPS logo are the");
puts("trademark property of <A HREF=\"http://www.easysw.com\">Easy Software");
puts("Products</A>. CUPS is copyright 1997-1999 by Easy Software Products,");
puts("All Rights Reserved.");
puts("</BODY>");
puts("</HTML>");
/*
* Close the HTTP server connection...
@@ -134,6 +158,420 @@ main(int argc, /* I - Number of command-line arguments */
}
/*
* 'show_job_list()' - Show a list of jobs...
*/
static void
show_job_list(http_t *http, /* I - HTTP connection */
cups_lang_t *language) /* I - Client's language */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* IPP attribute */
char *job_uri, /* job-uri */
*printer_uri, /* job-printer-uri */
*job_name, /* job-name */
*job_user; /* job-originating-user-name */
int job_id, /* job-id */
job_priority, /* job-priority */
job_k_octets, /* job-k-octets */
copies; /* copies */
ipp_jstate_t job_state; /* job-state */
printf("<H1>Jobs on %s</H1>\n", getenv("SERVER_NAME"));
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* job-uri
*/
request = ippNew();
request->request.op.operation_id = IPP_GET_JOBS;
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, "job-uri",
NULL, "ipp://localhost/jobs/");
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/jobs/")) != NULL)
{
/*
* Do a table for the jobs...
*/
puts("<CENTER>");
puts("<TABLE WIDTH=\"90%\" BORDER=\"1\">");
puts("<TR>");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_PRINT_JOBS));
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_JOB_STATE));
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_JOB_NAME));
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_USER_NAME));
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_PRIORITY));
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_COPIES));
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_FILE_SIZE));
puts("</TR>");
/*
* Loop through the jobs returned in the list and display
* their devices...
*/
for (attr = response->attrs; attr != NULL; attr = attr->next)
{
/*
* Skip leading attributes until we hit a job...
*/
while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
attr = attr->next;
if (attr == NULL)
break;
/*
* Show the job status for each job...
*/
job_uri = NULL;
printer_uri = NULL;
job_name = "unknown";
job_user = "unknown";
job_id = 0;
job_priority = 50;
job_k_octets = 0;
copies = 1;
job_state = IPP_JOB_PENDING;
while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
{
if (strcmp(attr->name, "job-uri") == 0 &&
attr->value_tag == IPP_TAG_URI)
job_uri = attr->values[0].string.text;
if (strcmp(attr->name, "job-printer-uri") == 0 &&
attr->value_tag == IPP_TAG_URI)
printer_uri = attr->values[0].string.text;
if (strcmp(attr->name, "job-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
job_name = attr->values[0].string.text;
if (strcmp(attr->name, "job-originating-user-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
job_user = attr->values[0].string.text;
if (strcmp(attr->name, "job-id") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
job_id = attr->values[0].integer;
if (strcmp(attr->name, "job-priority") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
job_priority = attr->values[0].integer;
if (strcmp(attr->name, "job-k-octets") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
job_k_octets = attr->values[0].integer;
if (strcmp(attr->name, "copies") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
copies = attr->values[0].integer;
if (strcmp(attr->name, "job-state") == 0 &&
attr->value_tag == IPP_TAG_ENUM)
job_state = (ipp_jstate_t)attr->values[0].integer;
attr = attr->next;
}
/*
* See if we have everything needed...
*/
if (job_id && job_uri != NULL && printer_uri != NULL)
{
puts("<TR>");
printf("<TD><A HREF=\"http://%s:%s/jobs/%d\">%s-%d</A></TD>\n",
getenv("SERVER_NAME"), getenv("SERVER_PORT"), job_id,
strrchr(printer_uri, '/') + 1, job_id);
printf("<TD>%s</TD>\n", job_state == IPP_JOB_PROCESSING ?
cupsLangString(language, CUPS_MSG_PROCESSING) :
cupsLangString(language, CUPS_MSG_PENDING));
printf("<TD>%s</TD>\n", job_name);
printf("<TD>%s</TD>\n", job_user);
printf("<TD>%d</TD>\n", job_priority);
printf("<TD>%d</TD>\n", copies);
printf("<TD>%dk</TD>\n", job_k_octets);
puts("</TR>");
}
if (attr == NULL)
break;
}
ippDelete(response);
puts("</TABLE>");
puts("</CENTER>");
}
else
puts("<P>No jobs found.");
}
/*
* 'show_job_info()' - Show job information.
*/
static void
show_job_info(http_t *http, /* I - Server connection */
cups_lang_t *language, /* I - Language */
char *name) /* I - Job "name" */
{
int i; /* Looping var */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* IPP attribute */
char uri[HTTP_MAX_URI];/* Real URI */
char *job_uri, /* job-uri */
*printer_uri, /* job-printer-uri */
*job_name, /* job-name */
*job_user; /* job-originating-user-name */
int job_id, /* job-id */
job_priority, /* job-priority */
job_k_octets; /* job-k-octets */
ipp_jstate_t job_state; /* job-state */
/*
* Build an IPP_GET_JOB_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* job-uri
*/
request = ippNew();
request->request.op.operation_id = IPP_GET_JOB_ATTRIBUTES;
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);
sprintf(uri, "ipp://localhost/jobs/%s", name);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL, uri);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, uri + 15)) == NULL)
{
puts("<P>Unable to communicate with CUPS server!");
return;
}
if (response->request.status.status_code == IPP_NOT_FOUND)
{
puts("<P>Job does not exist or has completed.");
ippDelete(response);
return;
}
/*
* Get the job status for this job...
*/
if ((attr = ippFindAttribute(response, "job-uri", IPP_TAG_URI)) != NULL)
job_uri = attr->values[0].string.text;
else
{
puts("<P>Missing job-uri attribute!");
ippDelete(request);
return;
}
if ((attr = ippFindAttribute(response, "job-printer-uri", IPP_TAG_URI)) != NULL)
printer_uri = attr->values[0].string.text;
else
{
puts("<P>Missing job-printer-uri attribute!");
ippDelete(request);
return;
}
if ((attr = ippFindAttribute(response, "job-name", IPP_TAG_NAME)) != NULL)
job_name = attr->values[0].string.text;
else
job_name = "unknown";
if ((attr = ippFindAttribute(response, "job-originating-user-name",
IPP_TAG_NAME)) != NULL)
job_user = attr->values[0].string.text;
else
job_user = "unknown";
if ((attr = ippFindAttribute(response, "job-id", IPP_TAG_INTEGER)) != NULL)
job_id = attr->values[0].integer;
else
{
puts("<P>Missing job-id attribute!");
ippDelete(request);
return;
}
if ((attr = ippFindAttribute(response, "job-priority", IPP_TAG_INTEGER)) != NULL)
job_priority = attr->values[0].integer;
else
job_priority = 50;
if ((attr = ippFindAttribute(response, "job-k-octets", IPP_TAG_INTEGER)) != NULL)
job_k_octets = attr->values[0].integer;
else
job_k_octets = 0;
if ((attr = ippFindAttribute(response, "job-state", IPP_TAG_ENUM)) != NULL)
job_state = (ipp_jstate_t)attr->values[0].integer;
else
job_state = IPP_JOB_PENDING;
/*
* Do a table for the job...
*/
printf("<H1><A HREF=\"http://%s:%s/printers/%s\">%s-%d</A></H1>\n",
getenv("SERVER_NAME"), getenv("SERVER_PORT"),
strrchr(printer_uri, '/') + 1, strrchr(printer_uri, '/') + 1, job_id);
puts("<CENTER>");
puts("<TABLE WIDTH=\"90%\" BORDER=\"1\">");
puts("<TR>");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_JOB_STATE));
printf("<TD>%s</TD>\n", job_state == IPP_JOB_PROCESSING ?
cupsLangString(language, CUPS_MSG_PROCESSING) :
cupsLangString(language, CUPS_MSG_PENDING));
puts("</TR>");
puts("<TR>");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_JOB_NAME));
printf("<TD>%s</TD>\n", job_name);
puts("</TR>");
puts("<TR>");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_USER_NAME));
printf("<TD>%s</TD>\n", job_user);
puts("</TR>");
puts("<TR>");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_PRIORITY));
printf("<TD>%d</TD>\n", job_priority);
puts("</TR>");
puts("<TR>");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_FILE_SIZE));
printf("<TD>%dk</TD>\n", job_k_octets);
puts("</TR>");
puts("<TR VALIGN=\"TOP\">");
printf("<TH>%s</TH>\n", cupsLangString(language, CUPS_MSG_OPTIONS));
puts("<TD>");
for (attr = response->attrs; attr != NULL; attr = attr->next)
{
if (attr->group_tag != IPP_TAG_JOB &&
attr->group_tag != IPP_TAG_EXTENSION)
continue;
if (strcmp(attr->name, "job-uri") == 0 ||
strcmp(attr->name, "job-printer-uri") == 0 ||
strcmp(attr->name, "job-name") == 0 ||
strcmp(attr->name, "job-originating-user-name") == 0 ||
strcmp(attr->name, "job-id") == 0 ||
strcmp(attr->name, "job-priority") == 0 ||
strcmp(attr->name, "job-k-octets") == 0 ||
strcmp(attr->name, "job-state") == 0)
continue;
if (attr->value_tag != IPP_TAG_BOOLEAN)
printf("%s=", attr->name);
for (i = 0; i < attr->num_values; i ++)
{
if (i)
putchar(',');
switch (attr->value_tag)
{
case IPP_TAG_INTEGER :
case IPP_TAG_ENUM :
printf("%d", attr->values[i].integer);
break;
case IPP_TAG_BOOLEAN :
if (!attr->values[i].boolean)
printf("no");
case IPP_TAG_NOVALUE :
fputs(attr->name, stdout);
break;
case IPP_TAG_RANGE :
printf("%d-%d", attr->values[i].range.lower,
attr->values[i].range.upper);
break;
case IPP_TAG_RESOLUTION :
printf("%dx%d%s", attr->values[i].resolution.xres,
attr->values[i].resolution.yres,
attr->values[i].resolution.units == IPP_RES_PER_INCH ?
"dpi" : "dpc");
break;
case IPP_TAG_STRING :
case IPP_TAG_TEXT :
case IPP_TAG_NAME :
case IPP_TAG_KEYWORD :
case IPP_TAG_CHARSET :
case IPP_TAG_LANGUAGE :
case IPP_TAG_MIMETYPE :
case IPP_TAG_URI :
printf("\"%s\"", attr->values[i].string.text);
break;
}
}
puts("<BR>");
}
puts("</TD>");
puts("</TR>");
puts("</TABLE></CENTER>");
ippDelete(response);
}
/*
* End of "$Id$".
*/
+372 -259
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Printer status CGI 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,14 +23,30 @@
*
* Contents:
*
* main() - Main entry for CGI.
* main() - Main entry for CGI.
* show_printer_list() - Show a list of printers...
* show_printer_info() - Show printer information.
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/debug.h>
/*
* Local functions...
*/
static void show_printer_list(http_t *http, cups_lang_t *language);
static void show_printer_info(http_t *http, cups_lang_t *language,
char *name);
/*
@@ -44,22 +60,7 @@ main(int argc, /* I - Number of command-line arguments */
cups_lang_t *language; /* Language information */
char *printer; /* Printer name */
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 +85,74 @@ 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));
}
/*
* Print the standard header...
*/
puts("<HTML>");
puts("<HEAD>");
if (printer)
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"10\">");
else
cgiSetVariable("TITLE", printer);
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"30\">");
printf("<TITLE>%s on %s - Common UNIX Printing System</TITLE>\n",
printer == NULL ? "Printers" : printer, getenv("SERVER_NAME"));
puts("<LINK REL=STYLESHEET TYPE=\"text/css\" HREF=\"/cups.css\">");
puts("<MAP NAME=\"navbar\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"10,10,85,30\" HREF=\"/printers\" ALT=\"Current Printer Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"95,10,175,30\" HREF=\"/classes\" ALT=\"Current Printer Classes Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"185,10,235,30\" HREF=\"/jobs\" ALT=\"Current Jobs Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"245,10,395,30\" HREF=\"/documentation.html\" ALT=\"Read CUPS Documentation On-Line\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"405,10,490,30\" HREF=\"http://www.cups.org\" ALT=\"Download the Current CUPS Software\">");
puts("</MAP>");
puts("</HEAD>");
puts("<BODY>");
puts("<P ALIGN=CENTER>");
puts("<A HREF=\"http://www.easysw.com\" ALT=\"Easy Software Products Home Page\">");
puts("<IMG SRC=\"/images/logo.gif\" WIDTH=\"71\" HEIGHT=\"40\" BORDER=0 ALT=\"Easy Software Products Home Page\"></A>");
puts("<IMG SRC=\"/images/navbar.gif\" WIDTH=\"540\" HEIGHT=\"40\" USEMAP=\"#navbar\" BORDER=0>");
cgiCopyTemplateLang(stdout, TEMPLATES, "header.tmpl", getenv("LANG"));
printf("<H1>%s on %s</H1>\n", printer == NULL ? "Printers" : printer,
getenv("SERVER_NAME"));
fflush(stdout);
if (op == NULL || strcasecmp(op, "print-test-page") != 0)
{
/*
* Get the default destination...
*/
puts("<CENTER>");
puts("<TABLE WIDTH=\"90%\" BORDER=\"1\">");
puts("<TR>");
puts("<TH>Name</TH>");
puts("<TH WIDTH=\"50%\">Status</TH>");
puts("<TH WIDTH=\"25%\">Jobs</TH>");
puts("</TR>");
request = ippNew();
request->request.op.operation_id = CUPS_GET_DEFAULT;
request->request.op.request_id = 1;
/*
* Show the information...
*/
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"));
}
}
}
if (printer == NULL)
show_printer_list(http, language);
else
{
/*
* Print a test page...
*/
show_printer_info(http, language, printer);
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", printer);
/*
* Write a standard trailer...
*/
/*
* Build an IPP_PRINT_JOB request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* document-format
*/
puts("</TABLE>");
puts("</CENTER>");
request = ippNew();
puts("<HR>");
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
puts("<P>The Common UNIX Printing System, CUPS, and the CUPS logo are the");
puts("trademark property of <A HREF=\"http://www.easysw.com\">Easy Software");
puts("Products</A>. CUPS is copyright 1997-1999 by Easy Software Products,");
puts("All Rights Reserved.");
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);
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");
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");
/*
* Do the request and get back a response...
*/
if ((response = cupsDoFileRequest(http, request, uri + 15,
CUPS_DATADIR "/data/testprint.ps")) != NULL)
{
status = response->request.status.status_code;
ippSetCGIVars(response, NULL, NULL);
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"));
}
else
cgiCopyTemplateLang(stdout, TEMPLATES, "test-page.tmpl", getenv("LANG"));
}
cgiCopyTemplateLang(stdout, TEMPLATES, "trailer.tmpl", getenv("LANG"));
puts("</BODY>");
puts("</HTML>");
/*
* Close the HTTP server connection...
@@ -355,6 +169,305 @@ main(int argc, /* I - Number of command-line arguments */
}
/*
* 'show_printer_list()' - Show a list of printers...
*/
static void
show_printer_list(http_t *http, /* I - HTTP connection */
cups_lang_t *language)/* I - Client's language */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_attribute_t *attr; /* IPP attribute */
/*
* 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_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);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/printers/")) != NULL)
{
/*
* Loop through the printers returned in the list and display
* their devices...
*/
for (attr = response->attrs; attr != NULL; attr = attr->next)
{
/*
* Skip leading attributes until we hit a job...
*/
while (attr != NULL && attr->group_tag != IPP_TAG_PRINTER)
attr = attr->next;
if (attr == NULL)
break;
/*
* Show the printer status for each printer...
*/
while (attr != NULL && attr->group_tag == IPP_TAG_PRINTER)
{
if (strcmp(attr->name, "printer-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
show_printer_info(http, language, attr->values[0].string.text);
attr = attr->next;
}
if (attr == NULL)
break;
}
ippDelete(response);
}
}
/*
* 'show_printer_info()' - Show printer information.
*/
static void
show_printer_info(http_t *http,
cups_lang_t *language,
char *name)
{
ipp_t *request, /* IPP request */
*response, /* IPP response */
*jobs; /* IPP Get Jobs response */
int jobcount; /* Number of jobs */
ipp_attribute_t *attr; /* IPP attribute */
char *message; /* Printer state message */
int accepting; /* Accepting requests? */
ipp_pstate_t pstate; /* Printer state */
char uri[HTTP_MAX_URI];/* Printer URI */
/*
* Build a IPP_GET_PRINTER_ATTRIBUTES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
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, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
sprintf(uri, "ipp://localhost/printers/%s", name);
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, uri + 15)) == NULL)
{
puts("<P>Unable to communicate with CUPS server!");
return;
}
if (response->request.status.status_code == IPP_NOT_FOUND)
{
puts("<P>Printer does not exist.");
ippDelete(response);
return;
}
/*
* Grab the needed printer attributes...
*/
if ((attr = ippFindAttribute(response, "printer-state", IPP_TAG_ENUM)) != NULL)
pstate = (ipp_pstate_t)attr->values[0].integer;
else
pstate = IPP_PRINTER_IDLE;
if ((attr = ippFindAttribute(response, "printer-state-message", IPP_TAG_TEXT)) != NULL)
message = attr->values[0].string.text;
else
message = NULL;
if ((attr = ippFindAttribute(response, "printer-is-accepting-jobs",
IPP_TAG_BOOLEAN)) != NULL)
accepting = attr->values[0].boolean;
else
accepting = 1;
if ((attr = ippFindAttribute(response, "printer-uri", IPP_TAG_URI)) != NULL)
strcpy(uri, attr->values[0].string.text);
/*
* Display the printer entry...
*/
puts("<TR>");
printf("<TD VALIGN=TOP><A HREF=\"/printers/%s\">%s</A></TD>\n", name, name);
printf("<TD VALIGN=TOP><IMG SRC=\"/images/printer-%s.gif\" ALIGN=\"LEFT\">\n",
pstate == IPP_PRINTER_IDLE ? "idle" :
pstate == IPP_PRINTER_PROCESSING ? "processing" : "stopped");
printf("%s: %s, %s<BR>\n",
cupsLangString(language, CUPS_MSG_PRINTER_STATE),
cupsLangString(language, pstate == IPP_PRINTER_IDLE ? CUPS_MSG_IDLE :
pstate == IPP_PRINTER_PROCESSING ?
CUPS_MSG_PROCESSING : CUPS_MSG_STOPPED),
cupsLangString(language, accepting ? CUPS_MSG_ACCEPTING_JOBS :
CUPS_MSG_NOT_ACCEPTING_JOBS));
if (message)
printf("<BR CLEAR=ALL><I>\"%s\"</I>\n", message);
else if (!accepting || pstate == IPP_PRINTER_STOPPED)
puts("<BR CLEAR=ALL><I>\"Reason Unknown\"</I>");
puts("</TD>");
/*
* Show a list of jobs as needed...
*/
if (pstate != IPP_PRINTER_IDLE)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = IPP_GET_JOBS;
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);
jobs = cupsDoRequest(http, request, uri + 15);
}
else
jobs = NULL;
puts("<TD VALIGN=\"TOP\">");
jobcount = 0;
if (jobs != NULL)
{
char *username; /* Pointer to job-originating-user-name */
int jobid, /* job-id */
size; /* job-k-octets */
for (attr = jobs->attrs; attr != NULL; attr = attr->next)
{
/*
* Skip leading attributes until we hit a job...
*/
while (attr != NULL && attr->group_tag != IPP_TAG_JOB)
attr = attr->next;
if (attr == NULL)
break;
/*
* Pull the needed attributes from this job...
*/
jobid = 0;
size = 0;
username = NULL;
while (attr != NULL && attr->group_tag == IPP_TAG_JOB)
{
if (strcmp(attr->name, "job-id") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
jobid = attr->values[0].integer;
if (strcmp(attr->name, "job-k-octets") == 0 &&
attr->value_tag == IPP_TAG_INTEGER)
size = attr->values[0].integer;
if (strcmp(attr->name, "job-originating-user-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
username = attr->values[0].string.text;
attr = attr->next;
}
/*
* Display the job if it matches the current printer...
*/
if (username != NULL)
{
jobcount ++;
printf("<A HREF=\"/jobs/%d\">%s-%d %s %dk</A><BR>\n", jobid, name,
jobid, username, size);
}
if (attr == NULL)
break;
}
ippDelete(jobs);
}
if (jobcount == 0)
puts("None");
puts("</TD>");
puts("</TR>");
ippDelete(response);
}
/*
* End of "$Id$".
*/
-455
Ver Arquivo
@@ -1,455 +0,0 @@
/*
* "$Id$"
*
* CGI template function.
*
* Copyright 1997-2000 by Easy Software Products.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* 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 GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* Contents:
*
* 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...
*/
#include "cgi.h"
/*
* Local functions...
*/
static void cgi_copy(FILE *out, FILE *in, int element, char term);
static void cgi_puts(const char *s, FILE *out);
/*
* 'cgiCopyTemplateFile()' - Copy a template file and replace all the
* '{variable}' strings with the variable value.
*/
void
cgiCopyTemplateFile(FILE *out, /* I - Output file */
const char *tmpl) /* 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...
*/
sprintf(filename, "%s/%s/%s", directory, locale, tmpl);
if (access(filename, 0))
{
locale[2] = '\0';
sprintf(filename, "%s/%s/%s", directory, locale, tmpl);
if (access(filename, 0))
sprintf(filename, "%s/%s", directory, tmpl);
}
/*
* Open the template file...
*/
if ((in = fopen(filename, "r")) == NULL)
return;
/*
* Parse the file to the end...
*/
cgi_copy(out, in, 0, 0);
/*
* Close the template file and return...
*/
fclose(in);
}
/*
* 'cgi_copy()' - Copy the template file, substituting as needed...
*/
static void
cgi_copy(FILE *out, /* I - Output file */
FILE *in, /* I - Input file */
int element, /* I - Element number (0 to N) */
char term) /* I - Terminating character */
{
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 */
char outval[1024], /* Output string */
compare[1024]; /* Comparison string */
int result; /* Result of comparison */
/*
* Parse the file to the end...
*/
while ((ch = getc(in)) != EOF)
if (ch == term)
break;
else if (ch == '{')
{
/*
* Get a variable name...
*/
for (s = name; (ch = getc(in)) != EOF;)
if (strchr("}]<>=!", ch))
break;
else if (s > name && ch == '?')
break;
else if (s < (name + sizeof(name) - 1))
*s++ = ch;
*s = '\0';
/*
* See if it has a value...
*/
if (name[0] == '?')
{
/*
* 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)
strcpy(outval, value);
else
outval[0] = '\0';
}
if ((value = cgiGetArray(name + 1, element)) != NULL)
strcpy(outval, value);
else
outval[0] = '\0';
}
else if (name[0] == '#')
{
/*
* Insert count...
*/
if (name[1])
sprintf(outval, "%d", cgiGetSize(name + 1));
else
sprintf(outval, "%d", element + 1);
}
else if (name[0] == '[')
{
/*
* Loop for # of elements...
*/
int i; /* Looping var */
long pos; /* File position */
int count; /* Number of elements */
if (isdigit(name[1]))
count = atoi(name + 1);
else
count = cgiGetSize(name + 1);
pos = ftell(in);
if (count > 0)
{
for (i = 0; i < count; i ++)
{
fseek(in, pos, SEEK_SET);
cgi_copy(out, in, i, '}');
}
}
else
cgi_copy(NULL, in, 0, '}');
continue;
}
else
{
/*
* 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)
sprintf(outval, "{%s}", name);
else
strcpy(outval, value);
}
else if ((value = cgiGetArray(name, element)) == NULL)
sprintf(outval, "{%s}", name);
else
strcpy(outval, value);
}
/*
* See if the terminating character requires another test...
*/
if (ch == '}')
{
/*
* End of substitution...
*/
if (out)
cgi_puts(outval, out);
continue;
}
/*
* OK, process one of the following checks:
*
* {name?exist:not-exist} Exists?
* {name=value?true:false} Equal
* {name<value?true:false} Less than
* {name>value?true:false} Greater than
* {name!value?true:false} Not equal
*/
if (ch == '?')
{
/*
* Test for existance...
*/
result = cgiGetArray(name, element) != NULL && outval[0];
}
else
{
/*
* Compare to a string...
*/
op = ch;
for (s = compare; (ch = getc(in)) != EOF;)
if (ch == '?')
break;
else if (ch == '#')
{
sprintf(s, "%d", element + 1);
s += strlen(s);
}
else if (ch == '{')
{
/*
* Grab the value of a variable...
*/
innerptr = innername;
while ((ch = getc(in)) != EOF && ch != '}')
if (innerptr < (innername + sizeof(innername) - 1))
*innerptr++ = ch;
*innerptr = '\0';
if (innername[0] == '#')
sprintf(s, "%d", cgiGetSize(innername + 1));
else if ((innerptr = strrchr(innername, '-')) != NULL &&
isdigit(innerptr[1]))
{
*innerptr++ = '\0';
if ((innerval = cgiGetArray(innername, atoi(innerptr) - 1)) == NULL)
*s = '\0';
else
strcpy(s, innerval);
}
else if (innername[0] == '?')
{
if ((innerval = cgiGetArray(innername + 1, element)) == NULL)
*s = '\0';
else
strcpy(s, innerval);
}
else if ((innerval = cgiGetArray(innername, element)) == NULL)
sprintf(s, "{%s}", innername);
else
strcpy(s, innerval);
s += strlen(s);
}
else if (ch == '\\')
*s++ = getc(in);
else
*s++ = ch;
*s = '\0';
if (ch != '?')
return;
/*
* Do the comparison...
*/
switch (op)
{
case '<' :
result = strcasecmp(outval, compare) < 0;
break;
case '>' :
result = strcasecmp(outval, compare) > 0;
break;
case '=' :
result = strcasecmp(outval, compare) == 0;
break;
case '!' :
result = strcasecmp(outval, compare) != 0;
break;
default :
result = 1;
break;
}
}
if (result)
{
/*
* Comparison true; output first part and ignore second...
*/
cgi_copy(out, in, element, ':');
cgi_copy(NULL, in, element, '}');
}
else
{
/*
* Comparison false; ignore first part and output second...
*/
cgi_copy(NULL, in, element, ':');
cgi_copy(out, in, element, '}');
}
}
else if (ch == '\\') /* Quoted char */
{
if (out)
putc(getc(in), out);
else
getc(in);
}
else if (out)
putc(ch, out);
}
/*
* 'cgi_puts()' - Put a string to the output file, quoting as needed...
*/
static void
cgi_puts(const char *s,
FILE *out)
{
while (*s)
{
if (s[0] == '<' && s[1] != '/' && !isalpha(s[1]))
fputs("&lt;", out);
else if (*s == '\"')
fputs("&quot;", out);
else if (s[0] == '&' && isspace(s[1]))
fputs("&amp;", out);
else
putc(*s, out);
s ++;
}
}
/*
* End of "$Id$".
*/
-656
Ver Arquivo
@@ -1,656 +0,0 @@
/*
* "$Id$"
*
* CGI form variable and array functions.
*
* Copyright 1997-2000 by Easy Software Products.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the Free
* Software Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* 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 GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* Contents:
*
* cgiInitialize() - Initialize the CGI variable "database"...
* cgiCheckVariables() - Check for the presence of "required" variables.
* cgiGetArray() - Get an element from a form array...
* cgiGetSize() - Get the size of a form array value.
* cgiGetVariable() - Get a CGI variable from the database...
* cgiSetArray() - Set array element N to the specified string.
* cgiSetVariable() - Set a CGI variable in the database...
* cgi_add_variable() - Add a form variable.
* cgi_compare_variables() - Compare two variables.
* cgi_find_variable() - Find a variable...
* cgi_initialize_get() - Initialize form variables using the GET method.
* cgi_initialize_post() - Initialize variables using the POST method.
* cgi_initialize_string() - Initialize form variables from a string.
* cgi_sort_variables() - Sort all form variables for faster lookup.
*/
/*#define DEBUG*/
#include "cgi.h"
/*
* Data structure to hold all the CGI form variables and arrays...
*/
typedef struct
{
const char *name; /* Name of variable */
int nvalues, /* Number of values */
avalues; /* Number of values allocated */
const char **values; /* Value(s) of variable */
} var_t;
/*
* Local globals...
*/
static int form_count = 0, /* Form variable count */
form_alloc = 0; /* Number of variables allocated */
static var_t *form_vars = NULL; /* Form variables */
/*
* Local functions...
*/
static void cgi_add_variable(const char *name, int element,
const char *value);
static int cgi_compare_variables(const var_t *v1, const var_t *v2);
static var_t *cgi_find_variable(const char *name);
static int cgi_initialize_get(void);
static int cgi_initialize_post(void);
static int cgi_initialize_string(const char *data);
static void cgi_sort_variables(void);
/*
* 'cgiInitialize()' - Initialize the CGI variable "database"...
*/
int /* O - Non-zero if there was form data */
cgiInitialize(void)
{
char *method; /* Form posting method */
#ifdef DEBUG
setbuf(stdout, NULL);
puts("Content-type: text/plain\n");
#endif /* DEBUG */
method = getenv("REQUEST_METHOD");
if (method == NULL)
return (0);
if (strcasecmp(method, "GET") == 0)
return (cgi_initialize_get());
else if (strcasecmp(method, "POST") == 0)
return (cgi_initialize_post());
else
return (0);
}
/*
* 'cgiCheckVariables()' - Check for the presence of "required" variables.
*
* Names may be separated by spaces and/or commas.
*/
int /* O - 1 if all variables present, 0 otherwise */
cgiCheckVariables(const char *names) /* I - Variables to look for */
{
char name[255], /* Current variable name */
*s; /* Pointer in string */
const char *val; /* Value of variable */
int element; /* Array element number */
if (names == NULL)
return (1);
while (*names != '\0')
{
while (*names == ' ' || *names == ',')
names ++;
for (s = name; *names != '\0' && *names != ' ' && *names != ','; s ++, names ++)
*s = *names;
*s = 0;
if (name[0] == '\0')
break;
if ((s = strrchr(name, '-')) != NULL)
{
*s = '\0';
element = atoi(s + 1) - 1;
val = cgiGetArray(name, element);
}
else
val = cgiGetVariable(name);
if (val == NULL)
return (0);
if (*val == '\0')
return (0); /* Can't be blank, either! */
}
return (1);
}
/*
* 'cgiGetArray()' - Get an element from a form array...
*/
const char * /* O - Element value or NULL */
cgiGetArray(const char *name, /* I - Name of array variable */
int element) /* I - Element number (0 to N) */
{
var_t *var; /* Pointer to variable */
if ((var = cgi_find_variable(name)) == NULL)
return (NULL);
if (var->nvalues == 1)
return (var->values[0]);
if (element < 0 || element >= var->nvalues)
return (NULL);
return (var->values[element]);
}
/*
* 'cgiGetSize()' - Get the size of a form array value.
*/
int /* O - Number of elements */
cgiGetSize(const char *name) /* I - Name of variable */
{
var_t *var; /* Pointer to variable */
if ((var = cgi_find_variable(name)) == NULL)
return (0);
return (var->nvalues);
}
/*
* 'cgiGetVariable()' - Get a CGI variable from the database...
*
* Returns NULL if the variable doesn't exist... If the variable is an
* array of values, returns the last element...
*/
const char * /* O - Value of variable */
cgiGetVariable(const char *name)/* I - Name of variable */
{
const var_t *var; /* Returned variable */
var = cgi_find_variable(name);
#ifdef DEBUG
if (var == NULL)
printf("cgiGetVariable(\"%s\") is returning NULL...\n", name);
else
printf("cgiGetVariable(\"%s\") is returning \"%s\"...\n", name,
var->values[var->nvalues - 1]);
#endif /* DEBUG */
return ((var == NULL) ? NULL : var->values[var->nvalues - 1]);
}
/*
* 'cgiSetArray()' - Set array element N to the specified string.
*
* If the variable array is smaller than (element + 1), the intervening
* elements are set to NULL.
*/
void
cgiSetArray(const char *name, /* I - Name of variable */
int element, /* I - Element number (0 to N) */
const char *value) /* I - Value of variable */
{
int i; /* Looping var */
var_t *var; /* Returned variable */
if (name == NULL || value == NULL || element < 0)
return;
if ((var = cgi_find_variable(name)) == NULL)
{
cgi_add_variable(name, element, value);
cgi_sort_variables();
}
else
{
if (element >= var->avalues)
{
var->avalues = element + 16;
var->values = (const char **)realloc((void *)(var->values),
sizeof(char *) * var->avalues);
}
if (element >= var->nvalues)
{
for (i = var->nvalues; i < element; i ++)
var->values[i] = NULL;
var->nvalues = element + 1;
}
else if (var->values[element])
free((char *)var->values[element]);
var->values[element] = strdup(value);
}
}
/*
* 'cgiSetSize()' - Set the array size.
*/
void
cgiSetSize(const char *name, /* I - Name of variable */
int size) /* I - Number of elements (0 to N) */
{
int i; /* Looping var */
var_t *var; /* Returned variable */
if (name == NULL || size < 0)
return;
if ((var = cgi_find_variable(name)) == NULL)
return;
if (size >= var->avalues)
{
var->avalues = size + 16;
var->values = (const char **)realloc((void *)(var->values),
sizeof(char *) * var->avalues);
}
if (size > var->nvalues)
{
for (i = var->nvalues; i < size; i ++)
var->values[i] = NULL;
}
else if (size < var->nvalues)
{
for (i = size; i < var->nvalues; i ++)
if (var->values[i])
free((void *)(var->values[i]));
}
var->nvalues = size;
}
/*
* 'cgiSetVariable()' - Set a CGI variable in the database...
*
* If the variable is an array, this truncates the array to a single element.
*/
void
cgiSetVariable(const char *name, /* I - Name of variable */
const char *value) /* I - Value of variable */
{
int i; /* Looping var */
var_t *var; /* Returned variable */
if (name == NULL || value == NULL)
return;
if ((var = cgi_find_variable(name)) == NULL)
{
cgi_add_variable(name, 0, value);
cgi_sort_variables();
}
else
{
for (i = 0; i < var->nvalues; i ++)
if (var->values[i])
free((char *)var->values[i]);
var->values[0] = strdup(value);
var->nvalues = 1;
}
}
/*
* 'cgi_add_variable()' - Add a form variable.
*/
static void
cgi_add_variable(const char *name, /* I - Variable name */
int element, /* I - Array element number */
const char *value) /* I - Variable value */
{
var_t *var; /* New variable */
if (name == NULL || value == NULL)
return;
#ifdef DEBUG
printf("Adding variable \'%s\' with value \'%s\'...\n", name, value);
#endif /* DEBUG */
if (form_count >= form_alloc)
{
if (form_alloc == 0)
form_vars = malloc(sizeof(var_t) * 16);
else
form_vars = realloc(form_vars, (form_alloc + 16) * sizeof(var_t));
form_alloc += 16;
}
var = form_vars + form_count;
var->name = strdup(name);
var->nvalues = element + 1;
var->avalues = element + 1;
var->values = calloc(element + 1, sizeof(char *));
var->values[element] = strdup(value);
form_count ++;
}
/*
* 'cgi_compare_variables()' - Compare two variables.
*/
static int /* O - Result of comparison */
cgi_compare_variables(const var_t *v1, /* I - First variable */
const var_t *v2) /* I - Second variable */
{
return (strcasecmp(v1->name, v2->name));
}
/*
* 'cgi_find_variable()' - Find a variable...
*/
static var_t * /* O - Variable pointer or NULL */
cgi_find_variable(const char *name) /* I - Name of variable */
{
var_t key; /* Search key */
if (form_count < 1 || name == NULL)
return (NULL);
key.name = name;
return ((var_t *)bsearch(&key, form_vars, form_count, sizeof(var_t),
(int (*)(const void *, const void *))cgi_compare_variables));
}
/*
* 'cgi_initialize_get()' - Initialize form variables using the GET method.
*/
static int /* O - 1 if form data read */
cgi_initialize_get(void)
{
char *data; /* Pointer to form data string */
#ifdef DEBUG
puts("Initializing variables using GET method...");
#endif /* DEBUG */
/*
* Check to see if there is anything for us to read...
*/
data = getenv("QUERY_STRING");
if (data == NULL || strlen(data) == 0)
return (0);
/*
* Parse it out and return...
*/
return (cgi_initialize_string(data));
}
/*
* 'cgi_initialize_post()' - Initialize variables using the POST method.
*/
static int /* O - 1 if form data was read */
cgi_initialize_post(void)
{
char *content_length, /* Length of input data (string) */
*data; /* Pointer to form data string */
int length, /* Length of input data */
nbytes, /* Number of bytes read this read() */
tbytes, /* Total number of bytes read */
status; /* Return status */
#ifdef DEBUG
puts("Initializing variables using POST method...");
#endif /* DEBUG */
/*
* Check to see if there is anything for us to read...
*/
content_length = getenv("CONTENT_LENGTH");
if (content_length == NULL || atoi(content_length) == 0)
return (0);
/*
* Get the length of the input stream and allocate a buffer for it...
*/
length = atoi(content_length);
data = malloc(length + 1);
/*
* Read the data into the buffer...
*/
for (tbytes = 0; tbytes < length; tbytes += nbytes)
if ((nbytes = read(0, data + tbytes, length - tbytes)) < 0)
{
free(data);
return (0);
}
data[length] = '\0';
/*
* Parse it out...
*/
status = cgi_initialize_string(data);
/*
* Free the data and return...
*/
free(data);
return (status);
}
/*
* 'cgi_initialize_string()' - Initialize form variables from a string.
*/
static int
cgi_initialize_string(const char *data) /* I - Form data string */
{
int done; /* True if we're done reading a form variable */
char *s, /* Pointer to current form string */
ch, /* Temporary character */
name[255], /* Name of form variable */
value[65536]; /* Variable value... */
/*
* Check input...
*/
if (data == NULL)
return (0);
/*
* Loop until we've read all the form data...
*/
while (*data != '\0')
{
/*
* Get the variable name...
*/
for (s = name; *data != '\0'; data ++, s ++)
if (*data == '=')
break;
else
*s = *data;
*s = '\0';
if (*data == '=')
data ++;
else
return (0);
/*
* Read the variable value...
*/
for (s = value, done = 0; !done && *data != '\0'; data ++, s ++)
switch (*data)
{
case '&' : /* End of data... */
done = 1;
s --;
break;
case '+' : /* Escaped space character */
*s = ' ';
break;
case '%' : /* Escaped control character */
/*
* Read the hex code from stdin...
*/
data ++;
ch = *data - '0';
if (ch > 9)
ch -= 7;
*s = ch << 4;
data ++;
ch = *data - '0';
if (ch > 9)
ch -= 7;
*s |= ch;
break;
default : /* Other characters come straight through */
*s = *data;
break;
}
*s = '\0'; /* nul terminate the string */
/*
* Remove trailing whitespace...
*/
s --;
while (s >= value && *s == ' ')
*s-- = '\0';
/*
* Add the string to the variable "database"...
*/
if ((s = strrchr(name, '-')) != NULL && isdigit(s[1]))
{
*s++ = '\0';
cgiSetArray(name, atoi(s) - 1, value);
}
else if (cgiGetVariable(name) != NULL)
cgiSetArray(name, cgiGetSize(name), value);
else
cgiSetVariable(name, value);
}
return (1);
}
/*
* 'cgi_sort_variables()' - Sort all form variables for faster lookup.
*/
static void
cgi_sort_variables(void)
{
#ifdef DEBUG
int i;
puts("Sorting variables...");
#endif /* DEBUG */
if (form_count < 2)
return;
qsort(form_vars, form_count, sizeof(var_t),
(int (*)(const void *, const void *))cgi_compare_variables);
#ifdef DEBUG
puts("New variable list is:");
for (i = 0; i < form_count; i ++)
printf("%s = %s\n", form_vars[i].name, form_vars[i].value);
#endif /* DEBUG */
}
/*
* End of "$Id$".
*/
+7 -19
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Configuration file makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1993-2000 by Easy Software Products.
# Copyright 1993-1999 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -28,9 +28,7 @@ include ../Makedefs
# Config files...
#
KEEP = classes.conf client.conf cupsd.conf printers.conf
REPLACE = mime.convs mime.types
FILES = classes.conf cupsd.conf mime.convs mime.types printers.conf
#
# Make everything...
@@ -38,35 +36,25 @@ REPLACE = mime.convs mime.types
all:
#
# Clean all config and object files...
#
clean:
#
# Install files...
#
install:
-$(MKDIR) $(SERVERROOT)
$(CHMOD) ugo+rx $(SERVERROOT)
for file in $(KEEP); do \
if test -r $(SERVERROOT)/$$file ; then \
$(INSTALL_DATA) $$file $(SERVERROOT)/$$file.N ; \
-$(MKDIR) $(SERVERROOT)/conf
for file in $(FILES); do \
if test -e $(SERVERROOT)/conf/$$file ; then \
$(CP) $$file $(SERVERROOT)/conf/$$file.N ; \
else \
$(INSTALL_DATA) $$file $(SERVERROOT) ; \
$(CP) $$file $(SERVERROOT)/conf ; \
fi ; \
done
for file in $(REPLACE); do \
if test -r $(SERVERROOT)/$$file ; then \
$(MV) $(SERVERROOT)/$$file $(SERVERROOT)/$$file.O ; \
fi ; \
$(INSTALL_DATA) $$file $(SERVERROOT) ; \
done
#
# End of "$Id$".
+10 -27
Ver Arquivo
@@ -1,10 +1,10 @@
#
# "$Id: classes.conf 1152 2000-06-22 18:25:29Z mike $"
# "$Id: classes.conf 333 1999-05-17 18:03:40Z mike $"
#
# Sample class configuration file for the Common UNIX Printing System
# (CUPS) scheduler.
#
# 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
@@ -15,7 +15,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44141 Airport View Drive, Suite 204
# 44145 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -47,35 +47,18 @@
#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.
#
#Location Room 101 in the activities building
#
# State: sets the initial state of the class. Can be one of the
# following:
#
# Idle - Class is available to print new jobs.
# Stopped - Class is disabled but accepting new jobs.
#
#State Idle
#
# StateMessage: sets the printer-state-message attribute for the class.
#
#StateMessage Class is idle.
#
# Accepting: is the class accepting jobs?
#
#Accepting Yes
#Accepting No
#
#
# Printer: adds a printer to the class.
#
@@ -85,5 +68,5 @@
#</Class>
#
# End of "$Id: classes.conf 1152 2000-06-22 18:25:29Z mike $".
# End of "$Id: classes.conf 333 1999-05-17 18:03:40Z mike $".
#
-50
Ver Arquivo
@@ -1,50 +0,0 @@
#
# "$Id: client.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample client configuration file for the Common UNIX Printing System
# (CUPS).
#
# Copyright 1997-2000 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
# 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
#
########################################################################
# #
# This is the CUPS client configuration file. This file is used to #
# define client-specific parameters, such as the default server or #
# default printer. #
# #
########################################################################
#
# ServerName: the hostname of your server. By default CUPS will use the
# hostname of the system.
#
#ServerName myhost.domain.com
#
# DefaultPrinter: the default printer (or class) that clients should use.
#
#DefaultPrinter myprinter
#DefaultPrinter myprinter@host
#
# End of "$Id: client.conf 969 2000-03-10 16:56:46Z mike $".
#
+153 -379
Ver Arquivo
@@ -1,10 +1,10 @@
#
# "$Id: cupsd.conf 1344 2000-09-06 18:32:40Z mike $"
# "$Id: cupsd.conf 429 1999-06-21 19:43:22Z mike $"
#
# Sample configuration file for the Common UNIX Printing System (CUPS)
# scheduler.
#
# 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
@@ -15,7 +15,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44141 Airport View Drive, Suite 204
# 44145 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -34,17 +34,49 @@
# #
########################################################################
#
# 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
#
# 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.
#
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.
#
#ServerName myhost.domain.com
@@ -55,68 +87,36 @@
#ServerAdmin root@your.domain.com
#
# ServerRoot: the root directory for the scheduler.
# By default the compiled-in value.
#
########
######## Server Options
########
#ServerRoot /var/cups
#
# AccessLog: the access 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/access_log"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
# "logs/access_log"
#
#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"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
# "logs/error_log"
#
#ErrorLog /var/log/cups/error_log
#ErrorLog logs/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"
#
#FontPath /usr/share/cups/fonts
#PageLog logs/page_log
#
# LogLevel: controls the number of messages logged to the ErrorLog
@@ -139,133 +139,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 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
#
# Printcap: the name of the printcap file. Default is no filename.
# 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
########
######## 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
#
#Port 80
Port 631
#MaxRequestSize 0
#
# HostNameLookups: whether or not to do lookups on IP addresses to get a
@@ -274,6 +152,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.
@@ -288,137 +172,6 @@ Port 631
#KeepAliveTimeout 60
#
# MaxClients: controls the maximum number of simultaneous clients that
# will be handled. Defaults to 100.
#
#MaxClients 100
#
# 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 printer information to
# other CUPS servers. Enabled by default.
#
#Browsing On
#
# BrowseShortNames: whether or not to use "short" names for remote printers
# when possible (e.g. "printer" instead of "printer@host".) Enabled by
# default.
#
#BrowseShortNames Yes
#
# BrowseAddress: specifies a broadcast address to be used. By
# default browsing information is broadcast to all active interfaces.
#
# 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
#
# BrowseAllow: specifies an address mask to allow for incoming browser
# packets. The default is to allow packets from all addresses.
#
# BrowseDeny: specifies an address mask to deny for incoming browser
# packets. The default is to deny packets from no addresses.
#
# Both "BrowseAllow" and "BrowseDeny" accept the following notations for
# addresses:
#
# All
# None
# *.domain.com
# .domain.com
# host.domain.com
# nnn.*
# nnn.nnn.*
# nnn.nnn.nnn.*
# nnn.nnn.nnn.nnn
# nnn.nnn.nnn.nnn/mm
# nnn.nnn.nnn.nnn/mmm.mmm.mmm.mmm
#
# The hostname/domainname restrictions only work if you have turned hostname
# lookups on!
#
#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.
#
#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.
#
#BrowseTimeout 300
#
# ImplicitClasses: whether or not to use implicit classes.
#
@@ -438,32 +191,98 @@ Port 631
#ImplicitClasses On
########
######## Security Options
########
#
# 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.)
# Browsing: whether or not to broadcast printer information to
# other CUPS servers. Enabled by default.
#
#SystemGroup sys
#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.
#
#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 broadcast to all active interfaces.
#
# 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
#
# DocumentRoot: the root directory for HTTP documents that are served.
# By default the compiled in directory.
#
#DocumentRoot /usr/share/cups/doc
#
# DefaultLanguage: the default language if not specified by the browser.
# If not specified, the current locale is used.
#
#DefaultLanguage en
#
# DefaultCharset: the default character set to use. If not specified,
# defaults to iso-8859-1. Note that this can also be overridden in
# HTML documents...
#
#DefaultCharset iso-8859-1
#
# 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 "32m" (32 megabytes).
#
#RIPCache: 32m
#
# 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
#
# Access permissions for each directory served by the scheduler.
# Locations are relative to DocumentRoot...
#
# AuthType: the authorization to use:
#
# None - Perform no authentication
# Basic - Perform authentication using the HTTP Basic method.
# 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)
# AuthType: the authorization to use; currently only "Basic" authorization is
# supported.
#
# AuthClass: the authorization class; currently only "Anonymous", "User",
# "System" (valid user belonging to group SystemGroup), and "Group"
@@ -479,77 +298,32 @@ Port 631
# Deny: denies access from the specified hostname, domain, IP address, or
# network.
#
# Both "Allow" and "Deny" accept the following notations for addresses:
#
# All
# None
# *.domain.com
# .domain.com
# host.domain.com
# nnn.*
# nnn.nnn.*
# nnn.nnn.nnn.*
# nnn.nnn.nnn.nnn
# nnn.nnn.nnn.nnn/mm
# nnn.nnn.nnn.nnn/mmm.mmm.mmm.mmm
#
# The host and domain address require that you enable hostname lookups
# with "HostNameLookups On" above.
#
<Location />
</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.
#
## Anonymous access (default)
#AuthType None
## Require a username and password (Basic authentication)
## Require a username and password
#AuthType Basic
#AuthClass User
## Require a username and password (Digest/MD5 authentication)
#AuthType Digest
#AuthClass User
## Restrict access to local domain
#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.
# is a member of group "sys" to do any admin tasks. You can change the
# group name using the SystemGroup directive.
#
AuthType Basic
@@ -562,5 +336,5 @@ Allow From 127.0.0.1
</Location>
#
# End of "$Id: cupsd.conf 1344 2000-09-06 18:32:40Z mike $".
# End of "$Id: cupsd.conf 429 1999-06-21 19:43:22Z mike $".
#
+250
Ver Arquivo
@@ -0,0 +1,250 @@
#
# "$Id: cupsd.conf-personal 407 1999-06-17 20:02:43Z mike $"
#
# Scheduler configuration file for ESP Print Personal.
#
########################################################################
# #
# This is the CUPS configuration file. If you are familiar with #
# Apache or any of the other popular web servers, we've followed the #
# same format. Any configuration variable used here has the same #
# semantics as the corresponding variable in Apache. If we need #
# different functionality then a different name is used to avoid #
# confusion... #
# #
########################################################################
#
# 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 Listen lines to listen to more than one
# port:
#
# Listen 127.0.0.1:80
# Listen 127.0.0.1:631
#
# For ESP Print Personal, we can only listen on the local host...
#
#Listen 127.0.0.1:80
Listen 127.0.0.1:631
#
# 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.
#
SystemGroup sys
#
# ServerName: the hostname of your server, as advertised to the world.
# By default CUPS will use the hostname of the system.
#
#ServerName myhost.domain.com
#
# ServerAdmin: the email address to send all complaints/problems to.
# By default CUPS will use "root@hostname".
#
#ServerAdmin root@your.domain.com
#
# ServerRoot: the root directory for the scheduler.
# By default the compiled-in value.
#
#ServerRoot /var/cups
#
# AccessLog: the access log file; if this does not start with a leading /
# then it is assumed to be relative to ServerRoot. By default set to
# "logs/access_log"
#
#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
# "logs/error_log"
#
#ErrorLog logs/error_log
#
# 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"
#
#PageLog logs/page_log
#
# LogLevel: controls the number of messages logged to the ErrorLog
# file and can be one of the following:
#
# debug Log everything.
# info Log all requests and state changes.
# warn Log errors and warnings.
# error Log only errors.
# none Log nothing.
#
LogLevel info
#
# MaxLogSize: controls the maximum size of each log file before they are
# rotated. Defaults to 1048576 (1MB). Set to 0 to disable log rotating.
#
#MaxLogSize 0
#
# MaxRequestSize: controls the maximum size of print files. Set to 0 to
# disable this feature (defaults to 0.)
#
#MaxRequestSize 0
#
# HostNameLookups: whether or not to do lookups on IP addresses to get a
# fully-qualified hostname. This defaults to Off for performance reasons...
#
#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.
#
#KeepAlive On
#
# KeepAliveTimeout: the timeout before Keep-Alive connections are
# automatically closed. Default is 60 seconds.
#
#KeepAliveTimeout 60
#
# Browsing: not available in ESP Print Personal.
#
Browsing Off
#
# DocumentRoot: the root directory for HTTP documents that are served.
# By default the compiled in directory.
#
#DocumentRoot /usr/share/cups/doc
#
# DefaultLanguage: the default language if not specified by the browser.
# If not specified, the current locale is used.
#
#DefaultLanguage en
#
# DefaultCharset: the default character set to use. If not specified,
# defaults to iso-8859-1. Note that this can also be overridden in
# HTML documents...
#
#DefaultCharset iso-8859-1
#
# 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 "32m" (32 megabytes).
#
#RIPCache: 32m
#
# Access permissions for each directory served by the scheduler.
# Locations are relative to DocumentRoot...
#
# AuthType: the authorization to use; currently only "Basic" authorization is
# supported.
#
# AuthClass: the authorization class; currently only "Anonymous", "User",
# "System" (valid user belonging to group SystemGroup), and "Group"
# (valid user belonging to the specified group) are supported.
#
# AuthGroupName: the group name for "Group" authorization.
#
# Order: the order of Allow/Deny processing.
#
# Allow: allows access from the specified hostname, domain, IP address, or
# network.
#
# Deny: denies access from the specified hostname, domain, IP address, or
# network.
#
<Location />
</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.
#
## Require a username and password
#AuthType Basic
#AuthClass User
## Restrict access to local domain
#Order Deny,Allow
#Deny From All
#Allow From .mydomain.com
</Location>
<Location /admin>
#
# 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 group "sys" to do any admin tasks. You can change the
# group name using the SystemGroup directive.
#
AuthType Basic
AuthClass System
## Restrict access to local domain
Order Deny,Allow
Deny From All
Allow From 127.0.0.1
</Location>
#
# End of "$Id: cupsd.conf-personal 407 1999-06-17 20:02:43Z mike $".
#
+313
Ver Arquivo
@@ -0,0 +1,313 @@
#
# "$Id: cupsd.conf-professional 407 1999-06-17 20:02:43Z mike $"
#
# Scheduler configuration file for ESP Print Professional.
#
########################################################################
# #
# This is the CUPS configuration file. If you are familiar with #
# Apache or any of the other popular web servers, we've followed the #
# same format. Any configuration variable used here has the same #
# semantics as the corresponding variable in Apache. If we need #
# different functionality then a different name is used to avoid #
# confusion... #
# #
########################################################################
#
# 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
#
#Port 80
Port 631
#
# 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.
#
SystemGroup sys
#
# ServerName: the hostname of your server, as advertised to the world.
# By default CUPS will use the hostname of the system.
#
#ServerName myhost.domain.com
#
# ServerAdmin: the email address to send all complaints/problems to.
# By default CUPS will use "root@hostname".
#
#ServerAdmin root@your.domain.com
#
# ServerRoot: the root directory for the scheduler.
# By default the compiled-in value.
#
#ServerRoot /var/cups
#
# AccessLog: the access log file; if this does not start with a leading /
# then it is assumed to be relative to ServerRoot. By default set to
# "logs/access_log"
#
#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
# "logs/error_log"
#
#ErrorLog logs/error_log
#
# 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"
#
#PageLog logs/page_log
#
# LogLevel: controls the number of messages logged to the ErrorLog
# file and can be one of the following:
#
# debug Log everything.
# info Log all requests and state changes.
# warn Log errors and warnings.
# error Log only errors.
# none Log nothing.
#
LogLevel info
#
# MaxLogSize: controls the maximum size of each log file before they are
# rotated. Defaults to 1048576 (1MB). Set to 0 to disable log rotating.
#
#MaxLogSize 0
#
# MaxRequestSize: controls the maximum size of print files. Set to 0 to
# disable this feature (defaults to 0.)
#
#MaxRequestSize 0
#
# HostNameLookups: whether or not to do lookups on IP addresses to get a
# fully-qualified hostname. This defaults to Off for performance reasons...
#
#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.
#
#KeepAlive On
#
# KeepAliveTimeout: the timeout before Keep-Alive connections are
# automatically closed. Default is 60 seconds.
#
#KeepAliveTimeout 60
#
# 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.
#
#ImplicitClasses On
#
# 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.
#
#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 broadcast to all active interfaces.
#
# 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
#
# DocumentRoot: the root directory for HTTP documents that are served.
# By default the compiled in directory.
#
#DocumentRoot /usr/share/cups/doc
#
# DefaultLanguage: the default language if not specified by the browser.
# If not specified, the current locale is used.
#
#DefaultLanguage en
#
# DefaultCharset: the default character set to use. If not specified,
# defaults to iso-8859-1. Note that this can also be overridden in
# HTML documents...
#
#DefaultCharset iso-8859-1
#
# 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 "32m" (32 megabytes).
#
#RIPCache: 32m
#
# Access permissions for each directory served by the scheduler.
# Locations are relative to DocumentRoot...
#
# AuthType: the authorization to use; currently only "Basic" authorization is
# supported.
#
# AuthClass: the authorization class; currently only "Anonymous", "User",
# "System" (valid user belonging to group SystemGroup), and "Group"
# (valid user belonging to the specified group) are supported.
#
# AuthGroupName: the group name for "Group" authorization.
#
# Order: the order of Allow/Deny processing.
#
# Allow: allows access from the specified hostname, domain, IP address, or
# network.
#
# Deny: denies access from the specified hostname, domain, IP address, or
# network.
#
<Location />
</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.
#
## Require a username and password
#AuthType Basic
#AuthClass User
## Restrict access to local domain
#Order Deny,Allow
#Deny From All
#Allow From .mydomain.com
</Location>
<Location /admin>
#
# 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 group "sys" to do any admin tasks. You can change the
# group name using the SystemGroup directive.
#
AuthType Basic
AuthClass System
## Restrict access to local domain
Order Deny,Allow
Deny From All
Allow From 127.0.0.1
</Location>
#
# End of "$Id: cupsd.conf-professional 407 1999-06-17 20:02:43Z mike $".
#
+12 -28
Ver Arquivo
@@ -1,9 +1,9 @@
#
# "$Id: mime.convs 1340 2000-09-06 13:53:00Z mike $"
# "$Id: mime.convs 237 1999-04-21 19:29:35Z 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 237 1999-04-21 19:29:35Z mike $".
#
+13 -35
Ver Arquivo
@@ -1,9 +1,9 @@
#
# "$Id: mime.types 1340 2000-09-06 13:53:00Z mike $"
# "$Id: mime.types 185 1999-03-24 18:38:50Z 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
@@ -97,11 +92,13 @@ image/x-sgi-rgb rgb sgi bw icon short(0,474)
image/x-xbitmap xbm
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 Sun Raster, Alias, SoftImage, GIMP??? files
image/x-sun-raster ras
#image/x-alias pix
#image/x-softimage
#image/x-gimp-xcf xcf xcf.gz
########################################################################
#
@@ -110,13 +107,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,22 +114,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)
application/vnd.cups-postscript
application/vnd.cups-raster string(0,"RaSt") string(0,"tSaR")
application/vnd.cups-raw
########################################################################
#
# 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
#
# End of "$Id: mime.types 1340 2000-09-06 13:53:00Z mike $".
# End of "$Id: mime.types 185 1999-03-24 18:38:50Z mike $".
#
-2
Ver Arquivo
@@ -1,2 +0,0 @@
# This is a dummy printcap file that is automatically generated by the
# CUPS software for old applications that rely on it.
+11 -18
Ver Arquivo
@@ -1,10 +1,10 @@
#
# "$Id: printers.conf 1152 2000-06-22 18:25:29Z mike $"
# "$Id: printers.conf 334 1999-05-17 18:11:26Z mike $"
#
# Sample printer configuration file for the Common UNIX Printing System
# (CUPS) scheduler.
#
# 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
@@ -15,7 +15,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44141 Airport View Drive, Suite 204
# 44145 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -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.
#
@@ -71,26 +77,13 @@
# State: sets the initial state of the printer. Can be one of the
# following:
#
# Idle - Printer is available to print new jobs.
# Idle - Printer is available to accept new jobs.
# Stopped - Printer is disabled but accepting new jobs.
#
#State Idle
#
# StateMessage: sets the printer-state-message attribute for the printer.
#
#StateMessage Printer is idle.
#
# Accepting: is the printer accepting jobs?
#
#Accepting Yes
#Accepting No
#</Printer>
#
# End of "$Id: printers.conf 1152 2000-06-22 18:25:29Z mike $".
# End of "$Id: printers.conf 334 1999-05-17 18:11:26Z mike $".
#
+5 -39
Ver Arquivo
@@ -5,7 +5,7 @@
*
* @configure_input@
*
* 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
@@ -28,21 +28,15 @@
* Version of software...
*/
#define CUPS_SVERSION "CUPS v1.1.3"
#define CUPS_SVERSION "CUPS v1.0"
/*
* Where are files stored?
*/
#define CUPS_LOCALEDIR "/usr/share/locale"
#define CUPS_SERVERROOT "/etc/cups"
#define CUPS_SERVERBIN "/usr/lib/cups"
#define CUPS_DOCROOT "/usr/share/doc/cups"
#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"
#define CUPS_LOCALEDIR "/usr/lib/locale"
#define CUPS_SERVERROOT "/var/cups"
#define CUPS_DATADIR "/usr/share/cups"
/*
* Do we have various image libraries?
@@ -68,14 +62,6 @@
#undef HAVE_SYS_NDIR_H
#undef HAVE_NDIR_H
/*
* Do we have PAM stuff?
*/
#ifndef HAVE_LIBPAM
#define HAVE_LIBPAM 0
#endif /* !HAVE_LIBPAM */
/*
* Do we have <shadow.h>?
*/
@@ -96,19 +82,6 @@
#undef HAVE_STRCASECMP
#undef HAVE_STRNCASECMP
/*
* Do we have the vsyslog() function?
*/
#undef HAVE_VSYSLOG
/*
* Do we have the (v)snprintf() functions?
*/
#undef HAVE_SNPRINTF
#undef HAVE_VSNPRINTF
/*
* What signal functions to use?
*/
@@ -123,13 +96,6 @@
#undef HAVE_WAITPID
#undef HAVE_WAIT3
/*
* Do we have the mallinfo function and malloc.h?
*/
#undef HAVE_MALLINFO
#undef HAVE_MALLOC_H
/*
* End of "$Id$".
*/
+76 -452
Ver Arquivo
@@ -3,7 +3,7 @@ dnl "$Id$"
dnl
dnl Configuration script for the Common UNIX Printing System (CUPS).
dnl
dnl Copyright 1997-2000 by Easy Software Products, all rights reserved.
dnl Copyright 1997-1999 by Easy Software Products, all rights reserved.
dnl
dnl These coded instructions, statements, and computer programs are the
dnl property of Easy Software Products and are protected by Federal
@@ -24,535 +24,159 @@ 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...
dnl Clear default debugging options and set normal optimization by
dnl default unless the user asks for debugging specifically.
uname=`uname`
uversion=`uname -r | sed -e '1,$s/[[^0-9]]//g'`
if test "$uname" = "IRIX64"; then
uname="IRIX"
fi
dnl CFLAGS="${CFLAGS:=}"
dnl CXXFLAGS="${CXXFLAGS:=}"
dnl OPTIM="-O"
dnl AC_SUBST(OPTIM)
dnl Clear the debugging and non-shared library options unless the user asks
dnl for them...
dnl AC_ARG_ENABLE(debug, [ --enable-debug turn on debugging [default=no]],
dnl if eval "test x$enable_debug = xyes"; then
dnl OPTIM="-g"
dnl fi)
dnl Clear default debugging options and set debugging by
dnl default unless the user asks for no debugging specifically.
OPTIM=""
AC_SUBST(OPTIM)
PICFLAG=1
CFLAGS="${CFLAGS:=}"
CXXFLAGS="${CXXFLAGS:=}"
OPTIM="-g"
AC_SUBST(OPTIM)
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(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*)
LIBCUPS="libcups.so.2"
LIBCUPSIMAGE="libcupsimage.so.2"
DSO="\$(CC) -Wl,-h,\$@ -G \$(OPTIM) -o"
;;
HP-UX*)
LIBCUPS="libcups.sl.2"
LIBCUPSIMAGE="libcupsimage.sl.2"
DSO="ld -b -z +h \$@ -o"
;;
FreeBSD* | NetBSD* | OpenBSD*)
LIBCUPS="libcups.so.2"
LIBCUPSIMAGE="libcupsimage.so.2"
DSO="\$(CC) -Wl,-soname,\$@ -shared \$(OPTIM) -o"
;;
OSF1* | Linux*)
LIBCUPS="libcups.so.2"
LIBCUPSIMAGE="libcupsimage.so.2"
DSO="\$(CC) -Wl,-soname,\$@ -shared \$(OPTIM) -o"
;;
IRIX*)
LIBCUPS="libcups.so.2"
LIBCUPSIMAGE="libcupsimage.so.2"
DSO="\$(CC) -soname \$@ -shared \$(OPTIM) -o"
;;
*)
echo "Warning: shared libraries may not be supported. Trying -shared"
echo " option with compiler."
LIBCUPS="libcups.so.2"
LIBCUPSIMAGE="libcupsimage.so.2"
DSO="\$(CC) -Wl,-soname,\$@ -shared \$(OPTIM) -o"
;;
esac
else
PICFLAG=0
LIBCUPS="libcups.a"
LIBCUPSIMAGE="libcupsimage.a"
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="")
AC_ARG_ENABLE(debug, [ --disable-debug turn off debugging [default=no]],
if eval "test x$disable_debug = xyes"; then
OPTIM="-O"
fi)
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)
if test "$NROFF" = ""; then
AC_PATH_PROG(GROFF,groff)
if test "$GROFF" = ""; then
AC_PATH_PROG(NROFF,groff)
if test "$NROFF" = ""; then
NROFF="echo"
else
NROFF="$GROFF -T ascii"
NROFF="$NROFF -T ascii"
fi
fi
AC_PATH_PROG(HTMLDOC,htmldoc)
AC_PATH_PROG(MKDIR,mkdir)
AC_PATH_PROG(PACK,pack)
if test "$PACK" = ""; then
AC_PATH_PROG(PACK,gzip)
if test "$PACK" = ""; then
PACK="echo"
CAT="dummy"
else
PACK="$PACK -fv9"
CAT="gz"
fi
else
PACK="$PACK -f"
CAT="z"
fi
AC_SUBST(CAT)
AC_PATH_PROG(RM,rm)
AC_PATH_PROG(SED,sed)
AC_PATH_PROG(SMBCLIENT,smbclient)
if test "$SMBCLIENT" = ""; then
echo "Looking for smbclient in standard locations..."
AC_PATH_PROG(SMBCLIENT,smbclient,samba_not_detected,
/usr/samba/bin:/usr/local/samba/bin:/usr/freeware/samba/bin:/opt/samba/bin)
fi
dnl Architecture checks...
AC_C_BIGENDIAN
uname=`uname`
if test "$uname" = "IRIX64"; then
uname=IRIX
fi
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=""
AC_SUBST(NETLIBS)
AC_CHECK_LIB(socket,socket,
if test "$uname" != "IRIX"; then
NETLIBS="-lsocket"
LIBS="$LIBS -lsocket"
else
echo "Not using -lsocket since you are running IRIX."
fi)
AC_CHECK_LIB(nsl,gethostbyaddr,
if test "$uname" != "IRIX"; then
NETLIBS="$NETLIBS -lnsl"
LIBS="$LIBS -lnsl"
else
echo "Not using -lnsl since you are running IRIX."
fi)
dnl Save the current libraries since we don't want the image libraries
dnl included with every program...
SAVELIBS="$LIBS"
dnl Check for image libraries...
LIBJPEG=""
LIBPNG=""
LIBTIFF=""
LIBZ=""
AC_SUBST(LIBJPEG)
AC_SUBST(LIBPNG)
AC_SUBST(LIBTIFF)
AC_SUBST(LIBZ)
AC_CHECK_LIB(jpeg, jpeg_destroy_decompress,
IMGLIBS=""
AC_SUBST(IMGLIBS)
AC_CHECK_HEADER(jpeglib.h,
AC_DEFINE(HAVE_LIBJPEG)
LIBJPEG="-ljpeg"
LIBS="$LIBS -ljpeg")
AC_CHECK_LIB(z, gzgets,
IMGLIBS="$IMGLIBS -ljpeg")
AC_CHECK_HEADER(zlib.h,
AC_DEFINE(HAVE_LIBZ)
LIBZ="-lz"
LIBS="$LIBS -lz")
dnl PNG library uses math library functions...
AC_CHECK_LIB(m, pow)
AC_CHECK_LIB(png, png_set_tRNS_to_alpha,
IMGLIBS="$IMGLIBS -lz")
AC_CHECK_HEADER(png.h,
AC_DEFINE(HAVE_LIBPNG)
LIBPNG="-lpng")
AC_CHECK_LIB(tiff, TIFFReadScanline,
IMGLIBS="$IMGLIBS -lpng")
AC_CHECK_HEADER(tiff.h,
AC_DEFINE(HAVE_LIBTIFF)
LIBTIFF="-ltiff")
dnl Restore original LIBS settings...
LIBS="$SAVELIBS"
IMGLIBS="$IMGLIBS -ltiff")
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)
AC_CHECK_FUNCS(strcasecmp)
AC_CHECK_FUNCS(strncasecmp)
AC_CHECK_FUNCS(snprintf)
AC_CHECK_FUNCS(vsnprintf)
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.
AC_CHECK_FUNCS(waitpid)
AC_CHECK_FUNCS(wait3)
dnl Update compiler options...
if test -n "$GCC"; then
if test -z "$OPTIM"; then
OPTIM="-O2 -g3"
fi
if test $PICFLAG = 1; then
OPTIM="-fPIC $OPTIM"
fi
OPTIM="-Wall $OPTIM"
else
case $uname in
IRIX*)
if test -z "$OPTIM"; then
OPTIM="-O2 -g3"
fi
if test $uversion -ge 62; then
OPTIM="$OPTIM -n32 -mips3"
fi
OPTIM="-fullwarn $OPTIM"
;;
HP-UX*)
if test -z "$OPTIM"; then
OPTIM="+O2 -g3"
fi
OPTIM="-Ae $OPTIM"
;;
SunOS*)
# Solaris
if test -z "$OPTIM"; then
OPTIM="-O -g3"
fi
if test $PICFLAG = 1; then
OPTIM="-KPIC $OPTIM"
fi
;;
*)
# Running some other operating system; inform the user they
# should contribute the necessary options to
# cups-support@cups.org...
echo "Building CUPS with default compiler optimizations; contact"
echo "cups-support@cups.org with uname and compiler options needed"
echo "for your platform, or set the CFLAGS environment variable"
echo "before running configure."
;;
esac
fi
if test "$DSO" != ":"; then
# When using DSOs the image libraries are linked to libcupsimage.so
# rather than to the executables. This makes things smaller if you
# are using any static libraries, and it also allows us to distribute
# a single DSO rather than a bunch...
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!)
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"
;;
esac
else
DSOLIBS=""
IMGLIBS="\$(LIBJPEG) \$(LIBPNG) \$(LIBTIFF) \$(LIBZ)"
fi
AC_SUBST(DSO)
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="/"
prefix="/usr"
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" -a "$prefix" = "/"; then
datadir="/usr/share"
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
fi
dnl Fix "libdir" variable for IRIX 6.x...
if test "$uname" = "IRIX" -a $uversion -ge 62; then
libdir="$exec_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
fi
dnl Fix "fontpath" variable...
if test "x$fontpath" = "x"; then
fontpath="$datadir/cups/fonts"
fi
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...
if test $prefix = "/"; then
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
dnl CUPS_SERVERROOT needs special attention for the default location...
if test "$prefix" = "/usr"; then
CUPS_SERVERROOT="/var/cups"
else
INITDIR="/etc"
INITDDIR="../init.d"
CUPS_SERVERROOT="$prefix/var/cups"
fi
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_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$CUPS_SERVERROOT")
AC_SUBST(CUPS_SERVERROOT)
AC_SUBST(CUPS_SERVERBIN)
AC_SUBST(CUPS_LOGDIR)
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")
;;
OSF1*)
CUPS_LOCALEDIR='${exec_prefix}/lib/nls/msg'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$exec_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")
;;
esac
CUPS_LOCALEDIR="$prefix/lib/locale"
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$CUPS_LOCALEDIR")
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")
dnl Set the CUPS_DATAFILE directory...
CUPS_DATADIR="$prefix/share/cups"
AC_DEFINE_UNQUOTED(CUPS_DATADIR, "$CUPS_DATADIR")
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_FONTPATH directory...
AC_DEFINE_UNQUOTED(CUPS_FONTPATH, "$fontpath")
AC_OUTPUT(Makedefs cups.sh)
AC_OUTPUT(Makedefs)
dnl
dnl End of "$Id$".
-15
Ver Arquivo
@@ -15,21 +15,6 @@ 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>
+265 -467
Ver Arquivo
@@ -1,10 +1,13 @@
#
# "$Id: cups.list 1368 2000-09-14 18:04:10Z mike $"
# "$Id: cups.list 432 1999-06-21 20:14:24Z mike $"
#
# ESP Package Manager (EPM) file list for the Common UNIX Printing
# System (CUPS).
#
# Copyright 1997-2000 by Easy Software Products, all rights reserved.
# EPM can be found in the "epm" subdirectory of this distribution.
# Please report problems and fixes to Michael Sweet (mike@easysw.com).
#
# 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
@@ -24,488 +27,283 @@
#
%product Common UNIX Printing System
%copyright 1993-2000 by Easy Software Products, All Rights Reserved.
%copyright 1993-1999 by Easy Software Products, All Rights Reserved.
%vendor Easy Software Products
%license LICENSE.txt
%readme README.txt
%version 1.1.3
%incompat printpro
%license LICENSE.cups
%readme README.cups
%version 1.0b4
%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
# 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
f 0555 root sys /var/cups/backend/ipp backend/ipp
f 4555 root sys /var/cups/backend/lpd backend/lpd
f 0555 root sys /var/cups/backend/parallel backend/parallel
f 0555 root sys /var/cups/backend/serial backend/serial
f 0555 root sys /var/cups/backend/smb backend/smb
f 0555 root sys /var/cups/backend/socket backend/socket
f 0500 root sys /usr/sbin/cupsd scheduler/cupsd
f 0555 root sys /var/cups/cgi-bin/classes.cgi cgi-bin/classes.cgi
f 0555 root sys /var/cups/cgi-bin/jobs.cgi cgi-bin/jobs.cgi
f 0555 root sys /var/cups/cgi-bin/printers.cgi cgi-bin/printers.cgi
f 0555 root sys /var/cups/filter/pstoraster pstoraster/pstoraster
f 0555 root sys /var/cups/filter/imagetops filter/imagetops
f 0555 root sys /var/cups/filter/pstops filter/pstops
f 0555 root sys /var/cups/filter/texttops filter/texttops
f 0555 root sys /var/cups/filter/rastertohp filter/rastertohp
f 0555 root sys /var/cups/filter/hpgltops filter/hpgltops
f 0555 root sys /var/cups/filter/imagetoraster filter/imagetoraster
# 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
# 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
%system all
f 0555 root sys /usr/bin/lp systemv/lp
f 0555 root sys /usr/bin/lpstat systemv/lpstat
f 0555 root sys /usr/lib/lpadmin systemv/lpadmin
f 0555 root sys /usr/lib/cancel systemv/cancel
f 0555 root sys /usr/lib/accept systemv/accept
l 0555 root sys /usr/lib/reject accept
l 0555 root sys /usr/bin/disable /usr/lib/accept
l 0555 root sys /usr/bin/enable /usr/lib/accept
f 0555 root sys /usr/sbin/lpc berkeley/lpc
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
# Directories
d 0755 root sys $LOGDIR -
d 0700 lp sys $REQUESTS -
d 1700 lp sys $REQUESTS/tmp -
d 0755 root sys /var/cups/interfaces
d 0755 root sys /var/cups/logs
d 0755 root sys /var/cups/ppd
d 0755 root sys /var/cups/requests
# 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
d 0555 root sys $DATADIR -
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
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
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
d 0555 root sys $DATADIR/fonts -
f 0444 root sys $DATADIR/fonts/AvantGarde-Book fonts/AvantGarde-Book
f 0444 root sys $DATADIR/fonts/AvantGarde-BookOblique fonts/AvantGarde-BookOblique
f 0444 root sys $DATADIR/fonts/AvantGarde-Demi fonts/AvantGarde-Demi
f 0444 root sys $DATADIR/fonts/AvantGarde-DemiOblique fonts/AvantGarde-DemiOblique
f 0444 root sys $DATADIR/fonts/Bookman-Demi fonts/Bookman-Demi
f 0444 root sys $DATADIR/fonts/Bookman-DemiItalic fonts/Bookman-DemiItalic
f 0444 root sys $DATADIR/fonts/Bookman-Light fonts/Bookman-Light
f 0444 root sys $DATADIR/fonts/Bookman-LightItalic fonts/Bookman-LightItalic
f 0444 root sys $DATADIR/fonts/Charter-Bold fonts/Charter-Bold
f 0444 root sys $DATADIR/fonts/Charter-BoldItalic fonts/Charter-BoldItalic
f 0444 root sys $DATADIR/fonts/Charter-Italic fonts/Charter-Italic
f 0444 root sys $DATADIR/fonts/Charter-Roman fonts/Charter-Roman
f 0444 root sys $DATADIR/fonts/Courier fonts/Courier
f 0444 root sys $DATADIR/fonts/Courier-Bold fonts/Courier-Bold
f 0444 root sys $DATADIR/fonts/Courier-BoldOblique fonts/Courier-BoldOblique
f 0444 root sys $DATADIR/fonts/Courier-Oblique fonts/Courier-Oblique
f 0444 root sys $DATADIR/fonts/Helvetica fonts/Helvetica
f 0444 root sys $DATADIR/fonts/Helvetica-Bold fonts/Helvetica-Bold
f 0444 root sys $DATADIR/fonts/Helvetica-BoldOblique fonts/Helvetica-BoldOblique
f 0444 root sys $DATADIR/fonts/Helvetica-Narrow fonts/Helvetica-Narrow
f 0444 root sys $DATADIR/fonts/Helvetica-Narrow-Bold fonts/Helvetica-Narrow-Bold
f 0444 root sys $DATADIR/fonts/Helvetica-Narrow-BoldOblique fonts/Helvetica-Narrow-BoldOblique
f 0444 root sys $DATADIR/fonts/Helvetica-Narrow-Oblique fonts/Helvetica-Narrow-Oblique
f 0444 root sys $DATADIR/fonts/Helvetica-Oblique fonts/Helvetica-Oblique
f 0444 root sys $DATADIR/fonts/NewCenturySchlbk-Bold fonts/NewCenturySchlbk-Bold
f 0444 root sys $DATADIR/fonts/NewCenturySchlbk-BoldItalic fonts/NewCenturySchlbk-BoldItalic
f 0444 root sys $DATADIR/fonts/NewCenturySchlbk-Italic fonts/NewCenturySchlbk-Italic
f 0444 root sys $DATADIR/fonts/NewCenturySchlbk-Roman fonts/NewCenturySchlbk-Roman
f 0444 root sys $DATADIR/fonts/Palatino-Bold fonts/Palatino-Bold
f 0444 root sys $DATADIR/fonts/Palatino-BoldItalic fonts/Palatino-BoldItalic
f 0444 root sys $DATADIR/fonts/Palatino-Italic fonts/Palatino-Italic
f 0444 root sys $DATADIR/fonts/Palatino-Roman fonts/Palatino-Roman
f 0444 root sys $DATADIR/fonts/Symbol fonts/Symbol
f 0444 root sys $DATADIR/fonts/Times-Bold fonts/Times-Bold
f 0444 root sys $DATADIR/fonts/Times-BoldItalic fonts/Times-BoldItalic
f 0444 root sys $DATADIR/fonts/Times-Italic fonts/Times-Italic
f 0444 root sys $DATADIR/fonts/Times-Roman fonts/Times-Roman
f 0444 root sys $DATADIR/fonts/Utopia-Bold fonts/Utopia-Bold
f 0444 root sys $DATADIR/fonts/Utopia-BoldItalic fonts/Utopia-BoldItalic
f 0444 root sys $DATADIR/fonts/Utopia-Italic fonts/Utopia-Italic
f 0444 root sys $DATADIR/fonts/Utopia-Regular fonts/Utopia-Regular
f 0444 root sys $DATADIR/fonts/ZapfChancery-MediumItalic fonts/ZapfChancery-MediumItalic
f 0444 root sys $DATADIR/fonts/ZapfDingbats fonts/ZapfDingbats
d 0555 root sys $DATADIR/pstoraster -
f 0444 root sys $DATADIR/pstoraster/Fontmap pstoraster/Fontmap
f 0444 root sys $DATADIR/pstoraster/gs_btokn.ps pstoraster/gs_btokn.ps
f 0444 root sys $DATADIR/pstoraster/gs_ccfnt.ps pstoraster/gs_ccfnt.ps
f 0444 root sys $DATADIR/pstoraster/gs_cff.ps pstoraster/gs_cff.ps
f 0444 root sys $DATADIR/pstoraster/gs_cidfn.ps pstoraster/gs_cidfn.ps
f 0444 root sys $DATADIR/pstoraster/gs_cmap.ps pstoraster/gs_cmap.ps
f 0444 root sys $DATADIR/pstoraster/gs_cmdl.ps pstoraster/gs_cmdl.ps
f 0444 root sys $DATADIR/pstoraster/gs_dbt_e.ps pstoraster/gs_dbt_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_diskf.ps pstoraster/gs_diskf.ps
f 0444 root sys $DATADIR/pstoraster/gs_dpnxt.ps pstoraster/gs_dpnxt.ps
f 0444 root sys $DATADIR/pstoraster/gs_dps.ps pstoraster/gs_dps.ps
f 0444 root sys $DATADIR/pstoraster/gs_dps1.ps pstoraster/gs_dps1.ps
f 0444 root sys $DATADIR/pstoraster/gs_dps2.ps pstoraster/gs_dps2.ps
f 0444 root sys $DATADIR/pstoraster/gs_epsf.ps pstoraster/gs_epsf.ps
f 0444 root sys $DATADIR/pstoraster/gs_fform.ps pstoraster/gs_fform.ps
f 0444 root sys $DATADIR/pstoraster/gs_fonts.ps pstoraster/gs_fonts.ps
f 0444 root sys $DATADIR/pstoraster/gs_init.ps pstoraster/gs_init.ps
f 0444 root sys $DATADIR/pstoraster/gs_iso_e.ps pstoraster/gs_iso_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_kanji.ps pstoraster/gs_kanji.ps
f 0444 root sys $DATADIR/pstoraster/gs_ksb_e.ps pstoraster/gs_ksb_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_lev2.ps pstoraster/gs_lev2.ps
f 0444 root sys $DATADIR/pstoraster/gs_ll3.ps pstoraster/gs_ll3.ps
f 0444 root sys $DATADIR/pstoraster/gs_mex_e.ps pstoraster/gs_mex_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_mro_e.ps pstoraster/gs_mro_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_pfile.ps pstoraster/gs_pfile.ps
f 0444 root sys $DATADIR/pstoraster/gs_res.ps pstoraster/gs_res.ps
f 0444 root sys $DATADIR/pstoraster/gs_setpd.ps pstoraster/gs_setpd.ps
f 0444 root sys $DATADIR/pstoraster/gs_statd.ps pstoraster/gs_statd.ps
f 0444 root sys $DATADIR/pstoraster/gs_std_e.ps pstoraster/gs_std_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_sym_e.ps pstoraster/gs_sym_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_ttf.ps pstoraster/gs_ttf.ps
f 0444 root sys $DATADIR/pstoraster/gs_typ32.ps pstoraster/gs_typ32.ps
f 0444 root sys $DATADIR/pstoraster/gs_typ42.ps pstoraster/gs_typ42.ps
f 0444 root sys $DATADIR/pstoraster/gs_type1.ps pstoraster/gs_type1.ps
f 0444 root sys $DATADIR/pstoraster/gs_wan_e.ps pstoraster/gs_wan_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_wl1_e.ps pstoraster/gs_wl1_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_wl2_e.ps pstoraster/gs_wl2_e.ps
f 0444 root sys $DATADIR/pstoraster/gs_wl5_e.ps pstoraster/gs_wl5_e.ps
d 0555 root sys $DATADIR/model -
f 0444 root sys $DATADIR/model/deskjet.ppd ppd/deskjet.ppd
f 0444 root sys $DATADIR/model/laserjet.ppd ppd/laserjet.ppd
f 0444 root sys $DATADIR/model/epson9.ppd ppd/epson9.ppd
f 0444 root sys $DATADIR/model/epson24.ppd ppd/epson24.ppd
f 0444 root sys $DATADIR/model/stcolor.ppd ppd/stcolor.ppd
f 0444 root sys $DATADIR/model/stphoto.ppd ppd/stphoto.ppd
d 0555 root sys $DATADIR/templates -
f 0444 root sys $DATADIR/templates/add-class.tmpl templates/add-class.tmpl
f 0444 root sys $DATADIR/templates/add-printer.tmpl templates/add-printer.tmpl
f 0444 root sys $DATADIR/templates/admin-op.tmpl templates/admin-op.tmpl
f 0444 root sys $DATADIR/templates/admin.tmpl templates/admin.tmpl
f 0444 root sys $DATADIR/templates/choose-device.tmpl templates/choose-device.tmpl
f 0444 root sys $DATADIR/templates/choose-make.tmpl templates/choose-make.tmpl
f 0444 root sys $DATADIR/templates/choose-members.tmpl templates/choose-members.tmpl
f 0444 root sys $DATADIR/templates/choose-model.tmpl templates/choose-model.tmpl
f 0444 root sys $DATADIR/templates/choose-serial.tmpl templates/choose-serial.tmpl
f 0444 root sys $DATADIR/templates/choose-uri.tmpl templates/choose-uri.tmpl
f 0444 root sys $DATADIR/templates/class-added.tmpl templates/class-added.tmpl
f 0444 root sys $DATADIR/templates/class-confirm.tmpl templates/class-confirm.tmpl
f 0444 root sys $DATADIR/templates/class-deleted.tmpl templates/class-deleted.tmpl
f 0444 root sys $DATADIR/templates/class-modified.tmpl templates/class-modified.tmpl
f 0444 root sys $DATADIR/templates/classes.tmpl templates/classes.tmpl
f 0444 root sys $DATADIR/templates/config-printer.tmpl templates/config-printer.tmpl
f 0444 root sys $DATADIR/templates/config-printer2.tmpl templates/config-printer2.tmpl
f 0444 root sys $DATADIR/templates/error.tmpl templates/error.tmpl
f 0444 root sys $DATADIR/templates/header.tmpl templates/header.tmpl
f 0444 root sys $DATADIR/templates/job-cancel.tmpl templates/job-cancel.tmpl
f 0444 root sys $DATADIR/templates/job-hold.tmpl templates/job-hold.tmpl
f 0444 root sys $DATADIR/templates/job-release.tmpl templates/job-release.tmpl
f 0444 root sys $DATADIR/templates/job-restart.tmpl templates/job-restart.tmpl
f 0444 root sys $DATADIR/templates/jobs.tmpl templates/jobs.tmpl
f 0444 root sys $DATADIR/templates/modify-class.tmpl templates/modify-class.tmpl
f 0444 root sys $DATADIR/templates/modify-printer.tmpl templates/modify-printer.tmpl
f 0444 root sys $DATADIR/templates/option-boolean.tmpl templates/option-boolean.tmpl
f 0444 root sys $DATADIR/templates/option-header.tmpl templates/option-header.tmpl
f 0444 root sys $DATADIR/templates/option-pickmany.tmpl templates/option-pickmany.tmpl
f 0444 root sys $DATADIR/templates/option-pickone.tmpl templates/option-pickone.tmpl
f 0444 root sys $DATADIR/templates/option-trailer.tmpl templates/option-trailer.tmpl
f 0444 root sys $DATADIR/templates/printer-accept.tmpl templates/printer-accept.tmpl
f 0444 root sys $DATADIR/templates/printer-added.tmpl templates/printer-added.tmpl
f 0444 root sys $DATADIR/templates/printer-configured.tmpl templates/printer-configured.tmpl
f 0444 root sys $DATADIR/templates/printer-confirm.tmpl templates/printer-confirm.tmpl
f 0444 root sys $DATADIR/templates/printer-deleted.tmpl templates/printer-deleted.tmpl
f 0444 root sys $DATADIR/templates/printer-modified.tmpl templates/printer-modified.tmpl
f 0444 root sys $DATADIR/templates/printer-reject.tmpl templates/printer-reject.tmpl
f 0444 root sys $DATADIR/templates/printer-start.tmpl templates/printer-start.tmpl
f 0444 root sys $DATADIR/templates/printer-stop.tmpl templates/printer-stop.tmpl
f 0444 root sys $DATADIR/templates/printers.tmpl templates/printers.tmpl
f 0444 root sys $DATADIR/templates/test-page.tmpl templates/test-page.tmpl
f 0444 root sys $DATADIR/templates/trailer.tmpl templates/trailer.tmpl
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
f 0444 root sys /usr/share/cups/data/8859-1 data/8859-1
f 0444 root sys /usr/share/cups/data/8859-14 data/8859-14
f 0444 root sys /usr/share/cups/data/8859-15 data/8859-15
f 0444 root sys /usr/share/cups/data/8859-2 data/8859-2
f 0444 root sys /usr/share/cups/data/8859-3 data/8859-3
f 0444 root sys /usr/share/cups/data/8859-4 data/8859-4
f 0444 root sys /usr/share/cups/data/8859-5 data/8859-5
f 0444 root sys /usr/share/cups/data/8859-6 data/8859-6
f 0444 root sys /usr/share/cups/data/8859-7 data/8859-7
f 0444 root sys /usr/share/cups/data/8859-8 data/8859-8
f 0444 root sys /usr/share/cups/data/8859-9 data/8859-9
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/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/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_l2img.ps pstoraster/gs_l2img.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pfile.ps pstoraster/gs_pfile.ps
f 0444 root sys /usr/share/cups/pstoraster/pfbtogs.ps pstoraster/pfbtogs.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/gs_wan_e.ps pstoraster/gs_wan_e.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_sym_e.ps pstoraster/gs_sym_e.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_dbt_e.ps pstoraster/gs_dbt_e.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_iso_e.ps pstoraster/gs_iso_e.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_ttf.ps pstoraster/gs_ttf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pdf.ps pstoraster/gs_pdf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ccfnt.ps pstoraster/gs_ccfnt.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_sec.ps pstoraster/pdf_sec.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_res.ps pstoraster/gs_res.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_base.ps pstoraster/pdf_base.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_btokn.ps pstoraster/gs_btokn.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_diskf.ps pstoraster/gs_diskf.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_2ps.ps pstoraster/pdf_2ps.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_kanji.ps pstoraster/gs_kanji.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/gs_type1.ps pstoraster/gs_type1.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_statd.ps pstoraster/gs_statd.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_typ42.ps pstoraster/gs_typ42.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_cidfn.ps pstoraster/gs_cidfn.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_dps1.ps pstoraster/gs_dps1.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_cmap.ps pstoraster/gs_cmap.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_fform.ps pstoraster/gs_fform.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_main.ps pstoraster/pdf_main.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
# 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/classes.conf conf/classes.conf
c 0644 root sys $SERVERROOT/cupsd.conf conf/cupsd.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 $SERVERROOT/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
%system 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 $LIBDIR/libcups.a cups/libcups.a
c 0600 root sys /var/cups/conf/classes.conf conf/classes.conf
c 0600 root sys /var/cups/conf/cupsd.conf conf/cupsd.conf
c 0600 root sys /var/cups/conf/mime.convs conf/mime.convs
c 0600 root sys /var/cups/conf/mime.types conf/mime.types
c 0600 root sys /var/cups/conf/printers.conf conf/printers.conf
# Documentation files
d 0555 root sys $DOCDIR -
f 0444 root sys $DOCDIR/cups.css doc/cups.css
f 0444 root sys $DOCDIR/documentation.html doc/documentation.html
f 0444 root sys $DOCDIR/index.html doc/index.html
d 0555 root sys $DOCDIR/images -
f 0444 root sys $DOCDIR/images/classes.gif doc/images/classes.gif
f 0444 root sys $DOCDIR/images/printer-idle.gif doc/images/printer-idle.gif
f 0444 root sys $DOCDIR/images/printer-processing.gif doc/images/printer-processing.gif
f 0444 root sys $DOCDIR/images/printer-stopped.gif doc/images/printer-stopped.gif
f 0444 root sys $DOCDIR/images/accept-jobs.gif doc/images/accept-jobs.gif
f 0444 root sys $DOCDIR/images/add-class.gif doc/images/add-class.gif
f 0444 root sys $DOCDIR/images/add-printer.gif doc/images/add-printer.gif
f 0444 root sys $DOCDIR/images/cancel-job.gif doc/images/cancel-job.gif
f 0444 root sys $DOCDIR/images/cancel-jobs.gif doc/images/cancel-jobs.gif
f 0444 root sys $DOCDIR/images/cancel.gif doc/images/cancel.gif
f 0444 root sys $DOCDIR/images/continue.gif doc/images/continue.gif
f 0444 root sys $DOCDIR/images/config-printer.gif doc/images/config-printer.gif
f 0444 root sys $DOCDIR/images/cups-block-diagram.gif doc/images/cups-block-diagram.gif
f 0444 root sys $DOCDIR/images/delete-class.gif doc/images/delete-class.gif
f 0444 root sys $DOCDIR/images/delete-printer.gif doc/images/delete-printer.gif
f 0444 root sys $DOCDIR/images/hold-job.gif doc/images/hold-job.gif
f 0444 root sys $DOCDIR/images/left.gif doc/images/left.gif
f 0444 root sys $DOCDIR/images/logo.gif doc/images/logo.gif
f 0444 root sys $DOCDIR/images/manage-classes.gif doc/images/manage-classes.gif
f 0444 root sys $DOCDIR/images/manage-jobs.gif doc/images/manage-jobs.gif
f 0444 root sys $DOCDIR/images/manage-printers.gif doc/images/manage-printers.gif
f 0444 root sys $DOCDIR/images/modify-class.gif doc/images/modify-class.gif
f 0444 root sys $DOCDIR/images/modify-printer.gif doc/images/modify-printer.gif
f 0444 root sys $DOCDIR/images/navbar.gif doc/images/navbar.gif
f 0444 root sys $DOCDIR/images/print-test-page.gif doc/images/print-test-page.gif
f 0444 root sys $DOCDIR/images/reject-jobs.gif doc/images/reject-jobs.gif
f 0444 root sys $DOCDIR/images/release-job.gif doc/images/release-job.gif
f 0444 root sys $DOCDIR/images/restart-job.gif doc/images/restart-job.gif
f 0444 root sys $DOCDIR/images/right.gif doc/images/right.gif
f 0444 root sys $DOCDIR/images/show-active.gif doc/images/show-active.gif
f 0444 root sys $DOCDIR/images/show-completed.gif doc/images/show-completed.gif
f 0444 root sys $DOCDIR/images/start-class.gif doc/images/start-class.gif
f 0444 root sys $DOCDIR/images/start-printer.gif doc/images/start-printer.gif
f 0444 root sys $DOCDIR/images/stop-class.gif doc/images/stop-class.gif
f 0444 root sys $DOCDIR/images/stop-printer.gif doc/images/stop-printer.gif
f 0444 root sys $DOCDIR/cmp.html doc/cmp.html
f 0444 root sys $DOCDIR/cmp.pdf doc/cmp.pdf
f 0444 root sys $DOCDIR/cupsdoc.css doc/cupsdoc.css
f 0444 root sys $DOCDIR/idd.html doc/idd.html
f 0444 root sys $DOCDIR/idd.pdf doc/idd.pdf
f 0444 root sys $DOCDIR/ipp.html doc/ipp.html
f 0444 root sys $DOCDIR/ipp.pdf doc/ipp.pdf
f 0444 root sys $DOCDIR/overview.html doc/overview.html
f 0444 root sys $DOCDIR/overview.pdf doc/overview.pdf
f 0444 root sys $DOCDIR/sam.html doc/sam.html
f 0444 root sys $DOCDIR/sam.pdf doc/sam.pdf
f 0444 root sys $DOCDIR/sdd.html doc/sdd.html
f 0444 root sys $DOCDIR/sdd.pdf doc/sdd.pdf
f 0444 root sys $DOCDIR/spm.html doc/spm.html
f 0444 root sys $DOCDIR/spm.pdf doc/spm.pdf
f 0444 root sys $DOCDIR/sps.html doc/sps.html
f 0444 root sys $DOCDIR/sps.pdf doc/sps.pdf
f 0444 root sys $DOCDIR/ssr.html doc/ssr.html
f 0444 root sys $DOCDIR/ssr.pdf doc/ssr.pdf
f 0444 root sys $DOCDIR/sum.html doc/sum.html
f 0444 root sys $DOCDIR/sum.pdf doc/sum.pdf
f 0444 root sys $DOCDIR/svd.html doc/svd.html
f 0444 root sys $DOCDIR/svd.pdf doc/svd.pdf
f 0444 root sys $DOCDIR/images/cups-bar.gif doc/images/cups-bar.gif
f 0444 root sys $DOCDIR/images/cups-large.gif doc/images/cups-large.gif
f 0444 root sys $DOCDIR/images/cups-medium.gif doc/images/cups-medium.gif
f 0444 root sys $DOCDIR/images/cups-small.gif doc/images/cups-small.gif
f 0444 root sys /usr/share/cups/doc/cmp.html doc/cmp.html
f 0444 root sys /usr/share/cups/doc/cmp.pdf doc/cmp.pdf
f 0444 root sys /usr/share/cups/doc/cupsdoc.css doc/cupsdoc.css
f 0444 root sys /usr/share/cups/doc/cups.css doc/cups.css
f 0444 root sys /usr/share/cups/doc/documentation.html doc/documentation.html
f 0444 root sys /usr/share/cups/doc/idd.html doc/idd.html
f 0444 root sys /usr/share/cups/doc/idd.pdf doc/idd.pdf
f 0444 root sys /usr/share/cups/doc/images/classes.gif doc/images/classes.gif
f 0444 root sys /usr/share/cups/doc/images/cups-bar.gif doc/images/cups-bar.gif
f 0444 root sys /usr/share/cups/doc/images/cups-block-diagram.gif doc/images/cups-block-diagram.gif
f 0444 root sys /usr/share/cups/doc/images/cups-large.gif doc/images/cups-large.gif
f 0444 root sys /usr/share/cups/doc/images/cups-medium.gif doc/images/cups-medium.gif
f 0444 root sys /usr/share/cups/doc/images/cups-small.gif doc/images/cups-small.gif
f 0444 root sys /usr/share/cups/doc/images/logo.gif doc/images/logo.gif
f 0444 root sys /usr/share/cups/doc/images/navbar.gif doc/images/navbar.gif
f 0444 root sys /usr/share/cups/doc/images/printer-idle.gif doc/images/printer-idle.gif
f 0444 root sys /usr/share/cups/doc/images/printer-processing.gif doc/images/printer-processing.gif
f 0444 root sys /usr/share/cups/doc/images/printer-stopped.gif doc/images/printer-stopped.gif
f 0444 root sys /usr/share/cups/doc/index.html doc/index.html
f 0444 root sys /usr/share/cups/doc/overview.html doc/overview.html
f 0444 root sys /usr/share/cups/doc/overview.pdf doc/overview.pdf
f 0444 root sys /usr/share/cups/doc/sam.html doc/sam.html
f 0444 root sys /usr/share/cups/doc/sam.pdf doc/sam.pdf
f 0444 root sys /usr/share/cups/doc/sdd.html doc/sdd.html
f 0444 root sys /usr/share/cups/doc/sdd.pdf doc/sdd.pdf
f 0444 root sys /usr/share/cups/doc/ssr.html doc/ssr.html
f 0444 root sys /usr/share/cups/doc/ssr.pdf doc/ssr.pdf
f 0444 root sys /usr/share/cups/doc/stp.html doc/stp.html
f 0444 root sys /usr/share/cups/doc/stp.pdf doc/stp.pdf
f 0444 root sys /usr/share/cups/doc/sum.html doc/sum.html
f 0444 root sys /usr/share/cups/doc/sum.pdf doc/sum.pdf
f 0444 root sys /usr/share/cups/doc/svd.html doc/svd.html
f 0444 root sys /usr/share/cups/doc/svd.pdf doc/svd.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 -
%system irix irix64
f 0444 root sys /usr/share/catman/a_man/cat1/accept.z man/accept.z
l 0444 root sys /usr/share/catman/a_man/cat1/reject.z accept.z
f 0444 root sys /usr/share/catman/u_man/cat1/backend.z man/backend.z
f 0444 root sys /usr/share/catman/u_man/cat5/classes.conf.z man/classes.conf.z
f 0444 root sys /usr/share/catman/u_man/cat5/cupsd.conf.z man/cupsd.conf.z
f 0444 root sys /usr/share/catman/a_man/cat1/cupsd.z man/cupsd.z
f 0444 root sys /usr/share/catman/a_man/cat1/enable.z man/enable.z
l 0444 root sys /usr/share/catman/a_man/cat1/disable.z enable.z
f 0444 root sys /usr/share/catman/u_man/cat1/filter.z man/filter.z
f 0444 root sys /usr/share/catman/a_man/cat1/lpadmin.z man/lpadmin.z
f 0444 root sys /usr/share/catman/a_man/cat1/lpc.z man/lpc.z
f 0444 root sys /usr/share/catman/u_man/cat1/lprm.z man/lprm.z
f 0444 root sys /usr/share/catman/u_man/cat1/lpr.z man/lpr.z
f 0444 root sys /usr/share/catman/u_man/cat1/lpstat.z man/lpstat.z
f 0444 root sys /usr/share/catman/u_man/cat1/lp.z man/lp.z
l 0444 root sys /usr/share/catman/u_man/cat1/cancel.z lp.z
f 0444 root sys /usr/share/catman/u_man/cat5/mime.convs.z man/mime.convs.z
f 0444 root sys /usr/share/catman/u_man/cat5/mime.types.z man/mime.types.z
f 0444 root sys /usr/share/catman/u_man/cat5/printers.conf.z man/printers.conf.z
%system hpux linux dunix solaris sunos
f 0444 root sys /usr/man/man8/accept.8 man/accept.8
l 0444 root sys /usr/man/man8/reject.8 accept.8
f 0444 root sys /usr/man/man1/backend.1 man/backend.1
f 0444 root sys /usr/man/man1/classes.conf.5 man/classes.conf.5
f 0444 root sys /usr/man/man8/cupsd.8 man/cupsd.8
f 0444 root sys /usr/man/man5/cupsd.conf.5 man/cupsd.conf.5
f 0444 root sys /usr/man/man8/enable.8 man/enable.8
l 0444 root sys /usr/man/man8/disable.8 enable.8
f 0444 root sys /usr/man/man1/filter.1 man/filter.1
f 0444 root sys /usr/man/man8/lpadmin.8 man/lpadmin.8
f 0444 root sys /usr/man/man8/lpc.8 man/lpc.8
f 0444 root sys /usr/man/man1/lprm.1 man/lprm.1
f 0444 root sys /usr/man/man1/lpr.1 man/lpr.1
f 0444 root sys /usr/man/man1/lpstat.1 man/lpstat.1
f 0444 root sys /usr/man/man1/lp.1 man/lp.1
l 0444 root sys /usr/man/man1/cancel.1 lp.1
f 0444 root sys /usr/man/man5/mime.convs.5 man/mime.convs.5
f 0444 root sys /usr/man/man5/mime.types.5 man/mime.types.5
f 0444 root sys /usr/man/man5/printers.conf.5 man/printers.conf.5
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
# Startup script
%system all
i 0555 root sys cups cups.sh
# Startup scripts
%system hpux
%install /sbin/init.d/lp start
%remove /sbin/init.d/lp stop
%patch /sbin/init.d/lp stop
f 0555 root sys /sbin/init.d/lp cups.sh
l 0555 root sys /sbin/rc1.d/K280lp ../init.d/lp
l 0555 root sys /sbin/rc2.d/S720lp ../init.d/lp
%system irix irix64
%install /etc/init.d/lp start
%remove /etc/init.d/lp stop
%patch /etc/init.d/lp stop
f 0555 root sys /etc/init.d/lp cups.sh
l 0555 root sys /etc/rc0.d/K25lp ../init.d/lp
l 0555 root sys /etc/rc2.d/S60lp ../init.d/lp
%system linux
%install /etc/rc.d/init.d/lpd start
%remove /etc/rc.d/init.d/lpd stop
%patch /etc/rc.d/init.d/lpd stop
f 0555 root sys /etc/rc.d/init.d/lpd cups.sh
l 0555 root sys /etc/rc.d/rc2.d/S60lpd ../init.d/lpd
l 0555 root sys /etc/rc.d/rc3.d/S60lpd ../init.d/lpd
l 0555 root sys /etc/rc.d/rc4.d/S60lpd ../init.d/lpd
l 0555 root sys /etc/rc.d/rc5.d/S60lpd ../init.d/lpd
l 0555 root sys /etc/rc.d/rc0.d/K60lpd ../init.d/lpd
l 0555 root sys /etc/rc.d/rc1.d/K60lpd ../init.d/lpd
l 0555 root sys /etc/rc.d/rc6.d/K60lpd ../init.d/lpd
%system dunix
%install /sbin/init.d/lpd start
%remove /sbin/init.d/lpd stop
%patch /sbin/init.d/lpd stop
f 0555 root sys /sbin/init.d/lpd cups.sh
l 0555 root sys /sbin/rc0.d/K05lpd ../init.d/lpd
l 0555 root sys /sbin/rc2.d/K00lpd ../init.d/lpd
l 0555 root sys /sbin/rc3.d/S65lpd ../init.d/lpd
%system solaris sunos
%install /etc/init.d/lp start
%remove /etc/init.d/lp stop
%patch /etc/init.d/lp stop
f 0555 root sys /etc/init.d/lp cups.sh
l 0555 root sys /etc/rc0.d/K20lp ../init.d/lp
l 0555 root sys /etc/rc2.d/S80lp ../init.d/lp
#
# End of "$Id: cups.list 1368 2000-09-14 18:04:10Z mike $".
# End of "$Id: cups.list 432 1999-06-21 20:14:24Z mike $".
#
Arquivo executável
+64
Ver Arquivo
@@ -0,0 +1,64 @@
#!/bin/sh
#
# "$Id$"
#
# Startup/shutdown script for the Common UNIX Printing System (CUPS).
#
# 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
# 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
#
# See if the CUPS daemon is running, and if so stop it...
case "`uname`" in
IRIX* | HP-UX | SunOS)
pid=`ps -e | awk '{print $1,$4}' | grep cupsd | awk '{print $1}'`
;;
OSF1)
pid=`ps -e | awk '{print $1,$5}' | grep cupsd | awk '{print $1}'`
;;
Linux)
pid=`ps ax | awk '{print $1,$5}' | grep cupsd | awk '{print $1}'`
;;
*)
pid=""
;;
esac
case $1 in
start | restart)
if test "$pid" != ""; then
echo "Restarting CUPS scheduler..."
kill -HUP $pid
else
echo "Starting CUPS scheduler..."
/usr/sbin/cupsd 2>&1 >/dev/null &
fi
;;
stop)
if test "$pid" != ""; then
echo "Stopping CUPS scheduler..."
kill $pid
sleep 1
fi
;;
esac
#
# End of "$Id$".
#
-114
Ver Arquivo
@@ -1,114 +0,0 @@
#!/bin/sh
#
# "$Id$"
#
# Startup/shutdown script for the Common UNIX Printing System (CUPS).
#
# Linux chkconfig stuff:
#
# chkconfig: 0235 99 00
# description: Startup/shutdown script for the Common UNIX \
# Printing System (CUPS).
#
# Copyright 1997-2000 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
# 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
#
# See what program to use for configuration stuff...
case "`uname`" in
IRIX*)
IS_ON=/sbin/chkconfig
;;
*)
IS_ON=/bin/true
;;
esac
# The verbose flag controls the printing of the names of
# daemons as they are started.
if $IS_ON verbose; then
ECHO=echo
else
ECHO=:
fi
# See if the CUPS server is running...
case "`uname`" in
IRIX* | HP-UX | SunOS)
pid=`ps -e | awk '{print $1,$4}' | grep cupsd | awk '{print $1}'`
;;
OSF1)
pid=`ps -e | awk '{print $1,$5}' | grep cupsd | awk '{print $1}'`
;;
Linux)
pid=`ps ax | awk '{print $1,$5}' | grep cupsd | awk '{print $1}'`
;;
*)
pid=""
;;
esac
# Start or stop the CUPS server based upon the first argument to the script.
case $1 in
start | restart | reload)
if test "$pid" != ""; then
if $IS_ON cups; then
kill -HUP $pid
$ECHO "cups: scheduler restarted."
else
kill $pid
$ECHO "cups: scheduler stopped."
fi
else
if $IS_ON cups; then
prefix=@prefix@
exec_prefix=@exec_prefix@
@sbindir@/cupsd
$ECHO "cups: scheduler started."
fi
fi
;;
stop)
if test "$pid" != ""; then
kill $pid
$ECHO "cups: scheduler stopped."
fi
;;
status)
if test "$pid" != ""; then
echo "cups: Scheduler is running."
else
echo "cups: Scheduler is not running."
fi
;;
*)
echo "Usage: cups {reload|restart|start|status|stop}"
exit 1
;;
esac
exit 0
#
# End of "$Id$".
#
-174
Ver Arquivo
@@ -1,174 +0,0 @@
#
# "$Id: cups.spec 1339 2000-09-06 12:38:12Z mike $"
#
# RPM "spec" file for the Common UNIX Printing System (CUPS).
#
# Original version by Jason McMullan <jmcc@ontv.com>.
#
# Copyright 1999-2000 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
# 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
#
Summary: Common Unix Printing System
Name: cups
Version: 1.1.3
Release: 0
Copyright: GPL
Group: System Environment/Daemons
Source: ftp://ftp.easysw.com/pub/cups/%{version}/cups-%{version}-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
Conflicts: lpr
%package devel
Summary: Common Unix Printing System - development environment
Group: Development/Libraries
%description
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.
%description devel
The Common UNIX Printing System provides a portable printing layer for
UNIX® operating systems. This is the development package for creating
additional printer drivers, and other CUPS services.
%prep
%setup
%build
./configure
# If we got this far, all prerequisite libraries must be here.
make
%install
# these lines just make sure the directory structure in the
# 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 \
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
%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
%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
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
%dir /etc/cups
%config /etc/cups/*.conf
%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/*
/usr/man/*
/usr/sbin/*
%dir /usr/share/cups
/usr/share/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
%files devel
%dir /usr/include/cups
/usr/include/cups/*
/usr/lib/*.a
#
# End of "$Id: cups.spec 1339 2000-09-06 12:38:12Z mike $".
#
+43 -72
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Support library 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,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
OBJS = $(LIBOBJS) testhttp.o testppd.o
OBJS = emit.o filter.o http.o ipp.o language.o mark.o mime.o \
options.o page.o ppd.o raster.o string.o type.o usersys.o \
util.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 mime.h ppd.h raster.h
#
# Targets in this directory...
#
TARGETS = $(LIBCUPS) libcups.a
TARGETS = libcups.a testmime testppd testhttp
#
# Make all targets...
@@ -53,65 +50,33 @@ TARGETS = $(LIBCUPS) libcups.a
all: $(TARGETS)
#
# Remove object and target files...
#
clean:
$(RM) $(OBJS) $(TARGETS) `basename $(LIBCUPS) .2`
rm -f $(OBJS) $(TARGETS)
#
# Install object and target files...
#
install: all
-$(MKDIR) $(INCLUDEDIR)/cups
$(CHMOD) ugo+rx $(INCLUDEDIR)
$(CHMOD) ugo+rx $(INCLUDEDIR)/cups
$(INSTALL_DATA) $(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) `basename $(LIBDIR)/$(LIBCUPS) .2`; \
$(LN) $(LIBCUPS) `basename $(LIBDIR)/$(LIBCUPS) .2`; \
fi
#
# libcups.so.2, libcups.sl.1
#
libcups.so.2 libcups.sl.2: $(LIBOBJS) ../Makedefs
echo Linking $@...
$(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
$(CP) libcups.a $(LIBDIR)
-$(MKDIR) $(INCLUDEDIR)/cups
$(CP) $(HEADERS) $(INCLUDEDIR)/cups
#
# libcups.a
#
libcups.a: $(LIBOBJS)
libcups.a: $(OBJS)
echo Archiving $@...
$(RM) $@
$(AR) $(ARFLAGS) $@ $(LIBOBJS)
$(AR) $(ARFLAGS) $@ $(OBJS)
$(RANLIB) $@
#
# cups_C.h - the default POSIX locale that is compiled in.
#
@@ -121,45 +86,51 @@ cups_C.h: ../locale/C/cups_C
$(RM) cups_C.h
$(AWK) '{print "\"" $$0 "\","}' < ../locale/C/cups_C > cups_C.h
dest.o: cups.h http.h ipp.h language.h string.h
emit.o: ppd.h
http.o: http.h ipp.h md5.h string.h
ipp.o: http.h ipp.h string.h language.h
language.o: cups_C.h language.h string.h
mark.o: ppd.h
md5.o: md5.h
options.o: cups.h
page.o: ppd.h
ppd.o: language.h ppd.h
snprintf.o: string.h
string.o: string.h
usersys.o: cups.h
util.o: cups.h http.h ipp.h
emit.o: ppd.h ../config.h ../Makedefs
filter.o: mime.h ../config.h ../Makedefs
http.o: http.h ipp.h string.h ../config.h ../Makedefs
ipp.o: http.h ipp.h ../config.h ../Makedefs
language.o: cups_C.h language.h string.h ../config.h ../Makedefs
mark.o: ppd.h ../config.h ../Makedefs
mime.o: mime.h ../config.h ../Makedefs
options.o: cups.h ../config.h ../Makedefs
page.o: ppd.h ../config.h ../Makedefs
ppd.o: language.h ppd.h ../config.h ../Makedefs
raster.o: raster.h ../config.h ../Makedefs
string.o: string.h ../config.h ../Makedefs
type.o: mime.h ../config.h ../Makedefs
usersys.o: cups.h ../config.h ../Makedefs
util.o: cups.h http.h ipp.h ../config.h ../Makedefs
#
# testhttp (dependency on static CUPS library is intentional)
# testhttp
#
testhttp: testhttp.o libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testhttp.o libcups.a $(NETLIBS)
testhttp.o: http.h
$(CC) $(LDFLAGS) -o $@ testhttp.o $(LIBS)
testhttp.o: http.h ../Makedefs
#
# testppd (dependency on static CUPS library is intentional)
# testmime
#
testmime: testmime.o libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testmime.o $(LIBS)
testmime.o: mime.h ../Makedefs
#
# testppd
#
testppd: testppd.o libcups.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testppd.o libcups.a $(NETLIBS)
testppd.o: ppd.h
$(OBJS): ../Makedefs ../config.h
$(CC) $(LDFLAGS) -o $@ testppd.o $(LIBS)
testppd.o: ppd.h ../Makedefs
#
# End of "$Id$".
-180
Ver Arquivo
@@ -1,180 +0,0 @@
# Microsoft Developer Studio Project File - Name="cups" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Static Library" 0x0104
CFG=cups - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "cups.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "cups.mak" CFG="cups - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "cups - Win32 Release" (based on "Win32 (x86) Static Library")
!MESSAGE "cups - Win32 Debug" (based on "Win32 (x86) Static Library")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "cups - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD CPP /nologo /MT /W3 /GX /O2 /I "..\visualc" /I ".." /D "WIN32" /D "NDEBUG" /D "_MBCS" /D "_LIB" /YX /FD /c
# ADD BASE RSC /l 0x409 /d "NDEBUG"
# ADD RSC /l 0x409 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"cups.lib"
!ELSEIF "$(CFG)" == "cups - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I "..\visualc" /I ".." /I "../visualc" /D "WIN32" /D "_DEBUG" /D "_MBCS" /D "_LIB" /YX /FD /GZ /c
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LIB32=link.exe -lib
# ADD BASE LIB32 /nologo
# ADD LIB32 /nologo /out:"cupsd.lib"
!ENDIF
# Begin Target
# Name "cups - Win32 Release"
# Name "cups - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\emit.c
# End Source File
# Begin Source File
SOURCE=.\filter.c
# End Source File
# Begin Source File
SOURCE=.\http.c
# End Source File
# Begin Source File
SOURCE=.\ipp.c
# End Source File
# Begin Source File
SOURCE=.\language.c
# End Source File
# Begin Source File
SOURCE=.\mark.c
# End Source File
# Begin Source File
SOURCE=.\mime.c
# End Source File
# Begin Source File
SOURCE=.\options.c
# End Source File
# Begin Source File
SOURCE=.\page.c
# End Source File
# Begin Source File
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
SOURCE=.\string.c
# End Source File
# Begin Source File
SOURCE=.\type.c
# End Source File
# Begin Source File
SOURCE=.\util.c
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\cups.h
# End Source File
# Begin Source File
SOURCE=.\http.h
# End Source File
# Begin Source File
SOURCE=.\ipp.h
# End Source File
# Begin Source File
SOURCE=.\language.h
# End Source File
# Begin Source File
SOURCE=.\mime.h
# End Source File
# Begin Source File
SOURCE=.\ppd.h
# End Source File
# Begin Source File
SOURCE=.\raster.h
# End Source File
# End Group
# End Target
# End Project
+34 -46
Ver Arquivo
@@ -3,7 +3,7 @@
*
* API definitions 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
@@ -29,8 +29,9 @@
* Include necessary headers...
*/
# include "ipp.h"
# include "ppd.h"
# include <cups/ipp.h>
# include <cups/mime.h>
# include <cups/ppd.h>
/*
@@ -46,7 +47,7 @@ extern "C" {
* Constants...
*/
# define CUPS_VERSION 1.0103
# define CUPS_VERSION 1.0
# define CUPS_DATE_ANY -1
@@ -75,73 +76,60 @@ 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) */
};
/*
* Types & structures...
*/
typedef struct /**** Printer Information ****/
{
char name[IPP_MAX_NAME], /* Printer or class name */
uri[HTTP_MAX_URI]; /* Universal resource identifier */
unsigned char info[IPP_MAX_NAME], /* Printer or class info/description */
location[IPP_MAX_NAME]; /* Location text */
ipp_pstate_t state; /* Printer state */
unsigned char message[IPP_MAX_NAME]; /* State text */
cups_ptype_t type; /* Printer type/capability codes */
} cups_browse_t;
typedef struct /**** Printer Options ****/
{
char *name; /* Name of option */
char *value; /* Value of option */
} cups_option_t;
typedef struct /**** Destination ****/
{
char *name, /* Printer or class name */
*instance; /* Local instance name or NULL */
int is_default; /* Is this printer the default? */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
} cups_dest_t;
/*
* Functions...
*/
extern int cupsCancelJob(const char *printer, int job);
extern int cupsCancelJob(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);
char *resource, char *filename);
extern int cupsGetClasses(char ***classes);
extern const char *cupsGetDefault(void);
extern const char *cupsGetPPD(const char *printer);
extern char *cupsGetPPD(char *printer);
extern char *cupsGetDefault(void);
extern int cupsGetPrinters(char ***printers);
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 cupsPrintFile(char *printer, char *filename, char *title,
int num_options, cups_option_t *options);
extern int cupsAddDest(const char *name, const char *instance,
int num_dests, cups_dest_t **dests);
extern void cupsFreeDests(int num_dests, cups_dest_t *dests);
extern cups_dest_t *cupsGetDest(const char *name, const char *instance,
int num_dests, cups_dest_t *dests);
extern int cupsGetDests(cups_dest_t **dests);
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 int cupsAddOption(char *name, char *value, 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,
extern char *cupsGetOption(char *name, int num_options,
cups_option_t *options);
extern int cupsParseOptions(const char *arg, int num_options,
extern int cupsParseOptions(char *arg, int num_options,
cups_option_t **options);
extern int cupsMarkOptions(ppd_file_t *ppd, int num_options,
cups_option_t *options);
extern const char *cupsGetPassword(const char *prompt);
extern const char *cupsServer(void);
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);
extern char *cupsGetPassword(const char *prompt);
extern char *cupsServer();
extern char *cupsUser();
# ifdef __cplusplus
}
-132
Ver Arquivo
@@ -1,132 +0,0 @@
"iso-8859-1",
"OK",
"Cancel",
"Help",
"Quit",
"Close",
"Yes",
"No",
"On",
"Off",
"Save",
"Discard",
"Default",
"Options",
"More Info",
"Black",
"Color",
"Cyan",
"Magenta",
"Yellow",
"Copyright 1993-2000 by Easy Software Products, All Rights Reserved.",
"General",
"Printer",
"Image",
"HP-GL/2",
"Extra",
"Document",
"Other",
"Print Pages: ",
"Entire Document",
"Page Range:",
"Reverse Order: ",
"Page Format: ",
" 1-Up",
" 2-Up",
" 4-Up",
"Image Scaling: ",
"Use Natural Image Size",
"Zoom by Percent",
"Zoom by PPI",
"Mirror Image: ",
"Color Saturation: ",
"Color Hue: ",
"Fit to Page: ",
"Shading: ",
"Pen Width: ",
"Gamma Correction: ",
"Brightness: ",
"Add",
"Delete",
"Modify",
"Printer URI",
"Printer Name",
"Printer Location",
"Printer Info",
"Printer Make and Model",
"Device URI",
"Formatting Page",
"Printing Page",
"Initializing Printer",
"Printer State",
"Accepting Jobs",
"Not Accepting Jobs",
"Print Jobs",
"Class",
"Local",
"Remote",
"Duplexing",
"Stapling",
"Fast Copies",
"Collated Copies",
"Hole Punching",
"Covering",
"Binding",
"Sorting",
"Small (up to 9.5x14in)",
"Medium (9.5x14in to 13x19in)",
"Large (13x19in and larger)",
"Custom Size",
"Idle",
"Processing",
"Stopped",
"All",
"Odd",
"Even",
"Darker Lighter",
"Media Size",
"Media Type",
"Media Source",
"Orientation: ",
"Portrait",
"Landscape",
"Job State",
"Job Name",
"User Name",
"Priority",
"Copies",
"File Size",
"Pending",
"Output Mode",
"Resolution",
"Text",
"Pretty Print",
"Margins",
"Left",
"Right",
"Bottom",
"Top",
"Filename(s)",
"Print",
"400 Your browser sent a request that this server could not understand.",
"This server could not verify that you are authorized to access the resource.",
"You must pay to access this server.",
"You don't have permission to access the resource on this server.",
"The requested resource was not found on this server.",
"The requested method is not allowed with the resource.",
"An appropriate representation for the resource was not found on this server.",
"You don't have permission to use this server as a proxy host.",
"The request has taken too long to complete and has been aborted.",
"The requested resource has more than one value.",
"The requested resource is gone and has not been replaced.",
"The requested method requires a valid Content-Length.",
"The precondition on the request evaluated to false.",
"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.",
"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.",
"The requested resource is currently unavailable on this server.",
"The proxy server has taken too long to respond to this server.",
"This server does not support the HTTP version required by your browser.",
+1 -1
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Debugging macros 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
-504
Ver Arquivo
@@ -1,504 +0,0 @@
/*
* "$Id$"
*
* User-defined destination (and option) 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:
*
* cupsAddDest() - Add a destination to the list of destinations.
* cupsFreeDests() - Free the memory used by the list of destinations.
* cupsGetDest() - Get the named destination from the list.
* cupsGetDests() - Get the list of destinations.
* cupsSetDests() - Set the list of destinations.
* cups_get_dests() - Get destinations from a file.
*/
/*
* Include necessary headers...
*/
#include "cups.h"
#include "string.h"
#include <stdlib.h>
#include <ctype.h>
/*
* Local functions...
*/
static int cups_get_dests(const char *filename, int num_dests,
cups_dest_t **dests);
/*
* 'cupsAddDest()' - Add a destination to the list of destinations.
*/
int /* O - New number of destinations */
cupsAddDest(const char *name, /* I - Name of destination */
const char *instance, /* I - Instance of destination */
int num_dests, /* I - Number of destinations */
cups_dest_t **dests) /* IO - Destinations */
{
int i; /* Looping var */
cups_dest_t *dest; /* Destination pointer */
if (name == NULL || dests == NULL)
return (0);
if ((dest = cupsGetDest(name, instance, num_dests, *dests)) != NULL)
return (num_dests);
/*
* Add new destination...
*/
if (num_dests == 0)
dest = malloc(sizeof(cups_dest_t));
else
dest = realloc(*dests, sizeof(cups_dest_t) * (num_dests + 1));
if (dest == NULL)
return (num_dests);
*dests = dest;
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 &&
strcasecmp(instance, dest->instance) < 0)
break;
if (i > 0)
memmove(dest + 1, dest, i * sizeof(cups_dest_t));
dest->name = strdup(name);
dest->is_default = 0;
dest->num_options = 0;
dest->options = (cups_option_t *)0;
if (instance == NULL)
dest->instance = NULL;
else
dest->instance = strdup(instance);
return (num_dests + 1);
}
/*
* 'cupsFreeDests()' - Free the memory used by the list of destinations.
*/
void
cupsFreeDests(int num_dests, /* I - Number of destinations */
cups_dest_t *dests) /* I - Destinations */
{
int i; /* Looping var */
cups_dest_t *dest; /* Current destination */
if (num_dests == 0 || dests == NULL)
return;
for (i = num_dests, dest = dests; i > 0; i --, dest ++)
{
free(dest->name);
if (dest->instance)
free(dest->instance);
cupsFreeOptions(dest->num_options, dest->options);
}
free(dests);
}
/*
* 'cupsGetDest()' - Get the named destination from the list.
*/
cups_dest_t * /* O - Destination pointer or NULL */
cupsGetDest(const char *name, /* I - Name of destination */
const char *instance, /* I - Instance of destination */
int num_dests, /* I - Number of destinations */
cups_dest_t *dests) /* I - Destinations */
{
int comp; /* Result of comparison */
if (num_dests == 0 || dests == NULL)
return (NULL);
if (name == NULL)
{
/*
* NULL name for default printer.
*/
while (num_dests > 0)
{
if (dests->is_default)
return (dests);
num_dests --;
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 ++;
}
}
return (NULL);
}
/*
* 'cupsGetDests()' - Get the list of destinations.
*/
int /* O - Number of destinations */
cupsGetDests(cups_dest_t **dests) /* O - Destinations */
{
int i; /* Looping var */
int num_dests; /* Number of destinations */
int count; /* Number of printers/classes */
char **names; /* Printer/class names */
cups_dest_t *dest; /* Destination pointer */
const char *home; /* HOME environment variable */
char filename[1024]; /* Local ~/.lpoptions file */
/*
* Initialize destination array...
*/
num_dests = 0;
*dests = (cups_dest_t *)0;
/*
* Grab all available printers...
*/
if ((count = cupsGetPrinters(&names)) > 0)
{
for (i = 0; i < count; i ++)
{
num_dests = cupsAddDest(names[i], NULL, num_dests, dests);
free(names[i]);
}
free(names);
}
/*
* Grab all available classes...
*/
if ((count = cupsGetClasses(&names)) > 0)
{
for (i = 0; i < count; i ++)
{
num_dests = cupsAddDest(names[i], NULL, num_dests, dests);
free(names[i]);
}
free(names);
}
/*
* Grab the default destination...
*/
if ((dest = cupsGetDest(cupsGetDefault(), NULL, num_dests, *dests)) != NULL)
dest->is_default = 1;
/*
* 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);
if ((home = getenv("HOME")) != NULL)
{
snprintf(filename, sizeof(filename), "%s/.lpoptions", home);
num_dests = cups_get_dests(filename, num_dests, dests);
}
/*
* Return the number of destinations...
*/
return (num_dests);
}
/*
* 'cupsSetDests()' - Set the list of destinations.
*/
void
cupsSetDests(int num_dests, /* I - Number of destinations */
cups_dest_t *dests) /* I - Destinations */
{
int i, j; /* Looping vars */
cups_dest_t *dest; /* Current destination */
cups_option_t *option; /* Current option */
FILE *fp; /* File pointer */
const char *home; /* HOME environment variable */
char filename[1024]; /* lpoptions file */
/*
* Figure out which file to write to...
*/
if (getuid() == 0)
{
if ((home = getenv("CUPS_SERVERROOT")) != NULL)
snprintf(filename, sizeof(filename), "%s/lpoptions", home);
else
strcpy(filename, CUPS_SERVERROOT "/lpoptions");
}
else if ((home = getenv("HOME")) != NULL)
snprintf(filename, sizeof(filename), "%s/.lpoptions", home);
else
return;
/*
* Try to open the file...
*/
if ((fp = fopen(filename, "w")) == NULL)
return;
/*
* Write each printer; each line looks like:
*
* Dest name[/instance] options
* Default name[/instance] options
*/
for (i = num_dests, dest = dests; i > 0; i --, dest ++)
if (dest->instance != NULL || dest->num_options != 0 || dest->is_default)
{
fprintf(fp, "%s %s", dest->is_default ? "Default" : "Dest",
dest->name);
if (dest->instance)
fprintf(fp, "/%s", dest->instance);
for (j = dest->num_options, option = dest->options; j > 0; j --, option ++)
if (option->value[0])
fprintf(fp, " %s=%s", option->name, option->value);
else
fprintf(fp, " %s", option->name);
fputs("\n", fp);
}
/*
* Close the file and return...
*/
fclose(fp);
}
/*
* 'cups_get_dests()' - Get destinations from a file.
*/
static int /* O - Number of destinations */
cups_get_dests(const char *filename, /* I - File to read from */
int num_dests, /* I - Number of destinations */
cups_dest_t **dests) /* IO - Destinations */
{
int i; /* Looping var */
cups_dest_t *dest; /* Current destination */
FILE *fp; /* File pointer */
char line[8192], /* Line from file */
*lineptr, /* Pointer into line */
*name, /* Name of destination/option */
*instance; /* Instance of destination */
/*
* Try to open the file...
*/
if ((fp = fopen(filename, "r")) == NULL)
return (num_dests);
/*
* Read each printer; each line looks like:
*
* Dest name[/instance] options
* Default name[/instance] options
*/
while (fgets(line, sizeof(line), fp) != NULL)
{
/*
* See what type of line it is...
*/
if (strncasecmp(line, "dest", 4) == 0 && isspace(line[4]))
lineptr = line + 4;
else if (strncasecmp(line, "default", 7) == 0 && isspace(line[7]))
lineptr = line + 7;
else
continue;
/*
* Skip leading whitespace...
*/
while (isspace(*lineptr))
lineptr ++;
if (!*lineptr)
continue;
name = lineptr;
/*
* Search for an instance...
*/
while (!isspace(*lineptr) && *lineptr && *lineptr != '/')
lineptr ++;
if (!*lineptr)
continue;
if (*lineptr == '/')
{
/*
* Found an instance...
*/
*lineptr++ = '\0';
instance = lineptr;
/*
* Search for an instance...
*/
while (!isspace(*lineptr) && *lineptr)
lineptr ++;
}
else
instance = NULL;
*lineptr++ = '\0';
/*
* Add the destination...
*/
num_dests = cupsAddDest(name, instance, num_dests, dests);
if ((dest = cupsGetDest(name, instance, num_dests, *dests)) == NULL)
{
/*
* Out of memory!
*/
fclose(fp);
return (num_dests);
}
/*
* Add options until we hit the end of the line...
*/
if (dest->num_options)
{
/*
* Free old options...
*/
cupsFreeOptions(dest->num_options, dest->options);
dest->num_options = 0;
dest->options = (cups_option_t *)0;
}
dest->num_options = cupsParseOptions(lineptr, dest->num_options,
&(dest->options));
/*
* Set this as default if needed...
*/
if (strncasecmp(line, "default", 7) == 0)
{
for (i = 0; i < num_dests; i ++)
(*dests)[i].is_default = 0;
dest->is_default = 1;
}
}
/*
* Close the file and return...
*/
fclose(fp);
return (num_dests);
}
/*
* End of "$Id$".
*/
+172 -206
Ver Arquivo
@@ -3,7 +3,7 @@
*
* PPD code emission routines 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
@@ -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 (strcmp(((ppd_option_t *)choices[i]->option)->keyword, "PageSize") == 0 &&
strcmp(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[7 -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,201 +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...
*/
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);
}
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$".
*/
+7 -11
Ver Arquivo
@@ -3,7 +3,7 @@
*
* File type conversion routines 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
@@ -37,7 +37,7 @@
#include <stdlib.h>
#include <ctype.h>
#include <cups/string.h>
#include "string.h"
#include "mime.h"
@@ -58,7 +58,7 @@ mimeAddFilter(mime_t *mime, /* I - MIME database */
mime_type_t *src, /* I - Source type */
mime_type_t *dst, /* I - Destination type */
int cost, /* I - Relative time/resource cost */
const char *filter) /* I - Filter program to run */
char *filter) /* I - Filter program to run */
{
mime_filter_t *temp; /* New filter */
@@ -88,8 +88,7 @@ mimeAddFilter(mime_t *mime, /* I - MIME database */
if (temp->cost > cost)
{
temp->cost = cost;
strncpy(temp->filter, filter, sizeof(temp->filter) - 1);
temp->filter[sizeof(temp->filter) - 1] = '\0';
strcpy(temp->filter, filter);
}
}
else
@@ -117,8 +116,7 @@ mimeAddFilter(mime_t *mime, /* I - MIME database */
temp->src = src;
temp->dst = dst;
temp->cost = cost;
strncpy(temp->filter, filter, sizeof(temp->filter) - 1);
temp->filter[sizeof(temp->filter) - 1] = '\0';
strcpy(temp->filter, filter);
if (mime->num_filters > 1)
qsort(mime->filters, mime->num_filters, sizeof(mime_filter_t),
@@ -186,10 +184,8 @@ mimeFilter(mime_t *mime, /* I - MIME database */
* OK, now look for filters from the source type to any other type...
*/
mincost = 9999999;
mintemp = NULL;
num_mintemp = 0;
mincurrent = NULL;
mincost = 9999999;
mintemp = NULL;
for (i = mime->num_filters, current = mime->filters; i > 0; i --, current ++)
if (current->src == src)
+193 -459
Ver Arquivo
Diferenças do arquivo suprimidas por serem muito extensas Carregar Diff
+46 -54
Ver Arquivo
@@ -4,7 +4,7 @@
* Hyper-Text Transport Protocol definitions 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
@@ -47,8 +47,6 @@
# include <netinet/tcp.h>
# endif /* WIN32 || __EMX__ */
# include "md5.h"
/*
* C++ magic...
@@ -65,7 +63,7 @@ extern "C" {
# define HTTP_MAX_URI 1024 /* Max length of URI string */
# define HTTP_MAX_HOST 256 /* Max length of hostname string */
# define HTTP_MAX_BUFFER 2048 /* Max length of data buffer */
# define HTTP_MAX_BUFFER 8192 /* Max length of data buffer */
# define HTTP_MAX_VALUE 256 /* Max header field value length */
@@ -126,21 +124,6 @@ typedef enum
} http_encoding_t;
/*
* HTTP authentication types...
*/
typedef enum
{
HTTP_AUTH_NONE, /* No authentication in use */
HTTP_AUTH_BASIC, /* Basic authentication in use */
HTTP_AUTH_MD5, /* Digest authentication in use */
HTTP_AUTH_MD5_SESS, /* MD5-session authentication in use */
HTTP_AUTH_MD5_INT, /* Digest authentication in use for body */
HTTP_AUTH_MD5_SESS_INT /* MD5-session authentication in use for body */
} http_auth_t;
/*
* HTTP status codes...
*/
@@ -199,10 +182,18 @@ typedef enum
typedef enum
{
HTTP_FIELD_UNKNOWN = -1,
HTTP_FIELD_ACCEPT = 0,
HTTP_FIELD_ACCEPT_CHARSET,
HTTP_FIELD_ACCEPT_ENCODING,
HTTP_FIELD_ACCEPT_LANGUAGE,
HTTP_FIELD_ACCEPT_RANGES,
HTTP_FIELD_AGE,
HTTP_FIELD_ALLOW,
HTTP_FIELD_ALTERNATES,
HTTP_FIELD_AUTHORIZATION,
HTTP_FIELD_CACHE_CONTROL,
HTTP_FIELD_CONNECTION,
HTTP_FIELD_CONTENT_BASE,
HTTP_FIELD_CONTENT_ENCODING,
HTTP_FIELD_CONTENT_LANGUAGE,
HTTP_FIELD_CONTENT_LENGTH,
@@ -212,19 +203,38 @@ typedef enum
HTTP_FIELD_CONTENT_TYPE,
HTTP_FIELD_CONTENT_VERSION,
HTTP_FIELD_DATE,
HTTP_FIELD_DERIVED_FROM,
HTTP_FIELD_ETAG,
HTTP_FIELD_EXPIRES,
HTTP_FIELD_FROM,
HTTP_FIELD_HOST,
HTTP_FIELD_IF_MATCH,
HTTP_FIELD_IF_MODIFIED_SINCE,
HTTP_FIELD_IF_NONE_MATCH,
HTTP_FIELD_IF_RANGE,
HTTP_FIELD_IF_UNMODIFIED_SINCE,
HTTP_FIELD_KEEP_ALIVE,
HTTP_FIELD_LAST_MODIFIED,
HTTP_FIELD_LINK,
HTTP_FIELD_LOCATION,
HTTP_FIELD_MAX_FORWARDS,
HTTP_FIELD_MESSAGE_ID,
HTTP_FIELD_MIME_VERSION,
HTTP_FIELD_PRAGMA,
HTTP_FIELD_PROXY_AUTHENTICATE,
HTTP_FIELD_PROXY_AUTHORIZATION,
HTTP_FIELD_PUBLIC,
HTTP_FIELD_RANGE,
HTTP_FIELD_REFERER,
HTTP_FIELD_RETRY_AFTER,
HTTP_FIELD_SERVER,
HTTP_FIELD_TRANSFER_ENCODING,
HTTP_FIELD_UPGRADE,
HTTP_FIELD_URI,
HTTP_FIELD_USER_AGENT,
HTTP_FIELD_VARY,
HTTP_FIELD_VIA,
HTTP_FIELD_WARNING,
HTTP_FIELD_WWW_AUTHENTICATE,
HTTP_FIELD_MAX
} http_field_t;
@@ -238,7 +248,6 @@ typedef struct
{
int fd; /* File descriptor for this socket */
int blocking; /* To block or not to block */
int error; /* Last error on read */
time_t activity; /* Time since last read/write */
http_state_t state; /* State of client */
http_status_t status; /* Status of last request */
@@ -255,12 +264,6 @@ typedef struct
int used; /* Number of bytes used in buffer */
char buffer[HTTP_MAX_BUFFER];
/* Buffer for messages */
int auth_type; /* Authentication in use */
md5_state_t md5_state; /* MD5 state */
char nonce[HTTP_MAX_VALUE];
/* Nonce value */
int nonce_count; /* Nonce count */
void *tls; /* TLS state information */
} http_t;
@@ -269,46 +272,35 @@ typedef struct
*/
# define httpBlocking(http,b) (http)->blocking = (b)
extern int httpCheck(http_t *http);
# define httpClearFields(http) memset((http)->fields, 0, sizeof((http)->fields)),\
httpSetField((http), HTTP_FIELD_HOST, (http)->hostname)
extern void httpClose(http_t *http);
extern http_t *httpConnect(const char *host, int port);
extern int httpDelete(http_t *http, const char *uri);
# define httpError(http) ((http)->error)
extern http_t *httpConnect(char *host, int port);
extern int httpDelete(http_t *http, char *uri);
extern void httpFlush(http_t *http);
extern int httpGet(http_t *http, const char *uri);
extern int httpGet(http_t *http, char *uri);
extern char *httpGets(char *line, int length, http_t *http);
extern const char *httpGetDateString(time_t t);
extern time_t httpGetDateTime(const char *s);
extern char *httpGetDateString(time_t t);
extern time_t httpGetDateTime(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 int httpHead(http_t *http, char *uri);
extern void httpInitialize(void);
extern int httpOptions(http_t *http, const char *uri);
extern int httpPost(http_t *http, const char *uri);
extern int httpOptions(http_t *http, char *uri);
extern int httpPost(http_t *http, char *uri);
extern int httpPrintf(http_t *http, const char *format, ...);
extern int httpPut(http_t *http, const char *uri);
extern int httpPut(http_t *http, 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 const char *httpStatus(http_status_t status);
extern int httpTrace(http_t *http, const char *uri);
extern void httpSeparate(char *uri, char *method, char *username,
char *host, int *port, char *resource);
extern void httpSetField(http_t *http, http_field_t field, char *value);
extern char *httpStatus(http_status_t status);
extern int httpTrace(http_t *http, char *uri);
extern http_status_t httpUpdate(http_t *http);
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 httpWrite(http_t *http, char *buffer, int length);
extern char *httpEncode64(char *out, char *in);
extern char *httpDecode64(char *out, 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]);
/*
+161 -423
Ver Arquivo
@@ -4,7 +4,7 @@
* Internet Printing Protocol support functions 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
@@ -38,17 +38,13 @@
* ippAddSeparator() - Add a group separator to an IPP request.
* ippDateToTime() - Convert from RFC 1903 Date/Time format to UNIX time
* ippDelete() - Delete an IPP request.
* 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.
* add_attr() - Add a new attribute to the request.
* ipp_read() - Semi-blocking read on a HTTP connection...
*/
@@ -58,26 +54,18 @@
#include <stdio.h>
#include <stdlib.h>
#include "string.h"
#include "language.h"
#include <string.h>
#include "ipp.h"
#include "debug.h"
#include <ctype.h>
/*
* Local globals...
*/
static int ipp_port = 0;
/*
* Local functions...
*/
static int ipp_read(http_t *http, unsigned char *buffer, int length);
static ipp_attribute_t *add_attr(ipp_t *ipp, int num_values);
static int ipp_read(http_t *http, char *buffer, int length);
/*
@@ -85,10 +73,10 @@ static int ipp_read(http_t *http, unsigned char *buffer, int length);
*/
ipp_attribute_t * /* O - New attribute */
ippAddBoolean(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
char value) /* I - Value of attribute */
ippAddBoolean(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
char value) /* I - Value of attribute */
{
ipp_attribute_t *attr; /* New attribute */
@@ -98,7 +86,7 @@ ippAddBoolean(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
if ((attr = add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -115,11 +103,11 @@ ippAddBoolean(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddBooleans(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
const char *values) /* I - Values */
ippAddBooleans(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
char *values) /* I - Values */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -131,7 +119,7 @@ ippAddBooleans(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
if ((attr = add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -151,10 +139,10 @@ ippAddBooleans(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddDate(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
const ipp_uchar_t *value) /* I - Value */
ippAddDate(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
ipp_uchar_t *value) /* I - Value */
{
ipp_attribute_t *attr; /* New attribute */
@@ -165,7 +153,7 @@ ippAddDate(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL || value == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
if ((attr = add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -182,11 +170,11 @@ ippAddDate(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddInteger(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
const char *name, /* I - Name of attribute */
int value) /* I - Value of attribute */
ippAddInteger(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
char *name, /* I - Name of attribute */
int value) /* I - Value of attribute */
{
ipp_attribute_t *attr; /* New attribute */
@@ -197,7 +185,7 @@ ippAddInteger(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
if ((attr = add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -214,12 +202,12 @@ ippAddInteger(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddIntegers(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
const char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
const int *values) /* I - Values */
ippAddIntegers(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
int *values) /* I - Values */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -228,7 +216,7 @@ ippAddIntegers(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
if ((attr = add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -248,12 +236,12 @@ ippAddIntegers(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddString(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
const char *name, /* I - Name of attribute */
const char *charset, /* I - Character set */
const char *value) /* I - Value */
ippAddString(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
char *name, /* I - Name of attribute */
char *charset, /* I - Character set */
char *value) /* I - Value */
{
ipp_attribute_t *attr; /* New attribute */
@@ -261,7 +249,7 @@ ippAddString(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
if ((attr = add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -270,22 +258,6 @@ ippAddString(ipp_t *ipp, /* I - IPP request */
attr->values[0].string.charset = charset ? strdup(charset) : NULL;
attr->values[0].string.text = strdup(value);
if (type == IPP_TAG_LANGUAGE || type == IPP_TAG_CHARSET)
{
/*
* 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);
}
return (attr);
}
@@ -295,13 +267,13 @@ ippAddString(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddStrings(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
const char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
const char *charset, /* I - Character set */
const char **values) /* I - Values */
ippAddStrings(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
ipp_tag_t type, /* I - Type of attribute */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
char *charset, /* I - Character set */
char **values) /* I - Values */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -310,7 +282,7 @@ ippAddStrings(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
if ((attr = add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -337,11 +309,11 @@ ippAddStrings(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddRange(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
int lower, /* I - Lower value */
int upper) /* I - Upper value */
ippAddRange(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
int lower, /* I - Lower value */
int upper) /* I - Upper value */
{
ipp_attribute_t *attr; /* New attribute */
@@ -349,7 +321,7 @@ ippAddRange(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
if ((attr = add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -367,12 +339,12 @@ ippAddRange(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddRanges(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
const int *lower, /* I - Lower values */
const int *upper) /* I - Upper values */
ippAddRanges(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
int *lower, /* I - Lower values */
int *upper) /* I - Upper values */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -381,7 +353,7 @@ ippAddRanges(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
if ((attr = add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -404,12 +376,12 @@ ippAddRanges(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddResolution(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
ipp_res_t units, /* I - Units for resolution */
int xres, /* I - X resolution */
int yres) /* I - Y resolution */
ippAddResolution(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
ipp_res_t units, /* I - Units for resolution */
int xres, /* I - X resolution */
int yres) /* I - Y resolution */
{
ipp_attribute_t *attr; /* New attribute */
@@ -417,7 +389,7 @@ ippAddResolution(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
if ((attr = add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -436,13 +408,13 @@ ippAddResolution(ipp_t *ipp, /* I - IPP request */
*/
ipp_attribute_t * /* O - New attribute */
ippAddResolutions(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
const char *name, /* I - Name of attribute */
int num_values,/* I - Number of values */
ipp_res_t units, /* I - Units for resolution */
const int *xres, /* I - X resolutions */
const int *yres) /* I - Y resolutions */
ippAddResolutions(ipp_t *ipp, /* I - IPP request */
ipp_tag_t group, /* I - IPP group */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
ipp_res_t units, /* I - Units for resolution */
int *xres, /* I - X resolutions */
int *yres) /* I - Y resolutions */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -451,7 +423,7 @@ ippAddResolutions(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
if ((attr = add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -485,7 +457,7 @@ ippAddSeparator(ipp_t *ipp) /* I - IPP request */
if (ipp == NULL)
return (NULL);
if ((attr = _ipp_add_attr(ipp, 0)) == NULL)
if ((attr = add_attr(ipp, 0)) == NULL)
return (NULL);
attr->group_tag = IPP_TAG_ZERO;
@@ -500,8 +472,8 @@ ippAddSeparator(ipp_t *ipp) /* I - IPP request */
* in seconds.
*/
time_t /* O - UNIX time value */
ippDateToTime(const ipp_uchar_t *date) /* I - RFC 1903 date info */
time_t /* O - UNIX time value */
ippDateToTime(ipp_uchar_t *date)/* I - RFC 1903 date info */
{
struct tm unixdate; /* UNIX date/time info */
time_t t; /* Computed time */
@@ -540,6 +512,8 @@ ippDateToTime(const ipp_uchar_t *date) /* I - RFC 1903 date info */
else
t -= date[9] * 3600 + date[10] * 60;
t -= timezone;
return (t);
}
@@ -551,6 +525,7 @@ 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 */
@@ -560,101 +535,52 @@ ippDelete(ipp_t *ipp) /* I - IPP request */
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);
}
/*
* 'ippErrorString()' - Return a textual message for the given error message.
*/
const char * /* O - Text string */
ippErrorString(ipp_status_t error) /* I - Error status */
{
static cups_lang_t *language = 0; /* Language info */
/*
* Load the localized message file as needed...
*/
if (!language)
language = cupsLangDefault();
/*
* Return the appropriate message...
*/
switch (error)
{
case IPP_OK :
case IPP_OK_SUBST :
case IPP_OK_CONFLICT :
return ("OK");
case IPP_BAD_REQUEST :
return (cupsLangString(language, HTTP_BAD_REQUEST));
case IPP_FORBIDDEN :
return (cupsLangString(language, HTTP_FORBIDDEN));
case IPP_NOT_AUTHENTICATED :
case IPP_NOT_AUTHORIZED :
return (cupsLangString(language, HTTP_UNAUTHORIZED));
case IPP_NOT_POSSIBLE :
return (cupsLangString(language, HTTP_METHOD_NOT_ALLOWED));
case IPP_TIMEOUT :
return (cupsLangString(language, HTTP_REQUEST_TIMEOUT));
case IPP_NOT_FOUND :
return (cupsLangString(language, HTTP_NOT_FOUND));
case IPP_GONE :
return (cupsLangString(language, HTTP_GONE));
case IPP_DOCUMENT_FORMAT :
return (cupsLangString(language, HTTP_UNSUPPORTED_MEDIATYPE));
case IPP_CONFLICT :
return (cupsLangString(language, HTTP_CONFLICT));
case IPP_INTERNAL_ERROR :
return (cupsLangString(language, HTTP_SERVER_ERROR));
case IPP_OPERATION_NOT_SUPPORTED :
case IPP_VERSION_NOT_SUPPORTED :
return (cupsLangString(language, HTTP_NOT_SUPPORTED));
case IPP_SERVICE_UNAVAILABLE :
case IPP_DEVICE_ERROR :
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");
}
}
/*
* 'ippFindAttribute()' - Find a named attribute in a request...
*/
ipp_attribute_t * /* O - Matching attribute */
ippFindAttribute(ipp_t *ipp, /* I - IPP request */
const char *name, /* I - Name of attribute */
ipp_tag_t type) /* I - Type of attribute */
ippFindAttribute(ipp_t *ipp, /* I - IPP request */
char *name, /* I - Name of attribute */
ipp_tag_t type) /* I - Type of attribute */
{
ipp_attribute_t *attr; /* Current atttribute */
@@ -669,8 +595,8 @@ ippFindAttribute(ipp_t *ipp, /* I - IPP request */
DEBUG_printf(("ippFindAttribute: attr = %08x, name = \'%s\'\n", attr,
attr->name));
if (attr->name != NULL && strcasecmp(attr->name, name) == 0 &&
(attr->value_tag == type || type == IPP_TAG_ZERO ||
if (attr->name != NULL && strcmp(attr->name, name) == 0 &&
(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);
@@ -765,16 +691,11 @@ ippLength(ipp_t *ipp) /* I - IPP request */
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
bytes += 4 * attr->num_values;/* Charset + text length */
bytes += 2 * attr->num_values;/* Charset length */
for (i = 0; i < attr->num_values; i ++)
bytes += strlen(attr->values[i].string.charset) +
strlen(attr->values[i].string.text);
break;
default :
for (i = 0; i < attr->num_values; i ++)
bytes += attr->values[0].unknown.length;
break;
}
}
@@ -788,27 +709,10 @@ ippLength(ipp_t *ipp) /* I - IPP request */
}
/*
* 'ippNew()' - Allocate a new IPP request.
*/
ipp_t * /* O - New IPP request */
ippNew(void)
{
ipp_t *temp; /* New IPP request */
if ((temp = (ipp_t *)calloc(sizeof(ipp_t), 1)) != NULL)
{
/*
* Default to IPP 1.1...
*/
temp->request.any.version[0] = 1;
temp->request.any.version[1] = 1;
}
return (temp);
return ((ipp_t *)calloc(sizeof(ipp_t), 1));
}
@@ -821,8 +725,7 @@ ippRead(http_t *http, /* I - HTTP data */
ipp_t *ipp) /* I - IPP data */
{
int n; /* Length of data */
unsigned char buffer[8192], /* Data buffer */
*bufptr; /* Pointer into buffer */
char buffer[8192]; /* Data buffer */
ipp_attribute_t *attr; /* Current attribute */
ipp_tag_t tag; /* Current tag */
@@ -900,7 +803,7 @@ ippRead(http_t *http, /* I - HTTP data */
ipp->state = IPP_DATA;
break;
}
else if (tag < IPP_TAG_UNSUPPORTED_VALUE)
else if (tag <= IPP_TAG_UNSUPPORTED)
{
/*
* Group tag... Set the current group and continue...
@@ -960,11 +863,11 @@ ippRead(http_t *http, /* I - HTTP data */
buffer[n] = '\0';
DEBUG_printf(("ippRead: name = \'%s\'\n", buffer));
attr = ipp->current = _ipp_add_attr(ipp, IPP_MAX_VALUES);
attr = ipp->current = add_attr(ipp, IPP_MAX_VALUES);
attr->group_tag = ipp->curtag;
attr->value_tag = tag;
attr->name = strdup((char *)buffer);
attr->name = strdup(buffer);
attr->num_values = 0;
}
@@ -1010,7 +913,7 @@ ippRead(http_t *http, /* I - HTTP data */
buffer[n] = '\0';
DEBUG_printf(("ippRead: value = \'%s\'\n", buffer));
attr->values[attr->num_values].string.text = strdup((char *)buffer);
attr->values[attr->num_values].string.text = strdup(buffer);
break;
case IPP_TAG_DATE :
if (ipp_read(http, buffer, 11) < 11)
@@ -1047,45 +950,21 @@ ippRead(http_t *http, /* I - HTTP data */
if (ipp_read(http, buffer, n) < n)
return (IPP_ERROR);
bufptr = buffer;
buffer[n] = '\0';
/*
* text-with-language and name-with-language are composite
* values:
*
* charset-length
* charset
* text-length
* text
*/
attr->values[attr->num_values].string.charset = strdup(buffer);
n = (bufptr[0] << 8) | bufptr[1];
if (ipp_read(http, buffer, 2) < 2)
return (IPP_ERROR);
attr->values[attr->num_values].string.charset = calloc(n + 1, 1);
n = (buffer[0] << 8) | buffer[1];
memcpy(attr->values[attr->num_values].string.charset,
bufptr + 2, n);
if (ipp_read(http, buffer, n) < n)
return (IPP_ERROR);
bufptr += 2 + n;
n = (bufptr[0] << 8) | bufptr[1];
buffer[n] = '\0';
attr->values[attr->num_values].string.text = calloc(n + 1, 1);
memcpy(attr->values[attr->num_values].string.text,
bufptr + 2, n);
break;
default : /* Other unsupported values */
attr->values[attr->num_values].unknown.length = n;
if (n > 0)
{
attr->values[attr->num_values].unknown.data = malloc(n);
if (ipp_read(http, attr->values[attr->num_values].unknown.data, n) < n)
return (IPP_ERROR);
}
else
attr->values[attr->num_values].unknown.data = NULL;
attr->values[attr->num_values].string.text = strdup(buffer);
break;
}
@@ -1102,9 +981,6 @@ ippRead(http_t *http, /* I - HTTP data */
case IPP_DATA :
break;
default :
break; /* anti-compiler-warning-code */
}
return (ipp->state);
@@ -1115,7 +991,7 @@ ippRead(http_t *http, /* I - HTTP data */
* 'ippTimeToDate()' - Convert from UNIX time to RFC 1903 format.
*/
const ipp_uchar_t * /* O - RFC-1903 date/time data */
ipp_uchar_t * /* O - RFC-1903 date/time data */
ippTimeToDate(time_t t) /* I - UNIX time value */
{
struct tm *unixdate; /* UNIX unixdate/time info */
@@ -1168,7 +1044,7 @@ ippWrite(http_t *http, /* I - HTTP data */
{
int i; /* Looping var */
int n; /* Length of data */
unsigned char buffer[8192], /* Data buffer */
char buffer[8192], /* Data buffer */
*bufptr; /* Pointer into buffer */
ipp_attribute_t *attr; /* Current attribute */
@@ -1188,8 +1064,8 @@ ippWrite(http_t *http, /* I - HTTP data */
bufptr = buffer;
*bufptr++ = ipp->request.any.version[0];
*bufptr++ = ipp->request.any.version[1];
*bufptr++ = 1;
*bufptr++ = 0;
*bufptr++ = ipp->request.any.op_status >> 8;
*bufptr++ = ipp->request.any.op_status;
*bufptr++ = ipp->request.any.request_id >> 24;
@@ -1197,7 +1073,7 @@ ippWrite(http_t *http, /* I - HTTP data */
*bufptr++ = ipp->request.any.request_id >> 8;
*bufptr++ = ipp->request.any.request_id;
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
if (httpWrite(http, buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP header...");
return (IPP_ERROR);
@@ -1332,17 +1208,6 @@ ippWrite(http_t *http, /* I - HTTP data */
DEBUG_printf(("ippWrite: writing string = %d, \'%s\'\n", n,
attr->values[i].string.text));
if ((sizeof(buffer) - (bufptr - buffer)) < (n + 2))
{
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP attribute...");
return (IPP_ERROR);
}
bufptr = buffer;
}
*bufptr++ = n >> 8;
*bufptr++ = n;
memcpy(bufptr, attr->values[i].string.text, n);
@@ -1445,92 +1310,26 @@ ippWrite(http_t *http, /* I - HTTP data */
*bufptr++ = 0;
}
n = strlen(attr->values[i].string.charset) +
strlen(attr->values[i].string.text) +
2;
if ((sizeof(buffer) - (bufptr - buffer)) < (n + 2))
{
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP attribute...");
return (IPP_ERROR);
}
bufptr = buffer;
}
/* Length of entire value */
*bufptr++ = n >> 8;
*bufptr++ = n;
/* Length of charset */
n = strlen(attr->values[i].string.charset);
*bufptr++ = n >> 8;
*bufptr++ = n;
/* Charset */
memcpy(bufptr, attr->values[i].string.charset, n);
bufptr += n;
/* Length of text */
n = strlen(attr->values[i].string.text);
*bufptr++ = n >> 8;
*bufptr++ = n;
/* Text */
memcpy(bufptr, attr->values[i].string.text, n);
bufptr += n;
}
break;
default :
for (i = 0; i < attr->num_values; i ++)
{
if (i)
{
/*
* Arrays and sets are done by sending additional
* values with a zero-length name...
*/
*bufptr++ = attr->value_tag;
*bufptr++ = 0;
*bufptr++ = 0;
}
n = attr->values[i].unknown.length;
if ((sizeof(buffer) - (bufptr - buffer)) < (n + 2))
{
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP attribute...");
return (IPP_ERROR);
}
bufptr = buffer;
}
/* Length of unknown value */
*bufptr++ = n >> 8;
*bufptr++ = n;
/* Value */
if (n > 0)
{
memcpy(bufptr, attr->values[i].unknown.data, n);
bufptr += n;
}
}
break;
}
/*
* Write the data out...
*/
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
if (httpWrite(http, buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP attribute...");
return (IPP_ERROR);
@@ -1553,7 +1352,7 @@ ippWrite(http_t *http, /* I - HTTP data */
*/
buffer[0] = IPP_TAG_END;
if (httpWrite(http, (char *)buffer, 1) < 0)
if (httpWrite(http, buffer, 1) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP end-tag...");
return (IPP_ERROR);
@@ -1565,9 +1364,6 @@ ippWrite(http_t *http, /* I - HTTP data */
case IPP_DATA :
break;
default :
break; /* anti-compiler-warning-code */
}
return (ipp->state);
@@ -1581,44 +1377,31 @@ ippWrite(http_t *http, /* I - HTTP data */
int /* O - Port number */
ippPort(void)
{
const char *server_port; /* SERVER_PORT environment variable */
char *server_port; /* SERVER_PORT environment variable */
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("SERVER_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));
return (ntohs(port->s_port));
}
/*
* 'ippSetPort()' - Set the default port number.
* 'add_attr()' - Add a new attribute to the request.
*/
void
ippSetPort(int p) /* I - Port number to use */
static ipp_attribute_t * /* O - New attribute */
add_attr(ipp_t *ipp, /* I - IPP request */
int num_values) /* I - Number of values */
{
ipp_port = p;
}
ipp_attribute_t *attr; /* New attribute */
/*
* '_ipp_add_attr()' - Add a new attribute to the request.
*/
ipp_attribute_t * /* O - New attribute */
_ipp_add_attr(ipp_t *ipp, /* I - IPP request */
int num_values) /* I - Number of values */
{
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("_ipp_add_attr(%08x, %d)\n", ipp, num_values));
DEBUG_printf(("add_attr(%08x, %d)\n", ipp, num_values));
if (ipp == NULL || num_values < 0)
return (NULL);
@@ -1642,63 +1425,17 @@ _ipp_add_attr(ipp_t *ipp, /* I - IPP request */
}
/*
* '_ipp_free_attr()' - Free an attribute.
*/
void
_ipp_free_attr(ipp_attribute_t *attr) /* I - Attribute to free */
{
int i; /* Looping var */
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;
default :
break; /* anti-compiler-warning-code */
}
if (attr->name != NULL)
free(attr->name);
free(attr);
}
/*
* 'ipp_read()' - Semi-blocking read on a HTTP connection...
*/
static int /* O - Number of bytes read */
ipp_read(http_t *http, /* I - Client connection */
unsigned char *buffer, /* O - Buffer for data */
int length) /* I - Total length */
static int /* O - Number of bytes read */
ipp_read(http_t *http, /* I - Client connection */
char *buffer,/* O - Buffer for data */
int length) /* I - Total length */
{
int tbytes, /* Total bytes read */
bytes; /* Bytes read this pass */
int tbytes, /* Total bytes read */
bytes; /* Bytes read this pass */
/*
@@ -1706,7 +1443,7 @@ ipp_read(http_t *http, /* I - Client connection */
*/
for (tbytes = 0; tbytes < length; tbytes += bytes, buffer += bytes)
if ((bytes = httpRead(http, (char *)buffer, length - tbytes)) <= 0)
if ((bytes = httpRead(http, buffer, length - tbytes)) <= 0)
break;
/*
@@ -1717,6 +1454,7 @@ ipp_read(http_t *http, /* I - Client connection */
}
/*
* End of "$Id$".
*/
+32 -52
Ver Arquivo
@@ -4,7 +4,7 @@
* Internet Printing Protocol definitions 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
@@ -30,7 +30,7 @@
* Include necessary headers...
*/
# include "http.h"
# include <cups/http.h>
/*
@@ -75,14 +75,11 @@ typedef enum /**** Format tags for attribute formats... ****/
IPP_TAG_JOB,
IPP_TAG_END,
IPP_TAG_PRINTER,
IPP_TAG_UNSUPPORTED_GROUP,
IPP_TAG_UNSUPPORTED_VALUE = 0x10,
IPP_TAG_EXTENSION,
IPP_TAG_UNSUPPORTED = 0x10,
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,
@@ -90,12 +87,11 @@ typedef enum /**** Format tags for attribute formats... ****/
IPP_TAG_DATE,
IPP_TAG_RESOLUTION,
IPP_TAG_RANGE,
IPP_TAG_COLLECTION,
IPP_TAG_TEXTLANG,
IPP_TAG_NAMELANG,
IPP_TAG_TEXT = 0x41,
IPP_TAG_NAME,
IPP_TAG_KEYWORD = 0x44,
IPP_TAG_KEYWORD,
IPP_TAG_URI,
IPP_TAG_URISCHEME,
IPP_TAG_CHARSET,
@@ -109,6 +105,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,
@@ -139,7 +143,7 @@ typedef enum /**** Job States.... */
IPP_JOB_HELD,
IPP_JOB_PROCESSING,
IPP_JOB_STOPPED,
IPP_JOB_CANCELLED,
IPP_JOB_CANCELED,
IPP_JOB_ABORTED,
IPP_JOB_COMPLETED
} ipp_jstate_t;
@@ -172,15 +176,12 @@ typedef enum /**** IPP operations... ****/
IPP_GET_JOB_ATTRIBUTES,
IPP_GET_JOBS,
IPP_GET_PRINTER_ATTRIBUTES,
IPP_HOLD_JOB,
IPP_HOLD_JOB = 0x000c,
IPP_RELEASE_JOB,
IPP_RESTART_JOB,
IPP_PAUSE_PRINTER = 0x0010,
IPP_RESUME_PRINTER,
IPP_PURGE_JOBS,
IPP_SET_PRINTER_ATTRIBUTES,
IPP_SET_JOB_ATTRIBUTES,
IPP_GET_PRINTER_SUPPORTED_VALUES,
IPP_PRIVATE = 0x4000,
CUPS_GET_DEFAULT,
CUPS_GET_PRINTERS,
@@ -191,10 +192,7 @@ typedef enum /**** IPP operations... ****/
CUPS_DELETE_CLASS,
CUPS_ACCEPT_JOBS,
CUPS_REJECT_JOBS,
CUPS_SET_DEFAULT,
CUPS_GET_DEVICES,
CUPS_GET_PPDS,
CUPS_MOVE_JOB
CUPS_SET_DEFAULT
} ipp_op_t;
typedef enum /**** IPP status codes... ****/
@@ -217,20 +215,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 ****/
@@ -286,12 +278,6 @@ typedef union /**** Attribute Value ****/
char *charset; /* Character set */
char *text; /* String */
} string; /* String with language value */
struct
{
int length; /* Length of attribute */
void *data; /* Data in attribute */
} unknown; /* Unknown attribute type */
} ipp_value_t;
typedef struct ipp_attribute_s /**** Attribute ****/
@@ -320,33 +306,27 @@ typedef struct /**** Request State ****/
* Prototypes...
*/
extern ipp_attribute_t *ippAddBoolean(ipp_t *ipp, ipp_tag_t group, const char *name, char value);
extern ipp_attribute_t *ippAddBooleans(ipp_t *ipp, ipp_tag_t group, const char *name, int num_values, const char *values);
extern ipp_attribute_t *ippAddDate(ipp_t *ipp, ipp_tag_t group, const char *name, const ipp_uchar_t *value);
extern ipp_attribute_t *ippAddInteger(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, const char *name, int value);
extern ipp_attribute_t *ippAddIntegers(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, const char *name, int num_values, const int *values);
extern ipp_attribute_t *ippAddRange(ipp_t *ipp, ipp_tag_t group, const char *name, int lower, int upper);
extern ipp_attribute_t *ippAddRanges(ipp_t *ipp, ipp_tag_t group, const char *name, int num_values, const int *lower, const int *upper);
extern ipp_attribute_t *ippAddResolution(ipp_t *ipp, ipp_tag_t group, const char *name, ipp_res_t units, int xres, int yres);
extern ipp_attribute_t *ippAddResolutions(ipp_t *ipp, ipp_tag_t group, const char *name, int num_values, ipp_res_t units, const int *xres, const int *yres);
extern time_t ippDateToTime(ipp_uchar_t *date);
extern ipp_attribute_t *ippAddBoolean(ipp_t *ipp, ipp_tag_t group, char *name, char value);
extern ipp_attribute_t *ippAddBooleans(ipp_t *ipp, ipp_tag_t group, char *name, int num_values, char *values);
extern ipp_attribute_t *ippAddDate(ipp_t *ipp, ipp_tag_t group, char *name, ipp_uchar_t *value);
extern ipp_attribute_t *ippAddInteger(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, char *name, int value);
extern ipp_attribute_t *ippAddIntegers(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, char *name, int num_values, int *values);
extern ipp_attribute_t *ippAddRange(ipp_t *ipp, ipp_tag_t group, char *name, int lower, int upper);
extern ipp_attribute_t *ippAddRanges(ipp_t *ipp, ipp_tag_t group, char *name, int num_values, int *lower, int *upper);
extern ipp_attribute_t *ippAddResolution(ipp_t *ipp, ipp_tag_t group, char *name, ipp_res_t units, int xres, int yres);
extern ipp_attribute_t *ippAddResolutions(ipp_t *ipp, ipp_tag_t group, char *name, int num_values, ipp_res_t units, int *xres, int *yres);
extern ipp_attribute_t *ippAddSeparator(ipp_t *ipp);
extern ipp_attribute_t *ippAddString(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, const char *name, const char *charset, const char *value);
extern ipp_attribute_t *ippAddStrings(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, const char *name, int num_values, const char *charset, const char **values);
extern time_t ippDateToTime(const ipp_uchar_t *date);
extern ipp_attribute_t *ippAddString(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, char *name, char *charset, char *value);
extern ipp_attribute_t *ippAddStrings(ipp_t *ipp, ipp_tag_t group, ipp_tag_t type, char *name, int num_values, char *charset, char **values);
extern void ippDelete(ipp_t *ipp);
extern const char *ippErrorString(ipp_status_t error);
extern ipp_attribute_t *ippFindAttribute(ipp_t *ipp, const char *name, ipp_tag_t type);
extern ipp_attribute_t *ippFindAttribute(ipp_t *ipp, char *name, ipp_tag_t type);
extern size_t ippLength(ipp_t *ipp);
extern ipp_t *ippNew(void);
extern ipp_state_t ippRead(http_t *http, ipp_t *ipp);
extern const ipp_uchar_t *ippTimeToDate(time_t t);
extern 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 *);
/*
* C++ magic...
+31 -63
Ver Arquivo
@@ -3,7 +3,7 @@
*
* I18N/language support 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
@@ -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 */
{
@@ -140,11 +127,10 @@ cupsLangFree(cups_lang_t *lang) /* I - Language to free */
*/
cups_lang_t * /* O - Language data */
cupsLangGet(const char *language) /* I - Language or locale */
cupsLangGet(char *language) /* I - Language or locale */
{
int i, count; /* Looping vars */
char langname[16], /* Requested language name */
real[16], /* Real language name */
char real[16], /* Real language name */
filename[1024], /* Filename for language locale file */
*localedir; /* Directory for locale files */
FILE *fp; /* Language locale file pointer */
@@ -157,50 +143,32 @@ 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.
* operating systems.
*/
if (language == NULL || language[0] == '\0' ||
strcmp(language, "POSIX") == 0)
strcpy(langname, "C");
else
{
/*
* Copy the locale string over safely...
*/
if (language == NULL || language[0] == '\0')
language = "C";
strncpy(langname, language, sizeof(langname) - 1);
langname[sizeof(langname) - 1] = '\0';
/*
* Strip charset from "locale.charset"...
*/
if ((text = strchr(langname, '.')) != NULL)
*text = '\0';
}
if (strlen(langname) < 2)
if (strlen(language) < 2)
strcpy(real, "C");
else
{
real[0] = tolower(langname[0]);
real[1] = tolower(langname[1]);
real[0] = tolower(language[0]);
real[1] = tolower(language[1]);
if (langname[2] == '_' || langname[2] == '-')
if (language[2] == '_' || language[2] == '-')
{
real[2] = '_';
real[3] = toupper(langname[3]);
real[4] = toupper(langname[4]);
real[3] = toupper(language[3]);
real[4] = toupper(language[4]);
real[5] = '\0';
langname[5] = '\0';
language[5] = '\0';
}
else
{
langname[2] = '\0';
language[2] = '\0';
real[2] = '\0';
}
}
@@ -214,7 +182,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
if ((localedir = getenv("LOCALEDIR")) == NULL)
localedir = CUPS_LOCALEDIR;
snprintf(filename, sizeof(filename), "%s/%s/cups_%s", localedir, real, real);
sprintf(filename, "%s/%s/cups_%s", localedir, real, real);
if ((fp = fopen(filename, "r")) == NULL)
if (strlen(real) > 2)
@@ -224,8 +192,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
*/
real[2] = '\0';
snprintf(filename, sizeof(filename), "%s/%s/cups_%s", localedir, real,
real);
sprintf(filename, "%s/%s/cups_%s", localedir, real, real);
fp = fopen(filename, "r");
}
@@ -234,7 +201,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
*/
for (lang = lang_cache; lang != NULL; lang = lang->next)
if (strcmp(lang->language, langname) == 0)
if (strcmp(lang->language, language) == 0)
{
lang->used ++;
@@ -303,6 +270,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
lang_cache = lang;
}
/*
* Free all old strings as needed...
*/
@@ -320,7 +288,7 @@ cupsLangGet(const char *language) /* I - Language or locale */
*/
lang->used ++;
strcpy(lang->language, langname);
strcpy(lang->language, language);
for (i = 0; i < (sizeof(lang_encodings) / sizeof(lang_encodings[0])); i ++)
if (strcmp(lang_encodings[i], line) == 0)
+4 -33
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Multi-language support 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
@@ -139,17 +139,6 @@ typedef enum /**** Message Indices ****/
CUPS_MSG_COPIES,
CUPS_MSG_FILE_SIZE,
CUPS_MSG_PENDING,
CUPS_MSG_OUTPUT_MODE,
CUPS_MSG_RESOLUTION,
CUPS_MSG_TEXT,
CUPS_MSG_PRETTYPRINT,
CUPS_MSG_MARGINS,
CUPS_MSG_LEFT,
CUPS_MSG_RIGHT,
CUPS_MSG_BOTTOM,
CUPS_MSG_TOP,
CUPS_MSG_FILENAME,
CUPS_MSG_PRINT,
CUPS_MSG_HTTP_BASE = 200,
CUPS_MSG_HTTP_END = 505,
CUPS_MSG_MAX
@@ -168,20 +157,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 ****/
@@ -199,16 +175,11 @@ typedef struct cups_lang_str /**** Language Cache Structure ****/
* Prototypes...
*/
# ifdef WIN32
# define cupsLangDefault() cupsLangGet(setlocale(LC_ALL, ""))
# else /* This fix works around bugs in the Linux and HP-UX setlocale() */
# define cupsLangDefault() cupsLangGet(getenv("LANG"))
# endif /* WIN32 */
# define cupsLangDefault() cupsLangGet(setlocale(LC_ALL, ""))
extern char *cupsLangEncoding(cups_lang_t *lang);
extern void cupsLangFlush(void);
extern void cupsLangFree(cups_lang_t *lang);
extern cups_lang_t *cupsLangGet(const char *language);
extern cups_lang_t *cupsLangGet(char *language);
# define cupsLangString(lang,msg) (lang)->messages[(msg)]
# ifdef __cplusplus
+69 -78
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Option marking routines 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
@@ -33,6 +33,7 @@
* ppdMarkDefaults() - Mark all default options in the PPD file.
* ppdMarkOption() - Mark an option in a PPD file.
* ppd_defaults() - Set the defaults for this group and all sub-groups.
* ppd_default() - Set the default choice for an option.
*/
/*
@@ -41,14 +42,14 @@
#include "ppd.h"
#include "string.h"
#include "debug.h"
/*
* Local functions...
*/
static void ppd_defaults(ppd_file_t *ppd, ppd_group_t *g);
static void ppd_defaults(ppd_group_t *g);
static void ppd_default(ppd_option_t *o);
/*
@@ -118,8 +119,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, "False") == 0)
if (j == 0)
c1 = NULL;
}
@@ -149,8 +149,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, "False") == 0)
if (j == 0)
c2 = NULL;
}
@@ -161,9 +160,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;
@@ -184,7 +180,7 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
ppd_choice_t * /* O - Choice pointer or NULL */
ppdFindChoice(ppd_option_t *o, /* I - Pointer to option */
const char *choice) /* I - Name of choice */
char *choice) /* I - Name of choice */
{
int i; /* Looping var */
ppd_choice_t *c; /* Current choice */
@@ -194,7 +190,7 @@ ppdFindChoice(ppd_option_t *o, /* I - Pointer to option */
return (NULL);
for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
if (strcasecmp(c->choice, choice) == 0)
if (strcmp(c->choice, choice) == 0)
return (c);
return (NULL);
@@ -207,7 +203,7 @@ ppdFindChoice(ppd_option_t *o, /* I - Pointer to option */
ppd_choice_t * /* O - Pointer to choice or NULL */
ppdFindMarkedChoice(ppd_file_t *ppd, /* I - PPD file */
const char *option) /* I - Keyword/option name */
char *option) /* I - Keyword/option name */
{
int i; /* Looping var */
ppd_option_t *o; /* Pointer to option */
@@ -231,7 +227,7 @@ ppdFindMarkedChoice(ppd_file_t *ppd, /* I - PPD file */
ppd_option_t * /* O - Pointer to option or NULL */
ppdFindOption(ppd_file_t *ppd, /* I - PPD file data */
const char *option) /* I - Option/Keyword name */
char *option) /* I - Option/Keyword name */
{
int i, j, k; /* Looping vars */
ppd_option_t *o; /* Pointer to option */
@@ -245,12 +241,12 @@ ppdFindOption(ppd_file_t *ppd, /* I - PPD file data */
for (i = ppd->num_groups, g = ppd->groups; i > 0; i --, g ++)
{
for (j = g->num_options, o = g->options; j > 0; j --, o ++)
if (strcasecmp(o->keyword, option) == 0)
if (strcmp(o->keyword, option) == 0)
return (o);
for (j = g->num_subgroups, sg = g->subgroups; j > 0; j --, sg ++)
for (k = sg->num_options, o = sg->options; k > 0; k --, o ++)
if (strcasecmp(o->keyword, option) == 0)
if (strcmp(o->keyword, option) == 0)
return (o);
}
@@ -264,8 +260,8 @@ ppdFindOption(ppd_file_t *ppd, /* I - PPD file data */
int /* O - Non-zero if option is marked */
ppdIsMarked(ppd_file_t *ppd, /* I - PPD file data */
const char *option, /* I - Option/Keyword name */
const char *choice) /* I - Choice name */
char *option, /* I - Option/Keyword name */
char *choice) /* I - Choice name */
{
ppd_option_t *o; /* Option pointer */
ppd_choice_t *c; /* Choice pointer */
@@ -293,13 +289,19 @@ ppdMarkDefaults(ppd_file_t *ppd)/* I - PPD file record */
{
int i; /* Looping variables */
ppd_group_t *g; /* Current group */
ppd_option_t *o; /* PageSize option */
if (ppd == NULL)
return;
for (i = ppd->num_groups, g = ppd->groups; i > 0; i --, g ++)
ppd_defaults(ppd, g);
ppd_defaults(g);
o = ppdFindOption(ppd, "PageSize");
for (i = 0; i < ppd->num_sizes; i ++)
ppd->sizes[i].marked = strcmp(ppd->sizes[i].name, o->defchoice) == 0;
}
@@ -314,8 +316,8 @@ ppdMarkDefaults(ppd_file_t *ppd)/* I - PPD file record */
int /* O - Number of conflicts */
ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
const char *option, /* I - Keyword */
const char *choice) /* I - Option name */
char *option, /* I - Keyword */
char *choice) /* I - Option name */
{
int i; /* Looping var */
ppd_option_t *o; /* Option pointer */
@@ -325,7 +327,7 @@ ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
if (ppd == NULL)
return (0);
if (strcasecmp(option, "PageSize") == 0 && strncasecmp(choice, "Custom.", 7) == 0)
if (strcmp(option, "PageSize") == 0 && strncmp(choice, "Custom.", 7) == 0)
{
/*
* Handle variable page sizes...
@@ -339,67 +341,35 @@ ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
return (0);
for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
if (strcasecmp(c->choice, choice) == 0)
break;
if (strcmp(c->choice, choice) == 0)
c->marked = 1;
else if (o->ui != PPD_UI_PICKMANY)
c->marked = 0;
if (i)
if (strcmp(option, "PageSize") == 0 || strcmp(option, "PageRegion") == 0)
{
/*
* Option found; mark it and then handle unmarking any other options.
* Mark current page size...
*/
c->marked = 1;
for (i = 0; i < ppd->num_sizes; i ++)
ppd->sizes[i].marked = strcmp(ppd->sizes[i].name, choice) == 0;
if (o->ui != PPD_UI_PICKMANY)
for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
if (strcasecmp(c->choice, choice) != 0)
c->marked = 0;
/*
* Unmark the current PageSize or PageRegion setting, as appropriate...
*/
if (strcasecmp(option, "PageSize") == 0 || strcasecmp(option, "PageRegion") == 0)
if (strcmp(option, "PageSize") == 0)
{
/*
* Mark current page size...
*/
for (i = 0; i < ppd->num_sizes; i ++)
ppd->sizes[i].marked = strcasecmp(ppd->sizes[i].name, choice) == 0;
/*
* Unmark the current PageSize or PageRegion setting, as appropriate...
*/
if (strcasecmp(option, "PageSize") == 0)
{
if ((o = ppdFindOption(ppd, "PageRegion")) != NULL)
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
}
else
{
if ((o = ppdFindOption(ppd, "PageSize")) != NULL)
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
}
o = ppdFindOption(ppd, "PageRegion");
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
}
else if (strcasecmp(option, "InputSlot") == 0)
else
{
/*
* Unmark ManualFeed option...
*/
if ((o = ppdFindOption(ppd, "ManualFeed")) != NULL)
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
}
else if (strcasecmp(option, "ManualFeed") == 0)
{
/*
* Unmark InputSlot option...
*/
if ((o = ppdFindOption(ppd, "InputSlot")) != NULL)
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
o = ppdFindOption(ppd, "PageSize");
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
}
}
@@ -412,8 +382,7 @@ ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
*/
static void
ppd_defaults(ppd_file_t *ppd, /* I - PPD file */
ppd_group_t *g) /* I - Group to default */
ppd_defaults(ppd_group_t *g) /* I - Group to default */
{
int i; /* Looping var */
ppd_option_t *o; /* Current option */
@@ -424,11 +393,33 @@ ppd_defaults(ppd_file_t *ppd, /* I - PPD file */
return;
for (i = g->num_options, o = g->options; i > 0; i --, o ++)
if (strcasecmp(o->keyword, "PageRegion") != 0)
ppdMarkOption(ppd, o->keyword, o->defchoice);
if (strcmp(o->keyword, "PageRegion") != 0)
ppd_default(o);
for (i = g->num_subgroups, sg = g->subgroups; i > 0; i --, sg ++)
ppd_defaults(ppd, sg);
ppd_defaults(sg);
}
/*
* 'ppd_default()' - Set the default choice for an option.
*/
static void
ppd_default(ppd_option_t *o) /* I - Option to default */
{
int i; /* Looping var */
ppd_choice_t *c; /* Current choice */
if (o == NULL)
return;
for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
if (strcmp(c->choice, o->defchoice) == 0)
c->marked = 1;
else
c->marked = 0;
}
-392
Ver Arquivo
@@ -1,392 +0,0 @@
/*
Copyright (C) 1999 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/*$Id$ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321.
It is derived directly from the text of the RFC and not from the
reference implementation.
The original and principal author of md5.c is L. Peter Deutsch
<ghost@aladdin.com>. Other authors are noted in the change history
that follows (in reverse chronological order):
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5).
1999-05-03 lpd Original version.
*/
#include "md5.h"
#include "string.h"
#ifdef TEST
/*
* Compile with -DTEST to create a self-contained executable test program.
* The test program should print out the same values as given in section
* A.5 of RFC 1321, reproduced below.
*/
main()
{
static const char *const test[7] = {
"", /*d41d8cd98f00b204e9800998ecf8427e*/
"a", /*0cc175b9c0f1b6a831c399e269772661*/
"abc", /*900150983cd24fb0d6963f7d28e17f72*/
"message digest", /*f96b697d7cb7938d525a2f31aaf161d0*/
"abcdefghijklmnopqrstuvwxyz", /*c3fcd3d76192e4007dfb496cca67e13b*/
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",
/*d174ab98d277d9f5a5611c2c9f419d9f*/
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" /*57edf4a22be3c955ac49da2e2107b67a*/
};
int i;
for (i = 0; i < 7; ++i) {
md5_state_t state;
md5_byte_t digest[16];
int di;
md5_init(&state);
md5_append(&state, (const md5_byte_t *)test[i], strlen(test[i]));
md5_finish(&state, digest);
printf("MD5 (\"%s\") = ", test[i]);
for (di = 0; di < 16; ++di)
printf("%02x", digest[di]);
printf("\n");
}
return 0;
}
#endif /* TEST */
/*
* For reference, here is the program that computed the T values.
*/
#if 0
#include <math.h>
main()
{
int i;
for (i = 1; i <= 64; ++i) {
unsigned long v = (unsigned long)(4294967296.0 * fabs(sin((double)i)));
printf("#define T%d 0x%08lx\n", i, v);
}
return 0;
}
#endif
/*
* End of T computation program.
*/
#define T1 0xd76aa478
#define T2 0xe8c7b756
#define T3 0x242070db
#define T4 0xc1bdceee
#define T5 0xf57c0faf
#define T6 0x4787c62a
#define T7 0xa8304613
#define T8 0xfd469501
#define T9 0x698098d8
#define T10 0x8b44f7af
#define T11 0xffff5bb1
#define T12 0x895cd7be
#define T13 0x6b901122
#define T14 0xfd987193
#define T15 0xa679438e
#define T16 0x49b40821
#define T17 0xf61e2562
#define T18 0xc040b340
#define T19 0x265e5a51
#define T20 0xe9b6c7aa
#define T21 0xd62f105d
#define T22 0x02441453
#define T23 0xd8a1e681
#define T24 0xe7d3fbc8
#define T25 0x21e1cde6
#define T26 0xc33707d6
#define T27 0xf4d50d87
#define T28 0x455a14ed
#define T29 0xa9e3e905
#define T30 0xfcefa3f8
#define T31 0x676f02d9
#define T32 0x8d2a4c8a
#define T33 0xfffa3942
#define T34 0x8771f681
#define T35 0x6d9d6122
#define T36 0xfde5380c
#define T37 0xa4beea44
#define T38 0x4bdecfa9
#define T39 0xf6bb4b60
#define T40 0xbebfbc70
#define T41 0x289b7ec6
#define T42 0xeaa127fa
#define T43 0xd4ef3085
#define T44 0x04881d05
#define T45 0xd9d4d039
#define T46 0xe6db99e5
#define T47 0x1fa27cf8
#define T48 0xc4ac5665
#define T49 0xf4292244
#define T50 0x432aff97
#define T51 0xab9423a7
#define T52 0xfc93a039
#define T53 0x655b59c3
#define T54 0x8f0ccc92
#define T55 0xffeff47d
#define T56 0x85845dd1
#define T57 0x6fa87e4f
#define T58 0xfe2ce6e0
#define T59 0xa3014314
#define T60 0x4e0811a1
#define T61 0xf7537e82
#define T62 0xbd3af235
#define T63 0x2ad7d2bb
#define T64 0xeb86d391
static void
md5_process(md5_state_t *pms, const md5_byte_t *data /*[64]*/)
{
md5_word_t
a = pms->abcd[0], b = pms->abcd[1],
c = pms->abcd[2], d = pms->abcd[3];
md5_word_t t;
#ifndef ARCH_IS_BIG_ENDIAN
# define ARCH_IS_BIG_ENDIAN 1 /* slower, default implementation */
#endif
#if ARCH_IS_BIG_ENDIAN
/*
* On big-endian machines, we must arrange the bytes in the right
* order. (This also works on machines of unknown byte order.)
*/
md5_word_t X[16];
const md5_byte_t *xp = data;
int i;
for (i = 0; i < 16; ++i, xp += 4)
X[i] = xp[0] + (xp[1] << 8) + (xp[2] << 16) + (xp[3] << 24);
#else /* !ARCH_IS_BIG_ENDIAN */
/*
* On little-endian machines, we can process properly aligned data
* without copying it.
*/
md5_word_t xbuf[16];
const md5_word_t *X;
if (!((data - (const md5_byte_t *)0) & 3)) {
/* data are properly aligned */
X = (const md5_word_t *)data;
} else {
/* not aligned */
memcpy(xbuf, data, 64);
X = xbuf;
}
#endif
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
/* Round 1. */
/* Let [abcd k s i] denote the operation
a = b + ((a + F(b,c,d) + X[k] + T[i]) <<< s). */
#define F(x, y, z) (((x) & (y)) | (~(x) & (z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + F(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 7, T1);
SET(d, a, b, c, 1, 12, T2);
SET(c, d, a, b, 2, 17, T3);
SET(b, c, d, a, 3, 22, T4);
SET(a, b, c, d, 4, 7, T5);
SET(d, a, b, c, 5, 12, T6);
SET(c, d, a, b, 6, 17, T7);
SET(b, c, d, a, 7, 22, T8);
SET(a, b, c, d, 8, 7, T9);
SET(d, a, b, c, 9, 12, T10);
SET(c, d, a, b, 10, 17, T11);
SET(b, c, d, a, 11, 22, T12);
SET(a, b, c, d, 12, 7, T13);
SET(d, a, b, c, 13, 12, T14);
SET(c, d, a, b, 14, 17, T15);
SET(b, c, d, a, 15, 22, T16);
#undef SET
/* Round 2. */
/* Let [abcd k s i] denote the operation
a = b + ((a + G(b,c,d) + X[k] + T[i]) <<< s). */
#define G(x, y, z) (((x) & (z)) | ((y) & ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + G(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 1, 5, T17);
SET(d, a, b, c, 6, 9, T18);
SET(c, d, a, b, 11, 14, T19);
SET(b, c, d, a, 0, 20, T20);
SET(a, b, c, d, 5, 5, T21);
SET(d, a, b, c, 10, 9, T22);
SET(c, d, a, b, 15, 14, T23);
SET(b, c, d, a, 4, 20, T24);
SET(a, b, c, d, 9, 5, T25);
SET(d, a, b, c, 14, 9, T26);
SET(c, d, a, b, 3, 14, T27);
SET(b, c, d, a, 8, 20, T28);
SET(a, b, c, d, 13, 5, T29);
SET(d, a, b, c, 2, 9, T30);
SET(c, d, a, b, 7, 14, T31);
SET(b, c, d, a, 12, 20, T32);
#undef SET
/* Round 3. */
/* Let [abcd k s t] denote the operation
a = b + ((a + H(b,c,d) + X[k] + T[i]) <<< s). */
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define SET(a, b, c, d, k, s, Ti)\
t = a + H(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 5, 4, T33);
SET(d, a, b, c, 8, 11, T34);
SET(c, d, a, b, 11, 16, T35);
SET(b, c, d, a, 14, 23, T36);
SET(a, b, c, d, 1, 4, T37);
SET(d, a, b, c, 4, 11, T38);
SET(c, d, a, b, 7, 16, T39);
SET(b, c, d, a, 10, 23, T40);
SET(a, b, c, d, 13, 4, T41);
SET(d, a, b, c, 0, 11, T42);
SET(c, d, a, b, 3, 16, T43);
SET(b, c, d, a, 6, 23, T44);
SET(a, b, c, d, 9, 4, T45);
SET(d, a, b, c, 12, 11, T46);
SET(c, d, a, b, 15, 16, T47);
SET(b, c, d, a, 2, 23, T48);
#undef SET
/* Round 4. */
/* Let [abcd k s t] denote the operation
a = b + ((a + I(b,c,d) + X[k] + T[i]) <<< s). */
#define I(x, y, z) ((y) ^ ((x) | ~(z)))
#define SET(a, b, c, d, k, s, Ti)\
t = a + I(b,c,d) + X[k] + Ti;\
a = ROTATE_LEFT(t, s) + b
/* Do the following 16 operations. */
SET(a, b, c, d, 0, 6, T49);
SET(d, a, b, c, 7, 10, T50);
SET(c, d, a, b, 14, 15, T51);
SET(b, c, d, a, 5, 21, T52);
SET(a, b, c, d, 12, 6, T53);
SET(d, a, b, c, 3, 10, T54);
SET(c, d, a, b, 10, 15, T55);
SET(b, c, d, a, 1, 21, T56);
SET(a, b, c, d, 8, 6, T57);
SET(d, a, b, c, 15, 10, T58);
SET(c, d, a, b, 6, 15, T59);
SET(b, c, d, a, 13, 21, T60);
SET(a, b, c, d, 4, 6, T61);
SET(d, a, b, c, 11, 10, T62);
SET(c, d, a, b, 2, 15, T63);
SET(b, c, d, a, 9, 21, T64);
#undef SET
/* Then perform the following additions. (That is increment each
of the four registers by the value it had before this block
was started.) */
pms->abcd[0] += a;
pms->abcd[1] += b;
pms->abcd[2] += c;
pms->abcd[3] += d;
}
void
md5_init(md5_state_t *pms)
{
pms->count[0] = pms->count[1] = 0;
pms->abcd[0] = 0x67452301;
pms->abcd[1] = 0xefcdab89;
pms->abcd[2] = 0x98badcfe;
pms->abcd[3] = 0x10325476;
}
void
md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes)
{
const md5_byte_t *p = data;
int left = nbytes;
int offset = (pms->count[0] >> 3) & 63;
md5_word_t nbits = (md5_word_t)(nbytes << 3);
if (nbytes <= 0)
return;
/* Update the message length. */
pms->count[1] += nbytes >> 29;
pms->count[0] += nbits;
if (pms->count[0] < nbits)
pms->count[1]++;
/* Process an initial partial block. */
if (offset) {
int copy = (offset + nbytes > 64 ? 64 - offset : nbytes);
memcpy(pms->buf + offset, p, copy);
if (offset + copy < 64)
return;
p += copy;
left -= copy;
md5_process(pms, pms->buf);
}
/* Process full blocks. */
for (; left >= 64; p += 64, left -= 64)
md5_process(pms, p);
/* Process a final partial block. */
if (left)
memcpy(pms->buf, p, left);
}
void
md5_finish(md5_state_t *pms, md5_byte_t digest[16])
{
static const md5_byte_t pad[64] = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
md5_byte_t data[8];
int i;
/* Save the length before padding. */
for (i = 0; i < 8; ++i)
data[i] = (md5_byte_t)(pms->count[i >> 2] >> ((i & 3) << 3));
/* Pad to 56 bytes mod 64. */
md5_append(pms, pad, ((55 - (pms->count[0] >> 3)) & 63) + 1);
/* Append the length. */
md5_append(pms, data, 8);
for (i = 0; i < 16; ++i)
digest[i] = (md5_byte_t)(pms->abcd[i >> 2] >> ((i & 3) << 3));
}
-94
Ver Arquivo
@@ -1,94 +0,0 @@
/*
Copyright (C) 1999 Aladdin Enterprises. All rights reserved.
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
L. Peter Deutsch
ghost@aladdin.com
*/
/*$Id$ */
/*
Independent implementation of MD5 (RFC 1321).
This code implements the MD5 Algorithm defined in RFC 1321.
It is derived directly from the text of the RFC and not from the
reference implementation.
The original and principal author of md5.h is L. Peter Deutsch
<ghost@aladdin.com>. Other authors are noted in the change history
that follows (in reverse chronological order):
1999-11-04 lpd Edited comments slightly for automatic TOC extraction.
1999-10-18 lpd Fixed typo in header comment (ansi2knr rather than md5);
added conditionalization for C++ compilation from Martin
Purschke <purschke@bnl.gov>.
1999-05-03 lpd Original version.
*/
#ifndef md5_INCLUDED
# define md5_INCLUDED
/*
* This code has some adaptations for the Ghostscript environment, but it
* will compile and run correctly in any environment with 8-bit chars and
* 32-bit ints. Specifically, it assumes that if the following are
* defined, they have the same meaning as in Ghostscript: P1, P2, P3,
* ARCH_IS_BIG_ENDIAN.
*/
typedef unsigned char md5_byte_t; /* 8-bit byte */
typedef unsigned int md5_word_t; /* 32-bit word */
/* Define the state of the MD5 Algorithm. */
typedef struct md5_state_s {
md5_word_t count[2]; /* message length in bits, lsw first */
md5_word_t abcd[4]; /* digest buffer */
md5_byte_t buf[64]; /* accumulate block */
} md5_state_t;
#ifdef __cplusplus
extern "C"
{
#endif
/* Initialize the algorithm. */
#ifdef P1
void md5_init(P1(md5_state_t *pms));
#else
void md5_init(md5_state_t *pms);
#endif
/* Append a string to the message. */
#ifdef P3
void md5_append(P3(md5_state_t *pms, const md5_byte_t *data, int nbytes));
#else
void md5_append(md5_state_t *pms, const md5_byte_t *data, int nbytes);
#endif
/* Finish the message and return the digest. */
#ifdef P2
void md5_finish(P2(md5_state_t *pms, md5_byte_t digest[16]));
#else
void md5_finish(md5_state_t *pms, md5_byte_t digest[16]);
#endif
#ifdef __cplusplus
} /* end extern "C" */
#endif
#endif /* md5_INCLUDED */
-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$".
*/
+74 -23
Ver Arquivo
@@ -3,7 +3,7 @@
*
* MIME database file routines 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
@@ -29,6 +29,73 @@
* load_types() - Load a xyz.types file...
* delete_rules() - Free all memory for the given rule tree.
* load_convs() - Load a xyz.convs file...
*
* Revision History:
*
* $Log: mime.c,v $
* Revision 1.13 1999/06/18 18:36:10 mike
* Fixed address to 44141 Airport View Drive...
*
* Revision 1.12 1999/04/21 21:19:33 mike
* Changes for HP-UX.
*
* Revision 1.11 1999/04/21 19:31:29 mike
* Changed the directory header stuff to use the autoconf-recommended
* sequence of #ifdef's.
*
* Changed the language routines to look for the LOCALEDIR environment
* variable, and if it is not defined to use the LOCALEDIR string defined
* in config.h.
*
* Revision 1.10 1999/03/01 20:51:53 mike
* Code cleanup - removed extraneous semi-colons...
*
* Revision 1.9 1999/02/26 22:00:51 mike
* Added more debug statements.
*
* Fixed bugs in cupsPrintFile() - wasn't setting the IPP_TAG_MIMETYPE
* value tag for the file type.
*
* Updated conversion filter code to handle wildcards for super-type.
*
* Revision 1.8 1999/02/20 16:04:38 mike
* Updated mime.c to scan directories under WIN32.
*
* Fixed some compiler warnings under WIN32.
*
* Updated VC++ project files.
*
* Updated mime.types and mime.convs files for actual registered
* MIME type names.
*
* Revision 1.7 1999/02/05 17:40:53 mike
* Added IPP client read/write code.
*
* Added string functions missing from some UNIXs.
*
* Added option parsing functions.
*
* Added IPP convenience functions (not implemented yet).
*
* Updated source files to use local string.h as needed (for
* missing string functions)
*
* Revision 1.6 1999/02/01 22:08:39 mike
* Restored original directory-scanning functionality of mimeLoad().
*
* Revision 1.4 1999/01/27 18:31:56 mike
* Updated PPD routines to handle emulations and patch files.
*
* Added DSC comments to emit output as appropriate.
*
* Revision 1.3 1999/01/24 14:18:43 mike
* Check-in prior to CVS use.
*
* Revision 1.2 1998/08/06 14:38:38 mike
* Finished coding and testing for CUPS 1.0.
*
* Revision 1.1 1998/06/11 20:50:53 mike
* Initial revision
*/
/*
@@ -39,7 +106,7 @@
#include <stdlib.h>
#include <ctype.h>
#include <cups/string.h>
#include "string.h"
#include "mime.h"
#if defined(WIN32) || defined(__EMX__)
@@ -110,8 +177,8 @@ mimeDelete(mime_t *mime) /* I - MIME database */
*/
mime_t * /* O - Updated MIME database */
mimeMerge(mime_t *mime, /* I - MIME database to add to */
const char *pathname) /* I - Directory to load */
mimeMerge(mime_t *mime, /* I - MIME database to add to */
char *pathname) /* I - Directory to load */
{
#if defined(WIN32) || defined(__EMX__)
HANDLE dir; /* Directory handle */
@@ -128,9 +195,7 @@ mimeMerge(mime_t *mime, /* I - MIME database to add to */
if (pathname == NULL)
return (NULL);
strncpy(filename, pathname, sizeof(filename) - 1);
filename[sizeof(filename) - 1] = '\0';
strcpy(filename, pathname);
pathsep = filename + strlen(filename);
if (pathsep == filename ||
(pathsep[-1] != '/' && pathsep[-1] != '\\'))
@@ -230,7 +295,7 @@ mimeMerge(mime_t *mime, /* I - MIME database to add to */
* Load a mime.types file...
*/
snprintf(filename, sizeof(filename), "%s/%s", pathname, dent->d_name);
sprintf(filename, "%s/%s", pathname, dent->d_name);
load_types(mime, filename);
}
}
@@ -250,7 +315,7 @@ mimeMerge(mime_t *mime, /* I - MIME database to add to */
* Load a mime.convs file...
*/
snprintf(filename, sizeof(filename), "%s/%s", pathname, dent->d_name);
sprintf(filename, "%s/%s", pathname, dent->d_name);
load_convs(mime, filename);
}
}
@@ -373,8 +438,6 @@ load_types(mime_t *mime, /* I - MIME database */
typeptr = mimeAddType(mime, super, type);
mimeAddTypeRule(typeptr, lineptr);
}
fclose(fp);
}
@@ -507,16 +570,6 @@ load_convs(mime_t *mime, /* I - MIME database */
*temp = '\0';
if (strcmp(super, "*") == 0 && strcmp(type, "*") == 0)
{
/*
* Force * / * to be "application/octet-stream"...
*/
strcpy(super, "application");
strcpy(type, "octet-stream");
}
/*
* Add the filter to the MIME database, supporting wildcards as needed...
*/
@@ -526,8 +579,6 @@ load_convs(mime_t *mime, /* I - MIME database */
(type[0] == '*' || strcmp((*temptype)->type, type) == 0))
mimeAddFilter(mime, *temptype, dsttype, cost, filter);
}
fclose(fp);
}
+8 -10
Ver Arquivo
@@ -3,7 +3,7 @@
*
* MIME type/conversion database definitions 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
@@ -60,8 +60,7 @@ typedef enum
MIME_MAGIC_CHAR, /* Character/byte matches */
MIME_MAGIC_SHORT, /* Short/16-bit word matches */
MIME_MAGIC_INT, /* Integer/32-bit word matches */
MIME_MAGIC_LOCALE, /* Current locale matches string */
MIME_MAGIC_CONTAINS /* File contains a string */
MIME_MAGIC_LOCALE /* Current locale matches string */
} mime_op_t;
typedef struct mime_magic_str /**** MIME Magic Data ****/
@@ -73,7 +72,6 @@ typedef struct mime_magic_str /**** MIME Magic Data ****/
short op, /* Operation code (see above) */
invert; /* Invert the result */
int offset, /* Offset in file */
region, /* Region length */
length; /* Length of data */
union
{
@@ -116,16 +114,16 @@ typedef struct /**** MIME Database ****/
extern void mimeDelete(mime_t *mime);
#define mimeLoad(pathname) mimeMerge((mime_t *)0, (pathname));
extern mime_t *mimeMerge(mime_t *mime, const char *pathname);
extern mime_t *mimeMerge(mime_t *mime, char *pathname);
extern mime_t *mimeNew(void);
extern mime_type_t *mimeAddType(mime_t *mime, const char *super, const char *type);
extern int mimeAddTypeRule(mime_type_t *mt, const char *rule);
extern mime_type_t *mimeFileType(mime_t *mime, const char *pathname);
extern mime_type_t *mimeType(mime_t *mime, const char *super, const char *type);
extern mime_type_t *mimeAddType(mime_t *mime, char *super, char *type);
extern int mimeAddTypeRule(mime_type_t *mt, char *rule);
extern mime_type_t *mimeFileType(mime_t *mime, char *pathname);
extern mime_type_t *mimeType(mime_t *mime, char *super, char *type);
extern mime_filter_t *mimeAddFilter(mime_t *mime, mime_type_t *src, mime_type_t *dst,
int cost, const char *filter);
int cost, char *filter);
extern mime_filter_t *mimeFilter(mime_t *mime, mime_type_t *src, mime_type_t *dst,
int *num_filters);
+30 -354
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Option 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,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"
/*
@@ -47,8 +45,8 @@
*/
int /* O - Number of options */
cupsAddOption(const char *name, /* I - Name of option */
const char *value, /* I - Value of option */
cupsAddOption(char *name, /* I - Name of option */
char *value, /* I - Value of option */
int num_options, /* I - Number of options */
cups_option_t **options) /* IO - Pointer to options */
{
@@ -64,7 +62,7 @@ cupsAddOption(const char *name, /* I - Name of option */
*/
for (i = 0, temp = *options; i < num_options; i ++, temp ++)
if (strcasecmp(temp->name, name) == 0)
if (strcmp(temp->name, name) == 0)
break;
if (i >= num_options)
@@ -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.
*/
@@ -398,8 +128,8 @@ cupsFreeOptions(int num_options, /* I - Number of options */
* 'cupsGetOption()' - Get an option value.
*/
const char * /* O - Option value or NULL */
cupsGetOption(const char *name, /* I - Name of option */
char * /* O - Option value or NULL */
cupsGetOption(char *name, /* I - Name of option */
int num_options,/* I - Number of options */
cups_option_t *options) /* I - Options */
{
@@ -410,7 +140,7 @@ cupsGetOption(const char *name, /* I - Name of option */
return (NULL);
for (i = 0; i < num_options; i ++)
if (strcasecmp(options[i].name, name) == 0)
if (strcmp(options[i].name, name) == 0)
return (options[i].value);
return (NULL);
@@ -422,7 +152,7 @@ cupsGetOption(const char *name, /* I - Name of option */
*/
int /* O - Number of options found */
cupsParseOptions(const char *arg, /* I - Argument to parse */
cupsParseOptions(char *arg, /* I - Argument to parse */
int num_options, /* I - Number of options */
cups_option_t **options) /* O - Options found */
{
@@ -549,97 +279,43 @@ cupsMarkOptions(ppd_file_t *ppd, /* I - PPD file */
{
int i; /* Looping var */
int conflict; /* Option conflicts */
char *val, /* Pointer into value */
*ptr, /* Pointer into string */
s[255]; /* Temporary string */
conflict = 0;
for (i = num_options; i > 0; i --, options ++)
if (strcasecmp(options->name, "media") == 0)
if (strcmp(options->name, "media") == 0)
{
/*
* Loop through the option string, separating it at commas and
* marking each individual option.
*/
for (val = options->value; *val;)
{
/*
* Extract the sub-option from the string...
*/
for (ptr = s; *val && *val != ',' && (ptr - s) < (sizeof(s) - 1);)
*ptr++ = *val++;
*ptr++ = '\0';
if (*val == ',')
val ++;
/*
* Mark it...
*/
if (ppdMarkOption(ppd, "PageSize", s))
conflict = 1;
if (ppdMarkOption(ppd, "InputSlot", s))
conflict = 1;
if (ppdMarkOption(ppd, "MediaType", s))
conflict = 1;
if (ppdMarkOption(ppd, "EFMediaQualityMode", s)) /* EFI */
conflict = 1;
if (strcasecmp(s, "manual") == 0)
if (ppdMarkOption(ppd, "ManualFeed", "True"))
conflict = 1;
}
if (ppdMarkOption(ppd, "PageSize", options->value))
conflict = 1;
if (ppdMarkOption(ppd, "InputSlot", options->value))
conflict = 1;
if (ppdMarkOption(ppd, "MediaType", options->value))
conflict = 1;
}
else if (strcasecmp(options->name, "sides") == 0)
else if (strcmp(options->name, "sides") == 0)
{
if (strcasecmp(options->value, "one-sided") == 0)
if (strcmp(options->value, "one-sided") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "None"))
conflict = 1;
if (ppdMarkOption(ppd, "EFDuplex", "None")) /* EFI */
conflict = 1;
if (ppdMarkOption(ppd, "KD03Duplex", "None")) /* Kodak */
}
else if (strcmp(options->value, "two-sided-long-edge") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "NoTumble"))
conflict = 1;
}
else if (strcasecmp(options->value, "two-sided-long-edge") == 0)
else if (strcmp(options->value, "two-sided-short-edge") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "DuplexNoTumble"))
conflict = 1;
if (ppdMarkOption(ppd, "EFDuplex", "DuplexNoTumble")) /* EFI */
conflict = 1;
if (ppdMarkOption(ppd, "KD03Duplex", "DuplexNoTumble")) /* Kodak */
conflict = 1;
}
else if (strcasecmp(options->value, "two-sided-short-edge") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "DuplexTumble"))
conflict = 1;
if (ppdMarkOption(ppd, "EFDuplex", "DuplexTumble")) /* EFI */
conflict = 1;
if (ppdMarkOption(ppd, "KD03Duplex", "DuplexTumble")) /* Kodak */
if (ppdMarkOption(ppd, "Duplex", "Tumble"))
conflict = 1;
}
}
else if (strcasecmp(options->name, "resolution") == 0 ||
strcasecmp(options->name, "printer-resolution") == 0)
else if (strcmp(options->name, "resolution") == 0)
{
if (ppdMarkOption(ppd, "Resolution", options->value))
conflict = 1;
if (ppdMarkOption(ppd, "SetResolution", options->value))
/* Calcomp, Linotype, QMS, Summagraphics, Tektronix, Varityper */
conflict = 1;
if (ppdMarkOption(ppd, "JCLResolution", options->value)) /* HP */
conflict = 1;
if (ppdMarkOption(ppd, "CNRes_PGP", options->value)) /* Canon */
conflict = 1;
}
else if (strcasecmp(options->name, "output-bin") == 0)
{
if (ppdMarkOption(ppd, "OutputBin", options->value))
if (ppdMarkOption(ppd, "JCLResolution", options->value))
conflict = 1;
}
else if (ppdMarkOption(ppd, options->name, options->value))
+32 -42
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Page size functions 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
@@ -45,7 +45,7 @@
ppd_size_t * /* O - Size record for page or NULL */
ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
const char *name) /* I - Size name */
char *name) /* I - Size name */
{
int i; /* Looping var */
float w, l; /* Width and length of page */
@@ -57,19 +57,9 @@ ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
if (name != NULL)
{
if (strncmp(name, "Custom.", 7) == 0 && ppd->variable_sizes)
if (strncmp(name, "Custom.", 7) == 0 &&
strcmp(ppd->sizes[0].name, "Custom") == 0)
{
/*
* Find the custom page size...
*/
for (i = 0; i < ppd->num_sizes; i ++)
if (strcmp("Custom", ppd->sizes[i].name) == 0)
break;
if (i == ppd->num_sizes)
return (NULL);
/*
* Variable size; size name can be one of the following:
*
@@ -80,47 +70,47 @@ ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
*/
units[0] = '\0';
if (sscanf(name + 7, "%fx%f%254s", &w, &l, units) < 2)
if (sscanf(name + 7, "%fx%f%s", &w, &l, units) < 2)
return (NULL);
if (strcasecmp(units, "in") == 0)
{
ppd->sizes[i].width = w * 72.0f;
ppd->sizes[i].length = l * 72.0f;
ppd->sizes[i].left = ppd->custom_margins[0];
ppd->sizes[i].bottom = ppd->custom_margins[1];
ppd->sizes[i].right = w * 72.0f - ppd->custom_margins[2];
ppd->sizes[i].top = l * 72.0f - ppd->custom_margins[3];
ppd->sizes[0].width = w * 72.0;
ppd->sizes[0].length = l * 72.0;
ppd->sizes[0].left = ppd->custom_margins[0];
ppd->sizes[0].bottom = ppd->custom_margins[1];
ppd->sizes[0].right = w * 72.0 - ppd->custom_margins[2];
ppd->sizes[0].top = l * 72.0 - ppd->custom_margins[3];
}
else if (strcasecmp(units, "cm") == 0)
{
ppd->sizes[i].width = w / 2.54f * 72.0f;
ppd->sizes[i].length = l / 2.54f * 72.0f;
ppd->sizes[i].left = ppd->custom_margins[0];
ppd->sizes[i].bottom = ppd->custom_margins[1];
ppd->sizes[i].right = w / 2.54f * 72.0f - ppd->custom_margins[2];
ppd->sizes[i].top = l / 2.54f * 72.0f - ppd->custom_margins[3];
ppd->sizes[0].width = w * 2.54 * 72.0;
ppd->sizes[0].length = l * 2.54 * 72.0;
ppd->sizes[0].left = ppd->custom_margins[0];
ppd->sizes[0].bottom = ppd->custom_margins[1];
ppd->sizes[0].right = w * 2.54 * 72.0 - ppd->custom_margins[2];
ppd->sizes[0].top = l * 2.54 * 72.0 - ppd->custom_margins[3];
}
else if (strcasecmp(units, "mm") == 0)
{
ppd->sizes[i].width = w / 25.4f * 72.0f;
ppd->sizes[i].length = l / 25.4f * 72.0f;
ppd->sizes[i].left = ppd->custom_margins[0];
ppd->sizes[i].bottom = ppd->custom_margins[1];
ppd->sizes[i].right = w / 25.4f * 72.0f - ppd->custom_margins[2];
ppd->sizes[i].top = l / 25.4f * 72.0f - ppd->custom_margins[3];
ppd->sizes[0].width = w * 25.4 * 72.0;
ppd->sizes[0].length = l * 25.4 * 72.0;
ppd->sizes[0].left = ppd->custom_margins[0];
ppd->sizes[0].bottom = ppd->custom_margins[1];
ppd->sizes[0].right = w * 25.4 * 72.0 - ppd->custom_margins[2];
ppd->sizes[0].top = l * 25.4 * 72.0 - ppd->custom_margins[3];
}
else
{
ppd->sizes[i].width = w;
ppd->sizes[i].length = l;
ppd->sizes[i].left = ppd->custom_margins[0];
ppd->sizes[i].bottom = ppd->custom_margins[1];
ppd->sizes[i].right = w - ppd->custom_margins[2];
ppd->sizes[i].top = l - ppd->custom_margins[3];
ppd->sizes[0].width = w;
ppd->sizes[0].length = l;
ppd->sizes[0].left = ppd->custom_margins[0];
ppd->sizes[0].bottom = ppd->custom_margins[1];
ppd->sizes[0].right = w - ppd->custom_margins[2];
ppd->sizes[0].top = l - ppd->custom_margins[3];
}
return (ppd->sizes + i);
return (ppd->sizes);
}
else
{
@@ -154,7 +144,7 @@ ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
float /* O - Width of page in points or 0.0 */
ppdPageWidth(ppd_file_t *ppd, /* I - PPD file record */
const char *name) /* I - Size name */
char *name) /* I - Size name */
{
ppd_size_t *size; /* Page size */
@@ -172,7 +162,7 @@ ppdPageWidth(ppd_file_t *ppd, /* I - PPD file record */
float /* O - Length of page in points or 0.0 */
ppdPageLength(ppd_file_t *ppd, /* I - PPD file */
const char *name) /* I - Size name */
char *name) /* I - Size name */
{
ppd_size_t *size; /* Page size */
+134 -245
Ver Arquivo
@@ -3,7 +3,7 @@
*
* PPD file routines 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
@@ -70,8 +70,6 @@
# define WRITE_BINARY "w" /* Open a binary file for writing */
#endif /* WIN32 || __EMX__ */
#define safe_free(p) if (p) free(p) /* Safe free macro */
#define PPD_KEYWORD 1 /* Line contained a keyword */
#define PPD_OPTION 2 /* Line contained an option name */
#define PPD_TEXT 4 /* Line contained human-readable text */
@@ -121,14 +119,14 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
* Free all strings at the top level...
*/
safe_free(ppd->lang_encoding);
safe_free(ppd->lang_version);
safe_free(ppd->modelname);
safe_free(ppd->ttrasterizer);
safe_free(ppd->manufacturer);
safe_free(ppd->product);
safe_free(ppd->nickname);
safe_free(ppd->shortnickname);
free(ppd->lang_encoding);
free(ppd->lang_version);
free(ppd->modelname);
free(ppd->ttrasterizer);
free(ppd->manufacturer);
free(ppd->product);
free(ppd->nickname);
free(ppd->shortnickname);
/*
* Free any emulations...
@@ -138,11 +136,11 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
{
for (i = ppd->num_emulations, emul = ppd->emulations; i > 0; i --, emul ++)
{
safe_free(emul->start);
safe_free(emul->stop);
free(emul->start);
free(emul->stop);
}
safe_free(ppd->emulations);
free(ppd->emulations);
}
/*
@@ -154,7 +152,7 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
for (i = ppd->num_groups, group = ppd->groups; i > 0; i --, group ++)
ppd_free_group(group);
safe_free(ppd->groups);
free(ppd->groups);
}
/*
@@ -162,14 +160,14 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
*/
if (ppd->num_sizes > 0)
safe_free(ppd->sizes);
free(ppd->sizes);
/*
* Free any constraints...
*/
if (ppd->num_consts > 0)
safe_free(ppd->consts);
free(ppd->consts);
/*
* Free any fonts...
@@ -178,9 +176,9 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
if (ppd->num_fonts > 0)
{
for (i = ppd->num_fonts, font = ppd->fonts; i > 0; i --, font ++)
safe_free(*font);
free(*font);
safe_free(ppd->fonts);
free(ppd->fonts);
}
/*
@@ -188,13 +186,13 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
*/
if (ppd->num_profiles > 0)
safe_free(ppd->profiles);
free(ppd->profiles);
/*
* Free the whole record...
*/
safe_free(ppd);
free(ppd);
}
@@ -217,7 +215,7 @@ ppd_free_group(ppd_group_t *group) /* I - Group to free */
i --, option ++)
ppd_free_option(option);
safe_free(group->options);
free(group->options);
}
if (group->num_subgroups > 0)
@@ -227,7 +225,7 @@ ppd_free_group(ppd_group_t *group) /* I - Group to free */
i --, subgroup ++)
ppd_free_group(subgroup);
safe_free(group->subgroups);
free(group->subgroups);
}
}
@@ -248,9 +246,9 @@ ppd_free_option(ppd_option_t *option) /* I - Option to free */
for (i = option->num_choices, choice = option->choices;
i > 0;
i --, choice ++)
safe_free(choice->code);
free(choice->code);
safe_free(option->choices);
free(option->choices);
}
}
@@ -287,7 +285,7 @@ ppd_get_group(ppd_file_t *ppd, /* I - PPD file */
ppd->num_groups ++;
memset(group, 0, sizeof(ppd_group_t));
strncpy(group->text, name, sizeof(group->text) - 1);
strcpy(group->text, name);
}
return (group);
@@ -326,7 +324,7 @@ ppd_get_option(ppd_group_t *group, /* I - Group */
group->num_options ++;
memset(option, 0, sizeof(ppd_option_t));
strncpy(option->keyword, name, sizeof(option->keyword) - 1);
strcpy(option->keyword, name);
}
return (option);
@@ -358,7 +356,7 @@ ppd_add_choice(ppd_option_t *option, /* I - Option */
option->num_choices ++;
memset(choice, 0, sizeof(ppd_choice_t));
strncpy(choice->choice, name, sizeof(choice->choice) - 1);
strcpy(choice->choice, name);
return (choice);
}
@@ -388,7 +386,7 @@ ppd_add_size(ppd_file_t *ppd, /* I - PPD file */
ppd->num_sizes ++;
memset(size, 0, sizeof(ppd_size_t));
strncpy(size->name, name, sizeof(size->name) - 1);
strcpy(size->name, name);
return (size);
}
@@ -451,14 +449,14 @@ ppdOpen(FILE *fp) /* I - File to read from */
* Either this is not a PPD file, or it is not a 4.x PPD file.
*/
safe_free(string);
if (string != NULL)
free(string);
return (NULL);
}
DEBUG_printf(("ppdOpen: keyword = %s, string = %08x\n", keyword, string));
safe_free(string);
if (string != NULL)
free(string);
/*
* Allocate memory for the PPD file record...
@@ -584,8 +582,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)
@@ -603,10 +599,9 @@ ppdOpen(FILE *fp) /* I - File to read from */
ppd->num_profiles ++;
memset(profile, 0, sizeof(ppd_profile_t));
strncpy(profile->resolution, name, sizeof(profile->resolution) - 1);
strncpy(profile->media_type, text, sizeof(profile->media_type) - 1);
sscanf(string, "%f%f%f%f%f%f%f%f%f%f%f", &(profile->density),
&(profile->gamma),
strcpy(profile->resolution, name);
strcpy(profile->media_type, text);
sscanf(string, "%f%f%f%f%f%f%f%f%f%f", &(profile->density),
profile->matrix[0] + 0, profile->matrix[0] + 1,
profile->matrix[0] + 2, profile->matrix[1] + 0,
profile->matrix[1] + 1, profile->matrix[1] + 2,
@@ -631,32 +626,8 @@ ppdOpen(FILE *fp) /* I - File to read from */
*filter = string;
string = NULL;
}
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)
strcmp(string, "True") == 0)
{
ppd->variable_sizes = 1;
@@ -670,43 +641,37 @@ 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);
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);
free(string);
return (NULL);
}
if ((choice = ppd_add_choice(option, "Custom")) == NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
strncpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE),
sizeof(choice->text) - 1);
strcpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE));
group = NULL;
option = NULL;
}
else if (strcmp(keyword, "MaxMediaWidth") == 0)
ppd->custom_max[0] = (float)atof(string);
ppd->custom_max[0] = atof(string);
else if (strcmp(keyword, "MaxMediaHeight") == 0)
ppd->custom_max[1] = (float)atof(string);
ppd->custom_max[1] = atof(string);
else if (strcmp(keyword, "ParamCustomPageSize") == 0)
{
if (strcmp(name, "Width") == 0)
@@ -721,72 +686,20 @@ ppdOpen(FILE *fp) /* I - File to read from */
ppd->custom_margins + 1, ppd->custom_margins + 2,
ppd->custom_margins + 3);
else if (strcmp(keyword, "CustomPageSize") == 0 &&
strcmp(name, "True") == 0)
strcmp(name, "True") == 0 &&
ppd->variable_sizes)
{
if (!ppd->variable_sizes)
{
ppd->variable_sizes = 1;
/*
* Add a "Custom" page size entry...
*/
ppd_add_size(ppd, "Custom");
/*
* Add a "Custom" page size option...
*/
if ((option = ppdFindOption(ppd, "PageSize")) == NULL)
{
ppd_group_t *temp;
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 ((choice = ppd_add_choice(option, "Custom")) == NULL)
{
DEBUG_puts("Unable to add Custom choice!");
ppdClose(ppd);
safe_free(string);
return (NULL);
}
strncpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE),
sizeof(choice->text) - 1);
option = NULL;
}
if ((option = ppdFindOption(ppd, "PageSize")) == NULL)
{
DEBUG_puts("Unable to find PageSize option!");
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
if ((choice = ppdFindChoice(option, "Custom")) == NULL)
{
DEBUG_puts("Unable to find Custom choice!");
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -900,7 +813,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (group == NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -913,7 +826,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (option == NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -930,28 +843,19 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (text[0])
{
strncpy(option->text, text, sizeof(option->text) - 1);
strcpy(option->text, text);
ppd_fix(option->text);
}
else
{
if (strcmp(name, "PageSize") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_SIZE),
sizeof(option->text) - 1);
strcpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_SIZE));
else if (strcmp(name, "MediaType") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_TYPE),
sizeof(option->text) - 1);
strcpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_TYPE));
else if (strcmp(name, "InputSlot") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_SOURCE),
sizeof(option->text) - 1);
else if (strcmp(name, "ColorModel") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_OUTPUT_MODE),
sizeof(option->text) - 1);
else if (strcmp(name, "Resolution") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_RESOLUTION),
sizeof(option->text) - 1);
strcpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_SOURCE));
else
strncpy(option->text, name, sizeof(option->text) - 1);
strcpy(option->text, name);
}
option->section = PPD_ORDER_ANY;
@@ -967,7 +871,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (group == NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -983,7 +887,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (option == NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -998,7 +902,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
else
option->ui = PPD_UI_PICKONE;
strncpy(option->text, text, sizeof(option->text) - 1);
strcpy(option->text, text);
option->section = PPD_ORDER_JCL;
group = NULL;
@@ -1015,7 +919,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (group != NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -1028,13 +932,50 @@ 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);
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);
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);
strcpy(subgroup->text, string);
}
else if (strcmp(keyword, "CloseSubGroup") == 0)
subgroup = NULL;
else if (strcmp(keyword, "OrderDependency") == 0 ||
strcmp(keyword, "NonUIOrderDependency") == 0)
{
if (sscanf(string, "%f%40s%40s", &order, name, keyword) != 3)
if (sscanf(string, "%f%s%s", &order, name, keyword) != 3)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -1056,25 +997,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
{
@@ -1092,28 +1032,26 @@ 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);
strcpy(group->options[i].defchoice, string);
break;
}
group = NULL;
}
else
strncpy(option->defchoice, string, sizeof(option->defchoice) - 1);
strcpy(option->defchoice, string);
}
else if (strcmp(keyword, "UIConstraints") == 0 ||
strcmp(keyword, "NonUIConstraints") == 0)
@@ -1127,7 +1065,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (constraint == NULL)
{
ppdClose(ppd);
safe_free(string);
free(string);
return (NULL);
}
@@ -1135,14 +1073,14 @@ ppdOpen(FILE *fp) /* I - File to read from */
constraint += ppd->num_consts;
ppd->num_consts ++;
switch (sscanf(string, "%40s%40s%40s%40s", constraint->option1,
switch (sscanf(string, "%s%s%s%s", constraint->option1,
constraint->choice1, constraint->option2,
constraint->choice2))
{
case 0 : /* Error */
case 1 : /* Error */
ppdClose(ppd);
safe_free(string);
free(string);
break;
case 2 : /* Two options... */
@@ -1201,8 +1139,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)
{
/*
@@ -1220,7 +1156,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (mask & PPD_TEXT)
{
strncpy(choice->text, text, sizeof(choice->text) - 1);
strcpy(choice->text, text);
ppd_fix(choice->text);
}
else if (strcmp(name, "True") == 0)
@@ -1228,7 +1164,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
else if (strcmp(name, "False") == 0)
strcpy(choice->text, "No");
else
strncpy(choice->text, name, sizeof(choice->text) - 1);
strcpy(choice->text, name);
if (strncmp(keyword, "JCL", 3) == 0)
ppd_decode(string); /* Decode quoted string */
@@ -1237,7 +1173,8 @@ ppdOpen(FILE *fp) /* I - File to read from */
string = NULL; /* Don't free this string below */
}
safe_free(string);
if (string != NULL)
free(string);
}
#ifdef DEBUG
@@ -1325,7 +1262,7 @@ ppdOpenFd(int fd) /* I - File to read from */
ppd = ppdOpen(fp);
safe_free(fp);
free(fp);
}
else
ppd = NULL;
@@ -1339,7 +1276,7 @@ ppdOpenFd(int fd) /* I - File to read from */
*/
ppd_file_t * /* O - PPD file record */
ppdOpenFile(const char *filename) /* I - File to read from */
ppdOpenFile(char *filename) /* I - File to read from */
{
FILE *fp; /* File pointer */
ppd_file_t *ppd; /* PPD file record */
@@ -1413,11 +1350,7 @@ compare_strings(char *s, /* I - First string */
* Bounce out if *s and *t aren't both digits...
*/
if (isdigit(*s) && !isdigit(*t))
return (1);
else if (!isdigit(*s) && isdigit(*t))
return (-1);
else if (!isdigit(*s) || !isdigit(*t))
if (!isdigit(*s) || !isdigit(*t))
continue;
if (*s < *t)
@@ -1534,7 +1467,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) */
/*
@@ -1549,8 +1482,6 @@ ppd_read(FILE *fp, /* I - File to read from */
* Now loop until we have a valid line...
*/
*string = NULL;
do
{
/*
@@ -1584,12 +1515,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
{
@@ -1604,46 +1533,6 @@ ppd_read(FILE *fp, /* I - File to read from */
}
}
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 --;
+13 -18
Ver Arquivo
@@ -4,7 +4,7 @@
* PostScript Printer Description definitions 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
@@ -153,7 +153,6 @@ typedef struct /**** sRGB Color Profiles ****/
char resolution[41], /* Resolution or "-" */
media_type[41]; /* Media type of "-" */
float density, /* Ink density to use */
gamma, /* Gamma correction to use */
matrix[3][3]; /* Transform matrix */
} ppd_profile_t;
@@ -166,8 +165,7 @@ typedef struct /**** Files ****/
contone_only, /* 1 = continuous tone only, 0 = not */
landscape, /* -90 or 90 */
model_number, /* Device-specific model number */
manual_copies, /* 1 = Copies done manually, 0 = hardware */
throughput; /* Pages per minute */
manual_copies; /* 1 = Copies done manually, 0 = hardware */
ppd_cs_t colorspace; /* Default colorspace */
char *patches; /* Patch commands to be sent to printer */
int num_emulations; /* Number of emulations supported */
@@ -198,7 +196,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,27 +204,25 @@ 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);
extern int ppdEmitFd(ppd_file_t *ppd, int fd,
ppd_section_t section);
extern int ppdIsMarked(ppd_file_t *ppd, const char *keyword,
const char *option);
extern int ppdIsMarked(ppd_file_t *ppd, char *keyword,
char *option);
extern void ppdMarkDefaults(ppd_file_t *ppd);
extern int ppdMarkOption(ppd_file_t *ppd, const char *keyword,
const char *option);
extern ppd_choice_t *ppdFindChoice(ppd_option_t *o, const char *option);
extern ppd_choice_t *ppdFindMarkedChoice(ppd_file_t *ppd, const char *keyword);
extern ppd_option_t *ppdFindOption(ppd_file_t *ppd, const char *keyword);
extern int ppdMarkOption(ppd_file_t *ppd, char *keyword,
char *option);
extern ppd_choice_t *ppdFindChoice(ppd_option_t *o, char *option);
extern ppd_choice_t *ppdFindMarkedChoice(ppd_file_t *ppd, char *keyword);
extern ppd_option_t *ppdFindOption(ppd_file_t *ppd, char *keyword);
extern ppd_file_t *ppdOpen(FILE *fp);
extern ppd_file_t *ppdOpenFd(int fd);
extern ppd_file_t *ppdOpenFile(const char *filename);
extern float ppdPageLength(ppd_file_t *ppd, const char *name);
extern ppd_size_t *ppdPageSize(ppd_file_t *ppd, const char *name);
extern float ppdPageWidth(ppd_file_t *ppd, const char *name);
extern ppd_file_t *ppdOpenFile(char *filename);
extern float ppdPageLength(ppd_file_t *ppd, char *name);
extern ppd_size_t *ppdPageSize(ppd_file_t *ppd, char *name);
extern float ppdPageWidth(ppd_file_t *ppd, char *name);
/*
* C++ magic...
+1 -1
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Raster file 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
+1 -1
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Raster file definitions 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
-287
Ver Arquivo
@@ -1,287 +0,0 @@
/*
* "$Id$"
*
* snprintf functions 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:
*
* vsnprintf() - Format a string into a fixed size buffer.
* snprintf() - Format a string into a fixed size buffer.
*/
/*
* Include necessary headers...
*/
#include <stdio.h>
#include <ctype.h>
#include "string.h"
#ifndef HAVE_VSNPRINTF
/*
* 'vsnprintf()' - Format a string into a fixed size buffer.
*/
int /* O - Number of bytes formatted */
vsnprintf(char *buffer, /* O - Output buffer */
size_t bufsize, /* O - Size of output buffer */
const char *format, /* I - printf-style format string */
va_list ap) /* I - Pointer to additional arguments */
{
char *bufptr, /* Pointer to position in buffer */
*bufend, /* Pointer to end of buffer */
sign, /* Sign of format width */
size, /* Size character (h, l, L) */
type; /* Format type character */
const char *bufformat; /* Start of format */
int width, /* Width of field */
prec; /* Number of characters of precision */
char tformat[100], /* Temporary format string for sprintf() */
temp[1024]; /* Buffer for formatted numbers */
int *chars; /* Pointer to integer for %p */
char *s; /* Pointer to string */
int slen; /* Length of string */
/*
* Loop through the format string, formatting as needed...
*/
bufptr = buffer;
bufend = buffer + bufsize - 1;
while (*format && bufptr < bufend)
{
if (*format == '%')
{
bufformat = format;
format ++;
if (*format == '%')
{
*bufptr++ = *format++;
continue;
}
else if (strchr(" -+#\'", *format))
sign = *format++;
else
sign = 0;
width = 0;
while (isdigit(*format))
width = width * 10 + *format++ - '0';
if (*format == '.')
{
format ++;
prec = 0;
while (isdigit(*format))
prec = prec * 10 + *format++ - '0';
}
else
prec = -1;
if (*format == 'l' && format[1] == 'l')
{
size = 'L';
format += 2;
}
else if (*format == 'h' || *format == 'l' || *format == 'L')
size = *format++;
if (!*format)
break;
type = *format++;
switch (type)
{
case 'E' : /* Floating point formats */
case 'G' :
case 'e' :
case 'f' :
case 'g' :
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, double));
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
break;
case 'B' : /* Integer formats */
case 'X' :
case 'b' :
case 'd' :
case 'i' :
case 'o' :
case 'u' :
case 'x' :
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, int));
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
break;
case 'p' : /* Pointer value */
if ((chars = va_arg(ap, int *)) != NULL)
*chars = bufptr - buffer;
break;
case 'c' : /* Character or character array */
if (width <= 1)
*bufptr++ = va_arg(ap, int);
else
{
if ((bufptr + width) > bufend)
width = bufend - bufptr;
memcpy(bufptr, va_arg(ap, char *), width);
bufptr += width;
}
break;
case 's' : /* String */
if ((s = va_arg(ap, char *)) == NULL)
s = "(null)";
slen = strlen(s);
if (slen > width && prec != width)
width = slen;
if ((bufptr + width) > bufend)
width = bufend - bufptr;
if (slen > width)
slen = width;
if (sign == '-')
{
strncpy(bufptr, s, slen);
memset(bufptr + slen, ' ', width - slen);
}
else
{
memset(bufptr, ' ', width - slen);
strncpy(bufptr + width - slen, s, slen);
}
bufptr += width;
break;
case 'n' : /* Output number of chars so far */
if ((format - bufformat + 1) > sizeof(tformat) ||
(width + 2) > sizeof(temp))
break;
strncpy(tformat, bufformat, format - bufformat);
tformat[format - bufformat] = '\0';
sprintf(temp, tformat, va_arg(ap, int));
if ((bufptr + strlen(temp)) > bufend)
{
strncpy(bufptr, temp, bufend - bufptr);
bufptr = bufend;
break;
}
else
{
strcpy(bufptr, temp);
bufptr += strlen(temp);
}
break;
}
}
else
*bufptr++ = *format++;
}
/*
* Nul-terminate the string and return the number of characters in it.
*/
*bufptr = '\0';
return (bufptr - buffer);
}
#endif /* !HAVE_VSNPRINT */
#ifndef HAVE_SNPRINTF
/*
* 'snprintf()' - Format a string into a fixed size buffer.
*/
int /* O - Number of bytes formatted */
snprintf(char *buffer, /* O - Output buffer */
size_t bufsize, /* O - Size of output buffer */
const char *format, /* I - printf-style format string */
...) /* I - Additional arguments as needed */
{
int bytes; /* Number of bytes formatted */
va_list ap; /* Pointer to additional arguments */
va_start(ap, format);
bytes = vsnprintf(buffer, bufsize, format, ap);
va_end(ap);
return (bytes);
}
#endif /* !HAVE_SNPRINTF */
/*
* End of "$Id$".
*/
+1 -1
Ver Arquivo
@@ -3,7 +3,7 @@
*
* String functions 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
+1 -29
Ver Arquivo
@@ -3,7 +3,7 @@
*
* String definitions 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
@@ -29,8 +29,6 @@
* Include necessary headers...
*/
# include <stdio.h>
# include <stdarg.h>
# include <config.h>
# include <string.h>
@@ -45,15 +43,6 @@
# endif /* WIN32 || __EMX__ */
/*
* C++ magic...
*/
# ifdef __cplusplus
extern "C" {
# endif /* __cplusplus */
/*
* Prototypes...
*/
@@ -70,23 +59,6 @@ extern int strcasecmp(const char *, const char *);
extern int strncasecmp(const char *, const char *, size_t n);
# endif /* !HAVE_STRNCASECMP */
# ifndef HAVE_SNPRINTF
extern int snprintf(char *, size_t, const char *, ...);
# endif /* !HAVE_SNPRINTF */
# ifndef HAVE_VSNPRINTF
extern int vsnprintf(char *, size_t, const char *, va_list);
# endif /* !HAVE_VSNPRINTF */
/*
* C++ magic...
*/
# ifdef __cplusplus
}
# endif /* __cplusplus */
#endif /* !_CUPS_STRING_H_ */
/*
+3 -3
Ver Arquivo
@@ -3,7 +3,7 @@
*
* HTTP test program 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
@@ -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));
}
}
+2 -2
Ver Arquivo
@@ -3,7 +3,7 @@
*
* MIME test program 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
@@ -104,7 +104,7 @@ main(int argc, /* I - Number of command-line args */
case 3 :
src = mimeFileType(mime, argv[1]);
sscanf(argv[2], "%15[^/]/%31s", super, type);
sscanf(argv[2], "%[^/]/%s", super, type);
dst = mimeType(mime, super, type);
filters = mimeFilter(mime, src, dst, &num_filters);
+1 -1
Ver Arquivo
@@ -66,7 +66,7 @@ LINK32=link.exe
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I ".." /I "../visualc" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
+3 -7
Ver Arquivo
@@ -3,7 +3,7 @@
*
* PPD test program 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
@@ -44,8 +44,8 @@ int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
int i, j, k, m; /* Looping vars */
const char *filename; /* File to load */
int i, j, k, m, n; /* Looping vars */
char *filename; /* File to load */
ppd_file_t *ppd; /* PPD file record */
ppd_size_t *size; /* Size record */
ppd_group_t *group; /* UI group */
@@ -171,10 +171,6 @@ main(int argc, /* I - Number of command-line arguments */
}
}
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);
}
+1 -1
Ver Arquivo
@@ -66,7 +66,7 @@ LINK32=link.exe
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I ".." /I "../visualc" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /I ".." /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
+41 -95
Ver Arquivo
@@ -3,7 +3,7 @@
*
* MIME typing routines 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
@@ -41,7 +41,7 @@
#include <ctype.h>
#include <locale.h>
#include <cups/string.h>
#include "string.h"
#include "mime.h"
@@ -50,8 +50,8 @@
*/
static int compare(mime_type_t **, mime_type_t **);
static int checkrules(const char *, FILE *, mime_magic_t *);
static int patmatch(const char *, const char *);
static int checkrules(char *, FILE *, mime_magic_t *);
static int patmatch(char *, char *);
/*
@@ -59,9 +59,9 @@ static int patmatch(const char *, const char *);
*/
mime_type_t * /* O - New (or existing) MIME type */
mimeAddType(mime_t *mime, /* I - MIME database */
const char *super, /* I - Super-type name */
const char *type) /* I - Type name */
mimeAddType(mime_t *mime, /* I - MIME database */
char *super, /* I - Super-type name */
char *type) /* I - Type name */
{
mime_type_t *temp, /* New MIME type */
**types; /* New MIME types array */
@@ -108,8 +108,8 @@ mimeAddType(mime_t *mime, /* I - MIME database */
mime->num_types ++;
*types = temp;
strncpy(temp->super, super, sizeof(temp->super) - 1);
strncpy(temp->type, type, sizeof(temp->type) - 1);
strcpy(temp->super, super);
strcpy(temp->type, type);
if (mime->num_types > 1)
qsort(mime->types, mime->num_types, sizeof(mime_type_t *),
@@ -125,17 +125,17 @@ mimeAddType(mime_t *mime, /* I - MIME database */
int /* O - 0 on success, -1 on failure */
mimeAddTypeRule(mime_type_t *mt, /* I - Type to add to */
const char *rule) /* I - Rule to add */
char *rule) /* I - Rule to add */
{
int num_values, /* Number of values seen */
op, /* Operation code */
logic, /* Logic for next rule */
invert; /* Invert following rule? */
char name[255], /* Name in rule string */
value[3][255], /* Value in rule string */
value[2][255], /* Value in rule string */
*ptr, /* Position in name or value */
quote; /* Quote character */
int length[3]; /* Length of each parameter */
int length[2]; /* Length of each parameter */
mime_magic_t *temp, /* New rule */
*current; /* Current rule */
@@ -383,8 +383,6 @@ mimeAddTypeRule(mime_type_t *mt, /* I - Type to add to */
op = MIME_MAGIC_INT;
else if (strcmp(name, "locale") == 0)
op = MIME_MAGIC_LOCALE;
else if (strcmp(name, "contains") == 0)
op = MIME_MAGIC_CONTAINS;
else
return (-1);
}
@@ -394,7 +392,7 @@ mimeAddTypeRule(mime_type_t *mt, /* I - Type to add to */
* This is just a filename match on the extension...
*/
snprintf(value[0], sizeof(value[0]), "*.%s", name);
sprintf(value[0], "*.%s", name);
length[0] = strlen(value[0]);
num_values = 1;
op = MIME_MAGIC_MATCH;
@@ -452,32 +450,32 @@ mimeAddTypeRule(mime_type_t *mt, /* I - Type to add to */
break;
case MIME_MAGIC_ASCII :
case MIME_MAGIC_PRINTABLE :
temp->offset = strtol(value[0], NULL, 0);
temp->length = strtol(value[1], NULL, 0);
temp->offset = atoi(value[0]);
temp->length = atoi(value[1]);
if (temp->length > MIME_MAX_BUFFER)
temp->length = MIME_MAX_BUFFER;
break;
case MIME_MAGIC_STRING :
temp->offset = strtol(value[0], NULL, 0);
temp->offset = atoi(value[0]);
if (length[1] > sizeof(temp->value.stringv))
return (-1);
temp->length = length[1];
memcpy(temp->value.stringv, value[1], length[1]);
break;
case MIME_MAGIC_CHAR :
temp->offset = strtol(value[0], NULL, 0);
temp->offset = atoi(value[0]);
if (length[1] == 1)
temp->value.charv = value[1][0];
else
temp->value.charv = strtol(value[1], NULL, 0);
temp->value.charv = atoi(value[1]);
break;
case MIME_MAGIC_SHORT :
temp->offset = strtol(value[0], NULL, 0);
temp->value.shortv = strtol(value[1], NULL, 0);
temp->offset = atoi(value[0]);
temp->value.shortv = atoi(value[1]);
break;
case MIME_MAGIC_INT :
temp->offset = strtol(value[0], NULL, 0);
temp->value.intv = strtol(value[1], NULL, 0);
temp->offset = atoi(value[0]);
temp->value.intv = atoi(value[1]);
break;
case MIME_MAGIC_LOCALE :
if (length[0] > (sizeof(temp->value.localev) - 1))
@@ -485,14 +483,6 @@ mimeAddTypeRule(mime_type_t *mt, /* I - Type to add to */
strcpy(temp->value.localev, value[0]);
break;
case MIME_MAGIC_CONTAINS :
temp->offset = strtol(value[0], NULL, 0);
temp->region = strtol(value[1], NULL, 0);
if (length[2] > sizeof(temp->value.stringv))
return (-1);
temp->length = length[2];
memcpy(temp->value.stringv, value[2], length[2]);
break;
}
}
else
@@ -507,14 +497,14 @@ mimeAddTypeRule(mime_type_t *mt, /* I - Type to add to */
* 'mimeFileType()' - Determine the type of a file.
*/
mime_type_t * /* O - Type of file */
mimeFileType(mime_t *mime, /* I - MIME database */
const char *pathname) /* I - Name of file to check */
mime_type_t * /* O - Type of file */
mimeFileType(mime_t *mime, /* I - MIME database */
char *pathname) /* I - Name of file to check */
{
int i; /* Looping var */
FILE *fp; /* File pointer */
mime_type_t **types; /* File types */
const char *filename; /* Base filename of file */
char *filename; /* Base filename of file */
/*
@@ -566,9 +556,9 @@ mimeFileType(mime_t *mime, /* I - MIME database */
*/
mime_type_t * /* O - Matching file type definition */
mimeType(mime_t *mime, /* I - MIME database */
const char *super, /* I - Super-type name */
const char *type) /* I - Type name */
mimeType(mime_t *mime, /* I - MIME database */
char *super, /* I - Super-type name */
char *type) /* I - Type name */
{
mime_type_t key, /* MIME type search key*/
*keyptr, /* Key pointer... */
@@ -592,11 +582,8 @@ mimeType(mime_t *mime, /* I - MIME database */
* Lookup the type in the array...
*/
strncpy(key.super, super, sizeof(key.super) - 1);
key.super[sizeof(key.super) - 1] = '\0';
strncpy(key.type, type, sizeof(key.type) - 1);
key.type[sizeof(key.type) - 1] = '\0';
strcpy(key.super, super);
strcpy(key.type, type);
keyptr = &key;
match = (mime_type_t **)bsearch(&keyptr, mime->types, mime->num_types,
@@ -633,12 +620,11 @@ compare(mime_type_t **t0, /* I - First type */
*/
static int /* O - 1 if match, 0 if no match */
checkrules(const char *filename, /* I - Filename */
checkrules(char *filename, /* I - Filename */
FILE *fp, /* I - File to check */
mime_magic_t *rules) /* I - Rules to check */
{
int n; /* Looping var */
int region; /* Region to look at */
int logic, /* Logic to apply */
result, /* Result of test */
intv; /* Integer value */
@@ -658,8 +644,6 @@ checkrules(const char *filename, /* I - Filename */
logic = rules->parent->op;
bufoffset = -1;
buflength = 0;
result = 0;
while (rules != NULL)
{
@@ -702,8 +686,8 @@ checkrules(const char *filename, /* I - Filename */
bufptr = buffer + rules->offset - bufoffset;
while (n > 0)
if ((*bufptr >= 32 && *bufptr <= 126) ||
(*bufptr >= 8 && *bufptr <= 13) ||
*bufptr == 26 || *bufptr == 27)
(*bufptr >= 8 && *bufptr <= 10) ||
*bufptr == 13 || *bufptr == 26)
{
n --;
bufptr ++;
@@ -732,7 +716,7 @@ checkrules(const char *filename, /* I - Filename */
}
/*
* Test for 8-bit printable characters plus standard control chars.
* Test for ASCII printable characters plus standard control chars.
*/
if ((rules->offset + rules->length) > (bufoffset + buflength))
@@ -743,10 +727,10 @@ checkrules(const char *filename, /* I - Filename */
bufptr = buffer + rules->offset - bufoffset;
while (n > 0)
if (*bufptr >= 128 ||
if ((*bufptr >= 160 && *bufptr <= 254) ||
(*bufptr >= 32 && *bufptr <= 126) ||
(*bufptr >= 8 && *bufptr <= 13) ||
*bufptr == 26 || *bufptr == 27)
(*bufptr >= 8 && *bufptr <= 10) ||
*bufptr == 13 || *bufptr == 26)
{
n --;
bufptr ++;
@@ -882,44 +866,6 @@ checkrules(const char *filename, /* I - Filename */
result = (strcmp(rules->value.localev, setlocale(LC_ALL, NULL)) == 0);
break;
case MIME_MAGIC_CONTAINS :
/*
* Load the buffer if necessary...
*/
if (bufoffset < 0 || rules->offset < bufoffset ||
(rules->offset + rules->region) > (bufoffset + buflength))
{
/*
* Reload file buffer...
*/
fseek(fp, rules->offset, SEEK_SET);
buflength = fread(buffer, 1, sizeof(buffer), fp);
bufoffset = rules->offset;
}
/*
* Compare the buffer against the string. If the file is too
* short then don't compare - it can't match...
*/
if ((rules->offset + rules->length) > (bufoffset + buflength))
result = 0;
else
{
if (buflength > rules->region)
region = rules->region - rules->length;
else
region = buflength - rules->length;
for (n = 0; n < region; n ++)
if ((result = (memcmp(buffer + rules->offset - bufoffset + n,
rules->value.stringv, rules->length) == 0)) != 0)
break;
}
break;
default :
if (rules->child != NULL)
result = checkrules(filename, fp, rules->child);
@@ -960,9 +906,9 @@ checkrules(const char *filename, /* I - Filename */
* 'patmatch()' - Pattern matching...
*/
static int /* O - 1 if match, 0 if no match */
patmatch(const char *s, /* I - String to match against */
const char *pat) /* I - Pattern to match against */
static int /* O - 1 if match, 0 if no match */
patmatch(char *s, /* I - String to match against */
char *pat) /* I - Pattern to match against */
{
/*
* Range check the input...
+82 -205
Ver Arquivo
@@ -4,7 +4,7 @@
* User, system, and password 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
@@ -24,13 +24,6 @@
*
* Contents:
*
* cupsGetPassword() - Get a password from the user...
* cupsServer() - Return the hostname of the default server...
* 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...
*/
/*
@@ -38,173 +31,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 char cups_user[65] = "",
cups_server[256] = "";
static const char *(*cups_pwdcb)(const char *) = cups_get_password;
/*
* 'cupsGetPassword()' - Get a password from the user...
*/
const char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return ((*cups_pwdcb)(prompt));
}
/*
* '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...
@@ -214,22 +45,19 @@ cupsSetUser(const char *user) /* I - User name */
* 'cupsUser()' - Return the current user's name.
*/
const char * /* O - User name */
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 */
char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return (NULL);
}
@@ -244,55 +72,104 @@ cups_get_password(const char *prompt) /* I - Prompt string */
* 'cupsUser()' - Return the current user's name.
*/
const char * /* O - User name */
char * /* O - User name */
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
{
/*
* Rewind the password file again and 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();
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 */
char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return (getpass(prompt));
}
#endif /* WIN32 || __EMX__ */
/*
* 'cupsServer()' - Return the hostname of the default server...
*/
char * /* O - Server name */
cupsServer(void)
{
FILE *fp; /* cupsd.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 cupsd.conf file...
*/
if ((fp = fopen(CUPS_SERVERROOT "/conf/cupsd.conf", "r")) == NULL)
return ("localhost");
/*
* Read the cupsd.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)
return (server);
}
/*
* Didn't see a ServerName line, so return "localhost"...
*/
fclose(fp);
return ("localhost");
}
/*
* End of "$Id$".
*/
+257 -745
Ver Arquivo
Diferenças do arquivo suprimidas por serem muito extensas Carregar Diff
+29 -4
Ver Arquivo
@@ -1,6 +1,6 @@
%%BeginResource: procset hpgltops 1.1 0
%%BeginResource: procset hpgltops 1.0 0
%
% "$Id: HPGLprolog 932 2000-02-26 20:01:37Z mike $"
% "$Id: HPGLprolog 312 1999-05-11 19:45:40Z mike $"
%
% HP-GL/2 filter procset for the Common UNIX Printing System (CUPS).
%
@@ -9,7 +9,7 @@
% should be called 'NP' (newpath), but GhostScript uses the 'NP' name
% for 'noaccess put' in some of its font files...
%
% Copyright 1993-2000 Easy Software Products
% Copyright 1993-1999 Easy Software Products
%
% These coded instructions, statements, and computer programs are the
% property of Easy Software Products and are protected by Federal
@@ -33,5 +33,30 @@
/ST { stroke } bind def
/CP { closepath } bind def
/MP { newpath } bind def
/SP { setlinewidth setrgbcolor } bind def
%
% If you have more than 8 pens defined for your HP-GL/2 output you'll
% need to add P# definitions (# = pen number) to set the appropriate color.
% If you don't you'll get errors. The default 8 pens cover the primary
% colors (white, black, red, green, yellow, blue, magenta, cyan). Ditto
% for pen widths (W#).
%
% PC and PW commands in the input stream will define/redefine these
% appropriately, but some packages don't generate them...
%
/P0 { 1.0 1.0 1.0 setrgbcolor } bind def
/P1 { 0.0 0.0 0.0 setrgbcolor } bind def
/P2 { 1.0 0.0 0.0 setrgbcolor } bind def
/P3 { 0.0 1.0 0.0 setrgbcolor } bind def
/P4 { 1.0 1.0 0.0 setrgbcolor } bind def
/P5 { 0.0 0.0 1.0 setrgbcolor } bind def
/P6 { 1.0 0.0 1.0 setrgbcolor } bind def
/P7 { 0.0 1.0 1.0 setrgbcolor } bind def
/W0 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W1 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W2 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W3 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W4 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W5 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W6 { DefaultPenWidth PenScaling mul setlinewidth } bind def
/W7 { DefaultPenWidth PenScaling mul setlinewidth } bind def
%%EndResource
+5 -56
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Datafile makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1993-2000 by Easy Software Products.
# Copyright 1993-1999 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -28,39 +28,8 @@ 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 \
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 \
iso-8859-13 \
iso-8859-14 \
iso-8859-15 \
utf-8
DATAFILES = HPGLprolog psglyphs testprint.ps
FILES = 8859-1 8859-14 8859-15 8859-2 8859-3 8859-4 8859-5 \
8859-6 8859-7 8859-8 8859-9 HPGLprolog
#
# Make everything...
@@ -68,39 +37,19 @@ DATAFILES = HPGLprolog psglyphs testprint.ps
all:
#
# Clean all config and object files...
#
clean:
#
# Install files...
#
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)/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
-$(MKDIR) $(DATADIR)
$(CP) $(FILES) $(DATADIR)
#
# End of "$Id$".
-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
-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
-251
Ver Arquivo
@@ -1,251 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-1
# (Latin1/West European) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9F 0178
A0 00A0
A1 00A1
A2 00A2
A3 00A3
A4 00A4
A5 00A5
A6 00A6
A7 00A7
A8 00A8
A9 00A9
AA 00AA
AB 00AB
AC 00AC
AD 00AD
AE 00AE
AF 00AF
B0 00B0
B1 00B1
B2 00B2
B3 00B3
B4 00B4
B5 00B5
B6 00B6
B7 00B7
B8 00B8
B9 00B9
BA 00BA
BB 00BB
BC 00BC
BD 00BD
BE 00BE
BF 00BF
C0 00C0
C1 00C1
C2 00C2
C3 00C3
C4 00C4
C5 00C5
C6 00C6
C7 00C7
C8 00C8
C9 00C9
CA 00CA
CB 00CB
CC 00CC
CD 00CD
CE 00CE
CF 00CF
D0 00D0
D1 00D1
D2 00D2
D3 00D3
D4 00D4
D5 00D5
D6 00D6
D7 00D7
D8 00D8
D9 00D9
DA 00DA
DB 00DB
DC 00DC
DD 00DD
DE 00DE
DF 00DF
E0 00E0
E1 00E1
E2 00E2
E3 00E3
E4 00E4
E5 00E5
E6 00E6
E7 00E7
E8 00E8
E9 00E9
EA 00EA
EB 00EB
EC 00EC
ED 00ED
EE 00EE
EF 00EF
F0 00F0
F1 00F1
F2 00F2
F3 00F3
F4 00F4
F5 00F5
F6 00F6
F7 00F7
F8 00F8
F9 00F9
FA 00FA
FB 00FB
FC 00FC
FD 00FD
FE 00FE
FF 00FF
-251
Ver Arquivo
@@ -1,251 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-10
# (Latin6/Nordic) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9F 0178
A0 00A0
A1 0104
A2 0112
A3 0122
A4 012A
A5 0128
A6 0136
A7 00A7
A8 013B
A9 0110
AA 0160
AB 0166
AC 017D
AD 00AD
AE 016A
AF 014A
B0 00B0
B1 0105
B2 0113
B3 0123
B4 012B
B5 0129
B6 0137
B7 00B7
B8 013C
B9 0111
BA 0161
BB 0167
BC 017E
BD 2015
BE 016B
BF 014B
C0 0100
C1 00C1
C2 00C2
C3 00C3
C4 00C4
C5 00C5
C6 00C6
C7 012E
C8 010C
C9 00C9
CA 0118
CB 00CB
CC 0116
CD 00CD
CE 00CE
CF 00CF
D0 0110
D1 0145
D2 014C
D3 00D3
D4 00D4
D5 00D5
D6 00D6
D7 0168
D8 00D8
D9 0172
DA 00DA
DB 00DB
DC 00DC
DD 00DD
DE 00DE
DF 00DF
E0 0101
E1 00E1
E2 00E2
E3 00E3
E4 00E4
E5 00E5
E6 00E6
E7 012F
E8 010D
E9 00E9
EA 0119
EB 00EB
EC 0117
ED 00ED
EE 00EE
EF 00EF
F0 00F0
F1 0146
F2 014D
F3 00F3
F4 00F4
F5 00F5
F6 00F6
F7 0169
F8 00F8
F9 0173
FA 00FA
FB 00FB
FC 00FC
FD 00FD
FE 00FD
FF 0138
-251
Ver Arquivo
@@ -1,251 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-13
# (Latin7/Baltic Rim) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9F 0178
A0 00A0
A1 201D
A2 00A2
A3 00A3
A4 00A4
A5 201E
A6 00A6
A7 00A7
A8 00D8
A9 00A9
AA 0156
AB 00AB
AC 00AC
AD 00AD
AE 00AE
AF 00C6
B0 00B0
B1 00B1
B2 00B2
B3 00B3
B4 201C
B5 00B5
B6 00B6
B7 00B7
B8 00F8
B9 00B9
BA 0157
BB 00BB
BC 00BC
BD 00BD
BE 00BE
BF 00E6
C0 0104
C1 012E
C2 0100
C3 0106
C4 00C4
C5 00C5
C6 0118
C7 0112
C8 010C
C9 00C9
CA 0179
CB 0116
CC 0122
CD 0136
CE 012A
CF 013B
D0 0160
D1 0143
D2 0145
D3 00D3
D4 014C
D5 00D5
D6 00D6
D7 00D7
D8 0172
D9 0141
DA 015A
DB 016A
DC 00DC
DD 017B
DE 017D
DF 00DF
E0 0105
E1 012F
E2 0101
E3 0107
E4 00E4
E5 00E5
E6 0119
E7 0113
E8 010D
E9 00E9
EA 017A
EB 0117
EC 0123
ED 0137
EE 012B
EF 013C
F0 0161
F1 0144
F2 0146
F3 00F3
F4 014D
F5 00F5
F6 00F6
F7 00F7
F8 0173
F9 0142
FA 015B
FB 016B
FC 00FC
FD 017C
FE 017E
FF 2019
-251
Ver Arquivo
@@ -1,251 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-14
# (Latin8/Celtic) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9F 0178
A0 00A0
A1 1E02
A2 1E03
A3 00A3
A4 010A
A5 010B
A6 1E0A
A7 00A7
A8 1E80
A9 00A9
AA 1E82
AB 1E0B
AC 1EF2
AD 00AD
AE 00AE
AF 0178
B0 1E1E
B1 1E1F
B2 0120
B3 0121
B4 1E40
B5 1E41
B6 00B6
B7 1E56
B8 1E81
B9 1E57
BA 1E83
BB 1E60
BC 1EF3
BD 1E84
BE 1E85
BF 1E61
C0 00C0
C1 00C1
C2 00C2
C3 00C3
C4 00C4
C5 00C5
C6 00C6
C7 00C7
C8 00C8
C9 00C9
CA 00CA
CB 00CB
CC 00CC
CD 00CD
CE 00CE
CF 00CF
D0 0174
D1 00D1
D2 00D2
D3 00D3
D4 00D4
D5 00D5
D6 00D6
D7 1E6A
D8 00D8
D9 00D9
DA 00DA
DB 00DB
DC 00DC
DD 00DD
DE 0176
DF 00DF
E0 00E0
E1 00E1
E2 00E2
E3 00E3
E4 00E4
E5 00E5
E6 00E6
E7 00E7
E8 00E8
E9 00E9
EA 00EA
EB 00EB
EC 00EC
ED 00ED
EE 00EE
EF 00EF
F0 0175
F1 00F1
F2 00F2
F3 00F3
F4 00F4
F5 00F5
F6 00F6
F7 1E6B
F8 00F8
F9 00F9
FA 00FA
FB 00FB
FC 00FC
FD 00FD
FE 0177
FF 00FF
-251
Ver Arquivo
@@ -1,251 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-15
# (Latin9/West Europe + Euro) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9F 0178
A0 00A0
A1 00A1
A2 00A2
A3 00A3
A4 20AC
A5 00A5
A6 0160
A7 00A7
A8 0161
A9 00A9
AA 00AA
AB 00AB
AC 00AC
AD 00AD
AE 00AE
AF 00AF
B0 00B0
B1 00B1
B2 00B2
B3 00B3
B4 017D
B5 00B5
B6 00B6
B7 00B7
B8 017E
B9 00B9
BA 00BA
BB 00BB
BC 0152
BD 0153
BE 0178
BF 00BF
C0 00C0
C1 00C1
C2 00C2
C3 00C3
C4 00C4
C5 00C5
C6 00C6
C7 00C7
C8 00C8
C9 00C9
CA 00CA
CB 00CB
CC 00CC
CD 00CD
CE 00CE
CF 00CF
D0 00D0
D1 00D1
D2 00D2
D3 00D3
D4 00D4
D5 00D5
D6 00D6
D7 00D7
D8 00D8
D9 00D9
DA 00DA
DB 00DB
DC 00DC
DD 00DD
DE 00DE
DF 00DF
E0 00E0
E1 00E1
E2 00E2
E3 00E3
E4 00E4
E5 00E5
E6 00E6
E7 00E7
E8 00E8
E9 00E9
EA 00EA
EB 00EB
EC 00EC
ED 00ED
EE 00EE
EF 00EF
F0 00F0
F1 00F1
F2 00F2
F3 00F3
F4 00F4
F5 00F5
F6 00F6
F7 00F7
F8 00F8
F9 00F9
FA 00FA
FB 00FB
FC 00FC
FD 00FD
FE 00FE
FF 00FF
-253
Ver Arquivo
@@ -1,253 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-2
# (Latin2/East European) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
84 201E
85 2026
86 2020
87 2021
89 2030
8A 0160
8B 2039
8C 015A
8D 0164
8E 017D
8F 0179
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
99 2122
9A 0161
9B 203A
8C 015B
8D 0165
8E 017E
8F 017A
A0 00A0
A1 0104
A2 02D8
A3 0141
A4 00A4
A5 013D
A6 015A
A7 00A7
A8 00A8
A9 0160
AA 015E
AB 0164
AC 0179
AD 00AD
AE 017D
AF 017B
B0 00B0
B1 0105
B2 02DB
B3 0142
B4 00B4
B5 013E
B6 015B
B7 02C7
B8 00B8
B9 0161
BA 015F
BB 0165
BC 017A
BD 02DD
BE 017E
BF 017C
C0 0154
C1 00C1
C2 00C2
C3 0102
C4 00C4
C5 0139
C6 0106
C7 00C7
C8 010C
C9 00C9
CA 0118
CB 00CB
CC 011A
CD 00CD
CE 00CE
CF 010E
D0 0110
D1 0143
D2 0147
D3 00D3
D4 00D4
D5 0150
D6 00D6
D7 00D7
D8 0158
D9 016E
DA 00DA
DB 0170
DC 00DC
DD 00DD
DE 0162
DF 00DF
E0 0155
E1 00E1
E2 00E2
E3 0103
E4 00E4
E5 013A
E6 0107
E7 00E7
E8 010D
E9 00E9
EA 0119
EB 00EB
EC 011B
ED 00ED
EE 00EE
EF 010F
F0 0111
F1 0144
F2 0148
F3 00F3
F4 00F4
F5 0151
F6 00F6
F7 00F7
F8 0159
F9 016F
FA 00FA
FB 0171
FC 00FC
FD 00FD
FE 0163
FF 02D9
-244
Ver Arquivo
@@ -1,244 +0,0 @@
charset 8bit
#
# This file defines the font and character mappings used for ISO-8859-3
# (Latin3/South European) text printing.
#
# The first line consists of:
#
# direction width normal bold italic bold-italic
#
# Direction is the string "ltor" or "rtol", indicating left-to-right or
# right-to-left text.
#
# Width is the string "single" or "double"; double means that the glyphs
# are twice as wide as ASCII characters in the Courier typeface.
#
# "Normal", "bold", "italic", and "bold-italic" are the typefaces to use
# for each presentation. If characters are only available in a single
# style then only one typeface should be listed (e.g. "Symbol")
#
# Each font that is listed will be used (and downloaded if needed) when
# printing.
#
00 ff ltor single Courier Courier-Bold Courier-Italic Courier-BoldItalic
#
# The following lines define the mapping from the 8-bit character set to
# the Unicode glyphs for each character:
#
# char glyph
#
# "Char" and "glyph" are hexadecimal values.
#
20 0020
21 0021
22 0022
23 0023
24 0024
25 0025
26 0026
27 0027
28 0028
29 0029
2A 002A
2B 002B
2C 002C
2D 002D
2E 002E
2F 002F
30 0030
31 0031
32 0032
33 0033
34 0034
35 0035
36 0036
37 0037
38 0038
39 0039
3A 003A
3B 003B
3C 003C
3D 003D
3E 003E
3F 003F
40 0040
41 0041
42 0042
43 0043
44 0044
45 0045
46 0046
47 0047
48 0048
49 0049
4A 004A
4B 004B
4C 004C
4D 004D
4E 004E
4F 004F
50 0050
51 0051
52 0052
53 0053
54 0054
55 0055
56 0056
57 0057
58 0058
59 0059
5A 005A
5B 005B
5C 005C
5D 005D
5E 005E
5F 005F
60 0060
61 0061
62 0062
63 0063
64 0064
65 0065
66 0066
67 0067
68 0068
69 0069
6A 006A
6B 006B
6C 006C
6D 006D
6E 006E
6F 006F
70 0070
71 0071
72 0072
73 0073
74 0074
75 0075
76 0076
77 0077
78 0078
79 0079
7A 007A
7B 007B
7C 007C
7D 007D
7E 007E
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9F 0178
A0 00A0
A1 0126
A2 02D8
A3 00A3
A4 00A4
A6 0124
A7 00A7
A8 00A8
A9 0130
AA 015E
AB 011E
AC 0134
AD 00AD
AF 017B
B0 00B0
B1 0127
B2 00B2
B3 00B3
B4 00B4
B5 00B5
B6 0125
B7 00B7
B8 00B8
B9 0131
BA 015F
BB 011F
BC 0135
BD 00BD
BF 017C
C0 00C0
C1 00C1
C2 00C2
C4 00C4
C5 010A
C6 0108
C7 00C7
C8 00C8
C9 00C9
CA 00CA
CB 00CB
CC 00CC
CD 00CD
CE 00CE
CF 00CF
D1 00D1
D2 00D2
D3 00D3
D4 00D4
D5 0120
D6 00D6
D7 00D7
D8 011C
D9 00D9
DA 00DA
DB 00DB
DC 00DC
DD 016C
DE 015C
DF 00DF
E0 00E0
E1 00E1
E2 00E2
E4 00E4
E5 010B
E6 0109
E7 00E7
E8 00E8
E9 00E9
EA 00EA
EB 00EB
EC 00EC
ED 00ED
EE 00EE
EF 00EF
F1 00F1
F2 00F2
F3 00F3
F4 00F4
F5 0121
F6 00F6
F7 00F7
F8 011D
F9 00F9
FA 00FA
FB 00FB
FC 00FC
FD 016D
FE 015D
FF 02D9

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