4e2dac1463304a7d039aaff72d595e2714ec721e
[thirdparty/cups.git] / 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  */