backend/socket.c

   1 /*
   2  * "$Id: socket.c 7881 2008-08-28 20:21:56Z mike $"
   3  *
   4  *   AppSocket backend for the Common UNIX Printing System (CUPS).
   5  *
   6  *   Copyright 2007-2011 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  *   wait_bc() - Wait for back-channel data...
  21  */
  22
  23 /*
  24  * Include necessary headers.
  25  */
  26
  27 #include <cups/http-private.h>
  28 #include "backend-private.h"
  29 #include <stdarg.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32
  33 #ifdef WIN32
  34 #  include <winsock.h>
  35 #else
  36 #  include <unistd.h>
  37 #  include <fcntl.h>
  38 #  include <sys/socket.h>
  39 #  include <netinet/in.h>
  40 #  include <arpa/inet.h>
  41 #  include <netdb.h>
  42 #endif /* WIN32 */
  43
  44
  45 /*
  46  * Local functions...
  47  */
  48
  49 static int      wait_bc(int device_fd, int secs);
  50
  51
  52 /*
  53  * 'main()' - Send a file to the printer or server.
  54  *
  55  * Usage:
  56  *
  57  *    printer-uri job-id user title copies options [file]
  58  */
  59
  60 int                                     /* O - Exit status */
  61 main(int  argc,                         /* I - Number of command-line arguments (6 or 7) */
  62      char *argv[])                      /* I - Command-line arguments */
  63 {
  64   const char    *device_uri;            /* Device URI */
  65   char          scheme[255],            /* Scheme in URI */
  66                 hostname[1024],         /* Hostname */
  67                 username[255],          /* Username info (not used) */
  68                 resource[1024],         /* Resource info (not used) */
  69                 *options,               /* Pointer to options */
  70                 *name,                  /* Name of option */
  71                 *value,                 /* Value of option */
  72                 sep;                    /* Option separator */
  73   int           print_fd;               /* Print file */
  74   int           copies;                 /* Number of copies to print */
  75   time_t        start_time;             /* Time of first connect */
  76 #ifdef __APPLE__
  77   time_t        current_time,           /* Current time */
  78                 wait_time;              /* Time to wait before shutting down socket */
  79 #endif /* __APPLE__ */
  80   int           contimeout;             /* Connection timeout */
  81   int           waiteof;                /* Wait for end-of-file? */
  82   int           port;                   /* Port number */
  83   char          portname[255];          /* Port name */
  84   int           delay;                  /* Delay for retries... */
  85   int           device_fd;              /* AppSocket */
  86   int           error;                  /* Error code (if any) */
  87   http_addrlist_t *addrlist,            /* Address list */
  88                 *addr;                  /* Connected address */
  89   char          addrname[256];          /* Address name */
  90   int           snmp_fd,                /* SNMP socket */
  91                 start_count,            /* Page count via SNMP at start */
  92                 page_count,             /* Page count via SNMP */
  93                 have_supplies;          /* Printer supports supply levels? */
  94   ssize_t       tbytes;                 /* Total number of bytes written */
  95 #if defined(HAVE_SIGACTION) && !defined(HAVE_SIGSET)
  96   struct sigaction action;              /* Actions for POSIX signals */
  97 #endif /* HAVE_SIGACTION && !HAVE_SIGSET */
  98
  99
 100  /*
 101   * Make sure status messages are not buffered...
 102   */
 103
 104   setbuf(stderr, NULL);
 105
 106  /*
 107   * Ignore SIGPIPE signals...
 108   */
 109
 110 #ifdef HAVE_SIGSET
 111   sigset(SIGPIPE, SIG_IGN);
 112 #elif defined(HAVE_SIGACTION)
 113   memset(&action, 0, sizeof(action));
 114   action.sa_handler = SIG_IGN;
 115   sigaction(SIGPIPE, &action, NULL);
 116 #else
 117   signal(SIGPIPE, SIG_IGN);
 118 #endif /* HAVE_SIGSET */
 119
 120  /*
 121   * Check command-line...
 122   */
 123
 124   if (argc == 1)
 125   {
 126     printf("network socket \"Unknown\" \"%s\"\n",
 127            _cupsLangString(cupsLangDefault(), _("AppSocket/HP JetDirect")));
 128     return (CUPS_BACKEND_OK);
 129   }
 130   else if (argc < 6 || argc > 7)
 131   {
 132     _cupsLangPrintf(stderr,
 133                     _("Usage: %s job-id user title copies options [file]"),
 134                     argv[0]);
 135     return (CUPS_BACKEND_FAILED);
 136   }
 137
 138  /*
 139   * If we have 7 arguments, print the file named on the command-line.
 140   * Otherwise, send stdin instead...
 141   */
 142
 143   if (argc == 6)
 144   {
 145     print_fd = 0;
 146     copies   = 1;
 147   }
 148   else
 149   {
 150    /*
 151     * Try to open the print file...
 152     */
 153
 154     if ((print_fd = open(argv[6], O_RDONLY)) < 0)
 155     {
 156       _cupsLangPrintError("ERROR", _("Unable to open print file"));
 157       return (CUPS_BACKEND_FAILED);
 158     }
 159
 160     copies = atoi(argv[4]);
 161   }
 162
 163  /*
 164   * Extract the hostname and port number from the URI...
 165   */
 166
 167   while ((device_uri = cupsBackendDeviceURI(argv)) == NULL)
 168   {
 169     _cupsLangPrintFilter(stderr, "INFO", _("Unable to locate printer."));
 170     sleep(10);
 171
 172     if (getenv("CLASS") != NULL)
 173       return (CUPS_BACKEND_FAILED);
 174   }
 175
 176   httpSeparateURI(HTTP_URI_CODING_ALL, device_uri, scheme, sizeof(scheme),
 177                   username, sizeof(username), hostname, sizeof(hostname), &port,
 178                   resource, sizeof(resource));
 179
 180   if (port == 0)
 181     port = 9100;        /* Default to HP JetDirect/Tektronix PhaserShare */
 182
 183  /*
 184   * Get options, if any...
 185   */
 186
 187   waiteof    = 1;
 188   contimeout = 7 * 24 * 60 * 60;
 189
 190   if ((options = strchr(resource, '?')) != NULL)
 191   {
 192    /*
 193     * Yup, terminate the device name string and move to the first
 194     * character of the options...
 195     */
 196
 197     *options++ = '\0';
 198
 199    /*
 200     * Parse options...
 201     */
 202
 203     while (*options)
 204     {
 205      /*
 206       * Get the name...
 207       */
 208
 209       name = options;
 210
 211       while (*options && *options != '=' && *options != '+' && *options != '&')
 212         options ++;
 213
 214       if ((sep = *options) != '\0')
 215         *options++ = '\0';
 216
 217       if (sep == '=')
 218       {
 219        /*
 220         * Get the value...
 221         */
 222
 223         value = options;
 224
 225         while (*options && *options != '+' && *options != '&')
 226           options ++;
 227
 228         if (*options)
 229           *options++ = '\0';
 230       }
 231       else
 232         value = (char *)"";
 233
 234      /*
 235       * Process the option...
 236       */
 237
 238       if (!strcasecmp(name, "waiteof"))
 239       {
 240        /*
 241         * Set the wait-for-eof value...
 242         */
 243
 244         waiteof = !value[0] || !strcasecmp(value, "on") ||
 245                   !strcasecmp(value, "yes") || !strcasecmp(value, "true");
 246       }
 247       else if (!strcasecmp(name, "contimeout"))
 248       {
 249        /*
 250         * Set the connection timeout...
 251         */
 252
 253         if (atoi(value) > 0)
 254           contimeout = atoi(value);
 255       }
 256     }
 257   }
 258
 259  /*
 260   * Then try finding the remote host...
 261   */
 262
 263   start_time = time(NULL);
 264
 265   sprintf(portname, "%d", port);
 266
 267   fputs("STATE: +connecting-to-device\n", stderr);
 268   fprintf(stderr, "DEBUG: Looking up \"%s\"...\n", hostname);
 269
 270   while ((addrlist = httpAddrGetList(hostname, AF_UNSPEC, portname)) == NULL)
 271   {
 272     _cupsLangPrintFilter(stderr, "INFO",
 273                          _("Unable to locate printer \"%s\"."), hostname);
 274     sleep(10);
 275
 276     if (getenv("CLASS") != NULL)
 277     {
 278       fputs("STATE: -connecting-to-device\n", stderr);
 279       return (CUPS_BACKEND_STOP);
 280     }
 281   }
 282
 283  /*
 284   * See if the printer supports SNMP...
 285   */
 286
 287   if ((snmp_fd = _cupsSNMPOpen(addrlist->addr.addr.sa_family)) >= 0)
 288   {
 289     have_supplies = !backendSNMPSupplies(snmp_fd, &(addr->addr), &start_count,
 290                                          NULL);
 291   }
 292   else
 293     have_supplies = start_count = 0;
 294
 295  /*
 296   * Wait for data from the filter...
 297   */
 298
 299   if (print_fd == 0)
 300     if (!backendWaitLoop(snmp_fd, &(addrlist->addr), backendNetworkSideCB))
 301       return (CUPS_BACKEND_OK);
 302
 303  /*
 304   * Connect to the printer...
 305   */
 306
 307   fprintf(stderr, "DEBUG: Connecting to %s:%d\n", hostname, port);
 308   _cupsLangPrintFilter(stderr, "INFO", _("Connecting to printer."));
 309
 310   for (delay = 5;;)
 311   {
 312     if ((addr = httpAddrConnect(addrlist, &device_fd)) == NULL)
 313     {
 314       error     = errno;
 315       device_fd = -1;
 316
 317       if (getenv("CLASS") != NULL)
 318       {
 319        /*
 320         * If the CLASS environment variable is set, the job was submitted
 321         * to a class and not to a specific queue.  In this case, we want
 322         * to abort immediately so that the job can be requeued on the next
 323         * available printer in the class.
 324         */
 325
 326         _cupsLangPrintFilter(stderr, "INFO",
 327                              _("Unable to contact printer, queuing on next "
 328                                "printer in class."));
 329
 330        /*
 331         * Sleep 5 seconds to keep the job from requeuing too rapidly...
 332         */
 333
 334         sleep(5);
 335
 336         return (CUPS_BACKEND_FAILED);
 337       }
 338
 339       fprintf(stderr, "DEBUG: Connection error: %s\n", strerror(error));
 340
 341       if (error == ECONNREFUSED || error == EHOSTDOWN ||
 342           error == EHOSTUNREACH)
 343       {
 344         if (contimeout && (time(NULL) - start_time) > contimeout)
 345         {
 346           _cupsLangPrintFilter(stderr, "ERROR",
 347                                _("The printer is not responding."));
 348           return (CUPS_BACKEND_FAILED);
 349         }
 350
 351         switch (error)
 352         {
 353           case EHOSTDOWN :
 354               _cupsLangPrintFilter(stderr, "WARNING",
 355                                    _("Network printer \"%s\" may not exist or "
 356                                      "is unavailable at this time."),
 357                                    hostname);
 358               break;
 359
 360           case EHOSTUNREACH :
 361               _cupsLangPrintFilter(stderr, "WARNING",
 362                                    _("Network printer \"%s\" is unreachable at "
 363                                      "this time."), hostname);
 364               break;
 365
 366           case ECONNREFUSED :
 367           default :
 368               _cupsLangPrintFilter(stderr, "WARNING",
 369                                    _("Network printer \"%s\" is busy."),
 370                                    hostname);
 371               break;
 372         }
 373
 374         sleep(delay);
 375
 376         if (delay < 30)
 377           delay += 5;
 378       }
 379       else
 380       {
 381         _cupsLangPrintFilter(stderr, "ERROR",
 382                              _("Network printer \"%s\" is not responding."),
 383                              hostname);
 384         sleep(30);
 385       }
 386     }
 387     else
 388       break;
 389   }
 390
 391   fputs("STATE: -connecting-to-device\n", stderr);
 392   _cupsLangPrintFilter(stderr, "INFO", _("Connected to printer."));
 393
 394 #ifdef AF_INET6
 395   if (addr->addr.addr.sa_family == AF_INET6)
 396     fprintf(stderr, "DEBUG: Connected to [%s]:%d (IPv6)...\n",
 397             httpAddrString(&addr->addr, addrname, sizeof(addrname)),
 398             ntohs(addr->addr.ipv6.sin6_port));
 399   else
 400 #endif /* AF_INET6 */
 401     if (addr->addr.addr.sa_family == AF_INET)
 402       fprintf(stderr, "DEBUG: Connected to %s:%d (IPv4)...\n",
 403               httpAddrString(&addr->addr, addrname, sizeof(addrname)),
 404               ntohs(addr->addr.ipv4.sin_port));
 405
 406  /*
 407   * Print everything...
 408   */
 409
 410   tbytes = 0;
 411
 412   while (copies > 0 && tbytes >= 0)
 413   {
 414     copies --;
 415
 416     if (print_fd != 0)
 417     {
 418       fputs("PAGE: 1 1\n", stderr);
 419       lseek(print_fd, 0, SEEK_SET);
 420     }
 421
 422     tbytes = backendRunLoop(print_fd, device_fd, snmp_fd, &(addr->addr), 1, 0,
 423                             backendNetworkSideCB);
 424
 425     if (print_fd != 0 && tbytes >= 0)
 426       _cupsLangPrintFilter(stderr, "INFO", _("Print file sent."));
 427   }
 428
 429 #ifdef __APPLE__
 430  /*
 431   * Wait up to 5 seconds to get any pending back-channel data...
 432   */
 433
 434   wait_time = time(NULL) + 5;
 435   while (wait_time >= time(&current_time))
 436     if (wait_bc(device_fd, wait_time - current_time) <= 0)
 437       break;
 438 #endif /* __APPLE__ */
 439
 440   if (waiteof)
 441   {
 442    /*
 443     * Shutdown the socket and wait for the other end to finish...
 444     */
 445
 446     _cupsLangPrintFilter(stderr, "INFO", _("Waiting for printer to finish."));
 447
 448     shutdown(device_fd, 1);
 449
 450     while (wait_bc(device_fd, 90) > 0);
 451   }
 452
 453  /*
 454   * Collect the final page count as needed...
 455   */
 456
 457   if (have_supplies &&
 458       !backendSNMPSupplies(snmp_fd, &(addr->addr), &page_count, NULL) &&
 459       page_count > start_count)
 460     fprintf(stderr, "PAGE: total %d\n", page_count - start_count);
 461
 462  /*
 463   * Close the socket connection...
 464   */
 465
 466   close(device_fd);
 467
 468   httpAddrFreeList(addrlist);
 469
 470  /*
 471   * Close the input file and return...
 472   */
 473
 474   if (print_fd != 0)
 475     close(print_fd);
 476
 477   _cupsLangPrintFilter(stderr, "INFO", _("Ready to print."));
 478
 479   return (CUPS_BACKEND_OK);
 480 }
 481
 482
 483 /*
 484  * 'wait_bc()' - Wait for back-channel data...
 485  */
 486
 487 static int                              /* O - # bytes read or -1 on error */
 488 wait_bc(int device_fd,                  /* I - Socket */
 489         int secs)                       /* I - Seconds to wait */
 490 {
 491   struct timeval timeout;               /* Timeout for select() */
 492   fd_set        input;                  /* Input set for select() */
 493   ssize_t       bytes;                  /* Number of back-channel bytes read */
 494   char          buffer[1024];           /* Back-channel buffer */
 495
 496
 497  /*
 498   * Wait up to "secs" seconds for backchannel data...
 499   */
 500
 501   timeout.tv_sec  = secs;
 502   timeout.tv_usec = 0;
 503
 504   FD_ZERO(&input);
 505   FD_SET(device_fd, &input);
 506
 507   if (select(device_fd + 1, &input, NULL, NULL, &timeout) > 0)
 508   {
 509    /*
 510     * Grab the data coming back and spit it out to stderr...
 511     */
 512
 513     if ((bytes = read(device_fd, buffer, sizeof(buffer))) > 0)
 514     {
 515       fprintf(stderr, "DEBUG: Received %d bytes of back-channel data\n",
 516               (int)bytes);
 517       cupsBackChannelWrite(buffer, bytes, 1.0);
 518     }
 519
 520     return (bytes);
 521   }
 522   else
 523     return (-1);
 524 }
 525
 526
 527 /*
 528  * End of "$Id: socket.c 7881 2008-08-28 20:21:56Z mike $".
 529  */