backend/socket.c

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