backend/serial.c

   1 /*
   2  * "$Id: serial.c 7647 2008-06-16 17:39:40Z mike $"
   3  *
   4  *   Serial port backend for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 2007 by Apple Inc.
   7  *   Copyright 1997-2007 by Easy Software Products, all rights reserved.
   8  *
   9  *   These coded instructions, statements, and computer programs are the
  10  *   property of Apple Inc. and are protected by Federal copyright
  11  *   law.  Distribution and use rights are outlined in the file "LICENSE.txt"
  12  *   "LICENSE" which should have been included with this file.  If this
  13  *   file is missing or damaged, see the license at "http://www.cups.org/".
  14  *
  15  *   This file is subject to the Apple OS-Developed Software exception.
  16  *
  17  * Contents:
  18  *
  19  *   main()         - Send a file to the printer or server.
  20  *   list_devices() - List all serial devices.
  21  *   side_cb()      - Handle side-channel requests...
  22  */
  23
  24 /*
  25  * Include necessary headers.
  26  */
  27
  28 #include "backend-private.h"
  29
  30 #ifdef __hpux
  31 #  include <sys/modem.h>
  32 #endif /* __hpux */
  33
  34 #ifdef WIN32
  35 #  include <io.h>
  36 #else
  37 #  include <unistd.h>
  38 #  include <fcntl.h>
  39 #  include <termios.h>
  40 #  ifdef __hpux
  41 #    include <sys/time.h>
  42 #  else
  43 #    include <sys/select.h>
  44 #  endif /* __hpux */
  45 #  ifdef HAVE_SYS_IOCTL_H
  46 #    include <sys/ioctl.h>
  47 #  endif /* HAVE_SYS_IOCTL_H */
  48 #endif /* WIN32 */
  49
  50 #ifdef __sgi
  51 #  include <invent.h>
  52 #  ifndef INV_EPP_ECP_PLP
  53 #    define INV_EPP_ECP_PLP     6       /* From 6.3/6.4/6.5 sys/invent.h */
  54 #    define INV_ASO_SERIAL      14      /* serial portion of SGI ASO board */
  55 #    define INV_IOC3_DMA        16      /* DMA mode IOC3 serial */
  56 #    define INV_IOC3_PIO        17      /* PIO mode IOC3 serial */
  57 #    define INV_ISA_DMA         19      /* DMA mode ISA serial -- O2 */
  58 #  endif /* !INV_EPP_ECP_PLP */
  59 #endif /* __sgi */
  60
  61 #ifndef CRTSCTS
  62 #  ifdef CNEW_RTSCTS
  63 #    define CRTSCTS CNEW_RTSCTS
  64 #  else
  65 #    define CRTSCTS 0
  66 #  endif /* CNEW_RTSCTS */
  67 #endif /* !CRTSCTS */
  68
  69 #if defined(__APPLE__)
  70 #  include <CoreFoundation/CoreFoundation.h>
  71 #  include <IOKit/IOKitLib.h>
  72 #  include <IOKit/serial/IOSerialKeys.h>
  73 #  include <IOKit/IOBSD.h>
  74 #endif /* __APPLE__ */
  75
  76 #if defined(__linux) && defined(TIOCGSERIAL)
  77 #  include <linux/serial.h>
  78 #  include <linux/ioctl.h>
  79 #endif /* __linux && TIOCGSERIAL */
  80
  81
  82 /*
  83  * Local functions...
  84  */
  85
  86 static void     list_devices(void);
  87 static void     side_cb(int print_fd, int device_fd, int use_bc);
  88
  89
  90 /*
  91  * 'main()' - Send a file to the printer or server.
  92  *
  93  * Usage:
  94  *
  95  *    printer-uri job-id user title copies options [file]
  96  */
  97
  98 int                                     /* O - Exit status */
  99 main(int  argc,                         /* I - Number of command-line arguments (6 or 7) */
 100      char *argv[])                      /* I - Command-line arguments */
 101 {
 102   char          method[255],            /* Method in URI */
 103                 hostname[1024],         /* Hostname */
 104                 username[255],          /* Username info (not used) */
 105                 resource[1024],         /* Resource info (device and options) */
 106                 *options,               /* Pointer to options */
 107                 *name,                  /* Name of option */
 108                 *value,                 /* Value of option */
 109                 sep;                    /* Option separator */
 110   int           port;                   /* Port number (not used) */
 111   int           copies;                 /* Number of copies to print */
 112   int           print_fd,               /* Print file */
 113                 device_fd;              /* Serial device */
 114   int           nfds;                   /* Maximum file descriptor value + 1 */
 115   fd_set        input,                  /* Input set for reading */
 116                 output;                 /* Output set for writing */
 117   ssize_t       print_bytes,            /* Print bytes read */
 118                 bc_bytes,               /* Backchannel bytes read */
 119                 total_bytes,            /* Total bytes written */
 120                 bytes;                  /* Bytes written */
 121   int           dtrdsr;                 /* Do dtr/dsr flow control? */
 122   int           print_size;             /* Size of output buffer for writes */
 123   char          print_buffer[8192],     /* Print data buffer */
 124                 *print_ptr,             /* Pointer into print data buffer */
 125                 bc_buffer[1024];        /* Back-channel data buffer */
 126   struct termios opts;                  /* Serial port options */
 127   struct termios origopts;              /* Original port options */
 128 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
 129   struct sigaction action;              /* Actions for POSIX signals */
 130 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
 131
 132
 133  /*
 134   * Make sure status messages are not buffered...
 135   */
 136
 137   setbuf(stderr, NULL);
 138
 139  /*
 140   * Ignore SIGPIPE signals...
 141   */
 142
 143 #ifdef HAVE_SIGSET
 144   sigset(SIGPIPE, SIG_IGN);
 145 #elif defined(HAVE_SIGACTION)
 146   memset(&action, 0, sizeof(action));
 147   action.sa_handler = SIG_IGN;
 148   sigaction(SIGPIPE, &action, NULL);
 149 #else
 150   signal(SIGPIPE, SIG_IGN);
 151 #endif /* HAVE_SIGSET */
 152
 153  /*
 154   * Check command-line...
 155   */
 156
 157   if (argc == 1)
 158   {
 159     list_devices();
 160     return (CUPS_BACKEND_OK);
 161   }
 162   else if (argc < 6 || argc > 7)
 163   {
 164     _cupsLangPrintf(stderr,
 165                     _("Usage: %s job-id user title copies options [file]\n"),
 166                     argv[0]);
 167     return (CUPS_BACKEND_FAILED);
 168   }
 169
 170  /*
 171   * If we have 7 arguments, print the file named on the command-line.
 172   * Otherwise, send stdin instead...
 173   */
 174
 175   if (argc == 6)
 176   {
 177     print_fd = 0;
 178     copies   = 1;
 179   }
 180   else
 181   {
 182    /*
 183     * Try to open the print file...
 184     */
 185
 186     if ((print_fd = open(argv[6], O_RDONLY)) < 0)
 187     {
 188       _cupsLangPrintf(stderr,
 189                       _("ERROR: Unable to open print file \"%s\": %s\n"),
 190                       argv[6], strerror(errno));
 191       return (CUPS_BACKEND_FAILED);
 192     }
 193
 194     copies = atoi(argv[4]);
 195   }
 196
 197  /*
 198   * Extract the device name and options from the URI...
 199   */
 200
 201   httpSeparateURI(HTTP_URI_CODING_ALL, cupsBackendDeviceURI(argv),
 202                   method, sizeof(method), username, sizeof(username),
 203                   hostname, sizeof(hostname), &port,
 204                   resource, sizeof(resource));
 205
 206  /*
 207   * See if there are any options...
 208   */
 209
 210   if ((options = strchr(resource, '?')) != NULL)
 211   {
 212    /*
 213     * Yup, terminate the device name string and move to the first
 214     * character of the options...
 215     */
 216
 217     *options++ = '\0';
 218   }
 219
 220  /*
 221   * Open the serial port device...
 222   */
 223
 224   fputs("STATE: +connecting-to-device\n", stderr);
 225
 226   do
 227   {
 228     if ((device_fd = open(resource, O_RDWR | O_NOCTTY | O_EXCL |
 229                                     O_NDELAY)) == -1)
 230     {
 231       if (getenv("CLASS") != NULL)
 232       {
 233        /*
 234         * If the CLASS environment variable is set, the job was submitted
 235         * to a class and not to a specific queue.  In this case, we want
 236         * to abort immediately so that the job can be requeued on the next
 237         * available printer in the class.
 238         */
 239
 240         _cupsLangPuts(stderr,
 241                       _("INFO: Unable to contact printer, queuing on next "
 242                         "printer in class...\n"));
 243
 244        /*
 245         * Sleep 5 seconds to keep the job from requeuing too rapidly...
 246         */
 247
 248         sleep(5);
 249
 250         return (CUPS_BACKEND_FAILED);
 251       }
 252
 253       if (errno == EBUSY)
 254       {
 255         _cupsLangPuts(stderr,
 256                       _("INFO: Printer busy; will retry in 30 seconds...\n"));
 257         sleep(30);
 258       }
 259       else
 260       {
 261         _cupsLangPrintf(stderr,
 262                         _("ERROR: Unable to open device file \"%s\": %s\n"),
 263                         resource, strerror(errno));
 264         return (CUPS_BACKEND_FAILED);
 265       }
 266     }
 267   }
 268   while (device_fd < 0);
 269
 270   fputs("STATE: -connecting-to-device\n", stderr);
 271
 272  /*
 273   * Set any options provided...
 274   */
 275
 276   tcgetattr(device_fd, &origopts);
 277   tcgetattr(device_fd, &opts);
 278
 279   opts.c_lflag &= ~(ICANON | ECHO | ISIG);
 280                                         /* Raw mode */
 281   opts.c_oflag &= ~OPOST;               /* Don't post-process */
 282
 283   print_size = 96;                      /* 9600 baud / 10 bits/char / 10Hz */
 284   dtrdsr     = 0;                       /* No dtr/dsr flow control */
 285
 286   if (options)
 287   {
 288     while (*options)
 289     {
 290      /*
 291       * Get the name...
 292       */
 293
 294       name = options;
 295
 296       while (*options && *options != '=' && *options != '+' && *options != '&')
 297         options ++;
 298
 299       if ((sep = *options) != '\0')
 300         *options++ = '\0';
 301
 302       if (sep == '=')
 303       {
 304        /*
 305         * Get the value...
 306         */
 307
 308         value = options;
 309
 310         while (*options && *options != '+' && *options != '&')
 311           options ++;
 312
 313         if (*options)
 314           *options++ = '\0';
 315       }
 316       else
 317         value = (char *)"";
 318
 319      /*
 320       * Process the option...
 321       */
 322
 323       if (!strcasecmp(name, "baud"))
 324       {
 325        /*
 326         * Set the baud rate...
 327         */
 328
 329         print_size = atoi(value) / 100;
 330
 331 #if B19200 == 19200
 332         cfsetispeed(&opts, atoi(value));
 333         cfsetospeed(&opts, atoi(value));
 334 #else
 335         switch (atoi(value))
 336         {
 337           case 1200 :
 338               cfsetispeed(&opts, B1200);
 339               cfsetospeed(&opts, B1200);
 340               break;
 341           case 2400 :
 342               cfsetispeed(&opts, B2400);
 343               cfsetospeed(&opts, B2400);
 344               break;
 345           case 4800 :
 346               cfsetispeed(&opts, B4800);
 347               cfsetospeed(&opts, B4800);
 348               break;
 349           case 9600 :
 350               cfsetispeed(&opts, B9600);
 351               cfsetospeed(&opts, B9600);
 352               break;
 353           case 19200 :
 354               cfsetispeed(&opts, B19200);
 355               cfsetospeed(&opts, B19200);
 356               break;
 357           case 38400 :
 358               cfsetispeed(&opts, B38400);
 359               cfsetospeed(&opts, B38400);
 360               break;
 361 #  ifdef B57600
 362           case 57600 :
 363               cfsetispeed(&opts, B57600);
 364               cfsetospeed(&opts, B57600);
 365               break;
 366 #  endif /* B57600 */
 367 #  ifdef B115200
 368           case 115200 :
 369               cfsetispeed(&opts, B115200);
 370               cfsetospeed(&opts, B115200);
 371               break;
 372 #  endif /* B115200 */
 373 #  ifdef B230400
 374           case 230400 :
 375               cfsetispeed(&opts, B230400);
 376               cfsetospeed(&opts, B230400);
 377               break;
 378 #  endif /* B230400 */
 379           default :
 380               _cupsLangPrintf(stderr, _("WARNING: Unsupported baud rate %s!\n"),
 381                               value);
 382               break;
 383         }
 384 #endif /* B19200 == 19200 */
 385       }
 386       else if (!strcasecmp(name, "bits"))
 387       {
 388        /*
 389         * Set number of data bits...
 390         */
 391
 392         switch (atoi(value))
 393         {
 394           case 7 :
 395               opts.c_cflag &= ~CSIZE;
 396               opts.c_cflag |= CS7;
 397               opts.c_cflag |= PARENB;
 398               opts.c_cflag &= ~PARODD;
 399               break;
 400           case 8 :
 401               opts.c_cflag &= ~CSIZE;
 402               opts.c_cflag |= CS8;
 403               opts.c_cflag &= ~PARENB;
 404               break;
 405         }
 406       }
 407       else if (!strcasecmp(name, "parity"))
 408       {
 409        /*
 410         * Set parity checking...
 411         */
 412
 413         if (!strcasecmp(value, "even"))
 414         {
 415           opts.c_cflag |= PARENB;
 416           opts.c_cflag &= ~PARODD;
 417         }
 418         else if (!strcasecmp(value, "odd"))
 419         {
 420           opts.c_cflag |= PARENB;
 421           opts.c_cflag |= PARODD;
 422         }
 423         else if (!strcasecmp(value, "none"))
 424           opts.c_cflag &= ~PARENB;
 425         else if (!strcasecmp(value, "space"))
 426         {
 427          /*
 428           * Note: we only support space parity with 7 bits per character...
 429           */
 430
 431           opts.c_cflag &= ~CSIZE;
 432           opts.c_cflag |= CS8;
 433           opts.c_cflag &= ~PARENB;
 434         }
 435         else if (!strcasecmp(value, "mark"))
 436         {
 437          /*
 438           * Note: we only support mark parity with 7 bits per character
 439           * and 1 stop bit...
 440           */
 441
 442           opts.c_cflag &= ~CSIZE;
 443           opts.c_cflag |= CS7;
 444           opts.c_cflag &= ~PARENB;
 445           opts.c_cflag |= CSTOPB;
 446         }
 447       }
 448       else if (!strcasecmp(name, "flow"))
 449       {
 450        /*
 451         * Set flow control...
 452         */
 453
 454         if (!strcasecmp(value, "none"))
 455         {
 456           opts.c_iflag &= ~(IXON | IXOFF);
 457           opts.c_cflag &= ~CRTSCTS;
 458         }
 459         else if (!strcasecmp(value, "soft"))
 460         {
 461           opts.c_iflag |= IXON | IXOFF;
 462           opts.c_cflag &= ~CRTSCTS;
 463         }
 464         else if (!strcasecmp(value, "hard") ||
 465                  !strcasecmp(value, "rtscts"))
 466         {
 467           opts.c_iflag &= ~(IXON | IXOFF);
 468           opts.c_cflag |= CRTSCTS;
 469         }
 470         else if (!strcasecmp(value, "dtrdsr"))
 471         {
 472           opts.c_iflag &= ~(IXON | IXOFF);
 473           opts.c_cflag &= ~CRTSCTS;
 474
 475           dtrdsr = 1;
 476         }
 477       }
 478       else if (!strcasecmp(name, "stop"))
 479       {
 480         switch (atoi(value))
 481         {
 482           case 1 :
 483               opts.c_cflag &= ~CSTOPB;
 484               break;
 485
 486           case 2 :
 487               opts.c_cflag |= CSTOPB;
 488               break;
 489         }
 490       }
 491     }
 492   }
 493
 494   tcsetattr(device_fd, TCSANOW, &opts);
 495   fcntl(device_fd, F_SETFL, 0);
 496
 497  /*
 498   * Now that we are "connected" to the port, ignore SIGTERM so that we
 499   * can finish out any page data the driver sends (e.g. to eject the
 500   * current page...  Only ignore SIGTERM if we are printing data from
 501   * stdin (otherwise you can't cancel raw jobs...)
 502   */
 503
 504   if (print_fd != 0)
 505   {
 506 #ifdef HAVE_SIGSET /* Use System V signals over POSIX to avoid bugs */
 507     sigset(SIGTERM, SIG_IGN);
 508 #elif defined(HAVE_SIGACTION)
 509     memset(&action, 0, sizeof(action));
 510
 511     sigemptyset(&action.sa_mask);
 512     action.sa_handler = SIG_IGN;
 513     sigaction(SIGTERM, &action, NULL);
 514 #else
 515     signal(SIGTERM, SIG_IGN);
 516 #endif /* HAVE_SIGSET */
 517   }
 518
 519  /*
 520   * Figure out the maximum file descriptor value to use with select()...
 521   */
 522
 523   nfds = (print_fd > device_fd ? print_fd : device_fd) + 1;
 524
 525  /*
 526   * Finally, send the print file.  Ordinarily we would just use the
 527   * backendRunLoop() function, however since we need to use smaller
 528   * writes and may need to do DSR/DTR flow control, we duplicate much
 529   * of the code here instead...
 530   */
 531
 532   if (print_size > sizeof(print_buffer))
 533     print_size = sizeof(print_buffer);
 534
 535   total_bytes = 0;
 536
 537   while (copies > 0)
 538   {
 539     copies --;
 540
 541     if (print_fd != 0)
 542     {
 543       fputs("PAGE: 1 1\n", stderr);
 544       lseek(print_fd, 0, SEEK_SET);
 545     }
 546
 547    /*
 548     * Now loop until we are out of data from print_fd...
 549     */
 550
 551     for (print_bytes = 0, print_ptr = print_buffer;;)
 552     {
 553      /*
 554       * Use select() to determine whether we have data to copy around...
 555       */
 556
 557       FD_ZERO(&input);
 558       if (!print_bytes)
 559         FD_SET(print_fd, &input);
 560       FD_SET(device_fd, &input);
 561       if (!print_bytes)
 562         FD_SET(CUPS_SC_FD, &input);
 563
 564       FD_ZERO(&output);
 565       if (print_bytes)
 566         FD_SET(device_fd, &output);
 567
 568       if (select(nfds, &input, &output, NULL, NULL) < 0)
 569         continue;                       /* Ignore errors here */
 570
 571      /*
 572       * Check if we have a side-channel request ready...
 573       */
 574
 575       if (FD_ISSET(CUPS_SC_FD, &input))
 576       {
 577        /*
 578         * Do the side-channel request, then start back over in the select
 579         * loop since it may have read from print_fd...
 580         */
 581
 582         side_cb(print_fd, device_fd, 1);
 583         continue;
 584       }
 585
 586      /*
 587       * Check if we have back-channel data ready...
 588       */
 589
 590       if (FD_ISSET(device_fd, &input))
 591       {
 592         if ((bc_bytes = read(device_fd, bc_buffer, sizeof(bc_buffer))) > 0)
 593         {
 594           fprintf(stderr,
 595                   "DEBUG: Received " CUPS_LLFMT " bytes of back-channel data!\n",
 596                   CUPS_LLCAST bc_bytes);
 597           cupsBackChannelWrite(bc_buffer, bc_bytes, 1.0);
 598         }
 599       }
 600
 601      /*
 602       * Check if we have print data ready...
 603       */
 604
 605       if (FD_ISSET(print_fd, &input))
 606       {
 607         if ((print_bytes = read(print_fd, print_buffer, print_size)) < 0)
 608         {
 609          /*
 610           * Read error - bail if we don't see EAGAIN or EINTR...
 611           */
 612
 613           if (errno != EAGAIN || errno != EINTR)
 614           {
 615             _cupsLangPrintError(_("ERROR: Unable to read print data"));
 616
 617             tcsetattr(device_fd, TCSADRAIN, &origopts);
 618
 619             close(device_fd);
 620
 621             if (print_fd != 0)
 622               close(print_fd);
 623
 624             return (CUPS_BACKEND_FAILED);
 625           }
 626
 627           print_bytes = 0;
 628         }
 629         else if (print_bytes == 0)
 630         {
 631          /*
 632           * End of file, break out of the loop...
 633           */
 634
 635           break;
 636         }
 637
 638         print_ptr = print_buffer;
 639       }
 640
 641      /*
 642       * Check if the device is ready to receive data and we have data to
 643       * send...
 644       */
 645
 646       if (print_bytes && FD_ISSET(device_fd, &output))
 647       {
 648         if (dtrdsr)
 649         {
 650          /*
 651           * Check the port and sleep until DSR is set...
 652           */
 653
 654           int status;
 655
 656
 657           if (!ioctl(device_fd, TIOCMGET, &status))
 658             if (!(status & TIOCM_DSR))
 659             {
 660              /*
 661               * Wait for DSR to go high...
 662               */
 663
 664               fputs("DEBUG: DSR is low; waiting for device...\n", stderr);
 665
 666               do
 667               {
 668                /*
 669                 * Poll every 100ms...
 670                 */
 671
 672                 usleep(100000);
 673
 674                 if (ioctl(device_fd, TIOCMGET, &status))
 675                   break;
 676               }
 677               while (!(status & TIOCM_DSR));
 678
 679               fputs("DEBUG: DSR is high; writing to device...\n", stderr);
 680             }
 681         }
 682
 683         if ((bytes = write(device_fd, print_ptr, print_bytes)) < 0)
 684         {
 685          /*
 686           * Write error - bail if we don't see an error we can retry...
 687           */
 688
 689           if (errno != EAGAIN && errno != EINTR && errno != ENOTTY)
 690           {
 691             _cupsLangPrintError(_("ERROR: Unable to write print data"));
 692
 693             tcsetattr(device_fd, TCSADRAIN, &origopts);
 694
 695             close(device_fd);
 696
 697             if (print_fd != 0)
 698               close(print_fd);
 699
 700             return (CUPS_BACKEND_FAILED);
 701           }
 702         }
 703         else
 704         {
 705           fprintf(stderr, "DEBUG: Wrote %d bytes...\n", (int)bytes);
 706
 707           print_bytes -= bytes;
 708           print_ptr   += bytes;
 709           total_bytes += bytes;
 710         }
 711       }
 712     }
 713   }
 714
 715  /*
 716   * Close the serial port and input file and return...
 717   */
 718
 719   tcsetattr(device_fd, TCSADRAIN, &origopts);
 720
 721   close(device_fd);
 722
 723   if (print_fd != 0)
 724     close(print_fd);
 725
 726   return (total_bytes < 0 ? CUPS_BACKEND_FAILED : CUPS_BACKEND_OK);
 727 }
 728
 729
 730 /*
 731  * 'list_devices()' - List all serial devices.
 732  */
 733
 734 static void
 735 list_devices(void)
 736 {
 737 #if defined(__hpux) || defined(__sgi) || defined(__sun) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 738   static char   *funky_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
 739                                         /* Funky hex numbering used for some *
 740                                          * devices                           */
 741 #endif /* __hpux || __sgi || __sun || __FreeBSD__ || __OpenBSD__ || __FreeBSD_kernel__ */
 742
 743 #ifdef __linux
 744   int                   i, j;           /* Looping vars */
 745   int                   fd;             /* File descriptor */
 746   char                  device[255];    /* Device filename */
 747 #  ifdef TIOCGSERIAL
 748   struct serial_struct  serinfo;        /* serial port info */
 749 #  endif /* TIOCGSERIAL */
 750
 751
 752   for (i = 0; i < 100; i ++)
 753   {
 754     sprintf(device, "/dev/ttyS%d", i);
 755
 756     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 757     {
 758 #  ifdef TIOCGSERIAL
 759      /*
 760       * See if this port exists...
 761       */
 762
 763       serinfo.reserved_char[0] = 0;
 764
 765       if (!ioctl(fd, TIOCGSERIAL, &serinfo))
 766       {
 767         if (serinfo.type == PORT_UNKNOWN)
 768         {
 769          /*
 770           * Nope...
 771           */
 772
 773           close(fd);
 774           continue;
 775         }
 776       }
 777 #  endif /* TIOCGSERIAL */
 778
 779       close(fd);
 780
 781 #  if defined(_ARCH_PPC) || defined(powerpc) || defined(__powerpc)
 782       printf("serial serial:%s?baud=230400 \"Unknown\" \"Serial Port #%d\"\n",
 783              device, i + 1);
 784 #  else
 785       printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
 786              device, i + 1);
 787 #  endif /* _ARCH_PPC || powerpc || __powerpc */
 788     }
 789   }
 790
 791   for (i = 0; i < 16; i ++)
 792   {
 793     sprintf(device, "/dev/usb/ttyUSB%d", i);
 794     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 795     {
 796       close(fd);
 797       printf("serial serial:%s?baud=230400 \"Unknown\" \"USB Serial Port #%d\"\n",
 798              device, i + 1);
 799     }
 800
 801     sprintf(device, "/dev/ttyUSB%d", i);
 802     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 803     {
 804       close(fd);
 805       printf("serial serial:%s?baud=230400 \"Unknown\" \"USB Serial Port #%d\"\n",
 806              device, i + 1);
 807     }
 808   }
 809
 810   for (i = 0; i < 64; i ++)
 811   {
 812     for (j = 0; j < 8; j ++)
 813     {
 814       sprintf(device, "/dev/ttyQ%02de%d", i, j);
 815       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 816       {
 817         close(fd);
 818         printf("serial serial:%s?baud=115200 \"Unknown\" "
 819                "\"Equinox ESP %d Port #%d\"\n",
 820                device, i, j + 1);
 821       }
 822     }
 823   }
 824 #elif defined(__sgi)
 825   int           i, j, n;        /* Looping vars */
 826   char          device[255];    /* Device filename */
 827   inventory_t   *inv;           /* Hardware inventory info */
 828
 829
 830  /*
 831   * IRIX maintains a hardware inventory of most devices...
 832   */
 833
 834   setinvent();
 835
 836   while ((inv = getinvent()) != NULL)
 837   {
 838     if (inv->inv_class == INV_SERIAL)
 839     {
 840      /*
 841       * Some sort of serial port...
 842       */
 843
 844       if (inv->inv_type == INV_CDSIO || inv->inv_type == INV_CDSIO_E)
 845       {
 846        /*
 847         * CDSIO port...
 848         */
 849
 850         for (n = 0; n < 6; n ++)
 851           printf("serial serial:/dev/ttyd%d?baud=38400 \"Unknown\" \"CDSIO Board %d Serial Port #%d\"\n",
 852                  n + 5 + 8 * inv->inv_controller, inv->inv_controller, n + 1);
 853       }
 854       else if (inv->inv_type == INV_EPC_SERIAL)
 855       {
 856        /*
 857         * Everest serial port...
 858         */
 859
 860         if (inv->inv_unit == 0)
 861           i = 1;
 862         else
 863           i = 41 + 4 * (int)inv->inv_controller;
 864
 865         for (n = 0; n < (int)inv->inv_state; n ++)
 866           printf("serial serial:/dev/ttyd%d?baud=38400 \"Unknown\" \"EPC Serial Port %d, Ebus slot %d\"\n",
 867                  n + i, n + 1, (int)inv->inv_controller);
 868       }
 869       else if (inv->inv_state > 1)
 870       {
 871        /*
 872         * Standard serial port under IRIX 6.4 and earlier...
 873         */
 874
 875         for (n = 0; n < (int)inv->inv_state; n ++)
 876           printf("serial serial:/dev/ttyd%d?baud=38400 \"Unknown\" \"Onboard Serial Port %d\"\n",
 877                  n + (int)inv->inv_unit + 1, n + (int)inv->inv_unit + 1);
 878       }
 879       else
 880       {
 881        /*
 882         * Standard serial port under IRIX 6.5 and beyond...
 883         */
 884
 885         printf("serial serial:/dev/ttyd%d?baud=115200 \"Unknown\" \"Onboard Serial Port %d\"\n",
 886                (int)inv->inv_controller, (int)inv->inv_controller);
 887       }
 888     }
 889   }
 890
 891   endinvent();
 892
 893  /*
 894   * Central Data makes serial and parallel "servers" that can be
 895   * connected in a number of ways.  Look for ports...
 896   */
 897
 898   for (i = 0; i < 10; i ++)
 899     for (j = 0; j < 8; j ++)
 900       for (n = 0; n < 32; n ++)
 901       {
 902         if (i == 8)             /* EtherLite */
 903           sprintf(device, "/dev/ttydn%d%c", j, funky_hex[n]);
 904         else if (i == 9)        /* PCI */
 905           sprintf(device, "/dev/ttydp%d%c", j, funky_hex[n]);
 906         else                    /* SCSI */
 907           sprintf(device, "/dev/ttyd%d%d%c", i, j, funky_hex[n]);
 908
 909         if (access(device, 0) == 0)
 910         {
 911           if (i == 8)
 912             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
 913                    device, j, n);
 914           else if (i == 9)
 915             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data PCI Serial Port, ID %d, port %d\"\n",
 916                    device, j, n);
 917           else
 918             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
 919                    device, i, j, n);
 920         }
 921       }
 922 #elif defined(__sun)
 923   int           i, j, n;        /* Looping vars */
 924   char          device[255];    /* Device filename */
 925
 926
 927  /*
 928   * Standard serial ports...
 929   */
 930
 931   for (i = 0; i < 26; i ++)
 932   {
 933     sprintf(device, "/dev/cua/%c", 'a' + i);
 934     if (access(device, 0) == 0)
 935 #  ifdef B115200
 936       printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
 937              device, i + 1);
 938 #  else
 939       printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
 940              device, i + 1);
 941 #  endif /* B115200 */
 942   }
 943
 944  /*
 945   * MAGMA serial ports...
 946   */
 947
 948   for (i = 0; i < 40; i ++)
 949   {
 950     sprintf(device, "/dev/term/%02d", i);
 951     if (access(device, 0) == 0)
 952       printf("serial serial:%s?baud=38400 \"Unknown\" \"MAGMA Serial Board #%d Port #%d\"\n",
 953              device, (i / 10) + 1, (i % 10) + 1);
 954   }
 955
 956  /*
 957   * Central Data serial ports...
 958   */
 959
 960   for (i = 0; i < 9; i ++)
 961     for (j = 0; j < 8; j ++)
 962       for (n = 0; n < 32; n ++)
 963       {
 964         if (i == 8)     /* EtherLite */
 965           sprintf(device, "/dev/sts/ttyN%d%c", j, funky_hex[n]);
 966         else
 967           sprintf(device, "/dev/sts/tty%c%d%c", i + 'C', j,
 968                   funky_hex[n]);
 969
 970         if (access(device, 0) == 0)
 971         {
 972           if (i == 8)
 973             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
 974                    device, j, n);
 975           else
 976             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
 977                    device, i, j, n);
 978         }
 979       }
 980 #elif defined(__hpux)
 981   int           i, j, n;        /* Looping vars */
 982   char          device[255];    /* Device filename */
 983
 984
 985  /*
 986   * Standard serial ports...
 987   */
 988
 989   for (i = 0; i < 10; i ++)
 990   {
 991     sprintf(device, "/dev/tty%dp0", i);
 992     if (access(device, 0) == 0)
 993       printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
 994              device, i + 1);
 995   }
 996
 997  /*
 998   * Central Data serial ports...
 999   */
1000
1001   for (i = 0; i < 9; i ++)
1002     for (j = 0; j < 8; j ++)
1003       for (n = 0; n < 32; n ++)
1004       {
1005         if (i == 8)     /* EtherLite */
1006           sprintf(device, "/dev/ttyN%d%c", j, funky_hex[n]);
1007         else
1008           sprintf(device, "/dev/tty%c%d%c", i + 'C', j,
1009                   funky_hex[n]);
1010
1011         if (access(device, 0) == 0)
1012         {
1013           if (i == 8)
1014             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
1015                    device, j, n);
1016           else
1017             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
1018                    device, i, j, n);
1019         }
1020       }
1021 #elif defined(__osf__)
1022   int           i;              /* Looping var */
1023   char          device[255];    /* Device filename */
1024
1025
1026  /*
1027   * Standard serial ports...
1028   */
1029
1030   for (i = 0; i < 100; i ++)
1031   {
1032     sprintf(device, "/dev/tty%02d", i);
1033     if (access(device, 0) == 0)
1034       printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
1035              device, i + 1);
1036   }
1037 #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
1038   int   i, j;           /* Looping vars */
1039   int   fd;             /* File descriptor */
1040   char  device[255];    /* Device filename */
1041
1042
1043  /*
1044   * SIO ports...
1045   */
1046
1047   for (i = 0; i < 32; i ++)
1048   {
1049     sprintf(device, "/dev/ttyd%c", funky_hex[i]);
1050     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1051     {
1052       close(fd);
1053       printf("serial serial:%s?baud=115200 \"Unknown\" \"Standard Serial Port #%d\"\n",
1054              device, i + 1);
1055     }
1056   }
1057
1058  /*
1059   * Cyclades ports...
1060   */
1061
1062   for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
1063     for (j = 0; j < 32; j ++)
1064     {
1065       sprintf(device, "/dev/ttyc%d%c", i, funky_hex[j]);
1066       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1067       {
1068         close(fd);
1069         printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Port #%d\"\n",
1070                device, i, j + 1);
1071       }
1072
1073       sprintf(device, "/dev/ttyC%d%c", i, funky_hex[j]);
1074       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1075       {
1076         close(fd);
1077         printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Port #%d\"\n",
1078                device, i, j + 1);
1079       }
1080     }
1081
1082  /*
1083   * Digiboard ports...
1084   */
1085
1086   for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
1087     for (j = 0; j < 32; j ++)
1088     {
1089       sprintf(device, "/dev/ttyD%d%c", i, funky_hex[j]);
1090       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1091       {
1092         close(fd);
1093         printf("serial serial:%s?baud=115200 \"Unknown\" \"Digiboard #%d Serial Port #%d\"\n",
1094                device, i, j + 1);
1095       }
1096     }
1097
1098  /*
1099   * Stallion ports...
1100   */
1101
1102   for (i = 0; i < 32; i ++)
1103   {
1104     sprintf(device, "/dev/ttyE%c", funky_hex[i]);
1105     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1106     {
1107       close(fd);
1108       printf("serial serial:%s?baud=115200 \"Unknown\" \"Stallion Serial Port #%d\"\n",
1109              device, i + 1);
1110     }
1111   }
1112
1113  /*
1114   * SX ports...
1115   */
1116
1117   for (i = 0; i < 128; i ++)
1118   {
1119     sprintf(device, "/dev/ttyA%d", i + 1);
1120     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1121     {
1122       close(fd);
1123       printf("serial serial:%s?baud=115200 \"Unknown\" \"SX Serial Port #%d\"\n",
1124              device, i + 1);
1125     }
1126   }
1127 #elif defined(__NetBSD__)
1128   int   i, j;           /* Looping vars */
1129   int   fd;             /* File descriptor */
1130   char  device[255];    /* Device filename */
1131
1132
1133  /*
1134   * Standard serial ports...
1135   */
1136
1137   for (i = 0; i < 4; i ++)
1138   {
1139     sprintf(device, "/dev/tty%02d", i);
1140     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1141     {
1142       close(fd);
1143       printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
1144              device, i + 1);
1145     }
1146   }
1147
1148  /*
1149   * Cyclades-Z ports...
1150   */
1151
1152   for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
1153     for (j = 0; j < 64; j ++)
1154     {
1155       sprintf(device, "/dev/ttyCZ%02d%02d", i, j);
1156       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1157       {
1158         close(fd);
1159         printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Prt #%d\"\n",
1160                device, i, j + 1);
1161       }
1162     }
1163 #elif defined(__APPLE__)
1164  /*
1165   * Standard serial ports on MacOS X...
1166   */
1167
1168   kern_return_t                 kernResult;
1169   mach_port_t                   masterPort;
1170   io_iterator_t                 serialPortIterator;
1171   CFMutableDictionaryRef        classesToMatch;
1172   io_object_t                   serialService;
1173
1174
1175   kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort);
1176   if (KERN_SUCCESS != kernResult)
1177     return;
1178
1179  /*
1180   * Serial devices are instances of class IOSerialBSDClient.
1181   */
1182
1183   classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
1184   if (classesToMatch != NULL)
1185   {
1186     CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey),
1187                          CFSTR(kIOSerialBSDRS232Type));
1188
1189     kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
1190                                               &serialPortIterator);
1191     if (kernResult == KERN_SUCCESS)
1192     {
1193       while ((serialService = IOIteratorNext(serialPortIterator)))
1194       {
1195         CFTypeRef       serialNameAsCFString;
1196         CFTypeRef       bsdPathAsCFString;
1197         char            serialName[128];
1198         char            bsdPath[1024];
1199         Boolean         result;
1200
1201
1202         serialNameAsCFString =
1203             IORegistryEntryCreateCFProperty(serialService,
1204                                             CFSTR(kIOTTYDeviceKey),
1205                                             kCFAllocatorDefault, 0);
1206         if (serialNameAsCFString)
1207         {
1208           result = CFStringGetCString(serialNameAsCFString, serialName,
1209                                       sizeof(serialName),
1210                                       kCFStringEncodingASCII);
1211           CFRelease(serialNameAsCFString);
1212
1213           if (result)
1214           {
1215             bsdPathAsCFString =
1216                 IORegistryEntryCreateCFProperty(serialService,
1217                                                 CFSTR(kIOCalloutDeviceKey),
1218                                                 kCFAllocatorDefault, 0);
1219             if (bsdPathAsCFString)
1220             {
1221               result = CFStringGetCString(bsdPathAsCFString, bsdPath,
1222                                           sizeof(bsdPath),
1223                                           kCFStringEncodingASCII);
1224               CFRelease(bsdPathAsCFString);
1225
1226               if (result)
1227                 printf("serial serial:%s?baud=115200 \"Unknown\" \"%s\"\n",
1228                        bsdPath, serialName);
1229             }
1230           }
1231         }
1232
1233         IOObjectRelease(serialService);
1234       }
1235
1236      /*
1237       * Release the iterator.
1238       */
1239
1240       IOObjectRelease(serialPortIterator);
1241     }
1242   }
1243 #endif
1244 }
1245
1246
1247 /*
1248  * 'side_cb()' - Handle side-channel requests...
1249  */
1250
1251 static void
1252 side_cb(int print_fd,                   /* I - Print file */
1253         int device_fd,                  /* I - Device file */
1254         int use_bc)                     /* I - Using back-channel? */
1255 {
1256   cups_sc_command_t     command;        /* Request command */
1257   cups_sc_status_t      status;         /* Request/response status */
1258   char                  data[2048];     /* Request/response data */
1259   int                   datalen;        /* Request/response data size */
1260
1261
1262   datalen = sizeof(data);
1263
1264   if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
1265   {
1266     _cupsLangPuts(stderr,
1267                   _("WARNING: Failed to read side-channel request!\n"));
1268     return;
1269   }
1270
1271   switch (command)
1272   {
1273     case CUPS_SC_CMD_DRAIN_OUTPUT :
1274         if (backendDrainOutput(print_fd, device_fd))
1275           status = CUPS_SC_STATUS_IO_ERROR;
1276         else if (tcdrain(device_fd))
1277           status = CUPS_SC_STATUS_IO_ERROR;
1278         else
1279           status = CUPS_SC_STATUS_OK;
1280
1281         datalen = 0;
1282         break;
1283
1284     case CUPS_SC_CMD_GET_BIDI :
1285         data[0] = use_bc;
1286         datalen = 1;
1287         break;
1288
1289     default :
1290         status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
1291         datalen = 0;
1292         break;
1293   }
1294
1295   cupsSideChannelWrite(command, status, data, datalen, 1.0);
1296 }
1297
1298
1299 /*
1300  * End of "$Id: serial.c 7647 2008-06-16 17:39:40Z mike $".
1301  */