backend/serial.c

   1 /*
   2  * "$Id: serial.c 6910 2007-09-04 20:34:29Z 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       FD_SET(CUPS_SC_FD, &input);
 562
 563       FD_ZERO(&output);
 564       if (print_bytes)
 565         FD_SET(device_fd, &output);
 566
 567       if (select(nfds, &input, &output, NULL, NULL) < 0)
 568         continue;                       /* Ignore errors here */
 569
 570      /*
 571       * Check if we have a side-channel request ready...
 572       */
 573
 574       if (FD_ISSET(CUPS_SC_FD, &input))
 575         side_cb(print_fd, device_fd, 1);
 576
 577      /*
 578       * Check if we have back-channel data ready...
 579       */
 580
 581       if (FD_ISSET(device_fd, &input))
 582       {
 583         if ((bc_bytes = read(device_fd, bc_buffer, sizeof(bc_buffer))) > 0)
 584         {
 585           fprintf(stderr,
 586                   "DEBUG: Received " CUPS_LLFMT " bytes of back-channel data!\n",
 587                   CUPS_LLCAST bc_bytes);
 588           cupsBackChannelWrite(bc_buffer, bc_bytes, 1.0);
 589         }
 590       }
 591
 592      /*
 593       * Check if we have print data ready...
 594       */
 595
 596       if (FD_ISSET(print_fd, &input))
 597       {
 598         if ((print_bytes = read(print_fd, print_buffer, print_size)) < 0)
 599         {
 600          /*
 601           * Read error - bail if we don't see EAGAIN or EINTR...
 602           */
 603
 604           if (errno != EAGAIN || errno != EINTR)
 605           {
 606             _cupsLangPrintError(_("ERROR: Unable to read print data"));
 607
 608             tcsetattr(device_fd, TCSADRAIN, &origopts);
 609
 610             close(device_fd);
 611
 612             if (print_fd != 0)
 613               close(print_fd);
 614
 615             return (CUPS_BACKEND_FAILED);
 616           }
 617
 618           print_bytes = 0;
 619         }
 620         else if (print_bytes == 0)
 621         {
 622          /*
 623           * End of file, break out of the loop...
 624           */
 625
 626           break;
 627         }
 628
 629         print_ptr = print_buffer;
 630       }
 631
 632      /*
 633       * Check if the device is ready to receive data and we have data to
 634       * send...
 635       */
 636
 637       if (print_bytes && FD_ISSET(device_fd, &output))
 638       {
 639         if (dtrdsr)
 640         {
 641          /*
 642           * Check the port and sleep until DSR is set...
 643           */
 644
 645           int status;
 646
 647
 648           if (!ioctl(device_fd, TIOCMGET, &status))
 649             if (!(status & TIOCM_DSR))
 650             {
 651              /*
 652               * Wait for DSR to go high...
 653               */
 654
 655               fputs("DEBUG: DSR is low; waiting for device...\n", stderr);
 656
 657               do
 658               {
 659                /*
 660                 * Poll every 100ms...
 661                 */
 662
 663                 usleep(100000);
 664
 665                 if (ioctl(device_fd, TIOCMGET, &status))
 666                   break;
 667               }
 668               while (!(status & TIOCM_DSR));
 669
 670               fputs("DEBUG: DSR is high; writing to device...\n", stderr);
 671             }
 672         }
 673
 674         if ((bytes = write(device_fd, print_ptr, print_bytes)) < 0)
 675         {
 676          /*
 677           * Write error - bail if we don't see an error we can retry...
 678           */
 679
 680           if (errno != EAGAIN && errno != EINTR && errno != ENOTTY)
 681           {
 682             _cupsLangPrintError(_("ERROR: Unable to write print data"));
 683
 684             tcsetattr(device_fd, TCSADRAIN, &origopts);
 685
 686             close(device_fd);
 687
 688             if (print_fd != 0)
 689               close(print_fd);
 690
 691             return (CUPS_BACKEND_FAILED);
 692           }
 693         }
 694         else
 695         {
 696           fprintf(stderr, "DEBUG: Wrote %d bytes...\n", (int)bytes);
 697
 698           print_bytes -= bytes;
 699           print_ptr   += bytes;
 700           total_bytes += bytes;
 701         }
 702       }
 703     }
 704   }
 705
 706  /*
 707   * Close the serial port and input file and return...
 708   */
 709
 710   tcsetattr(device_fd, TCSADRAIN, &origopts);
 711
 712   close(device_fd);
 713
 714   if (print_fd != 0)
 715     close(print_fd);
 716
 717   return (total_bytes < 0 ? CUPS_BACKEND_FAILED : CUPS_BACKEND_OK);
 718 }
 719
 720
 721 /*
 722  * 'list_devices()' - List all serial devices.
 723  */
 724
 725 static void
 726 list_devices(void)
 727 {
 728 #if defined(__hpux) || defined(__sgi) || defined(__sun) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
 729   static char   *funky_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
 730                                         /* Funky hex numbering used for some *
 731                                          * devices                           */
 732 #endif /* __hpux || __sgi || __sun || __FreeBSD__ || __OpenBSD__ || __FreeBSD_kernel__ */
 733
 734 #ifdef __linux
 735   int                   i, j;           /* Looping vars */
 736   int                   fd;             /* File descriptor */
 737   char                  device[255];    /* Device filename */
 738 #  ifdef TIOCGSERIAL
 739   struct serial_struct  serinfo;        /* serial port info */
 740 #  endif /* TIOCGSERIAL */
 741
 742
 743   for (i = 0; i < 100; i ++)
 744   {
 745     sprintf(device, "/dev/ttyS%d", i);
 746
 747     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 748     {
 749 #  ifdef TIOCGSERIAL
 750      /*
 751       * See if this port exists...
 752       */
 753
 754       serinfo.reserved_char[0] = 0;
 755
 756       if (!ioctl(fd, TIOCGSERIAL, &serinfo))
 757       {
 758         if (serinfo.type == PORT_UNKNOWN)
 759         {
 760          /*
 761           * Nope...
 762           */
 763
 764           close(fd);
 765           continue;
 766         }
 767       }
 768 #  endif /* TIOCGSERIAL */
 769
 770       close(fd);
 771
 772 #  if defined(_ARCH_PPC) || defined(powerpc) || defined(__powerpc)
 773       printf("serial serial:%s?baud=230400 \"Unknown\" \"Serial Port #%d\"\n",
 774              device, i + 1);
 775 #  else
 776       printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
 777              device, i + 1);
 778 #  endif /* _ARCH_PPC || powerpc || __powerpc */
 779     }
 780   }
 781
 782   for (i = 0; i < 16; i ++)
 783   {
 784     sprintf(device, "/dev/usb/ttyUSB%d", i);
 785     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 786     {
 787       close(fd);
 788       printf("serial serial:%s?baud=230400 \"Unknown\" \"USB Serial Port #%d\"\n",
 789              device, i + 1);
 790     }
 791
 792     sprintf(device, "/dev/ttyUSB%d", i);
 793     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 794     {
 795       close(fd);
 796       printf("serial serial:%s?baud=230400 \"Unknown\" \"USB Serial Port #%d\"\n",
 797              device, i + 1);
 798     }
 799   }
 800
 801   for (i = 0; i < 64; i ++)
 802   {
 803     for (j = 0; j < 8; j ++)
 804     {
 805       sprintf(device, "/dev/ttyQ%02de%d", i, j);
 806       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
 807       {
 808         close(fd);
 809         printf("serial serial:%s?baud=115200 \"Unknown\" "
 810                "\"Equinox ESP %d Port #%d\"\n",
 811                device, i, j + 1);
 812       }
 813     }
 814   }
 815 #elif defined(__sgi)
 816   int           i, j, n;        /* Looping vars */
 817   char          device[255];    /* Device filename */
 818   inventory_t   *inv;           /* Hardware inventory info */
 819
 820
 821  /*
 822   * IRIX maintains a hardware inventory of most devices...
 823   */
 824
 825   setinvent();
 826
 827   while ((inv = getinvent()) != NULL)
 828   {
 829     if (inv->inv_class == INV_SERIAL)
 830     {
 831      /*
 832       * Some sort of serial port...
 833       */
 834
 835       if (inv->inv_type == INV_CDSIO || inv->inv_type == INV_CDSIO_E)
 836       {
 837        /*
 838         * CDSIO port...
 839         */
 840
 841         for (n = 0; n < 6; n ++)
 842           printf("serial serial:/dev/ttyd%d?baud=38400 \"Unknown\" \"CDSIO Board %d Serial Port #%d\"\n",
 843                  n + 5 + 8 * inv->inv_controller, inv->inv_controller, n + 1);
 844       }
 845       else if (inv->inv_type == INV_EPC_SERIAL)
 846       {
 847        /*
 848         * Everest serial port...
 849         */
 850
 851         if (inv->inv_unit == 0)
 852           i = 1;
 853         else
 854           i = 41 + 4 * (int)inv->inv_controller;
 855
 856         for (n = 0; n < (int)inv->inv_state; n ++)
 857           printf("serial serial:/dev/ttyd%d?baud=38400 \"Unknown\" \"EPC Serial Port %d, Ebus slot %d\"\n",
 858                  n + i, n + 1, (int)inv->inv_controller);
 859       }
 860       else if (inv->inv_state > 1)
 861       {
 862        /*
 863         * Standard serial port under IRIX 6.4 and earlier...
 864         */
 865
 866         for (n = 0; n < (int)inv->inv_state; n ++)
 867           printf("serial serial:/dev/ttyd%d?baud=38400 \"Unknown\" \"Onboard Serial Port %d\"\n",
 868                  n + (int)inv->inv_unit + 1, n + (int)inv->inv_unit + 1);
 869       }
 870       else
 871       {
 872        /*
 873         * Standard serial port under IRIX 6.5 and beyond...
 874         */
 875
 876         printf("serial serial:/dev/ttyd%d?baud=115200 \"Unknown\" \"Onboard Serial Port %d\"\n",
 877                (int)inv->inv_controller, (int)inv->inv_controller);
 878       }
 879     }
 880   }
 881
 882   endinvent();
 883
 884  /*
 885   * Central Data makes serial and parallel "servers" that can be
 886   * connected in a number of ways.  Look for ports...
 887   */
 888
 889   for (i = 0; i < 10; i ++)
 890     for (j = 0; j < 8; j ++)
 891       for (n = 0; n < 32; n ++)
 892       {
 893         if (i == 8)             /* EtherLite */
 894           sprintf(device, "/dev/ttydn%d%c", j, funky_hex[n]);
 895         else if (i == 9)        /* PCI */
 896           sprintf(device, "/dev/ttydp%d%c", j, funky_hex[n]);
 897         else                    /* SCSI */
 898           sprintf(device, "/dev/ttyd%d%d%c", i, j, funky_hex[n]);
 899
 900         if (access(device, 0) == 0)
 901         {
 902           if (i == 8)
 903             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
 904                    device, j, n);
 905           else if (i == 9)
 906             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data PCI Serial Port, ID %d, port %d\"\n",
 907                    device, j, n);
 908           else
 909             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
 910                    device, i, j, n);
 911         }
 912       }
 913 #elif defined(__sun)
 914   int           i, j, n;        /* Looping vars */
 915   char          device[255];    /* Device filename */
 916
 917
 918  /*
 919   * Standard serial ports...
 920   */
 921
 922   for (i = 0; i < 26; i ++)
 923   {
 924     sprintf(device, "/dev/cua/%c", 'a' + i);
 925     if (access(device, 0) == 0)
 926 #  ifdef B115200
 927       printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
 928              device, i + 1);
 929 #  else
 930       printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
 931              device, i + 1);
 932 #  endif /* B115200 */
 933   }
 934
 935  /*
 936   * MAGMA serial ports...
 937   */
 938
 939   for (i = 0; i < 40; i ++)
 940   {
 941     sprintf(device, "/dev/term/%02d", i);
 942     if (access(device, 0) == 0)
 943       printf("serial serial:%s?baud=38400 \"Unknown\" \"MAGMA Serial Board #%d Port #%d\"\n",
 944              device, (i / 10) + 1, (i % 10) + 1);
 945   }
 946
 947  /*
 948   * Central Data serial ports...
 949   */
 950
 951   for (i = 0; i < 9; i ++)
 952     for (j = 0; j < 8; j ++)
 953       for (n = 0; n < 32; n ++)
 954       {
 955         if (i == 8)     /* EtherLite */
 956           sprintf(device, "/dev/sts/ttyN%d%c", j, funky_hex[n]);
 957         else
 958           sprintf(device, "/dev/sts/tty%c%d%c", i + 'C', j,
 959                   funky_hex[n]);
 960
 961         if (access(device, 0) == 0)
 962         {
 963           if (i == 8)
 964             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
 965                    device, j, n);
 966           else
 967             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
 968                    device, i, j, n);
 969         }
 970       }
 971 #elif defined(__hpux)
 972   int           i, j, n;        /* Looping vars */
 973   char          device[255];    /* Device filename */
 974
 975
 976  /*
 977   * Standard serial ports...
 978   */
 979
 980   for (i = 0; i < 10; i ++)
 981   {
 982     sprintf(device, "/dev/tty%dp0", i);
 983     if (access(device, 0) == 0)
 984       printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
 985              device, i + 1);
 986   }
 987
 988  /*
 989   * Central Data serial ports...
 990   */
 991
 992   for (i = 0; i < 9; i ++)
 993     for (j = 0; j < 8; j ++)
 994       for (n = 0; n < 32; n ++)
 995       {
 996         if (i == 8)     /* EtherLite */
 997           sprintf(device, "/dev/ttyN%d%c", j, funky_hex[n]);
 998         else
 999           sprintf(device, "/dev/tty%c%d%c", i + 'C', j,
1000                   funky_hex[n]);
1001
1002         if (access(device, 0) == 0)
1003         {
1004           if (i == 8)
1005             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data EtherLite Serial Port, ID %d, port %d\"\n",
1006                    device, j, n);
1007           else
1008             printf("serial serial:%s?baud=38400 \"Unknown\" \"Central Data SCSI Serial Port, logical bus %d, ID %d, port %d\"\n",
1009                    device, i, j, n);
1010         }
1011       }
1012 #elif defined(__osf__)
1013   int           i;              /* Looping var */
1014   char          device[255];    /* Device filename */
1015
1016
1017  /*
1018   * Standard serial ports...
1019   */
1020
1021   for (i = 0; i < 100; i ++)
1022   {
1023     sprintf(device, "/dev/tty%02d", i);
1024     if (access(device, 0) == 0)
1025       printf("serial serial:%s?baud=38400 \"Unknown\" \"Serial Port #%d\"\n",
1026              device, i + 1);
1027   }
1028 #elif defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__FreeBSD_kernel__)
1029   int   i, j;           /* Looping vars */
1030   int   fd;             /* File descriptor */
1031   char  device[255];    /* Device filename */
1032
1033
1034  /*
1035   * SIO ports...
1036   */
1037
1038   for (i = 0; i < 32; i ++)
1039   {
1040     sprintf(device, "/dev/ttyd%c", funky_hex[i]);
1041     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1042     {
1043       close(fd);
1044       printf("serial serial:%s?baud=115200 \"Unknown\" \"Standard Serial Port #%d\"\n",
1045              device, i + 1);
1046     }
1047   }
1048
1049  /*
1050   * Cyclades ports...
1051   */
1052
1053   for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
1054     for (j = 0; j < 32; j ++)
1055     {
1056       sprintf(device, "/dev/ttyc%d%c", i, funky_hex[j]);
1057       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1058       {
1059         close(fd);
1060         printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Port #%d\"\n",
1061                device, i, j + 1);
1062       }
1063
1064       sprintf(device, "/dev/ttyC%d%c", i, funky_hex[j]);
1065       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1066       {
1067         close(fd);
1068         printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Port #%d\"\n",
1069                device, i, j + 1);
1070       }
1071     }
1072
1073  /*
1074   * Digiboard ports...
1075   */
1076
1077   for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
1078     for (j = 0; j < 32; j ++)
1079     {
1080       sprintf(device, "/dev/ttyD%d%c", i, funky_hex[j]);
1081       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1082       {
1083         close(fd);
1084         printf("serial serial:%s?baud=115200 \"Unknown\" \"Digiboard #%d Serial Port #%d\"\n",
1085                device, i, j + 1);
1086       }
1087     }
1088
1089  /*
1090   * Stallion ports...
1091   */
1092
1093   for (i = 0; i < 32; i ++)
1094   {
1095     sprintf(device, "/dev/ttyE%c", funky_hex[i]);
1096     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1097     {
1098       close(fd);
1099       printf("serial serial:%s?baud=115200 \"Unknown\" \"Stallion Serial Port #%d\"\n",
1100              device, i + 1);
1101     }
1102   }
1103
1104  /*
1105   * SX ports...
1106   */
1107
1108   for (i = 0; i < 128; i ++)
1109   {
1110     sprintf(device, "/dev/ttyA%d", i + 1);
1111     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1112     {
1113       close(fd);
1114       printf("serial serial:%s?baud=115200 \"Unknown\" \"SX Serial Port #%d\"\n",
1115              device, i + 1);
1116     }
1117   }
1118 #elif defined(__NetBSD__)
1119   int   i, j;           /* Looping vars */
1120   int   fd;             /* File descriptor */
1121   char  device[255];    /* Device filename */
1122
1123
1124  /*
1125   * Standard serial ports...
1126   */
1127
1128   for (i = 0; i < 4; i ++)
1129   {
1130     sprintf(device, "/dev/tty%02d", i);
1131     if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1132     {
1133       close(fd);
1134       printf("serial serial:%s?baud=115200 \"Unknown\" \"Serial Port #%d\"\n",
1135              device, i + 1);
1136     }
1137   }
1138
1139  /*
1140   * Cyclades-Z ports...
1141   */
1142
1143   for (i = 0; i < 16; i ++) /* Should be up to 65536 boards... */
1144     for (j = 0; j < 64; j ++)
1145     {
1146       sprintf(device, "/dev/ttyCZ%02d%02d", i, j);
1147       if ((fd = open(device, O_WRONLY | O_NOCTTY | O_NDELAY)) >= 0)
1148       {
1149         close(fd);
1150         printf("serial serial:%s?baud=115200 \"Unknown\" \"Cyclades #%d Serial Prt #%d\"\n",
1151                device, i, j + 1);
1152       }
1153     }
1154 #elif defined(__APPLE__)
1155  /*
1156   * Standard serial ports on MacOS X...
1157   */
1158
1159   kern_return_t                 kernResult;
1160   mach_port_t                   masterPort;
1161   io_iterator_t                 serialPortIterator;
1162   CFMutableDictionaryRef        classesToMatch;
1163   io_object_t                   serialService;
1164
1165
1166   kernResult = IOMasterPort(MACH_PORT_NULL, &masterPort);
1167   if (KERN_SUCCESS != kernResult)
1168     return;
1169
1170  /*
1171   * Serial devices are instances of class IOSerialBSDClient.
1172   */
1173
1174   classesToMatch = IOServiceMatching(kIOSerialBSDServiceValue);
1175   if (classesToMatch != NULL)
1176   {
1177     CFDictionarySetValue(classesToMatch, CFSTR(kIOSerialBSDTypeKey),
1178                          CFSTR(kIOSerialBSDRS232Type));
1179
1180     kernResult = IOServiceGetMatchingServices(masterPort, classesToMatch,
1181                                               &serialPortIterator);
1182     if (kernResult == KERN_SUCCESS)
1183     {
1184       while ((serialService = IOIteratorNext(serialPortIterator)))
1185       {
1186         CFTypeRef       serialNameAsCFString;
1187         CFTypeRef       bsdPathAsCFString;
1188         char            serialName[128];
1189         char            bsdPath[1024];
1190         Boolean         result;
1191
1192
1193         serialNameAsCFString =
1194             IORegistryEntryCreateCFProperty(serialService,
1195                                             CFSTR(kIOTTYDeviceKey),
1196                                             kCFAllocatorDefault, 0);
1197         if (serialNameAsCFString)
1198         {
1199           result = CFStringGetCString(serialNameAsCFString, serialName,
1200                                       sizeof(serialName),
1201                                       kCFStringEncodingASCII);
1202           CFRelease(serialNameAsCFString);
1203
1204           if (result)
1205           {
1206             bsdPathAsCFString =
1207                 IORegistryEntryCreateCFProperty(serialService,
1208                                                 CFSTR(kIOCalloutDeviceKey),
1209                                                 kCFAllocatorDefault, 0);
1210             if (bsdPathAsCFString)
1211             {
1212               result = CFStringGetCString(bsdPathAsCFString, bsdPath,
1213                                           sizeof(bsdPath),
1214                                           kCFStringEncodingASCII);
1215               CFRelease(bsdPathAsCFString);
1216
1217               if (result)
1218                 printf("serial serial:%s?baud=115200 \"Unknown\" \"%s\"\n",
1219                        bsdPath, serialName);
1220             }
1221           }
1222         }
1223
1224         IOObjectRelease(serialService);
1225       }
1226
1227      /*
1228       * Release the iterator.
1229       */
1230
1231       IOObjectRelease(serialPortIterator);
1232     }
1233   }
1234 #endif
1235 }
1236
1237
1238 /*
1239  * 'side_cb()' - Handle side-channel requests...
1240  */
1241
1242 static void
1243 side_cb(int print_fd,                   /* I - Print file */
1244         int device_fd,                  /* I - Device file */
1245         int use_bc)                     /* I - Using back-channel? */
1246 {
1247   cups_sc_command_t     command;        /* Request command */
1248   cups_sc_status_t      status;         /* Request/response status */
1249   char                  data[2048];     /* Request/response data */
1250   int                   datalen;        /* Request/response data size */
1251
1252
1253   datalen = sizeof(data);
1254
1255   if (cupsSideChannelRead(&command, &status, data, &datalen, 1.0))
1256   {
1257     _cupsLangPuts(stderr,
1258                   _("WARNING: Failed to read side-channel request!\n"));
1259     return;
1260   }
1261
1262   switch (command)
1263   {
1264     case CUPS_SC_CMD_DRAIN_OUTPUT :
1265         if (backendDrainOutput(print_fd, device_fd))
1266           status = CUPS_SC_STATUS_IO_ERROR;
1267         else if (tcdrain(device_fd))
1268           status = CUPS_SC_STATUS_IO_ERROR;
1269         else
1270           status = CUPS_SC_STATUS_OK;
1271
1272         datalen = 0;
1273         break;
1274
1275     case CUPS_SC_CMD_GET_BIDI :
1276         data[0] = use_bc;
1277         datalen = 1;
1278         break;
1279
1280     default :
1281         status  = CUPS_SC_STATUS_NOT_IMPLEMENTED;
1282         datalen = 0;
1283         break;
1284   }
1285
1286   cupsSideChannelWrite(command, status, data, datalen, 1.0);
1287 }
1288
1289
1290 /*
1291  * End of "$Id: serial.c 6910 2007-09-04 20:34:29Z mike $".
1292  */