doc/spm.shtml

   1 <HTML>
   2 <HEAD>
   3         <META NAME="COPYRIGHT" CONTENT="Copyright 1997-2000, All Rights Reserved">
   4         <META NAME="DOCNUMBER" CONTENT="CUPS-SPM-1.1">
   5         <META NAME="Author" CONTENT="Easy Software Products">
   6         <TITLE>CUPS Software Programmers Manual</TITLE>
   7 </HEAD>
   8 <BODY>
   9
  10 <H1 ALIGN="RIGHT">Preface</H1>
  11
  12 <P>This software programmers manual provides software programming
  13 information for the Common UNIX Printing System ("CUPS") Version 1.1.
  14
  15 <EMBED SRC="system-overview.shtml">
  16
  17 <!-- NEED 2in -->
  18 <H2>Document Overview</H2>
  19
  20 <P>This software programmers manual is organized into the following sections:
  21
  22 <UL>
  23         <LI><A HREF="#OVERVIEW">1 - Printing System Overview</A>
  24         <LI><A HREF="#CUPS_API">2 - The CUPS API</A>
  25         <LI><A HREF="#WRITING_FILTERS">3 - Writing Filters</A>
  26         <LI><A HREF="#WRITING_DRIVERS">4 - Writing Printer Drivers</A>
  27         <LI><A HREF="#WRITING_BACKENDS">5 - Writing Backends</A>
  28         <LI><A HREF="#LICENSE">A - Software License Agreement</A>
  29         <LI><A HREF="#CONSTANTS">B - Constants</A>
  30         <LI><A HREF="#STRUCTURES">C - Structures</A>
  31         <LI><A HREF="#FUNCTIONS">D - Functions</A>
  32 </UL>
  33
  34 <H2>Notation Conventions</H2>
  35
  36 <P>Various font and syntax conventions are used in this guide. Examples and
  37 their meanings and uses are explained below:
  38
  39 <CENTER><TABLE WIDTH="80%">
  40 <TR>
  41         <TH>Example</TH>
  42         <TD>&nbsp;&nbsp;&nbsp;</TD>
  43         <TH>Description</TH>
  44 </TR>
  45 <TR><TD>&nbsp;</TD></TR>
  46 <TR VALIGN="TOP">
  47         <TD><CODE>lpstat</CODE><BR>
  48         <CODE>lpstat(1)</CODE></TD>
  49
  50         <TD>&nbsp;&nbsp;&nbsp;</TD>
  51
  52         <TD>The names of commands; the first mention of a command or
  53         function in a chapter is followed by a manual page section
  54         number.</TD>
  55 </TR>
  56 <TR><TD>&nbsp;</TD></TR>
  57 <TR VALIGN="TOP">
  58         <TD><VAR>/var</VAR><BR>
  59         <VAR>/usr/share/cups/data/testprint.ps</VAR></TD>
  60
  61         <TD>&nbsp;&nbsp;&nbsp;</TD>
  62
  63         <TD>File and directory names.</TD>
  64 </TR>
  65 <TR><TD>&nbsp;</TD></TR>
  66 <TR VALIGN="TOP">
  67         <TD NOWRAP><TT>Request ID is Printer-123</TT></TD>
  68
  69         <TD>&nbsp;&nbsp;&nbsp;</TD>
  70
  71         <TD>Screen output.</TD>
  72 </TR>
  73 <TR><TD>&nbsp;</TD></TR>
  74 <TR VALIGN="TOP">
  75         <TD NOWRAP><KBD>lp -d printer filename ENTER</KBD></TD>
  76
  77         <TD>&nbsp;&nbsp;&nbsp;</TD>
  78
  79         <TD>Literal user input; special keys like <KBD>ENTER</B></KBD> are
  80         in ALL CAPS.</TD>
  81 </TR>
  82 <TR><TD>&nbsp;</TD></TR>
  83 <TR VALIGN="TOP">
  84         <TD>12.3</TD>
  85
  86         <TD>&nbsp;&nbsp;&nbsp;</TD>
  87
  88         <TD>Numbers in the text are written using the period (.) to indicate
  89         the decimal point.</TD>
  90 </TR>
  91 </TABLE></CENTER>
  92
  93 <!-- NEED 3in -->
  94 <H2>Abbreviations</H2>
  95
  96 The following abbreviations are used throughout this manual:
  97
  98 <UL>
  99 <DL>
 100
 101         <DT>kb
 102         <DD>Kilobytes, or 1024 bytes<BR>&nbsp;
 103
 104         <DT>Mb
 105         <DD>Megabytes, or 1048576 bytes<BR>&nbsp;
 106
 107         <DT>Gb
 108         <DD>Gigabytes, or 1073741824 bytes<BR>&nbsp;
 109
 110 </DL>
 111 </UL>
 112
 113 <H2>Other References</H2>
 114
 115 <UL>
 116 <DL>
 117
 118         <DT>CUPS Software Administrators Manual
 119
 120         <DD>An administration guide for the CUPS software.<BR>&nbsp;
 121
 122         <DT>CUPS Software Users Manual
 123
 124         <DD>An end-user guide for using the CUPS software.<BR>&nbsp;
 125
 126 </DL>
 127 </UL>
 128
 129
 130 <EMBED SRC="printing-overview.shtml">
 131
 132
 133 <H1 ALIGN="RIGHT"><A NAME="CUPS_API">2 - The CUPS API</A></H1>
 134
 135 <P>This chapter describes the CUPS Application Programmers Interface ("API").
 136
 137 <H2>The CUPS API Library</H2>
 138
 139 <P>The CUPS library provides a whole collection of interfaces needed to
 140 support the internal needs of the CUPS software as well as the needs of
 141 applications, filters, printer drivers, and backends.
 142
 143 <P>Unlike the rest of CUPS, the CUPS API library is provided under the
 144 GNU Library General Public License. This means that you can use the
 145 CUPS API library in both proprietary and open-source programs.
 146
 147 <P>Programs that use the CUPS API library typically will include the
 148 <CODE>&lt;cups/cups.h&gt;</CODE> header file:
 149
 150 <UL><PRE>
 151 #include &lt;cups/cups.h&gt;
 152
 153 ...
 154
 155 jobid = cupsPrintFile("myprinter", "filename.ps", "title",
 156                       num_options, options);
 157 </PRE></UL>
 158
 159 <P>Use the <CODE>-lcups</CODE> compiler option when linking to the CUPS API
 160 library:
 161
 162 <UL><PRE>
 163 <B>cc -o program program.c -lcups ENTER</B>
 164 </PRE></UL>
 165
 166 <P>Additional options and libraries may be required depending on the
 167 operating system and the location of the CUPS API library.
 168
 169 <H3>Detecting the CUPS API Library in GNU Autoconf</H3>
 170
 171 <P>GNU autoconf is a popular configuration tool used by many programs.
 172 Add the following lines to your <VAR>configure.in</CODE> file to check
 173 for the CUPS API library in your configuration script:
 174
 175 <UL><PRE>
 176 AC_CHECK_LIB(socket,socket,
 177 if test "$uname" != "IRIX"; then
 178         LIBS="-lsocket $LIBS"
 179 else
 180         echo "Not using -lsocket since you are running IRIX."
 181 fi)
 182 AC_CHECK_LIB(nsl,gethostbyaddr,
 183 if test "$uname" != "IRIX"; then
 184         LIBS="-lnsl $LIBS"
 185 else
 186         echo "Not using -lnsl since you are running IRIX."
 187 fi)
 188
 189 AC_CHECK_LIB(cups,httpConnect)
 190 </PRE></UL>
 191
 192 <H2>Printing Services</H2>
 193
 194 <P>The CUPS API library provides some basic printing services for applications
 195 that need to print files.
 196
 197 <H3>Include Files</H3>
 198
 199 <P>The include file used by all of these functions is
 200 <CODE>&lt;cups/cups.h&gt;</CODE>:
 201
 202 <UL><PRE>
 203 #include &lt;cups/cups.h&gt;
 204 </PRE></UL>
 205
 206 <H3>Printing a File</H3>
 207
 208 <P>The CUPS API provides two functions for printing files. The first is
 209 <CODE>cupsPrintFile</CODE> which prints a single named file:
 210
 211 <UL><PRE>
 212 #include &lt;cups/cups.h&gt;
 213
 214 ...
 215
 216 int jobid;
 217
 218 ...
 219
 220 jobid = cupsPrintFile("<I>name</I>", "<I>filename</I>", "<I>title</I>", 0, NULL);
 221 </PRE></UL>
 222
 223 <P>The <CODE>name</CODE> string is the name of the printer or class to
 224 print to. The <CODE>filename</CODE> string is the name of the file to
 225 print. The <CODE>title</CODE> string is the name of the print job, e.g.
 226 "Acme Word Document".
 227
 228 <P>The return value is a unique ID number for the print job or 0 if there
 229 was an error.
 230
 231 <H3>Printing Multiple Files</H3>
 232
 233 <P>The second printing function is <CODE>cupsPrintFiles</CODE>:
 234
 235 <UL><PRE>
 236 #include &lt;cups/cups.h&gt;
 237
 238 ...
 239
 240 int        jobid;
 241 int        num_files;
 242 const char *files[100];
 243 ...
 244
 245 jobid = cupsPrintFiles("name", <I>num_files</I>, <I>files</I>, "title", 0, NULL);
 246 </PRE></UL>
 247
 248 <P>Instead of passing a filename string as with <CODE>cupsPrintFile()</CODE>,
 249 you pass a file count (<CODE>num_files</CODE>) and filename pointer array
 250 (<CODE>files</CODE>) for each file that you want to print.
 251
 252 <P>As with <CODE>cupsPrintFile()</CODE>, the return value is a unique ID for
 253 the print job.
 254
 255 <H3>Cancelling Jobs</H3>
 256
 257 <P>The <CODE>cupsCancelJob()</CODE> function cancels a queued print job:
 258
 259 <UL><PRE>
 260 #include &lt;cups/cups.h&gt;
 261
 262 ...
 263
 264 int jobid;
 265 int status;
 266 ...
 267
 268 status = cupsCancelJob("<I>name</I>", <I>jobid</I>);
 269 </PRE></UL>
 270
 271 <P>The <CODE>name</CODE> string specifies the destination and is used
 272 to determine the server to send the request to. The <CODE>jobid</CODE>
 273 value is the integer returned from a previous <CODE>cupsPrintFile()</CODE>
 274 or <CODE>cupsPrintFiles()</CODE> call.
 275
 276 <P><CODE>cupsCancelJob()</CODE> returns <CODE>1</CODE> if the job was
 277 successfully cancelled and <CODE>0</CODE> if there was an error.
 278
 279 <H3>Getting the Available Printers and Classes</H3>
 280
 281 <P>The <CODE>cupsGetDests()</CODE> function can be used to get a list
 282 of the available printers, classes, and instances that a user has defined:
 283
 284 <UL><PRE>
 285 #include &lt;cups/cups.h&gt;
 286
 287 ...
 288
 289 int         num_dests;
 290 cups_dest_t *dests;
 291
 292 ...
 293
 294 num_dests = cupsGetDests(&amp;dests);
 295 </PRE></UL>
 296
 297 <P>Each destination is stored in a <CODE>cups_dest_t</CODE> structure which
 298 defines the printer or class name, the instance name (if any), if it is the
 299 default destination, and the default options the user has defined for the
 300 destination:
 301
 302 <UL><PRE>
 303 typedef struct               /**** Destination ****/
 304 {
 305   char          *name,       /* Printer or class name */
 306                 *instance;   /* Local instance name or NULL */
 307   int           is_default;  /* Is this printer the default? */
 308   int           num_options; /* Number of options */
 309   cups_option_t *options;    /* Options */
 310 } cups_dest_t;
 311 </PRE></UL>
 312
 313 <P>The destinations are sorted by name and instance for your convenience.
 314 Once you have the list of available destinations, you can lookup a specific
 315 destination using the <CODE>cupsGetDest()</CODE> function:
 316
 317 <UL><PRE>
 318 #include &lt;cups/cups.h&gt;
 319
 320 ...
 321
 322 int         num_dests;
 323 cups_dest_t *dests;
 324 cups_dest_t *mydest;
 325
 326 ...
 327
 328 mydest = cupsGetDest("<I>name</I>", "<I>instance</I>", num_dests, dests);
 329 </PRE></UL>
 330
 331 <P>The <CODE>name</CODE> string is the printer or class name. You can pass
 332 a value of <CODE>NULL</CODE> to get the default destination.
 333
 334 <P>The <CODE>instance</CODE> string is the user-defined instance name. Pass
 335 <CODE>NULL</CODE> to select the default instance, e.g. "name" instead of
 336 "name/instance".
 337
 338 <H3>Printing with Options</H3>
 339
 340 <P>All of the previous printing examples have passed <CODE>0</CODE> and
 341 <CODE>NULL</CODE> for the last two arguments to the <CODE>cupsPrintFile()</CODE>
 342 and <CODE>cupsPrintFiles()</CODE> functions. These last two arguments are the
 343 number of options and a pointer to the option array:
 344
 345 <UL><PRE>
 346 int cupsPrintFile(const char *name, const char *filename, const char *title,
 347                   int num_options, cups_option_t *options);
 348 int cupsPrintFiles(const char *name, int num_files, const char **files,
 349                    const char *title, int num_options,
 350                    cups_option_t *options);
 351 </UL></PRE>
 352
 353 <P>The <CODE>cups_option_t</CODE> structure holds each option and its value.
 354 These are converted as needed and passed to the CUPS server when printing a
 355 file.
 356
 357 <P>The simplest way of handling options is to use the <CODE>num_options</CODE>
 358 and <CODE>options</CODE> members of the <CODE>cups_dest_t</CODE>
 359 structure described earlier:
 360
 361 <UL><PRE>
 362 #include &lt;cups/cups.h&gt;
 363
 364 ...
 365
 366 int         jobid;
 367 int         num_dests;
 368 cups_dest_t *dests;
 369 cups_dest_t *mydest;
 370
 371 ...
 372
 373 mydest = cupsGetDest("<I>name</I>", "<I>instance</I>", num_dests, dests);
 374
 375 jobid  = cupsPrintFile(mydest-&gt;name, "filename", "title",
 376                        mydest-&gt;num_options, mydest-&gt;options);
 377 </PRE></UL>
 378
 379 <P>This effectively uses the options a user has previous selected without a
 380 lot of code.
 381
 382 <H3>Setting Printer Options</H3>
 383
 384 <P>Options can also be set by your program using the <CODE>cupsAddOption()</CODE>
 385 function:
 386
 387 <UL><PRE>
 388 #include &lt;cups/cups.h&gt;
 389
 390 ...
 391
 392 int           num_options;
 393 cups_option_t *options;
 394
 395 ...
 396
 397 num_options = 0;
 398 options     = NULL;
 399
 400 ...
 401
 402 num_options = cupsAddOption("<I>name</I>", "<I>value</I>", num_options, &amp;options);
 403 num_options = cupsAddOption("<I>name</I>", "<I>value</I>", num_options, &amp;options);
 404 num_options = cupsAddOption("<I>name</I>", "<I>value</I>", num_options, &amp;options);
 405 num_options = cupsAddOption("<I>name</I>", "<I>value</I>", num_options, &amp;options);
 406 </PRE></UL>
 407
 408 <P>The <CODE>name</CODE> string is the name of the option, and the
 409 <CODE>value</CODE> string is the value for that option.
 410
 411 <P>Each call to <CODE>cupsAddOption()</CODE> returns the new number of
 412 options. Since adding two options with the same name overwrites the
 413 first value with the second, do not assume that calling
 414 <CODE>cupsAddOptions()</CODE> 20 times will result in 20 options.
 415
 416 <P>Call <CODE>cupsFreeOptions</CODE> once you are done using the options:
 417
 418 <UL><PRE>
 419 #include &lt;cups/cups.h&gt;
 420
 421 ...
 422
 423 int           num_options;
 424 cups_option_t *options;
 425
 426 ...
 427
 428 cupsFreeOptions(num_options, options);
 429 </PRE></UL>
 430
 431 <H3>Getting Errors</H3>
 432
 433 <P>If any of the CUPS API printing functions returns an error, the reason for
 434 that error can be found by calling <CODE>cupsLastError()</CODE> and
 435 <CODE>cupsErrorString()</CODE>. <CODE>cupsLastError()</CODE> returns the
 436 last IPP error code that was encountered. <CODE>cupsErrorString()</CODE>
 437 converts the error code to a localized message string suitable for
 438 presentation to the user:
 439
 440 <UL><PRE>
 441 #include &lt;cups/cups.h&gt;
 442
 443 ...
 444
 445 int jobid;
 446
 447 ...
 448
 449 if (jobid == 0)
 450   puts(cupsErrorString(cupsLastError()));
 451 </PRE></UL>
 452
 453 <H2>PPD Services</H2>
 454
 455 <P>CUPS includes functions to access and manipulate PostScript Printer
 456 Description ("PPD") files that are used with the printer drivers in CUPS.
 457
 458 <P>Each PPD file enumerates the available features provided by a
 459 printer, including conflict information for specific options (e.g.
 460 can't duplex output on envelopes.)
 461
 462 <H3>Include Files</H3>
 463
 464 <P>Include the <CODE>&lt;cups/ppd.h&gt;</CODE> header file to use the PPD
 465 functions:
 466
 467 <UL><PRE>
 468 #include &lt;cups/ppd.h&gt;
 469 </PRE></UL>
 470
 471 <P>This header file is also included by the
 472 <CODE>&lt;cups/cups.h&gt;</CODE> header file.
 473
 474 <H3>Getting a PPD File for a Printer</H3>
 475
 476 <P>The <CODE>cupsGetPPD()</CODE> function retrieves the PPD file for the
 477 named printer or class:
 478
 479 <UL><PRE>
 480 #include &lt;cups/cups.h&gt;
 481
 482 ...
 483
 484 const char *filename;
 485
 486 filename = cupsGetPPD("<I>name</I>");
 487 </PRE></UL>
 488
 489 <P>The <CODE>name</CODE> string is the name of the printer or class, including
 490 the remote server name as appropriate (e.g. "printer@server".)
 491
 492 <P>The return value is a pointer to a filename in static storage; this value
 493 is overwritten with each call to <CODE>cupsGetPPD()</CODE>. If the printer
 494 or class does not exist, a <CODE>NULL</CODE> pointer will be returned.
 495
 496 <H3>Loading a PPD File</H3>
 497
 498 <P>The <CODE>ppdOpenFile()</CODE> function "opens" a PPD file and loads it
 499 into memory:
 500
 501 <UL><PRE>
 502 #include &lt;cups/ppd.h&gt;
 503
 504 ...
 505
 506 ppd_file_t *ppd;
 507
 508 ppd = ppdOpenFile("<I>filename</I>");
 509 </PRE></UL>
 510
 511 <P>The <CODE>filename</CODE> string is the name of the file to load, such as
 512 the value returned by the <CODE>cupsGetPPD()</CODE> function.
 513
 514 <P>The return value is a pointer to a structure describing the contents of the
 515 PPD file or NULL if the PPD file could not be read.
 516
 517 <H3>Freeing PPD File Information</H3>
 518
 519 <P>Once you are done using a PPD file, call the <CODE>ppdClose()</CODE> function
 520 to free all memory that has been used:
 521
 522 <UL><PRE>
 523 #include &lt;cups/ppd.h&gt;
 524
 525 ...
 526
 527 ppd_file_t *ppd;
 528
 529 ...
 530
 531 ppdClose(ppd);
 532 </PRE></UL>
 533
 534 <H3>The PPD File Structure</H3>
 535
 536 <P>Each PPD file contains a number of capability attributes, printer options,
 537 and conflict definitions. The page size options also include the physical
 538 margins for the printer and the minimum and maximum sizes for the printer.
 539 All of this information is stored in the <CODE>ppd_file_t</CODE> structure.
 540
 541 <H4>Capabilities</H4>
 542
 543 <P>Each PPD file contains a number of informational attributes that
 544 describe the capabilities of the printer. These are provided in the
 545 <CODE>ppd_file_t</CODE> structure in the following members:
 546
 547 <CENTER><TABLE WIDTH="80%" BORDER="1">
 548 <TR>
 549         <TH>Member</TH>
 550         <TH>Type</TH>
 551         <TH>Description</TH>
 552 </TR>
 553 <TR>
 554         <TD><CODE>accurate_screens</CODE></TD>
 555         <TD><CODE>int</CODE></TD>
 556         <TD>1 = supports accurate screens</TD>
 557 </TR>
 558 <TR>
 559         <TD><CODE>color_device</CODE></TD>
 560         <TD><CODE>int</CODE></TD>
 561         <TD>1 = color device</TD>
 562 </TR>
 563 <TR>
 564         <TD><CODE>colorspace</CODE></TD>
 565         <TD><CODE>ppd_cs_t</CODE></TD>
 566         <TD>Default colorspace: PPD_CS_CMYK, PPD_CS_CMY, PPD_CS_GRAY,
 567         PPD_CS_RGB, PPD_CS_RGBK, PPD_CS_N</TD>
 568 </TR>
 569 <TR>
 570         <TD><CODE>contone_only</CODE></TD>
 571         <TD><CODE>int</CODE></TD>
 572         <TD>1 = printer is continuous tone only</TD>
 573 </TR>
 574 <TR>
 575         <TD><CODE>num_emulations<BR>
 576         emulations</CODE></TD>
 577         <TD><CODE>int<BR>
 578         ppd_emul_t *</CODE></TD>
 579         <TD>Emulations supported by the printer</TD>
 580 </TR>
 581 <TR>
 582         <TD><CODE>flip_duplex</CODE></TD>
 583         <TD><CODE>int</CODE></TD>
 584         <TD>1 = need to flip odd pages when duplexing</TD>
 585 </TR>
 586 <TR>
 587         <TD><CODE>num_fonts<BR>
 588         fonts</CODE></TD>
 589         <TD><CODE>int<BR>
 590         char **</CODE></TD>
 591         <TD>The fonts available on the printer.</TD>
 592 </TR>
 593 <TR>
 594         <TD><CODE>jcl_begin<BR>
 595         jcl_ps<BR>
 596         jcl_end</CODE></TD>
 597         <TD><CODE>char *</CODE></TD>
 598         <TD>Job Control Language commands for PostScript output</TD>
 599 </TR>
 600 <TR>
 601         <TD><CODE>landscape</CODE></TD>
 602         <TD><CODE>int</CODE></TD>
 603         <TD>Landscape orientation, -90 or 90 degrees</TD>
 604 </TR>
 605 <TR>
 606         <TD><CODE>lang_encoding</CODE></TD>
 607         <TD><CODE>char *</CODE></TD>
 608         <TD>The character used for the option strings</TD>
 609 </TR>
 610 <TR>
 611         <TD><CODE>lang_version</CODE></TD>
 612         <TD><CODE>char *</CODE></TD>
 613         <TD>The language used for the options strings (English, French, etc.)</TD>
 614 </TR>
 615 <TR>
 616         <TD><CODE>language_level</CODE></TD>
 617         <TD><CODE>int</CODE></TD>
 618         <TD>PostScript language level, 1 to 3</TD>
 619 </TR>
 620 <TR>
 621         <TD><CODE>manual_copies</CODE></TD>
 622         <TD><CODE>int</CODE></TD>
 623         <TD>1 = Copies are done manually</TD>
 624 </TR>
 625 <TR>
 626         <TD><CODE>model_number</CODE></TD>
 627         <TD><CODE>int</CODE></TD>
 628         <TD>Driver-specific model number.</TD>
 629 </TR>
 630 <TR>
 631         <TD><CODE>patches</CODE></TD>
 632         <TD><CODE>char *</CODE></TD>
 633         <TD>Patch commands to send to the printer</TD>
 634 </TR>
 635 <TR>
 636         <TD><CODE>manufacturer</CODE></TD>
 637         <TD><CODE>char *</CODE></TD>
 638         <TD>The Manufacturer attribute from the PPD file, if any</TD>
 639 </TR>
 640 <TR>
 641         <TD><CODE>modelname</CODE></TD>
 642         <TD><CODE>char *</CODE></TD>
 643         <TD>The ModelName attribute from the PPD file</TD>
 644 </TR>
 645 <TR>
 646         <TD><CODE>nickname</CODE></TD>
 647         <TD><CODE>char *</CODE></TD>
 648         <TD>The NickName attribute from the PPD file, if any</TD>
 649 </TR>
 650 <TR>
 651         <TD><CODE>product</CODE></TD>
 652         <TD><CODE>char *</CODE></TD>
 653         <TD>The Product attribute from the PPD file, if any</TD>
 654 </TR>
 655 <TR>
 656         <TD><CODE>shortnickname</CODE></TD>
 657         <TD><CODE>char *</CODE></TD>
 658         <TD>The ShortNickName attribute from the PPD file, if any</TD>
 659 </TR>
 660 <TR>
 661         <TD><CODE>throughput</CODE></TD>
 662         <TD><CODE>int</CODE></TD>
 663         <TD>Number of pages per minute</TD>
 664 </TR>
 665 <TR>
 666         <TD><CODE>ttrasterizer</CODE></TD>
 667         <TD><CODE>char *</CODE></TD>
 668         <TD>The TruType font rasterizer (Type42)</TD>
 669 </TR>
 670 <TR>
 671         <TD><CODE>variable_sizes</CODE></TD>
 672         <TD><CODE>int</CODE></TD>
 673         <TD>1 = supports variable sizes</TD>
 674 </TR>
 675 </TABLE></CENTER>
 676
 677 <H4>Options and Groups</H4>
 678
 679 <P>PPD files support multiple options, which are stored in
 680 <CODE>ppd_option_t</CODE> and <CODE>ppd_choice_t</CODE> structures by
 681 the PPD functions.
 682
 683 <P>Each option in turn is associated with a group
 684 stored in the <CODE>ppd_group_t</CODE> structure. Groups can be
 685 specified in the PPD file; if an option is not associated with a group
 686 then it is put in a "General" or "Extra" group depending on the option.
 687
 688 <P>Groups can also have sub-groups; CUPS currently limits the depth of
 689 sub-groups to 1 level to reduce programming complexity.
 690
 691 <H4>Conflicts</H4>
 692
 693 <P>PPD files support specification of conflict conditions between
 694 different options. Conflicts are stored in <CODE>ppd_conflict_t</CODE>
 695 structures which specify the options that conflict with each other.
 696
 697 <H4>Page Sizes</H4>
 698
 699 <P>PPD files specify all of the available pages sizes and the physical
 700 margins associated with them. These sizes are stored in
 701 <CODE>ppd_size_t</CODE> structures and are available in the
 702 <CODE>num_sizes</CODE> and <CODE>sizes</CODE> members of the
 703 <CODE>ppd_file_t</CODE> structure. You can lookup a particular page size
 704 with the <CODE>ppdPageWidth()</CODE>, <CODE>ppdPageLength()</CODE>, and
 705 <CODE>ppdPageSize()</CODE> functions:
 706
 707 <UL><PRE>
 708 #include &lt;cups/ppd.h&gt;
 709
 710 ...
 711
 712 ppd_file_t *ppd;
 713 ppd_size_t *size;
 714 float      width;
 715 float      length;
 716
 717 ...
 718
 719 size   = ppdPageSize(ppd, "<I>size</I>");
 720 width  = ppdPageWidth(ppd, "<I>size</I>");
 721 length = ppdPageLength(ppd, "<I>size</I>");
 722 </PRE></UL>
 723
 724 <P>The <CODE>size</CODE> string is the named page size option. The
 725 width and length are in points; there are 72 points per inch. The
 726 <CODE>ppd_size_t</CODE> structure contains the width, length, and
 727 margin information:
 728
 729 <UL><PRE>
 730 typedef struct    /**** Page Sizes ****/
 731 {
 732   int   marked;   /* Page size selected? */
 733   char  name[41]; /* Media size option */
 734   float width,    /* Width of media in points */
 735         length,   /* Length of media in points */
 736         left,     /* Left printable margin in points */
 737         bottom,   /* Bottom printable margin in points */
 738         right,    /* Right printable margin in points */
 739         top;      /* Top printable margin in points */
 740 } ppd_size_t;
 741 </PRE></UL>
 742
 743 <H4>Custom Page Sizes</H4>
 744
 745 <P>Besides the standard page sizes listed in a PPD file, some printers
 746 support variable or custom page sizes. If <CODE>variables_sizes</CODE>
 747 is non-zero, the <CODE>custom_min</CODE>, <CODE>custom_max</CODE>, and
 748 <CODE>custom_margins</CODE> members of the <CODE>ppd_file_t</CODE>
 749 structure define the limits of the variable sizes.
 750
 751 <P>To get the resulting media size, use a page size string of
 752 <CODE>Custom.<I>width</I>x<I>length</I></CODE>, where <CODE>width</CODE>
 753 and <CODE>length</CODE> are integer values in points:
 754
 755 <UL><PRE>
 756 Custom.612x792   [8.5 inches wide, 11 inches long]
 757 Custom.1224x792  [17 inches wide, 11 inches long]
 758 </PRE></UL>
 759
 760 <H3>Marking Options</H3>
 761
 762 <P>Before marking any user-defined options, call the <CODE>ppdMarkDefaults()</CODE>
 763 function to mark the default options from the PPD file:
 764
 765 <UL><PRE>
 766 #include &lt;cups/ppd.h&gt;
 767
 768 ...
 769
 770 ppd_file_t *ppd;
 771
 772 ...
 773
 774 ppdMarkDefaults(ppd);
 775 </PRE></UL>
 776
 777 <P>Then call the <CODE>ppdMarkOption()</CODE> function to mark individual
 778 options:
 779
 780 <UL><PRE>
 781 #include &lt;cups/ppd.h&gt;
 782
 783 ...
 784
 785 ppd_file_t *ppd;
 786 int        conflicts;
 787
 788 ...
 789
 790 conflicts = ppdMarkOption(ppd, "<I>name</I>", "<I>value</I>");
 791 </PRE></UL>
 792
 793 <P>The <CODE>name</CODE> and <CODE>value</CODE> strings choose a
 794 particular option and choice, respectively. The return value is 0
 795 if there are not conflicts created by the selection.
 796
 797 <P>CUPS also provides a convenience function for marking all options
 798 in the <CODE>cups_option_t</CODE> structure:
 799
 800 <UL><PRE>
 801 #include &lt;cups/cups.h&gt;
 802
 803 ...
 804
 805 ppd_file_t    *ppd;
 806 int           num_options;
 807 cups_option_t *options;
 808 int           conflicts;
 809
 810 ...
 811
 812 conflicts = cupsMarkOptions(ppd, num_options, options);
 813 </PRE></UL>
 814
 815 <P>The <CODE>cupsMarkOptions()</CODE> function also handles mapping the
 816 IPP job template attributes to PPD options. The return value is the number
 817 of conflicts present.
 818
 819 <H3>Checking for Conflicts</H3>
 820
 821 <P>The <CODE>ppdMarkOption()</CODE> and <CODE>cupsMarkOptions()</CODE>
 822 functions return the number of conflicts with the currently marked options.
 823
 824 <P>Call the <CODE>ppdConflicts()</CODE> function to get the number of
 825 conflicts after you have marked all of the options:
 826
 827 <UL><PRE>
 828 #include &lt;cups/cups.h&gt;
 829
 830 ...
 831
 832 ppd_file_t *ppd;
 833 int        conflicts;
 834
 835 ...
 836
 837 conflicts = ppdConflicts(ppd);
 838 </PRE></UL>
 839
 840 <P>The return value is the number of conflicting options, or 0 if there
 841 are no conflicts.
 842
 843
 844 <H1 ALIGN="RIGHT"><A NAME="WRITING_FILTERS">3 - Writing Filters</A></H1>
 845
 846 <P>This chapter describes how to write a file filter for CUPS.
 847
 848 <H2>Overview</H2>
 849
 850 <H3>Security Considerations</H3>
 851
 852 <H3>Users and Groups</H3>
 853
 854 <H3>Temporary Files</H3>
 855
 856 <H3>Page Accounting</H3>
 857
 858
 859 <H2>Command-Line Arguments</H2>
 860
 861 <H3>Copy Generation</H3>
 862
 863
 864 <H2>Environment Variables</H2>
 865
 866
 867 <H2>Writing a HTML Filter</H2>
 868
 869
 870 <H1 ALIGN="RIGHT"><A NAME="WRITING_DRIVERS">4 - Writing Filters</A></H1>
 871
 872 <P>This chapter discusses how to write a printer driver, which is a
 873 special filter program that converts CUPS raster data into the
 874 appropriate commands and data required for a printer.
 875
 876 <H2>Overview</H2>
 877
 878 <H3>Page Accounting</H3>
 879
 880 <H3>Color Management</H3>
 881
 882
 883 <H2>Raster Functions</H2>
 884
 885 <H3>cupsRasterOpen()</H3>
 886
 887 <H3>cupsRasterReadHeader()</H3>
 888
 889 <H3>cupsRasterReadPixels()</H3>
 890
 891 <H3>cupsRasterClose()</H3>
 892
 893
 894 <H2>Writing a HP-PCL Driver</H2>
 895
 896
 897 <H1 ALIGN="RIGHT"><A NAME="WRITING_BACKENDS">5 - Writing Filters</A></H1>
 898
 899 <P>This chapter describes how to write a backend for CUPS.  Backends
 900 communicate directly with printers and allow printer drivers and
 901 filters to send data using any type of connection transparently.
 902
 903 <H2>Overview</H2>
 904
 905 <H3>Security Considerations</H3>
 906
 907 <H3>Users and Groups</H3>
 908
 909 <H3>Temporary Files</H3>
 910
 911 <H3>Page Accounting</H3>
 912
 913 <H3>Retries</H3>
 914
 915
 916 <H2>Command-Line Arguments</H2>
 917
 918 <H3>Copy Generation</H3>
 919
 920
 921 <H2>Environment Variables</H2>
 922
 923
 924 <H2>Writing a Serial Port Backend</H2>
 925
 926
 927 <H1 ALIGN="RIGHT"><A NAME="LICENSE">A - Software License Agreement</A></H1>
 928
 929 <EMBED SRC="../LICENSE.html">
 930
 931
 932 <H1 ALIGN="RIGHT"><A NAME="CONSTANTS">B - Constants</A></H1>
 933
 934 <P>This appendix lists all of the constants that are defined by the CUPS
 935 API.
 936
 937 <H2>CUPS Constants</H2>
 938
 939 <H2>HTTP Constants</H2>
 940
 941 <H2>IPP Constants</H2>
 942
 943 <H2>Language Constants</H2>
 944
 945 <H2>PPD Constants</H2>
 946
 947 <H2>Raster Constants</H2>
 948
 949
 950 <H1 ALIGN="RIGHT"><A NAME="STRUCTURES">C - Structures</A></H1>
 951
 952 <P>This appendix describes all of the structures that are defined by the CUPS
 953 API.
 954
 955
 956 <H1 ALIGN="RIGHT"><A HREF="FUNCTIONS">D - Functions</A></H1>
 957
 958 <P>This appendix provides a reference for all of the CUPS API functions.
 959
 960 <!-- NEW PAGE --><H2><A NAME="cupsAddOption">cupsAddOption()</A></H2>
 961
 962 <H3>Usage</H3>
 963
 964 <PRE>
 965 int
 966 cupsAddOption(const char *name,
 967               const char *value,
 968               int num_options,
 969               cups_option_t **options);
 970 </PRE>
 971
 972 <H3>Arguments</H3>
 973
 974 <CENTER><TABLE WIDTH="80%" BORDER>
 975 <TR>
 976         <TH>Argument</TH>
 977         <TH>Description</TH>
 978 </TR>
 979 <TR>
 980         <TD>name</TD>
 981         <TD>The name of the option.</TD>
 982 </TR>
 983 <TR>
 984         <TD>value</TD>
 985         <TD>The value of the option.</TD>
 986 </TR>
 987 <TR>
 988         <TD>num_options</TD>
 989         <TD>Number of options currently in the array.</TD>
 990 </TR>
 991 <TR>
 992         <TD>options</TD>
 993         <TD>Pointer to the options array.</TD>
 994 </TR>
 995 </TABLE></CENTER>
 996
 997 <H3>Returns</H3>
 998
 999 <P>The new number of options.
1000
1001 <H3>Description</H3>
1002
1003 <P><CODE>cupsAddOption()</CODE> adds an option to the specified array.
1004
1005 <H3>Example</H3>
1006
1007 <PRE>
1008 #include &lt;cups.h&gt;
1009
1010 ...
1011
1012 /* Declare the options array */
1013 int           num_options;
1014 <A HREF="#cups_option_t">cups_option_t</A> *options;
1015
1016 /* Initialize the options array */
1017 num_options = 0;
1018 options     = (cups_option_t *)0;
1019
1020 /* Add options using cupsAddOption() */
1021 num_options = cupsAddOption("media", "letter", num_options, &amp;options);
1022 num_options = cupsAddOption("resolution", "300dpi", num_options, &amp;options);
1023 </PRE>
1024
1025 <H3>See Also</H3>
1026
1027 <A HREF="#cupsFreeOptions"><CODE>cupsFreeOptions()</CODE></A>,
1028 <A HREF="#cupsGetOption"><CODE>cupsGetOption()</CODE></A>,
1029 <A HREF="#cupsParseOptions"><CODE>cupsParseOptions()</CODE></A>
1030
1031 <!-- NEW PAGE --><H2><A NAME="cupsCancelJob">cupsCancelJob()</A></H2>
1032
1033 <H3>Usage</H3>
1034
1035 <PRE>
1036 int
1037 cupsCancelJob(const char *dest,
1038               int job);
1039 </PRE>
1040
1041 <H3>Arguments</H3>
1042
1043 <CENTER><TABLE WIDTH="80%" BORDER>
1044 <TR>
1045         <TH>Argument</TH>
1046         <TH>Description</TH>
1047 </TR>
1048 <TR>
1049         <TD>dest</TD>
1050         <TD>Printer or class name</TD>
1051 </TR>
1052 <TR>
1053         <TD>job</TD>
1054         <TD>Job ID</TD>
1055 </TR>
1056 </TABLE></CENTER>
1057
1058 <H3>Returns</H3>
1059
1060 <P>1 on success, 0 on failure. On failure the error can be found by calling
1061 <A HREF="#cupsLastError"><CODE>cupsLastError()</CODE></A>.
1062
1063 <H3>Description</H3>
1064
1065 <P><CODE>cupsCancelJob()</CODE> cancels the specifies job.
1066
1067 <H3>Example</H3>
1068
1069 <PRE>
1070 #include &lt;cups.h&gt;
1071
1072 cupsCancelJob("LaserJet", 1);
1073 </PRE>
1074
1075 <H3>See Also</H3>
1076
1077 <P>
1078 <A HREF="#cupsLastError"><CODE>cupsLastError()</CODE></A>,
1079 <A HREF="#cupsPrintFile"><CODE>cupsPrintFile()</CODE></A>
1080
1081 <!-- NEW PAGE --><H2><A NAME="cupsDoFileRequest">cupsDoFileRequest()</A></H2>
1082
1083 <H3>Usage</H3>
1084
1085 <PRE>
1086 ipp_t *
1087 cupsDoFileRequest(http_t *http,
1088                   ipp_t *request,
1089                   const char *resource,
1090                   const char *filename);
1091 </PRE>
1092
1093 <H3>Arguments</H3>
1094
1095 <CENTER><TABLE WIDTH="80%" BORDER>
1096 <TR>
1097         <TH>Argument</TH>
1098         <TH>Description</TH>
1099 </TR>
1100 <TR>
1101         <TD>http</TD>
1102         <TD>HTTP connection to server.</TD>
1103 </TR>
1104 <TR>
1105         <TD>request</TD>
1106         <TD>IPP request data.</TD>
1107 </TR>
1108 <TR>
1109         <TD>resource</TD>
1110         <TD>HTTP resource name for POST.</TD>
1111 </TR>
1112 <TR>
1113         <TD>filename</TD>
1114         <TD>File to send with POST request (<CODE>NULL</CODE> pointer if none.)</TD>
1115 </TR>
1116 </TABLE></CENTER>
1117
1118 <H3>Returns</H3>
1119
1120 <P>IPP response data or <CODE>NULL</CODE> if the request fails. On failure
1121 the error can be found by calling
1122 <A HREF="#cupsLastError"><CODE>cupsLastError()</CODE></A>.
1123
1124 <H3>Description</H3>
1125
1126 <P><CODE>cupsDoFileRequest()</CODE> does a HTTP POST request and provides the
1127 IPP request and optionally the contents of a file to the IPP server. It also
1128 handles resubmitting the request and performing password authentication as
1129 needed.
1130
1131 <H3>Example</H3>
1132
1133 <PRE>
1134 #include &lt;cups.h&gt;
1135
1136 <A HREF="#http_t">http_t</A>      *http;
1137 <A HREF="#cups_lang_t">cups_lang_t</A> *language;
1138 <A HREF="#ipp_t">ipp_t</A>       *request;
1139 ipp_t       *response;
1140
1141 ...
1142
1143 /* Get the default language */
1144 language = <A HREF="#cupsLangDefault">cupsLangDefault()</A>;
1145
1146 /* Create a new IPP request */
1147 request  = <A HREF="#ippNew">ippNew()</A>;
1148
1149 request-&gt;request.op.operation_id = IPP_PRINT_FILE;
1150 request-&gt;request.op.request_id   = 1;
1151
1152 /* Add required attributes */
1153 <A HREF="#ippAddString">ippAddString</A>(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1154              "attributes-charset", NULL, <A HREF="#cupsLangEncoding">cupsLangEncoding</A>(language));
1155
1156 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1157              "attributes-natural-language", NULL,
1158              language != NULL ? language-&gt;language : "C");
1159
1160 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1161              NULL, "ipp://hostname/resource");
1162
1163 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_NAME, "requesting-user-name",
1164              NULL, <A HREF="#cupsUser">cupsUser()</A>);
1165
1166 /* Do the request... */
1167 response = cupsDoFileRequest(http, request, "/resource", "filename.txt");
1168 </PRE>
1169
1170 <H3>See Also</H3>
1171
1172 <P>
1173 <A HREF="#cupsLangDefault"><CODE>cupsLangDefault()</CODE></A>,
1174 <A HREF="#cupsLangEncoding"><CODE>cupsLangEncoding()</CODE></A>,
1175 <A HREF="#cupsUser"><CODE>cupsUser()</CODE></A>,
1176 <A HREF="#httpConnect"><CODE>httpConnect()</CODE></A>,
1177 <A HREF="#ippAddString"><CODE>ippAddString()</CODE></A>,
1178 <A HREF="#ippNew"><CODE>ippNew()</CODE></A>
1179
1180 <!-- NEW PAGE --><H2><A NAME="cupsDoRequest">cupsDoRequest()</A></H2>
1181
1182 <H3>Usage</H3>
1183
1184 <PRE>
1185 ipp_t *
1186 cupsDoRequest(http_t *http,
1187               ipp_t *request,
1188               const char *resource);
1189 </PRE>
1190
1191 <H3>Arguments</H3>
1192
1193 <CENTER><TABLE WIDTH="80%" BORDER>
1194 <TR>
1195         <TH>Argument</TH>
1196         <TH>Description</TH>
1197 </TR>
1198 <TR>
1199         <TD>http</TD>
1200         <TD>HTTP connection to server.</TD>
1201 </TR>
1202 <TR>
1203         <TD>request</TD>
1204         <TD>IPP request data.</TD>
1205 </TR>
1206 <TR>
1207         <TD>resource</TD>
1208         <TD>HTTP resource name for POST.</TD>
1209 </TR>
1210 </TABLE></CENTER>
1211
1212 <H3>Returns</H3>
1213
1214 <P>IPP response data or <CODE>NULL</CODE> if the request fails. On failure
1215 the error can be found by calling
1216 <A HREF="#cupsLastError"><CODE>cupsLastError()</CODE></A>.
1217
1218 <H3>Description</H3>
1219
1220 <P><CODE>cupsDoRequest()</CODE> does a HTTP POST request and provides
1221 the IPP request to the IPP server. It also handles resubmitting the
1222 request and performing password authentication as needed.
1223
1224 <H3>Example</H3>
1225
1226 <PRE>
1227 #include &lt;cups.h&gt;
1228
1229 <A HREF="#http_t">http_t</A>      *http;
1230 <A HREF="#cups_lang_t">cups_lang_t</A> *language;
1231 <A HREF="#ipp_t">ipp_t</A>       *request;
1232 ipp_t       *response;
1233
1234 ...
1235
1236 /* Get the default language */
1237 language = <A HREF="#cupsLangDefault">cupsLangDefault()</A>;
1238
1239 /* Create a new IPP request */
1240 request  = <A HREF="#ippNew">ippNew()</A>;
1241
1242 request-&gt;request.op.operation_id = IPP_GET_PRINTER_ATTRIBUTES;
1243 request-&gt;request.op.request_id   = 1;
1244
1245 /* Add required attributes */
1246 <A HREF="#ippAddString">ippAddString</A>(request, IPP_TAG_OPERATION, IPP_TAG_CHARSET,
1247              "attributes-charset", NULL, <A HREF="#cupsLangEncoding">cupsLangEncoding</A>(language));
1248
1249 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_LANGUAGE,
1250              "attributes-natural-language", NULL,
1251              language != NULL ? language-&gt;language : "C");
1252
1253 ippAddString(request, IPP_TAG_OPERATION, IPP_TAG_URI, "printer-uri",
1254              NULL, "ipp://hostname/resource");
1255
1256 /* Do the request... */
1257 response = cupsDoRequest(http, request, "/resource");
1258 </PRE>
1259
1260 <H3>See Also</H3>
1261
1262 <P>
1263 <A HREF="#cupsLangDefault"><CODE>cupsLangDefault()</CODE></A>,
1264 <A HREF="#cupsLangEncoding"><CODE>cupsLangEncoding()</CODE></A>,
1265 <A HREF="#cupsUser"><CODE>cupsUser()</CODE></A>,
1266 <A HREF="#httpConnect"><CODE>httpConnect()</CODE></A>,
1267 <A HREF="#ippAddString"><CODE>ippAddString()</CODE></A>,
1268 <A HREF="#ippNew"><CODE>ippNew()</CODE></A>
1269
1270 <!-- NEW PAGE --><H2><A NAME="cupsFreeOptions">cupsFreeOptions()</A></H2>
1271
1272 <H3>Usage</H3>
1273
1274 <PRE>
1275 void
1276 cupsFreeOptions(int num_options,
1277                 cups_option_t *options);
1278
1279 <H3>Arguments</H3>
1280
1281 <CENTER><TABLE WIDTH="80%" BORDER>
1282 <TR>
1283         <TH>Argument</TH>
1284         <TH>Description</TH>
1285 </TR>
1286 <TR>
1287         <TD>num_options</TD>
1288         <TD>Number of options in array.</TD>
1289 </TR>
1290 <TR>
1291         <TD>options</TD>
1292         <TD>Pointer to options array.</TD>
1293 </TR>
1294 </TABLE></CENTER>
1295
1296 <H3>Description</H3>
1297
1298 <P><CODE>cupsFreeOptions()</CODE> frees all memory associated with the
1299 option array specified.
1300
1301 <H3>Example</H3>
1302
1303 <PRE>
1304 #include &lt;cups/cups.h&gt;
1305
1306 int           num_options;
1307 cups_option_t *options;
1308
1309 ...
1310
1311 cupsFreeOptions(num_options, options);
1312 </PRE>
1313
1314 <H3>See Also</H3>
1315
1316 <P>
1317 <A HREF="#cupsAddOption">cupsAddOption()</A>,
1318 <A HREF="#cupsGetOption">cupsGetOption()</A>,
1319 <A HREF="#cupsMarkOptions">cupsMarkOptions()</A>,
1320 <A HREF="#cupsParseOptions">cupsParseOptions()</A>
1321
1322 <!-- NEW PAGE --><H2><A NAME="cupsGetClasses">cupsGetClasses()</A></H2>
1323
1324 <H3>Usage</H3>
1325
1326 <PRE>
1327 int
1328 cupsGetClasses(char ***classes);
1329 </PRE>
1330
1331 <H3>Arguments</H3>
1332
1333 <CENTER><TABLE WIDTH="80%" BORDER>
1334 <TR>
1335         <TH>Argument</TH>
1336         <TH>Description</TH>
1337 </TR>
1338 <TR>
1339         <TD>classes</TD>
1340         <TD>Pointer to character pointer array.</TD>
1341 </TR>
1342 </TABLE></CENTER>
1343
1344 <H3>Returns</H3>
1345
1346 <P>The number of printer classes available.
1347
1348 <H3>Description</H3>
1349
1350 <P><CODE>cupsGetClasses()</CODE> gets a list of the available printer classes.
1351 The returned array should be freed using the <CODE>free()</CODE> when it is
1352 no longer needed.
1353
1354 <H3>Example</H3>
1355
1356 <PRE>
1357 #include &lt;cups/cups.h&gt;
1358
1359 int  i;
1360 int  num_classes;
1361 char **classes;
1362
1363 ...
1364
1365 num_classes = cupsGetClasses(&classes);
1366
1367 ...
1368
1369 if (num_classes > 0)
1370 {
1371   for (i = 0; i < num_classes; i ++)
1372     free(classes[i]);
1373
1374   free(classes);
1375 }
1376 </PRE>
1377
1378 <H3>See Also</H3>
1379
1380 <P>
1381 <A HREF="#cupsGetDefault">cupsGetDefault()</CODE>,
1382 <A HREF="#cupsGetPrinters">cupsGetPrinters()</CODE>
1383
1384 <!-- NEW PAGE --><H2><A NAME="cupsGetDefault">cupsGetDefault()</A></H2>
1385
1386 <H3>Usage</H3>
1387
1388 <PRE>
1389 const char *
1390 cupsGetDefault(void);
1391 </PRE>
1392
1393 <H3>Returns</H3>
1394
1395 <P>A pointer to the default destination.
1396
1397 <H3>Description</H3>
1398
1399 <P><CODE>cupsGetDefault()</CODE> gets the default destination printer or class.
1400 The default destination is stored in a static string and will be overwritten
1401 (usually with the same value) after each call.
1402
1403 <H3>Example</H3>
1404
1405 <PRE>
1406 #include &lt;cups/cups.h&gt;
1407
1408 printf("The default destination is %s\n", cupsGetDefault());
1409 </PRE>
1410
1411 <H3>See Also</H3>
1412
1413 <P>
1414 <A HREF="#cupsGetClasses">cupsGetClasses()</CODE>,
1415 <A HREF="#cupsGetPrinters">cupsGetPrinters()</CODE>
1416
1417 <!-- NEW PAGE --><H2><A NAME="cupsGetOption">cupsGetOption()</A></H2>
1418
1419 <H3>Usage</H3>
1420
1421 <PRE>
1422 const char *
1423 cupsGetOption(const char *name,
1424               int num_options,
1425               cups_option_t *options);
1426 </PRE>
1427
1428 <H3>Arguments</H3>
1429
1430 <CENTER><TABLE WIDTH="80%" BORDER>
1431 <TR>
1432         <TH>Argument</TH>
1433         <TH>Description</TH>
1434 </TR>
1435 <TR>
1436         <TD>name</TD>
1437         <TD>The name of the option.</TD>
1438 </TR>
1439 <TR>
1440         <TD>num_options</TD>
1441         <TD>The number of options in the array.</TD>
1442 </TR>
1443 <TR>
1444         <TD>options</TD>
1445         <TD>The options array.</TD>
1446 </TR>
1447 </TABLE></CENTER>
1448
1449 <H3>Returns</H3>
1450
1451 <P>A pointer to the option values or <CODE>NULL</CODE> if the option is
1452 not defined.
1453
1454 <H3>Description</H3>
1455
1456 <P><CODE>cupsGetOption()</CODE> returns the first occurrence of the
1457 named option. If the option is not included in the options array then a
1458 <CODE>NULL</CODE> pointer is returned.
1459
1460 <PRE>
1461 #include &lt;cups/cups.h&gt;
1462
1463 int           num_options;
1464 cups_option_t *options;
1465 const char    *media;
1466
1467 ...
1468
1469 media = cupsGetOption("media", num_options, options);
1470 </PRE>
1471
1472 <H3>See Also</H3>
1473
1474 <P>
1475 <A HREF="#cupsAddOption">cupsAddOption()</A>,
1476 <A HREF="#cupsFreeOptions">cupsFreeOptions()</A>,
1477 <A HREF="#cupsMarkOptions">cupsMarkOptions()</A>,
1478 <A HREF="#cupsParseOptions">cupsParseOptions()</A>
1479
1480 <!-- NEW PAGE --><H2><A NAME="cupsGetPassword">cupsGetPassword()</A></H2>
1481
1482 <H3>Usage</H3>
1483
1484 <PRE>
1485 const char *
1486 cupsGetPassword(const char *prompt);
1487 </PRE>
1488
1489 <H3>Arguments</H3>
1490
1491 <CENTER><TABLE WIDTH="80%" BORDER>
1492 <TR>
1493         <TH>Argument</TH>
1494         <TH>Description</TH>
1495 </TR>
1496 <TR>
1497         <TD>prompt</TD>
1498         <TD>The prompt to display to the user.</TD>
1499 </TR>
1500 </TABLE></CENTER>
1501
1502 <H3>Returns</H3>
1503
1504 <P>A pointer to the password that was entered or <CODE>NULL</CODE> if no
1505 password was entered.
1506
1507 <H3>Description</H3>
1508
1509 <P><CODE>cupsGetPassword()</CODE> displays the prompt string and asks the user
1510 for a password. The password text is not echoed to the user.
1511
1512 <H3>Example</H3>
1513
1514 <PRE>
1515 #include &lt;cups/cups.h&gt;
1516
1517 char *password;
1518
1519 ...
1520
1521 password = cupsGetPassword("Please enter a password:");
1522 </PRE>
1523
1524 <H3>See Also</H3>
1525
1526 <P>
1527 <A HREF="#cupsServer">cupsServer()</A>,
1528 <A HREF="#cupsUser()">cupsUser()</A>
1529
1530 <!-- NEW PAGE --><H2><A NAME="cupsGetPPD">cupsGetPPD()</A></H2>
1531
1532 <H3>Usage</H3>
1533
1534 <PRE>
1535 const char *
1536 cupsGetPPD(const char *printer);
1537 </PRE>
1538
1539 <H3>Arguments</H3>
1540
1541 <CENTER><TABLE WIDTH="80%" BORDER>
1542 <TR>
1543         <TH>Argument</TH>
1544         <TH>Description</TH>
1545 </TR>
1546 <TR>
1547         <TD>printer</TD>
1548         <TD>The name of the printer.</TD>
1549 </TR>
1550 </TABLE></CENTER>
1551
1552 <H3>Returns</H3>
1553
1554 <P>The name of a temporary file containing the PPD file or <CODE>NULL</CODE>
1555 if the printer cannot be located or does not have a PPD file.
1556
1557 <H3>Description</H3>
1558
1559 <P><CODE>cupsGetPPD()</CODE> gets a copy of the PPD file for the named printer.
1560 The printer name can be of the form "printer" or "printer@hostname".
1561
1562 <P>You should remove (unlink) the PPD file after you are done using it. The
1563 filename is stored in a static buffer and will be overwritten with each call
1564 to <CODE>cupsGetPPD()</CODE>.
1565
1566 <H3>Example</H3>
1567
1568 <PRE>
1569 #include &lt;cups/cups.h&gt;
1570
1571 char *ppd;
1572
1573 ...
1574
1575 ppd = cupsGetPPD("printer@hostname");
1576
1577 ...
1578
1579 unlink(ppd);
1580 </PRE>
1581
1582 <!-- NEW PAGE --><H2><A NAME="cupsGetPrinters">cupsGetPrinters()</A></H2>
1583
1584 <H3>Usage</H3>
1585
1586 <PRE>
1587 int
1588 cupsGetPrinters(char ***printers);
1589 </PRE>
1590
1591 <H3>Arguments</H3>
1592
1593 <CENTER><TABLE WIDTH="80%" BORDER>
1594 <TR>
1595         <TH>Argument</TH>
1596         <TH>Description</TH>
1597 </TR>
1598 <TR>
1599         <TD>printers</TD>
1600         <TD>Pointer to character pointer array.</TD>
1601 </TR>
1602 </TABLE></CENTER>
1603
1604 <H3>Returns</H3>
1605
1606 <P>The number of printer printers available.
1607
1608 <H3>Description</H3>
1609
1610 <P><CODE>cupsGetPrinters()</CODE> gets a list of the available printers.
1611 The returned array should be freed using the <CODE>free()</CODE> when it is
1612 no longer needed.
1613
1614 <H3>Example</H3>
1615
1616 <PRE>
1617 #include &lt;cups/cups.h&gt;
1618
1619 int  i;
1620 int  num_printers;
1621 char **printers;
1622
1623 ...
1624
1625 num_printers = cupsGetPrinters(&printers);
1626
1627 ...
1628
1629 if (num_printers > 0)
1630 {
1631   for (i = 0; i < num_printers; i ++)
1632     free(printers[i]);
1633
1634   free(printers);
1635 }
1636 </PRE>
1637
1638 <H3>See Also</H3>
1639
1640 <P>
1641 <A HREF="#cupsGetClasses">cupsGetClasses()</CODE>,
1642 <A HREF="#cupsGetDefault">cupsGetDefault()</CODE>
1643
1644 <!-- NEW PAGE --><H2><A NAME="cupsLangDefault">cupsLangDefault()</A></H2>
1645
1646 <H3>Usage</H3>
1647
1648 <PRE>
1649 const char *
1650 cupsLangDefault(void);
1651 </PRE>
1652
1653 <H3>Returns</H3>
1654
1655 <P>A pointer to the default language structure.
1656
1657 <H3>Description</H3>
1658
1659 <P><CODE>cupsLangDefault()</CODE> returns a language structure for the default
1660 language. The default language is defined by the <CODE>LANG</CODE> environment
1661 variable. If the specified language cannot be located then the POSIX (English)
1662 locale is used.
1663
1664 <P>Call <CODE>cupsLangFree()</CODE> to free any memory associated with the
1665 language structure when you are done.
1666
1667 <H3>Example</H3>
1668
1669 <PRE>
1670 #include &lt;cups/language.h&gt;
1671
1672 cups_lang_t *language;
1673 ...
1674
1675 language = cupsLangDefault();
1676
1677 ...
1678
1679 cupsLangFree(language);
1680 </PRE>
1681
1682 <H3>See Also</H3>
1683
1684 <P>
1685 <A HREF="#cupsLangEncoding">cupsLangEncoding()</A>,
1686 <A HREF="#cupsLangFlush">cupsLangFlush()</A>,
1687 <A HREF="#cupsLangFree">cupsLangFree()</A>,
1688 <A HREF="#cupsLangGet">cupsLangGet()</A>,
1689 <A HREF="#cupsLangString">cupsLangString()</A>
1690
1691 <!-- NEW PAGE --><H2><A NAME="cupsLangEncoding">cupsLangEncoding()</A></H2>
1692
1693 <H3>Usage</H3>
1694
1695 <PRE>
1696 char *
1697 cupsLangEncoding(cups_lang_t *language);
1698 </PRE>
1699
1700 <H3>Arguments</H3>
1701
1702 <CENTER><TABLE WIDTH="80%" BORDER>
1703 <TR>
1704         <TH>Argument</TH>
1705         <TH>Description</TH>
1706 </TR>
1707 <TR>
1708         <TD>language</TD>
1709         <TD>The language structure.</TD>
1710 </TR>
1711 </TABLE></CENTER>
1712
1713 <H3>Returns</H3>
1714
1715 <P>A pointer to the encoding string.
1716
1717 <H3>Description</H3>
1718
1719 <P><CODE>cupsLangEncoding()</CODE> returns the language encoding used for the
1720 specified language, e.g. "iso-8859-1", "utf-8", etc.
1721
1722 <H3>Example</H3>
1723
1724 <PRE>
1725 #include &lt;cups/language.h&gt;
1726
1727 cups_lang_t *language;
1728 char        *encoding;
1729 ...
1730
1731 language = cupsLangDefault();
1732 encoding = cupsLangEncoding(language);
1733 ...
1734
1735 cupsLangFree(language);
1736 </PRE>
1737
1738 <H3>See Also</H3>
1739
1740 <P>
1741 <A HREF="#cupsLangDefault">cupsLangDefault()</A>,
1742 <A HREF="#cupsLangFlush">cupsLangFlush()</A>,
1743 <A HREF="#cupsLangFree">cupsLangFree()</A>,
1744 <A HREF="#cupsLangGet">cupsLangGet()</A>,
1745 <A HREF="#cupsLangString">cupsLangString()</A>
1746
1747 <!-- NEW PAGE --><H2><A NAME="cupsLangFlush">cupsLangFlush()</A></H2>
1748
1749 <H3>Usage</H3>
1750
1751 <PRE>
1752 void
1753 cupsLangFlush(void);
1754 </PRE>
1755
1756 <H3>Description</H3>
1757
1758 <P><CODE>cupsLangFlush()</CODE> frees all language structures that have been
1759 allocated.
1760
1761 <H3>Example</H3>
1762
1763 <PRE>
1764 #include &lt;cups/language.h&gt;
1765
1766 ...
1767
1768 cupsLangFlush();
1769 </PRE>
1770
1771 <H3>See Also</H3>
1772
1773 <P>
1774 <A HREF="#cupsLangDefault">cupsLangDefault()</A>,
1775 <A HREF="#cupsLangEncoding">cupsLangEncoding()</A>,
1776 <A HREF="#cupsLangFree">cupsLangFree()</A>,
1777 <A HREF="#cupsLangGet">cupsLangGet()</A>,
1778 <A HREF="#cupsLangString">cupsLangString()</A>
1779
1780 <!-- NEW PAGE --><H2><A NAME="cupsLangFree">cupsLangFree()</A></H2>
1781
1782 <H3>Usage</H3>
1783
1784 <PRE>
1785 void
1786 cupsLangFree(cups_lang_t *language);
1787 </PRE>
1788
1789 <H3>Arguments</H3>
1790
1791 <CENTER><TABLE WIDTH="80%" BORDER>
1792 <TR>
1793         <TH>Argument</TH>
1794         <TH>Description</TH>
1795 </TR>
1796 <TR>
1797         <TD>language</TD>
1798         <TD>The language structure to free.</TD>
1799 </TR>
1800 </TABLE></CENTER>
1801
1802 <H3>Description</H3>
1803
1804 <P><CODE>cupsLangFree()</CODE> frees the specified language structure.
1805
1806 <H3>Example</H3>
1807
1808 <PRE>
1809 #include &lt;cups/language.h&gt;
1810
1811 cups_lang_t *language;
1812 ...
1813
1814 cupsLangFree(language);
1815 </PRE>
1816
1817 <H3>See Also</H3>
1818
1819 <P>
1820 <A HREF="#cupsLangDefault">cupsLangDefault()</A>,
1821 <A HREF="#cupsLangEncoding">cupsLangEncoding()</A>,
1822 <A HREF="#cupsLangFlush">cupsLangFlush()</A>,
1823 <A HREF="#cupsLangGet">cupsLangGet()</A>,
1824 <A HREF="#cupsLangString">cupsLangString()</A>
1825
1826 <!-- NEW PAGE --><H2><A NAME="cupsLangGet">cupsLangGet()</A></H2>
1827
1828 <H3>Usage</H3>
1829
1830 <PRE>
1831 cups_lang_t *
1832 cupsLangGet(const char *name);
1833 </PRE>
1834
1835 <H3>Arguments</H3>
1836
1837 <CENTER><TABLE WIDTH="80%" BORDER>
1838 <TR>
1839         <TH>Argument</TH>
1840         <TH>Description</TH>
1841 </TR>
1842 <TR>
1843         <TD>name</TD>
1844         <TD>The name of the locale.</TD>
1845 </TR>
1846 </TABLE></CENTER>
1847
1848 <H3>Returns</H3>
1849
1850 <P>A pointer to a language structure.
1851
1852 <H3>Description</H3>
1853
1854 <P><CODE>cupsLangGet()</CODE> returns a language structure for the specified
1855 locale. If the locale is not defined then the POSIX (English) locale is
1856 substituted.
1857
1858 <H3>Example</H3>
1859
1860 <PRE>
1861 #include &lt;cups/language.h&gt;
1862
1863 cups_lang_t *language;
1864
1865 ...
1866
1867 language = cupsLangGet("fr");
1868
1869 ...
1870
1871 cupsLangFree(language);
1872 </PRE>
1873
1874 <H3>See Also</H3>
1875
1876 <P>
1877 <A HREF="#cupsLangDefault">cupsLangDefault()</A>,
1878 <A HREF="#cupsLangEncoding">cupsLangEncoding()</A>,
1879 <A HREF="#cupsLangFlush">cupsLangFlush()</A>,
1880 <A HREF="#cupsLangFree">cupsLangFree()</A>,
1881 <A HREF="#cupsLangString">cupsLangString()</A>
1882
1883 <!-- NEW PAGE --><H2><A NAME="cupsLangString">cupsLangString()</A></H2>
1884
1885 <H3>Usage</H3>
1886
1887 <PRE>
1888 char *
1889 cupsLangString(cups_lang_t *language,
1890                int         message);
1891 </PRE>
1892
1893 <H3>Arguments</H3>
1894
1895 <CENTER><TABLE WIDTH="80%" BORDER>
1896 <TR>
1897         <TH>Argument</TH>
1898         <TH>Description</TH>
1899 </TR>
1900 <TR>
1901         <TD>language</TD>
1902         <TD>The language to query.</TD>
1903 </TR>
1904 <TR>
1905         <TD>message</TD>
1906         <TD>The message number.</TD>
1907 </TR>
1908 </TABLE></CENTER>
1909
1910 <H3>Returns</H3>
1911
1912 <P>A pointer to the message string or <CODE>NULL</CODE> if the message is
1913 not defined.
1914
1915 <H3>Description</H3>
1916
1917 <P><CODE>cupsLangString()</CODE> returns a pointer to the specified message
1918 string in the specified language.
1919
1920 <H3>Example</H3>
1921
1922 <PRE>
1923 #include &lt;cups/language.h&gt;
1924
1925 cups_lang_t *language;
1926 char        *s;
1927 ...
1928
1929 language = cupsLangGet("fr");
1930
1931 s = cupsLangString(language, CUPS_MSG_YES);
1932
1933 ...
1934
1935 cupsLangFree(language);
1936 </PRE>
1937
1938 <H3>See Also</H3>
1939
1940 <P>
1941 <A HREF="#cupsLangDefault">cupsLangDefault()</A>,
1942 <A HREF="#cupsLangEncoding">cupsLangEncoding()</A>,
1943 <A HREF="#cupsLangFlush">cupsLangFlush()</A>,
1944 <A HREF="#cupsLangFree">cupsLangFree()</A>,
1945 <A HREF="#cupsLangGet">cupsLangGet()</A>
1946
1947 <!-- NEW PAGE --><H2><A NAME="cupsLastError">cupsLastError()</A></H2>
1948
1949 <H3>Usage</H3>
1950
1951 <PRE>
1952 ipp_status_t
1953 cupsLastError(void);
1954 </PRE>
1955
1956 <H3>Returns</H3>
1957
1958 <P>An enumeration containing the last IPP error.
1959
1960 <H3>Description</H3>
1961
1962 <P><CODE>cupsLastError()</CODE> returns the last IPP error that occurred.
1963 If no error occurred then it will return <CODE>IPP_OK</CODE> or
1964 <CODE>IPP_OK_CONFLICT</CODE>.
1965
1966 <H3>Example</H3>
1967
1968 <PRE>
1969 #include &lt;cups/cups.h&gt;
1970
1971 ipp_status_t status;
1972
1973 ...
1974
1975 status = cupsLastError();
1976 </PRE>
1977
1978 <H3>See Also</H3>
1979
1980 <P>
1981 <A HREF="#cupsCancelJob">cupsCancelJob()</A>,
1982 <A HREF="#cupsPrintFile">cupsPrintFile()</A>
1983
1984 <!-- NEW PAGE --><H2><A NAME="cupsMarkOptions">cupsMarkOptions()</A></H2>
1985
1986 <H3>Usage</H3>
1987
1988 <PRE>
1989 int
1990 cupsMarkOptions(ppd_file_t *ppd,
1991                 int num_options,
1992                 cups_option_t *options);
1993 </PRE>
1994
1995 <H3>Arguments</H3>
1996
1997 <CENTER><TABLE WIDTH="80%" BORDER>
1998 <TR>
1999         <TH>Argument</TH>
2000         <TH>Description</TH>
2001 </TR>
2002 <TR>
2003         <TD>ppd</TD>
2004         <TD>The PPD file to mark.</TD>
2005 </TR>
2006 <TR>
2007         <TD>num_options</TD>
2008         <TD>The number of options in the options array.</TD>
2009 </TR>
2010 <TR>
2011         <TD>options</TD>
2012         <TD>A pointer to the options array.</TD>
2013 </TR>
2014 </TABLE></CENTER>
2015
2016 <H3>Returns</H3>
2017
2018 <P>The number of conflicts found.
2019
2020 <H3>Description</H3>
2021
2022 <P><CODE>cupsMarkOptions()</CODE> marks options in the PPD file. It also
2023 handles mapping of IPP option names and values to PPD option names.
2024
2025 <H3>Example</H3>
2026
2027 <PRE>
2028 #include &lt;cups/cups.h&gt;
2029
2030 int           num_options;
2031 cups_option_t *options;
2032 ppd_file_t    *ppd;
2033
2034 ...
2035
2036 cupsMarkOptions(ppd, num_options, options);
2037 </PRE>
2038
2039 <H3>See Also</H3>
2040
2041 <P>
2042 <A HREF="#cupsAddOption">cupsAddOption()</A>,
2043 <A HREF="#cupsFreeOptions">cupsFreeOptions()</A>,
2044 <A HREF="#cupsGetOption">cupsGetOption()</A>,
2045 <A HREF="#cupsParseOptions">cupsParseOptions()</A>
2046
2047 <!-- NEW PAGE --><H2><A NAME="cupsParseOptions">cupsParseOptions()</A></H2>
2048
2049 <H3>Usage</H3>
2050
2051 <PRE>
2052 int
2053 cupsParseOptions(const char *arg,
2054                  int num_options,
2055                  cups_option_t **options);
2056 </PRE>
2057
2058 <H3>Arguments</H3>
2059
2060 <CENTER><TABLE WIDTH="80%" BORDER>
2061 <TR>
2062         <TH>Argument</TH>
2063         <TH>Description</TH>
2064 </TR>
2065 <TR>
2066         <TD>arg</TD>
2067         <TD>The string containing one or more options.</TD>
2068 </TR>
2069 <TR>
2070         <TD>num_options</TD>
2071         <TD>The number of options in the options array.</TD>
2072 </TR>
2073 <TR>
2074         <TD>options</TD>
2075         <TD>A pointer to the options array pointer.</TD>
2076 </TR>
2077 </TABLE></CENTER>
2078
2079 <H3>Returns</H3>
2080
2081 <P>The new number of options in the array.
2082
2083 <H3>Description</H3>
2084
2085 <P><CODE>cupsParseOptions()</CODE> parses the specifies string for one
2086 or more options of the form "name=value", "name", or "noname". It can
2087 be called multiple times to combine the options from several strings.
2088
2089 <H3>Example</H3>
2090
2091 <PRE>
2092 #include &lt;cups/cups.h&gt;
2093
2094 int           num_options;
2095 cups_option_t *options;
2096
2097 ...
2098
2099 num_options = 0;
2100 options     = (cups_option_t *)0;
2101 num_options = cupsParseOptions(argv[5], num_options, &amp;options);
2102 </PRE>
2103
2104 <H3>See Also</H3>
2105
2106 <P>
2107 <A HREF="#cupsAddOption">cupsAddOption()</A>,
2108 <A HREF="#cupsFreeOptions">cupsFreeOptions()</A>,
2109 <A HREF="#cupsGetOption">cupsGetOption()</A>,
2110 <A HREF="#cupsMarkOptions">cupsMarkOptions()</A>
2111
2112 <!-- NEW PAGE --><H2><A NAME="cupsPrintFile">cupsPrintFile()</A></H2>
2113
2114 <H3>Usage</H3>
2115
2116 <PRE>
2117 int
2118 cupsPrintFile(const char    *printer,
2119               const char    *filename,
2120               const char    *title,
2121               int           num_options,
2122               cups_option_t *options);
2123 </PRE>
2124
2125 <H3>Arguments</H3>
2126
2127 <CENTER><TABLE WIDTH="80%" BORDER>
2128 <TR>
2129         <TH>Argument</TH>
2130         <TH>Description</TH>
2131 </TR>
2132 <TR>
2133         <TD>printer</TD>
2134         <TD>The printer or class to print to.</TD>
2135 </TR>
2136 <TR>
2137         <TD>filename</TD>
2138         <TD>The file to print.</TD>
2139 </TR>
2140 <TR>
2141         <TD>title</TD>
2142         <TD>The job title.</TD>
2143 </TR>
2144 <TR>
2145         <TD>num_options</TD>
2146         <TD>The number of options in the options array.</TD>
2147 </TR>
2148 <TR>
2149         <TD>options</TD>
2150         <TD>A pointer to the options array.</TD>
2151 </TR>
2152 </TABLE></CENTER>
2153
2154 <H3>Returns</H3>
2155
2156 <P>The new job ID number or 0 on error.
2157
2158 <H3>Description</H3>
2159
2160 <P><CODE>cupsPrintFile()</CODE> sends a file to the specified printer or
2161 class for printing. If the job cannot be printed the error code can be
2162 found by calling <CODE>cupsLastError()</CODE>.
2163
2164 <H3>Example</H3>
2165
2166 <PRE>
2167 #include &lt;cups/cups.h&gt;
2168
2169 int           num_options;
2170 cups_option_t *options;
2171 int           jobid;
2172
2173 ...
2174
2175 jobid = cupsPrintFile("printer@hostname", "filename.ps", "Job Title",
2176                       num_options, options);
2177 </PRE>
2178
2179 <H3>See Also</H3>
2180
2181 <P>
2182 <A HREF="#cupsCancelJob">cupsCancelJob()</A>,
2183 <A HREF="#cupsLastError">cupsLastError()</A>,
2184 <A HREF="#cupsPrintFiles">cupsPrintFiles()</A>
2185
2186 <!-- NEW PAGE --><H2><A NAME="cupsPrintFiles">cupsPrintFiles()</A></H2>
2187
2188 <H3>Usage</H3>
2189
2190 <PRE>
2191 int
2192 cupsPrintFiles(const char    *printer,
2193                int           num_files,
2194                const char    **files,
2195                const char    *title,
2196                int           num_options,
2197                cups_option_t *options);
2198 </PRE>
2199
2200 <H3>Arguments</H3>
2201
2202 <CENTER><TABLE WIDTH="80%" BORDER>
2203 <TR>
2204         <TH>Argument</TH>
2205         <TH>Description</TH>
2206 </TR>
2207 <TR>
2208         <TD>printer</TD>
2209         <TD>The printer or class to print to.</TD>
2210 </TR>
2211 <TR>
2212         <TD>num_files</TD>
2213         <TD>The number of files to print.</TD>
2214 </TR>
2215 <TR>
2216         <TD>files</TD>
2217         <TD>The files to print.</TD>
2218 </TR>
2219 <TR>
2220         <TD>title</TD>
2221         <TD>The job title.</TD>
2222 </TR>
2223 <TR>
2224         <TD>num_options</TD>
2225         <TD>The number of options in the options array.</TD>
2226 </TR>
2227 <TR>
2228         <TD>options</TD>
2229         <TD>A pointer to the options array.</TD>
2230 </TR>
2231 </TABLE></CENTER>
2232
2233 <H3>Returns</H3>
2234
2235 <P>The new job ID number or 0 on error.
2236
2237 <H3>Description</H3>
2238
2239 <P><CODE>cupsPrintFiles()</CODE> sends multiple files to the specified
2240 printer or class for printing. If the job cannot be printed the error
2241 code can be found by calling <CODE>cupsLastError()</CODE>.
2242
2243 <H3>Example</H3>
2244
2245 <PRE>
2246 #include &lt;cups/cups.h&gt;
2247
2248 int           num_files;
2249 const char    *files[100];
2250 int           num_options;
2251 cups_option_t *options;
2252 int           jobid;
2253
2254 ...
2255
2256 jobid = cupsPrintFiles("printer@hostname", num_files, files,
2257                        "Job Title", num_options, options);
2258 </PRE>
2259
2260 <H3>See Also</H3>
2261
2262 <P>
2263 <A HREF="#cupsCancelJob">cupsCancelJob()</A>,
2264 <A HREF="#cupsLastError">cupsLastError()</A>,
2265 <A HREF="#cupsPrintFile">cupsPrintFile()</A>
2266
2267 <!-- NEW PAGE --><H2><A NAME="cupsRasterClose">cupsRasterClose()</A></H2>
2268
2269 <H3>Usage</H3>
2270
2271 <PRE>
2272 void
2273 cupsRasterClose(cups_raster_t *ras);
2274 </PRE>
2275
2276 <H3>Arguments</H3>
2277
2278 <CENTER><TABLE WIDTH="80%" BORDER>
2279 <TR>
2280         <TH>Argument</TH>
2281         <TH>Description</TH>
2282 </TR>
2283 <TR>
2284         <TD>ras</TD>
2285         <TD>The raster stream to close.</TD>
2286 </TR>
2287 </TABLE></CENTER>
2288
2289 <H3>Description</H3>
2290
2291 <P><CODE>cupsRasterClose()</CODE> closes the specified raster stream.
2292
2293 <H3>Example</H3>
2294
2295 <PRE>
2296 #include &lt;cups/raster.h&gt;
2297
2298 cups_raster_t *ras;
2299
2300 ...
2301
2302 cupsRasterClose(ras);
2303 </PRE>
2304
2305 <H3>See Also</H3>
2306
2307 <P>
2308 <A HREF="#cupsRasterOpen">cupsRasterOpen()</A>,
2309 <A HREF="#cupsRasterReadHeader">cupsRasterReadHeader()</A>,
2310 <A HREF="#cupsRasterReadPixels">cupsRasterReadPixels()</A>,
2311 <A HREF="#cupsRasterWriteHeader">cupsRasterWriteHeader()</A>,
2312 <A HREF="#cupsRasterWritePixels">cupsRasterWritePixels()</A>
2313
2314
2315 <!-- NEW PAGE --><H2><A NAME="cupsRasterOpen">cupsRasterOpen()</A></H2>
2316
2317 <H3>Usage</H3>
2318
2319 <PRE>
2320 cups_raster_t *
2321 cupsRasterOpen(int fd,
2322                cups_mode_t mode);
2323 </PRE>
2324
2325 <H3>Arguments</H3>
2326
2327 <CENTER><TABLE WIDTH="80%" BORDER>
2328 <TR>
2329         <TH>Argument</TH>
2330         <TH>Description</TH>
2331 </TR>
2332 <TR>
2333         <TD>fd</TD>
2334         <TD>The file descriptor to use.</TD>
2335 </TR>
2336 <TR>
2337         <TD>mode</TD>
2338         <TD>The mode to use; <CODE>CUPS_RASTER_READ</CODE> or
2339         <CODE>CUPS_RASTER_WRITE</CODE>.</TD>
2340 </TR>
2341 </TABLE></CENTER>
2342
2343 <H3>Returns</H3>
2344
2345 <P>A pointer to a raster stream or <CODE>NULL</CODE> if there was an error.
2346
2347 <H3>Description</H3>
2348
2349 <P><CODE>cupsRasterOpen()</CODE> opens a raster stream for reading or writing.
2350
2351 <H3>Example</H3>
2352
2353 <PRE>
2354 #include &lt;cups/raster.h&gt;
2355
2356 cups_raster_t *ras;
2357
2358 ...
2359
2360 ras = cupsRasterOpen(0, CUPS_RASTER_READ);
2361 </PRE>
2362
2363 <H3>See Also</H3>
2364
2365 <P>
2366 <A HREF="#cupsRasterClose">cupsRasterClose()</A>,
2367 <A HREF="#cupsRasterReadHeader">cupsRasterReadHeader()</A>,
2368 <A HREF="#cupsRasterReadPixels">cupsRasterReadPixels()</A>,
2369 <A HREF="#cupsRasterWriteHeader">cupsRasterWriteHeader()</A>,
2370 <A HREF="#cupsRasterWritePixels">cupsRasterWritePixels()</A>
2371
2372 <!-- NEW PAGE --><H2><A NAME="cupsRasterReadHeader">cupsRasterReadHeader()</A></H2>
2373
2374 <H3>Usage</H3>
2375
2376 <PRE>
2377 unsigned
2378 cupsRasterReadHeader(cups_raster_t *ras,
2379                      cups_page_header_t *header);
2380 </PRE>
2381
2382 <H3>Arguments</H3>
2383
2384 <CENTER><TABLE WIDTH="80%" BORDER>
2385 <TR>
2386         <TH>Argument</TH>
2387         <TH>Description</TH>
2388 </TR>
2389 <TR>
2390         <TD>ras</TD>
2391         <TD>The raster stream to read from.</TD>
2392 </TR>
2393 <TR>
2394         <TD>header</TD>
2395         <TD>A pointer to a page header structure to read into.</TD>
2396 </TR>
2397 </TABLE></CENTER>
2398
2399 <H3>Returns</H3>
2400
2401 <P>1 on success, 0 on EOF or error.
2402
2403 <H3>Description</H3>
2404
2405 <P><CODE>cupsRasterReadHeader()</CODE> reads a page header from the specified
2406 raster stream.
2407
2408 <H3>Example</H3>
2409
2410 <PRE>
2411 #include &lt;cups/raster.h&gt;
2412
2413 int                  line;
2414 cups_raster_t        *ras;
2415 cups_raster_header_t header;
2416 unsigned char        pixels[8192];
2417 ...
2418
2419 while (cupsRasterReadHeader(ras, &amp;header))
2420 {
2421   ...
2422
2423   for (line = 0; line &lt; header.cupsHeight; line ++)
2424   {
2425     cupsRasterReadPixels(ras, pixels, header.cupsBytesPerLine);
2426
2427     ...
2428   }
2429 }
2430 </PRE>
2431
2432 <H3>See Also</H3>
2433
2434 <P>
2435 <A HREF="#cupsRasterClose">cupsRasterClose()</A>,
2436 <A HREF="#cupsRasterOpen">cupsRasterOpen()</A>,
2437 <A HREF="#cupsRasterReadPixels">cupsRasterReadPixels()</A>,
2438 <A HREF="#cupsRasterWriteHeader">cupsRasterWriteHeader()</A>,
2439 <A HREF="#cupsRasterWritePixels">cupsRasterWritePixels()</A>
2440
2441 <!-- NEW PAGE --><H2><A NAME="cupsRasterReadPixels">cupsRasterReadPixels()</A></H2>
2442
2443 <H3>Usage</H3>
2444
2445 <PRE>
2446 unsigned
2447 cupsRasterReadPixels(cups_raster_t *ras,
2448                      unsigned char *pixels,
2449                      unsigned length);
2450 </PRE>
2451
2452 <H3>Arguments</H3>
2453
2454 <CENTER><TABLE WIDTH="80%" BORDER>
2455 <TR>
2456         <TH>Argument</TH>
2457         <TH>Description</TH>
2458 </TR>
2459 <TR>
2460         <TD>ras</TD>
2461         <TD>The raster stream to read from.</TD>
2462 </TR>
2463 <TR>
2464         <TD>pixels</TD>
2465         <TD>The pointer to a pixel buffer.</TD>
2466 </TR>
2467 <TR>
2468         <TD>length</TD>
2469         <TD>The number of bytes of pixel data to read.</TD>
2470 </TR>
2471 </TABLE></CENTER>
2472
2473 <H3>Returns</H3>
2474
2475 <P>The number of bytes read or 0 on EOF or error.
2476
2477 <H3>Description</H3>
2478
2479 <P><CODE>cupsRasterReadPixels()</CODE> reads pixel data from the specified
2480 raster stream.
2481
2482 <H3>Example</H3>
2483
2484 <PRE>
2485 #include &lt;cups/raster.h&gt;
2486
2487 int                  line;
2488 cups_raster_t        *ras;
2489 cups_raster_header_t header;
2490 unsigned char        pixels[8192];
2491 ...
2492
2493 while (cupsRasterReadHeader(ras, &amp;header))
2494 {
2495   ...
2496
2497   for (line = 0; line &lt; header.cupsHeight; line ++)
2498   {
2499     cupsRasterReadPixels(ras, pixels, header.cupsBytesPerLine);
2500
2501     ...
2502   }
2503 }
2504 </PRE>
2505
2506 <H3>See Also</H3>
2507
2508 <P>
2509 <A HREF="#cupsRasterClose">cupsRasterClose()</A>,
2510 <A HREF="#cupsRasterOpen">cupsRasterOpen()</A>,
2511 <A HREF="#cupsRasterReadHeader">cupsRasterReadHeader()</A>,
2512 <A HREF="#cupsRasterWriteHeader">cupsRasterWriteHeader()</A>,
2513 <A HREF="#cupsRasterWritePixels">cupsRasterWritePixels()</A>
2514
2515 <!-- NEW PAGE --><H2><A NAME="cupsRasterWriteHeader">cupsRasterWriteHeader()</A></H2>
2516
2517 <H3>Usage</H3>
2518
2519 <PRE>
2520 unsigned
2521 cupsRasterWriteHeader(cups_raster_t *ras,
2522                       cups_page_header_t *header);
2523 </PRE>
2524
2525 <H3>Arguments</H3>
2526
2527 <CENTER><TABLE WIDTH="80%" BORDER>
2528 <TR>
2529         <TH>Argument</TH>
2530         <TH>Description</TH>
2531 </TR>
2532 <TR>
2533         <TD>ras</TD>
2534         <TD>The raster stream to write to.</TD>
2535 </TR>
2536 <TR>
2537         <TD>header</TD>
2538         <TD>A pointer to the page header to write.</TD>
2539 </TR>
2540 </TABLE></CENTER>
2541
2542 <H3>Returns</H3>
2543
2544 <P>1 on success, 0 on error.
2545
2546 <H3>Description</H3>
2547
2548 <P><CODE>cupsRasterWriteHeader()</CODE> writes the specified page header to
2549 a raster stream.
2550
2551 <H3>Example</H3>
2552
2553 <PRE>
2554 #include &lt;cups/raster.h&gt;
2555
2556 int                  line;
2557 cups_raster_t        *ras;
2558 cups_raster_header_t header;
2559 unsigned char        pixels[8192];
2560 ...
2561
2562 cupsRasterWriteHeader(ras, &amp;header);
2563
2564 for (line = 0; line &lt; header.cupsHeight; line ++)
2565 {
2566   ...
2567
2568   cupsRasterWritePixels(ras, pixels, header.cupsBytesPerLine);
2569 }
2570 </PRE>
2571
2572 <H3>See Also</H3>
2573
2574 <P>
2575 <A HREF="#cupsRasterClose">cupsRasterClose()</A>,
2576 <A HREF="#cupsRasterOpen">cupsRasterOpen()</A>,
2577 <A HREF="#cupsRasterReadHeader">cupsRasterReadHeader()</A>,
2578 <A HREF="#cupsRasterReadPixels">cupsRasterReadPixels()</A>,
2579 <A HREF="#cupsRasterWritePixels">cupsRasterWritePixels()</A>
2580
2581 <!-- NEW PAGE --><H2><A NAME="cupsRasterWritePixels">cupsRasterWritePixels()</A></H2>
2582
2583 <H3>Usage</H3>
2584
2585 <PRE>
2586 unsigned
2587 cupsRasterWritePixels(cups_raster_t *ras,
2588                       unsigned char *pixels,
2589                       unsigned length);
2590 </PRE>
2591
2592 <H3>Arguments</H3>
2593
2594 <CENTER><TABLE WIDTH="80%" BORDER>
2595 <TR>
2596         <TH>Argument</TH>
2597         <TH>Description</TH>
2598 </TR>
2599 <TR>
2600         <TD>ras</TD>
2601         <TD>The raster stream to write to.</TD>
2602 </TR>
2603 <TR>
2604         <TD>pixels</TD>
2605         <TD>The pixel data to write.</TD>
2606 </TR>
2607 <TR>
2608         <TD>length</TD>
2609         <TD>The number of bytes to write.</TD>
2610 </TR>
2611 </TABLE></CENTER>
2612
2613 <H3>Returns</H3>
2614
2615 <P>The number of bytes written.
2616
2617 <H3>Description</H3>
2618
2619 <P><CODE>cupsRasterWritePixels()</CODE> writes the specified pixel data to a
2620 raster stream.
2621
2622 <H3>Example</H3>
2623
2624 <PRE>
2625 #include &lt;cups/raster.h&gt;
2626
2627 int                  line;
2628 cups_raster_t        *ras;
2629 cups_raster_header_t header;
2630 unsigned char        pixels[8192];
2631 ...
2632
2633 cupsRasterWriteHeader(ras, &amp;header);
2634
2635 for (line = 0; line &lt; header.cupsHeight; line ++)
2636 {
2637   ...
2638
2639   cupsRasterWritePixels(ras, pixels, header.cupsBytesPerLine);
2640 }
2641 </PRE>
2642
2643 <H3>See Also</H3>
2644
2645 <P>
2646 <A HREF="#cupsRasterClose">cupsRasterClose()</A>,
2647 <A HREF="#cupsRasterOpen">cupsRasterOpen()</A>,
2648 <A HREF="#cupsRasterReadHeader">cupsRasterReadHeader()</A>,
2649 <A HREF="#cupsRasterReadPixels">cupsRasterReadPixels()</A>,
2650 <A HREF="#cupsRasterWriteHeader">cupsRasterWriteHeader()</A>
2651
2652 <!-- NEW PAGE --><H2><A NAME="cupsServer">cupsServer()</A></H2>
2653
2654 <H3>Usage</H3>
2655
2656 <PRE>
2657 const char *
2658 cupsServer(void);
2659 </PRE>
2660
2661 <H3>Returns</H3>
2662
2663 <P>A pointer to the default server name.
2664
2665 <H3>Description</H3>
2666
2667 <P><CODE>cupsServer()</CODE> returns a pointer to the default server name.
2668 The server name is stored in a static location and will be overwritten with
2669 every call to <CODE>cupsServer()</CODE>
2670
2671 <P>The default server is determined from the following locations:
2672
2673 <OL>
2674
2675         <LI>The <CODE>CUPS_SERVER</CODE> environment variable,
2676
2677         <LI>The <CODE>ServerName</CODE> directive in the
2678         <VAR>cupsd.conf</VAR> file,
2679
2680         <LI>The default host, "localhost".
2681
2682 </OL>
2683
2684 <H3>Example</H3>
2685
2686 <PRE>
2687 #include &lt;cups/cups.h&gt;
2688
2689 const char *server;
2690
2691 server = cupsServer();
2692 </PRE>
2693
2694 <H3>See Also</H3>
2695
2696 <P>
2697 <A HREF="#cupsGetPassword">cupsGetPassword()</A>,
2698 <A HREF="#cupsUser">cupsUser()</A>
2699
2700 <!-- NEW PAGE --><H2><A NAME="cupsTempFile">cupsTempFile()</A></H2>
2701
2702 <H3>Usage</H3>
2703
2704 <PRE>
2705 char *
2706 cupsTempFile(char *filename,
2707              int length);
2708 </PRE>
2709
2710 <H3>Arguments</H3>
2711
2712 <CENTER><TABLE WIDTH="80%" BORDER>
2713 <TR>
2714         <TH>Argument</TH>
2715         <TH>Description</TH>
2716 </TR>
2717 <TR>
2718         <TD>filename</TD>
2719         <TD>The character string to hold the temporary filename.</TD>
2720 </TR>
2721 <TR>
2722         <TD>length</TD>
2723         <TD>The size of the filename string in bytes.</TD>
2724 </TR>
2725 </TABLE></CENTER>
2726
2727 <H3>Returns</H3>
2728
2729 <P>A pointer to <CODE>filename</CODE>.
2730
2731 <H3>Description</H3>
2732
2733 <P><CODE>cupsTempFile()</CODE> generates a temporary filename for the
2734 <VAR>/var/tmp</VAR> directory or the directory specified by the
2735 <CODE>TMPDIR</CODE> environment variable.
2736
2737 <H3>Example</H3>
2738
2739 <PRE>
2740 #include &lt;cups/cups.h&gt;
2741
2742 char filename[256];
2743
2744 cupsTempFile(filename, sizeof(filename));
2745 </PRE>
2746
2747 <!-- NEW PAGE --><H2><A NAME="cupsUser">cupsUser()</A></H2>
2748
2749 <H3>Usage</H3>
2750
2751 <PRE>
2752 const char *
2753 cupsUser(void);
2754 </PRE>
2755
2756 <H3>Returns</H3>
2757
2758 <P>A pointer to the current username or <CODE>NULL</CODE> if the user ID is
2759 undefined.
2760
2761 <H3>Description</H3>
2762
2763 <P><CODE>cupsUser()</CODE> returns the name associated with the current
2764 user ID as reported by the <CODE>getuid()</CODE> system call.
2765
2766 <H3>Example</H3>
2767
2768 <PRE>
2769 #include &lt;cups/cups.h&gt;
2770
2771 const char *user;
2772
2773 user = cupsUser();
2774 </PRE>
2775
2776 <H3>See Also</H3>
2777
2778 <P>
2779 <A HREF="#cupsGetPassword">cupsGetPassword()</A>,
2780 <A HREF="#cupsServer">cupsServer()</A>
2781
2782 <!-- NEW PAGE --><H2><A NAME="httpBlocking">httpBlocking()</A></H2>
2783
2784 <H3>Usage</H3>
2785
2786 <PRE>
2787 </PRE>
2788
2789 <H3>Arguments</H3>
2790
2791 <CENTER><TABLE WIDTH="80%" BORDER>
2792 <TR>
2793         <TH>Argument</TH>
2794         <TH>Description</TH>
2795 </TR>
2796 <TR>
2797         <TD></TD>
2798         <TD></TD>
2799 </TR>
2800 </TABLE></CENTER>
2801
2802 <H3>Returns</H3>
2803
2804 <H3>Description</H3>
2805
2806 <H3>Example</H3>
2807
2808 <PRE>
2809 </PRE>
2810
2811 <H3>See Also</H3>
2812
2813
2814 <!-- NEW PAGE --><H2><A NAME="httpCheck">httpCheck()</A></H2>
2815
2816 <H3>Usage</H3>
2817
2818 <PRE>
2819 </PRE>
2820
2821 <H3>Arguments</H3>
2822
2823 <CENTER><TABLE WIDTH="80%" BORDER>
2824 <TR>
2825         <TH>Argument</TH>
2826         <TH>Description</TH>
2827 </TR>
2828 <TR>
2829         <TD></TD>
2830         <TD></TD>
2831 </TR>
2832 </TABLE></CENTER>
2833
2834 <H3>Returns</H3>
2835
2836 <H3>Description</H3>
2837
2838 <H3>Example</H3>
2839
2840 <PRE>
2841 </PRE>
2842
2843 <H3>See Also</H3>
2844
2845
2846 <!-- NEW PAGE --><H2><A NAME="httpClearFields">httpClearFields()</A></H2>
2847
2848 <H3>Usage</H3>
2849
2850 <PRE>
2851 </PRE>
2852
2853 <H3>Arguments</H3>
2854
2855 <CENTER><TABLE WIDTH="80%" BORDER>
2856 <TR>
2857         <TH>Argument</TH>
2858         <TH>Description</TH>
2859 </TR>
2860 <TR>
2861         <TD></TD>
2862         <TD></TD>
2863 </TR>
2864 </TABLE></CENTER>
2865
2866 <H3>Returns</H3>
2867
2868 <H3>Description</H3>
2869
2870 <H3>Example</H3>
2871
2872 <PRE>
2873 </PRE>
2874
2875 <H3>See Also</H3>
2876
2877
2878 <!-- NEW PAGE --><H2><A NAME="httpClose">httpClose()</A></H2>
2879
2880 <H3>Usage</H3>
2881
2882 <PRE>
2883 </PRE>
2884
2885 <H3>Arguments</H3>
2886
2887 <CENTER><TABLE WIDTH="80%" BORDER>
2888 <TR>
2889         <TH>Argument</TH>
2890         <TH>Description</TH>
2891 </TR>
2892 <TR>
2893         <TD></TD>
2894         <TD></TD>
2895 </TR>
2896 </TABLE></CENTER>
2897
2898 <H3>Returns</H3>
2899
2900 <H3>Description</H3>
2901
2902 <H3>Example</H3>
2903
2904 <PRE>
2905 </PRE>
2906
2907 <H3>See Also</H3>
2908
2909
2910 <!-- NEW PAGE --><H2><A NAME="httpConnect">httpConnect()</A></H2>
2911
2912 <H3>Usage</H3>
2913
2914 <PRE>
2915 </PRE>
2916
2917 <H3>Arguments</H3>
2918
2919 <CENTER><TABLE WIDTH="80%" BORDER>
2920 <TR>
2921         <TH>Argument</TH>
2922         <TH>Description</TH>
2923 </TR>
2924 <TR>
2925         <TD></TD>
2926         <TD></TD>
2927 </TR>
2928 </TABLE></CENTER>
2929
2930 <H3>Returns</H3>
2931
2932 <H3>Description</H3>
2933
2934 <H3>Example</H3>
2935
2936 <PRE>
2937 </PRE>
2938
2939 <H3>See Also</H3>
2940
2941
2942 <!-- NEW PAGE --><H2><A NAME="httpDecode64">httpDecode64()</A></H2>
2943
2944 <H3>Usage</H3>
2945
2946 <PRE>
2947 </PRE>
2948
2949 <H3>Arguments</H3>
2950
2951 <CENTER><TABLE WIDTH="80%" BORDER>
2952 <TR>
2953         <TH>Argument</TH>
2954         <TH>Description</TH>
2955 </TR>
2956 <TR>
2957         <TD></TD>
2958         <TD></TD>
2959 </TR>
2960 </TABLE></CENTER>
2961
2962 <H3>Returns</H3>
2963
2964 <H3>Description</H3>
2965
2966 <H3>Example</H3>
2967
2968 <PRE>
2969 </PRE>
2970
2971 <H3>See Also</H3>
2972
2973
2974 <!-- NEW PAGE --><H2><A NAME="httpDelete">httpDelete()</A></H2>
2975
2976 <H3>Usage</H3>
2977
2978 <PRE>
2979 </PRE>
2980
2981 <H3>Arguments</H3>
2982
2983 <CENTER><TABLE WIDTH="80%" BORDER>
2984 <TR>
2985         <TH>Argument</TH>
2986         <TH>Description</TH>
2987 </TR>
2988 <TR>
2989         <TD></TD>
2990         <TD></TD>
2991 </TR>
2992 </TABLE></CENTER>
2993
2994 <H3>Returns</H3>
2995
2996 <H3>Description</H3>
2997
2998 <H3>Example</H3>
2999
3000 <PRE>
3001 </PRE>
3002
3003 <H3>See Also</H3>
3004
3005
3006 <!-- NEW PAGE --><H2><A NAME="httpEncode64">httpEncode64()</A></H2>
3007
3008 <H3>Usage</H3>
3009
3010 <PRE>
3011 </PRE>
3012
3013 <H3>Arguments</H3>
3014
3015 <CENTER><TABLE WIDTH="80%" BORDER>
3016 <TR>
3017         <TH>Argument</TH>
3018         <TH>Description</TH>
3019 </TR>
3020 <TR>
3021         <TD></TD>
3022         <TD></TD>
3023 </TR>
3024 </TABLE></CENTER>
3025
3026 <H3>Returns</H3>
3027
3028 <H3>Description</H3>
3029
3030 <H3>Example</H3>
3031
3032 <PRE>
3033 </PRE>
3034
3035 <H3>See Also</H3>
3036
3037
3038 <!-- NEW PAGE --><H2><A NAME="httpError">httpError()</A></H2>
3039
3040 <H3>Usage</H3>
3041
3042 <PRE>
3043 </PRE>
3044
3045 <H3>Arguments</H3>
3046
3047 <CENTER><TABLE WIDTH="80%" BORDER>
3048 <TR>
3049         <TH>Argument</TH>
3050         <TH>Description</TH>
3051 </TR>
3052 <TR>
3053         <TD></TD>
3054         <TD></TD>
3055 </TR>
3056 </TABLE></CENTER>
3057
3058 <H3>Returns</H3>
3059
3060 <H3>Description</H3>
3061
3062 <H3>Example</H3>
3063
3064 <PRE>
3065 </PRE>
3066
3067 <H3>See Also</H3>
3068
3069
3070 <!-- NEW PAGE --><H2><A NAME="httpFlush">httpFlush()</A></H2>
3071
3072 <H3>Usage</H3>
3073
3074 <PRE>
3075 </PRE>
3076
3077 <H3>Arguments</H3>
3078
3079 <CENTER><TABLE WIDTH="80%" BORDER>
3080 <TR>
3081         <TH>Argument</TH>
3082         <TH>Description</TH>
3083 </TR>
3084 <TR>
3085         <TD></TD>
3086         <TD></TD>
3087 </TR>
3088 </TABLE></CENTER>
3089
3090 <H3>Returns</H3>
3091
3092 <H3>Description</H3>
3093
3094 <H3>Example</H3>
3095
3096 <PRE>
3097 </PRE>
3098
3099 <H3>See Also</H3>
3100
3101
3102 <!-- NEW PAGE --><H2><A NAME="httpGet">httpGet()</A></H2>
3103
3104 <H3>Usage</H3>
3105
3106 <PRE>
3107 </PRE>
3108
3109 <H3>Arguments</H3>
3110
3111 <CENTER><TABLE WIDTH="80%" BORDER>
3112 <TR>
3113         <TH>Argument</TH>
3114         <TH>Description</TH>
3115 </TR>
3116 <TR>
3117         <TD></TD>
3118         <TD></TD>
3119 </TR>
3120 </TABLE></CENTER>
3121
3122 <H3>Returns</H3>
3123
3124 <H3>Description</H3>
3125
3126 <H3>Example</H3>
3127
3128 <PRE>
3129 </PRE>
3130
3131 <H3>See Also</H3>
3132
3133
3134 <!-- NEW PAGE --><H2><A NAME="httpGets">httpGets()</A></H2>
3135
3136 <H3>Usage</H3>
3137
3138 <PRE>
3139 </PRE>
3140
3141 <H3>Arguments</H3>
3142
3143 <CENTER><TABLE WIDTH="80%" BORDER>
3144 <TR>
3145         <TH>Argument</TH>
3146         <TH>Description</TH>
3147 </TR>
3148 <TR>
3149         <TD></TD>
3150         <TD></TD>
3151 </TR>
3152 </TABLE></CENTER>
3153
3154 <H3>Returns</H3>
3155
3156 <H3>Description</H3>
3157
3158 <H3>Example</H3>
3159
3160 <PRE>
3161 </PRE>
3162
3163 <H3>See Also</H3>
3164
3165
3166 <!-- NEW PAGE --><H2><A NAME="httpGetDateString">httpGetDateString()</A></H2>
3167
3168 <H3>Usage</H3>
3169
3170 <PRE>
3171 </PRE>
3172
3173 <H3>Arguments</H3>
3174
3175 <CENTER><TABLE WIDTH="80%" BORDER>
3176 <TR>
3177         <TH>Argument</TH>
3178         <TH>Description</TH>
3179 </TR>
3180 <TR>
3181         <TD></TD>
3182         <TD></TD>
3183 </TR>
3184 </TABLE></CENTER>
3185
3186 <H3>Returns</H3>
3187
3188 <H3>Description</H3>
3189
3190 <H3>Example</H3>
3191
3192 <PRE>
3193 </PRE>
3194
3195 <H3>See Also</H3>
3196
3197
3198 <!-- NEW PAGE --><H2><A NAME="httpGetDateTime">httpGetDateTime()</A></H2>
3199
3200 <H3>Usage</H3>
3201
3202 <PRE>
3203 </PRE>
3204
3205 <H3>Arguments</H3>
3206
3207 <CENTER><TABLE WIDTH="80%" BORDER>
3208 <TR>
3209         <TH>Argument</TH>
3210         <TH>Description</TH>
3211 </TR>
3212 <TR>
3213         <TD></TD>
3214         <TD></TD>
3215 </TR>
3216 </TABLE></CENTER>
3217
3218 <H3>Returns</H3>
3219
3220 <H3>Description</H3>
3221
3222 <H3>Example</H3>
3223
3224 <PRE>
3225 </PRE>
3226
3227 <H3>See Also</H3>
3228
3229
3230 <!-- NEW PAGE --><H2><A NAME="httpGetField">httpGetField()</A></H2>
3231
3232 <H3>Usage</H3>
3233
3234 <PRE>
3235 </PRE>
3236
3237 <H3>Arguments</H3>
3238
3239 <CENTER><TABLE WIDTH="80%" BORDER>
3240 <TR>
3241         <TH>Argument</TH>
3242         <TH>Description</TH>
3243 </TR>
3244 <TR>
3245         <TD></TD>
3246         <TD></TD>
3247 </TR>
3248 </TABLE></CENTER>
3249
3250 <H3>Returns</H3>
3251
3252 <H3>Description</H3>
3253
3254 <H3>Example</H3>
3255
3256 <PRE>
3257 </PRE>
3258
3259 <H3>See Also</H3>
3260
3261
3262 <!-- NEW PAGE --><H2><A NAME="httpGetLength">httpGetLength()</A></H2>
3263
3264 <H3>Usage</H3>
3265
3266 <PRE>
3267 </PRE>
3268
3269 <H3>Arguments</H3>
3270
3271 <CENTER><TABLE WIDTH="80%" BORDER>
3272 <TR>
3273         <TH>Argument</TH>
3274         <TH>Description</TH>
3275 </TR>
3276 <TR>
3277         <TD></TD>
3278         <TD></TD>
3279 </TR>
3280 </TABLE></CENTER>
3281
3282 <H3>Returns</H3>
3283
3284 <H3>Description</H3>
3285
3286 <H3>Example</H3>
3287
3288 <PRE>
3289 </PRE>
3290
3291 <H3>See Also</H3>
3292
3293
3294 <!-- NEW PAGE --><H2><A NAME="httpHead">httpHead()</A></H2>
3295
3296 <H3>Usage</H3>
3297
3298 <PRE>
3299 </PRE>
3300
3301 <H3>Arguments</H3>
3302
3303 <CENTER><TABLE WIDTH="80%" BORDER>
3304 <TR>
3305         <TH>Argument</TH>
3306         <TH>Description</TH>
3307 </TR>
3308 <TR>
3309         <TD></TD>
3310         <TD></TD>
3311 </TR>
3312 </TABLE></CENTER>
3313
3314 <H3>Returns</H3>
3315
3316 <H3>Description</H3>
3317
3318 <H3>Example</H3>
3319
3320 <PRE>
3321 </PRE>
3322
3323 <H3>See Also</H3>
3324
3325
3326 <!-- NEW PAGE --><H2><A NAME="httpInitialize">httpInitialize()</A></H2>
3327
3328 <H3>Usage</H3>
3329
3330 <PRE>
3331 </PRE>
3332
3333 <H3>Arguments</H3>
3334
3335 <CENTER><TABLE WIDTH="80%" BORDER>
3336 <TR>
3337         <TH>Argument</TH>
3338         <TH>Description</TH>
3339 </TR>
3340 <TR>
3341         <TD></TD>
3342         <TD></TD>
3343 </TR>
3344 </TABLE></CENTER>
3345
3346 <H3>Returns</H3>
3347
3348 <H3>Description</H3>
3349
3350 <H3>Example</H3>
3351
3352 <PRE>
3353 </PRE>
3354
3355 <H3>See Also</H3>
3356
3357
3358 <!-- NEW PAGE --><H2><A NAME="httpOptions">httpOptions()</A></H2>
3359
3360 <H3>Usage</H3>
3361
3362 <PRE>
3363 </PRE>
3364
3365 <H3>Arguments</H3>
3366
3367 <CENTER><TABLE WIDTH="80%" BORDER>
3368 <TR>
3369         <TH>Argument</TH>
3370         <TH>Description</TH>
3371 </TR>
3372 <TR>
3373         <TD></TD>
3374         <TD></TD>
3375 </TR>
3376 </TABLE></CENTER>
3377
3378 <H3>Returns</H3>
3379
3380 <H3>Description</H3>
3381
3382 <H3>Example</H3>
3383
3384 <PRE>
3385 </PRE>
3386
3387 <H3>See Also</H3>
3388
3389
3390 <!-- NEW PAGE --><H2><A NAME="httpPost">httpPost()</A></H2>
3391
3392 <H3>Usage</H3>
3393
3394 <PRE>
3395 </PRE>
3396
3397 <H3>Arguments</H3>
3398
3399 <CENTER><TABLE WIDTH="80%" BORDER>
3400 <TR>
3401         <TH>Argument</TH>
3402         <TH>Description</TH>
3403 </TR>
3404 <TR>
3405         <TD></TD>
3406         <TD></TD>
3407 </TR>
3408 </TABLE></CENTER>
3409
3410 <H3>Returns</H3>
3411
3412 <H3>Description</H3>
3413
3414 <H3>Example</H3>
3415
3416 <PRE>
3417 </PRE>
3418
3419 <H3>See Also</H3>
3420
3421
3422 <!-- NEW PAGE --><H2><A NAME="httpPrintf">httpPrintf()</A></H2>
3423
3424 <H3>Usage</H3>
3425
3426 <PRE>
3427 </PRE>
3428
3429 <H3>Arguments</H3>
3430
3431 <CENTER><TABLE WIDTH="80%" BORDER>
3432 <TR>
3433         <TH>Argument</TH>
3434         <TH>Description</TH>
3435 </TR>
3436 <TR>
3437         <TD></TD>
3438         <TD></TD>
3439 </TR>
3440 </TABLE></CENTER>
3441
3442 <H3>Returns</H3>
3443
3444 <H3>Description</H3>
3445
3446 <H3>Example</H3>
3447
3448 <PRE>
3449 </PRE>
3450
3451 <H3>See Also</H3>
3452
3453
3454 <!-- NEW PAGE --><H2><A NAME="httpPut">httpPut()</A></H2>
3455
3456 <H3>Usage</H3>
3457
3458 <PRE>
3459 </PRE>
3460
3461 <H3>Arguments</H3>
3462
3463 <CENTER><TABLE WIDTH="80%" BORDER>
3464 <TR>
3465         <TH>Argument</TH>
3466         <TH>Description</TH>
3467 </TR>
3468 <TR>
3469         <TD></TD>
3470         <TD></TD>
3471 </TR>
3472 </TABLE></CENTER>
3473
3474 <H3>Returns</H3>
3475
3476 <H3>Description</H3>
3477
3478 <H3>Example</H3>
3479
3480 <PRE>
3481 </PRE>
3482
3483 <H3>See Also</H3>
3484
3485
3486 <!-- NEW PAGE --><H2><A NAME="httpRead">httpRead()</A></H2>
3487
3488 <H3>Usage</H3>
3489
3490 <PRE>
3491 </PRE>
3492
3493 <H3>Arguments</H3>
3494
3495 <CENTER><TABLE WIDTH="80%" BORDER>
3496 <TR>
3497         <TH>Argument</TH>
3498         <TH>Description</TH>
3499 </TR>
3500 <TR>
3501         <TD></TD>
3502         <TD></TD>
3503 </TR>
3504 </TABLE></CENTER>
3505
3506 <H3>Returns</H3>
3507
3508 <H3>Description</H3>
3509
3510 <H3>Example</H3>
3511
3512 <PRE>
3513 </PRE>
3514
3515 <H3>See Also</H3>
3516
3517
3518 <!-- NEW PAGE --><H2><A NAME="httpReconnect">httpReconnect()</A></H2>
3519
3520 <H3>Usage</H3>
3521
3522 <PRE>
3523 </PRE>
3524
3525 <H3>Arguments</H3>
3526
3527 <CENTER><TABLE WIDTH="80%" BORDER>
3528 <TR>
3529         <TH>Argument</TH>
3530         <TH>Description</TH>
3531 </TR>
3532 <TR>
3533         <TD></TD>
3534         <TD></TD>
3535 </TR>
3536 </TABLE></CENTER>
3537
3538 <H3>Returns</H3>
3539
3540 <H3>Description</H3>
3541
3542 <H3>Example</H3>
3543
3544 <PRE>
3545 </PRE>
3546
3547 <H3>See Also</H3>
3548
3549
3550 <!-- NEW PAGE --><H2><A NAME="httpSeparate">httpSeparate()</A></H2>
3551
3552 <H3>Usage</H3>
3553
3554 <PRE>
3555 </PRE>
3556
3557 <H3>Arguments</H3>
3558
3559 <CENTER><TABLE WIDTH="80%" BORDER>
3560 <TR>
3561         <TH>Argument</TH>
3562         <TH>Description</TH>
3563 </TR>
3564 <TR>
3565         <TD></TD>
3566         <TD></TD>
3567 </TR>
3568 </TABLE></CENTER>
3569
3570 <H3>Returns</H3>
3571
3572 <H3>Description</H3>
3573
3574 <H3>Example</H3>
3575
3576 <PRE>
3577 </PRE>
3578
3579 <H3>See Also</H3>
3580
3581
3582 <!-- NEW PAGE --><H2><A NAME="httpSetField">httpSetField()</A></H2>
3583
3584 <H3>Usage</H3>
3585
3586 <PRE>
3587 </PRE>
3588
3589 <H3>Arguments</H3>
3590
3591 <CENTER><TABLE WIDTH="80%" BORDER>
3592 <TR>
3593         <TH>Argument</TH>
3594         <TH>Description</TH>
3595 </TR>
3596 <TR>
3597         <TD></TD>
3598         <TD></TD>
3599 </TR>
3600 </TABLE></CENTER>
3601
3602 <H3>Returns</H3>
3603
3604 <H3>Description</H3>
3605
3606 <H3>Example</H3>
3607
3608 <PRE>
3609 </PRE>
3610
3611 <H3>See Also</H3>
3612
3613
3614 <!-- NEW PAGE --><H2><A NAME="httpTrace">httpTrace()</A></H2>
3615
3616 <H3>Usage</H3>
3617
3618 <PRE>
3619 </PRE>
3620
3621 <H3>Arguments</H3>
3622
3623 <CENTER><TABLE WIDTH="80%" BORDER>
3624 <TR>
3625         <TH>Argument</TH>
3626         <TH>Description</TH>
3627 </TR>
3628 <TR>
3629         <TD></TD>
3630         <TD></TD>
3631 </TR>
3632 </TABLE></CENTER>
3633
3634 <H3>Returns</H3>
3635
3636 <H3>Description</H3>
3637
3638 <H3>Example</H3>
3639
3640 <PRE>
3641 </PRE>
3642
3643 <H3>See Also</H3>
3644
3645
3646 <!-- NEW PAGE --><H2><A NAME="httpUpdate">httpUpdate()</A></H2>
3647
3648 <H3>Usage</H3>
3649
3650 <PRE>
3651 </PRE>
3652
3653 <H3>Arguments</H3>
3654
3655 <CENTER><TABLE WIDTH="80%" BORDER>
3656 <TR>
3657         <TH>Argument</TH>
3658         <TH>Description</TH>
3659 </TR>
3660 <TR>
3661         <TD></TD>
3662         <TD></TD>
3663 </TR>
3664 </TABLE></CENTER>
3665
3666 <H3>Returns</H3>
3667
3668 <H3>Description</H3>
3669
3670 <H3>Example</H3>
3671
3672 <PRE>
3673 </PRE>
3674
3675 <H3>See Also</H3>
3676
3677
3678 <!-- NEW PAGE --><H2><A NAME="httpWrite">httpWrite()</A></H2>
3679
3680 <H3>Usage</H3>
3681
3682 <PRE>
3683 </PRE>
3684
3685 <H3>Arguments</H3>
3686
3687 <CENTER><TABLE WIDTH="80%" BORDER>
3688 <TR>
3689         <TH>Argument</TH>
3690         <TH>Description</TH>
3691 </TR>
3692 <TR>
3693         <TD></TD>
3694         <TD></TD>
3695 </TR>
3696 </TABLE></CENTER>
3697
3698 <H3>Returns</H3>
3699
3700 <H3>Description</H3>
3701
3702 <H3>Example</H3>
3703
3704 <PRE>
3705 </PRE>
3706
3707 <H3>See Also</H3>
3708
3709
3710 <!-- NEW PAGE --><H2><A NAME="ippAddBoolean">ippAddBoolean()</A></H2>
3711
3712 <H3>Usage</H3>
3713
3714 <PRE>
3715 </PRE>
3716
3717 <H3>Arguments</H3>
3718
3719 <CENTER><TABLE WIDTH="80%" BORDER>
3720 <TR>
3721         <TH>Argument</TH>
3722         <TH>Description</TH>
3723 </TR>
3724 <TR>
3725         <TD></TD>
3726         <TD></TD>
3727 </TR>
3728 </TABLE></CENTER>
3729
3730 <H3>Returns</H3>
3731
3732 <H3>Description</H3>
3733
3734 <H3>Example</H3>
3735
3736 <PRE>
3737 </PRE>
3738
3739 <H3>See Also</H3>
3740
3741
3742 <!-- NEW PAGE --><H2><A NAME="ippAddBooleans">ippAddBooleans()</A></H2>
3743
3744 <H3>Usage</H3>
3745
3746 <PRE>
3747 </PRE>
3748
3749 <H3>Arguments</H3>
3750
3751 <CENTER><TABLE WIDTH="80%" BORDER>
3752 <TR>
3753         <TH>Argument</TH>
3754         <TH>Description</TH>
3755 </TR>
3756 <TR>
3757         <TD></TD>
3758         <TD></TD>
3759 </TR>
3760 </TABLE></CENTER>
3761
3762 <H3>Returns</H3>
3763
3764 <H3>Description</H3>
3765
3766 <H3>Example</H3>
3767
3768 <PRE>
3769 </PRE>
3770
3771 <H3>See Also</H3>
3772
3773
3774 <!-- NEW PAGE --><H2><A NAME="ippAddDate">ippAddDate()</A></H2>
3775
3776 <H3>Usage</H3>
3777
3778 <PRE>
3779 </PRE>
3780
3781 <H3>Arguments</H3>
3782
3783 <CENTER><TABLE WIDTH="80%" BORDER>
3784 <TR>
3785         <TH>Argument</TH>
3786         <TH>Description</TH>
3787 </TR>
3788 <TR>
3789         <TD></TD>
3790         <TD></TD>
3791 </TR>
3792 </TABLE></CENTER>
3793
3794 <H3>Returns</H3>
3795
3796 <H3>Description</H3>
3797
3798 <H3>Example</H3>
3799
3800 <PRE>
3801 </PRE>
3802
3803 <H3>See Also</H3>
3804
3805
3806 <!-- NEW PAGE --><H2><A NAME="ippAddInteger">ippAddInteger()</A></H2>
3807
3808 <H3>Usage</H3>
3809
3810 <PRE>
3811 </PRE>
3812
3813 <H3>Arguments</H3>
3814
3815 <CENTER><TABLE WIDTH="80%" BORDER>
3816 <TR>
3817         <TH>Argument</TH>
3818         <TH>Description</TH>
3819 </TR>
3820 <TR>
3821         <TD></TD>
3822         <TD></TD>
3823 </TR>
3824 </TABLE></CENTER>
3825
3826 <H3>Returns</H3>
3827
3828 <H3>Description</H3>
3829
3830 <H3>Example</H3>
3831
3832 <PRE>
3833 </PRE>
3834
3835 <H3>See Also</H3>
3836
3837
3838 <!-- NEW PAGE --><H2><A NAME="ippAddIntegers">ippAddIntegers()</A></H2>
3839
3840 <H3>Usage</H3>
3841
3842 <PRE>
3843 </PRE>
3844
3845 <H3>Arguments</H3>
3846
3847 <CENTER><TABLE WIDTH="80%" BORDER>
3848 <TR>
3849         <TH>Argument</TH>
3850         <TH>Description</TH>
3851 </TR>
3852 <TR>
3853         <TD></TD>
3854         <TD></TD>
3855 </TR>
3856 </TABLE></CENTER>
3857
3858 <H3>Returns</H3>
3859
3860 <H3>Description</H3>
3861
3862 <H3>Example</H3>
3863
3864 <PRE>
3865 </PRE>
3866
3867 <H3>See Also</H3>
3868
3869
3870 <!-- NEW PAGE --><H2><A NAME="ippAddRange">ippAddRange()</A></H2>
3871
3872 <H3>Usage</H3>
3873
3874 <PRE>
3875 </PRE>
3876
3877 <H3>Arguments</H3>
3878
3879 <CENTER><TABLE WIDTH="80%" BORDER>
3880 <TR>
3881         <TH>Argument</TH>
3882         <TH>Description</TH>
3883 </TR>
3884 <TR>
3885         <TD></TD>
3886         <TD></TD>
3887 </TR>
3888 </TABLE></CENTER>
3889
3890 <H3>Returns</H3>
3891
3892 <H3>Description</H3>
3893
3894 <H3>Example</H3>
3895
3896 <PRE>
3897 </PRE>
3898
3899 <H3>See Also</H3>
3900
3901
3902 <!-- NEW PAGE --><H2><A NAME="ippAddRanges">ippAddRanges()</A></H2>
3903
3904 <H3>Usage</H3>
3905
3906 <PRE>
3907 </PRE>
3908
3909 <H3>Arguments</H3>
3910
3911 <CENTER><TABLE WIDTH="80%" BORDER>
3912 <TR>
3913         <TH>Argument</TH>
3914         <TH>Description</TH>
3915 </TR>
3916 <TR>
3917         <TD></TD>
3918         <TD></TD>
3919 </TR>
3920 </TABLE></CENTER>
3921
3922 <H3>Returns</H3>
3923
3924 <H3>Description</H3>
3925
3926 <H3>Example</H3>
3927
3928 <PRE>
3929 </PRE>
3930
3931 <H3>See Also</H3>
3932
3933
3934 <!-- NEW PAGE --><H2><A NAME="ippAddResolution">ippAddResolution()</A></H2>
3935
3936 <H3>Usage</H3>
3937
3938 <PRE>
3939 </PRE>
3940
3941 <H3>Arguments</H3>
3942
3943 <CENTER><TABLE WIDTH="80%" BORDER>
3944 <TR>
3945         <TH>Argument</TH>
3946         <TH>Description</TH>
3947 </TR>
3948 <TR>
3949         <TD></TD>
3950         <TD></TD>
3951 </TR>
3952 </TABLE></CENTER>
3953
3954 <H3>Returns</H3>
3955
3956 <H3>Description</H3>
3957
3958 <H3>Example</H3>
3959
3960 <PRE>
3961 </PRE>
3962
3963 <H3>See Also</H3>
3964
3965
3966 <!-- NEW PAGE --><H2><A NAME="ippAddResolutions">ippAddResolutions()</A></H2>
3967
3968 <H3>Usage</H3>
3969
3970 <PRE>
3971 </PRE>
3972
3973 <H3>Arguments</H3>
3974
3975 <CENTER><TABLE WIDTH="80%" BORDER>
3976 <TR>
3977         <TH>Argument</TH>
3978         <TH>Description</TH>
3979 </TR>
3980 <TR>
3981         <TD></TD>
3982         <TD></TD>
3983 </TR>
3984 </TABLE></CENTER>
3985
3986 <H3>Returns</H3>
3987
3988 <H3>Description</H3>
3989
3990 <H3>Example</H3>
3991
3992 <PRE>
3993 </PRE>
3994
3995 <H3>See Also</H3>
3996
3997
3998 <!-- NEW PAGE --><H2><A NAME="ippAddSeparator">ippAddSeparator()</A></H2>
3999
4000 <H3>Usage</H3>
4001
4002 <PRE>
4003 </PRE>
4004
4005 <H3>Arguments</H3>
4006
4007 <CENTER><TABLE WIDTH="80%" BORDER>
4008 <TR>
4009         <TH>Argument</TH>
4010         <TH>Description</TH>
4011 </TR>
4012 <TR>
4013         <TD></TD>
4014         <TD></TD>
4015 </TR>
4016 </TABLE></CENTER>
4017
4018 <H3>Returns</H3>
4019
4020 <H3>Description</H3>
4021
4022 <H3>Example</H3>
4023
4024 <PRE>
4025 </PRE>
4026
4027 <H3>See Also</H3>
4028
4029
4030 <!-- NEW PAGE --><H2><A NAME="ippAddString">ippAddString()</A></H2>
4031
4032 <H3>Usage</H3>
4033
4034 <PRE>
4035 </PRE>
4036
4037 <H3>Arguments</H3>
4038
4039 <CENTER><TABLE WIDTH="80%" BORDER>
4040 <TR>
4041         <TH>Argument</TH>
4042         <TH>Description</TH>
4043 </TR>
4044 <TR>
4045         <TD></TD>
4046         <TD></TD>
4047 </TR>
4048 </TABLE></CENTER>
4049
4050 <H3>Returns</H3>
4051
4052 <H3>Description</H3>
4053
4054 <H3>Example</H3>
4055
4056 <PRE>
4057 </PRE>
4058
4059 <H3>See Also</H3>
4060
4061
4062 <!-- NEW PAGE --><H2><A NAME="ippAddStrings">ippAddStrings()</A></H2>
4063
4064 <H3>Usage</H3>
4065
4066 <PRE>
4067 </PRE>
4068
4069 <H3>Arguments</H3>
4070
4071 <CENTER><TABLE WIDTH="80%" BORDER>
4072 <TR>
4073         <TH>Argument</TH>
4074         <TH>Description</TH>
4075 </TR>
4076 <TR>
4077         <TD></TD>
4078         <TD></TD>
4079 </TR>
4080 </TABLE></CENTER>
4081
4082 <H3>Returns</H3>
4083
4084 <H3>Description</H3>
4085
4086 <H3>Example</H3>
4087
4088 <PRE>
4089 </PRE>
4090
4091 <H3>See Also</H3>
4092
4093
4094 <!-- NEW PAGE --><H2><A NAME="ippDateToTime">ippDateToTime()</A></H2>
4095
4096 <H3>Usage</H3>
4097
4098 <PRE>
4099 </PRE>
4100
4101 <H3>Arguments</H3>
4102
4103 <CENTER><TABLE WIDTH="80%" BORDER>
4104 <TR>
4105         <TH>Argument</TH>
4106         <TH>Description</TH>
4107 </TR>
4108 <TR>
4109         <TD></TD>
4110         <TD></TD>
4111 </TR>
4112 </TABLE></CENTER>
4113
4114 <H3>Returns</H3>
4115
4116 <H3>Description</H3>
4117
4118 <H3>Example</H3>
4119
4120 <PRE>
4121 </PRE>
4122
4123 <H3>See Also</H3>
4124
4125
4126 <!-- NEW PAGE --><H2><A NAME="ippDelete">ippDelete()</A></H2>
4127
4128 <H3>Usage</H3>
4129
4130 <PRE>
4131 </PRE>
4132
4133 <H3>Arguments</H3>
4134
4135 <CENTER><TABLE WIDTH="80%" BORDER>
4136 <TR>
4137         <TH>Argument</TH>
4138         <TH>Description</TH>
4139 </TR>
4140 <TR>
4141         <TD></TD>
4142         <TD></TD>
4143 </TR>
4144 </TABLE></CENTER>
4145
4146 <H3>Returns</H3>
4147
4148 <H3>Description</H3>
4149
4150 <H3>Example</H3>
4151
4152 <PRE>
4153 </PRE>
4154
4155 <H3>See Also</H3>
4156
4157
4158 <!-- NEW PAGE --><H2><A NAME="ippFindAttribute">ippFindAttribute()</A></H2>
4159
4160 <H3>Usage</H3>
4161
4162 <PRE>
4163 </PRE>
4164
4165 <H3>Arguments</H3>
4166
4167 <CENTER><TABLE WIDTH="80%" BORDER>
4168 <TR>
4169         <TH>Argument</TH>
4170         <TH>Description</TH>
4171 </TR>
4172 <TR>
4173         <TD></TD>
4174         <TD></TD>
4175 </TR>
4176 </TABLE></CENTER>
4177
4178 <H3>Returns</H3>
4179
4180 <H3>Description</H3>
4181
4182 <H3>Example</H3>
4183
4184 <PRE>
4185 </PRE>
4186
4187 <H3>See Also</H3>
4188
4189
4190 <!-- NEW PAGE --><H2><A NAME="ippLength">ippLength()</A></H2>
4191
4192 <H3>Usage</H3>
4193
4194 <PRE>
4195 </PRE>
4196
4197 <H3>Arguments</H3>
4198
4199 <CENTER><TABLE WIDTH="80%" BORDER>
4200 <TR>
4201         <TH>Argument</TH>
4202         <TH>Description</TH>
4203 </TR>
4204 <TR>
4205         <TD></TD>
4206         <TD></TD>
4207 </TR>
4208 </TABLE></CENTER>
4209
4210 <H3>Returns</H3>
4211
4212 <H3>Description</H3>
4213
4214 <H3>Example</H3>
4215
4216 <PRE>
4217 </PRE>
4218
4219 <H3>See Also</H3>
4220
4221
4222 <!-- NEW PAGE --><H2><A NAME="ippNew">ippNew()</A></H2>
4223
4224 <H3>Usage</H3>
4225
4226 <PRE>
4227 </PRE>
4228
4229 <H3>Arguments</H3>
4230
4231 <CENTER><TABLE WIDTH="80%" BORDER>
4232 <TR>
4233         <TH>Argument</TH>
4234         <TH>Description</TH>
4235 </TR>
4236 <TR>
4237         <TD></TD>
4238         <TD></TD>
4239 </TR>
4240 </TABLE></CENTER>
4241
4242 <H3>Returns</H3>
4243
4244 <H3>Description</H3>
4245
4246 <H3>Example</H3>
4247
4248 <PRE>
4249 </PRE>
4250
4251 <H3>See Also</H3>
4252
4253
4254 <!-- NEW PAGE --><H2><A NAME="ippPort">ippPort()</A></H2>
4255
4256 <H3>Usage</H3>
4257
4258 <PRE>
4259 </PRE>
4260
4261 <H3>Arguments</H3>
4262
4263 <CENTER><TABLE WIDTH="80%" BORDER>
4264 <TR>
4265         <TH>Argument</TH>
4266         <TH>Description</TH>
4267 </TR>
4268 <TR>
4269         <TD></TD>
4270         <TD></TD>
4271 </TR>
4272 </TABLE></CENTER>
4273
4274 <H3>Returns</H3>
4275
4276 <H3>Description</H3>
4277
4278 <H3>Example</H3>
4279
4280 <PRE>
4281 </PRE>
4282
4283 <H3>See Also</H3>
4284
4285
4286 <!-- NEW PAGE --><H2><A NAME="ippRead">ippRead()</A></H2>
4287
4288 <H3>Usage</H3>
4289
4290 <PRE>
4291 </PRE>
4292
4293 <H3>Arguments</H3>
4294
4295 <CENTER><TABLE WIDTH="80%" BORDER>
4296 <TR>
4297         <TH>Argument</TH>
4298         <TH>Description</TH>
4299 </TR>
4300 <TR>
4301         <TD></TD>
4302         <TD></TD>
4303 </TR>
4304 </TABLE></CENTER>
4305
4306 <H3>Returns</H3>
4307
4308 <H3>Description</H3>
4309
4310 <H3>Example</H3>
4311
4312 <PRE>
4313 </PRE>
4314
4315 <H3>See Also</H3>
4316
4317
4318 <!-- NEW PAGE --><H2><A NAME="ippTimeToDate">ippTimeToDate()</A></H2>
4319
4320 <H3>Usage</H3>
4321
4322 <PRE>
4323 </PRE>
4324
4325 <H3>Arguments</H3>
4326
4327 <CENTER><TABLE WIDTH="80%" BORDER>
4328 <TR>
4329         <TH>Argument</TH>
4330         <TH>Description</TH>
4331 </TR>
4332 <TR>
4333         <TD></TD>
4334         <TD></TD>
4335 </TR>
4336 </TABLE></CENTER>
4337
4338 <H3>Returns</H3>
4339
4340 <H3>Description</H3>
4341
4342 <H3>Example</H3>
4343
4344 <PRE>
4345 </PRE>
4346
4347 <H3>See Also</H3>
4348
4349
4350 <!-- NEW PAGE --><H2><A NAME="ippWrite">ippWrite()</A></H2>
4351
4352 <H3>Usage</H3>
4353
4354 <PRE>
4355 </PRE>
4356
4357 <H3>Arguments</H3>
4358
4359 <CENTER><TABLE WIDTH="80%" BORDER>
4360 <TR>
4361         <TH>Argument</TH>
4362         <TH>Description</TH>
4363 </TR>
4364 <TR>
4365         <TD></TD>
4366         <TD></TD>
4367 </TR>
4368 </TABLE></CENTER>
4369
4370 <H3>Returns</H3>
4371
4372 <H3>Description</H3>
4373
4374 <H3>Example</H3>
4375
4376 <PRE>
4377 </PRE>
4378
4379 <H3>See Also</H3>
4380
4381
4382 <!-- NEW PAGE --><H2><A NAME="ppdClose">ppdClose()</A></H2>
4383
4384 <H3>Usage</H3>
4385
4386 <PRE>
4387 </PRE>
4388
4389 <H3>Arguments</H3>
4390
4391 <CENTER><TABLE WIDTH="80%" BORDER>
4392 <TR>
4393         <TH>Argument</TH>
4394         <TH>Description</TH>
4395 </TR>
4396 <TR>
4397         <TD></TD>
4398         <TD></TD>
4399 </TR>
4400 </TABLE></CENTER>
4401
4402 <H3>Returns</H3>
4403
4404 <H3>Description</H3>
4405
4406 <H3>Example</H3>
4407
4408 <PRE>
4409 </PRE>
4410
4411 <H3>See Also</H3>
4412
4413
4414 <!-- NEW PAGE --><H2><A NAME="ppdConflicts">ppdConflicts()</A></H2>
4415
4416 <H3>Usage</H3>
4417
4418 <PRE>
4419 </PRE>
4420
4421 <H3>Arguments</H3>
4422
4423 <CENTER><TABLE WIDTH="80%" BORDER>
4424 <TR>
4425         <TH>Argument</TH>
4426         <TH>Description</TH>
4427 </TR>
4428 <TR>
4429         <TD></TD>
4430         <TD></TD>
4431 </TR>
4432 </TABLE></CENTER>
4433
4434 <H3>Returns</H3>
4435
4436 <H3>Description</H3>
4437
4438 <H3>Example</H3>
4439
4440 <PRE>
4441 </PRE>
4442
4443 <H3>See Also</H3>
4444
4445
4446 <!-- NEW PAGE --><H2><A NAME="pddEmitFd">pddEmitFd()</A></H2>
4447
4448 <H3>Usage</H3>
4449
4450 <PRE>
4451 </PRE>
4452
4453 <H3>Arguments</H3>
4454
4455 <CENTER><TABLE WIDTH="80%" BORDER>
4456 <TR>
4457         <TH>Argument</TH>
4458         <TH>Description</TH>
4459 </TR>
4460 <TR>
4461         <TD></TD>
4462         <TD></TD>
4463 </TR>
4464 </TABLE></CENTER>
4465
4466 <H3>Returns</H3>
4467
4468 <H3>Description</H3>
4469
4470 <H3>Example</H3>
4471
4472 <PRE>
4473 </PRE>
4474
4475 <H3>See Also</H3>
4476
4477
4478 <!-- NEW PAGE --><H2><A NAME="ppdEmit">ppdEmit()</A></H2>
4479
4480 <H3>Usage</H3>
4481
4482 <PRE>
4483 </PRE>
4484
4485 <H3>Arguments</H3>
4486
4487 <CENTER><TABLE WIDTH="80%" BORDER>
4488 <TR>
4489         <TH>Argument</TH>
4490         <TH>Description</TH>
4491 </TR>
4492 <TR>
4493         <TD></TD>
4494         <TD></TD>
4495 </TR>
4496 </TABLE></CENTER>
4497
4498 <H3>Returns</H3>
4499
4500 <H3>Description</H3>
4501
4502 <H3>Example</H3>
4503
4504 <PRE>
4505 </PRE>
4506
4507 <H3>See Also</H3>
4508
4509
4510 <!-- NEW PAGE --><H2><A NAME="ppdFindChoice">ppdFindChoice()</A></H2>
4511
4512 <H3>Usage</H3>
4513
4514 <PRE>
4515 </PRE>
4516
4517 <H3>Arguments</H3>
4518
4519 <CENTER><TABLE WIDTH="80%" BORDER>
4520 <TR>
4521         <TH>Argument</TH>
4522         <TH>Description</TH>
4523 </TR>
4524 <TR>
4525         <TD></TD>
4526         <TD></TD>
4527 </TR>
4528 </TABLE></CENTER>
4529
4530 <H3>Returns</H3>
4531
4532 <H3>Description</H3>
4533
4534 <H3>Example</H3>
4535
4536 <PRE>
4537 </PRE>
4538
4539 <H3>See Also</H3>
4540
4541
4542 <!-- NEW PAGE --><H2><A NAME="ppdFindMarkedChoice">ppdFindMarkedChoice()</A></H2>
4543
4544 <H3>Usage</H3>
4545
4546 <PRE>
4547 </PRE>
4548
4549 <H3>Arguments</H3>
4550
4551 <CENTER><TABLE WIDTH="80%" BORDER>
4552 <TR>
4553         <TH>Argument</TH>
4554         <TH>Description</TH>
4555 </TR>
4556 <TR>
4557         <TD></TD>
4558         <TD></TD>
4559 </TR>
4560 </TABLE></CENTER>
4561
4562 <H3>Returns</H3>
4563
4564 <H3>Description</H3>
4565
4566 <H3>Example</H3>
4567
4568 <PRE>
4569 </PRE>
4570
4571 <H3>See Also</H3>
4572
4573
4574 <!-- NEW PAGE --><H2><A NAME="ppdFindOption">ppdFindOption()</A></H2>
4575
4576 <H3>Usage</H3>
4577
4578 <PRE>
4579 </PRE>
4580
4581 <H3>Arguments</H3>
4582
4583 <CENTER><TABLE WIDTH="80%" BORDER>
4584 <TR>
4585         <TH>Argument</TH>
4586         <TH>Description</TH>
4587 </TR>
4588 <TR>
4589         <TD></TD>
4590         <TD></TD>
4591 </TR>
4592 </TABLE></CENTER>
4593
4594 <H3>Returns</H3>
4595
4596 <H3>Description</H3>
4597
4598 <H3>Example</H3>
4599
4600 <PRE>
4601 </PRE>
4602
4603 <H3>See Also</H3>
4604
4605
4606 <!-- NEW PAGE --><H2><A NAME="ppdIsMarked">ppdIsMarked()</A></H2>
4607
4608 <H3>Usage</H3>
4609
4610 <PRE>
4611 </PRE>
4612
4613 <H3>Arguments</H3>
4614
4615 <CENTER><TABLE WIDTH="80%" BORDER>
4616 <TR>
4617         <TH>Argument</TH>
4618         <TH>Description</TH>
4619 </TR>
4620 <TR>
4621         <TD></TD>
4622         <TD></TD>
4623 </TR>
4624 </TABLE></CENTER>
4625
4626 <H3>Returns</H3>
4627
4628 <H3>Description</H3>
4629
4630 <H3>Example</H3>
4631
4632 <PRE>
4633 </PRE>
4634
4635 <H3>See Also</H3>
4636
4637
4638 <!-- NEW PAGE --><H2><A NAME="ppdMarkDefaults">ppdMarkDefaults()</A></H2>
4639
4640 <H3>Usage</H3>
4641
4642 <PRE>
4643 </PRE>
4644
4645 <H3>Arguments</H3>
4646
4647 <CENTER><TABLE WIDTH="80%" BORDER>
4648 <TR>
4649         <TH>Argument</TH>
4650         <TH>Description</TH>
4651 </TR>
4652 <TR>
4653         <TD></TD>
4654         <TD></TD>
4655 </TR>
4656 </TABLE></CENTER>
4657
4658 <H3>Returns</H3>
4659
4660 <H3>Description</H3>
4661
4662 <H3>Example</H3>
4663
4664 <PRE>
4665 </PRE>
4666
4667 <H3>See Also</H3>
4668
4669
4670 <!-- NEW PAGE --><H2><A NAME="ppdMarkOption">ppdMarkOption()</A></H2>
4671
4672 <H3>Usage</H3>
4673
4674 <PRE>
4675 </PRE>
4676
4677 <H3>Arguments</H3>
4678
4679 <CENTER><TABLE WIDTH="80%" BORDER>
4680 <TR>
4681         <TH>Argument</TH>
4682         <TH>Description</TH>
4683 </TR>
4684 <TR>
4685         <TD></TD>
4686         <TD></TD>
4687 </TR>
4688 </TABLE></CENTER>
4689
4690 <H3>Returns</H3>
4691
4692 <H3>Description</H3>
4693
4694 <H3>Example</H3>
4695
4696 <PRE>
4697 </PRE>
4698
4699 <H3>See Also</H3>
4700
4701
4702 <!-- NEW PAGE --><H2><A NAME="ppdOpenFd">ppdOpenFd()</A></H2>
4703
4704 <H3>Usage</H3>
4705
4706 <PRE>
4707 </PRE>
4708
4709 <H3>Arguments</H3>
4710
4711 <CENTER><TABLE WIDTH="80%" BORDER>
4712 <TR>
4713         <TH>Argument</TH>
4714         <TH>Description</TH>
4715 </TR>
4716 <TR>
4717         <TD></TD>
4718         <TD></TD>
4719 </TR>
4720 </TABLE></CENTER>
4721
4722 <H3>Returns</H3>
4723
4724 <H3>Description</H3>
4725
4726 <H3>Example</H3>
4727
4728 <PRE>
4729 </PRE>
4730
4731 <H3>See Also</H3>
4732
4733
4734 <!-- NEW PAGE --><H2><A NAME="ppdOpenFile">ppdOpenFile()</A></H2>
4735
4736 <H3>Usage</H3>
4737
4738 <PRE>
4739 </PRE>
4740
4741 <H3>Arguments</H3>
4742
4743 <CENTER><TABLE WIDTH="80%" BORDER>
4744 <TR>
4745         <TH>Argument</TH>
4746         <TH>Description</TH>
4747 </TR>
4748 <TR>
4749         <TD></TD>
4750         <TD></TD>
4751 </TR>
4752 </TABLE></CENTER>
4753
4754 <H3>Returns</H3>
4755
4756 <H3>Description</H3>
4757
4758 <H3>Example</H3>
4759
4760 <PRE>
4761 </PRE>
4762
4763 <H3>See Also</H3>
4764
4765
4766 <!-- NEW PAGE --><H2><A NAME="ppdOpen">ppdOpen()</A></H2>
4767
4768 <H3>Usage</H3>
4769
4770 <PRE>
4771 </PRE>
4772
4773 <H3>Arguments</H3>
4774
4775 <CENTER><TABLE WIDTH="80%" BORDER>
4776 <TR>
4777         <TH>Argument</TH>
4778         <TH>Description</TH>
4779 </TR>
4780 <TR>
4781         <TD></TD>
4782         <TD></TD>
4783 </TR>
4784 </TABLE></CENTER>
4785
4786 <H3>Returns</H3>
4787
4788 <H3>Description</H3>
4789
4790 <H3>Example</H3>
4791
4792 <PRE>
4793 </PRE>
4794
4795 <H3>See Also</H3>
4796
4797
4798 <!-- NEW PAGE --><H2><A NAME="ppdPageLength">ppdPageLength()</A></H2>
4799
4800 <H3>Usage</H3>
4801
4802 <PRE>
4803 </PRE>
4804
4805 <H3>Arguments</H3>
4806
4807 <CENTER><TABLE WIDTH="80%" BORDER>
4808 <TR>
4809         <TH>Argument</TH>
4810         <TH>Description</TH>
4811 </TR>
4812 <TR>
4813         <TD></TD>
4814         <TD></TD>
4815 </TR>
4816 </TABLE></CENTER>
4817
4818 <H3>Returns</H3>
4819
4820 <H3>Description</H3>
4821
4822 <H3>Example</H3>
4823
4824 <PRE>
4825 </PRE>
4826
4827 <H3>See Also</H3>
4828
4829
4830 <!-- NEW PAGE --><H2><A NAME="ppdPageSize">ppdPageSize()</A></H2>
4831
4832 <H3>Usage</H3>
4833
4834 <PRE>
4835 </PRE>
4836
4837 <H3>Arguments</H3>
4838
4839 <CENTER><TABLE WIDTH="80%" BORDER>
4840 <TR>
4841         <TH>Argument</TH>
4842         <TH>Description</TH>
4843 </TR>
4844 <TR>
4845         <TD></TD>
4846         <TD></TD>
4847 </TR>
4848 </TABLE></CENTER>
4849
4850 <H3>Returns</H3>
4851
4852 <H3>Description</H3>
4853
4854 <H3>Example</H3>
4855
4856 <PRE>
4857 </PRE>
4858
4859 <H3>See Also</H3>
4860
4861
4862 <!-- NEW PAGE --><H2><A NAME="ppdPageWidth">ppdPageWidth()</A></H2>
4863
4864 <H3>Usage</H3>
4865
4866 <PRE>
4867 </PRE>
4868
4869 <H3>Arguments</H3>
4870
4871 <CENTER><TABLE WIDTH="80%" BORDER>
4872 <TR>
4873         <TH>Argument</TH>
4874         <TH>Description</TH>
4875 </TR>
4876 <TR>
4877         <TD></TD>
4878         <TD></TD>
4879 </TR>
4880 </TABLE></CENTER>
4881
4882 <H3>Returns</H3>
4883
4884 <H3>Description</H3>
4885
4886 <H3>Example</H3>
4887
4888 <PRE>
4889 </PRE>
4890
4891 <H3>See Also</H3>
4892
4893
4894 </BODY>
4895 </HTML>