]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * "$Id$" | |
3 | * | |
4 | * Backend test program for the Common UNIX Printing System (CUPS). | |
5 | * | |
6 | * Copyright 2007-2009 by Apple Inc. | |
7 | * Copyright 1997-2005 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() - Run the named backend. | |
20 | * sigterm_handler() - Flag when we get SIGTERM. | |
21 | * usage() - Show usage information. | |
22 | * walk_cb() - Show results of cupsSideChannelSNMPWalk... | |
23 | */ | |
24 | ||
25 | /* | |
26 | * Include necessary headers. | |
27 | */ | |
28 | ||
29 | #include <stdio.h> | |
30 | #include <stdlib.h> | |
31 | #include <cups/string.h> | |
32 | #include <cups/cups.h> | |
33 | #include <cups/sidechannel.h> | |
34 | #include <unistd.h> | |
35 | #include <fcntl.h> | |
36 | #include <errno.h> | |
37 | #include <sys/wait.h> | |
38 | #include <signal.h> | |
39 | ||
40 | ||
41 | /* | |
42 | * Local globals... | |
43 | */ | |
44 | ||
45 | static int job_canceled = 0; | |
46 | ||
47 | ||
48 | /* | |
49 | * Local functions... | |
50 | */ | |
51 | ||
52 | static void sigterm_handler(int sig); | |
53 | static void usage(void); | |
54 | static void walk_cb(const char *oid, const char *data, int datalen, | |
55 | void *context); | |
56 | ||
57 | ||
58 | /* | |
59 | * 'main()' - Run the named backend. | |
60 | * | |
61 | * Usage: | |
62 | * | |
63 | * betest [-s] [-t] device-uri job-id user title copies options [file] | |
64 | */ | |
65 | ||
66 | int /* O - Exit status */ | |
67 | main(int argc, /* I - Number of command-line args */ | |
68 | char *argv[]) /* I - Command-line arguments */ | |
69 | { | |
70 | int first_arg, /* First argument for backend */ | |
71 | do_cancel = 0, /* Simulate a cancel-job via SIGTERM */ | |
72 | do_ps = 0, /* Do PostScript query+test? */ | |
73 | do_pcl = 0, /* Do PCL query+test? */ | |
74 | do_side_tests = 0, /* Test side-channel ops? */ | |
75 | do_trickle = 0, /* Trickle data to backend */ | |
76 | do_walk = 0, /* Do OID lookup (0) or walking (1) */ | |
77 | show_log = 0; /* Show log messages from backends? */ | |
78 | const char *oid = ".1.3.6.1.2.1.43.10.2.1.4.1.1"; | |
79 | /* OID to lookup or walk */ | |
80 | char scheme[255], /* Scheme in URI == backend */ | |
81 | backend[1024]; /* Backend path */ | |
82 | const char *serverbin; /* CUPS_SERVERBIN environment variable */ | |
83 | int fd, /* Temporary file descriptor */ | |
84 | back_fds[2], /* Back-channel pipe */ | |
85 | side_fds[2], /* Side-channel socket */ | |
86 | data_fds[2], /* Data pipe */ | |
87 | back_pid = -1, /* Backend process ID */ | |
88 | data_pid = -1, /* Trickle process ID */ | |
89 | pid, /* Process ID */ | |
90 | status; /* Exit status */ | |
91 | ||
92 | ||
93 | /* | |
94 | * See if we have side-channel tests to do... | |
95 | */ | |
96 | ||
97 | for (first_arg = 1; | |
98 | argv[first_arg] && argv[first_arg][0] == '-'; | |
99 | first_arg ++) | |
100 | if (!strcmp(argv[first_arg], "-d")) | |
101 | show_log = 1; | |
102 | else if (!strcmp(argv[first_arg], "-cancel")) | |
103 | do_cancel = 1; | |
104 | else if (!strcmp(argv[first_arg], "-pcl")) | |
105 | do_pcl = 1; | |
106 | else if (!strcmp(argv[first_arg], "-ps")) | |
107 | do_ps = 1; | |
108 | else if (!strcmp(argv[first_arg], "-s")) | |
109 | do_side_tests = 1; | |
110 | else if (!strcmp(argv[first_arg], "-t")) | |
111 | do_trickle = 1; | |
112 | else if (!strcmp(argv[first_arg], "-get") && (first_arg + 1) < argc) | |
113 | { | |
114 | first_arg ++; | |
115 | ||
116 | do_side_tests = 1; | |
117 | oid = argv[first_arg]; | |
118 | } | |
119 | else if (!strcmp(argv[first_arg], "-walk") && (first_arg + 1) < argc) | |
120 | { | |
121 | first_arg ++; | |
122 | ||
123 | do_side_tests = 1; | |
124 | do_walk = 1; | |
125 | oid = argv[first_arg]; | |
126 | } | |
127 | else | |
128 | usage(); | |
129 | ||
130 | argc -= first_arg; | |
131 | if (argc < 6 || argc > 7 || (argc == 7 && do_trickle)) | |
132 | usage(); | |
133 | ||
134 | /* | |
135 | * Extract the scheme from the device-uri - that's the program we want to | |
136 | * execute. | |
137 | */ | |
138 | ||
139 | if (sscanf(argv[first_arg], "%254[^:]", scheme) != 1) | |
140 | { | |
141 | fputs("testbackend: Bad device-uri - no colon!\n", stderr); | |
142 | return (1); | |
143 | } | |
144 | ||
145 | if (!access(scheme, X_OK)) | |
146 | strlcpy(backend, scheme, sizeof(backend)); | |
147 | else | |
148 | { | |
149 | if ((serverbin = getenv("CUPS_SERVERBIN")) == NULL) | |
150 | serverbin = CUPS_SERVERBIN; | |
151 | ||
152 | snprintf(backend, sizeof(backend), "%s/backend/%s", serverbin, scheme); | |
153 | if (access(backend, X_OK)) | |
154 | { | |
155 | fprintf(stderr, "testbackend: Unknown device scheme \"%s\"!\n", scheme); | |
156 | return (1); | |
157 | } | |
158 | } | |
159 | ||
160 | /* | |
161 | * Create the back-channel pipe and side-channel socket... | |
162 | */ | |
163 | ||
164 | open("/dev/null", O_WRONLY); /* Make sure fd 3 and 4 are used */ | |
165 | open("/dev/null", O_WRONLY); | |
166 | ||
167 | pipe(back_fds); | |
168 | fcntl(back_fds[0], F_SETFL, fcntl(back_fds[0], F_GETFL) | O_NONBLOCK); | |
169 | fcntl(back_fds[1], F_SETFL, fcntl(back_fds[1], F_GETFL) | O_NONBLOCK); | |
170 | ||
171 | socketpair(AF_LOCAL, SOCK_STREAM, 0, side_fds); | |
172 | fcntl(side_fds[0], F_SETFL, fcntl(side_fds[0], F_GETFL) | O_NONBLOCK); | |
173 | fcntl(side_fds[1], F_SETFL, fcntl(side_fds[1], F_GETFL) | O_NONBLOCK); | |
174 | ||
175 | /* | |
176 | * Execute the trickle process as needed... | |
177 | */ | |
178 | ||
179 | if (do_trickle || do_pcl || do_ps || do_cancel) | |
180 | { | |
181 | pipe(data_fds); | |
182 | ||
183 | signal(SIGTERM, sigterm_handler); | |
184 | ||
185 | if ((data_pid = fork()) == 0) | |
186 | { | |
187 | /* | |
188 | * Trickle/query child comes here. Rearrange file descriptors so that | |
189 | * FD 1, 3, and 4 point to the backend... | |
190 | */ | |
191 | ||
192 | if ((fd = open("/dev/null", O_RDONLY)) != 0) | |
193 | { | |
194 | dup2(fd, 0); | |
195 | close(fd); | |
196 | } | |
197 | ||
198 | if (data_fds[1] != 1) | |
199 | { | |
200 | dup2(data_fds[1], 1); | |
201 | close(data_fds[1]); | |
202 | } | |
203 | close(data_fds[0]); | |
204 | ||
205 | if (back_fds[0] != 3) | |
206 | { | |
207 | dup2(back_fds[0], 3); | |
208 | close(back_fds[0]); | |
209 | } | |
210 | close(back_fds[1]); | |
211 | ||
212 | if (side_fds[0] != 4) | |
213 | { | |
214 | dup2(side_fds[0], 4); | |
215 | close(side_fds[0]); | |
216 | } | |
217 | close(side_fds[1]); | |
218 | ||
219 | if (do_trickle) | |
220 | { | |
221 | /* | |
222 | * Write 10 spaces, 1 per second... | |
223 | */ | |
224 | ||
225 | int i; /* Looping var */ | |
226 | ||
227 | for (i = 0; i < 10; i ++) | |
228 | { | |
229 | write(1, " ", 1); | |
230 | sleep(1); | |
231 | } | |
232 | } | |
233 | else if (do_cancel) | |
234 | { | |
235 | /* | |
236 | * Write PS or PCL lines until we see SIGTERM... | |
237 | */ | |
238 | ||
239 | int line = 0, page = 0; /* Current line and page */ | |
240 | ssize_t bytes; /* Number of bytes of response data */ | |
241 | char buffer[1024]; /* Output buffer */ | |
242 | ||
243 | ||
244 | if (do_pcl) | |
245 | write(1, "\033E", 2); | |
246 | else | |
247 | write(1, "%!\n/Courier findfont 12 scalefont setfont 0 setgray\n", 52); | |
248 | ||
249 | while (!job_canceled) | |
250 | { | |
251 | if (line == 0) | |
252 | { | |
253 | page ++; | |
254 | ||
255 | if (do_pcl) | |
256 | snprintf(buffer, sizeof(buffer), "PCL Page %d\r\n\r\n", page); | |
257 | else | |
258 | snprintf(buffer, sizeof(buffer), | |
259 | "18 732 moveto (PS Page %d) show\n", page); | |
260 | ||
261 | write(1, buffer, strlen(buffer)); | |
262 | } | |
263 | ||
264 | line ++; | |
265 | ||
266 | if (do_pcl) | |
267 | snprintf(buffer, sizeof(buffer), "Line %d\r\n", line); | |
268 | else | |
269 | snprintf(buffer, sizeof(buffer), "18 %d moveto (Line %d) show\n", | |
270 | 720 - line * 12, line); | |
271 | ||
272 | write(1, buffer, strlen(buffer)); | |
273 | ||
274 | if (line >= 55) | |
275 | { | |
276 | /* | |
277 | * Eject after 55 lines... | |
278 | */ | |
279 | ||
280 | line = 0; | |
281 | if (do_pcl) | |
282 | write(1, "\014", 1); | |
283 | else | |
284 | write(1, "showpage\n", 9); | |
285 | } | |
286 | ||
287 | /* | |
288 | * Check for back-channel data... | |
289 | */ | |
290 | ||
291 | if ((bytes = cupsBackChannelRead(buffer, sizeof(buffer), 0)) > 0) | |
292 | write(2, buffer, bytes); | |
293 | ||
294 | /* | |
295 | * Throttle output to ~100hz... | |
296 | */ | |
297 | ||
298 | usleep(10000); | |
299 | } | |
300 | ||
301 | /* | |
302 | * Eject current page with info... | |
303 | */ | |
304 | ||
305 | if (do_pcl) | |
306 | snprintf(buffer, sizeof(buffer), | |
307 | "Canceled on line %d of page %d\r\n\014\033E", line, page); | |
308 | else | |
309 | snprintf(buffer, sizeof(buffer), | |
310 | "\n18 %d moveto (Canceled on line %d of page %d)\nshowpage\n", | |
311 | 720 - line * 12, line, page); | |
312 | ||
313 | write(1, buffer, strlen(buffer)); | |
314 | ||
315 | /* | |
316 | * See if we get any back-channel data... | |
317 | */ | |
318 | ||
319 | while ((bytes = cupsBackChannelRead(buffer, sizeof(buffer), 5.0)) > 0) | |
320 | write(2, buffer, bytes); | |
321 | ||
322 | exit(0); | |
323 | } | |
324 | else | |
325 | { | |
326 | /* | |
327 | * Do PS or PCL query + test pages. | |
328 | */ | |
329 | ||
330 | char buffer[1024]; /* Buffer for response data */ | |
331 | ssize_t bytes; /* Number of bytes of response data */ | |
332 | double timeout; /* Timeout */ | |
333 | const char *data; /* Data to send */ | |
334 | static const char *pcl_data = /* PCL data */ | |
335 | "\033%-12345X@PJL\r\n" | |
336 | "@PJL JOB NAME = \"Hello, World!\"\r\n" | |
337 | "@PJL INFO USTATUS\r\n" | |
338 | "@PJL ENTER LANGUAGE = PCL\r\n" | |
339 | "\033E" | |
340 | "Hello, World!\n" | |
341 | "\014" | |
342 | "\033%-12345X@PJL\r\n" | |
343 | "@PJL EOJ NAME=\"Hello, World!\"\r\n" | |
344 | "\033%-12345X"; | |
345 | static const char *ps_data = /* PostScript data */ | |
346 | "%!\n" | |
347 | "save\n" | |
348 | "product = flush\n" | |
349 | "currentpagedevice /PageSize get aload pop\n" | |
350 | "2 copy gt {exch} if\n" | |
351 | "(Unknown)\n" | |
352 | "19 dict\n" | |
353 | "dup [612 792] (Letter) put\n" | |
354 | "dup [612 1008] (Legal) put\n" | |
355 | "dup [612 935] (w612h935) put\n" | |
356 | "dup [522 756] (Executive) put\n" | |
357 | "dup [595 842] (A4) put\n" | |
358 | "dup [420 595] (A5) put\n" | |
359 | "dup [499 709] (ISOB5) put\n" | |
360 | "dup [516 728] (B5) put\n" | |
361 | "dup [612 936] (w612h936) put\n" | |
362 | "dup [284 419] (Postcard) put\n" | |
363 | "dup [419.5 567] (DoublePostcard) put\n" | |
364 | "dup [558 774] (w558h774) put\n" | |
365 | "dup [553 765] (w553h765) put\n" | |
366 | "dup [522 737] (w522h737) put\n" | |
367 | "dup [499 709] (EnvISOB5) put\n" | |
368 | "dup [297 684] (Env10) put\n" | |
369 | "dup [459 649] (EnvC5) put\n" | |
370 | "dup [312 624] (EnvDL) put\n" | |
371 | "dup [279 540] (EnvMonarch) put\n" | |
372 | "{ exch aload pop 4 index sub abs 5 le exch\n" | |
373 | " 5 index sub abs 5 le and\n" | |
374 | " {exch pop exit} {pop} ifelse\n" | |
375 | "} bind forall\n" | |
376 | "= flush pop pop\n" | |
377 | "/Courier findfont 12 scalefont setfont\n" | |
378 | "0 setgray 36 720 moveto (Hello, ) show product show (!) show\n" | |
379 | "showpage\n" | |
380 | "restore\n" | |
381 | "\004"; | |
382 | ||
383 | ||
384 | if (do_pcl) | |
385 | data = pcl_data; | |
386 | else | |
387 | data = ps_data; | |
388 | ||
389 | write(1, data, strlen(data)); | |
390 | write(2, "DEBUG: START\n", 13); | |
391 | timeout = 60.0; | |
392 | while ((bytes = cupsBackChannelRead(buffer, sizeof(buffer), | |
393 | timeout)) > 0) | |
394 | { | |
395 | write(2, buffer, bytes); | |
396 | timeout = 5.0; | |
397 | } | |
398 | write(2, "\nDEBUG: END\n", 12); | |
399 | } | |
400 | ||
401 | exit(0); | |
402 | } | |
403 | else if (data_pid < 0) | |
404 | { | |
405 | perror("testbackend: Unable to fork"); | |
406 | return (1); | |
407 | } | |
408 | } | |
409 | else | |
410 | data_fds[0] = data_fds[1] = -1; | |
411 | ||
412 | /* | |
413 | * Execute the backend... | |
414 | */ | |
415 | ||
416 | if ((back_pid = fork()) == 0) | |
417 | { | |
418 | /* | |
419 | * Child comes here... | |
420 | */ | |
421 | ||
422 | if (do_trickle || do_ps || do_pcl || do_cancel) | |
423 | { | |
424 | if (data_fds[0] != 0) | |
425 | { | |
426 | dup2(data_fds[0], 0); | |
427 | close(data_fds[0]); | |
428 | } | |
429 | close(data_fds[1]); | |
430 | } | |
431 | ||
432 | if (!show_log) | |
433 | { | |
434 | if ((fd = open("/dev/null", O_WRONLY)) != 2) | |
435 | { | |
436 | dup2(fd, 2); | |
437 | close(fd); | |
438 | } | |
439 | } | |
440 | ||
441 | if (back_fds[1] != 3) | |
442 | { | |
443 | dup2(back_fds[1], 3); | |
444 | close(back_fds[0]); | |
445 | } | |
446 | close(back_fds[1]); | |
447 | ||
448 | if (side_fds[1] != 4) | |
449 | { | |
450 | dup2(side_fds[1], 4); | |
451 | close(side_fds[0]); | |
452 | } | |
453 | close(side_fds[1]); | |
454 | ||
455 | execv(backend, argv + first_arg); | |
456 | fprintf(stderr, "testbackend: Unable to execute \"%s\": %s\n", backend, | |
457 | strerror(errno)); | |
458 | return (errno); | |
459 | } | |
460 | else if (back_pid < 0) | |
461 | { | |
462 | perror("testbackend: Unable to fork"); | |
463 | return (1); | |
464 | } | |
465 | ||
466 | /* | |
467 | * Parent comes here, setup back and side channel file descriptors... | |
468 | */ | |
469 | ||
470 | if (do_trickle || do_ps || do_pcl || do_cancel) | |
471 | { | |
472 | close(data_fds[0]); | |
473 | close(data_fds[1]); | |
474 | } | |
475 | ||
476 | if (back_fds[0] != 3) | |
477 | { | |
478 | dup2(back_fds[0], 3); | |
479 | close(back_fds[0]); | |
480 | } | |
481 | close(back_fds[1]); | |
482 | ||
483 | if (side_fds[0] != 4) | |
484 | { | |
485 | dup2(side_fds[0], 4); | |
486 | close(side_fds[0]); | |
487 | } | |
488 | close(side_fds[1]); | |
489 | ||
490 | /* | |
491 | * Do side-channel tests as needed, then wait for the backend... | |
492 | */ | |
493 | ||
494 | if (do_side_tests) | |
495 | { | |
496 | int length; /* Length of buffer */ | |
497 | char buffer[2049]; /* Buffer for reponse */ | |
498 | cups_sc_status_t scstatus; /* Status of side-channel command */ | |
499 | static const char * const statuses[] = | |
500 | { | |
501 | "CUPS_SC_STATUS_NONE", /* No status */ | |
502 | "CUPS_SC_STATUS_OK", /* Operation succeeded */ | |
503 | "CUPS_SC_STATUS_IO_ERROR", /* An I/O error occurred */ | |
504 | "CUPS_SC_STATUS_TIMEOUT", /* The backend did not respond */ | |
505 | "CUPS_SC_STATUS_NO_RESPONSE", /* The device did not respond */ | |
506 | "CUPS_SC_STATUS_BAD_MESSAGE", /* The command/response message was invalid */ | |
507 | "CUPS_SC_STATUS_TOO_BIG", /* Response too big */ | |
508 | "CUPS_SC_STATUS_NOT_IMPLEMENTED" /* Command not implemented */ | |
509 | }; | |
510 | ||
511 | ||
512 | sleep(2); | |
513 | ||
514 | length = 0; | |
515 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_DRAIN_OUTPUT, buffer, | |
516 | &length, 60.0); | |
517 | printf("CUPS_SC_CMD_DRAIN_OUTPUT returned %s\n", statuses[scstatus]); | |
518 | ||
519 | length = 1; | |
520 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_GET_BIDI, buffer, | |
521 | &length, 5.0); | |
522 | printf("CUPS_SC_CMD_GET_BIDI returned %s, %d\n", statuses[scstatus], buffer[0]); | |
523 | ||
524 | length = sizeof(buffer) - 1; | |
525 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_GET_DEVICE_ID, buffer, | |
526 | &length, 5.0); | |
527 | buffer[length] = '\0'; | |
528 | printf("CUPS_SC_CMD_GET_DEVICE_ID returned %s, \"%s\"\n", | |
529 | statuses[scstatus], buffer); | |
530 | ||
531 | length = 1; | |
532 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_GET_STATE, buffer, | |
533 | &length, 5.0); | |
534 | printf("CUPS_SC_CMD_GET_STATE returned %s, %02X\n", statuses[scstatus], | |
535 | buffer[0] & 255); | |
536 | ||
537 | if (do_walk) | |
538 | { | |
539 | /* | |
540 | * Walk the OID tree... | |
541 | */ | |
542 | ||
543 | scstatus = cupsSideChannelSNMPWalk(oid, 5.0, walk_cb, NULL); | |
544 | printf("CUPS_SC_CMD_SNMP_WALK returned %s\n", statuses[scstatus]); | |
545 | } | |
546 | else | |
547 | { | |
548 | /* | |
549 | * Lookup the same OID twice... | |
550 | */ | |
551 | ||
552 | length = sizeof(buffer); | |
553 | scstatus = cupsSideChannelSNMPGet(oid, buffer, &length, 5.0); | |
554 | printf("CUPS_SC_CMD_SNMP_GET %s returned %s, %s\n", oid, | |
555 | statuses[scstatus], buffer); | |
556 | ||
557 | length = sizeof(buffer); | |
558 | scstatus = cupsSideChannelSNMPGet(oid, buffer, &length, 5.0); | |
559 | printf("CUPS_SC_CMD_SNMP_GET %s returned %s, %s\n", oid, | |
560 | statuses[scstatus], buffer); | |
561 | } | |
562 | ||
563 | length = 0; | |
564 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_SOFT_RESET, buffer, | |
565 | &length, 5.0); | |
566 | printf("CUPS_SC_CMD_SOFT_RESET returned %s\n", statuses[scstatus]); | |
567 | } | |
568 | ||
569 | if (do_cancel) | |
570 | { | |
571 | sleep(1); | |
572 | kill(data_pid, SIGTERM); | |
573 | kill(back_pid, SIGTERM); | |
574 | } | |
575 | ||
576 | while ((pid = wait(&status)) > 0) | |
577 | { | |
578 | if (status) | |
579 | { | |
580 | if (WIFEXITED(status)) | |
581 | printf("%s exited with status %d!\n", | |
582 | pid == back_pid ? backend : "test", | |
583 | WEXITSTATUS(status)); | |
584 | else | |
585 | printf("%s crashed with signal %d!\n", | |
586 | pid == back_pid ? backend : "test", | |
587 | WTERMSIG(status)); | |
588 | } | |
589 | } | |
590 | ||
591 | /* | |
592 | * Exit accordingly... | |
593 | */ | |
594 | ||
595 | return (status != 0); | |
596 | } | |
597 | ||
598 | ||
599 | /* | |
600 | * 'sigterm_handler()' - Flag when we get SIGTERM. | |
601 | */ | |
602 | ||
603 | static void | |
604 | sigterm_handler(int sig) /* I - Signal */ | |
605 | { | |
606 | (void)sig; | |
607 | ||
608 | job_canceled = 1; | |
609 | } | |
610 | ||
611 | ||
612 | /* | |
613 | * 'usage()' - Show usage information. | |
614 | */ | |
615 | ||
616 | static void | |
617 | usage(void) | |
618 | { | |
619 | puts("Usage: testbackend [-cancel] [-d] [-ps | -pcl] [-s [-oid OID] " | |
620 | "[-walk OID]] [-t] device-uri job-id user title copies options [file]"); | |
621 | puts(""); | |
622 | puts("Options:"); | |
623 | puts(" -cancel Simulate a canceled print job after 2 seconds."); | |
624 | puts(" -d Show log messages from backend."); | |
625 | puts(" -oid OID Lookup the specified SNMP OID."); | |
626 | puts(" (.1.3.6.1.2.1.43.10.2.1.4.1.1 is a good one for printers)"); | |
627 | puts(" -pcl Send PCL+PJL query and test page to backend."); | |
628 | puts(" -ps Send PostScript query and test page to backend."); | |
629 | puts(" -s Do side-channel + SNMP tests."); | |
630 | puts(" -t Send spaces slowly to backend ('trickle')."); | |
631 | puts(" -walk OID Walk the specified SNMP OID."); | |
632 | puts(" (.1.3.6.1.2.1.43 is a good one for printers)"); | |
633 | ||
634 | exit(1); | |
635 | } | |
636 | ||
637 | ||
638 | /* | |
639 | * 'walk_cb()' - Show results of cupsSideChannelSNMPWalk... | |
640 | */ | |
641 | ||
642 | static void | |
643 | walk_cb(const char *oid, /* I - OID */ | |
644 | const char *data, /* I - Data */ | |
645 | int datalen, /* I - Length of data */ | |
646 | void *context) /* I - Context (unused) */ | |
647 | { | |
648 | printf("CUPS_SC_CMD_SNMP_WALK %s=%s (%d bytes)\n", oid, data, datalen); | |
649 | } | |
650 | ||
651 | ||
652 | /* | |
653 | * End of "$Id$". | |
654 | */ |