Comparar commits

..

1 Commits

Autor SHA1 Mensagem Data
msweet 145d01c946 Import cups.org releases
git-svn-id: svn+ssh://src.apple.com/svn/cups/cups.org/tags/release-1.1b2@4306 a1ca3aef-8c08-0410-bb20-df032aa958be
2013-05-10 18:56:23 +00:00
1106 arquivos alterados com 249944 adições e 93378 exclusões
+299
Ver Arquivo
@@ -0,0 +1,299 @@
CHANGES.txt - 03/13/2000
------------------------
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
@@ -0,0 +1,26 @@
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".
+337 -220
Ver Arquivo
@@ -5,265 +5,382 @@
<BODY BGCOLOR=#ffffff>
<H1 ALIGN=CENTER><FONT FACE="Arial,HELVETICA">Aladdin Free Public License</FONT></H1>
<H2 ALIGN="CENTER">Common UNIX Printing System License Agreement</H2>
<P ALIGN=CENTER>(Version 6, June 17, 1997)</P>
<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: cups-info@cups.org<BR>
WWW: http://www.cups.org
<P ALIGN=CENTER>Copyright &copy; 1994, 1995, 1997 Aladdin Enterprises,<BR><BR>
Menlo Park, California, U.S.A. All rights reserved.</P>
<H3>Introduction</H3>
<BLOCKQUOTE>
NOTE: This License is not the same as any of the GNU Licenses published
by the Free Software Foundation. Its terms are substantially different
from those of the GNU Licenses. If you are familiar with the GNU
Licenses, please read this license with extra care.
<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>For those not familiar with the GNU General Public License, the license
basically allows you to:
<UL>
<LI>Use the CUPS software at no charge.
<LI>Distribute verbatim copies of the software in source or
binary form.
<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 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 have to provide source for any new drivers, changes, or
additions to the software, and all code must be provided under the GPL.
<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 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 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>
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: info@arsoft.com
</BLOCKQUOTE>
<P>Aladdin Enterprises hereby grants to anyone the permission to apply
this License to their own work, as long as the entire License
(including the above notices and this paragraph) is copied with no
changes, additions, or deletions except for changing the first
paragraph of Section 0 to include a suitable description of the work to
which the license is being applied and of the person or entity that
holds the copyright in the work, and, if the License is being applied
to a work created in a country other than the United States, replacing
the first paragraph of Section 6 with an appropriate reference to the
laws of the appropriate country.</P>
<H3>Support</H3>
<H2><FONT FACE="Arial,HELVETICA">0. Subject Matter</FONT></H2>
<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.
This License applies to the Common UNIX Printing System ("PROGRAM").
The Common UNIX Printing System is a copyrighted work whose copyright
is held by Easy Software Products (the "LICENSOR"). The Common UNIX
Printing System, CUPS, and the CUPS logo are the trademark property of
Easy Software Products.
<H3>Trademarks</H3>
<P>A "work based on the PROGRAM" means either the PROGRAM or any
derivative work of the PROGRAM, as defined in the United States
Copyright Act of 1976, such as a translation or a modification.
<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>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. NOTHING OTHER THAN THIS LICENSE GRANTS
YOU PERMISSION TO MODIFY OR DISTRIBUTE THE PROGRAM OR ITS DERIVATIVE
WORKS. THESE ACTIONS ARE PROHIBITED BY LAW. IF YOU DO NOT ACCEPT THESE
TERMS AND CONDITIONS, DO NOT MODIFY OR DISTRIBUTE THE PROGRAM.
<H2 ALIGN="CENTER">GNU General Public License</H2>
<H2><FONT FACE="Arial,HELVETICA">1. Licenses</FONT></H2>
<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
LICENSOR hereby grants you the following rights, provided that you comply
with all of the restrictions set forth in this License and provided,
further, that you distribute an unmodified copy of this License with the
PROGRAM:
<P ALIGN="CENTER">Everyone is permitted to copy and distribute verbatim
copies of this license document, but changing it is not allowed.
<OL TYPE=a>
<H3>Preamble</H3>
<LI>You may copy and distribute literal (i.e., verbatim) copies
of the PROGRAM's source code as you receive it throughout the
world, in any medium.<BR><BR>
<P>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.
<LI>You may modify the PROGRAM, create works based on the
PROGRAM and distribute copies of such throughout the world, in
any medium.<BR><BR>
<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 software, or if you modify it.
<P>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.
<P>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.
<P>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.
<P>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.
<P>The precise terms and conditions for copying, distribution and
modification follow.
<H3>GNU GENERAL PUBLIC LICENSE<BR>
TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION</H3>
<OL START="0">
<LI>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".
<P>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.
<LI>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.
<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.
<LI>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:
<OL TYPE="a">
<LI>You must cause the modified files to carry prominent notices
stating that you changed the files and the date of any change.
<LI>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.
<LI>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.)
</OL>
<H2><FONT FACE="Arial,HELVETICA">2. Restrictions</FONT></H2>
<P>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.
This license is subject to the following restrictions:
<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 Program.
<OL TYPE=a>
<P>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.
<LI>Distribution of the PROGRAM or any work based on the
PROGRAM by a commercial organization to any third party is
prohibited if any payment is made in connection with such
distribution, whether directly (as in payment for a copy of the
PROGRAM) or indirectly (as in payment for some service related
to the PROGRAM, or payment for some product or service that
includes a copy of the PROGRAM "without charge"; these are only
examples, and not an exhaustive enumeration of prohibited
activities). The following methods of distribution involving
payment shall not in and of themselves be a violation of this
restriction:<BR><BR>
<LI>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:
<OL TYPE=i>
<OL TYPE="a">
<LI>Posting the PROGRAM on a public access information
storage and retrieval service for which a fee is
received for retrieving information (such as an on-line
service), provided that the fee is not
content-dependent (i.e., the fee would be the same for
retrieving the same volume of information consisting of
random data) and that access to the service and to the
PROGRAM is available independent of any other product
or service. An example of a service that does not fall
under this section is an on-line service that is
operated by a company and that is only available to
customers of that company. (This is not an exhaustive
enumeration.)<BR><BR>
<LI>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,
<LI>Distributing the PROGRAM on removable
computer-readable media, provided that the files
containing the PROGRAM are reproduced entirely and
verbatim on such media, that all information on such
media be redistributable for non-commercial purposes
without charge, and that such media are distributed by
themselves (except for accompanying documentation)
independent of any other product or service. Examples
of such media include CD-ROM, magnetic tape, and
optical storage media. (This is not intended to be an
exhaustive list.) An example of a distribution that
does not fall under this section is a CD-ROM included
in a book or magazine. (This is not an exhaustive
enumeration.)<BR><BR>
<LI>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,
</OL>
<LI>Activities other than copying, distribution and
modification of the PROGRAM are not subject to this License and
they are outside its scope. Functional use (running) of the
PROGRAM is not restricted, and any output produced through the
use of the PROGRAM is subject to this license only if its
contents constitute a work based on the PROGRAM (independent of
having been made by running the PROGRAM).<BR><BR>
<LI>You must meet all of the following conditions with respect to any work
that you distribute or publish that in whole or in part contains or is
derived from the PROGRAM or any part thereof ("the Work"):<BR><BR>
<OL TYPE=i>
<LI>If you have modified the PROGRAM, you must cause
the Work to carry prominent notices stating that you
have modified the PROGRAM's files and the date of any
change;<BR><BR>
<LI>You must cause the Work to be licensed as a whole
and at no charge to all third parties under the terms
of this License;<BR><BR>
<LI>If the Work normally reads commands interactively
when run, you must cause it, at each time the Work
commences operation, 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). Such notice must also
state that users may redistribute the Work only under
the conditions of this License and tell the user how to
view the copy of this License included with the Work.
(Exceptions: if the PROGRAM is interactive but normally
prints or displays such an announcement only at the
request of a user, such as in an "About box", the Work
is required to print or display the notice only under
the same circumstances; if the PROGRAM itself is
interactive but does not normally print such an
announcement, the Work is not required to print an
announcement.);<BR><BR>
<LI>You must accompany the Work with the complete
corresponding machine-readable source code, delivered
on a medium customarily used for software interchange.
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 code. If you distribute with the Work any
component 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, you must also distribute
the source code of that component if you have it and
are allowed to do so;<BR><BR>
<LI>If you distribute any written or printed material
at all with the Work, such material must include either
a written copy of this License, or a prominent written
indication that the Work is covered by this License and
written instructions for printing and/or displaying the
copy of the License on the distribution medium;<BR><BR>
<LI>You may not impose any further restrictions on the
recipient's exercise of the rights granted herein.<BR><BR>
</OL>
<LI>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.)
</OL>
If distribution of executable or object code is made by offering the
equivalent ability to copy from a designated place, then offering
equivalent ability 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 code along with the object code.
<P>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.
<H2><FONT FACE="Arial,HELVETICA">3. Reservation of Rights</FONT></H2>
<P>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.
No rights are granted to the PROGRAM except as expressly set forth
herein. 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.
<LI>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.
<H2><FONT FACE="Arial,HELVETICA">4. Other Restrictions</FONT></H2>
<LI>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.
If the distribution and/or use of the PROGRAM is restricted in certain
countries for any reason, LICENSOR 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.
<LI>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.
<H2><FONT FACE="Arial,HELVETICA">5. Limitations</FONT></H2>
<LI>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.
THE PROGRAM IS PROVIDED TO YOU "AS IS", WITHOUT WARRANTY. THERE IS NO
WARRANTY FOR THE PROGRAM, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
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.
<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>IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL LICENSOR, 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.
<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.
<H2><FONT FACE="Arial,HELVETICA">6. General</FONT></H2>
<P>This section is intended to make thoroughly clear what is believed to
be a consequence of the rest of this License.
This License is governed by the laws of the State of Maryland, U.S.A.,
excluding choice of law rules.
<LI>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.
<P>If any part of this License is found to be in conflict with the law,
that part shall be interpreted in its broadest meaning consistent with
the law, and no other parts of the License shall be affected.
<LI>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.
<P>For United States Government users, the PROGRAM is provided with
RESTRICTED RIGHTS. If you are a unit or agency of the United States
Government or are acquiring the Software for any such unit or agency,
the following apply:
<P>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.
<BLOCKQUOTE>
If the unit or agency is the Department of Defense ("DOD"), the
Software and its documentation are classified as "commercial computer
software" and "commercial computer software documentation" respectively
and, pursuant to DFAR Section 227.7202, the Government is acquiring the
Software and its documentation in accordance with the terms of this
License. If the unit or agency is other than DOD, the Software and its
documentation are classified as "commercial computer software" and
"commercial computer software documentation" respectively and, pursuant
to FAR Section 12.212, the Government is acquiring the Software and its
documentation in accordance with the terms of this License.
</BLOCKQUOTE>
<LI>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.
</OL>
<H3>NO WARRANTY</H3>
<OL START="11">
<LI>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.
<LI>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.
</OL>
<H3>END OF TERMS AND CONDITIONS</H3>
</BODY>
</HTML>
-223
Ver Arquivo
@@ -1,223 +0,0 @@
Aladdin Free Public License
(Version 6, June 17, 1997)
Copyright © 1994, 1995, 1997 Aladdin Enterprises,
Menlo Park, California, U.S.A. All rights reserved.
NOTE: This License is not the same as any of the GNU Licenses
published by the Free Software Foundation. Its terms are
substantially different from those of the GNU Licenses. If you are
familiar with the GNU Licenses, please read this license with
extra care.
Aladdin Enterprises hereby grants to anyone the permission to apply this
License to their own work, as long as the entire License (including the
above notices and this paragraph) is copied with no changes, additions, or
deletions except for changing the first paragraph of Section 0 to include a
suitable description of the work to which the license is being applied and
of the person or entity that holds the copyright in the work, and, if the
License is being applied to a work created in a country other than the
United States, replacing the first paragraph of Section 6 with an
appropriate reference to the laws of the appropriate country.
0. Subject Matter
This License applies to the Common UNIX Printing System ("PROGRAM"). The
Common UNIX Printing System is a copyrighted work whose copyright is held by
Easy Software Products (the "LICENSOR"). The Common UNIX Printing System,
CUPS, and the CUPS logo are the trademark property of Easy Software
Products.
A "work based on the PROGRAM" means either the PROGRAM or any derivative
work of the PROGRAM, as defined in the United States Copyright Act of 1976,
such as a translation or a modification.
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. NOTHING OTHER THAN THIS LICENSE GRANTS YOU PERMISSION TO MODIFY OR
DISTRIBUTE THE PROGRAM OR ITS DERIVATIVE WORKS. THESE ACTIONS ARE PROHIBITED
BY LAW. IF YOU DO NOT ACCEPT THESE TERMS AND CONDITIONS, DO NOT MODIFY OR
DISTRIBUTE THE PROGRAM.
1. Licenses
LICENSOR hereby grants you the following rights, provided that you comply
with all of the restrictions set forth in this License and provided,
further, that you distribute an unmodified copy of this License with the
PROGRAM:
a. You may copy and distribute literal (i.e., verbatim) copies of the
PROGRAM's source code as you receive it throughout the world, in any
medium.
b. You may modify the PROGRAM, create works based on the PROGRAM and
distribute copies of such throughout the world, in any medium.
2. Restrictions
This license is subject to the following restrictions:
a. Distribution of the PROGRAM or any work based on the PROGRAM by a
commercial organization to any third party is prohibited if any payment
is made in connection with such distribution, whether directly (as in
payment for a copy of the PROGRAM) or indirectly (as in payment for
some service related to the PROGRAM, or payment for some product or
service that includes a copy of the PROGRAM "without charge"; these are
only examples, and not an exhaustive enumeration of prohibited
activities). The following methods of distribution involving payment
shall not in and of themselves be a violation of this restriction:
i. Posting the PROGRAM on a public access information storage and
retrieval service for which a fee is received for retrieving
information (such as an on-line service), provided that the fee is
not content-dependent (i.e., the fee would be the same for
retrieving the same volume of information consisting of random
data) and that access to the service and to the PROGRAM is
available independent of any other product or service. An example
of a service that does not fall under this section is an on-line
service that is operated by a company and that is only available
to customers of that company. (This is not an exhaustive
enumeration.)
ii. Distributing the PROGRAM on removable computer-readable media,
provided that the files containing the PROGRAM are reproduced
entirely and verbatim on such media, that all information on such
media be redistributable for non-commercial purposes without
charge, and that such media are distributed by themselves (except
for accompanying documentation) independent of any other product
or service. Examples of such media include CD-ROM, magnetic tape,
and optical storage media. (This is not intended to be an
exhaustive list.) An example of a distribution that does not fall
under this section is a CD-ROM included in a book or magazine.
(This is not an exhaustive enumeration.)
b. Activities other than copying, distribution and modification of the
PROGRAM are not subject to this License and they are outside its scope.
Functional use (running) of the PROGRAM is not restricted, and any
output produced through the use of the PROGRAM is subject to this
license only if its contents constitute a work based on the PROGRAM
(independent of having been made by running the PROGRAM).
c. You must meet all of the following conditions with respect to any work
that you distribute or publish that in whole or in part contains or is
derived from the PROGRAM or any part thereof ("the Work"):
i. If you have modified the PROGRAM, you must cause the Work to carry
prominent notices stating that you have modified the PROGRAM's
files and the date of any change;
ii. You must cause the Work to be licensed as a whole and at no charge
to all third parties under the terms of this License;
iii. If the Work normally reads commands interactively when run, you
must cause it, at each time the Work commences operation, 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). Such notice must also state that
users may redistribute the Work only under the conditions of this
License and tell the user how to view the copy of this License
included with the Work. (Exceptions: if the PROGRAM is interactive
but normally prints or displays such an announcement only at the
request of a user, such as in an "About box", the Work is required
to print or display the notice only under the same circumstances;
if the PROGRAM itself is interactive but does not normally print
such an announcement, the Work is not required to print an
announcement.);
iv. You must accompany the Work with the complete corresponding
machine-readable source code, delivered on a medium customarily
used for software interchange. 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 code. If you distribute with the
Work any component 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, you
must also distribute the source code of that component if you have
it and are allowed to do so;
v. If you distribute any written or printed material at all with the
Work, such material must include either a written copy of this
License, or a prominent written indication that the Work is
covered by this License and written instructions for printing
and/or displaying the copy of the License on the distribution
medium;
vi. You may not impose any further restrictions on the recipient's
exercise of the rights granted herein.
If distribution of executable or object code is made by offering the
equivalent ability to copy from a designated place, then offering equivalent
ability 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 code along with the object code.
3. Reservation of Rights
No rights are granted to the PROGRAM except as expressly set forth herein.
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.
4. Other Restrictions
If the distribution and/or use of the PROGRAM is restricted in certain
countries for any reason, LICENSOR 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.
5. Limitations
THE PROGRAM IS PROVIDED TO YOU "AS IS", WITHOUT WARRANTY. THERE IS NO
WARRANTY FOR THE PROGRAM, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 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.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL
LICENSOR, 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.
6. General
This License is governed by the laws of the State of Maryland, U.S.A.,
excluding choice of law rules.
If any part of this License is found to be in conflict with the law, that
part shall be interpreted in its broadest meaning consistent with the law,
and no other parts of the License shall be affected.
For United States Government users, the PROGRAM is provided with RESTRICTED
RIGHTS. If you are a unit or agency of the United States Government or are
acquiring the Software for any such unit or agency, the following apply:
If the unit or agency is the Department of Defense ("DOD"), the
Software and its documentation are classified as "commercial
computer software" and "commercial computer software
documentation" respectively and, pursuant to DFAR Section
227.7202, the Government is acquiring the Software and its
documentation in accordance with the terms of this License. If the
unit or agency is other than DOD, the Software and its
documentation are classified as "commercial computer software" and
"commercial computer software documentation" respectively and,
pursuant to FAR Section 12.212, the Government is acquiring the
Software and its documentation in accordance with the terms of
this License.
+34 -13
Ver Arquivo
@@ -3,9 +3,7 @@
#
# Common makefile definitions for the Common UNIX Printing System (CUPS).
#
# @configure_input@
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -16,7 +14,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -31,15 +29,30 @@
AR = @AR@
AWK = @AWK@
CC = @CC@
CHMOD = @CHMOD@
CP = @CP@
DSO = @DSO@
HTMLDOC = @HTMLDOC@
LN = /bin/ln -sf
MKDIR = @MKDIR@ -p
NROFF = @GROFF@ -T ascii
MV = @MV@
NROFF = @NROFF@
RANLIB = @RANLIB@
RM = @RM@ -f
SED = @SED@
SHELL = /bin/sh
#
# Libraries...
#
LIBCUPS = @LIBCUPS@
LIBCUPSIMAGE = @LIBCUPSIMAGE@
LIBJPEG = @LIBJPEG@
LIBPNG = @LIBPNG@
LIBTIFF = @LIBTIFF@
LIBZ = @LIBZ@
#
# Program options...
#
@@ -50,9 +63,11 @@ SHELL = /bin/sh
ARFLAGS = crvs
CFLAGS = @CFLAGS@ $(OPTIM) -I.. $(OPTIONS)
IMGLIBS = @IMGLIBS@ $(LIBS) -lm
DSOLIBS = @DSOLIBS@
IMGLIBS = @IMGLIBS@ -lm
LDFLAGS = @LDFLAGS@ $(OPTIM)
LIBS = @LIBS@ -L../cups -lcups
LIBS = -L../cups -lcups $(NETLIBS) @LIBS@
NETLIBS = @NETLIBS@
OPTIM = @OPTIM@
OPTIONS =
@@ -87,24 +102,30 @@ top_srcdir = @top_srcdir@
BINDIR = @bindir@
DATADIR = @CUPS_DATADIR@
INCLUDEDIR = $(includedir)/cups
DOCDIR = @CUPS_DOCDIR@
INCLUDEDIR = $(includedir)
LIBDIR = $(libdir)
LOCALEDIR = @CUPS_LOCALEDIR@
LOGDIR = @CUPS_LOGDIR@
MANDIR = @mandir@
REQUESTS = @CUPS_REQUESTS@
SBINDIR = @sbindir@
SERVERBIN = @CUPS_SERVERBIN@
SERVERROOT = @CUPS_SERVERROOT@
#
# Rules...
#
.SUFFIXES: .a .c .h .1 .2 .3 .4 .5 .6 .7 .8 .o .z
.SILENT:
.SUFFIXES: .a .c .h .man .o .1 .5 .8
.c.o:
echo Compiling $<...
$(CC) $(CFLAGS) -c $<
.1.z .2.z .3.z .4.z .5.z .6.z .7.z .8.z:
$(NROFF) -man $< >t
pack -f t
mv t.z $@
.man.1 .man.5 .man.8:
echo Formatting $<...
$(RM) $@
$(NROFF) -man $< >$@
#
# End of "$Id$"
+35 -9
Ver Arquivo
@@ -14,7 +14,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -37,7 +37,8 @@ DIRS = cups backend berkeley cgi-bin filter man pstoraster \
all:
for dir in $(DIRS); do\
(cd $$dir; make);\
echo Making all in $$dir... ;\
(cd $$dir; $(MAKE) -$(MAKEFLAGS)) || break;\
done
#
@@ -46,7 +47,8 @@ all:
clean:
for dir in $(DIRS); do\
(cd $$dir; make clean);\
echo Cleaning in $$dir... ;\
(cd $$dir; $(MAKE) -$(MAKEFLAGS) clean) || break;\
done
#
@@ -55,13 +57,37 @@ clean:
install:
for dir in $(DIRS); do\
(cd $$dir; make install);\
echo Installing in $$dir... ;\
(cd $$dir; $(MAKE) -$(MAKEFLAGS) install) || break;\
done
(cd conf; make install)
(cd data; make install)
(cd doc; make install)
(cd fonts; make install)
(cd ppd; make install)
echo Installing in conf...
(cd conf; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in data...
(cd data; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in doc...
(cd doc; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in fonts...
(cd fonts; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in ppd...
(cd ppd; $(MAKE) -$(MAKEFLAGS) install)
echo Installing in templates...
(cd templates; $(MAKE) -$(MAKEFLAGS) install)
#
# Make a software distribution...
#
epm:
epm -v cups
rpm:
epm -v -f rpm cups
deb:
epm -v -f deb cups
tardist:
epm -v -f tardist cups
#
# End of "$Id$".
-243
Ver Arquivo
@@ -1,243 +0,0 @@
<HTML>
<HEAD>
<TITLE>README - Common UNIX Printing System</TITLE>
</HEAD>
<BODY>
<H1>README - CUPS v1.0b1</H1>
<H2>Contents</H2>
<UL>
<LI><A HREF="#intro">Introduction</A>
<LI><A HREF="#require">Requirements</A>
<LI><A HREF="#compile">Compiling CUPS</A>
<LI><A HREF="#config">Configuring the Software</A>
<LI><A HREF="#run">Running the Software</A>
<LI><A HREF="#use">Using the Software</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="#license">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="compile">Compiling CUPS</A></H2>
CUPS uses GNU autoconf to configure the makefiles and source code for your
system. To configure CUPS for your system type:
<UL><PRE>
% ./configure ENTER
</PRE></UL>
The default installation will put the CUPS software in the <CODE>/usr</CODE>
and <CODE>/var</CODE> directories on your system, which will overwrite any
existing printing commands on your system. To install the CUPS software in
another location use the <CODE>--prefix</CODE> option:
<UL><PRE>
% ./configure --prefix=/usr/local ENTER
</PRE></UL>
Once you have configured things, just type:
<UL><PRE>
% make ENTER
</PRE></UL>
to build the software.
<H2><A NAME="install">Installing the Software</A></H2>
To install the software type:
<UL><PRE>
% make install ENTER
</PRE></UL>
<H2><A NAME="config">Configuring the Software</A></H2>
Before you run CUPS for the first time you'll need to edit the CUPS
configuration files which are normally located in /var/cups/conf.
<UL>
The <CODE>cupsd.conf</CODE> file configures all of the
"global" server settings and access control. The default
settings are usually appropriate for most environments.
<P>The <CODE>printers.conf</CODE> file configures each printer
queue. You'll need to add a listing for each printer on your
system.
<P>The <CODE>classes.conf</CODE> file configures each printer
class. You'll need to add a listing for each printer class you
want.
<P>The <CODE>mime.types</CODE> file defines all of the
recognized file types. You don't normally have to edit this
file.
<P>The <CODE>mime.convs</CODE> file defines all of the file
conversion filters. You don't normally have to edit this file.
</UL>
In addition to the files in the /var/cups/conf directory, you'll also need
to copy PPD files for each printer to the /var/cups/ppd directory. If you
don't have a PPD file for your printer, the drivers will still work, just
with reduced functionality.
<H2><A NAME="run">Running the Software</A></H2>
Once you have configured the software you can start the CUPS daemon by
typing:
<UL><PRE>
% /usr/sbin/cupsd &amp; ENTER
</PRE></UL>
<H2><A NAME="use">Using the Software</A></H2>
Once you have installed the software, you can use the normal lp or lpr
commands to print jobs. If you installed the software under /usr then
you shouldn't have to reconfigure any applications to recognize the new
printing system.
<P>One of the advantages of CUPS is that you don't always have to send
PostScript or Text files to your printers. If you have a JPEG file, you
can just type "lp filename.jpg" and CUPS will handle converting it for
you!
<P>You can monitor the status of jobs via the lpstat command or with your
web browser by pointing it at "http://localhost:631".
<H2><A NAME="known">Known Problems</A></H2>
The following known problems are being worked on and should be resolved for
the second beta release of CUPS:
<UL>
<LI>Documentation is not completed.
<LI>The lpadmin command is currently not provided.
<LI>The lpq command is currently not provided.
<LI>The lpc command currently only supports the help and status
commands.
<LI>While both GNU GhostScript and the CUPS image RIP are
provided, no sample raster printer driver is provided. The
final release of CUPS will include a PCL printer driver.
<LI>Automatic classing is currently not supported.
<LI>The CUPS server should disable core dumps by filters, backends,
and CGI programs.
<LI>The CUPS server should increase the FD limit to the maximum
allowed on the system.
<LI>The CUPS server should close stdin, stdout, and stderr and
run in the background ("daemon" mode...)
<LI>The class and job CGIs are currently not provided.
</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">Aladdin Free Public License</A>
which is located in the files "LICENSE.html" and "LICENSE.txt". For commercial
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>
+181 -128
Ver Arquivo
@@ -1,192 +1,245 @@
README - CUPS v1.0b1
README - CUPS v1.1b2 - 03/13/2000
---------------------------------
CONTENTS
************************************************************************
************************************************************************
**** ****
**** BETA SOFTWARE BETA SOFTWARE BETA SOFTWARE BETA SOFTWARE ****
**** ****
************************************************************************
************************************************************************
This is an official public beta release for the Common UNIX Printing
System. Since this is a beta release, we do not recommend that you
use this software on a production system. Instead, please use the
current 1.0.x release for your production systems.
Also, currently we are only providing source code for the beta releases.
As we approach a final production ("gold") release of CUPS 1.1 we will
provide binary distributions as well.
Please report all problems in the CUPS 1.1 beta releases to
"cups-beta@cups.org" or to the CUPS mailing list.
Thanks for using CUPS!
* Introduction
* Requirements
* Compiling CUPS
* Configuring the Software
* Running the Software
* Using the Software
* Known Problems
* Reporting Problems
* Other Resources
* Legal Stuff
INTRODUCTION
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.
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 (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.
managing print jobs and queues. The Line Printer Daemon (LPD, RFC1179)
and AppSocket protocols are also supported with reduced functionality.
CUPS adds network printer browsing and PostScript Printer Description
("PPD")-based printing options to support real world applications under
UNIX.
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.
CUPS also includes a customized version of GNU GhostScript (currently
based off GNU GhostScript 5.50) and an image file RIP that can be used
to support non-PostScript printers.
REQUIREMENTS
CUPS is Copyright 1993-2000 by Easy Software Products, All Rights
Reserved. CUPS is currently licensed under the terms of the GNU
General Public License. Please see the license file for details.
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®.
For the image file filters you'll need the JPEG, PNG, TIFF, and ZLIB
libraries. CUPS will build without these, but with reduced functionality.
SYSTEM REQUIREMENTS
If you make changes to the man pages you'll need GNU groff or another
nroff-like package.
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.
The documentation is formatted using the HTMLDOC software (again, not needed
unless you make changes.)
If you are installing from source you'll need an ANSI C compiler and
optionally one or more image file support libraries. Complete source
installation instructions can be found in the CUPS System
Administrator's Manual in the files "doc/sam.html" or "doc/sam.pdf".
COMPILING CUPS
CUPS uses GNU autoconf to configure the makefiles and source code for your
system. To configure CUPS for your system type:
SOFTWARE REQUIREMENTS
% ./configure ENTER
The following operating system software is required to install one of
the binary distributions from Easy Software Products:
The default installation will put the CUPS software in the /usr and /var
directories on your system, which will overwrite any existing printing
commands on your system. To install the CUPS software in another location
use the --prefix option:
- 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)
% ./configure --prefix=/usr/local ENTER
Once you have configured things, just type:
INSTALLING CUPS
% make ENTER
We are currently distributing CUPS binary distributions in TAR format
with installation and removal scripts generated by our ESP Package
Manager (EPM) software, which is available from:
to build the software.
http://www.easysw.com/epm
INSTALLING THE SOFTWARE
WARNING: Installing CUPS will overwrite your existing printing system.
Backup files are made by the installation script and restored by the
removal script, so if you experience problems you should be able to
remove the CUPS software to restore your previous configuration.
However, Easy Software Products makes no warranty for this and will not
be liable for any lost revenues, etc.
To install the software type:
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:
% make install ENTER
./cups.install ENTER
CONFIGURING THE SOFTWARE
After asking you a few yes/no questions the CUPS software will be
installed and the scheduler will be started automatically.
Before you run CUPS for the first time you'll need to edit the CUPS
configuration files which are normally located in /var/cups/conf.
The cupsd.conf file configures all of the "global" server settings and
access control. The default settings are usually appropriate for most
environments.
READING THE DOCUMENTATION
The printers.conf file configures each printer queue. You'll need to
add a listing for each printer on your system.
Once you have installed the software you can access the documentation
(and a bunch of other stuff) on-line at:
The classes.conf file configures each printer class. You'll need to add
a listing for each printer class you want.
http://localhost:631
The mime.types file defines all of the recognized file types. You don't
normally have to edit this file.
If you're having trouble getting that far, the documentation is located
in the "/usr/share/cups/doc" directory in the binary distributions, and
under the "doc" directory in the source archives.
The mime.convs file defines all of the file conversion filters. You
don't normally have to edit this file.
Please read the documentation before asking questions.
In addition to the files in the /var/cups/conf directory, you'll also need
to copy PPD files for each printer to the /var/cups/ppd directory. If you
don't have a PPD file for your printer, the drivers will still work, just
with reduced functionality.
RUNNING THE SOFTWARE
SETTING UP PRINTER QUEUES USING YOUR WEB BROWSER
Once you have configured the software you can start the CUPS daemon by
typing:
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:
% /usr/sbin/cupsd & ENTER
http://localhost:631/admin
USING THE SOFTWARE
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.
Once you have installed the software, you can use the normal lp or lpr
commands to print jobs. If you installed the software under /usr then you
shouldn't have to reconfigure any applications to recognize the new printing
system.
[note: adding, deleting, and modifying classes has not been implemented in
beta 2]
One of the advantages of CUPS is that you don't always have to send
PostScript or Text files to your printers. If you have a JPEG file, you can
just type "lp filename.jpg" and CUPS will handle converting it for you!
You can monitor the status of jobs via the lpstat command or with your web
browser by pointing it at "http://localhost:631".
SETTING UP PRINTER QUEUES FROM THE COMMAND-LINE
KNOWN PROBLEMS
CUPS works best with PPD (PostScript Printer Description) files. In a
pinch you can also use System V style printer interface scripts.
The following known problems are being worked on and should be resolved for
the second beta release of CUPS:
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:
* Documentation is not completed.
* The lpadmin command is currently not provided.
* The lpq command is currently not provided.
* The lpc command currently only supports the help and status commands.
* While both GNU GhostScript and the CUPS image RIP are provided, no
sample raster printer driver is provided. The final release of CUPS
will include a PCL printer driver.
* Automatic classing is currently not supported.
* The CUPS server should disable core dumps by filters, backends, and CGI
programs.
* The CUPS server should increase the FD limit to the maximum allowed on
the system.
* The CUPS server should close stdin, stdout, and stderr and run in the
background ("daemon" mode...)
* The class and job CGIs are currently not provided.
Digital UNIX:
CUPS has been built and tested on the following operating systems:
/usr/lib/lpadmin -p DeskJet -m deskjet.ppd -v parallel:/dev/lp0 -E
* 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)
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 [not in beta 2]
EPSON 24-pin Series epson24.ppd [not in beta 2]
These sample drivers provide basic printing capabilities, but generally
do not exercise the full potential of the printers or CUPS. For
commercial printer drivers check out our ESP Print Pro software at:
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 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, please send an email to cups-support@cups.org. Include
your operating system and version, compiler and version, and any errors or
problems you've run into.
If you have problems, please send an email to cups-support@cups.org.
Include your operating system and version, compiler and version, and
any errors or problems you've run into. If you are running a version
of Linux, be sure to provide the Linux distribution you have, too.
OTHER RESOURCES
See the CUPS web site at "http://www.cups.org" for other site links.
You can subscribe to the CUPS mailing list by sending a message containing
"subscribe cups" to majordomo@cups.org. This list is provided to discuss
problems, questions, and improvements to the CUPS software. New releases of
CUPS are announced to this list as well.
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-1999 by Easy Software Products. CUPS, the CUPS logo,
and the Common UNIX Printing System are the trademark property of Easy
Software Products.
CUPS is Copyright 1993-2000 by Easy Software Products. CUPS, the CUPS
logo, and the Common UNIX Printing System are the trademark property of
Easy Software Products.
CUPS is provided under the terms of the Aladdin Free Public License which is
located in the files "LICENSE.html" and "LICENSE.txt". For commercial
CUPS is provided under the terms of the GNU General Public License
which is located in the files "LICENSE.html" and "LICENSE.txt" (or the
file "cups.license" for a binary distribution.) For commercial
licensing information, please contact:
Attn: CUPS Licensing Information
Easy Software Products
44141 Airport View Drive, Suite 204
Hollywood, Maryland 20636-3111 USA
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
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.
Voice: +1.301.373.9603
Email: cups-info@cups.org
WWW: http://www.cups.org
+60 -19
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Backend makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -14,7 +14,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -24,8 +24,10 @@
include ../Makedefs
TARGETS = lpd parallel serial smb socket
OBJS = lpd.o parallel.o serial.o smb.o socket.o
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
#
# Make all targets...
@@ -33,66 +35,105 @@ OBJS = lpd.o parallel.o serial.o smb.o socket.o
all: $(TARGETS)
#
# Clean all object files...
#
clean:
rm -f $(OBJS) $(TARGETS)
$(RM) $(OBJS) $(TARGETS)
#
# Install all targets...
#
install:
-$(MKDIR) $(SERVERROOT)/backend
$(CP) $(TARGETS) $(SERVERROOT)/backend
-$(MKDIR) $(SERVERBIN)/backend
$(CP) $(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
#
# ipp
#
ipp: ipp.o ../cups/$(LIBCUPS)
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.a
lpd: lpd.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpd lpd.o $(LIBS)
lpd.o: ../cups/cups.h ../Makedefs
#
# parallel
#
parallel: parallel.o ../cups/libcups.a
parallel: parallel.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o parallel parallel.o $(LIBS)
parallel.o: ../cups/cups.h ../Makedefs
#
# serial
#
serial: serial.o ../cups/libcups.a
serial: serial.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o serial serial.o $(LIBS)
serial.o: ../cups/cups.h ../Makedefs
#
# smb
#
smb: smb.o ../cups/libcups.a
$(CC) $(LDFLAGS) -o smb smb.o $(LIBS)
smb.o: ../cups/cups.h ../Makedefs
#
# socket
#
socket: socket.o ../cups/libcups.a
socket: socket.o ../cups/$(LIBCUPS)
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$".
#
+31 -12
Ver Arquivo
@@ -1,9 +1,9 @@
/*
* "$Id$"
*
* Server Message Block backend for the Common UNIX Printing System (CUPS).
* Backend test program for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -23,44 +23,63 @@
*
* Contents:
*
* main() - Run the named backend.
*/
/*
* Include necessary headers.
*/
#include <cups/cups.h>
#include <stdio.h>
#include <stdlib.h>
#include <cups/string.h>
#include <unistd.h>
/*
* 'main()' - Send a file to the printer or server.
* 'main()' - Run the named backend.
*
* Usage:
*
* printer-uri job-id user title copies options [file]
* betest device-uri job-id user title copies options [file]
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments (6 or 7) */
main(int argc, /* I - Number of command-line arguments (7 or 8) */
char *argv[]) /* I - Command-line arguments */
{
if (argc < 6 || argc > 7)
char backend[255]; /* Method in URI */
if (argc < 7 || argc > 8)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
fputs("Usage: betest device-uri job-id user title copies options [file]\n",
stderr);
return (1);
}
fputs("ERROR: Backend not implemented yet!\n", stderr);
/*
* 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$".
*/
+668
Ver Arquivo
@@ -0,0 +1,668 @@
/*
* "$Id$"
*
* IPP 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 printer or server.
*/
/*
* Include necessary headers.
*/
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/string.h>
/*
* 'main()' - Send a file to the printer or server.
*
* 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 */
{
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 */
hostname[1024], /* Hostname */
username[255], /* Username info */
resource[1024], /* Resource info (printer name) */
filename[1024]; /* File to print */
int port; /* Port number (not used) */
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 (argc == 1)
{
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)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
return (1);
}
/*
* 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.
*/
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)
{
perror("ERROR: Unable to open print file");
return (1);
}
else
stat(filename, &fileinfo);
/*
* Extract the hostname and printer name from the URI...
*/
httpSeparate(argv[0], method, username, hostname, &port, resource);
/*
* Try connecting to the remote server...
*/
do
{
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);
}
}
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...
*/
snprintf(uri, sizeof(uri), "%s://%s:%d%s", method, hostname, port, resource);
/*
* 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...
*/
language = cupsLangDefault();
copies_sup = NULL;
do
{
/*
* Build the IPP request...
*/
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 != NULL ? language->language : "C");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
/*
* 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));
httpSetField(http, HTTP_FIELD_CONTENT_LENGTH, buffer);
/*
* Do the request...
*/
for (;;)
{
/*
* POST the request, retrying as needed...
*/
if (httpPost(http, resource))
{
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
{
fprintf(stderr, "ERROR: Printer will not accept print file (%x)!\n",
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);
}
else
{
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);
}
httpFlush(http);
break;
}
if (status != HTTP_OK)
{
if (fp != stdin)
fclose(fp);
httpClose(http);
return (1);
}
}
while (ipp_status > IPP_OK_CONFLICT);
/*
* 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)
{
/*
* Build the IPP request...
*/
request = ippNew();
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language != NULL ? language->language : "C");
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 (cupsGetOption("raw", num_options, options) ||
((content_type = getenv("CONTENT_TYPE")) != NULL &&
strcasecmp(content_type, "application/vnd.cups-raw") == 0))
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
if (copies_sup)
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "copies", atoi(argv[4]));
for (i = 0; i < num_options; i ++)
{
/*
* Skip the "raw" option - handled above...
*/
if (strcasecmp(options[i].name, "raw") == 0)
continue;
/*
* See what the option value is; for compatibility with older interface
* scripts, we have to support single-argument options as well as
* option=value, option=low-high, and option=MxN.
*/
option = options[i].name;
val = options[i].value;
if (*val == '\0')
val = NULL;
if (val != NULL)
{
if (strcasecmp(val, "true") == 0 ||
strcasecmp(val, "on") == 0 ||
strcasecmp(val, "yes") == 0)
{
/*
* Boolean value - true...
*/
n = 1;
val = "";
}
else if (strcasecmp(val, "false") == 0 ||
strcasecmp(val, "off") == 0 ||
strcasecmp(val, "no") == 0)
{
/*
* Boolean value - false...
*/
n = 0;
val = "";
}
n = strtol(val, &s, 0);
}
else
{
if (strncasecmp(option, "no", 2) == 0)
{
option += 2;
n = 0;
}
else
n = 1;
s = "";
}
if (*s != '\0' && *s != '-' && (*s != 'x' || s == val))
/*
* String value(s)...
*/
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
else if (val != NULL)
{
/*
* Numeric value, range, or resolution...
*/
if (*s == '-')
{
n2 = strtol(s + 1, NULL, 0);
ippAddRange(request, IPP_TAG_JOB, option, n, n2);
}
else if (*s == 'x')
{
n2 = strtol(s + 1, &s, 0);
if (strcasecmp(s, "dpc") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_CM, n, n2);
else if (strcasecmp(s, "dpi") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_INCH, n, n2);
else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
}
else
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, option, n);
}
else
/*
* Boolean value...
*/
ippAddBoolean(request, IPP_TAG_JOB, option, (char)n);
}
/*
* Now fill in the HTTP request stuff...
*/
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 (;;)
{
/*
* POST the request, retrying as needed...
*/
httpReconnect(http);
if (httpPost(http, resource))
{
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...
*/
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, sending print file...\n", stderr);
/*
* Then send the file...
*/
rewind(fp);
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)
{
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);
}
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);
}
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);
}
httpFlush(http);
break;
}
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;
}
/*
* Free memory...
*/
httpClose(http);
/*
* Close and remove the temporary file if necessary...
*/
fclose(fp);
if (argc < 7)
unlink(filename);
/*
* Return the queue status...
*/
return (status != HTTP_OK);
}
/*
* End of "$Id$".
*/
+50 -30
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Line Printer Daemon backend for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -83,7 +83,12 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
int status; /* Status of LPD job */
if (argc < 6 || argc > 7)
if (argc == 1)
{
puts("network lpd \"Unknown\" \"LPD/LPR Host or Printer\"");
return (0);
}
else if (argc < 6 || argc > 7)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
@@ -107,16 +112,16 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
int bytes; /* Number of bytes read */
if ((fp = fopen(tmpnam(filename), "w")) == NULL)
if ((fp = fopen(cupsTempFile(filename, sizeof(filename)), "w")) == NULL)
{
perror("lpd: unable to create temporary file");
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("lpd: unable to write to temporary file");
perror("ERROR: unable to write to temporary file");
fclose(fp);
unlink(filename);
return (1);
@@ -125,7 +130,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fclose(fp);
}
else
strcpy(filename, argv[6]);
{
strncpy(filename, argv[6], sizeof(filename) - 1);
filename[sizeof(filename) - 1] = '\0';
}
/*
* Extract the hostname and printer name from the URI...
@@ -137,8 +145,17 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Queue the job...
*/
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, atoi(argv[4]) /* copies */);
if (argc > 6)
{
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, atoi(argv[4]) /* copies */);
if (!status)
fprintf(stderr, "PAGE: 1 %d\n", atoi(argv[4]));
}
else
status = lpd_queue(hostname, resource + 1, filename,
argv[2] /* user */, 1);
/*
* Remove the temporary file if necessary...
@@ -175,10 +192,10 @@ lpd_command(int fd, /* I - Socket connection to LPD host */
*/
va_start(ap, format);
bytes = vsprintf(buf, format, ap);
bytes = vsnprintf(buf, sizeof(buf), format, ap);
va_end(ap);
fprintf(stderr, "lpd: lpd_command %02.2x %s", buf[0], buf + 1);
fprintf(stderr, "DEBUG: lpd_command %02.2x %s", buf[0], buf + 1);
/*
* Send the command...
@@ -194,7 +211,7 @@ lpd_command(int fd, /* I - Socket connection to LPD host */
if (recv(fd, &status, 1, 0) < 1)
return (-1);
fprintf(stderr, "lpd: lpd_command returning %d\n", status);
fprintf(stderr, "DEBUG: lpd_command returning %d\n", status);
return (status);
}
@@ -250,8 +267,9 @@ lpd_queue(char *hostname, /* I - Host to connect to */
{
if ((fd = rresvport(&port)) < 0)
{
perror("ERROR: Unable to connect to printer");
return (1);
perror("ERROR: Unable to reserve port");
sleep(30);
continue;
}
if (connect(fd, (struct sockaddr *)&addr, sizeof(addr)) < 0)
@@ -275,7 +293,7 @@ lpd_queue(char *hostname, /* I - Host to connect to */
else
{
perror("ERROR: Unable to connect to printer");
return (1);
sleep(30);
}
}
else
@@ -288,13 +306,13 @@ lpd_queue(char *hostname, /* I - Host to connect to */
if (stat(filename, &filestats))
{
perror("lpd: unable to stat print file");
perror("ERROR: unable to stat print file");
return (1);
}
if ((fp = fopen(filename, "rb")) == NULL)
{
perror("lpd: unable to open print file for reading");
perror("ERROR: unable to open print file for reading");
return (1);
}
@@ -306,29 +324,31 @@ lpd_queue(char *hostname, /* I - Host to connect to */
lpd_command(fd, "\002%s\n", printer); /* Receive print job(s) */
gethostname(localhost, sizeof(localhost));
if (strchr(localhost, '.') != NULL)
*strchr(localhost, '.') = '\0';
localhost[31] = '\0'; /* RFC 1179, Section 7.2 - host name < 32 chars */
sprintf(control, "H%s\nP%s\n", localhost, user);
snprintf(control, sizeof(control), "H%s\nP%s\n", localhost, user);
cptr = control + strlen(control);
while (copies > 0)
{
sprintf(cptr, "ldfA%03.3d%s\n", getpid() % 1000, localhost);
snprintf(cptr, sizeof(control) - (cptr - control), "ldfA%03.3d%s\n",
getpid() % 1000, localhost);
cptr += strlen(cptr);
copies --;
}
sprintf(cptr, "UdfA%03.3d%s\nNdfA%03.3d%s\n",
getpid() % 1000, localhost,
getpid() % 1000, localhost);
snprintf(cptr, sizeof(control) - (cptr - control),
"UdfA%03.3d%s\nNdfA%03.3d%s\n",
getpid() % 1000, localhost,
getpid() % 1000, localhost);
fprintf(stderr, "lpd: Control file is:\n%s", control);
fprintf(stderr, "DEBUG: Control file is:\n%s", control);
lpd_command(fd, "\002%d cfA%03.3d%s\n", strlen(control), getpid() % 1000,
localhost);
fprintf(stderr, "lpd: Sending control file (%d bytes)\n", strlen(control));
fprintf(stderr, "INFO: Sending control file (%d bytes)\n", strlen(control));
if (send(fd, control, strlen(control) + 1, 0) < (strlen(control) + 1))
{
@@ -344,12 +364,12 @@ lpd_queue(char *hostname, /* I - Host to connect to */
* Send the print file...
*/
fputs("lpd: Control file sent successfully\n", stderr);
fputs("INFO: Control file sent successfully\n", stderr);
lpd_command(fd, "\003%d dfA%03.3d%s\n", filestats.st_size,
lpd_command(fd, "\003%u dfA%03.3d%s\n", (unsigned)filestats.st_size,
getpid() % 1000, localhost);
fprintf(stderr, "lpd: Sending data file (%u bytes)\n",
fprintf(stderr, "INFO: Sending data file (%u bytes)\n",
(unsigned)filestats.st_size);
tbytes = 0;
@@ -375,7 +395,7 @@ lpd_queue(char *hostname, /* I - Host to connect to */
fprintf(stderr, "ERROR: Remote host did not accept data file (%d)\n",
status);
else
fputs("lpd: Data file sent successfully\n", stderr);
fputs("INFO: Data file sent successfully\n", stderr);
}
/*
+353 -18
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Parallel port backend for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -23,7 +23,8 @@
*
* Contents:
*
* main() - Send a file to the specified parallel port.
* main() - Send a file to the specified parallel port.
* list_devices() - List all parallel devices.
*/
/*
@@ -43,6 +44,24 @@
# 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.
@@ -63,15 +82,20 @@ 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 error; /* Error code (if any) */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total number of bytes written */
char buffer[8192]; /* Output buffer */
struct termios opts; /* Parallel port options */
if (argc < 6 || argc > 7)
if (argc == 1)
{
list_devices();
return (0);
}
else if (argc < 6 || argc > 7)
{
fputs("Usage: parallel job-id user title copies options [file]\n", stderr);
return (1);
@@ -83,7 +107,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
if (argc == 6)
fp = stdin;
{
fp = stdin;
copies = 1;
}
else
{
/*
@@ -95,6 +122,8 @@ 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]);
}
/*
@@ -143,23 +172,34 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Finally, send the print file...
*/
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
while (copies > 0)
{
/*
* Write the print data to the printer...
*/
copies --;
if (write(fd, buffer, nbytes) < nbytes)
if (fp != stdin)
{
perror("ERROR: Unable to send print file to printer");
break;
fputs("PAGE: 1 1\n", stderr);
rewind(fp);
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
/*
* Write the print data to the printer...
*/
if (write(fd, buffer, nbytes) < nbytes)
{
perror("ERROR: Unable to send print file to printer");
break;
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
}
/*
@@ -174,6 +214,301 @@ 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 */
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 ++)
{
sprintf(device, "/proc/parport/%d/autoprobe", i);
if ((probe = fopen(device, "r")) != NULL)
{
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
{
sprintf(device, "/dev/lp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
else
{
sprintf(device, "/dev/par%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct parallel:%s \"Unknown\" \"Parallel Port #%d\"\n", device, i + 1);
}
}
}
}
#elif defined(__sgi)
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", 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 */
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$".
*/
+378 -19
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Serial port backend for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -43,6 +43,24 @@
# 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.
@@ -66,15 +84,20 @@ 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 error; /* Error code (if any) */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total number of bytes written */
char buffer[8192]; /* Output buffer */
struct termios opts; /* Parallel port options */
if (argc < 6 || argc > 7)
if (argc == 1)
{
list_devices();
return (0);
}
else if (argc < 6 || argc > 7)
{
fputs("Usage: serial job-id user title copies options [file]\n", stderr);
return (1);
@@ -86,7 +109,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
if (argc == 6)
fp = stdin;
{
fp = stdin;
copies = 1;
}
else
{
/*
@@ -98,6 +124,8 @@ 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]);
}
/*
@@ -121,10 +149,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
}
/*
* Open the parallel port device...
* Open the serial port device...
*/
if ((fd = open(resource, O_WRONLY)) == -1)
if ((fd = open(resource, O_WRONLY | O_NOCTTY)) == -1)
{
perror("ERROR: Unable to open serial port device file");
return (1);
@@ -261,23 +289,34 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
* Finally, send the print file...
*/
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
while (copies > 0)
{
/*
* Write the print data to the printer...
*/
copies --;
if (write(fd, buffer, nbytes) < nbytes)
if (fp != stdin)
{
perror("ERROR: Unable to send print file to printer");
break;
fputs("PAGE: 1 1\n", stderr);
rewind(fp);
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
tbytes = 0;
while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0)
{
/*
* Write the print data to the printer...
*/
if (write(fd, buffer, nbytes) < nbytes)
{
perror("ERROR: Unable to send print file to printer");
break;
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
}
/*
@@ -292,6 +331,326 @@ 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 < 4; i ++)
{
sprintf(device, "/dev/ttyS%d", i);
if ((fd = open(device, O_WRONLY | O_NOCTTY)) >= 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)) >= 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)) >= 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)) >= 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)) >= 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)) >= 0)
{
close(fd);
printf("serial serial:%s?baud=115200 \"Unknown\" \"SX Serial Port #%d\"\n",
device, i + 1);
}
}
#endif
}
/*
* End of "$Id$".
*/
+94 -67
Ver Arquivo
@@ -3,7 +3,7 @@
*
* AppSocket backend for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -66,6 +66,7 @@ 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,7 +81,12 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
fd_set input; /* Input set for select() */
if (argc < 6 || argc > 7)
if (argc == 1)
{
puts("network socket \"Unknown\" \"AppSocket/HP JetDirect\"");
return (0);
}
else if (argc < 6 || argc > 7)
{
fprintf(stderr, "Usage: %s job-id user title copies options [file]\n",
argv[0]);
@@ -93,7 +99,10 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
*/
if (argc == 6)
fp = stdin;
{
fp = stdin;
copies = 1;
}
else
{
/*
@@ -105,6 +114,8 @@ 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]);
}
/*
@@ -135,91 +146,107 @@ main(int argc, /* I - Number of command-line arguments (6 or 7) */
addr.sin_family = hostaddr->h_addrtype;
addr.sin_port = htons(port);
for (;;)
while (copies > 0)
{
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
for (;;)
{
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 (error == ECONNREFUSED)
if ((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
fprintf(stderr, "INFO: Network host \'%s\' is busy; will retry in 30 seconds...\n",
hostname);
sleep(30);
perror("ERROR: Unable to create socket");
return (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);
}
}
else
{
perror("ERROR: Unable to connect to printer");
return (1);
}
}
else
break;
}
/*
* 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...
* Finally, send the print file...
*/
timeout.tv_sec = 0;
timeout.tv_usec = 0;
FD_ZERO(&input);
FD_SET(fd, &input);
if (select(fd + 1, &input, NULL, NULL, &timeout) > 0)
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)
{
/*
* Grab the data coming back and spit it out to stderr...
* Write the print data to the printer...
*/
if ((nbytes = recv(fd, buffer, sizeof(buffer), 0)) > 0)
fprintf(stderr, "INFO: Received %u bytes of back-channel data!\n",
nbytes);
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);
}
else if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
/*
* Close the socket connection...
*/
close(fd);
}
/*
* Close the socket connection and input file and return...
* Close the input file and return...
*/
close(fd);
if (fp != stdin)
fclose(fp);
+302
Ver Arquivo
@@ -0,0 +1,302 @@
/*
* "$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 <cups/string.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 */
size_t nbytes, /* Number of bytes written */
tbytes; /* Total number of bytes written */
char buffer[8192]; /* Output buffer */
struct termios opts; /* Parallel port options */
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...
*/
if ((fd = open(resource, O_WRONLY)) == -1)
{
perror("ERROR: Unable to open USB port device file");
return (1);
}
/*
* Set any options provided...
*/
tcgetattr(fd, &opts);
opts.c_lflag &= ~(ICANON | ECHO | ISIG); /* Raw mode */
/**** No options supported yet ****/
tcsetattr(fd, TCSANOW, &opts);
/*
* 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...
*/
if (write(fd, buffer, nbytes) < nbytes)
{
perror("ERROR: Unable to send print file to printer");
break;
}
else
tbytes += nbytes;
if (argc > 6)
fprintf(stderr, "INFO: Sending print file, %u bytes...\n", tbytes);
}
}
/*
* 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/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 */
if ((probe = fopen("/proc/bus/usb/devices", "r")) != NULL)
{
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 &&
make[0] && model[0])
{
/*
* We were processing a printer device; send the info out...
*/
printf("direct usb:/dev/usb/usblp%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
{
for (i = 0; i < 8; i ++)
{
sprintf(device, "/dev/usb/usblp%d", i);
if ((fd = open(device, O_WRONLY)) >= 0)
{
close(fd);
printf("direct usb:%s \"Unknown\" \"USB Printer #%d\"\n", device, i + 1);
}
}
}
#elif defined(__sgi)
#elif defined(__sun)
#elif defined(__hpux)
#elif defined(__osf)
#elif defined(FreeBSD) || defined(OpenBSD) || defined(NetBSD)
#endif
}
/*
* End of "$Id$".
*/
+22 -9
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Berkeley commands makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -14,7 +14,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -24,8 +24,8 @@
include ../Makedefs
TARGETS = lpc lpr lprm
OBJS = lpc.o lpr.o lprm.o
TARGETS = lpc lpq lpr lprm
OBJS = lpc.o lpq.o lpr.o lprm.o
#
# Make all targets...
@@ -38,7 +38,7 @@ all: $(TARGETS)
#
clean:
rm -f $(OBJS) $(TARGETS)
$(RM) $(OBJS) $(TARGETS)
#
# Install all targets...
@@ -46,24 +46,36 @@ clean:
install:
-$(MKDIR) $(BINDIR)
$(CP) lpq lpr lprm $(BINDIR)
-$(MKDIR) $(SBINDIR)
$(CP) lpr lprm $(BINDIR)
$(CP) lpc $(SBINDIR)
#
# lpc
#
lpc: lpc.o ../cups/libcups.a
lpc: lpc.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpc lpc.o $(LIBS)
lpc.o: ../cups/cups.h ../Makedefs
#
# lpq
#
lpq: lpq.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpq lpq.o $(LIBS)
lpq.o: ../cups/cups.h ../Makedefs
#
# lpr
#
lpr: lpr.o ../cups/libcups.a
lpr: lpr.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lpr lpr.o $(LIBS)
lpr.o: ../cups/cups.h ../Makedefs
@@ -72,7 +84,8 @@ lpr.o: ../cups/cups.h ../Makedefs
# lprm
#
lprm: lprm.o ../cups/libcups.a
lprm: lprm.o ../cups/$(LIBCUPS)
echo Linking $@...
$(CC) $(LDFLAGS) -o lprm lprm.o $(LIBS)
lprm.o: ../cups/cups.h ../Makedefs
+27 -13
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lpc" command for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -60,7 +60,6 @@ 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 */
@@ -70,7 +69,7 @@ main(int argc, /* I - Number of command-line arguments */
* Connect to the scheduler...
*/
http = httpConnect("localhost", ippPort());
http = httpConnect(cupsServer(), ippPort());
if (argc > 1)
{
@@ -87,8 +86,14 @@ main(int argc, /* I - Number of command-line arguments */
*/
printf("lpc> ");
while (gets(line) != NULL)
while (fgets(line, sizeof(line), stdin) != NULL)
{
/*
* Strip the trailing newline...
*/
line[strlen(line) - 1] = '\0';
/*
* Find any options in the string...
*/
@@ -225,7 +230,7 @@ show_status(http_t *http, /* I - HTTP connection to server */
/* Printer URI */
DEBUG_printf(("show_printers(%08x, %08x)\n", http, dests));
DEBUG_printf(("show_status(%08x, %08x)\n", http, dests));
if (http == NULL)
return;
@@ -257,7 +262,7 @@ show_status(http_t *http, /* I - HTTP connection to server */
if ((response = cupsDoRequest(http, request, "/printers/")) != NULL)
{
DEBUG_puts("show_printers: request succeeded...");
DEBUG_puts("show_status: request succeeded...");
/*
* Loop through the printers returned in the list and display
@@ -397,15 +402,16 @@ show_status(http_t *http, /* I - HTTP connection to server */
language = cupsLangDefault();
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL,
cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL,
cupsLangEncoding(language));
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language->language);
sprintf(printer_uri, "http://localhost/printers/%s", printer);
snprintf(printer_uri, sizeof(printer_uri),
"ipp://localhost/printers/%s", printer);
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI,
"printer-uri", NULL, printer_uri);
@@ -427,7 +433,15 @@ 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");
+488
Ver Arquivo
@@ -0,0 +1,488 @@
/*
* "$Id$"
*
* "lpq" command 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:
*
* main() - Parse options and commands.
* show_jobs() - Show jobs.
*/
/*
* Include necessary headers...
*/
/*
* Include necessary headers...
*/
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <cups/cups.h>
#include <cups/language.h>
#include <cups/debug.h>
/*
* Local functions...
*/
static int show_jobs(http_t *, const char *, const char *, const int,
const int);
static void show_printer(http_t *, const char *);
/*
* 'main()' - Parse options and commands.
*/
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 */
const char *dest, /* Desired printer */
*user; /* Desired user */
int id, /* Desired job ID */
interval, /* Reporting interval */
longstatus; /* Show file details */
/*
* Connect to the scheduler...
*/
http = httpConnect(cupsServer(), ippPort());
/*
* Check for command-line options...
*/
dest = cupsGetDefault();
user = NULL;
id = 0;
interval = 0;
longstatus = 0;
for (i = 1; i < argc; i ++)
if (argv[i][0] == '+')
interval = atoi(argv[i] + 1);
else if (argv[i][0] == '-')
{
switch (argv[i][1])
{
case 'P' : /* Printer */
if (argv[i][2])
dest = argv[i] + 2;
else
{
i ++;
dest = argv[i];
}
break;
case 'l' : /* Long status */
longstatus = 1;
break;
default :
fputs("Usage: lpq [-P dest] [-l] [+interval]\n", stderr);
return (1);
}
}
else if (isdigit(argv[i][0]))
id = atoi(argv[i]);
else
user = argv[i];
/*
* Show the status in a loop...
*/
for (;;)
{
if (dest)
show_printer(http, dest);
i = show_jobs(http, dest, user, id, longstatus);
if (i && interval)
{
fflush(stdout);
sleep(interval);
}
else
break;
}
/*
* Close the connection to the server and return...
*/
httpClose(http);
return (0);
}
/*
* 'show_jobs()' - Show jobs.
*/
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 */
{
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 */
*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 */
{
"th",
"st",
"nd",
"rd",
"th",
"th",
"th",
"th",
"th",
"th"
};
DEBUG_printf(("show_jobs(%08x, %08x, %08x, %d, %d)\n", http, dest, user, id,
longstatus));
if (http == NULL)
return (0);
/*
* Build an IPP_GET_JOBS or IPP_GET_JOB_ATTRIBUTES request, which requires
* the following attributes:
*
* attributes-charset
* attributes-natural-language
* job-uri or printer-uri
*/
request = ippNew();
request->request.op.operation_id = id ? IPP_GET_JOB_ATTRIBUTES : IPP_GET_JOBS;
request->request.op.request_id = 1;
language = cupsLangDefault();
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if (dest == NULL)
{
if (id)
sprintf(resource, "ipp://localhost/jobs/%d", id);
else
strcpy(resource, "ipp://localhost/jobs");
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
NULL, resource);
}
else
{
snprintf(resource, sizeof(resource), "ipp://localhost/printers/%s", dest);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
NULL, resource);
}
if (user)
{
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, user);
ippAddBoolean(request, IPP_TAG_OPERATION, "my-jobs", 1);
}
/*
* Do the request and get back a response...
*/
jobcount = 0;
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;
/*
* Loop through the job list and display them...
*/
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;
/*
* Pull the needed attributes from this job...
*/
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)
{
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)
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)
jobstate = (ipp_jstate_t)attr->values[0].integer;
if (strcmp(attr->name, "job-printer-uri") == 0 &&
attr->value_tag == IPP_TAG_URI)
if ((jobdest = strrchr(attr->values[0].string.text, '/')) != NULL)
jobdest ++;
if (strcmp(attr->name, "job-originating-user-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
jobuser = attr->values[0].string.text;
if (strcmp(attr->name, "job-name") == 0 &&
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;
}
/*
* See if we have everything needed...
*/
if (jobdest == NULL || jobid == 0)
{
if (attr == NULL)
break;
else
continue;
}
/**** TODO - support OSF/1 and Berkeley formats ****/
if (!longstatus && jobcount == 0)
puts("Rank Owner Job Files Total Size");
jobcount ++;
/*
* Display the job...
*/
if (jobstate == IPP_JOB_PROCESSING)
strcpy(rankstr, "active");
else
{
sprintf(rankstr, "%d%s\t", rank, ranks[rank % 10]);
rank ++;
}
if (longstatus)
{
puts("");
if (jobcopies > 1)
sprintf(namestr, "%d copies of %s", jobcopies, jobname);
else
strcpy(namestr, jobname);
printf("%s: %-31s [job %d localhost]\n", jobuser, rankstr, jobid);
printf(" %-31.31s %d bytes\n", namestr, jobsize);
}
else
printf("%-6s %-10.10s %-15d %-27.27s %d bytes\n", rankstr, 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$".
*/
+96 -13
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lpr" command for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -23,7 +23,8 @@
*
* Contents:
*
* main() - Parse options and send files for printing.
* main() - Parse options and send files for printing.
* sighandler() - Signal catcher for when we print from stdin...
*/
/*
@@ -35,6 +36,25 @@
#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.
*/
@@ -45,20 +65,21 @@ main(int argc, /* I - Number of command-line arguments */
{
int i; /* Looping var */
int job_id; /* Job ID */
char *dest; /* Destination printer */
char *title; /* Job title */
int priority; /* Job priority (1-100) */
const char *dest; /* Destination printer */
const char *title; /* Job title */
int num_copies; /* Number of copies per file */
int num_files; /* Number of files printed */
int num_options; /* Number of options */
cups_option_t *options; /* Options */
int silent; /* Silent or verbose output? */
char tempfile[1024]; /* Temporary file for printing from stdin */
int deletefile; /* Delete file after print? */
char buffer[8192]; /* Copy buffer */
FILE *temp; /* Temporary file pointer */
#ifdef HAVE_SIGACTION
struct sigaction action; /* Signal action */
#endif /* HAVE_SIGACTION */
silent = 0;
deletefile = 0;
dest = cupsGetDefault();
num_options = 0;
options = NULL;
@@ -84,6 +105,16 @@ 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 = cupsParseOptions("raw", num_options, &options);
break;
@@ -96,10 +127,14 @@ main(int argc, /* I - Number of command-line arguments */
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')
dest = argv[i] + 2;
@@ -174,9 +209,12 @@ main(int argc, /* I - Number of command-line arguments */
if (job_id < 1)
{
fprintf(stderr, "lpr: unable to print file \'%s\'.\n", argv[i]);
fprintf(stderr, "lpr: unable to print file \'%s\' - %s.\n",
argv[i], ippErrorString(cupsLastError()));
return (1);
}
else if (deletefile)
unlink(argv[i]);
}
/*
@@ -191,7 +229,26 @@ main(int argc, /* I - Number of command-line arguments */
return (1);
}
temp = fopen(tmpnam(tempfile), "w");
#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");
if (temp == NULL)
{
@@ -207,7 +264,7 @@ main(int argc, /* I - Number of command-line arguments */
if (i == 0)
{
fputs("lpr: stdin is empty, so no job has been sent.\n", stderr);
fputs("lpr: standard input is empty, so no job has been sent.\n", stderr);
return (1);
}
@@ -216,9 +273,12 @@ main(int argc, /* I - Number of command-line arguments */
else
job_id = cupsPrintFile(dest, tempfile, "(stdin)", num_options, options);
unlink(tempfile);
if (job_id < 1)
{
fprintf(stderr, "lpr: unable to print file \'%s\'.\n", argv[i]);
fprintf(stderr, "lpr: unable to print standard input - %s.\n",
ippErrorString(cupsLastError()));
return (1);
}
}
@@ -227,6 +287,29 @@ main(int argc, /* I - Number of command-line arguments */
}
#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$".
*/
+29 -6
Ver Arquivo
@@ -3,7 +3,7 @@
*
* "lprm" command for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -49,7 +49,7 @@ 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 */
char *dest; /* Destination printer */
const char *dest; /* Destination printer */
char uri[1024]; /* Printer or job URI */
ipp_t *request; /* IPP request */
ipp_t *response; /* IPP response */
@@ -65,12 +65,13 @@ main(int argc, /* I - Number of command-line arguments */
job_id = 0;
dest = cupsGetDefault();
response = NULL;
http = NULL;
/*
* Open a connection to the server...
*/
if ((http = httpConnect("localhost", ippPort())) == NULL)
if ((http = httpConnect(cupsServer(), ippPort())) == NULL)
{
fputs("lprm: Unable to contact server!\n", stderr);
return (1);
@@ -146,7 +147,7 @@ main(int argc, /* I - Number of command-line arguments */
if (dest)
{
sprintf(uri, "http://localhost/printers/%s", dest);
snprintf(uri, sizeof(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",
@@ -154,11 +155,14 @@ main(int argc, /* I - Number of command-line arguments */
}
else
{
sprintf(uri, "http://localhost/jobs/%d", job_id);
sprintf(uri, "ipp://localhost/jobs/%d", job_id);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri", NULL,
uri);
}
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME,
"requesting-user-name", NULL, cupsUser());
/*
* Do the request and get back a response...
*/
@@ -169,7 +173,26 @@ 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);
+64 -10
Ver Arquivo
@@ -14,7 +14,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -24,9 +24,10 @@
include ../Makedefs
#TARGETS = classes.cgi jobs.cgi printers.cgi
TARGETS = printers.cgi
OBJS = classes.o jobs.o printers.o
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
#
# Make all targets...
@@ -34,29 +35,82 @@ OBJS = classes.o jobs.o printers.o
all: $(TARGETS)
#
# Clean all object files...
#
clean:
rm -f $(OBJS) $(TARGETS)
$(RM) $(OBJS) libcgi.a $(TARGETS)
#
# Install all targets...
#
install:
-$(MKDIR) $(SERVERROOT)/cgi-bin
$(CP) $(TARGETS) $(SERVERROOT)/cgi-bin
-$(MKDIR) $(SERVERBIN)/cgi-bin
$(CP) $(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
#
# classes.cgi
#
classes.cgi: classes.o ../Makedefs ../cups/$(LIBCUPS) libcgi.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
#
# jobs.cgi
#
jobs.cgi: jobs.o ../Makedefs ../cups/$(LIBCUPS) libcgi.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
#
# printers.cgi
#
printers.cgi: printers.o ../Makedefs ../cups/libcups.a
$(CC) $(LDFLAGS) -o $@ printers.o $(LIBS)
printers.cgi: printers.o ../Makedefs ../cups/$(LIBCUPS) libcgi.a
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ printers.o libcgi.a $(LIBS)
$(OBJS): ../Makedefs ../cups/cups.h ../cups/ipp.h ../cups/language.h
printers.o: cgi.h ipp-var.h ../cups/cups.h ../cups/ipp.h ../cups/language.h
$(OBJS): ../Makedefs
#
# End of "$Id$".
+888
Ver Arquivo
@@ -0,0 +1,888 @@
/*
* "$Id$"
*
* Administration CGI 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:
*
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
/*
* Local functions...
*/
static void do_am_class(http_t *http, cups_lang_t *language, int modify);
static void do_am_printer(http_t *http, cups_lang_t *language, int modify);
static void do_delete_class(http_t *http, cups_lang_t *language);
static void do_delete_printer(http_t *http, cups_lang_t *language);
static void do_job_op(http_t *http, cups_lang_t *language, ipp_op_t op);
static void do_printer_op(http_t *http, cups_lang_t *language, ipp_op_t op);
static void do_test_page(http_t *http, cups_lang_t *language);
/*
* 'main()' - Main entry for CGI.
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
cups_lang_t *language; /* Language information */
http_t *http; /* Connection to the server */
const char *op; /* Operation name */
/*
* Get the request language...
*/
language = cupsLangDefault();
/*
* Send a standard header...
*/
printf("Content-Type: text/html;charset=%s\n\n", cupsLangEncoding(language));
cgiSetVariable("TITLE", "Admin");
cgiSetVariable("SERVER_NAME", getenv("SERVER_NAME"));
cgiSetVariable("REMOTE_USER", getenv("REMOTE_USER"));
cgiSetVariable("CUPS_VERSION", CUPS_SVERSION);
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
/*
* See if we have form data...
*/
if (!cgiInitialize())
{
/*
* Nope, send the administration menu...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/admin.tmpl");
}
else if ((op = cgiGetVariable("OP")) != NULL)
{
/*
* Connect to the HTTP server...
*/
http = httpConnect("localhost", ippPort());
/*
* Do the operation...
*/
if (strcmp(op, "cancel-job") == 0)
do_job_op(http, language, IPP_CANCEL_JOB);
else if (strcmp(op, "hold-job") == 0)
do_job_op(http, language, IPP_HOLD_JOB);
else if (strcmp(op, "release-job") == 0)
do_job_op(http, language, IPP_RELEASE_JOB);
else if (strcmp(op, "restart-job") == 0)
do_job_op(http, language, IPP_RESTART_JOB);
else if (strcmp(op, "start-printer") == 0)
do_printer_op(http, language, IPP_RESUME_PRINTER);
else if (strcmp(op, "stop-printer") == 0)
do_printer_op(http, language, IPP_PAUSE_PRINTER);
else if (strcmp(op, "accept-jobs") == 0)
do_printer_op(http, language, CUPS_ACCEPT_JOBS);
else if (strcmp(op, "reject-jobs") == 0)
do_printer_op(http, language, CUPS_REJECT_JOBS);
else if (strcmp(op, "print-test-page") == 0)
do_test_page(http, language);
else if (strcmp(op, "add-class") == 0)
do_am_class(http, language, 0);
else if (strcmp(op, "add-printer") == 0)
do_am_printer(http, language, 0);
else if (strcmp(op, "modify-class") == 0)
do_am_class(http, language, 1);
else if (strcmp(op, "modify-printer") == 0)
do_am_printer(http, language, 1);
else if (strcmp(op, "delete-class") == 0)
do_delete_class(http, language);
else if (strcmp(op, "delete-printer") == 0)
do_delete_printer(http, language);
else
{
/*
* Bad operation code... Display an error...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/admin-op.tmpl");
}
/*
* Close the HTTP server connection...
*/
httpClose(http);
}
else
{
/*
* Form data but no operation code... Display an error...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/admin-op.tmpl");
}
/*
* Send the standard trailer...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Free the request language...
*/
cupsLangFree(language);
/*
* Return with no errors...
*/
return (0);
}
/*
* 'do_am_class()' - Add or modify a class.
*/
static void
do_am_class(http_t *http, /* I - HTTP connection */
cups_lang_t *language, /* I - Client's language */
int modify) /* I - Modify the printer? */
{
}
/*
* 'do_am_printer()' - Add or modify a printer.
*/
static void
do_am_printer(http_t *http, /* I - HTTP connection */
cups_lang_t *language, /* I - Client's language */
int modify) /* I - Modify the printer? */
{
int i; /* Looping var */
ipp_t *request, /* IPP request */
*response; /* IPP response */
ipp_status_t status; /* Request status */
const char *var; /* CGI variable */
char uri[HTTP_MAX_URI], /* Device or printer URI */
*uriptr; /* Pointer into URI */
int maxrate; /* Maximum baud rate */
char baudrate[255]; /* Baud rate string */
static int baudrates[] = /* Baud rates */
{
1200,
2400,
4800,
9600,
19200,
38400,
57600,
115200,
230400,
460800
};
if (cgiGetVariable("PRINTER_LOCATION") == NULL)
{
if (modify)
{
/*
* 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;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s",
cgiGetVariable("PRINTER_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, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
}
/*
* Update the location and description of an existing printer...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/modify-printer.tmpl");
}
else
{
/*
* Get the name, location, and description for a new printer...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/add-printer.tmpl");
}
}
else if ((var = cgiGetVariable("DEVICE_URI")) == NULL)
{
/*
* Build a CUPS_GET_DEVICES request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = CUPS_GET_DEVICES;
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, "ipp://localhost/printers/");
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
}
/*
* Let the user choose...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/choose-device.tmpl");
}
else if (strchr(var, '/') == NULL)
{
/*
* User needs to set the full URI...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/choose-uri.tmpl");
}
else if (strncmp(var, "serial:", 7) == 0 && cgiGetVariable("BAUDRATE") == NULL)
{
/*
* Need baud rate, parity, etc.
*/
if ((var = strchr(var, '?')) != NULL &&
strncmp(var, "?baud=", 6) == 0)
maxrate = atoi(var + 6);
else
maxrate = 19200;
for (i = 0; i < 10; i ++)
if (baudrates[i] > maxrate)
break;
else
{
sprintf(baudrate, "%d", baudrates[i]);
cgiSetArray("BAUDRATES", i, baudrate);
}
cgiCopyTemplateFile(stdout, TEMPLATES "/choose-serial.tmpl");
}
else if ((var = cgiGetVariable("PPD_NAME")) == NULL)
{
/*
* Build a CUPS_GET_PPDS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = CUPS_GET_PPDS;
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, "ipp://localhost/printers/");
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
}
/*
* Let the user choose...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/choose-model.tmpl");
}
else
{
/*
* Build a CUPS_ADD_PRINTER request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* printer-location
* printer-info
* ppd-name
* device-uri
* printer-is-accepting-jobs
* printer-state
*/
request = ippNew();
request->request.op.operation_id = CUPS_ADD_PRINTER;
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);
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s",
cgiGetVariable("PRINTER_NAME"));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-location",
NULL, cgiGetVariable("PRINTER_LOCATION"));
ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_TEXT, "printer-info",
NULL, cgiGetVariable("PRINTER_INFO"));
ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_NAME, "ppd-name",
NULL, cgiGetVariable("PPD_NAME"));
strcpy(uri, cgiGetVariable("DEVICE_URI"));
if (strncmp(uri, "serial:", 7) == 0)
{
/*
* Update serial port URI to include baud rate, etc.
*/
if ((uriptr = strchr(uri, '?')) == NULL)
uriptr = uri + strlen(uri);
sprintf(uriptr, "?baud=%s+bits=%s+parity=%s+flow=%s",
cgiGetVariable("BAUDRATE"), cgiGetVariable("BITS"),
cgiGetVariable("PARITY"), cgiGetVariable("FLOW"));
}
ippAddString(request, IPP_TAG_PRINTER, IPP_TAG_URI, "device-uri",
NULL, uri);
ippAddBoolean(request, IPP_TAG_PRINTER, "printer-is-accepting-jobs", 1);
ippAddInteger(request, IPP_TAG_PRINTER, IPP_TAG_ENUM, "printer-state",
IPP_PRINTER_IDLE);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/admin/")) != NULL)
{
status = response->request.status.status_code;
ippDelete(response);
}
else
status = IPP_NOT_AUTHORIZED;
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
}
else if (modify)
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-modified.tmpl");
else
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-added.tmpl");
}
}
/*
* 'do_delete_class()' - Delete a class...
*/
static void
do_delete_class(http_t *http, /* I - HTTP connection */
cups_lang_t *language) /* I - Client's language */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
char uri[HTTP_MAX_URI]; /* Job URI */
const char *pclass; /* Printer class name */
ipp_status_t status; /* Operation status... */
if (cgiGetVariable("CONFIRM") == NULL)
{
cgiCopyTemplateFile(stdout, TEMPLATES "/class-confirm.tmpl");
return;
}
if ((pclass = cgiGetVariable("PRINTER_NAME")) != NULL)
snprintf(uri, sizeof(uri), "ipp://localhost/classes/%s", pclass);
else
{
cgiSetVariable("ERROR", ippErrorString(IPP_NOT_FOUND));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
return;
}
/*
* Build a CUPS_DELETE_CLASS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = CUPS_DELETE_CLASS;
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);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/admin/")) != NULL)
{
status = response->request.status.status_code;
ippDelete(response);
}
else
status = IPP_GONE;
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
}
else
cgiCopyTemplateFile(stdout, TEMPLATES "/class-deleted.tmpl");
}
/*
* 'do_delete_printer()' - Delete a printer...
*/
static void
do_delete_printer(http_t *http, /* I - HTTP connection */
cups_lang_t *language)/* I - Client's language */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
char uri[HTTP_MAX_URI]; /* Job URI */
const char *printer; /* Printer printer name */
ipp_status_t status; /* Operation status... */
if (cgiGetVariable("CONFIRM") == NULL)
{
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-confirm.tmpl");
return;
}
if ((printer = cgiGetVariable("PRINTER_NAME")) != NULL)
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", printer);
else
{
cgiSetVariable("ERROR", ippErrorString(IPP_NOT_FOUND));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
return;
}
/*
* Build a CUPS_DELETE_PRINTER request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = CUPS_DELETE_PRINTER;
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);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/admin/")) != NULL)
{
status = response->request.status.status_code;
ippDelete(response);
}
else
status = IPP_GONE;
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
}
else
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-deleted.tmpl");
}
/*
* 'do_job_op()' - Do a job operation.
*/
static void
do_job_op(http_t *http, /* I - HTTP connection */
cups_lang_t *language, /* I - Client's language */
ipp_op_t op) /* I - Operation to perform */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
char uri[HTTP_MAX_URI]; /* Job URI */
const char *job; /* Job ID */
const char *printer; /* Printer name (purge-jobs) */
ipp_status_t status; /* Operation status... */
if ((job = cgiGetVariable("JOB_ID")) != NULL)
snprintf(uri, sizeof(uri), "ipp://localhost/jobs/%s", job);
else if ((printer = cgiGetVariable("PRINTER_NAME")) != NULL)
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", printer);
else
{
cgiSetVariable("ERROR", ippErrorString(IPP_NOT_FOUND));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
return;
}
/*
* Build a job request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* job-uri or printer-uri (purge-jobs)
* requesting-user-name
*/
request = ippNew();
request->request.op.operation_id = op;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
if (job)
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "job-uri",
NULL, uri);
else
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");
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/jobs")) != NULL)
{
status = response->request.status.status_code;
ippDelete(response);
}
else
status = IPP_GONE;
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
}
else if (op == IPP_CANCEL_JOB)
cgiCopyTemplateFile(stdout, TEMPLATES "/job-cancel.tmpl");
else if (op == IPP_HOLD_JOB)
cgiCopyTemplateFile(stdout, TEMPLATES "/job-hold.tmpl");
else if (op == IPP_RELEASE_JOB)
cgiCopyTemplateFile(stdout, TEMPLATES "/job-release.tmpl");
}
/*
* 'do_printer_op()' - Do a printer operation.
*/
static void
do_printer_op(http_t *http, /* I - HTTP connection */
cups_lang_t *language, /* I - Client's language */
ipp_op_t op) /* I - Operation to perform */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
char uri[HTTP_MAX_URI]; /* Printer URI */
const char *printer; /* Printer name (purge-jobs) */
ipp_status_t status; /* Operation status... */
if ((printer = cgiGetVariable("PRINTER_NAME")) != NULL)
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", printer);
else
{
cgiSetVariable("ERROR", ippErrorString(IPP_NOT_FOUND));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
return;
}
/*
* Build a printer request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
request = ippNew();
request->request.op.operation_id = op;
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);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/admin/")) != NULL)
{
status = response->request.status.status_code;
ippDelete(response);
}
else
status = IPP_GONE;
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
}
else if (op == IPP_PAUSE_PRINTER)
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-stop.tmpl");
else if (op == IPP_RESUME_PRINTER)
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-start.tmpl");
else if (op == CUPS_ACCEPT_JOBS)
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-accept.tmpl");
else if (op == CUPS_REJECT_JOBS)
cgiCopyTemplateFile(stdout, TEMPLATES "/printer-reject.tmpl");
}
/*
* 'do_test_page()' - Send a test page.
*/
static void
do_test_page(http_t *http, /* I - HTTP connection */
cups_lang_t *language) /* I - Client's language */
{
ipp_t *request, /* IPP request */
*response; /* IPP response */
char uri[HTTP_MAX_URI]; /* Job URI */
const char *printer; /* Printer name (purge-jobs) */
ipp_status_t status; /* Operation status... */
if ((printer = cgiGetVariable("PRINTER_NAME")) != NULL)
snprintf(uri, sizeof(uri), "ipp://localhost/printers/%s", printer);
else
{
cgiSetVariable("ERROR", ippErrorString(IPP_NOT_FOUND));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
return;
}
/*
* Build an IPP_PRINT_JOB request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
* requesting-user-name
* document-format
*/
request = ippNew();
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
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);
ippDelete(response);
}
else
status = IPP_GONE;
if (status > IPP_OK_CONFLICT)
{
cgiSetVariable("ERROR", ippErrorString(status));
cgiCopyTemplateFile(stdout, TEMPLATES "/error.tmpl");
}
else
cgiCopyTemplateFile(stdout, TEMPLATES "/test-page.tmpl");
}
/*
* End of "$Id$".
*/
+81
Ver Arquivo
@@ -0,0 +1,81 @@
/*
* "$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 *template);
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);
# define cgiGetUser() getenv("REMOTE_USER")
# define cgiGetHost() (getenv("REMOTE_HOST") == NULL ? getenv("REMOTE_ADDR") : getenv("REMOTE_HOST"))
#endif /* !_CGI_H_ */
/*
* End of "$Id$".
*/
+221
Ver Arquivo
@@ -0,0 +1,221 @@
/*
* "$Id$"
*
* Class status CGI 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:
*
* main() - Main entry for CGI.
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
/*
* 'main()' - Main entry for CGI.
*/
int /* O - Exit status */
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 */
http_t *http; /* Connection to the server */
ipp_t *request, /* IPP request */
*response; /* IPP response */
char uri[HTTP_MAX_URI];
/* Printer URI */
const char *which_jobs; /* Which jobs to show */
/*
* Get any form variables...
*/
cgiInitialize();
/*
* Get the request language...
*/
language = cupsLangDefault();
/*
* Connect to the HTTP server...
*/
http = httpConnect("localhost", ippPort());
/*
* Tell the client to expect HTML...
*/
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...
*/
pclass = argv[0];
if (strcmp(pclass, "/") == 0 || strcmp(pclass, "classes.cgi") == 0)
{
pclass = NULL;
cgiSetVariable("TITLE", "Classes");
}
else
cgiSetVariable("TITLE", pclass);
/*
* 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 (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);
ippDelete(response);
}
/*
* Write the report...
*/
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
cgiCopyTemplateFile(stdout, TEMPLATES "/classes.tmpl");
/*
* Get jobs for the specified class if a class has been chosen...
*/
if (pclass != NULL)
{
/*
* Build an IPP_GET_JOBS request, which requires the following
* attributes:
*
* attributes-charset
* attributes-natural-language
* printer-uri
*/
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);
ippDelete(response);
cgiCopyTemplateFile(stdout, TEMPLATES "/jobs.tmpl");
}
}
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Close the HTTP server connection...
*/
httpClose(http);
cupsLangFree(language);
/*
* Return with no errors...
*/
return (0);
}
/*
* End of "$Id$".
*/
+89
Ver Arquivo
@@ -0,0 +1,89 @@
/*
* "$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$".
*/
+175
Ver Arquivo
@@ -0,0 +1,175 @@
/*
* "$Id$"
*
* IPP variable routines for the Common UNIX Printing System (CUPS).
*
* 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
* 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:
*
* ippSetCGIVars() - Set CGI variables from an IPP response.
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
/*
* 'ippSetCGIVars()' - Set CGI variables from an IPP response.
*/
void
ippSetCGIVars(ipp_t *response) /* I - Response data to be copied... */
{
int element; /* Element in CGI array */
ipp_attribute_t *attr; /* Attribute in response... */
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;
cgiSetVariable("SERVER_NAME", getenv("SERVER_NAME"));
cgiSetVariable("REMOTE_USER", getenv("REMOTE_USER"));
cgiSetVariable("CUPS_VERSION", CUPS_SVERSION);
for (attr = response->attrs;
attr && attr->group_tag == IPP_TAG_OPERATION;
attr = attr->next);
for (element = 0; attr != NULL; attr = attr->next, element ++)
{
/*
* Copy attributes to a separator...
*/
/* puts("<HR>");*/
for (; attr != NULL && attr->group_tag != IPP_TAG_ZERO; attr = attr->next)
{
/*
* Copy the attribute name, substituting "_" for "-"...
*/
if (attr->name == NULL)
continue;
/* printf("<P>%s\n", attr->name);*/
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 (strncmp(attr->values[i].string.text, "ipp:", 4) == 0)
{
httpSeparate(attr->values[i].string.text, method, username,
hostname, &port, resource);
if (username[0])
snprintf(uri, sizeof(uri), "http://%s@%s:%d%s", username,
hostname, port, resource);
else
snprintf(uri, sizeof(uri), "http://%s:%d%s", hostname, port,
resource);
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;
}
}
/*
* Add the element...
*/
cgiSetArray(name, element, value);
}
if (attr == NULL)
break;
}
}
/*
* End of "$Id$".
*/
+54
Ver Arquivo
@@ -0,0 +1,54 @@
/*
* "$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 "/home/mike/c/cups/templates"*/
#define TEMPLATES CUPS_DATADIR "/templates"
/*
* Prototype...
*/
extern void ippSetCGIVars(ipp_t *response);
/*
* End of "$Id$".
*/
+140
Ver Arquivo
@@ -0,0 +1,140 @@
/*
* "$Id$"
*
* Job status CGI 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:
*
* main() - Main entry for CGI.
*/
/*
* Include necessary headers...
*/
#include "ipp-var.h"
/*
* 'main()' - Main entry for CGI.
*/
int /* O - Exit status */
main(int argc, /* I - Number of command-line arguments */
char *argv[]) /* I - Command-line arguments */
{
cups_lang_t *language; /* Language information */
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();
/*
* Get the request language...
*/
language = cupsLangDefault();
/*
* Connect to the HTTP server...
*/
http = httpConnect("localhost", ippPort());
/*
* Tell the client to expect HTML...
*/
printf("Content-Type: text/html;charset=%s\n\n", cupsLangEncoding(language));
cgiSetVariable("TITLE", "Jobs");
cgiSetVariable("SERVER_NAME", getenv("SERVER_NAME"));
cgiSetVariable("REMOTE_USER", getenv("REMOTE_USER"));
cgiSetVariable("CUPS_VERSION", CUPS_SVERSION);
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
/*
* 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;
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);
/*
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
cgiCopyTemplateFile(stdout, TEMPLATES "/jobs.tmpl");
}
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Close the HTTP server connection...
*/
httpClose(http);
cupsLangFree(language);
/*
* Return with no errors...
*/
return (0);
}
/*
* End of "$Id$".
*/
+117 -357
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Printer status CGI for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -23,30 +23,14 @@
*
* Contents:
*
* main() - Main entry for CGI.
* show_printer_list() - Show a list of printers...
* show_printer_info() - Show printer information.
* main() - Main entry for CGI.
*/
/*
* Include necessary headers...
*/
#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);
#include "ipp-var.h"
/*
@@ -60,9 +44,19 @@ 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 */
char uri[HTTP_MAX_URI];
/* Printer URI */
const char *which_jobs; /* Which jobs to show */
/*
* Get any form variables...
*/
cgiInitialize();
setbuf(stdout, NULL);
/*
* Get the request language...
*/
@@ -88,72 +82,124 @@ main(int argc, /* I - Number of command-line arguments */
printer = argv[0];
if (strcmp(printer, "/") == 0 || strcmp(printer, "printers.cgi") == 0)
{
printer = NULL;
/*
* Print the standard header...
*/
puts("<HTML>");
puts("<HEAD>");
if (printer)
puts("<META HTTP-EQUIV=\"Refresh\" CONTENT=\"10\">");
cgiSetVariable("TITLE", "Printers");
}
else
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,100,35\" HREF=\"/printers\" ALT=\"Current Printer Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"115,10,205,35\" HREF=\"/classes\" ALT=\"Current Printer Classes Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"220,10,280,35\" HREF=\"/jobs\" ALT=\"Current Jobs Status\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"295,10,470,35\" HREF=\"/documentation.html\" ALT=\"Read CUPS Documentation On-Line\">");
puts("<AREA SHAPE=\"RECT\" COORDS=\"485,10,590,35\" 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>");
printf("<H1>%s on %s</H1>\n", printer == NULL ? "Printers" : printer,
getenv("SERVER_NAME"));
fflush(stdout);
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>");
cgiSetVariable("TITLE", printer);
/*
* Show the information...
* 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)
show_printer_list(http, language);
{
/*
* 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
show_printer_info(http, language, printer);
{
/*
* 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);
}
/*
* Write a standard trailer...
* Do the request and get back a response...
*/
puts("</TABLE>");
puts("</CENTER>");
if ((response = cupsDoRequest(http, request, "/")) != NULL)
{
ippSetCGIVars(response);
ippDelete(response);
}
puts("<HR>");
/*
* Write the report...
*/
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.");
cgiCopyTemplateFile(stdout, TEMPLATES "/header.tmpl");
cgiCopyTemplateFile(stdout, TEMPLATES "/printers.tmpl");
puts("</BODY>");
puts("</HTML>");
/*
* 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);
ippDelete(response);
cgiCopyTemplateFile(stdout, TEMPLATES "/jobs.tmpl");
}
}
cgiCopyTemplateFile(stdout, TEMPLATES "/trailer.tmpl");
/*
* Close the HTTP server connection...
@@ -170,292 +216,6 @@ 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;
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
attr = 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[1024]; /* 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)
{
/*
* 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;
/*
* 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;
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL,
cupsLangEncoding(language));
attr = ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL,
language->language);
attr = 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$".
*/
+364
Ver Arquivo
@@ -0,0 +1,364 @@
/*
* "$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.
* 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 *template) /* I - Template file to read */
{
FILE *in; /* Input file */
/*
* Open the template file...
*/
if ((in = fopen(template, "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 */
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
*s++ = ch;
*s = '\0';
/*
* See if it has a value...
*/
if (name[0] == '?')
{
/*
* Insert value only if it exists...
*/
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 ((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 != '}')
*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))) == 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;
}
}
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$".
*/
+654
Ver Arquivo
@@ -0,0 +1,654 @@
/*
* "$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
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$".
*/
+20 -7
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Configuration file makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1993-1999 by Easy Software Products.
# Copyright 1993-2000 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -28,7 +28,9 @@ include ../Makedefs
# Config files...
#
FILES = classes.conf cupsd.conf mime.convs mime.types printers.conf
KEEP = classes.conf client.conf cupsd.conf printers.conf
REPLACE = mime.convs mime.types
#
# Make everything...
@@ -36,25 +38,36 @@ FILES = classes.conf cupsd.conf mime.convs mime.types printers.conf
all:
#
# Clean all config and object files...
#
clean:
#
# Install files...
#
install:
-$(MKDIR) $(SERVERROOT)/conf
for file in $(FILES); do \
if test -e $(SERVERROOT)/conf/$$file ; then \
$(CP) $$file $(SERVERROOT)/conf/$$file.N ; \
-$(MKDIR) $(SERVERROOT)
for file in $(KEEP); do \
if test -r $(SERVERROOT)/$$file ; then \
$(CP) $$file $(SERVERROOT)/$$file.N ; \
else \
$(CP) $$file $(SERVERROOT)/conf ; \
$(CP) $$file $(SERVERROOT) ; \
fi ; \
done
for file in $(REPLACE); do \
if test -r $(SERVERROOT)/$$file ; then \
$(MV) $(SERVERROOT)/$$file $(SERVERROOT)/$$file.O ; \
fi ; \
$(CP) $$file $(SERVERROOT) ; \
done
if test -r /etc/printcap -a ! -r /etc/printcap.O; then \
$(CP) /etc/printcap /etc/printcap.O ; \
fi
#
# End of "$Id$".
+27 -4
Ver Arquivo
@@ -1,10 +1,10 @@
#
# "$Id: classes.conf 333 1999-05-17 18:03:40Z mike $"
# "$Id: classes.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample class configuration file for the Common UNIX Printing System
# (CUPS) scheduler.
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -15,7 +15,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -59,6 +59,29 @@
#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.
#
@@ -68,5 +91,5 @@
#</Class>
#
# End of "$Id: classes.conf 333 1999-05-17 18:03:40Z mike $".
# End of "$Id: classes.conf 969 2000-03-10 16:56:46Z mike $".
#
+50
Ver Arquivo
@@ -0,0 +1,50 @@
#
# "$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 $".
#
+174 -24
Ver Arquivo
@@ -1,10 +1,10 @@
#
# "$Id: cupsd.conf 349 1999-05-21 20:53:02Z mike $"
# "$Id: cupsd.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample configuration file for the Common UNIX Printing System (CUPS)
# scheduler.
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -15,7 +15,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -53,6 +53,13 @@
#Port 80
Port 631
#
# MaxClients: controls the maximum number of simultaneous clients that
# will be handled. Defaults to 100.
#
#MaxClients 100
#
# User/Group: the user and group the server runs under. Normally this
# must be lp and sys, however you can configure things for another user
@@ -63,20 +70,23 @@ Port 631
# program is run...
#
User lp
Group sys
#User lp
#Group sys
#
# SystemGroup: the group name for "System" (printer administration)
# access.
# access. The default varies depending on the operating system, but
# will be "sys", "system", or "root" (checked for in that order.)
#
SystemGroup sys
#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 name used by clients, see the client.conf file.
#
#ServerName myhost.domain.com
@@ -89,15 +99,39 @@ SystemGroup sys
#
# ServerRoot: the root directory for the scheduler.
# By default the compiled-in value.
# By default /etc/cups.
#
#ServerRoot /var/cups
#ServerRoot /etc/cups
#
# ServerBin: the root directory for the scheduler executables.
# By default /usr/lib/cups.
#
#ServerBin /usr/lib/cups
#
# DocumentRoot: the root directory for the HTTP server.
# By default /usr/share/doc/cups.
#
#DocumentRoot /usr/share/doc/cups
#
# RequestRoot: the directory where request files are stored.
# By default /var/spool/cups.
#
#RequestRoot /var/spool/cups
#
# AccessLog: the access log file; if this does not start with a leading /
# then it is assumed to be relative to ServerRoot. By default set to
# "logs/access_log"
# "/var/log/cups/access_log"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
#
#AccessLog logs/access_log
@@ -107,16 +141,22 @@ SystemGroup sys
# then it is assumed to be relative to ServerRoot. By default set to
# "logs/error_log"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
#
#ErrorLog logs/error_log
#ErrorLog /var/log/cups/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"
#
# You can also use the special name "syslog" to send the output to the
# syslog file or daemon.
#
#PageLog logs/page_log
#PageLog /var/log/cups/page_log
#
# LogLevel: controls the number of messages logged to the ErrorLog
@@ -139,8 +179,8 @@ LogLevel info
#MaxLogSize 0
#
# MaxRequestSize: controls the maximum size of print files. Set to 0 to
# disable this feature (defaults to 0.)
# MaxRequestSize: controls the maximum size of HTTP requests and print files.
# Set to 0 to disable this feature (defaults to 0.)
#
#MaxRequestSize 0
@@ -205,6 +245,9 @@ LogLevel info
# 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
@@ -238,6 +281,54 @@ LogLevel info
#BrowseAddress x.y.255.255
#BrowseAddress x.255.255.255
#
# BrowseOrder: specifies the order of
#
#BrowseOrder allow,deny
#BrowseOrder deny,allow
#
# 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
#
# BrowseRelay: relay browser packets from one address/network to another.
#
#BrowseRelay source-address destination-address
#
# BrowsePoll: poll the named server for printers
#
#BrowsePoll address:port
#
# DocumentRoot: the root directory for HTTP documents that are served.
# By default the compiled in directory.
@@ -254,27 +345,62 @@ LogLevel info
#
# DefaultCharset: the default character set to use. If not specified,
# defaults to iso-8859-1. Note that this can also be overridden in
# defaults to utf-8. Note that this can also be overridden in
# HTML documents...
#
#DefaultCharset iso-8859-1
#DefaultCharset utf-8
#
# RIPCache: the amount of memory that each RIP should use to cache
# bitmaps. The value can be any real number followed by "k" for
# kilobytes, "m" for megabytes, "g" for gigabytes, or "t" for tiles
# (1 tile = 256x256 pixels.) Defaults to "32m" (32 megabytes).
# (1 tile = 256x256 pixels.) Defaults to "8m" (8 megabytes).
#
#RIPCache: 32m
#RIPCache 8m
#
# TempDir: the directory to put temporary files in. This directory must be
# writable by the user defined above! Defaults to "/var/tmp" or the value
# of the TMPDIR environment variable.
#
#TempDir /var/tmp
#
# PreserveJobHistory: whether or not to preserve the job history after a
# job is completed, cancelled, or stopped. Default is Yes.
#
#PreserveJobHistory Yes
#
# PreserveJobFiles: whether or not to preserve the job files after a
# job is completed, cancelled, or stopped. Default is No.
#
#PreserveJobFiles No
#
# Printcap: the name of the printcap file. Default is /etc/printcap.
# Leave blank to disable printcap file generation.
#
#Printcap /etc/printcap
#
# Access permissions for each directory served by the scheduler.
# Locations are relative to DocumentRoot...
#
# AuthType: the authorization to use; currently only "Basic" authorization is
# supported.
# 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)
#
# AuthClass: the authorization class; currently only "Anonymous", "User",
# "System" (valid user belonging to group SystemGroup), and "Group"
@@ -290,6 +416,23 @@ LogLevel info
# 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>
@@ -300,10 +443,17 @@ LogLevel info
# and Deny lines, or by requiring a username and password.
#
## Require a username and password
## Anonymous access (default)
#AuthType None
## Require a username and password (Basic authentication)
#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
@@ -314,8 +464,8 @@ LogLevel info
#
# 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.
# is a member of the system group to do any admin tasks. You can change
# the group name using the SystemGroup directive.
#
AuthType Basic
@@ -328,5 +478,5 @@ Allow From 127.0.0.1
</Location>
#
# End of "$Id: cupsd.conf 349 1999-05-21 20:53:02Z mike $".
# End of "$Id: cupsd.conf 969 2000-03-10 16:56:46Z mike $".
#
+4 -4
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: mime.convs 237 1999-04-21 19:29:35Z mike $"
# "$Id: mime.convs 575 1999-07-30 13:57:16Z mike $"
#
# MIME converts file for the Common UNIX Printing System (CUPS).
#
@@ -41,12 +41,12 @@
# PostScript filters
#
application/msword application/postscript 50 mswordtops
#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/html application/postscript 50 htmltops
text/plain application/postscript 50 texttops
########################################################################
@@ -58,5 +58,5 @@ image/* application/vnd.cups-raster 50 imagetoraster
application/vnd.cups-postscript application/vnd.cups-raster 50 pstoraster
#
# End of "$Id: mime.convs 237 1999-04-21 19:29:35Z mike $".
# End of "$Id: mime.convs 575 1999-07-30 13:57:16Z mike $".
#
+5 -6
Ver Arquivo
@@ -1,5 +1,5 @@
#
# "$Id: mime.types 185 1999-03-24 18:38:50Z mike $"
# "$Id: mime.types 575 1999-07-30 13:57:16Z mike $"
#
# MIME types file for the Common UNIX Printing System (CUPS).
#
@@ -92,10 +92,9 @@ 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
# TODO: Add Sun Raster, Alias, SoftImage, GIMP??? files
image/x-sun-raster ras
# TODO: Add Alias, SoftImage, GIMP??? files
#image/x-alias pix
#image/x-softimage
#image/x-gimp-xcf xcf xcf.gz
@@ -114,10 +113,10 @@ text/plain txt printable(0,1024)
# CUPS-specific types...
#
application/vnd.cups-postscript
application/vnd.cups-postscript string(0,<1B>%-12345X)
application/vnd.cups-raster string(0,"RaSt") string(0,"tSaR")
application/vnd.cups-raw
#
# End of "$Id: mime.types 185 1999-03-24 18:38:50Z mike $".
# End of "$Id: mime.types 575 1999-07-30 13:57:16Z mike $".
#
+2
Ver Arquivo
@@ -0,0 +1,2 @@
# This is a dummy printcap file that is automatically generated by the
# CUPS software for old applications that rely on it.
+18 -5
Ver Arquivo
@@ -1,10 +1,10 @@
#
# "$Id: printers.conf 334 1999-05-17 18:11:26Z mike $"
# "$Id: printers.conf 969 2000-03-10 16:56:46Z mike $"
#
# Sample printer configuration file for the Common UNIX Printing System
# (CUPS) scheduler.
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -15,7 +15,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -77,13 +77,26 @@
# State: sets the initial state of the printer. Can be one of the
# following:
#
# Idle - Printer is available to accept new jobs.
# Idle - Printer is available to print 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 334 1999-05-17 18:11:26Z mike $".
# End of "$Id: printers.conf 969 2000-03-10 16:56:46Z mike $".
#
+32 -6
Ver Arquivo
@@ -5,7 +5,7 @@
*
* @configure_input@
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -16,7 +16,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -28,15 +28,20 @@
* Version of software...
*/
#define CUPS_SVERSION "CUPS v1.0"
#define CUPS_SVERSION "CUPS v1.1b2"
/*
* Where are files stored?
*/
#define CUPS_LOCALEDIR "/usr/lib/locale"
#define CUPS_SERVERROOT "/var/cups"
#define CUPS_DATADIR "/usr/share/cups"
#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"
/*
* Do we have various image libraries?
@@ -62,6 +67,14 @@
#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>?
*/
@@ -82,6 +95,19 @@
#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?
*/
+258 -42
Ver Arquivo
@@ -3,7 +3,7 @@ dnl "$Id$"
dnl
dnl Configuration script for the Common UNIX Printing System (CUPS).
dnl
dnl Copyright 1997-1999 by Easy Software Products, all rights reserved.
dnl Copyright 1997-2000 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
@@ -14,7 +14,7 @@ dnl at:
dnl
dnl Attn: CUPS Licensing Information
dnl Easy Software Products
dnl 44145 Airport View Drive, Suite 204
dnl 44141 Airport View Drive, Suite 204
dnl Hollywood, Maryland 20636-3111 USA
dnl
dnl Voice: (301) 373-9603
@@ -26,18 +26,69 @@ AC_INIT(cups/cups.h)
AC_CONFIG_HEADER(config.h)
AC_PREFIX_DEFAULT(/usr)
dnl Clear default debugging options and set normal optimization by
dnl default unless the user asks for debugging specifically.
dnl Get the operating system and version number...
CFLAGS="${CFLAGS:=}"
CXXFLAGS="${CXXFLAGS:=}"
OPTIM="-O"
uname=`uname`
uversion=`uname -r | sed -e '1,$s/[[^0-9]]//g'`
if test "$uname" = "IRIX64"; then
uname="IRIX"
fi
dnl Clear the debugging and non-shared library options unless the user asks
dnl for them...
OPTIM=""
AC_SUBST(OPTIM)
PICFLAG=1
CFLAGS="${CFLAGS:=}"
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(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]])
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
AC_ARG_ENABLE(pam, [ --enable-pam turn on PAM support [default=yes]])
dnl Checks for programs...
AC_PROG_AWK
@@ -45,50 +96,88 @@ AC_PROG_CC
AC_PROG_CPP
AC_PROG_RANLIB
AC_PATH_PROG(AR,ar)
AC_PATH_PROG(CHMOD,chmod)
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
NROFF="echo"
else
NROFF="$GROFF -T ascii"
fi
fi
AC_PATH_PROG(HTMLDOC,htmldoc)
AC_PATH_PROG(MKDIR,mkdir)
AC_PATH_PROG(RM,rm)
AC_PATH_PROG(GROFF,groff)
AC_PATH_PROG(HTMLDOC,htmldoc)
AC_PATH_PROG(SED,sed)
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",AC_CHECK_LIB(crypt,crypt))
AC_CHECK_HEADER(crypt.h, AC_DEFINE(HAVE_CRYPT_H))
AC_CHECK_LIB(sec,getspent)
if test "$enable_pam" != "no"; then
AC_CHECK_LIB(dl,dlopen)
AC_CHECK_LIB(pam,pam_start)
fi
NETLIBS=""
AC_SUBST(NETLIBS)
AC_CHECK_LIB(socket,socket,
if test "$uname" != "IRIX"; then
LIBS="$LIBS -lsocket"
NETLIBS="-lsocket"
else
echo "Not using -lsocket since you are running IRIX."
fi)
AC_CHECK_LIB(nsl,gethostbyaddr,
if test "$uname" != "IRIX"; then
LIBS="$LIBS -lnsl"
NETLIBS="$NETLIBS -lnsl"
else
echo "Not using -lnsl since you are running IRIX."
fi)
IMGLIBS=""
AC_SUBST(IMGLIBS)
AC_CHECK_HEADER(jpeglib.h,
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,
AC_DEFINE(HAVE_LIBJPEG)
IMGLIBS="$IMGLIBS -ljpeg")
AC_CHECK_HEADER(zlib.h,
LIBJPEG="-ljpeg"
LIBS="$LIBS -ljpeg")
AC_CHECK_LIB(z, deflate,
AC_DEFINE(HAVE_LIBZ)
IMGLIBS="$IMGLIBS -lz")
AC_CHECK_HEADER(png.h,
LIBZ="-lz"
LIBS="$LIBS -lz")
dnl PNG library uses math library functions...
AC_CHECK_LIB(m, pow)
AC_CHECK_LIB(png, png_read_info,
AC_DEFINE(HAVE_LIBPNG)
IMGLIBS="$IMGLIBS -lpng")
AC_CHECK_HEADER(tiff.h,
LIBPNG="-lpng")
AC_CHECK_LIB(tiff, TIFFReadScanline,
AC_DEFINE(HAVE_LIBTIFF)
IMGLIBS="$IMGLIBS -ltiff")
LIBTIFF="-ltiff")
dnl Restore original LIBS settings...
LIBS="$SAVELIBS"
dnl Checks for header files.
AC_HEADER_STDC
@@ -99,6 +188,11 @@ 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.
AC_CHECK_FUNCS(sigset)
@@ -108,30 +202,152 @@ dnl Checks for wait functions.
AC_CHECK_FUNCS(waitpid)
AC_CHECK_FUNCS(wait3)
dnl Fix "prefix" variable if it hasn't been specified...
if test "$prefix" = "NONE"; then
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 HP-UX and Solaris run-time linkers are EXTREMELY stupid when
# it comes to deciding where to find a DSO. Add linker options to
# tell them where to find the DSO (usually in /usr/lib... duh!)
case $uname in
HP-UX*)
LDFLAGS="$LDFLAGS -Wl,+b,$libdir,+fb"
;;
SunOS*)
# Solaris
LDFLAGS="-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)
dnl Fix prefix as needed..
if test "$prefix" = "NONE" ; then
prefix="/usr"
fi
dnl CUPS_SERVERROOT needs special attention for the default location...
if test "$prefix" = "/usr"; then
CUPS_SERVERROOT="/var/cups"
else
CUPS_SERVERROOT="$prefix/var/cups"
dnl Fix "libdir" variable for IRIX 6.x...
if test "$uname" = "IRIX" -a $uversion -ge 65; then
libdir="${prefix}/lib32"
fi
AC_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$CUPS_SERVERROOT")
dnl Need special attention for the default location...
if test "$prefix" = "/usr" ; then
CUPS_SERVERROOT="/etc/cups"
CUPS_LOGDIR="/var/log/cups"
CUPS_REQUESTS="/var/spool/cups"
AC_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$CUPS_SERVERROOT")
AC_DEFINE_UNQUOTED(CUPS_LOGDIR, "$CUPS_LOGDIR")
AC_DEFINE_UNQUOTED(CUPS_REQUESTS, "$CUPS_REQUESTS")
else
CUPS_SERVERROOT='${prefix}/etc/cups'
CUPS_LOGDIR='${prefix}/log/cups'
CUPS_REQUESTS='${prefix}/spool/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERROOT, "$prefix/etc/cups")
AC_DEFINE_UNQUOTED(CUPS_LOGDIR, "$prefix/log/cups")
AC_DEFINE_UNQUOTED(CUPS_REQUESTS, "$prefix/spool/cups")
fi
CUPS_SERVERBIN='${prefix}/lib/cups'
AC_DEFINE_UNQUOTED(CUPS_SERVERBIN, "$prefix/lib/cups")
AC_SUBST(CUPS_SERVERROOT)
AC_SUBST(CUPS_SERVERBIN)
AC_SUBST(CUPS_LOGDIR)
AC_SUBST(CUPS_REQUESTS)
dnl Set the CUPS_LOCALE directory...
CUPS_LOCALEDIR="$prefix/lib/locale"
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$CUPS_LOCALEDIR")
case "$uname" in
Linux)
CUPS_LOCALEDIR='${prefix}/share/locale'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$prefix/share/locale")
;;
OSF1)
CUPS_LOCALEDIR='${prefix}/lib/nls/msg'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$prefix/lib/nls/msg")
;;
*)
# This is the standard System V location...
CUPS_LOCALEDIR='${prefix}/lib/locale'
AC_DEFINE_UNQUOTED(CUPS_LOCALEDIR, "$prefix/lib/locale")
;;
esac
AC_SUBST(CUPS_LOCALEDIR)
dnl Set the CUPS_DATAFILE directory...
CUPS_DATADIR="$prefix/share/cups"
AC_DEFINE_UNQUOTED(CUPS_DATADIR, "$CUPS_DATADIR")
dnl Set the CUPS_DATADIR directory...
CUPS_DATADIR='${datadir}/cups'
AC_DEFINE_UNQUOTED(CUPS_DATADIR, "$prefix/share/cups")
AC_SUBST(CUPS_DATADIR)
dnl Set the CUPS_DOCDIR directory...
CUPS_DOCDIR='${datadir}/doc/cups'
AC_DEFINE_UNQUOTED(CUPS_DOCDIR, "$prefix/share/doc/cups")
AC_SUBST(CUPS_DOCDIR)
AC_OUTPUT(Makedefs)
dnl
+15
Ver Arquivo
@@ -15,6 +15,21 @@ 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>
+426
Ver Arquivo
@@ -0,0 +1,426 @@
#
# "$Id: cups.list 986 2000-03-13 18:56:08Z mike $"
#
# ESP Package Manager (EPM) file list 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
#
%product Common UNIX Printing System
%copyright 1993-2000 by Easy Software Products, All Rights Reserved.
%vendor Easy Software Products
%license LICENSE.txt
%readme README.txt
%version 1.1b2
%incompat printpro
%system all
# Server files
f 0500 root sys /usr/sbin/cupsd scheduler/cupsd
f 0555 root sys /usr/lib/cups/backend/ipp backend/ipp
l 0555 root sys /usr/lib/cups/backend/http ipp
f 0555 root sys /usr/lib/cups/backend/lpd backend/lpd
f 0555 root sys /usr/lib/cups/backend/parallel backend/parallel
f 0555 root sys /usr/lib/cups/backend/serial backend/serial
f 0555 root sys /usr/lib/cups/backend/socket backend/socket
f 0555 root sys /usr/lib/cups/backend/usb backend/usb
f 0555 root sys /usr/lib/cups/cgi-bin/admin.cgi cgi-bin/admin.cgi
f 0555 root sys /usr/lib/cups/cgi-bin/classes.cgi cgi-bin/classes.cgi
f 0555 root sys /usr/lib/cups/cgi-bin/jobs.cgi cgi-bin/jobs.cgi
f 0555 root sys /usr/lib/cups/cgi-bin/printers.cgi cgi-bin/printers.cgi
f 0555 root sys /usr/lib/cups/daemon/cups-polld scheduler/cups-polld
f 0555 root sys /usr/lib/cups/filter/pstoraster pstoraster/pstoraster
l 0555 root sys /usr/lib/cups/filter/pdftops pstoraster
f 0555 root sys /usr/lib/cups/filter/imagetops filter/imagetops
f 0555 root sys /usr/lib/cups/filter/pstops filter/pstops
f 0555 root sys /usr/lib/cups/filter/texttops filter/texttops
f 0555 root sys /usr/lib/cups/filter/rastertoepson filter/rastertoepson
f 0555 root sys /usr/lib/cups/filter/rastertohp filter/rastertohp
f 0555 root sys /usr/lib/cups/filter/hpgltops filter/hpgltops
f 0555 root sys /usr/lib/cups/filter/imagetoraster filter/imagetoraster
# Admin commands
l 0555 root sys /usr/bin/disable /usr/sbin/accept
l 0555 root sys /usr/bin/enable /usr/sbin/accept
l 0555 root sys /usr/lib/accept /usr/sbin/accept
l 0555 root sys /usr/lib/lpadmin /usr/sbin/lpadmin
l 0555 root sys /usr/lib/reject accept
f 0555 root sys /usr/sbin/accept systemv/accept
f 0555 root sys /usr/sbin/lpadmin systemv/lpadmin
f 0555 root sys /usr/sbin/lpc berkeley/lpc
l 0555 root sys /usr/sbin/reject accept
# User commands
f 0555 root sys /usr/bin/cancel systemv/cancel
f 0555 root sys /usr/bin/lp systemv/lp
f 0555 root sys /usr/bin/lpoptions systemv/lpoptions
f 4555 root sys /usr/bin/lppasswd systemv/lppasswd
f 0555 root sys /usr/bin/lpq berkeley/lpq
f 0555 root sys /usr/bin/lpr berkeley/lpr
f 0555 root sys /usr/bin/lprm berkeley/lprm
f 0555 root sys /usr/bin/lpstat systemv/lpstat
# DSOs
%system hpux
f 0555 root sys /usr/lib/libcups.sl.2 cups/libcups.sl.2
l 0555 root sys /usr/lib/libcups.sl libcups.sl.2
f 0555 root sys /usr/lib/libcupsimage.sl.2 filter/libcupsimage.sl.2
l 0555 root sys /usr/lib/libcupsimage.sl libcupsimage.sl.2
%system irix-6.5
f 0555 root sys /usr/lib32/libcups.so.2 cups/libcups.so.2
l 0555 root sys /usr/lib32/libcups.so libcups.so.2
f 0555 root sys /usr/lib32/libcupsimage.so.2 filter/libcupsimage.so.2
l 0555 root sys /usr/lib32/libcupsimage.so libcupsimage.so.2
%system !irix-6.5 !hpux
f 0555 root sys /usr/lib/libcups.so.2 cups/libcups.so.2
l 0555 root sys /usr/lib/libcups.so libcups.so.2
f 0555 root sys /usr/lib/libcupsimage.so.2 filter/libcupsimage.so.2
l 0555 root sys /usr/lib/libcupsimage.so libcupsimage.so.2
%system all
# Directories
d 0711 root sys /etc/cups/certs
d 0755 root sys /etc/cups/interfaces
d 0755 root sys /etc/cups/ppd
d 0755 root sys /var/log/cups
d 0755 root sys /var/spool/cups
# Data files
%system linux
f 0444 root sys /usr/share/locale/C/cups_C locale/C/cups_C
f 0444 root sys /usr/share/locale/de/cups_de locale/de/cups_de
f 0444 root sys /usr/share/locale/en/cups_en locale/en/cups_en
f 0444 root sys /usr/share/locale/es/cups_es locale/es/cups_es
f 0444 root sys /usr/share/locale/fr/cups_fr locale/fr/cups_fr
f 0444 root sys /usr/share/locale/it/cups_it locale/it/cups_it
%system dunix
f 0444 root sys /usr/lib/nls/msg/C/cups_C locale/C/cups_C
f 0444 root sys /usr/lib/nls/msg/de/cups_de locale/de/cups_de
f 0444 root sys /usr/lib/nls/msg/en/cups_en locale/en/cups_en
f 0444 root sys /usr/lib/nls/msg/es/cups_es locale/es/cups_es
f 0444 root sys /usr/lib/nls/msg/fr/cups_fr locale/fr/cups_fr
f 0444 root sys /usr/lib/nls/msg/it/cups_it locale/it/cups_it
%system !linux dunix
f 0444 root sys /usr/lib/locale/C/cups_C locale/C/cups_C
f 0444 root sys /usr/lib/locale/de/cups_de locale/de/cups_de
f 0444 root sys /usr/lib/locale/en/cups_en locale/en/cups_en
f 0444 root sys /usr/lib/locale/es/cups_es locale/es/cups_es
f 0444 root sys /usr/lib/locale/fr/cups_fr locale/fr/cups_fr
f 0444 root sys /usr/lib/locale/it/cups_it locale/it/cups_it
%system all
f 0444 root sys /usr/share/cups/charsets/cp874 data/cp874
f 0444 root sys /usr/share/cups/charsets/cp1250 data/cp1250
f 0444 root sys /usr/share/cups/charsets/cp1251 data/cp1251
f 0444 root sys /usr/share/cups/charsets/cp1252 data/cp1252
f 0444 root sys /usr/share/cups/charsets/cp1253 data/cp1253
f 0444 root sys /usr/share/cups/charsets/cp1254 data/cp1254
f 0444 root sys /usr/share/cups/charsets/cp1255 data/cp1255
f 0444 root sys /usr/share/cups/charsets/cp1256 data/cp1256
f 0444 root sys /usr/share/cups/charsets/cp1257 data/cp1257
f 0444 root sys /usr/share/cups/charsets/cp1258 data/cp1258
f 0444 root sys /usr/share/cups/charsets/iso-8859-1 data/iso-8859-1
f 0444 root sys /usr/share/cups/charsets/iso-8859-14 data/iso-8859-14
f 0444 root sys /usr/share/cups/charsets/iso-8859-15 data/iso-8859-15
f 0444 root sys /usr/share/cups/charsets/iso-8859-2 data/iso-8859-2
f 0444 root sys /usr/share/cups/charsets/iso-8859-3 data/iso-8859-3
f 0444 root sys /usr/share/cups/charsets/iso-8859-4 data/iso-8859-4
f 0444 root sys /usr/share/cups/charsets/iso-8859-5 data/iso-8859-5
f 0444 root sys /usr/share/cups/charsets/iso-8859-6 data/iso-8859-6
f 0444 root sys /usr/share/cups/charsets/iso-8859-7 data/iso-8859-7
f 0444 root sys /usr/share/cups/charsets/iso-8859-8 data/iso-8859-8
f 0444 root sys /usr/share/cups/charsets/iso-8859-9 data/iso-8859-9
f 0444 root sys /usr/share/cups/charsets/utf-8 data/utf-8
f 0444 root sys /usr/share/cups/data/HPGLprolog data/HPGLprolog
f 0444 root sys /usr/share/cups/data/psglyphs data/psglyphs
f 0444 root sys /usr/share/cups/data/testprint.ps data/testprint.ps
f 0444 root sys /usr/share/cups/fonts/AvantGarde-Book fonts/AvantGarde-Book
f 0444 root sys /usr/share/cups/fonts/AvantGarde-BookOblique fonts/AvantGarde-BookOblique
f 0444 root sys /usr/share/cups/fonts/AvantGarde-Demi fonts/AvantGarde-Demi
f 0444 root sys /usr/share/cups/fonts/AvantGarde-DemiOblique fonts/AvantGarde-DemiOblique
f 0444 root sys /usr/share/cups/fonts/Bookman-Demi fonts/Bookman-Demi
f 0444 root sys /usr/share/cups/fonts/Bookman-DemiItalic fonts/Bookman-DemiItalic
f 0444 root sys /usr/share/cups/fonts/Bookman-Light fonts/Bookman-Light
f 0444 root sys /usr/share/cups/fonts/Bookman-LightItalic fonts/Bookman-LightItalic
f 0444 root sys /usr/share/cups/fonts/Charter-Bold fonts/Charter-Bold
f 0444 root sys /usr/share/cups/fonts/Charter-BoldItalic fonts/Charter-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Charter-Italic fonts/Charter-Italic
f 0444 root sys /usr/share/cups/fonts/Charter-Roman fonts/Charter-Roman
f 0444 root sys /usr/share/cups/fonts/Courier fonts/Courier
f 0444 root sys /usr/share/cups/fonts/Courier-Bold fonts/Courier-Bold
f 0444 root sys /usr/share/cups/fonts/Courier-BoldOblique fonts/Courier-BoldOblique
f 0444 root sys /usr/share/cups/fonts/Courier-Oblique fonts/Courier-Oblique
f 0444 root sys /usr/share/cups/fonts/Helvetica fonts/Helvetica
f 0444 root sys /usr/share/cups/fonts/Helvetica-Bold fonts/Helvetica-Bold
f 0444 root sys /usr/share/cups/fonts/Helvetica-BoldOblique fonts/Helvetica-BoldOblique
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow fonts/Helvetica-Narrow
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow-Bold fonts/Helvetica-Narrow-Bold
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow-BoldOblique fonts/Helvetica-Narrow-BoldOblique
f 0444 root sys /usr/share/cups/fonts/Helvetica-Narrow-Oblique fonts/Helvetica-Narrow-Oblique
f 0444 root sys /usr/share/cups/fonts/Helvetica-Oblique fonts/Helvetica-Oblique
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-Bold fonts/NewCenturySchlbk-Bold
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-BoldItalic fonts/NewCenturySchlbk-BoldItalic
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-Italic fonts/NewCenturySchlbk-Italic
f 0444 root sys /usr/share/cups/fonts/NewCenturySchlbk-Roman fonts/NewCenturySchlbk-Roman
f 0444 root sys /usr/share/cups/fonts/Palatino-Bold fonts/Palatino-Bold
f 0444 root sys /usr/share/cups/fonts/Palatino-BoldItalic fonts/Palatino-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Palatino-Italic fonts/Palatino-Italic
f 0444 root sys /usr/share/cups/fonts/Palatino-Roman fonts/Palatino-Roman
f 0444 root sys /usr/share/cups/fonts/Symbol fonts/Symbol
f 0444 root sys /usr/share/cups/fonts/Times-Bold fonts/Times-Bold
f 0444 root sys /usr/share/cups/fonts/Times-BoldItalic fonts/Times-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Times-Italic fonts/Times-Italic
f 0444 root sys /usr/share/cups/fonts/Times-Roman fonts/Times-Roman
f 0444 root sys /usr/share/cups/fonts/Utopia-Bold fonts/Utopia-Bold
f 0444 root sys /usr/share/cups/fonts/Utopia-BoldItalic fonts/Utopia-BoldItalic
f 0444 root sys /usr/share/cups/fonts/Utopia-Italic fonts/Utopia-Italic
f 0444 root sys /usr/share/cups/fonts/Utopia-Regular fonts/Utopia-Regular
f 0444 root sys /usr/share/cups/fonts/ZapfChancery-MediumItalic fonts/ZapfChancery-MediumItalic
f 0444 root sys /usr/share/cups/fonts/ZapfDingbats fonts/ZapfDingbats
f 0444 root sys /usr/share/cups/pstoraster/Fontmap pstoraster/Fontmap
f 0444 root sys /usr/share/cups/pstoraster/gs_btokn.ps pstoraster/gs_btokn.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ccfnt.ps pstoraster/gs_ccfnt.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cff.ps pstoraster/gs_cff.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cidfn.ps pstoraster/gs_cidfn.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cmap.ps pstoraster/gs_cmap.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_cmdl.ps pstoraster/gs_cmdl.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dbt_e.ps pstoraster/gs_dbt_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_diskf.ps pstoraster/gs_diskf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dpnxt.ps pstoraster/gs_dpnxt.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dps1.ps pstoraster/gs_dps1.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dps2.ps pstoraster/gs_dps2.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_dps.ps pstoraster/gs_dps.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_epsf.ps pstoraster/gs_epsf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_fform.ps pstoraster/gs_fform.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_fonts.ps pstoraster/gs_fonts.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_init.ps pstoraster/gs_init.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_iso_e.ps pstoraster/gs_iso_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_kanji.ps pstoraster/gs_kanji.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ksb_e.ps pstoraster/gs_ksb_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_l2img.ps pstoraster/gs_l2img.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_lev2.ps pstoraster/gs_lev2.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ll3.ps pstoraster/gs_ll3.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_mex_e.ps pstoraster/gs_mex_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_mro_e.ps pstoraster/gs_mro_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pdfwr.ps pstoraster/gs_pdfwr.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pdf_e.ps pstoraster/gs_pdf_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_pfile.ps pstoraster/gs_pfile.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_res.ps pstoraster/gs_res.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_setpd.ps pstoraster/gs_setpd.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_statd.ps pstoraster/gs_statd.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_std_e.ps pstoraster/gs_std_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_sym_e.ps pstoraster/gs_sym_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_ttf.ps pstoraster/gs_ttf.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_typ32.ps pstoraster/gs_typ32.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_typ42.ps pstoraster/gs_typ42.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_type1.ps pstoraster/gs_type1.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wan_e.ps pstoraster/gs_wan_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wl1_e.ps pstoraster/gs_wl1_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wl2_e.ps pstoraster/gs_wl2_e.ps
f 0444 root sys /usr/share/cups/pstoraster/gs_wl5_e.ps pstoraster/gs_wl5_e.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf2dsc.ps pstoraster/pdf2dsc.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_base.ps pstoraster/pdf_base.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_draw.ps pstoraster/pdf_draw.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_font.ps pstoraster/pdf_font.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_main.ps pstoraster/pdf_main.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_ops.ps pstoraster/pdf_ops.ps
f 0444 root sys /usr/share/cups/pstoraster/pdf_sec.ps pstoraster/pdf_sec.ps
f 0444 root sys /usr/share/cups/model/deskjet.ppd ppd/deskjet.ppd
f 0444 root sys /usr/share/cups/model/laserjet.ppd ppd/laserjet.ppd
f 0444 root sys /usr/share/cups/model/stcolor.ppd ppd/stcolor.ppd
f 0444 root sys /usr/share/cups/model/stphoto.ppd ppd/stphoto.ppd
f 0444 root sys /usr/share/cups/templates/add-class.tmpl templates/add-class.tmpl
f 0444 root sys /usr/share/cups/templates/add-printer.tmpl templates/add-printer.tmpl
f 0444 root sys /usr/share/cups/templates/admin-op.tmpl templates/admin-op.tmpl
f 0444 root sys /usr/share/cups/templates/admin.tmpl templates/admin.tmpl
f 0444 root sys /usr/share/cups/templates/choose-device.tmpl templates/choose-device.tmpl
f 0444 root sys /usr/share/cups/templates/choose-make.tmpl templates/choose-make.tmpl
f 0444 root sys /usr/share/cups/templates/choose-model.tmpl templates/choose-model.tmpl
f 0444 root sys /usr/share/cups/templates/choose-serial.tmpl templates/choose-serial.tmpl
f 0444 root sys /usr/share/cups/templates/choose-uri.tmpl templates/choose-uri.tmpl
f 0444 root sys /usr/share/cups/templates/classes.tmpl templates/classes.tmpl
f 0444 root sys /usr/share/cups/templates/error.tmpl templates/error.tmpl
f 0444 root sys /usr/share/cups/templates/header.tmpl templates/header.tmpl
f 0444 root sys /usr/share/cups/templates/job-cancel.tmpl templates/job-cancel.tmpl
f 0444 root sys /usr/share/cups/templates/job-hold.tmpl templates/job-hold.tmpl
f 0444 root sys /usr/share/cups/templates/job-release.tmpl templates/job-release.tmpl
f 0444 root sys /usr/share/cups/templates/jobs.tmpl templates/jobs.tmpl
f 0444 root sys /usr/share/cups/templates/modify-class.tmpl templates/modify-class.tmpl
f 0444 root sys /usr/share/cups/templates/modify-printer.tmpl templates/modify-printer.tmpl
f 0444 root sys /usr/share/cups/templates/option-boolean.tmpl templates/option-boolean.tmpl
f 0444 root sys /usr/share/cups/templates/option-header.tmpl templates/option-header.tmpl
f 0444 root sys /usr/share/cups/templates/option-pickmany.tmpl templates/option-pickmany.tmpl
f 0444 root sys /usr/share/cups/templates/option-pickone.tmpl templates/option-pickone.tmpl
f 0444 root sys /usr/share/cups/templates/option-trailer.tmpl templates/option-trailer.tmpl
f 0444 root sys /usr/share/cups/templates/printer-accept.tmpl templates/printer-accept.tmpl
f 0444 root sys /usr/share/cups/templates/printer-reject.tmpl templates/printer-reject.tmpl
f 0444 root sys /usr/share/cups/templates/printer-start.tmpl templates/printer-start.tmpl
f 0444 root sys /usr/share/cups/templates/printer-stop.tmpl templates/printer-stop.tmpl
f 0444 root sys /usr/share/cups/templates/printers.tmpl templates/printers.tmpl
f 0444 root sys /usr/share/cups/templates/test-page.tmpl templates/test-page.tmpl
f 0444 root sys /usr/share/cups/templates/trailer.tmpl templates/trailer.tmpl
# Config files
c 0644 root sys /etc/cups/classes.conf conf/classes.conf
c 0644 root sys /etc/cups/cupsd.conf conf/cupsd.conf
f 0644 root sys /etc/cups/mime.convs conf/mime.convs
f 0644 root sys /etc/cups/mime.types conf/mime.types
c 0644 root sys /etc/cups/printers.conf conf/printers.conf
# Dummy printcap file for Digital UNIX and Linux...
%system dunix linux
%format !rpm
f 0644 root sys /etc/printcap conf/printcap
%system all
%format all
# Developer files
f 0444 root sys /usr/include/cups/cups.h cups/cups.h
f 0444 root sys /usr/include/cups/http.h cups/http.h
f 0444 root sys /usr/include/cups/image.h filter/image.h
f 0444 root sys /usr/include/cups/ipp.h cups/ipp.h
f 0444 root sys /usr/include/cups/language.h cups/language.h
f 0444 root sys /usr/include/cups/ppd.h cups/ppd.h
f 0444 root sys /usr/include/cups/raster.h filter/raster.h
%system irix-6.5
f 0444 root sys /usr/lib32/libcups.a cups/libcups.a
%system !irix-6.5
f 0444 root sys /usr/lib/libcups.a cups/libcups.a
%system all
# Documentation files
f 0444 root sys /usr/share/doc/cups/cups.css doc/cups.css
f 0444 root sys /usr/share/doc/cups/documentation.html doc/documentation.html
f 0444 root sys /usr/share/doc/cups/index.html doc/index.html
f 0444 root sys /usr/share/doc/cups/images/accept-jobs.gif doc/images/accept-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/add-class.gif doc/images/add-class.gif
f 0444 root sys /usr/share/doc/cups/images/add-printer.gif doc/images/add-printer.gif
f 0444 root sys /usr/share/doc/cups/images/cancel-job.gif doc/images/cancel-job.gif
f 0444 root sys /usr/share/doc/cups/images/cancel-jobs.gif doc/images/cancel-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/cancel.gif doc/images/cancel.gif
f 0444 root sys /usr/share/doc/cups/images/classes.gif doc/images/classes.gif
f 0444 root sys /usr/share/doc/cups/images/continue.gif doc/images/continue.gif
f 0444 root sys /usr/share/doc/cups/images/cups-bar.gif doc/images/cups-bar.gif
f 0444 root sys /usr/share/doc/cups/images/cups-block-diagram.gif doc/images/cups-block-diagram.gif
f 0444 root sys /usr/share/doc/cups/images/cups-large.gif doc/images/cups-large.gif
f 0444 root sys /usr/share/doc/cups/images/cups-medium.gif doc/images/cups-medium.gif
f 0444 root sys /usr/share/doc/cups/images/cups-small.gif doc/images/cups-small.gif
f 0444 root sys /usr/share/doc/cups/images/delete-class.gif doc/images/delete-class.gif
f 0444 root sys /usr/share/doc/cups/images/delete-printer.gif doc/images/delete-printer.gif
f 0444 root sys /usr/share/doc/cups/images/hold-job.gif doc/images/hold-job.gif
f 0444 root sys /usr/share/doc/cups/images/left.gif doc/images/left.gif
f 0444 root sys /usr/share/doc/cups/images/logo.gif doc/images/logo.gif
f 0444 root sys /usr/share/doc/cups/images/manage-classes.gif doc/images/manage-classes.gif
f 0444 root sys /usr/share/doc/cups/images/manage-jobs.gif doc/images/manage-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/manage-printers.gif doc/images/manage-printers.gif
f 0444 root sys /usr/share/doc/cups/images/modify-class.gif doc/images/modify-class.gif
f 0444 root sys /usr/share/doc/cups/images/modify-printer.gif doc/images/modify-printer.gif
f 0444 root sys /usr/share/doc/cups/images/navbar.gif doc/images/navbar.gif
f 0444 root sys /usr/share/doc/cups/images/print-test-page.gif doc/images/print-test-page.gif
f 0444 root sys /usr/share/doc/cups/images/printer-idle.gif doc/images/printer-idle.gif
f 0444 root sys /usr/share/doc/cups/images/printer-processing.gif doc/images/printer-processing.gif
f 0444 root sys /usr/share/doc/cups/images/printer-stopped.gif doc/images/printer-stopped.gif
f 0444 root sys /usr/share/doc/cups/images/reject-jobs.gif doc/images/reject-jobs.gif
f 0444 root sys /usr/share/doc/cups/images/release-job.gif doc/images/release-job.gif
f 0444 root sys /usr/share/doc/cups/images/restart-job.gif doc/images/restart-job.gif
f 0444 root sys /usr/share/doc/cups/images/right.gif doc/images/right.gif
f 0444 root sys /usr/share/doc/cups/images/show-active.gif doc/images/show-active.gif
f 0444 root sys /usr/share/doc/cups/images/show-completed.gif doc/images/show-completed.gif
f 0444 root sys /usr/share/doc/cups/images/start-class.gif doc/images/start-class.gif
f 0444 root sys /usr/share/doc/cups/images/start-printer.gif doc/images/start-printer.gif
f 0444 root sys /usr/share/doc/cups/images/stop-class.gif doc/images/stop-class.gif
f 0444 root sys /usr/share/doc/cups/images/stop-printer.gif doc/images/stop-printer.gif
f 0444 root sys /usr/share/doc/cups/cmp.html doc/cmp.html
f 0444 root sys /usr/share/doc/cups/cmp.pdf doc/cmp.pdf
f 0444 root sys /usr/share/doc/cups/cupsdoc.css doc/cupsdoc.css
f 0444 root sys /usr/share/doc/cups/idd.html doc/idd.html
f 0444 root sys /usr/share/doc/cups/idd.pdf doc/idd.pdf
f 0444 root sys /usr/share/doc/cups/overview.html doc/overview.html
f 0444 root sys /usr/share/doc/cups/overview.pdf doc/overview.pdf
f 0444 root sys /usr/share/doc/cups/sam.html doc/sam.html
f 0444 root sys /usr/share/doc/cups/sam.pdf doc/sam.pdf
f 0444 root sys /usr/share/doc/cups/sdd.html doc/sdd.html
f 0444 root sys /usr/share/doc/cups/sdd.pdf doc/sdd.pdf
f 0444 root sys /usr/share/doc/cups/spm.html doc/spm.html
f 0444 root sys /usr/share/doc/cups/spm.pdf doc/spm.pdf
f 0444 root sys /usr/share/doc/cups/ssr.html doc/ssr.html
f 0444 root sys /usr/share/doc/cups/ssr.pdf doc/ssr.pdf
f 0444 root sys /usr/share/doc/cups/sum.html doc/sum.html
f 0444 root sys /usr/share/doc/cups/sum.pdf doc/sum.pdf
# Man pages
%system irix
f 0444 root sys /usr/share/catman/a_man/cat1/accept.1 man/accept.8
l 0444 root sys /usr/share/catman/a_man/cat1/reject.1 accept.1
f 0444 root sys /usr/share/catman/u_man/cat1/backend.1 man/backend.1
f 0444 root sys /usr/share/catman/u_man/cat5/classes.conf.5 man/classes.conf.5
f 0444 root sys /usr/share/catman/u_man/cat5/cupsd.conf.5 man/cupsd.conf.5
f 0444 root sys /usr/share/catman/a_man/cat1/cupsd.1 man/cupsd.8
f 0444 root sys /usr/share/catman/a_man/cat1/enable.1 man/enable.8
l 0444 root sys /usr/share/catman/a_man/cat1/disable.1 enable.1
f 0444 root sys /usr/share/catman/u_man/cat1/filter.1 man/filter.1
f 0444 root sys /usr/share/catman/a_man/cat1/lpadmin.1 man/lpadmin.8
f 0444 root sys /usr/share/catman/a_man/cat1/lpc.1 man/lpc.8
f 0444 root sys /usr/share/catman/u_man/cat1/lpq.1 man/lpq.1
f 0444 root sys /usr/share/catman/u_man/cat1/lprm.1 man/lprm.1
f 0444 root sys /usr/share/catman/u_man/cat1/lpr.1 man/lpr.1
f 0444 root sys /usr/share/catman/u_man/cat1/lpstat.1 man/lpstat.1
f 0444 root sys /usr/share/catman/u_man/cat1/lp.1 man/lp.1
l 0444 root sys /usr/share/catman/u_man/cat1/cancel.1 lp.1
f 0444 root sys /usr/share/catman/u_man/cat5/mime.convs.5 man/mime.convs.5
f 0444 root sys /usr/share/catman/u_man/cat5/mime.types.5 man/mime.types.5
f 0444 root sys /usr/share/catman/u_man/cat5/printers.conf.5 man/printers.conf.5
%system !irix
f 0444 root sys /usr/man/man8/accept.8 man/accept.man
l 0444 root sys /usr/man/man8/reject.8 accept.man
f 0444 root sys /usr/man/man1/backend.1 man/backend.man
f 0444 root sys /usr/man/man1/classes.conf.5 man/classes.conf.man
f 0444 root sys /usr/man/man8/cupsd.8 man/cupsd.man
f 0444 root sys /usr/man/man5/cupsd.conf.5 man/cupsd.conf.man
f 0444 root sys /usr/man/man8/enable.8 man/enable.man
f 0444 root sys /usr/man/man8/esplicense.8 man/esplicense.man
l 0444 root sys /usr/man/man8/disable.8 enable.man
f 0444 root sys /usr/man/man1/filter.1 man/filter.man
f 0444 root sys /usr/man/man8/lpadmin.8 man/lpadmin.man
f 0444 root sys /usr/man/man8/lpc.8 man/lpc.man
f 0444 root sys /usr/man/man1/lpq.1 man/lpq.man
f 0444 root sys /usr/man/man1/lprm.1 man/lprm.man
f 0444 root sys /usr/man/man1/lpr.1 man/lpr.man
f 0444 root sys /usr/man/man1/lpstat.1 man/lpstat.man
f 0444 root sys /usr/man/man1/lp.1 man/lp.man
l 0444 root sys /usr/man/man1/cancel.1 lp.man
f 0444 root sys /usr/man/man5/mime.convs.5 man/mime.convs.man
f 0444 root sys /usr/man/man5/mime.types.5 man/mime.types.man
f 0444 root sys /usr/man/man5/printers.conf.5 man/printers.conf.man
# Startup script
%system all
i 0555 root sys cups cups.sh
#
# End of "$Id: cups.list 986 2000-03-13 18:56:08Z mike $".
#
Arquivo executável
+117
Ver Arquivo
@@ -0,0 +1,117 @@
#!/bin/sh
#
# "$Id$"
#
# Startup/shutdown script for the Common UNIX Printing System (CUPS).
#
# Linux chkconfig stuff:
#
# chkconfig: 02345 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* | Linux*)
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
# Change to the root directory first, in case we are being run from a
# CD-ROM installation script...
cd /
# Start or stop the CUPS server based upon the first argument to the script.
case $1 in
start | restart | reload)
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
/usr/sbin/cupsd 2>&1 >/dev/null &
$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$".
#
+116
Ver Arquivo
@@ -0,0 +1,116 @@
#
# "$Id: cups.spec 904 2000-02-18 17:48:09Z 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.1a8
Release: 0
Copyright: GPL
Group: System Environment/Daemons
Source: ftp://ftp.easysw.com/pub/cups/beta/cups-1.1a8-source.tar.gz
Url: http://www.cups.org
Packager: Michael Sweet <mike@easysw.com>
Vendor: Easy Software Products
# use buildroot so as not to disturb the version already installed
BuildRoot: /tmp/rpmbuild
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
make prefix=$RPM_BUILD_ROOT/usr LOGDIR=$RPM_BUILD_ROOT/var/log/cups \
REQUESTS=$RPM_BUILD_ROOT/var/spool/cups \
SERVERROOT=$RPM_BUILD_ROOT/etc/cups install
install -m 755 -o root -g root cups.sh $RPM_BUILD_ROOT/etc/rc.d/init.d/cups
%post
/sbin/chkconfig --add cups
%preun
/sbin/chkconfig --del cups
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
/etc/rc.d/init.d/cups
%config /etc/cups/*
%dir /etc/cups/certs
%dir /etc/cups/interfaces
%dir /etc/cups/ppd
/usr/bin/*
%%attr(4555,root,root) /usr/bin/lppasswd
/usr/lib/*
/usr/man/*
/usr/sbin/*
%dir /usr/share/cups
/usr/share/cups/*
%dir /usr/share/doc/cups
/usr/share/doc/cups/*
%dir /var/cups
/usr/lib/cups/backend/*
/usr/lib/cups/cgi-bin/*
/usr/lib/cups/filter/*
%dir /var/spool/cups
%dir /var/log/cups
%files devel
%dir /usr/include/cups
/usr/include/cups/*
/usr/lib/*.a
#
# End of "$Id: cups.spec 904 2000-02-18 17:48:09Z mike $".
#
+52 -40
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Support library Makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1997-1999 by Easy Software Products, all rights reserved.
# 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
@@ -14,7 +14,7 @@
#
# Attn: CUPS Licensing Information
# Easy Software Products
# 44145 Airport View Drive, Suite 204
# 44141 Airport View Drive, Suite 204
# Hollywood, Maryland 20636-3111 USA
#
# Voice: (301) 373-9603
@@ -28,20 +28,21 @@ include ../Makedefs
# Object files...
#
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 util.o
LIBOBJS = dest.o emit.o http.o ipp.o language.o mark.o md5.o options.o \
page.o ppd.o snprintf.o string.o usersys.o util.o
OBJS = $(LIBOBJS) testhttp.o testppd.o
#
# Header files to install...
#
HEADERS = cups.h http.h ipp.h language.h mime.h ppd.h raster.h
HEADERS = cups.h http.h ipp.h language.h ppd.h
#
# Targets in this directory...
#
TARGETS = libcups.a testmime testppd testhttp
TARGETS = $(LIBCUPS) testhttp testppd
#
# Make all targets...
@@ -54,25 +55,40 @@ all: $(TARGETS)
#
clean:
rm -f $(OBJS) $(TARGETS)
$(RM) $(OBJS) $(TARGETS)
#
# Install object and target files...
#
install: all
-$(MKDIR) $(LIBDIR)
$(CP) libcups.a $(LIBDIR)
-$(MKDIR) $(INCLUDEDIR)/cups
$(CP) $(HEADERS) $(INCLUDEDIR)/cups
-$(MKDIR) $(LIBDIR)
$(CP) $(LIBCUPS) $(LIBDIR)
if test $(LIBCUPS) != "libcups.a"; then \
$(RM) `basename $(LIBCUPS) .2`; \
$(LN) $(LIBCUPS) `basename $(LIBCUPS) .2`; \
fi
#
# libcups.so.2, libcups.sl.1
#
libcups.so.2 libcups.sl.2: $(LIBOBJS) ../Makedefs
echo Linking $@...
$(DSO) $@ $(LIBOBJS)
$(RM) `basename $@ .2`
$(LN) $@ `basename $@ .2`
#
# libcups.a
#
libcups.a: $(OBJS)
libcups.a: $(LIBOBJS)
echo Archiving $@...
$(RM) $@
$(AR) $(ARFLAGS) $@ $(OBJS)
$(AR) $(ARFLAGS) $@ $(LIBOBJS)
$(RANLIB) $@
#
@@ -80,50 +96,46 @@ libcups.a: $(OBJS)
#
cups_C.h: ../locale/C/cups_C
echo Generating $@...
$(RM) cups_C.h
$(AWK) '{print "\"" $$0 "\","}' < ../locale/C/cups_C > cups_C.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: 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
util.o: cups.h http.h ipp.h ../config.h ../Makedefs
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
#
# testhttp
# testhttp (dependency on static CUPS library is intentional)
#
testhttp: testhttp.o libcups.a
$(CC) $(LDFLAGS) -o $@ testhttp.o $(LIBS)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testhttp.o libcups.a $(NETLIBS)
testhttp.o: http.h ../Makedefs
testhttp.o: http.h
#
# testmime
#
testmime: testmime.o libcups.a
$(CC) $(LDFLAGS) -o $@ testmime.o $(LIBS)
testmime.o: mime.h ../Makedefs
#
# testppd
# testppd (dependency on static CUPS library is intentional)
#
testppd: testppd.o libcups.a
$(CC) $(LDFLAGS) -o $@ testppd.o $(LIBS)
echo Linking $@...
$(CC) $(LDFLAGS) -o $@ testppd.o libcups.a $(NETLIBS)
testppd.o: ppd.h ../Makedefs
testppd.o: ppd.h
$(OBJS): ../Makedefs ../config.h
#
# End of "$Id$".
+180
Ver Arquivo
@@ -0,0 +1,180 @@
# 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
+38 -29
Ver Arquivo
@@ -3,7 +3,7 @@
*
* API definitions for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -30,7 +30,6 @@
*/
# include <cups/ipp.h>
# include <cups/mime.h>
# include <cups/ppd.h>
@@ -74,57 +73,67 @@ enum /* Not a typedef'd enum so we can OR */
CUPS_PRINTER_SMALL = 0x1000, /* Can do Letter/Legal/A4 */
CUPS_PRINTER_MEDIUM = 0x2000, /* Can do Tabloid/B/C/A3/A2 */
CUPS_PRINTER_LARGE = 0x4000, /* Can do D/E/A1/A0 */
CUPS_PRINTER_VARIABLE = 0x8000 /* Can do variable sizes */
CUPS_PRINTER_VARIABLE = 0x8000, /* Can do variable sizes */
CUPS_PRINTER_IMPLICIT = 0x10000, /* Implicit class */
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 */
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(char *printer, int job);
extern int cupsCancelJob(const char *printer, int job);
#define cupsDoRequest(http,request,resource) cupsDoFileRequest((http),(request),(resource),NULL)
extern ipp_t *cupsDoFileRequest(http_t *http, ipp_t *request,
char *resource, char *filename);
const char *resource, const char *filename);
extern int cupsGetClasses(char ***classes);
extern char *cupsGetPPD(char *printer);
extern char *cupsGetDefault(void);
extern const char *cupsGetDefault(void);
extern const char *cupsGetPPD(const char *printer);
extern int cupsGetPrinters(char ***printers);
extern int cupsPrintFile(char *printer, char *filename, char *title,
int num_options, cups_option_t *options);
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 char *cupsTempFile(char *filename, int len);
extern int cupsAddOption(char *name, char *value, 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 cupsFreeOptions(int num_options, cups_option_t *options);
extern char *cupsGetOption(char *name, int num_options,
extern const char *cupsGetOption(const char *name, int num_options,
cups_option_t *options);
extern int cupsParseOptions(char *arg, int num_options,
extern int cupsParseOptions(const 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 const char *cupsUser(void);
# ifdef __cplusplus
}
# endif /* __cplusplus */
+132
Ver Arquivo
@@ -0,0 +1,132 @@
"us-ascii",
"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.",
+2 -2
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Debugging macros for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
+472
Ver Arquivo
@@ -0,0 +1,472 @@
/*
* "$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 (instance == NULL && dest->instance != NULL)
break;
else if (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 (name == NULL || num_dests == 0 || dests == NULL)
return (NULL);
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...
*/
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)
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$".
*/
+4 -4
Ver Arquivo
@@ -3,7 +3,7 @@
*
* PPD code emission routines for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -86,8 +86,8 @@ ppdEmit(ppd_file_t *ppd, /* I - PPD file record */
return (-1);
}
if (strcmp(((ppd_option_t *)choices[i]->option)->keyword, "PageSize") == 0 &&
strcmp(choices[i]->choice, "Custom") == 0)
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
@@ -107,7 +107,7 @@ ppdEmit(ppd_file_t *ppd, /* I - PPD file record */
*/
fputs("pop pop pop\n", fp);
fputs("<</PageSize[7 -2 roll]/ImagingBBox null>>setpagedevice\n", fp);
fputs("<</PageSize[5 -2 roll]/ImagingBBox null>>setpagedevice\n", fp);
}
}
+347 -196
Ver Arquivo
@@ -3,7 +3,7 @@
*
* HTTP routines for the Common UNIX Printing System (CUPS) scheduler.
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* Copyright 1997-2000 by Easy Software Products, all rights reserved.
*
* These statusd instructions, statements, and computer programs are the
* property of Easy Software Products and are protected by Federal
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -25,6 +25,8 @@
*
* httpInitialize() - Initialize the HTTP interface library and set the
* default HTTP proxy (if any).
* httpCheck() - Check to see if there is a pending response from
* the server.
* httpClose() - Close an HTTP connection...
* httpConnect() - Connect to a HTTP server.
* httpReconnect() - Reconnect to a HTTP server...
@@ -66,6 +68,7 @@
#include <ctype.h>
#include "string.h"
#include <fcntl.h>
#include <errno.h>
#include "http.h"
#include "ipp.h"
@@ -89,28 +92,21 @@
* Local functions...
*/
static http_field_t http_field(char *name);
static int http_send(http_t *http, http_state_t request, char *uri);
static http_field_t http_field(const char *name);
static int http_send(http_t *http, http_state_t request,
const char *uri);
/*
* Local globals...
*/
static char *http_fields[] =
static const char *http_fields[] =
{
"Accept",
"Accept-Charset",
"Accept-Encoding",
"Accept-Language",
"Accept-Ranges",
"Age",
"Allow",
"Alternates",
"Authorization",
"Cache-Control",
"Connection",
"Content-Base",
"Content-Encoding",
"Content-Language",
"Content-Length",
@@ -120,41 +116,22 @@ static char *http_fields[] =
"Content-Type",
"Content-Version",
"Date",
"Derived-From",
"Etag",
"Expires",
"From",
"Host",
"If-Match",
"If-Modified-Since",
"If-None-Match",
"If-Range",
"If-Unmodified-since",
"Keep-Alive",
"Last-Modified",
"Link",
"Location",
"Max-Forwards",
"Message-Id",
"MIME-Version",
"Pragma",
"Proxy-Authenticate",
"Proxy-Authorization",
"Public",
"Range",
"Referer",
"Retry-After",
"Server",
"Transfer-Encoding",
"Upgrade",
"URI",
"User-Agent",
"Vary",
"Via",
"Warning",
"WWW-Authenticate"
};
static char *days[7] =
static const char *days[7] =
{
"Sun",
"Mon",
@@ -164,7 +141,7 @@ static char *days[7] =
"Fri",
"Sat"
};
static char *months[12] =
static const char *months[12] =
{
"Jan",
"Feb",
@@ -215,6 +192,41 @@ httpInitialize(void)
}
/*
* 'httpCheck()' - Check to see if there is a pending response from the server.
*/
int /* O - 0 = no data, 1 = data available */
httpCheck(http_t *http) /* I - HTTP connection */
{
fd_set input; /* Input set for select() */
struct timeval timeout; /* Timeout */
/*
* First see if there is data in the buffer...
*/
if (http == NULL)
return (0);
if (http->used)
return (1);
/*
* Then try doing a select() to poll the socket...
*/
FD_ZERO(&input);
FD_SET(http->fd, &input);
timeout.tv_sec = 0;
timeout.tv_usec = 0;
return (select(http->fd + 1, &input, NULL, NULL, &timeout) > 0);
}
/*
* 'httpClose()' - Close an HTTP connection...
*/
@@ -240,8 +252,8 @@ httpClose(http_t *http) /* I - Connection to close */
*/
http_t * /* O - New HTTP connection */
httpConnect(char *host, /* I - Host to connect to */
int port) /* I - Port number */
httpConnect(const char *host, /* I - Host to connect to */
int port) /* I - Port number */
{
http_t *http; /* New HTTP connection */
struct hostent *hostaddr; /* Host address data */
@@ -272,8 +284,7 @@ httpConnect(char *host, /* I - Host to connect to */
* Copy the hostname and port and then "reconnect"...
*/
strcpy(http->hostname, host);
memset((char *)&(http->hostaddr), 0, sizeof(http->hostaddr));
strncpy(http->hostname, host, sizeof(http->hostname) - 1);
memcpy((char *)&(http->hostaddr.sin_addr), hostaddr->h_addr, hostaddr->h_length);
http->hostaddr.sin_family = hostaddr->h_addrtype;
#ifdef WIN32
@@ -317,7 +328,15 @@ httpReconnect(http_t *http) /* I - HTTP data */
*/
if ((http->fd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
{
#if defined(WIN32) || defined(__EMX__)
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 || __EMX__ */
http->status = HTTP_ERROR;
return (-1);
}
#ifdef FD_CLOEXEC
fcntl(http->fd, F_SETFD, FD_CLOEXEC); /* Close this socket when starting *
@@ -339,6 +358,13 @@ httpReconnect(http_t *http) /* I - HTTP data */
if (connect(http->fd, (struct sockaddr *)&(http->hostaddr),
sizeof(http->hostaddr)) < 0)
{
#if defined(WIN32) || defined(__EMX__)
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 || __EMX__ */
http->status = HTTP_ERROR;
#ifdef WIN32
closesocket(http->fd);
#else
@@ -348,6 +374,9 @@ httpReconnect(http_t *http) /* I - HTTP data */
return (-1);
}
http->error = 0;
http->status = HTTP_CONTINUE;
return (0);
}
@@ -358,12 +387,12 @@ httpReconnect(http_t *http) /* I - HTTP data */
*/
void
httpSeparate(char *uri, /* I - Universal Resource Identifier */
char *method, /* O - Method (http, https, etc.) */
char *username, /* O - Username */
char *host, /* O - Hostname */
int *port, /* O - Port number to use */
char *resource) /* O - Resource/filename */
httpSeparate(const char *uri, /* I - Universal Resource Identifier */
char *method, /* O - Method [32] (http, https, etc.) */
char *username, /* O - Username [32] */
char *host, /* O - Hostname [32] */
int *port, /* O - Port number to use */
char *resource) /* O - Resource/filename [1024] */
{
char *ptr; /* Pointer into string... */
@@ -376,49 +405,71 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
* Grab the method portion of the URI...
*/
ptr = host;
while (*uri != ':' && *uri != '\0')
*ptr++ = *uri++;
*ptr = '\0';
if (*uri == ':')
uri ++;
/*
* If the method contains a period or slash, then it's probably
* hostname/filename...
*/
if (strchr(host, '.') != NULL || strchr(host, '/') != NULL || *uri == '\0')
if (strncmp(uri, "//", 2) == 0)
{
if ((ptr = strchr(host, '/')) != NULL)
{
strcpy(resource, ptr);
*ptr = '\0';
}
else
resource[0] = '\0';
/*
* Workaround for HP IPP client bug...
*/
if (isdigit(*uri))
{
/*
* OK, we have "hostname:port[/resource]"...
*/
*port = strtol(uri, &uri, 10);
if (*uri == '/')
strcpy(resource, uri);
}
else
*port = 0;
strcpy(method, "http");
username[0] = '\0';
return;
strcpy(method, "ipp");
}
else
strcpy(method, host);
{
/*
* Standard URI with method...
*/
ptr = host;
while (*uri != ':' && *uri != '\0')
*ptr++ = *uri++;
*ptr = '\0';
if (*uri == ':')
uri ++;
/*
* If the method contains a period or slash, then it's probably
* hostname/filename...
*/
if (strchr(host, '.') != NULL || strchr(host, '/') != NULL || *uri == '\0')
{
if ((ptr = strchr(host, '/')) != NULL)
{
strncpy(resource, ptr, HTTP_MAX_URI - 1);
resource[HTTP_MAX_URI - 1] = '\0';
*ptr = '\0';
}
else
resource[0] = '\0';
if (isdigit(*uri))
{
/*
* OK, we have "hostname:port[/resource]"...
*/
*port = strtol(uri, (char **)&uri, 10);
if (*uri == '/')
{
strncpy(resource, uri, HTTP_MAX_URI - 1);
resource[HTTP_MAX_URI - 1] = '\0';
}
}
else
*port = 631;
strcpy(method, "http");
username[0] = '\0';
return;
}
else
{
strncpy(method, host, 31);
method[31] = '\0';
}
}
/*
* If the method starts with less than 2 slashes then it is a local resource...
@@ -426,7 +477,9 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
if (strncmp(uri, "//", 2) != 0)
{
strcpy(resource, uri);
strncpy(resource, uri, 1023);
resource[1023] = '\0';
username[0] = '\0';
host[0] = '\0';
*port = 0;
@@ -441,7 +494,7 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
uri ++;
ptr = host;
while (*uri != ':' && *uri != '@' && *uri != '/' && *uri != '\0')
while (!(*uri == ':' && isdigit(uri[1])) && *uri != '@' && *uri != '/' && *uri != '\0')
*ptr ++ = *uri ++;
*ptr = '\0';
@@ -452,9 +505,11 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
* Got a username...
*/
strcpy(username, host);
strncpy(username, host, 31);
username[31] = '\0';
ptr = host;
uri ++;
while (*uri != ':' && *uri != '/' && *uri != '\0')
*ptr ++ = *uri ++;
@@ -463,18 +518,20 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
else
username[0] = '\0';
if (*uri == '\0')
if (*uri != ':')
{
/*
* Hostname but no port or path...
*/
*port = 0;
resource[0] = '/';
resource[1] = '\0';
return;
if (strcasecmp(method, "http") == 0)
*port = 80;
else if (strcasecmp(method, "https") == 0)
*port = 443;
else if (strcasecmp(method, "ipp") == 0) /* Not registered yet... */
*port = ippPort();
else if (strcasecmp(method, "socket") == 0) /* Not registered yet... */
*port = 9100;
else
*port = 0;
}
else if (*uri == ':')
else
{
/*
* Parse port number...
@@ -488,27 +545,24 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
uri ++;
}
}
else
if (*uri == '\0')
{
/*
* Figure out the default port number based on the method...
* Hostname but no port or path...
*/
if (strcasecmp(method, "http") == 0)
*port = 80;
else if (strcasecmp(method, "https") == 0)
*port = 443;
else if (strcasecmp(method, "ipp") == 0) /* Not registered yet... */
*port = ippPort();
else
*port = 0;
resource[0] = '/';
resource[1] = '\0';
return;
}
/*
* The remaining portion is the resource string...
*/
strcpy(resource, uri);
strncpy(resource, uri, HTTP_MAX_URI - 1);
resource[HTTP_MAX_URI - 1] = '\0';
}
@@ -519,7 +573,7 @@ httpSeparate(char *uri, /* I - Universal Resource Identifier */
void
httpSetField(http_t *http, /* I - HTTP data */
http_field_t field, /* I - Field index */
char *value) /* I - Value */
const char *value) /* I - Value */
{
strncpy(http->fields[field], value, HTTP_MAX_VALUE - 1);
http->fields[field][HTTP_MAX_VALUE - 1] = '\0';
@@ -531,8 +585,8 @@ httpSetField(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpDelete(http_t *http, /* I - HTTP data */
char *uri) /* I - URI to delete */
httpDelete(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI to delete */
{
return (http_send(http, HTTP_DELETE, uri));
}
@@ -543,8 +597,8 @@ httpDelete(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpGet(http_t *http, /* I - HTTP data */
char *uri) /* I - URI to get */
httpGet(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI to get */
{
return (http_send(http, HTTP_GET, uri));
}
@@ -555,8 +609,8 @@ httpGet(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpHead(http_t *http, /* I - HTTP data */
char *uri) /* I - URI for head */
httpHead(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI for head */
{
return (http_send(http, HTTP_HEAD, uri));
}
@@ -567,8 +621,8 @@ httpHead(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpOptions(http_t *http, /* I - HTTP data */
char *uri) /* I - URI for options */
httpOptions(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI for options */
{
return (http_send(http, HTTP_OPTIONS, uri));
}
@@ -579,8 +633,8 @@ httpOptions(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpPost(http_t *http, /* I - HTTP data */
char *uri) /* I - URI for post */
httpPost(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI for post */
{
httpGetLength(http);
@@ -593,8 +647,8 @@ httpPost(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpPut(http_t *http, /* I - HTTP data */
char *uri) /* I - URI to put */
httpPut(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI to put */
{
httpGetLength(http);
@@ -607,8 +661,8 @@ httpPut(http_t *http, /* I - HTTP data */
*/
int /* O - Status of call (0 = success) */
httpTrace(http_t *http, /* I - HTTP data */
char *uri) /* I - URI for trace */
httpTrace(http_t *http, /* I - HTTP data */
const char *uri) /* I - URI for trace */
{
return (http_send(http, HTTP_TRACE, uri));
}
@@ -652,12 +706,15 @@ httpRead(http_t *http, /* I - HTTP data */
return (0);
if (http->data_encoding == HTTP_ENCODE_CHUNKED &&
http->data_remaining <= 0 &&
(http->state == HTTP_GET_SEND || http->state == HTTP_POST_RECV ||
http->state == HTTP_POST_SEND || http->state == HTTP_PUT_RECV))
http->data_remaining <= 0)
{
DEBUG_puts("httpRead: Getting chunk length...");
if (httpGets(len, sizeof(len), http) == NULL)
{
DEBUG_puts("httpRead: Could not get length!");
return (0);
}
http->data_remaining = strtol(len, NULL, 16);
}
@@ -671,6 +728,9 @@ httpRead(http_t *http, /* I - HTTP data */
* data, go idle...
*/
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
httpGets(len, sizeof(len), http);
if (http->state == HTTP_POST_RECV)
http->state ++;
else
@@ -705,13 +765,25 @@ httpRead(http_t *http, /* I - HTTP data */
if (bytes > 0)
http->data_remaining -= bytes;
else if (bytes < 0)
#if defined(WIN32) || defined(__EMX__)
http->error = WSAGetLastError();
#else
http->error = errno;
#endif /* WIN32 || __EMX__ */
if (http->data_remaining == 0 && http->data_encoding != HTTP_ENCODE_CHUNKED)
if (http->data_remaining == 0)
{
if (http->state == HTTP_POST_RECV)
http->state ++;
else
http->state = HTTP_WAITING;
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
httpGets(len, sizeof(len), http);
if (http->data_encoding != HTTP_ENCODE_CHUNKED)
{
if (http->state == HTTP_POST_RECV)
http->state ++;
else
http->state = HTTP_WAITING;
}
}
return (bytes);
@@ -723,13 +795,12 @@ httpRead(http_t *http, /* I - HTTP data */
*/
int /* O - Number of bytes written */
httpWrite(http_t *http, /* I - HTTP data */
char *buffer, /* I - Buffer for data */
int length) /* I - Number of bytes to write */
httpWrite(http_t *http, /* I - HTTP data */
const char *buffer, /* I - Buffer for data */
int length) /* I - Number of bytes to write */
{
int tbytes, /* Total bytes sent */
bytes; /* Bytes sent */
char len[32]; /* Length string */
int tbytes, /* Total bytes sent */
bytes; /* Bytes sent */
if (http == NULL || buffer == NULL)
@@ -737,28 +808,30 @@ httpWrite(http_t *http, /* I - HTTP data */
http->activity = time(NULL);
if (http->data_encoding == HTTP_ENCODE_CHUNKED &&
(http->state == HTTP_GET_SEND || http->state == HTTP_POST_RECV ||
http->state == HTTP_POST_SEND || http->state == HTTP_PUT_RECV))
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
{
sprintf(len, "%x\r\n", length);
if (send(http->fd, len, strlen(len), 0) < 3)
if (httpPrintf(http, "%x\r\n", length) < 0)
return (-1);
}
if (length == 0)
{
/*
* A zero-length chunk ends a transfer; unless we are sending POST
* data, go idle...
*/
if (length == 0)
{
/*
* A zero-length chunk ends a transfer; unless we are sending POST
* data, go idle...
*/
if (http->state == HTTP_POST_RECV)
http->state ++;
else
http->state = HTTP_WAITING;
DEBUG_puts("httpWrite: changing states...");
return (0);
if (http->state == HTTP_POST_RECV)
http->state ++;
else
http->state = HTTP_WAITING;
if (httpPrintf(http, "\r\n") < 0)
return (-1);
return (0);
}
}
tbytes = 0;
@@ -769,6 +842,7 @@ httpWrite(http_t *http, /* I - HTTP data */
if (bytes < 0)
{
DEBUG_puts("httpWrite: error writing data...\n");
return (-1);
}
@@ -779,12 +853,18 @@ httpWrite(http_t *http, /* I - HTTP data */
http->data_remaining -= bytes;
}
if (http->data_encoding == HTTP_ENCODE_CHUNKED)
if (httpPrintf(http, "\r\n") < 0)
return (-1);
if (http->data_remaining == 0 && http->data_encoding == HTTP_ENCODE_LENGTH)
{
/*
* Finished with the transfer; unless we are sending POST data, go idle...
*/
DEBUG_puts("httpWrite: changing states...");
if (http->state == HTTP_POST_RECV)
http->state ++;
else
@@ -821,6 +901,12 @@ httpGets(char *line, /* I - Line to read into */
* Pre-scan the buffer and see if there is a newline in there...
*/
#if defined(WIN32) || defined(__EMX__)
WSASetLastError(0);
#else
errno = 0;
#endif /* WIN32 || __EMX__ */
do
{
bufptr = http->buffer;
@@ -838,23 +924,46 @@ httpGets(char *line, /* I - Line to read into */
* No newline; see if there is more data to be read...
*/
if ((bytes = recv(http->fd, bufend, HTTP_MAX_BUFFER - http->used, 0)) < 1)
if ((bytes = recv(http->fd, bufend, HTTP_MAX_BUFFER - http->used, 0)) < 0)
{
/*
* Nope, can't get a line this time...
*/
#if defined(WIN32) || defined(__EMX__)
if (WSAGetLastError() != http->error)
{
http->error = WSAGetLastError();
continue;
}
DEBUG_printf(("httpGets(): recv() error %d!\n", WSAGetLastError()));
#else
if (errno != http->error)
{
http->error = errno;
continue;
}
DEBUG_printf(("httpGets(): recv() error %d!\n", errno));
#endif /* WIN32 || __EMX__ */
return (NULL);
}
else
else if (bytes == 0)
{
/*
* Yup, update the amount used and the end pointer...
*/
if (http->blocking)
http->error = EPIPE;
http->used += bytes;
bufend += bytes;
return (NULL);
}
/*
* Yup, update the amount used and the end pointer...
*/
http->used += bytes;
bufend += bytes;
}
}
while (bufptr >= bufend);
@@ -882,6 +991,7 @@ httpGets(char *line, /* I - Line to read into */
if (http->used > 0)
memcpy(http->buffer, bufptr, http->used);
DEBUG_printf(("httpGets(): Returning \"%s\"\n", line));
return (line);
}
else if (*bufptr == 0x0d)
@@ -890,6 +1000,8 @@ httpGets(char *line, /* I - Line to read into */
*lineptr++ = *bufptr++;
}
DEBUG_puts("httpGets(): No new line available!");
return (NULL);
}
@@ -903,18 +1015,25 @@ httpPrintf(http_t *http, /* I - HTTP data */
const char *format, /* I - printf-style format string */
...) /* I - Additional args as needed */
{
int bytes; /* Number of bytes to write */
char buf[HTTP_MAX_BUFFER]; /* Buffer for formatted string */
int bytes, /* Number of bytes to write */
nbytes, /* Number of bytes written */
tbytes; /* Number of bytes all together */
char buf[HTTP_MAX_BUFFER], /* Buffer for formatted string */
*bufptr; /* Pointer into buffer */
va_list ap; /* Variable argument pointer */
va_start(ap, format);
bytes = vsprintf(buf, format, ap);
bytes = vsnprintf(buf, sizeof(buf), format, ap);
va_end(ap);
DEBUG_printf(("httpPrintf: %s", buf));
return (send(http->fd, buf, bytes, 0));
for (tbytes = 0, bufptr = buf; tbytes < bytes; tbytes += nbytes, bufptr += nbytes)
if ((nbytes = send(http->fd, bufptr, bytes - tbytes, 0)) < 0)
return (-1);
return (bytes);
}
@@ -922,7 +1041,7 @@ httpPrintf(http_t *http, /* I - HTTP data */
* 'httpStatus()' - Return a short string describing a HTTP status code.
*/
char * /* O - String or NULL */
const char * /* O - String or NULL */
httpStatus(http_status_t status) /* I - HTTP status code */
{
switch (status)
@@ -963,7 +1082,7 @@ httpStatus(http_status_t status) /* I - HTTP status code */
* 'httpGetDateString()' - Get a formatted date/time string from a time value.
*/
char * /* O - Date/time string */
const char * /* O - Date/time string */
httpGetDateString(time_t t) /* I - UNIX time */
{
struct tm *tdate;
@@ -984,7 +1103,7 @@ httpGetDateString(time_t t) /* I - UNIX time */
*/
time_t /* O - UNIX time */
httpGetDateTime(char *s) /* I - Date/time string */
httpGetDateTime(const char *s) /* I - Date/time string */
{
int i; /* Looping var */
struct tm tdate; /* Time/date structure */
@@ -993,7 +1112,7 @@ httpGetDateTime(char *s) /* I - Date/time string */
int hour, min, sec; /* Time */
if (sscanf(s, "%*s%d%s%d%d:%d:%d", &day, mon, &year, &hour, &min, &sec) < 6)
if (sscanf(s, "%*s%d%15s%d%d:%d:%d", &day, mon, &year, &hour, &min, &sec) < 6)
return (0);
for (i = 0; i < 12; i ++)
@@ -1051,8 +1170,15 @@ httpUpdate(http_t *http) /* I - HTTP data */
/*
* Blank line means the start of the data section (if any). Return
* the result code, too...
*
* If we get status 100 (HTTP_CONTINUE), then we *don't* change states.
* Instead, we just return HTTP_CONTINUE to the caller and keep on
* tryin'...
*/
if (http->status == HTTP_CONTINUE)
return (http->status);
httpGetLength(http);
switch (http->state)
@@ -1106,7 +1232,20 @@ httpUpdate(http_t *http) /* I - HTTP data */
httpSetField(http, field, value);
}
else
{
http->status = HTTP_ERROR;
return (HTTP_ERROR);
}
}
/*
* See if there was an error...
*/
if (http->error)
{
http->status = HTTP_ERROR;
return (HTTP_ERROR);
}
/*
@@ -1122,8 +1261,8 @@ httpUpdate(http_t *http) /* I - HTTP data */
*/
char * /* O - Decoded string */
httpDecode64(char *out, /* I - String to write to */
char *in) /* I - String to read from */
httpDecode64(char *out, /* I - String to write to */
const char *in) /* I - String to read from */
{
int pos, /* Bit position */
base64; /* Value of this character */
@@ -1193,8 +1332,8 @@ httpDecode64(char *out, /* I - String to write to */
*/
char * /* O - Encoded string */
httpEncode64(char *out, /* I - String to write to */
char *in) /* I - String to read from */
httpEncode64(char *out, /* I - String to write to */
const char *in) /* I - String to read from */
{
char *outptr; /* Output pointer */
static char base64[] = /* Base64 characters... */
@@ -1217,7 +1356,10 @@ httpEncode64(char *out, /* I - String to write to */
in ++;
if (*in == '\0')
{
*outptr ++ = '=';
break;
}
*outptr ++ = base64[((in[0] << 2) | (in[1] >> 6)) & 63];
@@ -1244,17 +1386,21 @@ httpEncode64(char *out, /* I - String to write to */
* content-length or transfer-encoding fields.
*/
int
int /* O - Content length */
httpGetLength(http_t *http) /* I - HTTP data */
{
DEBUG_printf(("httpGetLength(%08x)\n", http));
if (strcasecmp(http->fields[HTTP_FIELD_TRANSFER_ENCODING], "chunked") == 0)
{
DEBUG_puts("httpGetLength: chunked request!");
http->data_encoding = HTTP_ENCODE_CHUNKED;
http->data_remaining = 0;
}
else
{
http->data_encoding = HTTP_ENCODE_LENGTH;
http->data_encoding = HTTP_ENCODE_LENGTH;
/*
* The following is a hack for HTTP servers that don't send a
@@ -1268,6 +1414,8 @@ httpGetLength(http_t *http) /* I - HTTP data */
http->data_remaining = 2147483647;
else
http->data_remaining = atoi(http->fields[HTTP_FIELD_CONTENT_LENGTH]);
DEBUG_printf(("httpGetLength: content_length = %d\n", http->data_remaining));
}
return (http->data_remaining);
@@ -1279,7 +1427,7 @@ httpGetLength(http_t *http) /* I - HTTP data */
*/
static http_field_t /* O - Field index */
http_field(char *name) /* I - String name */
http_field(const char *name) /* I - String name */
{
int i; /* Looping var */
@@ -1299,12 +1447,12 @@ http_field(char *name) /* I - String name */
static int /* O - 0 on success, non-zero on error */
http_send(http_t *http, /* I - HTTP data */
http_state_t request, /* I - Request code */
char *uri) /* I - URI */
const char *uri) /* I - URI */
{
int i; /* Looping var */
char *ptr, /* Pointer in buffer */
buf[1024]; /* Encoded URI buffer */
static char *codes[] = /* Request code strings */
static const char *codes[] = /* Request code strings */
{
NULL,
"OPTIONS",
@@ -1320,7 +1468,7 @@ http_send(http_t *http, /* I - HTTP data */
"TRACE",
"CLOSE"
};
static char *hex = "0123456789ABCDEF";
static const char *hex = "0123456789ABCDEF";
/* Hex digits */
@@ -1343,6 +1491,13 @@ http_send(http_t *http, /* I - HTTP data */
*ptr = '\0';
/*
* See if we had an error the last time around; if so, reconnect...
*/
if (http->status == HTTP_ERROR || http->status >= HTTP_BAD_REQUEST)
httpReconnect(http);
/*
* Send the request header...
*/
@@ -1351,22 +1506,12 @@ http_send(http_t *http, /* I - HTTP data */
if (request == HTTP_POST || request == HTTP_PUT)
http->state ++;
if (httpPrintf(http, "%s %s HTTP/1.1\n", codes[request], buf) < 1)
http->status = HTTP_CONTINUE;
if (httpPrintf(http, "%s %s HTTP/1.1\r\n", codes[request], buf) < 1)
{
/*
* Might have lost connection; try to reconnect...
*/
if (httpReconnect(http))
return (-1);
/*
* OK, we've reconnected, send the request again...
*/
if (httpPrintf(http, "%s %s HTTP/%d.%d\n", codes[request], buf,
http->version / 100, http->version % 100) < 1)
return (-1);
http->status = HTTP_ERROR;
return (-1);
}
for (i = 0; i < HTTP_FIELD_MAX; i ++)
@@ -1374,12 +1519,18 @@ http_send(http_t *http, /* I - HTTP data */
{
DEBUG_printf(("%s: %s\n", http_fields[i], http->fields[i]));
if (httpPrintf(http, "%s: %s\n", http_fields[i], http->fields[i]) < 1)
return (-1);
if (httpPrintf(http, "%s: %s\r\n", http_fields[i], http->fields[i]) < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
}
if (httpPrintf(http, "\n") < 1)
if (httpPrintf(http, "\r\n") < 1)
{
http->status = HTTP_ERROR;
return (-1);
}
httpClearFields(http);
+46 -47
Ver Arquivo
@@ -4,7 +4,7 @@
* Hyper-Text Transport Protocol definitions for the Common UNIX Printing
* System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -15,7 +15,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -47,6 +47,8 @@
# include <netinet/tcp.h>
# endif /* WIN32 || __EMX__ */
# include "md5.h"
/*
* C++ magic...
@@ -63,7 +65,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 8192 /* Max length of data buffer */
# define HTTP_MAX_BUFFER 2048 /* Max length of data buffer */
# define HTTP_MAX_VALUE 256 /* Max header field value length */
@@ -124,6 +126,21 @@ 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...
*/
@@ -131,7 +148,8 @@ typedef enum
typedef enum
{
HTTP_ERROR = -1, /* An error response from httpXxxx() */
HTTP_CONTINUE, /* Everything OK, keep going... */
HTTP_CONTINUE = 100, /* Everything OK, keep going... */
HTTP_OK = 200, /* OPTIONS/GET/HEAD/POST/TRACE command was successful */
HTTP_CREATED, /* PUT command was successful */
@@ -181,18 +199,10 @@ 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,
@@ -202,38 +212,19 @@ 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;
@@ -247,6 +238,7 @@ 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 */
@@ -263,6 +255,11 @@ 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 */
} http_t;
@@ -271,34 +268,36 @@ 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(char *host, int port);
extern int httpDelete(http_t *http, char *uri);
extern http_t *httpConnect(const char *host, int port);
extern int httpDelete(http_t *http, const char *uri);
# define httpError(http) ((http)->error)
extern void httpFlush(http_t *http);
extern int httpGet(http_t *http, char *uri);
extern int httpGet(http_t *http, const char *uri);
extern char *httpGets(char *line, int length, http_t *http);
extern char *httpGetDateString(time_t t);
extern time_t httpGetDateTime(char *s);
extern const char *httpGetDateString(time_t t);
extern time_t httpGetDateTime(const char *s);
# define httpGetField(http,field) (http)->fields[field]
extern int httpHead(http_t *http, char *uri);
extern int httpHead(http_t *http, const char *uri);
extern void httpInitialize(void);
extern int httpOptions(http_t *http, char *uri);
extern int httpPost(http_t *http, char *uri);
extern int httpOptions(http_t *http, const char *uri);
extern int httpPost(http_t *http, const char *uri);
extern int httpPrintf(http_t *http, const char *format, ...);
extern int httpPut(http_t *http, char *uri);
extern int httpPut(http_t *http, const char *uri);
extern int httpRead(http_t *http, char *buffer, int length);
extern int httpReconnect(http_t *http);
extern void httpSeparate(char *uri, char *method, char *username,
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, char *value);
extern char *httpStatus(http_status_t status);
extern int httpTrace(http_t *http, char *uri);
extern void httpSetField(http_t *http, http_field_t field, const char *value);
extern const char *httpStatus(http_status_t status);
extern int httpTrace(http_t *http, const char *uri);
extern http_status_t httpUpdate(http_t *http);
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 httpWrite(http_t *http, const char *buffer, int length);
extern char *httpEncode64(char *out, const char *in);
extern char *httpDecode64(char *out, const char *in);
extern int httpGetLength(http_t *http);
+324 -123
Ver Arquivo
@@ -4,7 +4,7 @@
* Internet Printing Protocol support functions for the Common UNIX
* Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -38,13 +38,14 @@
* 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.
* ippPort() - Return the default IPP port number.
* ippRead() - Read data for an IPP request.
* ippTimeToDate() - Convert from UNIX time to RFC 1903 format.
* ippWrite() - Write data for an IPP request.
* add_attr() - Add a new attribute to the request.
* _ipp_add_attr() - Add a new attribute to the request.
* ipp_read() - Semi-blocking read on a HTTP connection...
*/
@@ -54,7 +55,8 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "string.h"
#include "language.h"
#include "ipp.h"
#include "debug.h"
@@ -64,8 +66,7 @@
* Local functions...
*/
static ipp_attribute_t *add_attr(ipp_t *ipp, int num_values);
static int ipp_read(http_t *http, char *buffer, int length);
static int ipp_read(http_t *http, unsigned char *buffer, int length);
/*
@@ -73,10 +74,10 @@ static int ipp_read(http_t *http, char *buffer, int length);
*/
ipp_attribute_t * /* O - New 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 */
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 */
{
ipp_attribute_t *attr; /* New attribute */
@@ -86,7 +87,7 @@ ippAddBoolean(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, 1)) == NULL)
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -103,11 +104,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 */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
char *values) /* I - Values */
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 */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -119,7 +120,7 @@ ippAddBooleans(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, num_values)) == NULL)
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -139,10 +140,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 */
char *name, /* I - Name of attribute */
ipp_uchar_t *value) /* I - Value */
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 */
{
ipp_attribute_t *attr; /* New attribute */
@@ -153,7 +154,7 @@ ippAddDate(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL || value == NULL)
return (NULL);
if ((attr = add_attr(ipp, 1)) == NULL)
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -170,11 +171,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 */
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 */
const char *name, /* I - Name of attribute */
int value) /* I - Value of attribute */
{
ipp_attribute_t *attr; /* New attribute */
@@ -185,7 +186,7 @@ ippAddInteger(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, 1)) == NULL)
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -202,12 +203,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 */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
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 */
const char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
const int *values) /* I - Values */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -216,7 +217,7 @@ ippAddIntegers(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, num_values)) == NULL)
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -236,12 +237,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 */
char *name, /* I - Name of attribute */
char *charset, /* I - Character set */
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 */
const char *name, /* I - Name of attribute */
const char *charset, /* I - Character set */
const char *value) /* I - Value */
{
ipp_attribute_t *attr; /* New attribute */
@@ -249,7 +250,7 @@ ippAddString(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, 1)) == NULL)
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -267,13 +268,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 */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
char *charset, /* I - Character set */
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 */
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 */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -282,7 +283,7 @@ ippAddStrings(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, num_values)) == NULL)
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -309,11 +310,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 */
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 */
const char *name, /* I - Name of attribute */
int lower, /* I - Lower value */
int upper) /* I - Upper value */
{
ipp_attribute_t *attr; /* New attribute */
@@ -321,7 +322,7 @@ ippAddRange(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, 1)) == NULL)
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -339,12 +340,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 */
char *name, /* I - Name of attribute */
int num_values, /* I - Number of values */
int *lower, /* I - Lower values */
int *upper) /* I - Upper values */
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 */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -353,7 +354,7 @@ ippAddRanges(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, num_values)) == NULL)
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -376,12 +377,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 */
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 */
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 */
{
ipp_attribute_t *attr; /* New attribute */
@@ -389,7 +390,7 @@ ippAddResolution(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, 1)) == NULL)
if ((attr = _ipp_add_attr(ipp, 1)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -408,13 +409,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 */
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 */
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 */
{
int i; /* Looping var */
ipp_attribute_t *attr; /* New attribute */
@@ -423,7 +424,7 @@ ippAddResolutions(ipp_t *ipp, /* I - IPP request */
if (ipp == NULL || name == NULL)
return (NULL);
if ((attr = add_attr(ipp, num_values)) == NULL)
if ((attr = _ipp_add_attr(ipp, num_values)) == NULL)
return (NULL);
attr->name = strdup(name);
@@ -457,7 +458,7 @@ ippAddSeparator(ipp_t *ipp) /* I - IPP request */
if (ipp == NULL)
return (NULL);
if ((attr = add_attr(ipp, 0)) == NULL)
if ((attr = _ipp_add_attr(ipp, 0)) == NULL)
return (NULL);
attr->group_tag = IPP_TAG_ZERO;
@@ -472,8 +473,8 @@ ippAddSeparator(ipp_t *ipp) /* I - IPP request */
* in seconds.
*/
time_t /* O - UNIX time value */
ippDateToTime(ipp_uchar_t *date)/* I - RFC 1903 date info */
time_t /* O - UNIX time value */
ippDateToTime(const ipp_uchar_t *date) /* I - RFC 1903 date info */
{
struct tm unixdate; /* UNIX date/time info */
time_t t; /* Computed time */
@@ -571,14 +572,91 @@ ippDelete(ipp_t *ipp) /* I - IPP request */
}
/*
* '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_UNAVAILABLE :
case IPP_TEMPORARY_ERROR :
case IPP_PRINTER_BUSY :
return (cupsLangString(language, HTTP_SERVICE_UNAVAILABLE));
case IPP_NOT_ACCEPTING :
return (cupsLangString(language, CUPS_MSG_NOT_ACCEPTING_JOBS));
}
return ("ERROR");
}
/*
* 'ippFindAttribute()' - Find a named attribute in a request...
*/
ipp_attribute_t * /* O - Matching attribute */
ippFindAttribute(ipp_t *ipp, /* I - IPP request */
char *name, /* I - Name of attribute */
ipp_tag_t type) /* I - Type of attribute */
ippFindAttribute(ipp_t *ipp, /* I - IPP request */
const char *name, /* I - Name of attribute */
ipp_tag_t type) /* I - Type of attribute */
{
ipp_attribute_t *attr; /* Current atttribute */
@@ -593,7 +671,7 @@ ippFindAttribute(ipp_t *ipp, /* I - IPP request */
DEBUG_printf(("ippFindAttribute: attr = %08x, name = \'%s\'\n", attr,
attr->name));
if (attr->name != NULL && strcmp(attr->name, name) == 0 &&
if (attr->name != NULL && strcasecmp(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)))
@@ -689,11 +767,16 @@ ippLength(ipp_t *ipp) /* I - IPP request */
case IPP_TAG_TEXTLANG :
case IPP_TAG_NAMELANG :
bytes += 2 * attr->num_values;/* Charset length */
bytes += 4 * attr->num_values;/* Charset + text 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;
}
}
@@ -707,10 +790,27 @@ ippLength(ipp_t *ipp) /* I - IPP request */
}
/*
* 'ippNew()' - Allocate a new IPP request.
*/
ipp_t * /* O - New IPP request */
ippNew(void)
{
return ((ipp_t *)calloc(sizeof(ipp_t), 1));
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);
}
@@ -723,7 +823,8 @@ ippRead(http_t *http, /* I - HTTP data */
ipp_t *ipp) /* I - IPP data */
{
int n; /* Length of data */
char buffer[8192]; /* Data buffer */
unsigned char buffer[8192], /* Data buffer */
*bufptr; /* Pointer into buffer */
ipp_attribute_t *attr; /* Current attribute */
ipp_tag_t tag; /* Current tag */
@@ -801,7 +902,7 @@ ippRead(http_t *http, /* I - HTTP data */
ipp->state = IPP_DATA;
break;
}
else if (tag <= IPP_TAG_UNSUPPORTED)
else if (tag < IPP_TAG_UNSUPPORTED_VALUE)
{
/*
* Group tag... Set the current group and continue...
@@ -861,11 +962,11 @@ ippRead(http_t *http, /* I - HTTP data */
buffer[n] = '\0';
DEBUG_printf(("ippRead: name = \'%s\'\n", buffer));
attr = ipp->current = add_attr(ipp, IPP_MAX_VALUES);
attr = ipp->current = _ipp_add_attr(ipp, IPP_MAX_VALUES);
attr->group_tag = ipp->curtag;
attr->value_tag = tag;
attr->name = strdup(buffer);
attr->name = strdup((char *)buffer);
attr->num_values = 0;
}
@@ -911,7 +1012,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(buffer);
attr->values[attr->num_values].string.text = strdup((char *)buffer);
break;
case IPP_TAG_DATE :
if (ipp_read(http, buffer, 11) < 11)
@@ -948,21 +1049,45 @@ ippRead(http_t *http, /* I - HTTP data */
if (ipp_read(http, buffer, n) < n)
return (IPP_ERROR);
buffer[n] = '\0';
bufptr = buffer;
attr->values[attr->num_values].string.charset = strdup(buffer);
/*
* text-with-language and name-with-language are composite
* values:
*
* charset-length
* charset
* text-length
* text
*/
if (ipp_read(http, buffer, 2) < 2)
return (IPP_ERROR);
n = (bufptr[0] << 8) | bufptr[1];
n = (buffer[0] << 8) | buffer[1];
attr->values[attr->num_values].string.charset = calloc(n + 1, 1);
if (ipp_read(http, buffer, n) < n)
return (IPP_ERROR);
memcpy(attr->values[attr->num_values].string.charset,
bufptr + 2, n);
buffer[n] = '\0';
bufptr += 2 + n;
n = (bufptr[0] << 8) | bufptr[1];
attr->values[attr->num_values].string.text = strdup(buffer);
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;
break;
}
@@ -989,7 +1114,7 @@ ippRead(http_t *http, /* I - HTTP data */
* 'ippTimeToDate()' - Convert from UNIX time to RFC 1903 format.
*/
ipp_uchar_t * /* O - RFC-1903 date/time data */
const ipp_uchar_t * /* O - RFC-1903 date/time data */
ippTimeToDate(time_t t) /* I - UNIX time value */
{
struct tm *unixdate; /* UNIX unixdate/time info */
@@ -1042,7 +1167,7 @@ ippWrite(http_t *http, /* I - HTTP data */
{
int i; /* Looping var */
int n; /* Length of data */
char buffer[8192], /* Data buffer */
unsigned char buffer[8192], /* Data buffer */
*bufptr; /* Pointer into buffer */
ipp_attribute_t *attr; /* Current attribute */
@@ -1062,8 +1187,8 @@ ippWrite(http_t *http, /* I - HTTP data */
bufptr = buffer;
*bufptr++ = 1;
*bufptr++ = 0;
*bufptr++ = ipp->request.any.version[0];
*bufptr++ = ipp->request.any.version[1];
*bufptr++ = ipp->request.any.op_status >> 8;
*bufptr++ = ipp->request.any.op_status;
*bufptr++ = ipp->request.any.request_id >> 24;
@@ -1071,7 +1196,7 @@ ippWrite(http_t *http, /* I - HTTP data */
*bufptr++ = ipp->request.any.request_id >> 8;
*bufptr++ = ipp->request.any.request_id;
if (httpWrite(http, buffer, bufptr - buffer) < 0)
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP header...");
return (IPP_ERROR);
@@ -1206,6 +1331,17 @@ 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);
@@ -1308,26 +1444,92 @@ 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, buffer, bufptr - buffer) < 0)
if (httpWrite(http, (char *)buffer, bufptr - buffer) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP attribute...");
return (IPP_ERROR);
@@ -1350,7 +1552,7 @@ ippWrite(http_t *http, /* I - HTTP data */
*/
buffer[0] = IPP_TAG_END;
if (httpWrite(http, buffer, 1) < 0)
if (httpWrite(http, (char *)buffer, 1) < 0)
{
DEBUG_puts("ippWrite: Could not write IPP end-tag...");
return (IPP_ERROR);
@@ -1375,11 +1577,11 @@ ippWrite(http_t *http, /* I - HTTP data */
int /* O - Port number */
ippPort(void)
{
char *server_port; /* SERVER_PORT environment variable */
const char *server_port; /* SERVER_PORT environment variable */
struct servent *port; /* Port number info */
if ((server_port = getenv("SERVER_PORT")) != NULL)
if ((server_port = getenv("IPP_PORT")) != NULL)
return (atoi(server_port));
else if ((port = getservbyname("ipp", NULL)) == NULL)
return (IPP_PORT);
@@ -1389,17 +1591,17 @@ ippPort(void)
/*
* 'add_attr()' - Add a new attribute to the request.
* '_ipp_add_attr()' - Add a new attribute to the request.
*/
static ipp_attribute_t * /* O - New attribute */
add_attr(ipp_t *ipp, /* I - IPP request */
int num_values) /* I - Number of values */
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 */
ipp_attribute_t *attr; /* New attribute */
DEBUG_printf(("add_attr(%08x, %d)\n", ipp, num_values));
DEBUG_printf(("_ipp_add_attr(%08x, %d)\n", ipp, num_values));
if (ipp == NULL || num_values < 0)
return (NULL);
@@ -1427,13 +1629,13 @@ add_attr(ipp_t *ipp, /* I - IPP request */
* 'ipp_read()' - Semi-blocking read on a HTTP connection...
*/
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 */
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 */
{
int tbytes, /* Total bytes read */
bytes; /* Bytes read this pass */
int tbytes, /* Total bytes read */
bytes; /* Bytes read this pass */
/*
@@ -1441,7 +1643,7 @@ ipp_read(http_t *http, /* I - Client connection */
*/
for (tbytes = 0; tbytes < length; tbytes += bytes, buffer += bytes)
if ((bytes = httpRead(http, buffer, length - tbytes)) <= 0)
if ((bytes = httpRead(http, (char *)buffer, length - tbytes)) <= 0)
break;
/*
@@ -1452,7 +1654,6 @@ ipp_read(http_t *http, /* I - Client connection */
}
/*
* End of "$Id$".
*/
+37 -21
Ver Arquivo
@@ -4,7 +4,7 @@
* Internet Printing Protocol definitions for the Common UNIX Printing
* System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -75,8 +75,8 @@ typedef enum /**** Format tags for attribute formats... ****/
IPP_TAG_JOB,
IPP_TAG_END,
IPP_TAG_PRINTER,
IPP_TAG_EXTENSION,
IPP_TAG_UNSUPPORTED = 0x10,
IPP_TAG_UNSUPPORTED_GROUP,
IPP_TAG_UNSUPPORTED_VALUE = 0x10,
IPP_TAG_DEFAULT,
IPP_TAG_UNKNOWN,
IPP_TAG_NOVALUE,
@@ -87,11 +87,12 @@ 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,
IPP_TAG_KEYWORD = 0x44,
IPP_TAG_URI,
IPP_TAG_URISCHEME,
IPP_TAG_CHARSET,
@@ -143,7 +144,7 @@ typedef enum /**** Job States.... */
IPP_JOB_HELD,
IPP_JOB_PROCESSING,
IPP_JOB_STOPPED,
IPP_JOB_CANCELED,
IPP_JOB_CANCELLED,
IPP_JOB_ABORTED,
IPP_JOB_COMPLETED
} ipp_jstate_t;
@@ -176,12 +177,15 @@ typedef enum /**** IPP operations... ****/
IPP_GET_JOB_ATTRIBUTES,
IPP_GET_JOBS,
IPP_GET_PRINTER_ATTRIBUTES,
IPP_HOLD_JOB = 0x000c,
IPP_HOLD_JOB,
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,
@@ -192,7 +196,9 @@ typedef enum /**** IPP operations... ****/
CUPS_DELETE_CLASS,
CUPS_ACCEPT_JOBS,
CUPS_REJECT_JOBS,
CUPS_SET_DEFAULT
CUPS_SET_DEFAULT,
CUPS_GET_DEVICES,
CUPS_GET_PPDS
} ipp_op_t;
typedef enum /**** IPP status codes... ****/
@@ -278,6 +284,12 @@ 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 ****/
@@ -306,28 +318,32 @@ typedef struct /**** Request State ****/
* Prototypes...
*/
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 *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 ipp_attribute_t *ippAddSeparator(ipp_t *ipp);
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 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 void ippDelete(ipp_t *ipp);
extern ipp_attribute_t *ippFindAttribute(ipp_t *ipp, char *name, ipp_tag_t type);
extern const char *ippErrorString(ipp_status_t error);
extern ipp_attribute_t *ippFindAttribute(ipp_t *ipp, const 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 ipp_uchar_t *ippTimeToDate(time_t t);
extern const ipp_uchar_t *ippTimeToDate(time_t t);
extern ipp_state_t ippWrite(http_t *http, ipp_t *ipp);
extern int ippPort(void);
extern ipp_attribute_t *_ipp_add_attr(ipp_t *, int);
/*
* C++ magic...
*/
+39 -19
Ver Arquivo
@@ -3,7 +3,7 @@
*
* I18N/language support for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -127,10 +127,11 @@ cupsLangFree(cups_lang_t *lang) /* I - Language to free */
*/
cups_lang_t * /* O - Language data */
cupsLangGet(char *language) /* I - Language or locale */
cupsLangGet(const char *language) /* I - Language or locale */
{
int i, count; /* Looping vars */
char real[16], /* Real language name */
char langname[16], /* Requested language name */
real[16], /* Real language name */
filename[1024], /* Filename for language locale file */
*localedir; /* Directory for locale files */
FILE *fp; /* Language locale file pointer */
@@ -145,30 +146,48 @@ cupsLangGet(char *language) /* I - Language or locale */
* standard POSIX locale and is copied unchanged. Otherwise the
* 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.
* operating systems. Any trailing character set specification is
* dropped.
*/
if (language == NULL || language[0] == '\0')
language = "C";
if (language == NULL || language[0] == '\0' ||
strcmp(language, "POSIX") == 0)
strcpy(langname, "C");
else
{
/*
* Copy the locale string over safely...
*/
if (strlen(language) < 2)
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)
strcpy(real, "C");
else
{
real[0] = tolower(language[0]);
real[1] = tolower(language[1]);
real[0] = tolower(langname[0]);
real[1] = tolower(langname[1]);
if (language[2] == '_' || language[2] == '-')
if (langname[2] == '_' || langname[2] == '-')
{
real[2] = '_';
real[3] = toupper(language[3]);
real[4] = toupper(language[4]);
real[3] = toupper(langname[3]);
real[4] = toupper(langname[4]);
real[5] = '\0';
language[5] = '\0';
langname[5] = '\0';
}
else
{
language[2] = '\0';
langname[2] = '\0';
real[2] = '\0';
}
}
@@ -182,7 +201,7 @@ cupsLangGet(char *language) /* I - Language or locale */
if ((localedir = getenv("LOCALEDIR")) == NULL)
localedir = CUPS_LOCALEDIR;
sprintf(filename, "%s/%s/cups_%s", localedir, real, real);
snprintf(filename, sizeof(filename), "%s/%s/cups_%s", localedir, real, real);
if ((fp = fopen(filename, "r")) == NULL)
if (strlen(real) > 2)
@@ -192,7 +211,8 @@ cupsLangGet(char *language) /* I - Language or locale */
*/
real[2] = '\0';
sprintf(filename, "%s/%s/cups_%s", localedir, real, real);
snprintf(filename, sizeof(filename), "%s/%s/cups_%s", localedir, real,
real);
fp = fopen(filename, "r");
}
@@ -201,7 +221,7 @@ cupsLangGet(char *language) /* I - Language or locale */
*/
for (lang = lang_cache; lang != NULL; lang = lang->next)
if (strcmp(lang->language, language) == 0)
if (strcmp(lang->language, langname) == 0)
{
lang->used ++;
@@ -288,7 +308,7 @@ cupsLangGet(char *language) /* I - Language or locale */
*/
lang->used ++;
strcpy(lang->language, language);
strcpy(lang->language, langname);
for (i = 0; i < (sizeof(lang_encodings) / sizeof(lang_encodings[0])); i ++)
if (strcmp(lang_encodings[i], line) == 0)
+44 -23
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Multi-language support for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -48,13 +48,11 @@ typedef enum /**** Message Indices ****/
CUPS_MSG_CLOSE,
CUPS_MSG_YES,
CUPS_MSG_NO,
CUPS_MSG_AUTO,
CUPS_MSG_ON,
CUPS_MSG_OFF,
CUPS_MSG_SAVE,
CUPS_MSG_DISCARD,
CUPS_MSG_DEFAULT,
CUPS_MSG_USER_DEFINED,
CUPS_MSG_OPTIONS,
CUPS_MSG_MORE_INFO,
CUPS_MSG_BLACK,
@@ -63,18 +61,14 @@ typedef enum /**** Message Indices ****/
CUPS_MSG_MAGENTA,
CUPS_MSG_YELLOW,
CUPS_MSG_COPYRIGHT,
CUPS_MSG_ALL_RIGHTS_RESERVED,
CUPS_MSG_GENERAL,
CUPS_MSG_PRINTER,
CUPS_MSG_POSTSCRIPT,
CUPS_MSG_IMAGE,
CUPS_MSG_TEXT,
CUPS_MSG_HPGL,
CUPS_MSG_ADVANCED,
CUPS_MSG_PRINT_BANNER_PAGE,
CUPS_MSG_VERBOSE_LOGGING,
CUPS_MSG_PRINT_PAGES,
CUPS_MSG_HPGL2,
CUPS_MSG_EXTRA,
CUPS_MSG_DOCUMENT,
CUPS_MSG_OTHER,
CUPS_MSG_PRINT_PAGES,
CUPS_MSG_ENTIRE_DOCUMENT,
CUPS_MSG_PAGE_RANGE,
CUPS_MSG_REVERSE_ORDER,
@@ -87,22 +81,16 @@ typedef enum /**** Message Indices ****/
CUPS_MSG_ZOOM_BY_PERCENT,
CUPS_MSG_ZOOM_BY_PPI,
CUPS_MSG_MIRROR_IMAGE,
CUPS_MSG_ROTATE_IMAGE,
CUPS_MSG_BEST_FIT,
CUPS_MSG_COLOR_SATURATION,
CUPS_MSG_COLOR_HUE,
CUPS_MSG_NUMBER_OF_COLUMNS,
CUPS_MSG_MARGINS,
CUPS_MSG_WRAP_TEXT,
CUPS_MSG_FIT_TO_PAGE,
CUPS_MSG_SHADING,
CUPS_MSG_DEFAULT_PEN_WIDTH,
CUPS_MSG_GAMMA_CORRECTION,
CUPS_MSG_BRIGHTNESS,
CUPS_MSG_COLOR_PROFILE,
CUPS_MSG_ADD_PRINTER,
CUPS_MSG_DELETE_PRINTER,
CUPS_MSG_MODIFY_PRINTER,
CUPS_MSG_ADD,
CUPS_MSG_DELETE,
CUPS_MSG_MODIFY,
CUPS_MSG_PRINTER_URI,
CUPS_MSG_PRINTER_NAME,
CUPS_MSG_PRINTER_LOCATION,
@@ -134,6 +122,34 @@ typedef enum /**** Message Indices ****/
CUPS_MSG_IDLE,
CUPS_MSG_PROCESSING,
CUPS_MSG_STOPPED,
CUPS_MSG_ALL,
CUPS_MSG_ODD,
CUPS_MSG_EVEN_PAGES,
CUPS_MSG_DARKER_LIGHTER,
CUPS_MSG_MEDIA_SIZE,
CUPS_MSG_MEDIA_TYPE,
CUPS_MSG_MEDIA_SOURCE,
CUPS_MSG_ORIENTATION,
CUPS_MSG_PORTRAIT,
CUPS_MSG_LANDSCAPE,
CUPS_MSG_JOB_STATE,
CUPS_MSG_JOB_NAME,
CUPS_MSG_USER_NAME,
CUPS_MSG_PRIORITY,
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
@@ -170,11 +186,16 @@ typedef struct cups_lang_str /**** Language Cache Structure ****/
* Prototypes...
*/
# define cupsLangDefault() cupsLangGet(setlocale(LC_ALL, 0))
# 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 */
extern char *cupsLangEncoding(cups_lang_t *lang);
extern void cupsLangFlush(void);
extern void cupsLangFree(cups_lang_t *lang);
extern cups_lang_t *cupsLangGet(char *language);
extern cups_lang_t *cupsLangGet(const char *language);
# define cupsLangString(lang,msg) (lang)->messages[(msg)]
# ifdef __cplusplus
+88 -75
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Option marking routines for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -33,7 +33,6 @@
* 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.
*/
/*
@@ -48,8 +47,7 @@
* Local functions...
*/
static void ppd_defaults(ppd_group_t *g);
static void ppd_default(ppd_option_t *o);
static void ppd_defaults(ppd_file_t *ppd, ppd_group_t *g);
/*
@@ -59,9 +57,10 @@ static void ppd_default(ppd_option_t *o);
int /* O - Number of conflicts found */
ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
{
int i, j, /* Looping variables */
int i, j, k, /* Looping variables */
conflicts; /* Number of conflicts */
ppd_const_t *c; /* Current constraint */
ppd_group_t *g, *sg; /* Groups */
ppd_option_t *o1, *o2; /* Options */
ppd_choice_t *c1, *c2; /* Choices */
@@ -69,8 +68,22 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
if (ppd == NULL)
return (0);
/*
* Clear all conflicts...
*/
conflicts = 0;
for (i = ppd->num_groups, g = ppd->groups; i > 0; i --, g ++)
{
for (j = g->num_options, o1 = g->options; j > 0; j --, o1 ++)
o1->conflicted = 0;
for (j = g->num_subgroups, sg = g->subgroups; j > 0; j --, sg ++)
for (k = sg->num_options, o1 = sg->options; k > 0; k --, o1 ++)
o1->conflicted = 0;
}
/*
* Loop through all of the UI constraints and flag any options
* that conflict...
@@ -104,7 +117,7 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
if (c1->marked)
break;
if (j == 0)
if (j == 0 || strcasecmp(c1->choice, "None") == 0)
c1 = NULL;
}
@@ -134,7 +147,7 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
if (c2->marked)
break;
if (j == 0)
if (j == 0 || strcasecmp(c2->choice, "None") == 0)
c2 = NULL;
}
@@ -149,11 +162,6 @@ ppdConflicts(ppd_file_t *ppd) /* I - PPD to check */
o1->conflicted = 1;
o2->conflicted = 1;
}
else
{
o1->conflicted = 0;
o2->conflicted = 0;
}
}
/*
@@ -170,7 +178,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 */
char *choice) /* I - Name of choice */
const char *choice) /* I - Name of choice */
{
int i; /* Looping var */
ppd_choice_t *c; /* Current choice */
@@ -180,7 +188,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 (strcmp(c->choice, choice) == 0)
if (strcasecmp(c->choice, choice) == 0)
return (c);
return (NULL);
@@ -193,7 +201,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 */
char *option) /* I - Keyword/option name */
const char *option) /* I - Keyword/option name */
{
int i; /* Looping var */
ppd_option_t *o; /* Pointer to option */
@@ -217,7 +225,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 */
char *option) /* I - Option/Keyword name */
const char *option) /* I - Option/Keyword name */
{
int i, j, k; /* Looping vars */
ppd_option_t *o; /* Pointer to option */
@@ -231,12 +239,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 (strcmp(o->keyword, option) == 0)
if (strcasecmp(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 (strcmp(o->keyword, option) == 0)
if (strcasecmp(o->keyword, option) == 0)
return (o);
}
@@ -250,8 +258,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 */
char *option, /* I - Option/Keyword name */
char *choice) /* I - Choice name */
const char *option, /* I - Option/Keyword name */
const char *choice) /* I - Choice name */
{
ppd_option_t *o; /* Option pointer */
ppd_choice_t *c; /* Choice pointer */
@@ -279,19 +287,13 @@ 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(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;
ppd_defaults(ppd, g);
}
@@ -306,8 +308,8 @@ ppdMarkDefaults(ppd_file_t *ppd)/* I - PPD file record */
int /* O - Number of conflicts */
ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
char *option, /* I - Keyword */
char *choice) /* I - Option name */
const char *option, /* I - Keyword */
const char *choice) /* I - Option name */
{
int i; /* Looping var */
ppd_option_t *o; /* Option pointer */
@@ -317,7 +319,7 @@ ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
if (ppd == NULL)
return (0);
if (strcmp(option, "PageSize") == 0 && strncmp(choice, "Custom.", 7) == 0)
if (strcasecmp(option, "PageSize") == 0 && strncasecmp(choice, "Custom.", 7) == 0)
{
/*
* Handle variable page sizes...
@@ -331,35 +333,67 @@ ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
return (0);
for (i = o->num_choices, c = o->choices; i > 0; i --, c ++)
if (strcmp(c->choice, choice) == 0)
c->marked = 1;
else if (o->ui != PPD_UI_PICKMANY)
c->marked = 0;
if (strcasecmp(c->choice, choice) == 0)
break;
if (strcmp(option, "PageSize") == 0 || strcmp(option, "PageRegion") == 0)
if (i)
{
/*
* Mark current page size...
* Option found; mark it and then handle unmarking any other options.
*/
for (i = 0; i < ppd->num_sizes; i ++)
ppd->sizes[i].marked = strcmp(ppd->sizes[i].name, choice) == 0;
c->marked = 1;
/*
* Unmark the current PageSize or PageRegion setting, as appropriate...
*/
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;
if (strcmp(option, "PageSize") == 0)
if (strcasecmp(option, "PageSize") == 0 || strcasecmp(option, "PageRegion") == 0)
{
o = ppdFindOption(ppd, "PageRegion");
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 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;
}
}
else
else if (strcasecmp(option, "InputSlot") == 0)
{
o = ppdFindOption(ppd, "PageSize");
for (i = 0; i < o->num_choices; i ++)
o->choices[i].marked = 0;
/*
* 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;
}
}
@@ -372,7 +406,8 @@ ppdMarkOption(ppd_file_t *ppd, /* I - PPD file record */
*/
static void
ppd_defaults(ppd_group_t *g) /* I - Group to default */
ppd_defaults(ppd_file_t *ppd, /* I - PPD file */
ppd_group_t *g) /* I - Group to default */
{
int i; /* Looping var */
ppd_option_t *o; /* Current option */
@@ -383,33 +418,11 @@ ppd_defaults(ppd_group_t *g) /* I - Group to default */
return;
for (i = g->num_options, o = g->options; i > 0; i --, o ++)
if (strcmp(o->keyword, "PageRegion") != 0)
ppd_default(o);
if (strcasecmp(o->keyword, "PageRegion") != 0)
ppdMarkOption(ppd, o->keyword, o->defchoice);
for (i = g->num_subgroups, sg = g->subgroups; i > 0; i --, 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;
ppd_defaults(ppd, sg);
}
+392
Ver Arquivo
@@ -0,0 +1,392 @@
/*
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
@@ -0,0 +1,94 @@
/*
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 */
+79 -23
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Option routines for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -45,8 +45,8 @@
*/
int /* O - Number of options */
cupsAddOption(char *name, /* I - Name of option */
char *value, /* I - Value of option */
cupsAddOption(const char *name, /* I - Name of option */
const char *value, /* I - Value of option */
int num_options, /* I - Number of options */
cups_option_t **options) /* IO - Pointer to options */
{
@@ -62,7 +62,7 @@ cupsAddOption(char *name, /* I - Name of option */
*/
for (i = 0, temp = *options; i < num_options; i ++, temp ++)
if (strcmp(temp->name, name) == 0)
if (strcasecmp(temp->name, name) == 0)
break;
if (i >= num_options)
@@ -128,8 +128,8 @@ cupsFreeOptions(int num_options, /* I - Number of options */
* 'cupsGetOption()' - Get an option value.
*/
char * /* O - Option value or NULL */
cupsGetOption(char *name, /* I - Name of option */
const char * /* O - Option value or NULL */
cupsGetOption(const char *name, /* I - Name of option */
int num_options,/* I - Number of options */
cups_option_t *options) /* I - Options */
{
@@ -140,7 +140,7 @@ cupsGetOption(char *name, /* I - Name of option */
return (NULL);
for (i = 0; i < num_options; i ++)
if (strcmp(options[i].name, name) == 0)
if (strcasecmp(options[i].name, name) == 0)
return (options[i].value);
return (NULL);
@@ -152,7 +152,7 @@ cupsGetOption(char *name, /* I - Name of option */
*/
int /* O - Number of options found */
cupsParseOptions(char *arg, /* I - Argument to parse */
cupsParseOptions(const char *arg, /* I - Argument to parse */
int num_options, /* I - Number of options */
cups_option_t **options) /* O - Options found */
{
@@ -279,37 +279,93 @@ 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 (strcmp(options->name, "media") == 0)
if (strcasecmp(options->name, "media") == 0)
{
if (ppdMarkOption(ppd, "PageSize", options->value))
conflict = 1;
if (ppdMarkOption(ppd, "InputSlot", options->value))
conflict = 1;
if (ppdMarkOption(ppd, "MediaType", options->value))
conflict = 1;
/*
* 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;
}
}
else if (strcmp(options->name, "sides") == 0)
else if (strcasecmp(options->name, "sides") == 0)
{
if (strcmp(options->value, "one-sided") == 0)
if (strcasecmp(options->value, "one-sided") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "None"))
conflict = 1;
}
else if (strcmp(options->value, "two-sided-long-edge") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "NoTumble"))
if (ppdMarkOption(ppd, "EFDuplex", "None")) /* EFI */
conflict = 1;
if (ppdMarkOption(ppd, "KD03Duplex", "None")) /* Kodak */
conflict = 1;
}
else if (strcmp(options->value, "two-sided-short-edge") == 0)
else if (strcasecmp(options->value, "two-sided-long-edge") == 0)
{
if (ppdMarkOption(ppd, "Duplex", "Tumble"))
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 */
conflict = 1;
}
}
else if (strcasecmp(options->name, "resolution") == 0 ||
strcasecmp(options->name, "printer-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 (ppdMarkOption(ppd, options->name, options->value))
conflict = 1;
+42 -32
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Page size functions for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -45,7 +45,7 @@
ppd_size_t * /* O - Size record for page or NULL */
ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
char *name) /* I - Size name */
const char *name) /* I - Size name */
{
int i; /* Looping var */
float w, l; /* Width and length of page */
@@ -57,9 +57,19 @@ ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
if (name != NULL)
{
if (strncmp(name, "Custom.", 7) == 0 &&
strcmp(ppd->sizes[0].name, "Custom") == 0)
if (strncmp(name, "Custom.", 7) == 0 && ppd->variable_sizes)
{
/*
* 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:
*
@@ -70,47 +80,47 @@ ppdPageSize(ppd_file_t *ppd, /* I - PPD file record */
*/
units[0] = '\0';
if (sscanf(name + 7, "%fx%f%s", &w, &l, units) < 2)
if (sscanf(name + 7, "%fx%f%254s", &w, &l, units) < 2)
return (NULL);
if (strcasecmp(units, "in") == 0)
{
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];
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];
}
else if (strcasecmp(units, "cm") == 0)
{
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];
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];
}
else if (strcasecmp(units, "mm") == 0)
{
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];
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];
}
else
{
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];
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];
}
return (ppd->sizes);
return (ppd->sizes + i);
}
else
{
@@ -144,7 +154,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 */
char *name) /* I - Size name */
const char *name) /* I - Size name */
{
ppd_size_t *size; /* Page size */
@@ -162,7 +172,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 */
char *name) /* I - Size name */
const char *name) /* I - Size name */
{
ppd_size_t *size; /* Page size */
+422 -108
Ver Arquivo
@@ -3,7 +3,7 @@
*
* PPD file routines for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -40,17 +40,22 @@
* ppdOpenFile() - Read a PPD file into memory.
* ppd_read() - Read a line from a PPD file, skipping comment lines
* as necessary.
* compare_strings() - Compare two strings.
* compare_groups() - Compare two groups.
* compare_options() - Compare two options.
* compare_choices() - Compare two choices.
*/
/*
* Include necessary headers.
*/
/*#define DEBUG*/
#include "ppd.h"
#include <stdlib.h>
#include <ctype.h>
#include "string.h"
#include "language.h"
#include "debug.h"
/*
@@ -65,6 +70,8 @@
# 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 */
@@ -75,9 +82,14 @@
* Local functions...
*/
static int compare_strings(char *s, char *t);
static int compare_groups(ppd_group_t *g0, ppd_group_t *g1);
static int compare_options(ppd_option_t *o0, ppd_option_t *o1);
static int compare_choices(ppd_choice_t *c0, ppd_choice_t *c1);
static int ppd_read(FILE *fp, char *keyword, char *option,
char *text, char **string);
static void ppd_decode(char *string);
static void ppd_fix(char *string);
static void ppd_free_group(ppd_group_t *group);
static void ppd_free_option(ppd_option_t *option);
static ppd_group_t *ppd_get_group(ppd_file_t *ppd, char *name);
@@ -109,14 +121,14 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
* Free all strings at the top level...
*/
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);
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 any emulations...
@@ -126,11 +138,11 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
{
for (i = ppd->num_emulations, emul = ppd->emulations; i > 0; i --, emul ++)
{
free(emul->start);
free(emul->stop);
safe_free(emul->start);
safe_free(emul->stop);
}
free(ppd->emulations);
safe_free(ppd->emulations);
}
/*
@@ -142,7 +154,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);
free(ppd->groups);
safe_free(ppd->groups);
}
/*
@@ -150,14 +162,14 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
*/
if (ppd->num_sizes > 0)
free(ppd->sizes);
safe_free(ppd->sizes);
/*
* Free any constraints...
*/
if (ppd->num_consts > 0)
free(ppd->consts);
safe_free(ppd->consts);
/*
* Free any fonts...
@@ -166,9 +178,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 ++)
free(*font);
safe_free(*font);
free(ppd->fonts);
safe_free(ppd->fonts);
}
/*
@@ -176,13 +188,13 @@ ppdClose(ppd_file_t *ppd) /* I - PPD file record */
*/
if (ppd->num_profiles > 0)
free(ppd->profiles);
safe_free(ppd->profiles);
/*
* Free the whole record...
*/
free(ppd);
safe_free(ppd);
}
@@ -205,7 +217,7 @@ ppd_free_group(ppd_group_t *group) /* I - Group to free */
i --, option ++)
ppd_free_option(option);
free(group->options);
safe_free(group->options);
}
if (group->num_subgroups > 0)
@@ -215,7 +227,7 @@ ppd_free_group(ppd_group_t *group) /* I - Group to free */
i --, subgroup ++)
ppd_free_group(subgroup);
free(group->subgroups);
safe_free(group->subgroups);
}
}
@@ -236,9 +248,9 @@ ppd_free_option(ppd_option_t *option) /* I - Option to free */
for (i = option->num_choices, choice = option->choices;
i > 0;
i --, choice ++)
free(choice->code);
safe_free(choice->code);
free(option->choices);
safe_free(option->choices);
}
}
@@ -275,7 +287,7 @@ ppd_get_group(ppd_file_t *ppd, /* I - PPD file */
ppd->num_groups ++;
memset(group, 0, sizeof(ppd_group_t));
strcpy(group->text, name);
strncpy(group->text, name, sizeof(group->text) - 1);
}
return (group);
@@ -314,7 +326,7 @@ ppd_get_option(ppd_group_t *group, /* I - Group */
group->num_options ++;
memset(option, 0, sizeof(ppd_option_t));
strcpy(option->keyword, name);
strncpy(option->keyword, name, sizeof(option->keyword) - 1);
}
return (option);
@@ -346,7 +358,7 @@ ppd_add_choice(ppd_option_t *option, /* I - Option */
option->num_choices ++;
memset(choice, 0, sizeof(ppd_choice_t));
strcpy(choice->choice, name);
strncpy(choice->choice, name, sizeof(choice->choice) - 1);
return (choice);
}
@@ -376,7 +388,7 @@ ppd_add_size(ppd_file_t *ppd, /* I - PPD file */
ppd->num_sizes ++;
memset(size, 0, sizeof(ppd_size_t));
strcpy(size->name, name);
strncpy(size->name, name, sizeof(size->name) - 1);
return (size);
}
@@ -409,8 +421,15 @@ ppdOpen(FILE *fp) /* I - File to read from */
ppd_section_t section; /* Order dependency section */
ppd_profile_t *profile; /* Pointer to color profile */
char **filter; /* Pointer to filter */
cups_lang_t *language; /* Default language */
/*
* Get the default language for the user...
*/
language = cupsLangDefault();
/*
* Range check input...
*/
@@ -432,14 +451,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.
*/
if (string != NULL)
free(string);
safe_free(string);
return (NULL);
}
if (string != NULL)
free(string);
DEBUG_printf(("ppdOpen: keyword = %s, string = %08x\n", keyword, string));
safe_free(string);
/*
* Allocate memory for the PPD file record...
@@ -582,9 +601,10 @@ ppdOpen(FILE *fp) /* I - File to read from */
ppd->num_profiles ++;
memset(profile, 0, sizeof(ppd_profile_t));
strcpy(profile->resolution, name);
strcpy(profile->media_type, text);
sscanf(string, "%f%f%f%f%f%f%f%f%f%f", &(profile->density),
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),
profile->matrix[0] + 0, profile->matrix[0] + 1,
profile->matrix[0] + 2, profile->matrix[1] + 0,
profile->matrix[1] + 1, profile->matrix[1] + 2,
@@ -609,8 +629,11 @@ 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, "VariablePaperSize") == 0 &&
strcmp(string, "True") == 0)
strcmp(string, "True") == 0 &&
!ppd->variable_sizes)
{
ppd->variable_sizes = 1;
@@ -624,35 +647,38 @@ ppdOpen(FILE *fp) /* I - File to read from */
* Add a "Custom" page size option...
*/
if ((group = ppd_get_group(ppd, "General")) == NULL)
if ((group = ppd_get_group(ppd,
cupsLangString(language,
CUPS_MSG_GENERAL))) == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
if ((option = ppd_get_option(group, "PageSize")) == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
if ((choice = ppd_add_choice(option, "Custom")) == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
strcpy(choice->text, "Custom Size");
strncpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE),
sizeof(choice->text) - 1);
group = NULL;
option = NULL;
}
else if (strcmp(keyword, "MaxMediaWidth") == 0)
ppd->custom_max[0] = atof(string);
ppd->custom_max[0] = (float)atof(string);
else if (strcmp(keyword, "MaxMediaHeight") == 0)
ppd->custom_max[1] = atof(string);
ppd->custom_max[1] = (float)atof(string);
else if (strcmp(keyword, "ParamCustomPageSize") == 0)
{
if (strcmp(name, "Width") == 0)
@@ -667,20 +693,62 @@ 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 &&
ppd->variable_sizes)
strcmp(name, "True") == 0)
{
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 ((group = ppd_get_group(ppd,
cupsLangString(language,
CUPS_MSG_GENERAL))) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((option = ppd_get_option(group, "PageSize")) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((choice = ppd_add_choice(option, "Custom")) == NULL)
{
ppdClose(ppd);
safe_free(string);
return (NULL);
}
strncpy(choice->text, cupsLangString(language, CUPS_MSG_VARIABLE),
sizeof(choice->text) - 1);
group = NULL;
option = NULL;
}
if ((option = ppdFindOption(ppd, "PageSize")) == NULL)
{
ppdClose(ppd);
free(string);
ppdClose(ppd);
safe_free(string);
return (NULL);
}
if ((choice = ppdFindChoice(option, "Custom")) == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -773,45 +841,41 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (subgroup != NULL)
option = ppd_get_option(subgroup, name);
else
else if (group == NULL)
{
if (strcmp(name, "Collate") != 0 &&
strcmp(name, "Duplex") != 0 &&
strcmp(name, "InputSlot") != 0 &&
strcmp(name, "ManualFeed") != 0 &&
strcmp(name, "MediaType") != 0 &&
strcmp(name, "MediaColor") != 0 &&
strcmp(name, "MediaWeight") != 0 &&
strcmp(name, "OutputBin") != 0 &&
strcmp(name, "OutputMode") != 0 &&
strcmp(name, "OutputOrder") != 0 &&
strcmp(name, "PageSize") != 0 &&
strcmp(name, "PageRegion") != 0)
group = ppd_get_group(ppd, cupsLangString(language, CUPS_MSG_EXTRA));
else
group = ppd_get_group(ppd, cupsLangString(language, CUPS_MSG_GENERAL));
if (group == NULL)
{
if (strcmp(name, "Collate") != 0 &&
strcmp(name, "Duplex") != 0 &&
strcmp(name, "InputSlot") != 0 &&
strcmp(name, "ManualFeed") != 0 &&
strcmp(name, "MediaType") != 0 &&
strcmp(name, "MediaColor") != 0 &&
strcmp(name, "MediaWeight") != 0 &&
strcmp(name, "OutputBin") != 0 &&
strcmp(name, "OutputMode") != 0 &&
strcmp(name, "OutputOrder") != 0 &&
strcmp(name, "PageSize") != 0 &&
strcmp(name, "PageRegion") != 0)
group = ppd_get_group(ppd, "Printer");
else
group = ppd_get_group(ppd, "General");
if (group == NULL)
{
ppdClose(ppd);
free(string);
return (NULL);
}
option = ppd_get_option(group, name);
group = NULL;
ppdClose(ppd);
safe_free(string);
return (NULL);
}
else
option = ppd_get_option(group, name);
option = ppd_get_option(group, name);
group = NULL;
}
else
option = ppd_get_option(group, name);
if (option == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -826,7 +890,31 @@ ppdOpen(FILE *fp) /* I - File to read from */
else
option->ui = PPD_UI_PICKONE;
strcpy(option->text, text);
if (text[0])
{
strncpy(option->text, text, sizeof(option->text) - 1);
ppd_fix(option->text);
}
else
{
if (strcmp(name, "PageSize") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_SIZE),
sizeof(option->text) - 1);
else if (strcmp(name, "MediaType") == 0)
strncpy(option->text, cupsLangString(language, CUPS_MSG_MEDIA_TYPE),
sizeof(option->text) - 1);
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);
else
strncpy(option->text, name, sizeof(option->text) - 1);
}
option->section = PPD_ORDER_ANY;
}
@@ -836,19 +924,12 @@ ppdOpen(FILE *fp) /* I - File to read from */
* Find the JCL group, and add if needed...
*/
if (group != NULL)
{
ppdClose(ppd);
free(string);
return (NULL);
}
group = ppd_get_group(ppd, "JCL");
if (group == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -864,7 +945,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (option == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -879,7 +960,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
else
option->ui = PPD_UI_PICKONE;
strcpy(option->text, text);
strncpy(option->text, text, sizeof(option->text) - 1);
option->section = PPD_ORDER_JCL;
group = NULL;
@@ -896,13 +977,15 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (group != NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
if (strchr(string, '/') != NULL) /* Just show human readable text */
strcpy(string, strchr(string, '/') + 1);
ppd_decode(string);
ppd_fix(string);
group = ppd_get_group(ppd, string);
}
else if (strcmp(keyword, "CloseGroup") == 0)
@@ -916,7 +999,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (group == NULL || subgroup != NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -929,7 +1012,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (subgroup == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -938,17 +1021,19 @@ ppdOpen(FILE *fp) /* I - File to read from */
group->num_subgroups ++;
memset(subgroup, 0, sizeof(ppd_group_t));
strcpy(subgroup->text, string);
ppd_decode(string);
ppd_fix(string);
strncpy(subgroup->text, string, sizeof(subgroup->text) - 1);
}
else if (strcmp(keyword, "CloseSubGroup") == 0)
subgroup = NULL;
else if (strcmp(keyword, "OrderDependency") == 0 ||
strcmp(keyword, "NonUIOrderDependency") == 0)
{
if (sscanf(string, "%f%s%s", &order, name, keyword) != 3)
if (sscanf(string, "%f%40s%40s", &order, name, keyword) != 3)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -997,6 +1082,9 @@ ppdOpen(FILE *fp) /* I - File to read from */
}
else if (strncmp(keyword, "Default", 7) == 0)
{
if (string == NULL)
continue;
if (strchr(string, '/') != NULL)
*strchr(string, '/') = '\0';
@@ -1014,14 +1102,15 @@ ppdOpen(FILE *fp) /* I - File to read from */
for (i = 0; i < group->num_options; i ++)
if (strcmp(keyword, group->options[i].keyword) == 0)
{
strcpy(group->options[i].defchoice, string);
strncpy(group->options[i].defchoice, string,
sizeof(group->options[i].defchoice) - 1);
break;
}
group = NULL;
}
else
strcpy(option->defchoice, string);
strncpy(option->defchoice, string, sizeof(option->defchoice) - 1);
}
else if (strcmp(keyword, "UIConstraints") == 0 ||
strcmp(keyword, "NonUIConstraints") == 0)
@@ -1035,7 +1124,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (constraint == NULL)
{
ppdClose(ppd);
free(string);
safe_free(string);
return (NULL);
}
@@ -1043,14 +1132,14 @@ ppdOpen(FILE *fp) /* I - File to read from */
constraint += ppd->num_consts;
ppd->num_consts ++;
switch (sscanf(string, "%s%s%s%s", constraint->option1,
switch (sscanf(string, "%40s%40s%40s%40s", constraint->option1,
constraint->choice1, constraint->option2,
constraint->choice2))
{
case 0 : /* Error */
case 1 : /* Error */
ppdClose(ppd);
free(string);
safe_free(string);
break;
case 2 : /* Two options... */
@@ -1072,13 +1161,17 @@ ppdOpen(FILE *fp) /* I - File to read from */
if (constraint->choice1[0] == '*')
{
strcpy(constraint->choice2, constraint->option2);
strcpy(constraint->option2, constraint->choice1 + 1);
constraint->choice1[0] = '\0';
}
else if (constraint->option2[0] == '*')
strcpy(constraint->option2, constraint->option2 + 1);
else
{
if (constraint->option2[0] == '*')
strcpy(constraint->option2, constraint->option2 + 1);
constraint->choice2[0] = '\0';
constraint->choice2[0] = '\0';
}
break;
case 4 : /* Two options, two choices... */
@@ -1121,13 +1214,16 @@ ppdOpen(FILE *fp) /* I - File to read from */
choice = ppd_add_choice(option, name);
if (mask & PPD_TEXT)
strcpy(choice->text, text);
{
strncpy(choice->text, text, sizeof(choice->text) - 1);
ppd_fix(choice->text);
}
else if (strcmp(name, "True") == 0)
strcpy(choice->text, "Yes");
else if (strcmp(name, "False") == 0)
strcpy(choice->text, "No");
else
strcpy(choice->text, name);
strncpy(choice->text, name, sizeof(choice->text) - 1);
if (strncmp(keyword, "JCL", 3) == 0)
ppd_decode(string); /* Decode quoted string */
@@ -1136,8 +1232,7 @@ ppdOpen(FILE *fp) /* I - File to read from */
string = NULL; /* Don't free this string below */
}
if (string != NULL)
free(string);
safe_free(string);
}
#ifdef DEBUG
@@ -1149,24 +1244,48 @@ ppdOpen(FILE *fp) /* I - File to read from */
* Set the option back-pointer for each choice...
*/
qsort(ppd->groups, ppd->num_groups, sizeof(ppd_group_t),
(int (*)(const void *, const void *))compare_groups);
for (i = ppd->num_groups, group = ppd->groups;
i > 0;
i --, group ++)
{
qsort(group->options, group->num_options, sizeof(ppd_option_t),
(int (*)(const void *, const void *))compare_options);
for (j = group->num_options, option = group->options;
j > 0;
j --, option ++)
{
qsort(option->choices, option->num_choices, sizeof(ppd_choice_t),
(int (*)(const void *, const void *))compare_choices);
for (k = 0; k < option->num_choices; k ++)
option->choices[k].option = (void *)option;
}
qsort(group->subgroups, group->num_subgroups, sizeof(ppd_group_t),
(int (*)(const void *, const void *))compare_groups);
for (j = group->num_subgroups, subgroup = group->subgroups;
j > 0;
j --, subgroup ++)
{
qsort(subgroup->options, subgroup->num_options, sizeof(ppd_option_t),
(int (*)(const void *, const void *))compare_options);
for (k = group->num_options, option = group->options;
k > 0;
k --, option ++)
{
qsort(option->choices, option->num_choices, sizeof(ppd_choice_t),
(int (*)(const void *, const void *))compare_choices);
for (m = 0; m < option->num_choices; m ++)
option->choices[m].option = (void *)option;
}
}
}
return (ppd);
@@ -1201,7 +1320,7 @@ ppdOpenFd(int fd) /* I - File to read from */
ppd = ppdOpen(fp);
free(fp);
safe_free(fp);
}
else
ppd = NULL;
@@ -1215,7 +1334,7 @@ ppdOpenFd(int fd) /* I - File to read from */
*/
ppd_file_t * /* O - PPD file record */
ppdOpenFile(char *filename) /* I - File to read from */
ppdOpenFile(const char *filename) /* I - File to read from */
{
FILE *fp; /* File pointer */
ppd_file_t *ppd; /* PPD file record */
@@ -1245,6 +1364,151 @@ ppdOpenFile(char *filename) /* I - File to read from */
}
/*
* 'compare_strings()' - Compare two strings.
*/
int /* O - Result of comparison */
compare_strings(char *s, /* I - First string */
char *t) /* I - Second string */
{
int diff, /* Difference between digits */
digits; /* Number of digits */
/*
* Loop through both strings, returning only when a difference is
* seen. Also, compare whole numbers rather than just characters, too!
*/
while (*s && *t)
{
if (isdigit(*s) && isdigit(*t))
{
/*
* Got a number; start by skipping leading 0's...
*/
while (*s == '0')
s ++;
while (*t == '0')
t ++;
/*
* Skip equal digits...
*/
while (isdigit(*s) && *s == *t)
{
s ++;
t ++;
}
/*
* 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))
continue;
if (*s < *t)
diff = -1;
else
diff = 1;
/*
* Figure out how many more digits there are...
*/
digits = 0;
while (isdigit(*s))
{
digits ++;
s ++;
}
while (isdigit(*t))
{
digits --;
t ++;
}
/*
* Return if the number or value of the digits is different...
*/
if (digits < 0)
return (-1);
else if (digits > 0)
return (1);
else
return (diff);
}
else if (tolower(*s) < tolower(*t))
return (-1);
else if (tolower(*s) > tolower(*t))
return (1);
else
{
s ++;
t ++;
}
}
/*
* Return the results of the final comparison...
*/
if (*s)
return (1);
else if (*t)
return (-1);
else
return (0);
}
/*
* 'compare_groups()' - Compare two groups.
*/
static int /* O - Result of comparison */
compare_groups(ppd_group_t *g0, /* I - First group */
ppd_group_t *g1) /* I - Second group */
{
return (compare_strings(g0->text, g1->text));
}
/*
* 'compare_options()' - Compare two options.
*/
static int /* O - Result of comparison */
compare_options(ppd_option_t *o0,/* I - First option */
ppd_option_t *o1)/* I - Second option */
{
return (compare_strings(o0->text, o1->text));
}
/*
* 'compare_choices()' - Compare two choices.
*/
static int /* O - Result of comparison */
compare_choices(ppd_choice_t *c0,/* I - First choice */
ppd_choice_t *c1)/* I - Second choice */
{
return (compare_strings(c0->text, c1->text));
}
/*
* 'ppd_read()' - Read a line from a PPD file, skipping comment lines as
* necessary.
@@ -1495,6 +1759,56 @@ ppd_decode(char *string) /* I - String to decode */
}
/*
* 'ppd_fix()' - Fix WinANSI characters in the range 0x80 to 0x9f to be
* valid ISO-8859-1 characters...
*/
static void
ppd_fix(char *string) /* IO - String to fix */
{
unsigned char *p; /* Pointer into string */
static unsigned char lut[32] =/* Lookup table for characters */
{
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
0x20,
'l',
'`',
'\'',
'^',
'~',
0x20, /* bar */
0x20, /* circumflex */
0x20, /* dot */
0x20, /* double dot */
0x20,
0x20, /* circle */
0x20, /* ??? */
0x20,
'\"', /* should be right quotes */
0x20, /* ??? */
0x20 /* accent */
};
for (p = (unsigned char *)string; *p; p ++)
if (*p >= 0x80 && *p < 0xa0)
*p = lut[*p - 0x80];
}
/*
+15 -13
Ver Arquivo
@@ -4,7 +4,7 @@
* PostScript Printer Description definitions for the Common UNIX Printing
* System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -153,6 +153,7 @@ 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;
@@ -165,7 +166,8 @@ 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 */
manual_copies, /* 1 = Copies done manually, 0 = hardware */
throughput; /* Pages per minute */
ppd_cs_t colorspace; /* Default colorspace */
char *patches; /* Patch commands to be sent to printer */
int num_emulations; /* Number of emulations supported */
@@ -209,20 +211,20 @@ 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, char *keyword,
char *option);
extern int ppdIsMarked(ppd_file_t *ppd, const char *keyword,
const char *option);
extern void ppdMarkDefaults(ppd_file_t *ppd);
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 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 ppd_file_t *ppdOpen(FILE *fp);
extern ppd_file_t *ppdOpenFd(int fd);
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);
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);
/*
* C++ magic...
+287
Ver Arquivo
@@ -0,0 +1,287 @@
/*
* "$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$".
*/
+2 -2
Ver Arquivo
@@ -3,7 +3,7 @@
*
* String functions for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
+30 -2
Ver Arquivo
@@ -3,7 +3,7 @@
*
* String definitions for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -29,6 +29,8 @@
* Include necessary headers...
*/
# include <stdio.h>
# include <stdarg.h>
# include <config.h>
# include <string.h>
@@ -43,6 +45,15 @@
# endif /* WIN32 || __EMX__ */
/*
* C++ magic...
*/
# ifdef __cplusplus
extern "C" {
# endif /* __cplusplus */
/*
* Prototypes...
*/
@@ -59,6 +70,23 @@ 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_ */
/*
+2 -2
Ver Arquivo
@@ -3,7 +3,7 @@
*
* HTTP test program for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
+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 ".." /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 BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
+4 -4
Ver Arquivo
@@ -3,7 +3,7 @@
*
* PPD test program for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products, all rights reserved.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -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, n; /* Looping vars */
char *filename; /* File to load */
int i, j, k, m; /* Looping vars */
const char *filename; /* File to load */
ppd_file_t *ppd; /* PPD file record */
ppd_size_t *size; /* Size record */
ppd_group_t *group; /* UI group */
+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 ".." /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 BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
+181
Ver Arquivo
@@ -0,0 +1,181 @@
/*
* "$Id$"
*
* User, system, and password 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:
*
* cupsUser() - Return the current users name.
* cupsGetPassword() - Get a password from the user...
* cupsServer() - Return the hostname of the default server...
*/
/*
* Include necessary headers...
*/
#include "cups.h"
#include <config.h>
#include <stdlib.h>
#include <ctype.h>
#if defined(WIN32) || defined(__EMX__)
/*
* WIN32 and OS/2 username and password stuff...
*/
/*
* 'cupsUser()' - Return the current user's name.
*/
const char * /* O - User name */
cupsUser(void)
{
return ("WindowsUser");
}
/*
* 'cupsGetPassword()' - Get a password from the user...
*/
const char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return (NULL);
}
#else
/*
* UNIX username and password stuff...
*/
# include <pwd.h>
/*
* 'cupsUser()' - Return the current user's name.
*/
const char * /* O - User name */
cupsUser(void)
{
struct passwd *pwd; /* User/password entry */
/*
* Rewind the password file...
*/
setpwent();
/*
* Lookup the password entry for the current user.
*/
if ((pwd = getpwuid(getuid())) == NULL)
return ("unknown"); /* Unknown user! */
/*
* Rewind the password file again and return the username...
*/
setpwent();
return (pwd->pw_name);
}
/*
* 'cupsGetPassword()' - Get a password from the user...
*/
const char * /* O - Password */
cupsGetPassword(const char *prompt) /* I - Prompt string */
{
return (getpass(prompt));
}
#endif /* WIN32 || __EMX__ */
/*
* 'cupsServer()' - Return the hostname of the default server...
*/
const char * /* O - Server name */
cupsServer(void)
{
FILE *fp; /* client.conf file */
char *server; /* Pointer to server name */
static char line[1024]; /* Line from file */
/*
* First see if the CUPS_SERVER environment variable is set...
*/
if ((server = getenv("CUPS_SERVER")) != NULL)
return (server);
/*
* Next check to see if we have a client.conf file...
*/
if ((fp = fopen(CUPS_SERVERROOT "/client.conf", "r")) == NULL)
return ("localhost");
/*
* Read the client.conf file and look for a ServerName line...
*/
while (fgets(line, sizeof(line), fp) != NULL)
if (strncmp(line, "ServerName ", 11) == 0)
{
/*
* Got it! Drop any trailing newline and find the name...
*/
server = line + strlen(line) - 1;
if (*server == '\n')
*server = '\0';
for (server = line + 11; isspace(*server); server ++);
if (*server)
{
fclose(fp);
return (server);
}
}
/*
* Didn't see a ServerName line, so return "localhost"...
*/
fclose(fp);
return ("localhost");
}
/*
* End of "$Id$".
*/
+431 -110
Ver Arquivo
@@ -3,7 +3,7 @@
*
* Printing utilities for the Common UNIX Printing System (CUPS).
*
* Copyright 1997-1999 by Easy Software Products.
* 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
@@ -14,7 +14,7 @@
*
* Attn: CUPS Licensing Information
* Easy Software Products
* 44145 Airport View Drive, Suite 204
* 44141 Airport View Drive, Suite 204
* Hollywood, Maryland 20636-3111 USA
*
* Voice: (301) 373-9603
@@ -31,6 +31,8 @@
* cupsGetPrinters() - Get a list of printers.
* cupsPrintFile() - Print a file to a printer or class.
* cups_connect() - Connect to the specified host...
* cups_local_auth() - Get the local authorization certificate if
* available/applicable...
*/
/*
@@ -57,14 +59,17 @@
* Local globals...
*/
static http_t *cups_server = NULL;
static http_t *cups_server = NULL; /* Current server connection */
static ipp_status_t last_error = IPP_OK; /* Last IPP error */
static char authstring[255] = ""; /* Authorization string */
/*
* Local functions...
*/
static char *cups_connect(char *name, char *printer, char *hostname);
static char *cups_connect(const char *name, char *printer, char *hostname);
static int cups_local_auth(http_t *http);
/*
@@ -72,8 +77,8 @@ static char *cups_connect(char *name, char *printer, char *hostname);
*/
int /* O - 1 on success, 0 on failure */
cupsCancelJob(char *name, /* I - Name of printer or class */
int job) /* I - Job ID */
cupsCancelJob(const char *name, /* I - Name of printer or class */
int job) /* I - Job ID */
{
char printer[HTTP_MAX_URI], /* Printer name */
hostname[HTTP_MAX_URI], /* Hostname */
@@ -88,7 +93,10 @@ cupsCancelJob(char *name, /* I - Name of printer or class */
*/
if (!cups_connect(name, printer, hostname))
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (0);
}
/*
* Build an IPP_CANCEL_JOB request, which requires the following
@@ -98,6 +106,7 @@ cupsCancelJob(char *name, /* I - Name of printer or class */
* attributes-natural-language
* printer-uri
* job-id
* [requesting-user-name]
*/
request = ippNew();
@@ -114,21 +123,31 @@ cupsCancelJob(char *name, /* I - Name of printer or class */
"attributes-natural-language", NULL,
language != NULL ? language->language : "C");
sprintf(uri, "ipp://%s:%d/printers/%s", hostname, ippPort(), printer);
snprintf(uri, sizeof(uri), "ipp://%s:%d/printers/%s", hostname, ippPort(), printer);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
NULL, uri);
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, "job-id", job);
ippAddInteger(request, IPP_TAG_OPERATION, IPP_TAG_INTEGER, "job-id", job);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
/*
* Do the request...
*/
if ((response = cupsDoRequest(cups_server, request, "/jobs/")) == NULL)
{
last_error = IPP_BAD_REQUEST;
return (0);
}
else
{
last_error = response->request.status.status_code;
ippDelete(response);
ippDelete(response);
return (1);
return (1);
}
}
@@ -137,10 +156,10 @@ cupsCancelJob(char *name, /* I - Name of printer or class */
*/
ipp_t * /* O - Response data */
cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
ipp_t *request, /* I - IPP request */
char *resource, /* I - HTTP resource for POST */
char *filename) /* I - File to send or NULL */
cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
ipp_t *request, /* I - IPP request */
const char *resource, /* I - HTTP resource for POST */
const char *filename) /* I - File to send or NULL */
{
ipp_t *response; /* IPP response data */
char length[255]; /* Content-Length field */
@@ -149,14 +168,9 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
struct stat fileinfo; /* File information */
int bytes; /* Number of bytes read/written */
char buffer[8192]; /* Output buffer */
#if !defined(WIN32) && !defined(__EMX__)
char *password, /* Password string */
plain[255], /* Plaintext username:password */
const char *password; /* Password string */
char plain[255], /* Plaintext username:password */
encode[255]; /* Encoded username:password */
char junk[8192]; /* Junk buffer for error data */
#endif /* !WIN32 && !__EMX__ */
static char authstring[255] = "";
/* Authorization string */
DEBUG_printf(("cupsDoFileRequest(%08x, %08s, \'%s\', \'%s\')\n",
@@ -175,6 +189,7 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
*/
ippDelete(request);
last_error = IPP_NOT_FOUND;
return (NULL);
}
@@ -185,6 +200,7 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
*/
ippDelete(request);
last_error = IPP_NOT_FOUND;
return (NULL);
}
}
@@ -204,7 +220,7 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
*/
if (filename != NULL)
sprintf(length, "%u", ippLength(request) + fileinfo.st_size);
sprintf(length, "%u", ippLength(request) + (size_t)fileinfo.st_size);
else
sprintf(length, "%u", ippLength(request));
@@ -220,8 +236,7 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
DEBUG_puts("cupsDoFileRequest: post...");
if (httpPost(http, resource))
if (httpPost(http, resource))
break;
continue;
/*
* Send the IPP data and wait for the response...
@@ -254,7 +269,6 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
while ((status = httpUpdate(http)) == HTTP_CONTINUE);
#if !defined(WIN32) && !defined(__EMX__)
if (status == HTTP_UNAUTHORIZED)
{
DEBUG_puts("cupsDoFileRequest: unauthorized...");
@@ -265,7 +279,21 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
httpFlush(http);
if ((password = getpass("Password:")) != NULL)
/*
* See if we can do local authentication...
*/
if (cups_local_auth(http))
continue;
/*
* Nope - get a password from the user...
*/
printf("Authentication required for %s on %s...\n", cupsUser(),
http->hostname);
if ((password = cupsGetPassword("UNIX Password: ")) != NULL)
{
/*
* Got a password; send it to the server...
@@ -273,18 +301,27 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
if (!password[0])
break;
sprintf(plain, "%s:%s", cuserid(NULL), password);
snprintf(plain, sizeof(plain), "%s:%s", cupsUser(), password);
httpEncode64(encode, plain);
sprintf(authstring, "Basic %s", encode);
snprintf(authstring, sizeof(authstring), "Basic %s", encode);
continue;
}
else
break;
}
#endif /* !WIN32 && !__EMX__ */
if (status != HTTP_OK)
else if (status == HTTP_ERROR)
{
#if defined(WIN32) || defined(__EMX__)
if (http->error != WSAENETDOWN && http->error != WSAENETUNREACH)
#else
if (http->error != ENETDOWN && http->error != ENETUNREACH)
#endif /* WIN32 || __EMX__ */
continue;
else
break;
}
else if (status != HTTP_OK)
{
DEBUG_printf(("cupsDoFileRequest: error %d...\n", status));
@@ -314,6 +351,8 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
ippDelete(response);
response = NULL;
last_error = IPP_SERVICE_UNAVAILABLE;
/*
* Flush any remaining data...
*/
@@ -337,6 +376,15 @@ cupsDoFileRequest(http_t *http, /* I - HTTP connection to server */
ippDelete(request);
if (response)
last_error = response->request.status.status_code;
else if (status == HTTP_NOT_FOUND)
last_error = IPP_NOT_FOUND;
else if (status == HTTP_UNAUTHORIZED)
last_error = IPP_NOT_AUTHORIZED;
else if (status != HTTP_OK)
last_error = IPP_SERVICE_UNAVAILABLE;
return (response);
}
@@ -353,6 +401,7 @@ cupsGetClasses(char ***classes) /* O - Classes */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Default language */
char **temp; /* Temporary pointer */
/*
@@ -360,7 +409,10 @@ cupsGetClasses(char ***classes) /* O - Classes */
*/
if (!cups_connect("default", NULL, NULL))
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (0);
}
/*
* Build a CUPS_GET_CLASSES request, which requires the following
@@ -378,10 +430,10 @@ cupsGetClasses(char ***classes) /* O - Classes */
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
"attributes-natural-language", NULL, language->language);
/*
* Do the request and get back a response...
@@ -390,29 +442,46 @@ cupsGetClasses(char ***classes) /* O - Classes */
n = 0;
*classes = NULL;
if ((response = cupsDoRequest(cups_server, request, "/classes/")) != NULL)
if ((response = cupsDoRequest(cups_server, request, "/")) != NULL)
{
last_error = response->request.status.status_code;
for (attr = response->attrs; attr != NULL; attr = attr->next)
if (strcmp(attr->name, "printer-name") == 0 &&
if (attr->name != NULL &&
strcasecmp(attr->name, "printer-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
{
if (n == 0)
*classes = malloc(sizeof(char *));
temp = malloc(sizeof(char *));
else
*classes = realloc(*classes, sizeof(char *) * (n + 1));
temp = realloc(*classes, sizeof(char *) * (n + 1));
if (*classes == NULL)
if (temp == NULL)
{
/*
* Ran out of memory!
*/
while (n > 0)
{
n --;
free((*classes)[n]);
}
free(*classes);
ippDelete(response);
return (0);
}
(*classes)[n] = strdup(attr->values[0].string.text);
*classes = temp;
temp[n] = strdup(attr->values[0].string.text);
n ++;
}
ippDelete(response);
}
else
last_error = IPP_BAD_REQUEST;
return (n);
}
@@ -422,32 +491,78 @@ cupsGetClasses(char ***classes) /* O - Classes */
* 'cupsGetDefault()' - Get the default printer or class.
*/
char * /* O - Default printer or NULL */
const char * /* O - Default printer or NULL */
cupsGetDefault(void)
{
FILE *fp; /* cupsd.conf file */
char *printer; /* Pointer to server name */
char line[1024]; /* Line from file */
ipp_t *request, /* IPP Request */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Default language */
static char def_printer[64];/* Default printer */
const char *var; /* Environment variable */
static char def_printer[256];/* Default printer */
/*
* First see if the LPDEST or PRINTER environment variables are
* set...
* set... However, if PRINTER is set to "lp", ignore it to work
* around a "feature" in most Linux distributions - the default
* user login scripts set PRINTER to "lp"...
*/
if (getenv("LPDEST") != NULL)
return (getenv("LPDEST"));
else if (getenv("PRINTER") != NULL)
return (getenv("PRINTER"));
if ((var = getenv("LPDEST")) != NULL)
return (var);
else if ((var = getenv("PRINTER")) != NULL && strcmp(var, "lp") != 0)
return (var);
/*
* Next check to see if we have a client.conf file...
*/
if ((fp = fopen(CUPS_SERVERROOT "/client.conf", "r")) != NULL)
{
/*
* Read the client.conf file and look for a DefaultPrinter line...
*/
while (fgets(line, sizeof(line), fp) != NULL)
if (strncmp(line, "DefaultPrinter ", 15) == 0)
{
/*
* Got it! Drop any trailing newline and find the name...
*/
printer = line + strlen(line) - 1;
if (*printer == '\n')
*printer = '\0';
for (printer = line + 15; isspace(*printer); printer ++);
if (*printer)
{
strncpy(def_printer, printer, sizeof(def_printer) - 1);
def_printer[sizeof(def_printer) - 1] = '\0';
fclose(fp);
return (def_printer);
}
}
fclose(fp);
}
/*
* Try to connect to the server...
*/
if (!cups_connect("default", NULL, NULL))
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (NULL);
}
/*
* Build a CUPS_GET_DEFAULT request, which requires the following
@@ -474,17 +589,22 @@ cupsGetDefault(void)
* Do the request and get back a response...
*/
if ((response = cupsDoRequest(cups_server, request, "/printers/")) != NULL)
if ((response = cupsDoRequest(cups_server, request, "/")) != NULL)
{
last_error = response->request.status.status_code;
if ((attr = ippFindAttribute(response, "printer-name", IPP_TAG_NAME)) != NULL)
{
strcpy(def_printer, attr->values[0].string.text);
strncpy(def_printer, attr->values[0].string.text, sizeof(def_printer) - 1);
def_printer[sizeof(def_printer) - 1] = '\0';
ippDelete(response);
return (def_printer);
}
ippDelete(response);
}
else
last_error = IPP_BAD_REQUEST;
return (NULL);
}
@@ -494,8 +614,8 @@ cupsGetDefault(void)
* 'cupsGetPPD()' - Get the PPD file for a printer.
*/
char * /* O - Filename for PPD file */
cupsGetPPD(char *name) /* I - Printer name */
const char * /* O - Filename for PPD file */
cupsGetPPD(const char *name) /* I - Printer name */
{
FILE *fp; /* PPD file */
int bytes; /* Number of bytes read */
@@ -503,9 +623,12 @@ cupsGetPPD(char *name) /* I - Printer name */
char printer[HTTP_MAX_URI], /* Printer name */
hostname[HTTP_MAX_URI], /* Hostname */
resource[HTTP_MAX_URI]; /* Resource name */
static char filename[HTTP_MAX_URI]; /* Local filename */
char *tempdir; /* Temporary file directory */
struct stat fileinfo; /* File information */
const char *password; /* Password string */
char plain[255], /* Plaintext username:password */
encode[255]; /* Encoded username:password */
http_status_t status; /* HTTP status from server */
static char filename[HTTP_MAX_URI]; /* Local filename */
/*
@@ -513,7 +636,10 @@ cupsGetPPD(char *name) /* I - Printer name */
*/
if (!cups_connect(name, printer, hostname))
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (NULL);
}
/*
* Then check for the cache file...
@@ -521,36 +647,78 @@ cupsGetPPD(char *name) /* I - Printer name */
#if defined(WIN32) || defined(__EMX__)
tempdir = "C:/WINDOWS/TEMP";
snprintf(filename, sizeof(filename), "%s/%s.ppd", tempdir, printer);
#else
if ((tempdir = getenv("TMPDIR")) == NULL)
tempdir = "/tmp";
snprintf(filename, sizeof(filename), "%s/%d.%s.ppd", tempdir, getuid(), printer);
#endif /* WIN32 || __EMX__ */
sprintf(filename, "%s/%s.ppd", tempdir, printer);
if (stat(filename, &fileinfo))
memset(&fileinfo, 0, sizeof(fileinfo));
/*
* And send a request to the HTTP server using "if-modified-since"...
* And send a request to the HTTP server...
*/
sprintf(resource, "/printers/%s.ppd", printer);
snprintf(resource, sizeof(resource), "/printers/%s.ppd", printer);
httpClearFields(cups_server);
httpSetField(cups_server, HTTP_FIELD_HOST, hostname);
httpSetField(cups_server, HTTP_FIELD_IF_MODIFIED_SINCE,
httpGetDateString(fileinfo.st_mtime));
httpGet(cups_server, resource);
switch (httpUpdate(cups_server))
do
{
case HTTP_OK : /* New file - get it! */
httpClearFields(cups_server);
httpSetField(cups_server, HTTP_FIELD_HOST, hostname);
httpSetField(cups_server, HTTP_FIELD_AUTHORIZATION, authstring);
if (httpGet(cups_server, resource))
{
status = HTTP_UNAUTHORIZED;
continue;
}
while ((status = httpUpdate(cups_server)) == HTTP_CONTINUE);
if (status == HTTP_UNAUTHORIZED)
{
DEBUG_puts("cupsGetPPD: unauthorized...");
/*
* Flush any error message...
*/
httpFlush(cups_server);
/*
* See if we can do local authentication...
*/
if (cups_local_auth(cups_server))
continue;
/*
* Nope, get a password from the user...
*/
printf("Authentication required for %s on %s...\n", cupsUser(),
cups_server->hostname);
if ((password = cupsGetPassword("UNIX Password: ")) != NULL)
{
/*
* Got a password; send it to the server...
*/
if (!password[0])
break;
snprintf(plain, sizeof(plain), "%s:%s", cupsUser(), password);
httpEncode64(encode, plain);
snprintf(authstring, sizeof(authstring), "Basic %s", encode);
continue;
}
else
break;
case HTTP_NOT_MODIFIED : /* File hasn't been modified; use the current copy */
return (filename);
default :
return (NULL);
}
}
while (status == HTTP_UNAUTHORIZED);
/*
* OK, we need to copy the file; open the file and copy it...
@@ -589,6 +757,7 @@ cupsGetPrinters(char ***printers) /* O - Printers */
*response; /* IPP Response */
ipp_attribute_t *attr; /* Current attribute */
cups_lang_t *language; /* Default language */
char **temp; /* Temporary pointer */
/*
@@ -596,7 +765,10 @@ cupsGetPrinters(char ***printers) /* O - Printers */
*/
if (!cups_connect("default", NULL, NULL))
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (0);
}
/*
* Build a CUPS_GET_PRINTERS request, which requires the following
@@ -614,10 +786,10 @@ cupsGetPrinters(char ***printers) /* O - Printers */
language = cupsLangDefault();
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
"attributes-charset", NULL, cupsLangEncoding(language));
"attributes-charset", NULL, cupsLangEncoding(language));
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
"attributes-natural-language", NULL, language->language);
"attributes-natural-language", NULL, language->language);
/*
* Do the request and get back a response...
@@ -626,42 +798,70 @@ cupsGetPrinters(char ***printers) /* O - Printers */
n = 0;
*printers = NULL;
if ((response = cupsDoRequest(cups_server, request, "/printers/")) != NULL)
if ((response = cupsDoRequest(cups_server, request, "/")) != NULL)
{
last_error = response->request.status.status_code;
for (attr = response->attrs; attr != NULL; attr = attr->next)
if (strcmp(attr->name, "printer-name") == 0 &&
if (attr->name != NULL &&
strcasecmp(attr->name, "printer-name") == 0 &&
attr->value_tag == IPP_TAG_NAME)
{
if (n == 0)
*printers = malloc(sizeof(char *));
temp = malloc(sizeof(char *));
else
*printers = realloc(*printers, sizeof(char *) * (n + 1));
temp = realloc(*printers, sizeof(char *) * (n + 1));
if (*printers == NULL)
if (temp == NULL)
{
/*
* Ran out of memory!
*/
while (n > 0)
{
n --;
free((*printers)[n]);
}
free(*printers);
ippDelete(response);
return (0);
}
(*printers)[n] = strdup(attr->values[0].string.text);
*printers = temp;
temp[n] = strdup(attr->values[0].string.text);
n ++;
}
ippDelete(response);
}
else
last_error = IPP_BAD_REQUEST;
return (n);
}
/*
* 'cupsLastError()' - Return the last IPP error that occurred.
*/
ipp_status_t /* O - IPP error code */
cupsLastError(void)
{
return (last_error);
}
/*
* 'cupsPrintFile()' - Print a file to a printer or class.
*/
int /* O - Job ID */
cupsPrintFile(char *name, /* I - Printer or class name */
char *filename, /* I - File to print */
char *title, /* I - Title of job */
cupsPrintFile(const char *name, /* I - Printer or class name */
const char *filename, /* I - File to print */
const char *title, /* I - Title of job */
int num_options,/* I - Number of options */
cups_option_t *options) /* I - Options */
{
@@ -697,6 +897,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
{
DEBUG_printf(("cupsPrintFile: Unable to open connection - %s.\n",
strerror(errno)));
last_error = IPP_SERVICE_UNAVAILABLE;
ippDelete(request);
return (0);
}
@@ -709,7 +910,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
request->request.op.operation_id = IPP_PRINT_JOB;
request->request.op.request_id = 1;
sprintf(uri, "ipp://%s:%d/printers/%s", hostname, ippPort(), printer);
snprintf(uri, sizeof(uri), "ipp://%s:%d/printers/%s", hostname, ippPort(), printer);
language = cupsLangDefault();
@@ -728,22 +929,17 @@ cupsPrintFile(char *name, /* I - Printer or class name */
*/
if (cupsGetOption("raw", num_options, options))
ippAddString(request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/vnd.cups-raw");
else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_MIMETYPE, "document-format",
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_MIMETYPE, "document-format",
NULL, "application/octet-stream");
#if defined(WIN32) || defined(__EMX__)
ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "requesting-user-name",
NULL, "WindowsUser");
#else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "requesting-user-name",
NULL, cuserid(NULL));
#endif /* WIN32 || __EMX__ */
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
NULL, cupsUser());
if (title)
ippAddString(request, IPP_TAG_JOB, IPP_TAG_NAME, "job-name", NULL, title);
ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "job-name", NULL, title);
/*
* Then add all options on the command-line...
@@ -755,7 +951,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
* Skip the "raw" option - handled above...
*/
if (strcmp(options[i].name, "raw") == 0)
if (strcasecmp(options[i].name, "raw") == 0)
continue;
/*
@@ -799,7 +995,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
}
else
{
if (strncmp(option, "no", 2) == 0)
if (strncasecmp(option, "no", 2) == 0)
{
option += 2;
n = 0;
@@ -816,7 +1012,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
* String value(s)...
*/
DEBUG_printf(("cupsPrintJob: Adding string option \'%s\' with value \'%s\'...\n",
DEBUG_printf(("cupsPrintFile: Adding string option \'%s\' with value \'%s\'...\n",
option, val));
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
@@ -832,28 +1028,28 @@ cupsPrintFile(char *name, /* I - Printer or class name */
n2 = strtol(s + 1, NULL, 0);
ippAddRange(request, IPP_TAG_JOB, option, n, n2);
DEBUG_printf(("cupsPrintJob: Adding range option \'%s\' with value %d-%d...\n",
DEBUG_printf(("cupsPrintFile: Adding range option \'%s\' with value %d-%d...\n",
option, n, n2));
}
else if (*s == 'x')
{
n2 = strtol(s + 1, &s, 0);
if (strcmp(s, "dpc") == 0)
if (strcasecmp(s, "dpc") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_CM, n, n2);
else if (strcmp(s, "dpi") == 0)
else if (strcasecmp(s, "dpi") == 0)
ippAddResolution(request, IPP_TAG_JOB, option, IPP_RES_PER_INCH, n, n2);
else
ippAddString(request, IPP_TAG_JOB, IPP_TAG_KEYWORD, option, NULL, val);
DEBUG_printf(("cupsPrintJob: Adding resolution option \'%s\' with value %s...\n",
DEBUG_printf(("cupsPrintFile: Adding resolution option \'%s\' with value %s...\n",
option, val));
}
else
{
ippAddInteger(request, IPP_TAG_JOB, IPP_TAG_INTEGER, option, n);
DEBUG_printf(("cupsPrintJob: Adding integer option \'%s\' with value %d...\n",
DEBUG_printf(("cupsPrintFile: Adding integer option \'%s\' with value %d...\n",
option, n));
}
}
@@ -863,7 +1059,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
* Boolean value...
*/
DEBUG_printf(("cupsPrintJob: Adding boolean option \'%s\' with value %d...\n",
DEBUG_printf(("cupsPrintFile: Adding boolean option \'%s\' with value %d...\n",
option, n));
ippAddBoolean(request, IPP_TAG_JOB, option, (char)n);
}
@@ -873,7 +1069,7 @@ cupsPrintFile(char *name, /* I - Printer or class name */
* Try printing the file...
*/
sprintf(uri, "/printers/%s", printer);
snprintf(uri, sizeof(uri), "/printers/%s", printer);
if ((response = cupsDoFileRequest(cups_server, request, uri, filename)) == NULL)
jobid = 0;
@@ -898,14 +1094,64 @@ cupsPrintFile(char *name, /* I - Printer or class name */
}
/*
* 'cupsTempFile()' - Generate a temporary filename.
*/
char * /* O - Filename */
cupsTempFile(char *filename, /* I - Pointer to buffer */
int len) /* I - Size of buffer */
{
char *tmpdir; /* TMPDIR environment var */
static char buf[1024] = ""; /* Buffer if you pass in NULL and 0 */
/*
* See if a filename was specified...
*/
if (filename == NULL)
{
filename = buf;
len = sizeof(buf);
}
/*
* See if TMPDIR is defined...
*/
if ((tmpdir = getenv("TMPDIR")) == NULL)
tmpdir = "/var/tmp";
if ((int)(strlen(tmpdir) + 8) > len)
{
/*
* The specified directory exceeds the size of the buffer; default it...
*/
strcpy(buf, "/var/tmp/XXXXXX");
return (mktemp(buf));
}
else
{
/*
* Make the temporary name using the specified directory...
*/
sprintf(filename, "%s/XXXXXX", tmpdir);
return (mktemp(filename));
}
}
/*
* 'cups_connect()' - Connect to the specified host...
*/
static char * /* I - Printer name if success, NULL if fail */
cups_connect(char *name, /* I - Destination (printer[@host]) */
char *printer, /* O - Printer name */
char *hostname) /* O - Hostname */
static char * /* I - Printer name or NULL */
cups_connect(const char *name, /* I - Destination (printer[@host]) */
char *printer, /* O - Printer name [HTTP_MAX_URI] */
char *hostname) /* O - Hostname [HTTP_MAX_URI] */
{
char hostbuf[HTTP_MAX_URI];
/* Name of host */
@@ -914,18 +1160,30 @@ cups_connect(char *name, /* I - Destination (printer[@host]) */
if (name == NULL)
{
last_error = IPP_BAD_REQUEST;
return (NULL);
}
if (sscanf(name, "%[^@]@%s", printerbuf, hostbuf) == 1)
strcpy(hostbuf, "localhost");
if (sscanf(name, "%1023[^@]@%1023s", printerbuf, hostbuf) == 1)
{
strncpy(hostbuf, cupsServer(), sizeof(hostbuf) - 1);
hostbuf[sizeof(hostbuf) - 1] = '\0';
}
if (hostname != NULL)
strcpy(hostname, hostbuf);
{
strncpy(hostname, hostbuf, HTTP_MAX_URI - 1);
hostname[HTTP_MAX_URI - 1] = '\0';
}
else
hostname = hostbuf;
if (printer != NULL)
strcpy(printer, printerbuf);
{
strncpy(printer, printerbuf, HTTP_MAX_URI - 1);
printer[HTTP_MAX_URI - 1] = '\0';
}
else
printer = printerbuf;
@@ -938,12 +1196,75 @@ cups_connect(char *name, /* I - Destination (printer[@host]) */
}
if ((cups_server = httpConnect(hostname, ippPort())) == NULL)
{
last_error = IPP_SERVICE_UNAVAILABLE;
return (NULL);
}
else
return (printer);
}
/*
* 'cups_local_auth()' - Get the local authorization certificate if
* available/applicable...
*/
static int /* O - 1 if available, 0 if not */
cups_local_auth(http_t *http) /* I - Connection */
{
#if defined(WIN32) || defined(__EMX__)
/*
* Currently WIN32 and OS-2 do not support the CUPS server...
*/
return (0);
#else
int pid; /* Current process ID */
FILE *fp; /* Certificate file */
char filename[1024], /* Certificate filename */
certificate[33]; /* Certificate string */
/*
* See if we are accessing localhost...
*/
if (ntohl(http->hostaddr.sin_addr.s_addr) != 0x7f000001 &&
strcasecmp(http->hostname, "localhost") != 0)
return (0);
/*
* Try opening a certificate file for this PID. If that fails,
* try the root certificate...
*/
pid = getpid();
sprintf(filename, CUPS_SERVERROOT "/certs/%d", pid);
if ((fp = fopen(filename, "r")) == NULL && pid > 0)
fp = fopen(CUPS_SERVERROOT "/certs/0", "r");
if (fp == NULL)
return (0);
/*
* Read the certificate from the file...
*/
fgets(certificate, sizeof(certificate), fp);
fclose(fp);
/*
* Set the authorization string and return...
*/
sprintf(authstring, "Local %s", certificate);
return (1);
#endif /* WIN32 || __EMX__ */
}
/*
* End of "$Id$".
*/
+216
Ver Arquivo
@@ -0,0 +1,216 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x00a1
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x00a4
0xa5 0x00a5
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xaa 0x00aa
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x00af
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x00b9
0xba 0x00ba
0xbb 0x00bb
0xbc 0x00bc
0xbd 0x00bd
0xbe 0x00be
0xbf 0x00bf
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x00d0
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x00dd
0xde 0x00de
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x00f0
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x00fe
0xff 0x00ff
+217
Ver Arquivo
@@ -0,0 +1,217 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x1e02
0xa2 0x1e03
0xa3 0x00a3
0xa4 0x010a
0xa5 0x010b
0xa6 0x1e0a
0xa7 0x00a7
0xa8 0x1e80
0xa9 0x00a9
0xaa 0x1e82
0xab 0x1e0b
0xac 0x1ef2
0xad 0x00ad
0xae 0x00ae
0xaf 0x0178
0xb0 0x1e1e
0xb1 0x1e1f
0xb2 0x0120
0xb3 0x0121
0xb4 0x1e40
0xb5 0x1e41
0xb6 0x00b6
0xb7 0x1e56
0xb8 0x1e81
0xb9 0x1e57
0xba 0x1e83
0xbb 0x1e60
0xbc 0x1ef3
0xbd 0x1e84
0xbe 0x1e85
0xbf 0x1e61
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x0174
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x1e6a
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x00dd
0xde 0x0176
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x0175
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x1e6b
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x0177
0xff 0x00ff
+217
Ver Arquivo
@@ -0,0 +1,217 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x00a1
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x20ac
0xa5 0x00a5
0xa6 0x0160
0xa7 0x00a7
0xa8 0x0161
0xa9 0x00a9
0xaa 0x00aa
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x00af
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x017d
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x017e
0xb9 0x00b9
0xba 0x00ba
0xbb 0x00bb
0xbc 0x0152
0xbd 0x0153
0xbe 0x0178
0xbf 0x00bf
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x00d0
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x00dd
0xde 0x00de
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x00f0
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x00fe
0xff 0x00ff
+218
Ver Arquivo
@@ -0,0 +1,218 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x015a
0x8d 0x0164
0x8e 0x017d
0x8f 0x0179
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x8c 0x015b
0x8d 0x0165
0x8e 0x017e
0x8f 0x017a
0xa0 0x00a0
0xa1 0x0104
0xa2 0x02d8
0xa3 0x0141
0xa4 0x00a4
0xa5 0x013d
0xa6 0x015a
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x0160
0xaa 0x015e
0xab 0x0164
0xac 0x0179
0xad 0x00ad
0xae 0x017d
0xaf 0x017b
0xb0 0x00b0
0xb1 0x0105
0xb2 0x02db
0xb3 0x0142
0xb4 0x00b4
0xb5 0x013e
0xb6 0x015b
0xb7 0x02c7
0xb8 0x00b8
0xb9 0x0161
0xba 0x015f
0xbb 0x0165
0xbc 0x017a
0xbd 0x02dd
0xbe 0x017e
0xbf 0x017c
0xc0 0x0154
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x0102
0xc4 0x00c4
0xc5 0x0139
0xc6 0x0106
0xc7 0x00c7
0xc8 0x010c
0xc9 0x00c9
0xca 0x0118
0xcb 0x00cb
0xcc 0x011a
0xcd 0x00cd
0xce 0x00ce
0xcf 0x010e
0xd0 0x0110
0xd1 0x0143
0xd2 0x0147
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x0150
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x0158
0xd9 0x016e
0xda 0x00da
0xdb 0x0170
0xdc 0x00dc
0xdd 0x00dd
0xde 0x0162
0xdf 0x00df
0xe0 0x0155
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x0103
0xe4 0x00e4
0xe5 0x013a
0xe6 0x0107
0xe7 0x00e7
0xe8 0x010d
0xe9 0x00e9
0xea 0x0119
0xeb 0x00eb
0xec 0x011b
0xed 0x00ed
0xee 0x00ee
0xef 0x010f
0xf0 0x0111
0xf1 0x0144
0xf2 0x0148
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x0151
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x0159
0xf9 0x016f
0xfa 0x00fa
0xfb 0x0171
0xfc 0x00fc
0xfd 0x00fd
0xfe 0x0163
0xff 0x02d9
+209
Ver Arquivo
@@ -0,0 +1,209 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x0126
0xa2 0x02d8
0xa3 0x00a3
0xa4 0x00a4
0xa6 0x0124
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x0130
0xaa 0x015e
0xab 0x011e
0xac 0x0134
0xad 0x00ad
0xaf 0x017b
0xb0 0x00b0
0xb1 0x0127
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x0125
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x0131
0xba 0x015f
0xbb 0x011f
0xbc 0x0135
0xbd 0x00bd
0xbf 0x017c
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc4 0x00c4
0xc5 0x010a
0xc6 0x0108
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x0120
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x011c
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x016c
0xde 0x015c
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe4 0x00e4
0xe5 0x010b
0xe6 0x0109
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x0121
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x011d
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x016d
0xfe 0x015d
0xff 0x02d9
+216
Ver Arquivo
@@ -0,0 +1,216 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x0104
0xa2 0x0138
0xa3 0x0156
0xa4 0x00a4
0xa5 0x0128
0xa6 0x013b
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x0160
0xaa 0x0112
0xab 0x0122
0xac 0x0166
0xad 0x00ad
0xae 0x017d
0xaf 0x00af
0xb0 0x00b0
0xb1 0x0105
0xb2 0x02db
0xb3 0x0157
0xb4 0x00b4
0xb5 0x0129
0xb6 0x013c
0xb7 0x02c7
0xb8 0x00b8
0xb9 0x0161
0xba 0x0113
0xbb 0x0123
0xbc 0x0167
0xbd 0x014a
0xbe 0x017e
0xbf 0x014b
0xc0 0x0100
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x012e
0xc8 0x010c
0xc9 0x00c9
0xca 0x0118
0xcb 0x00cb
0xcc 0x0116
0xcd 0x00cd
0xce 0x00ce
0xcf 0x012a
0xd0 0x0110
0xd1 0x0145
0xd2 0x014c
0xd3 0x0136
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x0172
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x0168
0xde 0x016a
0xdf 0x00df
0xe0 0x0101
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x012f
0xe8 0x010d
0xe9 0x00e9
0xea 0x0119
0xeb 0x00eb
0xec 0x0117
0xed 0x00ed
0xee 0x00ee
0xef 0x012b
0xf0 0x0111
0xf1 0x0146
0xf2 0x014d
0xf3 0x0137
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x0173
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x0169
0xfe 0x016b
0xff 0x02d9
+216
Ver Arquivo
@@ -0,0 +1,216 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x0401
0xa2 0x0402
0xa3 0x0403
0xa4 0x0404
0xa5 0x0405
0xa6 0x0406
0xa7 0x0407
0xa8 0x0408
0xa9 0x0409
0xaa 0x040a
0xab 0x040b
0xac 0x040c
0xad 0x00ad
0xae 0x040e
0xaf 0x040f
0xb0 0x0410
0xb1 0x0411
0xb2 0x0412
0xb3 0x0413
0xb4 0x0414
0xb5 0x0415
0xb6 0x0416
0xb7 0x0417
0xb8 0x0418
0xb9 0x0419
0xba 0x041a
0xbb 0x041b
0xbc 0x041c
0xbd 0x041d
0xbe 0x041e
0xbf 0x041f
0xc0 0x0420
0xc1 0x0421
0xc2 0x0422
0xc3 0x0423
0xc4 0x0424
0xc5 0x0425
0xc6 0x0426
0xc7 0x0427
0xc8 0x0428
0xc9 0x0429
0xca 0x042a
0xcb 0x042b
0xcc 0x042c
0xcd 0x042d
0xce 0x042e
0xcf 0x042f
0xd0 0x0430
0xd1 0x0431
0xd2 0x0432
0xd3 0x0433
0xd4 0x0434
0xd5 0x0435
0xd6 0x0436
0xd7 0x0437
0xd8 0x0438
0xd9 0x0439
0xda 0x043a
0xdb 0x043b
0xdc 0x043c
0xdd 0x043d
0xde 0x043e
0xdf 0x043f
0xe0 0x0440
0xe1 0x0441
0xe2 0x0442
0xe3 0x0443
0xe4 0x0444
0xe5 0x0445
0xe6 0x0446
0xe7 0x0447
0xe8 0x0448
0xe9 0x0449
0xea 0x044a
0xeb 0x044b
0xec 0x044c
0xed 0x044d
0xee 0x044e
0xef 0x044f
0xf0 0x2116
0xf1 0x0451
0xf2 0x0452
0xf3 0x0453
0xf4 0x0454
0xf5 0x0455
0xf6 0x0456
0xf7 0x0457
0xf8 0x0458
0xf9 0x0459
0xfa 0x045a
0xfb 0x045b
0xfc 0x045c
0xfd 0x00a7
0xfe 0x045e
0xff 0x045f
+171
Ver Arquivo
@@ -0,0 +1,171 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0660
0x31 0x0661
0x32 0x0662
0x33 0x0663
0x34 0x0664
0x35 0x0665
0x36 0x0666
0x37 0x0667
0x38 0x0668
0x39 0x0669
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa4 0x00a4
0xac 0x060c
0xad 0x00ad
0xbb 0x061b
0xbf 0x061f
0xc1 0x0621
0xc2 0x0622
0xc3 0x0623
0xc4 0x0624
0xc5 0x0625
0xc6 0x0626
0xc7 0x0627
0xc8 0x0628
0xc9 0x0629
0xca 0x062a
0xcb 0x062b
0xcc 0x062c
0xcd 0x062d
0xce 0x062e
0xcf 0x062f
0xd0 0x0630
0xd1 0x0631
0xd2 0x0632
0xd3 0x0633
0xd4 0x0634
0xd5 0x0635
0xd6 0x0636
0xd7 0x0637
0xd8 0x0638
0xd9 0x0639
0xda 0x063a
0xe0 0x0640
0xe1 0x0641
0xe2 0x0642
0xe3 0x0643
0xe4 0x0644
0xe5 0x0645
0xe6 0x0646
0xe7 0x0647
0xe8 0x0648
0xe9 0x0649
0xea 0x064a
0xeb 0x064b
0xec 0x064c
0xed 0x064d
0xee 0x064e
0xef 0x064f
0xf0 0x0650
0xf1 0x0651
0xf2 0x0652
+210
Ver Arquivo
@@ -0,0 +1,210 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x02bd
0xa2 0x02bc
0xa3 0x00a3
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xaf 0x2015
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x0384
0xb5 0x0385
0xb6 0x0386
0xb7 0x00b7
0xb8 0x0388
0xb9 0x0389
0xba 0x038a
0xbb 0x00bb
0xbc 0x038c
0xbd 0x00bd
0xbe 0x038e
0xbf 0x038f
0xc0 0x0390
0xc1 0x0391
0xc2 0x0392
0xc3 0x0393
0xc4 0x0394
0xc5 0x0395
0xc6 0x0396
0xc7 0x0397
0xc8 0x0398
0xc9 0x0399
0xca 0x039a
0xcb 0x039b
0xcc 0x039c
0xcd 0x039d
0xce 0x039e
0xcf 0x039f
0xd0 0x03a0
0xd1 0x03a1
0xd3 0x03a3
0xd4 0x03a4
0xd5 0x03a5
0xd6 0x03a6
0xd7 0x03a7
0xd8 0x03a8
0xd9 0x03a9
0xda 0x03aa
0xdb 0x03ab
0xdc 0x03ac
0xdd 0x03ad
0xde 0x03ae
0xdf 0x03af
0xe0 0x03b0
0xe1 0x03b1
0xe2 0x03b2
0xe3 0x03b3
0xe4 0x03b4
0xe5 0x03b5
0xe6 0x03b6
0xe7 0x03b7
0xe8 0x03b8
0xe9 0x03b9
0xea 0x03ba
0xeb 0x03bb
0xec 0x03bc
0xed 0x03bd
0xee 0x03be
0xef 0x03bf
0xf0 0x03c0
0xf1 0x03c1
0xf2 0x03c2
0xf3 0x03c3
0xf4 0x03c4
0xf5 0x03c5
0xf6 0x03c6
0xf7 0x03c7
0xf8 0x03c8
0xf9 0x03c9
0xfa 0x03ca
0xfb 0x03cb
0xfc 0x03cc
0xfd 0x03cd
0xfe 0x03ce
+178
Ver Arquivo
@@ -0,0 +1,178 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x00a4
0xa5 0x00a5
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xaa 0x00d7
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x203e
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x00b9
0xba 0x00f7
0xbb 0x00bb
0xbc 0x00bc
0xbd 0x00bd
0xbe 0x00be
0xdf 0x2017
0xe0 0x05d0
0xe1 0x05d1
0xe2 0x05d2
0xe3 0x05d3
0xe4 0x05d4
0xe5 0x05d5
0xe6 0x05d6
0xe7 0x05d7
0xe8 0x05d8
0xe9 0x05d9
0xea 0x05da
0xeb 0x05db
0xec 0x05dc
0xed 0x05dd
0xee 0x05de
0xef 0x05df
0xf0 0x05e0
0xf1 0x05e1
0xf2 0x05e2
0xf3 0x05e3
0xf4 0x05e4
0xf5 0x05e5
0xf6 0x05e6
0xf7 0x05e7
0xf8 0x05e8
0xf9 0x05e9
0xfa 0x05ea
+218
Ver Arquivo
@@ -0,0 +1,218 @@
0x20 0x0020
0x21 0x0021
0x22 0x0022
0x23 0x0023
0x24 0x0024
0x25 0x0025
0x26 0x0026
0x27 0x0027
0x28 0x0028
0x29 0x0029
0x2a 0x002a
0x2b 0x002b
0x2c 0x002c
0x2d 0x002d
0x2e 0x002e
0x2f 0x002f
0x30 0x0030
0x31 0x0031
0x32 0x0032
0x33 0x0033
0x34 0x0034
0x35 0x0035
0x36 0x0036
0x37 0x0037
0x38 0x0038
0x39 0x0039
0x3a 0x003a
0x3b 0x003b
0x3c 0x003c
0x3d 0x003d
0x3e 0x003e
0x3f 0x003f
0x40 0x0040
0x41 0x0041
0x42 0x0042
0x43 0x0043
0x44 0x0044
0x45 0x0045
0x46 0x0046
0x47 0x0047
0x48 0x0048
0x49 0x0049
0x4a 0x004a
0x4b 0x004b
0x4c 0x004c
0x4d 0x004d
0x4e 0x004e
0x4f 0x004f
0x50 0x0050
0x51 0x0051
0x52 0x0052
0x53 0x0053
0x54 0x0054
0x55 0x0055
0x56 0x0056
0x57 0x0057
0x58 0x0058
0x59 0x0059
0x5a 0x005a
0x5b 0x005b
0x5c 0x005c
0x5d 0x005d
0x5e 0x005e
0x5f 0x005f
0x60 0x0060
0x61 0x0061
0x62 0x0062
0x63 0x0063
0x64 0x0064
0x65 0x0065
0x66 0x0066
0x67 0x0067
0x68 0x0068
0x69 0x0069
0x6a 0x006a
0x6b 0x006b
0x6c 0x006c
0x6d 0x006d
0x6e 0x006e
0x6f 0x006f
0x70 0x0070
0x71 0x0071
0x72 0x0072
0x73 0x0073
0x74 0x0074
0x75 0x0075
0x76 0x0076
0x77 0x0077
0x78 0x0078
0x79 0x0079
0x7a 0x007a
0x7b 0x007b
0x7c 0x007c
0x7d 0x007d
0x7e 0x007e
0x80 0x20ac
0x82 0x201a
0x83 0x0192
0x84 0x201e
0x85 0x2026
0x86 0x2020
0x87 0x2021
0x88 0x02c6
0x89 0x2030
0x8a 0x0160
0x8b 0x2039
0x8c 0x0152
0x91 0x2018
0x92 0x2019
0x93 0x201c
0x94 0x201d
0x95 0x2022
0x96 0x2013
0x97 0x2014
0x98 0x02dc
0x99 0x2122
0x9a 0x0161
0x9b 0x203a
0x9c 0x0153
0x9f 0x0178
0xa0 0x00a0
0xa1 0x00a1
0xa2 0x00a2
0xa3 0x00a3
0xa4 0x00a4
0xa5 0x00a5
0xa6 0x00a6
0xa7 0x00a7
0xa8 0x00a8
0xa9 0x00a9
0xaa 0x00aa
0xab 0x00ab
0xac 0x00ac
0xad 0x00ad
0xae 0x00ae
0xaf 0x00af
0xb0 0x00b0
0xb1 0x00b1
0xb2 0x00b2
0xb3 0x00b3
0xb4 0x00b4
0xb5 0x00b5
0xb6 0x00b6
0xb7 0x00b7
0xb8 0x00b8
0xb9 0x00b9
0xba 0x00ba
0xbb 0x00bb
0xbc 0x00bc
0xbd 0x00bd
0xbe 0x00be
0xbf 0x00bf
0xc0 0x00c0
0xc1 0x00c1
0xc2 0x00c2
0xc3 0x00c3
0xc4 0x00c4
0xc5 0x00c5
0xc6 0x00c6
0xc7 0x00c7
0xc8 0x00c8
0xc9 0x00c9
0xca 0x00ca
0xcb 0x00cb
0xcc 0x00cc
0xcd 0x00cd
0xce 0x00ce
0xcf 0x00cf
0xd0 0x011e
0xd1 0x00d1
0xd2 0x00d2
0xd3 0x00d3
0xd4 0x00d4
0xd5 0x00d5
0xd6 0x00d6
0xd7 0x00d7
0xd8 0x00d8
0xd9 0x00d9
0xda 0x00da
0xdb 0x00db
0xdc 0x00dc
0xdd 0x0130
0xde 0x015e
0xdf 0x00df
0xe0 0x00e0
0xe1 0x00e1
0xe2 0x00e2
0xe3 0x00e3
0xe4 0x00e4
0xe5 0x00e5
0xe6 0x00e6
0xe7 0x00e7
0xe8 0x00e8
0xe9 0x00e9
0xea 0x00ea
0xeb 0x00eb
0xec 0x00ec
0xed 0x00ed
0xee 0x00ee
0xef 0x00ef
0xf0 0x011f
0xf1 0x00f1
0xf2 0x00f2
0xf3 0x00f3
0xf4 0x00f4
0xf5 0x00f5
0xf6 0x00f6
0xf7 0x00f7
0xf8 0x00f8
0xf9 0x00f9
0xfa 0x00fa
0xfb 0x00fb
0xfc 0x00fc
0xfd 0x0131
0xfe 0x015f
0xff 0x00ff
+4 -29
Ver Arquivo
@@ -1,6 +1,6 @@
%%BeginResource: procset hpgltops 1.0 0
%%BeginResource: procset hpgltops 1.1 0
%
% "$Id: HPGLprolog 312 1999-05-11 19:45:40Z mike $"
% "$Id: HPGLprolog 932 2000-02-26 20:01:37Z 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-1999 Easy Software Products
% Copyright 1993-2000 Easy Software Products
%
% These coded instructions, statements, and computer programs are the
% property of Easy Software Products and are protected by Federal
@@ -33,30 +33,5 @@
/ST { stroke } bind def
/CP { closepath } bind def
/MP { newpath } 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
/SP { setlinewidth setrgbcolor } bind def
%%EndResource
+34 -4
Ver Arquivo
@@ -3,7 +3,7 @@
#
# Datafile makefile for the Common UNIX Printing System (CUPS).
#
# Copyright 1993-1999 by Easy Software Products.
# Copyright 1993-2000 by Easy Software Products.
#
# These coded instructions, statements, and computer programs are the
# property of Easy Software Products and are protected by Federal
@@ -28,8 +28,32 @@ include ../Makedefs
# Data files...
#
FILES = 8859-1 8859-14 8859-15 8859-2 8859-3 8859-4 8859-5 \
8859-6 8859-7 8859-8 8859-9 HPGLprolog
CHARSETS = cp874 \
cp1250 \
cp1251 \
cp1252 \
cp1253 \
cp1254 \
cp1255 \
cp1256 \
cp1257 \
cp1258 \
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
#
# Make everything...
@@ -37,19 +61,25 @@ FILES = 8859-1 8859-14 8859-15 8859-2 8859-3 8859-4 8859-5 \
all:
#
# Clean all config and object files...
#
clean:
#
# Install files...
#
install:
-$(MKDIR) $(DATADIR)
$(CP) $(FILES) $(DATADIR)
-$(MKDIR) $(DATADIR)/data
$(CP) $(DATAFILES) $(DATADIR)/data
-$(MKDIR) $(DATADIR)/charsets
$(CP) $(CHARSETS) $(DATADIR)/charsets
#
# End of "$Id$".
+254
Ver Arquivo
@@ -0,0 +1,254 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1250 (WinLatin2) 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.
#
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
7F 007F
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
9C 015B
9D 0165
9E 017E
9F 017A
A0 00A0
A1 02C7
A2 02D8
A3 0141
A4 00A4
A5 0104
A6 00A6
A7 00A7
A8 00A8
A9 00A9
AA 015E
AB 00AB
AC 00AC
AD 00AD
AE 00AE
AF 017B
B0 00B0
B1 00B1
B2 02DB
B3 0142
B4 00B4
B5 00B5
B6 00B6
B7 00B7
B8 00B8
B9 0105
BA 015F
BB 00BB
BC 013D
BD 02DD
BE 013E
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
+258
Ver Arquivo
@@ -0,0 +1,258 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1251 (WinCyrillic) 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.
#
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
7F 007F
80 0402
81 0403
82 201A
83 0453
84 201E
85 2026
86 2020
87 2021
88 20AC
89 2030
8A 0409
8B 2039
8C 040A
8D 040C
8E 040B
8F 040F
90 0452
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
99 2122
9A 0459
9B 203A
9C 045A
9D 045C
9E 045B
9F 045F
A0 00A0
A1 040E
A2 045E
A3 0408
A4 00A4
A5 0490
A6 00A6
A7 00A7
A8 0401
A9 00A9
AA 0404
AB 00AB
AC 00AC
AD 00AD
AE 00AE
AF 0407
B0 00B0
B1 00B1
B2 0406
B3 0456
B4 0491
B5 00B5
B6 00B6
B7 00B7
B8 0451
B9 2116
BA 0454
BB 00BB
BC 0458
BD 0405
BE 0455
BF 0457
C0 0410
C1 0411
C2 0412
C3 0413
C4 0414
C5 0415
C6 0416
C7 0417
C8 0418
C9 0419
CA 041A
CB 041B
CC 041C
CD 041D
CE 041E
CF 041F
D0 0420
D1 0421
D2 0422
D3 0423
D4 0424
D5 0425
D6 0426
D7 0427
D8 0428
D9 0429
DA 042A
DB 042B
DC 042C
DD 042D
DE 042E
DF 042F
E0 0430
E1 0431
E2 0432
E3 0433
E4 0434
E5 0435
E6 0436
E7 0437
E8 0438
E9 0439
EA 043A
EB 043B
EC 043C
ED 043D
EE 043E
EF 043F
F0 0440
F1 0441
F2 0442
F3 0443
F4 0444
F5 0445
F6 0446
F7 0447
F8 0448
F9 0449
FA 044A
FB 044B
FC 044C
FD 044D
FE 044E
FF 044F
+254
Ver Arquivo
@@ -0,0 +1,254 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1252 (WinLatin1) 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.
#
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
7F 007F
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0160
8B 2039
8C 0152
8E 017D
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9A 0161
9B 203A
9C 0153
9E 017E
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
+242
Ver Arquivo
@@ -0,0 +1,242 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1253 (WinGreek) 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.
#
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
7F 007F
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
89 2030
8B 2039
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
99 2122
9B 203A
A0 00A0
A1 0385
A2 0386
A3 00A3
A4 00A4
A5 00A5
A6 00A6
A7 00A7
A8 00A8
A9 00A9
AB 00AB
AC 00AC
AD 00AD
AE 00AE
AF 2015
B0 00B0
B1 00B1
B2 00B2
B3 00B3
B4 0384
B5 00B5
B6 00B6
B7 00B7
B8 0388
B9 0389
BA 038A
BB 00BB
BC 038C
BD 00BD
BE 038E
BF 038F
C0 0390
C1 0391
C2 0392
C3 0393
C4 0394
C5 0395
C6 0396
C7 0397
C8 0398
C9 0399
CA 039A
CB 039B
CC 039C
CD 039D
CE 039E
CF 039F
D0 03A0
D1 03A1
D3 03A3
D4 03A4
D5 03A5
D6 03A6
D7 03A7
D8 03A8
D9 03A9
DA 03AA
DB 03AB
DC 03AC
DD 03AD
DE 03AE
DF 03AF
E0 03B0
E1 03B1
E2 03B2
E3 03B3
E4 03B4
E5 03B5
E6 03B6
E7 03B7
E8 03B8
E9 03B9
EA 03BA
EB 03BB
EC 03BC
ED 03BD
EE 03BE
EF 03BF
F0 03C0
F1 03C1
F2 03C2
F3 03C3
F4 03C4
F5 03C5
F6 03C6
F7 03C7
F8 03C8
F9 03C9
FA 03CA
FB 03CB
FC 03CC
FD 03CD
FE 03CE
+252
Ver Arquivo
@@ -0,0 +1,252 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1254 (WinTurkish) 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.
#
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
7F 007F
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 011E
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 0130
DE 015E
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 011F
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 0131
FE 015F
FF 00FF
+236
Ver Arquivo
@@ -0,0 +1,236 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1255 (WinHebrew) 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.
#
rtol 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
7F 007F
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8B 2039
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
9B 203A
A0 00A0
A1 00A1
A2 00A2
A3 00A3
A4 20AA
A5 00A5
A6 00A6
A7 00A7
A8 00A8
A9 00A9
AA 00D7
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 00F7
BB 00BB
BC 00BC
BD 00BD
BE 00BE
BF 00BF
C0 05B0
C1 05B1
C2 05B2
C3 05B3
C4 05B4
C5 05B5
C6 05B6
C7 05B7
C8 05B8
C9 05B9
CB 05BB
CC 05BC
CD 05BD
CE 05BE
CF 05BF
D0 05C0
D1 05C1
D2 05C2
D3 05C3
D4 05F0
D5 05F1
D6 05F2
D7 05F3
D8 05F4
E0 05D0
E1 05D1
E2 05D2
E3 05D3
E4 05D4
E5 05D5
E6 05D6
E7 05D7
E8 05D8
E9 05D9
EA 05DA
EB 05DB
EC 05DC
ED 05DD
EE 05DE
EF 05DF
F0 05E0
F1 05E1
F2 05E2
F3 05E3
F4 05E4
F5 05E5
F6 05E6
F7 05E7
F8 05E8
F9 05E9
FA 05EA
FD 200E
FE 200F
+259
Ver Arquivo
@@ -0,0 +1,259 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1256 (WinArabic) 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.
#
rtol 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
7F 007F
80 20AC
81 067E
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8A 0679
8B 2039
8C 0152
8D 0686
8E 0698
8F 0688
90 06AF
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 06A9
99 2122
9A 0691
9B 203A
9C 0153
9D 200C
9E 200D
9F 06BA
A0 00A0
A1 060C
A2 00A2
A3 00A3
A4 00A4
A5 00A5
A6 00A6
A7 00A7
A8 00A8
A9 00A9
AA 06BE
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 061B
BB 00BB
BC 00BC
BD 00BD
BE 00BE
BF 061F
C0 06C1
C1 0621
C2 0622
C3 0623
C4 0624
C5 0625
C6 0626
C7 0627
C8 0628
C9 0629
CA 062A
CB 062B
CC 062C
CD 062D
CE 062E
CF 062F
D0 0630
D1 0631
D2 0632
D3 0633
D4 0634
D5 0635
D6 0636
D7 00D7
D8 0637
D9 0638
DA 0639
DB 063A
DC 0640
DD 0641
DE 0642
DF 0643
E0 00E0
E1 0644
E2 00E2
E3 0645
E4 0646
E5 0647
E6 0648
E7 00E7
E8 00E8
E9 00E9
EA 00EA
EB 00EB
EC 0649
ED 064A
EE 00EE
EF 00EF
F0 064B
F1 064C
F2 064D
F3 064E
F4 00F4
F5 064F
F6 0650
F7 00F7
F8 0651
F9 00F9
FA 0652
FB 00FB
FC 00FC
FD 200E
FE 200F
FF 06D2
+247
Ver Arquivo
@@ -0,0 +1,247 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1257 (WinBaltic) 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.
#
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
7F 007F
80 20AC
82 201A
84 201E
85 2026
86 2020
87 2021
89 2030
8B 2039
8D 00A8
8E 02C7
8F 00B8
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
99 2122
9B 203A
9D 00AF
9E 02DB
A0 00A0
A2 00A2
A3 00A3
A4 00A4
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 00B4
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 02D9
+250
Ver Arquivo
@@ -0,0 +1,250 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 1258 (WinVietnamese) 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.
#
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
7F 007F
80 20AC
82 201A
83 0192
84 201E
85 2026
86 2020
87 2021
88 02C6
89 2030
8B 2039
8C 0152
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
98 02DC
99 2122
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 0102
C4 00C4
C5 00C5
C6 00C6
C7 00C7
C8 00C8
C9 00C9
CA 00CA
CB 00CB
CC 0300
CD 00CD
CE 00CE
CF 00CF
D0 0110
D1 00D1
D2 0309
D3 00D3
D4 00D4
D5 01A0
D6 00D6
D7 00D7
D8 00D8
D9 00D9
DA 00DA
DB 00DB
DC 00DC
DD 01AF
DE 0303
DF 00DF
E0 00E0
E1 00E1
E2 00E2
E3 0103
E4 00E4
E5 00E5
E6 00E6
E7 00E7
E8 00E8
E9 00E9
EA 00EA
EB 00EB
EC 0301
ED 00ED
EE 00EE
EF 00EF
F0 0111
F1 00F1
F2 0323
F3 00F3
F4 00F4
F5 01A1
F6 00F6
F7 00F7
F8 00F8
F9 00F9
FA 00FA
FB 00FB
FC 00FC
FD 01B0
FE 20AB
FF 00FF
+228
Ver Arquivo
@@ -0,0 +1,228 @@
charset 8bit
#
# This file defines the font and character mappings used for Windows
# Code Page 874 (Thai) 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.
#
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
7F 007F
80 20AC
85 2026
91 2018
92 2019
93 201C
94 201D
95 2022
96 2013
97 2014
A0 00A0
A1 0E01
A2 0E02
A3 0E03
A4 0E04
A5 0E05
A6 0E06
A7 0E07
A8 0E08
A9 0E09
AA 0E0A
AB 0E0B
AC 0E0C
AD 0E0D
AE 0E0E
AF 0E0F
B0 0E10
B1 0E11
B2 0E12
B3 0E13
B4 0E14
B5 0E15
B6 0E16
B7 0E17
B8 0E18
B9 0E19
BA 0E1A
BB 0E1B
BC 0E1C
BD 0E1D
BE 0E1E
BF 0E1F
C0 0E20
C1 0E21
C2 0E22
C3 0E23
C4 0E24
C5 0E25
C6 0E26
C7 0E27
C8 0E28
C9 0E29
CA 0E2A
CB 0E2B
CC 0E2C
CD 0E2D
CE 0E2E
CF 0E2F
D0 0E30
D1 0E31
D2 0E32
D3 0E33
D4 0E34
D5 0E35
D6 0E36
D7 0E37
D8 0E38
D9 0E39
DA 0E3A
DF 0E3F
E0 0E40
E1 0E41
E2 0E42
E3 0E43
E4 0E44
E5 0E45
E6 0E46
E7 0E47
E8 0E48
E9 0E49
EA 0E4A
EB 0E4B
EC 0E4C
ED 0E4D
EE 0E4E
EF 0E4F
F0 0E50
F1 0E51
F2 0E52
F3 0E53
F4 0E54
F5 0E55
F6 0E56
F7 0E57
F8 0E58
F9 0E59
FA 0E5A
FB 0E5B
+251
Ver Arquivo
@@ -0,0 +1,251 @@
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.
#
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
@@ -0,0 +1,251 @@
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.
#
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

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