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