]>
Commit | Line | Data |
---|---|---|
568fa3fa MS |
1 | /* |
2 | * "$Id$" | |
3 | * | |
4 | * Backend test program for the Common UNIX Printing System (CUPS). | |
5 | * | |
6 | * Copyright 2007-2008 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 | * usage() - Show usage information. | |
21 | */ | |
22 | ||
23 | /* | |
24 | * Include necessary headers. | |
25 | */ | |
26 | ||
27 | #include <stdio.h> | |
28 | #include <stdlib.h> | |
29 | #include <cups/string.h> | |
30 | #include <cups/cups.h> | |
31 | #include <cups/sidechannel.h> | |
32 | #include <unistd.h> | |
33 | #include <fcntl.h> | |
34 | #include <errno.h> | |
35 | #include <sys/wait.h> | |
36 | ||
37 | ||
38 | /* | |
39 | * Local functions... | |
40 | */ | |
41 | ||
42 | static void usage(void); | |
43 | ||
44 | ||
45 | /* | |
46 | * 'main()' - Run the named backend. | |
47 | * | |
48 | * Usage: | |
49 | * | |
50 | * betest [-s] [-t] device-uri job-id user title copies options [file] | |
51 | */ | |
52 | ||
53 | int /* O - Exit status */ | |
54 | main(int argc, /* I - Number of command-line args */ | |
55 | char *argv[]) /* I - Command-line arguments */ | |
56 | { | |
57 | int first_arg, /* First argument for backend */ | |
58 | do_side_tests = 0, /* Test side-channel ops? */ | |
59 | do_trickle = 0; /* Trickle data to backend */ | |
60 | char scheme[255], /* Scheme in URI == backend */ | |
61 | backend[1024]; /* Backend path */ | |
62 | const char *serverbin; /* CUPS_SERVERBIN environment variable */ | |
63 | int back_fds[2], /* Back-channel pipe */ | |
64 | side_fds[2], /* Side-channel socket */ | |
65 | data_fds[2], /* Data pipe */ | |
66 | pid, /* Process ID */ | |
67 | status; /* Exit status */ | |
68 | ||
69 | ||
70 | /* | |
71 | * See if we have side-channel tests to do... | |
72 | */ | |
73 | ||
74 | for (first_arg = 1; | |
75 | argv[first_arg] && argv[first_arg][0] == '-'; | |
76 | first_arg ++) | |
77 | if (!strcmp(argv[first_arg], "-s")) | |
78 | do_side_tests = 1; | |
79 | else if (!strcmp(argv[first_arg], "-t")) | |
80 | do_trickle = 1; | |
81 | else | |
82 | usage(); | |
83 | ||
84 | argc -= first_arg; | |
85 | if (argc < 6 || argc > 7 || (argc == 7 && do_trickle)) | |
86 | usage(); | |
87 | ||
88 | /* | |
89 | * Extract the scheme from the device-uri - that's the program we want to | |
90 | * execute. | |
91 | */ | |
92 | ||
93 | if (sscanf(argv[first_arg], "%254[^:]", scheme) != 1) | |
94 | { | |
95 | fputs("testbackend: Bad device-uri - no colon!\n", stderr); | |
96 | return (1); | |
97 | } | |
98 | ||
99 | if (!access(scheme, X_OK)) | |
100 | strlcpy(backend, scheme, sizeof(backend)); | |
101 | else | |
102 | { | |
103 | if ((serverbin = getenv("CUPS_SERVERBIN")) == NULL) | |
104 | serverbin = CUPS_SERVERBIN; | |
105 | ||
106 | snprintf(backend, sizeof(backend), "%s/backend/%s", serverbin, scheme); | |
107 | if (access(backend, X_OK)) | |
108 | { | |
109 | fprintf(stderr, "testbackend: Unknown device scheme \"%s\"!\n", scheme); | |
110 | return (1); | |
111 | } | |
112 | } | |
113 | ||
114 | /* | |
115 | * Create the back-channel pipe and side-channel socket... | |
116 | */ | |
117 | ||
118 | open("/dev/null", O_WRONLY); /* Make sure fd 3 and 4 are used */ | |
119 | open("/dev/null", O_WRONLY); | |
120 | ||
121 | pipe(back_fds); | |
122 | fcntl(back_fds[0], F_SETFL, fcntl(back_fds[0], F_GETFL) | O_NONBLOCK); | |
123 | fcntl(back_fds[1], F_SETFL, fcntl(back_fds[1], F_GETFL) | O_NONBLOCK); | |
124 | ||
125 | socketpair(AF_LOCAL, SOCK_STREAM, 0, side_fds); | |
126 | fcntl(side_fds[0], F_SETFL, fcntl(side_fds[0], F_GETFL) | O_NONBLOCK); | |
127 | fcntl(side_fds[1], F_SETFL, fcntl(side_fds[1], F_GETFL) | O_NONBLOCK); | |
128 | ||
129 | /* | |
130 | * Execute the trickle process as needed... | |
131 | */ | |
132 | ||
133 | if (do_trickle) | |
134 | { | |
135 | pipe(data_fds); | |
136 | ||
137 | if ((pid = fork()) == 0) | |
138 | { | |
139 | /* | |
140 | * Trickle child comes here... | |
141 | */ | |
142 | ||
143 | int i; /* Looping var */ | |
144 | ||
145 | close(data_fds[0]); | |
146 | for (i = 0; i < 10; i ++) | |
147 | { | |
148 | /* | |
149 | * Write 10 spaces, 1 per second... | |
150 | */ | |
151 | ||
152 | write(data_fds[1], " ", 1); | |
153 | sleep(1); | |
154 | } | |
155 | ||
156 | exit(0); | |
157 | } | |
158 | else if (pid < 0) | |
159 | { | |
160 | perror("testbackend: Unable to fork"); | |
161 | return (1); | |
162 | } | |
163 | } | |
164 | else | |
165 | data_fds[0] = data_fds[1] = -1; | |
166 | ||
167 | /* | |
168 | * Execute the backend... | |
169 | */ | |
170 | ||
171 | if ((pid = fork()) == 0) | |
172 | { | |
173 | /* | |
174 | * Child comes here... | |
175 | */ | |
176 | ||
177 | if (do_trickle) | |
178 | { | |
179 | close(0); | |
180 | dup(data_fds[0]); | |
181 | close(data_fds[0]); | |
182 | close(data_fds[1]); | |
183 | } | |
184 | ||
185 | close(3); | |
186 | dup(back_fds[1]); | |
187 | close(back_fds[0]); | |
188 | close(back_fds[1]); | |
189 | ||
190 | close(4); | |
191 | dup(side_fds[1]); | |
192 | close(side_fds[0]); | |
193 | close(side_fds[1]); | |
194 | ||
195 | execv(backend, argv + first_arg); | |
196 | fprintf(stderr, "textbackend: Unable to execute \"%s\": %s\n", backend, | |
197 | strerror(errno)); | |
198 | return (errno); | |
199 | } | |
200 | else if (pid < 0) | |
201 | { | |
202 | perror("testbackend: Unable to fork"); | |
203 | return (1); | |
204 | } | |
205 | ||
206 | /* | |
207 | * Parent comes here, setup back and side channel file descriptors... | |
208 | */ | |
209 | ||
210 | if (do_trickle) | |
211 | { | |
212 | close(data_fds[0]); | |
213 | close(data_fds[1]); | |
214 | } | |
215 | ||
216 | close(3); | |
217 | dup(back_fds[0]); | |
218 | close(back_fds[0]); | |
219 | close(back_fds[1]); | |
220 | ||
221 | close(4); | |
222 | dup(side_fds[0]); | |
223 | close(side_fds[0]); | |
224 | close(side_fds[1]); | |
225 | ||
226 | /* | |
227 | * Do side-channel tests as needed, then wait for the backend... | |
228 | */ | |
229 | ||
230 | if (do_side_tests) | |
231 | { | |
232 | int length; /* Length of buffer */ | |
233 | char buffer[2049]; /* Buffer for reponse */ | |
234 | cups_sc_status_t scstatus; /* Status of side-channel command */ | |
235 | static const char * const statuses[] = | |
236 | { | |
237 | "CUPS_SC_STATUS_NONE", /* No status */ | |
238 | "CUPS_SC_STATUS_OK", /* Operation succeeded */ | |
239 | "CUPS_SC_STATUS_IO_ERROR", /* An I/O error occurred */ | |
240 | "CUPS_SC_STATUS_TIMEOUT", /* The backend did not respond */ | |
241 | "CUPS_SC_STATUS_NO_RESPONSE", /* The device did not respond */ | |
242 | "CUPS_SC_STATUS_BAD_MESSAGE", /* The command/response message was invalid */ | |
243 | "CUPS_SC_STATUS_TOO_BIG", /* Response too big */ | |
244 | "CUPS_SC_STATUS_NOT_IMPLEMENTED" /* Command not implemented */ | |
245 | }; | |
246 | ||
247 | ||
248 | length = 0; | |
249 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_DRAIN_OUTPUT, buffer, | |
250 | &length, 5.0); | |
251 | printf("CUPS_SC_CMD_DRAIN_OUTPUT returned %s\n", statuses[scstatus]); | |
252 | ||
253 | length = 1; | |
254 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_GET_BIDI, buffer, | |
255 | &length, 5.0); | |
256 | printf("CUPS_SC_CMD_GET_BIDI returned %s, %d\n", statuses[scstatus], buffer[0]); | |
257 | ||
258 | length = sizeof(buffer) - 1; | |
259 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_GET_DEVICE_ID, buffer, | |
260 | &length, 5.0); | |
261 | buffer[length] = '\0'; | |
262 | printf("CUPS_SC_CMD_GET_DEVICE_ID returned %s, \"%s\"\n", | |
263 | statuses[scstatus], buffer); | |
264 | ||
265 | length = 1; | |
266 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_GET_STATE, buffer, | |
267 | &length, 5.0); | |
268 | printf("CUPS_SC_CMD_GET_STATE returned %s, %02X\n", statuses[scstatus], | |
269 | buffer[0] & 255); | |
270 | ||
271 | length = 0; | |
272 | scstatus = cupsSideChannelDoRequest(CUPS_SC_CMD_SOFT_RESET, buffer, | |
273 | &length, 5.0); | |
274 | printf("CUPS_SC_CMD_SOFT_RESET returned %s\n", statuses[scstatus]); | |
275 | } | |
276 | ||
277 | while (wait(&status) != pid); | |
278 | ||
279 | if (status) | |
280 | { | |
281 | if (WIFEXITED(status)) | |
282 | printf("%s exited with status %d!\n", backend, WEXITSTATUS(status)); | |
283 | else | |
284 | printf("%s crashed with signal %d!\n", backend, WTERMSIG(status)); | |
285 | } | |
286 | ||
287 | /* | |
288 | * Exit accordingly... | |
289 | */ | |
290 | ||
291 | return (status != 0); | |
292 | } | |
293 | ||
294 | ||
295 | /* | |
296 | * 'usage()' - Show usage information. | |
297 | */ | |
298 | ||
299 | static void | |
300 | usage(void) | |
301 | { | |
302 | fputs("Usage: betest [-s] [-t] device-uri job-id user title copies options " | |
303 | "[file]\n", stderr); | |
304 | exit(1); | |
305 | } | |
306 | ||
307 | ||
308 | /* | |
309 | * End of "$Id$". | |
310 | */ |