source: vendor/current/source3/client/smbspool.c

Last change on this file was 989, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.7
File size: 15.4 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 SMB backend for the Common UNIX Printing System ("CUPS")
4
5 Copyright (C) Michael R Sweet 1999
6 Copyright (C) Andrew Tridgell 1994-1998
7 Copyright (C) Andrew Bartlett 2002
8 Copyright (C) Rodrigo Fernandez-Vizarra 2005
9 Copyright (C) James Peach 2008
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23*/
24
25#include "includes.h"
26#include "system/filesys.h"
27#include "system/passwd.h"
28#include "libsmb/libsmb.h"
29
30/*
31 * Starting with CUPS 1.3, Kerberos support is provided by cupsd including
32 * the forwarding of user credentials via the authenticated session between
33 * user and server and the KRB5CCNAME environment variable which will point
34 * to a temporary file or an in-memory representation depending on the version
35 * of Kerberos you use. As a result, all of the ticket code that used to
36 * live here has been removed, and we depend on the user session (if you
37 * run smbspool by hand) or cupsd to provide the necessary Kerberos info.
38 *
39 * Also, the AUTH_USERNAME and AUTH_PASSWORD environment variables provide
40 * for per-job authentication for non-Kerberized printing. We use those
41 * if there is no username and password specified in the device URI.
42 *
43 * Finally, if we have an authentication failure we return exit code 2
44 * which tells CUPS to hold the job for authentication and bug the user
45 * to get the necessary credentials.
46 */
47
48#define MAX_RETRY_CONNECT 3
49
50
51/*
52 * Globals...
53 */
54
55
56
57/*
58 * Local functions...
59 */
60
61static int get_exit_code(struct cli_state * cli, NTSTATUS nt_status);
62static void list_devices(void);
63static struct cli_state *smb_complete_connection(const char *, const char *,
64 int, const char *, const char *, const char *, const char *, int, bool *need_auth);
65static struct cli_state *smb_connect(const char *, const char *, int, const
66 char *, const char *, const char *, const char *, bool *need_auth);
67static int smb_print(struct cli_state *, char *, FILE *);
68static char *uri_unescape_alloc(const char *);
69#if 0
70static bool smb_encrypt;
71#endif
72
73/*
74 * 'main()' - Main entry for SMB backend.
75 */
76
77int /* O - Exit status */
78main(int argc, /* I - Number of command-line arguments */
79 char *argv[])
80{ /* I - Command-line arguments */
81 int i; /* Looping var */
82 int copies; /* Number of copies */
83 int port; /* Port number */
84 char uri[1024], /* URI */
85 *sep, /* Pointer to separator */
86 *tmp, *tmp2, /* Temp pointers to do escaping */
87 *password; /* Password */
88 char *username, /* Username */
89 *server, /* Server name */
90 *printer;/* Printer name */
91 const char *workgroup; /* Workgroup */
92 FILE *fp; /* File to print */
93 int status = 1; /* Status of LPD job */
94 struct cli_state *cli; /* SMB interface */
95 char null_str[1];
96 int tries = 0;
97 bool need_auth = true;
98 const char *dev_uri;
99 TALLOC_CTX *frame = talloc_stackframe();
100
101 null_str[0] = '\0';
102
103 /*
104 * we expect the URI in argv[0]. Detect the case where it is in
105 * argv[1] and cope
106 */
107 if (argc > 2 && strncmp(argv[0], "smb://", 6) &&
108 strncmp(argv[1], "smb://", 6) == 0) {
109 argv++;
110 argc--;
111 }
112
113 if (argc == 1) {
114 /*
115 * NEW! In CUPS 1.1 the backends are run with no arguments
116 * to list the available devices. These can be devices
117 * served by this backend or any other backends (i.e. you
118 * can have an SNMP backend that is only used to enumerate
119 * the available network printers... :)
120 */
121
122 list_devices();
123 status = 0;
124 goto done;
125 }
126
127 if (argc < 6 || argc > 7) {
128 fprintf(stderr,
129"Usage: %s [DEVICE_URI] job-id user title copies options [file]\n"
130" The DEVICE_URI environment variable can also contain the\n"
131" destination printer:\n"
132"\n"
133" smb://[username:password@][workgroup/]server[:port]/printer\n",
134 argv[0]);
135 goto done;
136 }
137
138 /*
139 * If we have 7 arguments, print the file named on the command-line.
140 * Otherwise, print data from stdin...
141 */
142
143 if (argc == 6) {
144 /*
145 * Print from Copy stdin to a temporary file...
146 */
147
148 fp = stdin;
149 copies = 1;
150 } else if ((fp = fopen(argv[6], "rb")) == NULL) {
151 perror("ERROR: Unable to open print file");
152 goto done;
153 } else {
154 char *p = argv[4];
155 char *endp;
156
157 copies = strtol(p, &endp, 10);
158 if (p == endp) {
159 perror("ERROR: Unable to determine number of copies");
160 goto done;
161 }
162 }
163
164 /*
165 * Find the URI...
166 */
167
168 dev_uri = getenv("DEVICE_URI");
169 if (dev_uri) {
170 strncpy(uri, dev_uri, sizeof(uri) - 1);
171 } else if (strncmp(argv[0], "smb://", 6) == 0) {
172 strncpy(uri, argv[0], sizeof(uri) - 1);
173 } else {
174 fputs("ERROR: No device URI found in DEVICE_URI environment variable or argv[0] !\n", stderr);
175 goto done;
176 }
177
178 uri[sizeof(uri) - 1] = '\0';
179
180 /*
181 * Extract the destination from the URI...
182 */
183
184 if ((sep = strrchr_m(uri, '@')) != NULL) {
185 tmp = uri + 6;
186 *sep++ = '\0';
187
188 /* username is in tmp */
189
190 server = sep;
191
192 /*
193 * Extract password as needed...
194 */
195
196 if ((tmp2 = strchr_m(tmp, ':')) != NULL) {
197 *tmp2++ = '\0';
198 password = uri_unescape_alloc(tmp2);
199 } else {
200 password = null_str;
201 }
202 username = uri_unescape_alloc(tmp);
203 } else {
204 if ((username = getenv("AUTH_USERNAME")) == NULL) {
205 username = null_str;
206 }
207
208 if ((password = getenv("AUTH_PASSWORD")) == NULL) {
209 password = null_str;
210 }
211
212 server = uri + 6;
213 }
214
215 tmp = server;
216
217 if ((sep = strchr_m(tmp, '/')) == NULL) {
218 fputs("ERROR: Bad URI - need printer name!\n", stderr);
219 goto done;
220 }
221
222 *sep++ = '\0';
223 tmp2 = sep;
224
225 if ((sep = strchr_m(tmp2, '/')) != NULL) {
226 /*
227 * Convert to smb://[username:password@]workgroup/server/printer...
228 */
229
230 *sep++ = '\0';
231
232 workgroup = uri_unescape_alloc(tmp);
233 server = uri_unescape_alloc(tmp2);
234 printer = uri_unescape_alloc(sep);
235 } else {
236 workgroup = NULL;
237 server = uri_unescape_alloc(tmp);
238 printer = uri_unescape_alloc(tmp2);
239 }
240
241 if ((sep = strrchr_m(server, ':')) != NULL) {
242 *sep++ = '\0';
243
244 port = atoi(sep);
245 } else {
246 port = 0;
247 }
248
249 /*
250 * Setup the SAMBA server state...
251 */
252
253 setup_logging("smbspool", DEBUG_STDERR);
254
255 smb_init_locale();
256
257 if (!lp_load_client(get_dyn_CONFIGFILE())) {
258 fprintf(stderr, "ERROR: Can't load %s - run testparm to debug it\n", get_dyn_CONFIGFILE());
259 goto done;
260 }
261
262 if (workgroup == NULL) {
263 workgroup = lp_workgroup();
264 }
265
266 load_interfaces();
267
268 do {
269 cli = smb_connect(workgroup, server, port, printer,
270 username, password, argv[2], &need_auth);
271 if (cli == NULL) {
272 if (need_auth) {
273 exit(2);
274 } else if (getenv("CLASS") == NULL) {
275 fprintf(stderr, "ERROR: Unable to connect to CIFS host, will retry in 60 seconds...\n");
276 sleep(60);
277 tries++;
278 } else {
279 fprintf(stderr, "ERROR: Unable to connect to CIFS host, trying next printer...\n");
280 goto done;
281 }
282 }
283 } while ((cli == NULL) && (tries < MAX_RETRY_CONNECT));
284
285 if (cli == NULL) {
286 fprintf(stderr, "ERROR: Unable to connect to CIFS host after (tried %d times)\n", tries);
287 goto done;
288 }
289
290 /*
291 * Now that we are connected to the server, ignore SIGTERM so that we
292 * can finish out any page data the driver sends (e.g. to eject the
293 * current page... Only ignore SIGTERM if we are printing data from
294 * stdin (otherwise you can't cancel raw jobs...)
295 */
296
297 if (argc < 7) {
298 CatchSignal(SIGTERM, SIG_IGN);
299 }
300
301 /*
302 * Queue the job...
303 */
304
305 for (i = 0; i < copies; i++) {
306 status = smb_print(cli, argv[3] /* title */ , fp);
307 if (status != 0) {
308 break;
309 }
310 }
311
312 cli_shutdown(cli);
313
314 /*
315 * Return the queue status...
316 */
317
318done:
319
320 TALLOC_FREE(frame);
321 return (status);
322}
323
324
325/*
326 * 'get_exit_code()' - Get the backend exit code based on the current error.
327 */
328
329static int
330get_exit_code(struct cli_state * cli,
331 NTSTATUS nt_status)
332{
333 int i;
334
335 /* List of NTSTATUS errors that are considered
336 * authentication errors
337 */
338 static const NTSTATUS auth_errors[] =
339 {
340 NT_STATUS_ACCESS_DENIED, NT_STATUS_ACCESS_VIOLATION,
341 NT_STATUS_SHARING_VIOLATION, NT_STATUS_PRIVILEGE_NOT_HELD,
342 NT_STATUS_INVALID_ACCOUNT_NAME, NT_STATUS_NO_SUCH_USER,
343 NT_STATUS_WRONG_PASSWORD, NT_STATUS_LOGON_FAILURE,
344 NT_STATUS_ACCOUNT_RESTRICTION, NT_STATUS_INVALID_LOGON_HOURS,
345 NT_STATUS_PASSWORD_EXPIRED, NT_STATUS_ACCOUNT_DISABLED
346 };
347
348
349 fprintf(stderr, "DEBUG: get_exit_code(cli=%p, nt_status=%s [%x])\n",
350 cli, nt_errstr(nt_status), NT_STATUS_V(nt_status));
351
352 for (i = 0; i < ARRAY_SIZE(auth_errors); i++) {
353 if (!NT_STATUS_EQUAL(nt_status, auth_errors[i])) {
354 continue;
355 }
356
357 if (cli) {
358 if (cli->use_kerberos && cli->got_kerberos_mechanism)
359 fputs("ATTR: auth-info-required=negotiate\n", stderr);
360 else
361 fputs("ATTR: auth-info-required=username,password\n", stderr);
362 }
363
364 /*
365 * 2 = authentication required...
366 */
367
368 return (2);
369
370 }
371
372 /*
373 * 1 = fail
374 */
375
376 return (1);
377}
378
379
380/*
381 * 'list_devices()' - List the available printers seen on the network...
382 */
383
384static void
385list_devices(void)
386{
387 /*
388 * Eventually, search the local workgroup for available hosts and printers.
389 */
390
391 puts("network smb \"Unknown\" \"Windows Printer via SAMBA\"");
392}
393
394
395static struct cli_state *
396smb_complete_connection(const char *myname,
397 const char *server,
398 int port,
399 const char *username,
400 const char *password,
401 const char *workgroup,
402 const char *share,
403 int flags,
404 bool *need_auth)
405{
406 struct cli_state *cli; /* New connection */
407 NTSTATUS nt_status;
408
409 /* Start the SMB connection */
410 *need_auth = false;
411 nt_status = cli_start_connection(&cli, myname, server, NULL, port,
412 SMB_SIGNING_DEFAULT, flags);
413 if (!NT_STATUS_IS_OK(nt_status)) {
414 fprintf(stderr, "ERROR: Connection failed: %s\n", nt_errstr(nt_status));
415 return NULL;
416 }
417
418 /*
419 * We pretty much guarantee password must be valid or a pointer to a
420 * 0 char.
421 */
422 if (!password) {
423 *need_auth = true;
424 return NULL;
425 }
426
427 nt_status = cli_session_setup(cli, username,
428 password, strlen(password) + 1,
429 password, strlen(password) + 1,
430 workgroup);
431 if (!NT_STATUS_IS_OK(nt_status)) {
432 fprintf(stderr, "ERROR: Session setup failed: %s\n", nt_errstr(nt_status));
433
434 if (get_exit_code(cli, nt_status) == 2) {
435 *need_auth = true;
436 }
437
438 cli_shutdown(cli);
439
440 return NULL;
441 }
442
443 nt_status = cli_tree_connect(cli, share, "?????", password,
444 strlen(password) + 1);
445 if (!NT_STATUS_IS_OK(nt_status)) {
446 fprintf(stderr, "ERROR: Tree connect failed (%s)\n",
447 nt_errstr(nt_status));
448
449 if (get_exit_code(cli, nt_status) == 2) {
450 *need_auth = true;
451 }
452
453 cli_shutdown(cli);
454
455 return NULL;
456 }
457#if 0
458 /* Need to work out how to specify this on the URL. */
459 if (smb_encrypt) {
460 if (!cli_cm_force_encryption(cli,
461 username,
462 password,
463 workgroup,
464 share)) {
465 fprintf(stderr, "ERROR: encryption setup failed\n");
466 cli_shutdown(cli);
467 return NULL;
468 }
469 }
470#endif
471
472 return cli;
473}
474
475/*
476 * 'smb_connect()' - Return a connection to a server.
477 */
478
479static struct cli_state * /* O - SMB connection */
480smb_connect(const char *workgroup, /* I - Workgroup */
481 const char *server, /* I - Server */
482 const int port, /* I - Port */
483 const char *share, /* I - Printer */
484 const char *username, /* I - Username */
485 const char *password, /* I - Password */
486 const char *jobusername, /* I - User who issued the print job */
487 bool *need_auth)
488{ /* O - Need authentication? */
489 struct cli_state *cli; /* New connection */
490 char *myname = NULL; /* Client name */
491 struct passwd *pwd;
492
493 /*
494 * Get the names and addresses of the client and server...
495 */
496 myname = get_myname(talloc_tos());
497 if (!myname) {
498 return NULL;
499 }
500
501 /*
502 * See if we have a username first. This is for backwards compatible
503 * behavior with 3.0.14a
504 */
505
506 if (username && *username && !getenv("KRB5CCNAME")) {
507 cli = smb_complete_connection(myname, server, port, username,
508 password, workgroup, share, 0, need_auth);
509 if (cli) {
510 fputs("DEBUG: Connected with username/password...\n", stderr);
511 return (cli);
512 }
513 }
514
515 /*
516 * Try to use the user kerberos credentials (if any) to authenticate
517 */
518 cli = smb_complete_connection(myname, server, port, jobusername, "",
519 workgroup, share,
520 CLI_FULL_CONNECTION_USE_KERBEROS, need_auth);
521
522 if (cli) {
523 fputs("DEBUG: Connected using Kerberos...\n", stderr);
524 return (cli);
525 }
526
527 /* give a chance for a passwordless NTLMSSP session setup */
528 pwd = getpwuid(geteuid());
529 if (pwd == NULL) {
530 return NULL;
531 }
532
533 cli = smb_complete_connection(myname, server, port, pwd->pw_name, "",
534 workgroup, share, 0, need_auth);
535
536 if (cli) {
537 fputs("DEBUG: Connected with NTLMSSP...\n", stderr);
538 return (cli);
539 }
540
541 /*
542 * last try. Use anonymous authentication
543 */
544
545 cli = smb_complete_connection(myname, server, port, "", "",
546 workgroup, share, 0, need_auth);
547 /*
548 * Return the new connection...
549 */
550
551 return (cli);
552}
553
554
555/*
556 * 'smb_print()' - Queue a job for printing using the SMB protocol.
557 */
558
559static int /* O - 0 = success, non-0 = failure */
560smb_print(struct cli_state * cli, /* I - SMB connection */
561 char *title, /* I - Title/job name */
562 FILE * fp)
563{ /* I - File to print */
564 uint16_t fnum; /* File number */
565 int nbytes, /* Number of bytes read */
566 tbytes; /* Total bytes read */
567 char buffer[8192], /* Buffer for copy */
568 *ptr; /* Pointer into title */
569 NTSTATUS nt_status;
570
571
572 /*
573 * Sanitize the title...
574 */
575
576 for (ptr = title; *ptr; ptr++) {
577 if (!isalnum((int) *ptr) && !isspace((int) *ptr)) {
578 *ptr = '_';
579 }
580 }
581
582 /*
583 * Open the printer device...
584 */
585
586 nt_status = cli_open(cli, title, O_RDWR | O_CREAT | O_TRUNC, DENY_NONE,
587 &fnum);
588 if (!NT_STATUS_IS_OK(nt_status)) {
589 fprintf(stderr, "ERROR: %s opening remote spool %s\n",
590 nt_errstr(nt_status), title);
591 return get_exit_code(cli, nt_status);
592 }
593
594 /*
595 * Copy the file to the printer...
596 */
597
598 if (fp != stdin)
599 rewind(fp);
600
601 tbytes = 0;
602
603 while ((nbytes = fread(buffer, 1, sizeof(buffer), fp)) > 0) {
604 NTSTATUS status;
605
606 status = cli_writeall(cli, fnum, 0, (uint8_t *)buffer,
607 tbytes, nbytes, NULL);
608 if (!NT_STATUS_IS_OK(status)) {
609 int ret = get_exit_code(cli, status);
610 fprintf(stderr, "ERROR: Error writing spool: %s\n",
611 nt_errstr(status));
612 fprintf(stderr, "DEBUG: Returning status %d...\n",
613 ret);
614 cli_close(cli, fnum);
615
616 return (ret);
617 }
618 tbytes += nbytes;
619 }
620
621 nt_status = cli_close(cli, fnum);
622 if (!NT_STATUS_IS_OK(nt_status)) {
623 fprintf(stderr, "ERROR: %s closing remote spool %s\n",
624 nt_errstr(nt_status), title);
625 return get_exit_code(cli, nt_status);
626 } else {
627 return (0);
628 }
629}
630
631static char *
632uri_unescape_alloc(const char *uritok)
633{
634 char *ret;
635
636 ret = (char *) SMB_STRDUP(uritok);
637 if (!ret) {
638 return NULL;
639 }
640
641 rfc1738_unescape(ret);
642 return ret;
643}
Note: See TracBrowser for help on using the repository browser.