]> git.ipfire.org Git - thirdparty/cups.git/blame - scheduler/dirsvc.c
Load cups into easysw/current.
[thirdparty/cups.git] / scheduler / dirsvc.c
CommitLineData
ef416fc2 1/*
80ca4592 2 * "$Id: dirsvc.c 5330 2006-03-23 21:07:20Z mike $"
ef416fc2 3 *
4 * Directory services routines for the Common UNIX Printing System (CUPS).
5 *
bd7854cb 6 * Copyright 1997-2006 by Easy Software Products, all rights reserved.
ef416fc2 7 *
8 * These coded instructions, statements, and computer programs are the
9 * property of Easy Software Products and are protected by Federal
10 * copyright law. Distribution and use rights are outlined in the file
11 * "LICENSE.txt" which should have been included with this file. If this
12 * file is missing or damaged please contact Easy Software Products
13 * at:
14 *
15 * Attn: CUPS Licensing Information
16 * Easy Software Products
17 * 44141 Airport View Drive, Suite 204
18 * Hollywood, Maryland 20636 USA
19 *
20 * Voice: (301) 373-9600
21 * EMail: cups-info@cups.org
22 * WWW: http://www.cups.org
23 *
24 * Contents:
25 *
26 * cupsdLoadRemoteCache() - Load the remote printer cache.
ef416fc2 27 * cupsdSaveRemoteCache() - Save the remote printer cache.
28 * cupsdSendBrowseDelete() - Send a "browse delete" message for a
29 * printer.
30 * cupsdSendBrowseList() - Send new browsing information as necessary.
ef416fc2 31 * cupsdStartBrowsing() - Start sending and receiving broadcast
32 * information.
33 * cupsdStartPolling() - Start polling servers as needed.
34 * cupsdStopBrowsing() - Stop sending and receiving broadcast
35 * information.
36 * cupsdStopPolling() - Stop polling servers as needed.
37 * cupsdUpdateCUPSBrowse() - Update the browse lists using the CUPS
38 * protocol.
39 * cupsdUpdatePolling() - Read status messages from the poll daemons.
40 * cupsdUpdateSLPBrowse() - Get browsing information via SLP.
e00b005a 41 * dequote() - Remote quotes from a string.
42 * process_browse_data() - Process new browse data.
43 * process_implicit_classes() - Create/update implicit classes as needed.
e1d6a774 44 * send_cups_browse() - Send new browsing information using the
45 * CUPS protocol.
46 * send_ldap_browse() - Send LDAP printer registrations.
47 * send_slp_browse() - Register the specified printer with SLP.
ef416fc2 48 * slp_attr_callback() - SLP attribute callback
49 * slp_dereg_printer() - SLPDereg() the specified printer
50 * slp_get_attr() - Get an attribute from an SLP registration.
51 * slp_reg_callback() - Empty SLPRegReport.
52 * slp_url_callback() - SLP service url callback
53 */
54
55/*
56 * Include necessary headers...
57 */
58
59#include "cupsd.h"
60#include <grp.h>
61
62
63/*
e00b005a 64 * Local functions...
ef416fc2 65 */
66
e00b005a 67static char *dequote(char *d, const char *s, int dlen);
b423cd4c 68static int is_local_queue(const char *uri, char *host, int hostlen,
69 char *resource, int resourcelen);
70static void process_browse_data(const char *uri, const char *host,
71 const char *resource, cups_ptype_t type,
e00b005a 72 ipp_pstate_t state, const char *location,
73 const char *info, const char *make_model,
74 int num_attrs, cups_option_t *attrs);
75static void process_implicit_classes(void);
e1d6a774 76static void send_cups_browse(cupsd_printer_t *p);
77#ifdef HAVE_LDAP
78static void send_ldap_browse(cupsd_printer_t *p);
79#endif /* HAVE_LDAP */
80ca4592 80#ifdef HAVE_LIBSLP
e1d6a774 81static void send_slp_browse(cupsd_printer_t *p);
80ca4592 82#endif /* HAVE_LIBSLP */
e00b005a 83
b423cd4c 84#ifdef HAVE_OPENLDAP
85static const char * const ldap_attrs[] =/* CUPS LDAP attributes */
86 {
87 "printerDescription",
88 "printerLocation",
89 "printerMakeAndModel",
90 "printerType",
91 "printerURI",
92 NULL
93 };
94#endif /* HAVE_OPENLDAP */
95
ef416fc2 96#ifdef HAVE_LIBSLP
e00b005a 97/*
98 * SLP definitions...
99 */
100
ef416fc2 101/*
102 * SLP service name for CUPS...
103 */
104
105# define SLP_CUPS_SRVTYPE "service:printer"
106# define SLP_CUPS_SRVLEN 15
107
108
109/*
110 * Printer service URL structure
111 */
112
113typedef struct _slpsrvurl_s /**** SLP URL list ****/
114{
115 struct _slpsrvurl_s *next; /* Next URL in list */
116 char url[HTTP_MAX_URI];
117 /* URL */
118} slpsrvurl_t;
119
120
121/*
122 * Local functions...
123 */
124
125static SLPBoolean slp_attr_callback(SLPHandle hslp, const char *attrlist,
126 SLPError errcode, void *cookie);
127static void slp_dereg_printer(cupsd_printer_t *p);
128static int slp_get_attr(const char *attrlist, const char *tag,
129 char **valbuf);
130static void slp_reg_callback(SLPHandle hslp, SLPError errcode,
131 void *cookie);
132static SLPBoolean slp_url_callback(SLPHandle hslp, const char *srvurl,
133 unsigned short lifetime,
134 SLPError errcode, void *cookie);
135#endif /* HAVE_LIBSLP */
136
137
138/*
139 * 'cupsdLoadRemoteCache()' - Load the remote printer cache.
140 */
141
142void
143cupsdLoadRemoteCache(void)
144{
145 cups_file_t *fp; /* remote.cache file */
146 int linenum; /* Current line number */
147 char line[1024], /* Line from file */
148 *value, /* Pointer to value */
bd7854cb 149 *valueptr, /* Pointer into value */
150 scheme[32], /* Scheme portion of URI */
151 username[64], /* Username portion of URI */
152 host[HTTP_MAX_HOST],
153 /* Hostname portion of URI */
154 resource[HTTP_MAX_URI];
155 /* Resource portion of URI */
156 int port; /* Port number */
ef416fc2 157 cupsd_printer_t *p; /* Current printer */
158 time_t now; /* Current time */
159
160
161 /*
162 * Open the remote.cache file...
163 */
164
165 snprintf(line, sizeof(line), "%s/remote.cache", CacheDir);
166 if ((fp = cupsFileOpen(line, "r")) == NULL)
167 return;
168
169 /*
170 * Read printer configurations until we hit EOF...
171 */
172
173 linenum = 0;
174 p = NULL;
175 now = time(NULL);
176
177 while (cupsFileGetConf(fp, line, sizeof(line), &value, &linenum))
178 {
179 /*
180 * Decode the directive...
181 */
182
183 if (!strcasecmp(line, "<Printer") ||
184 !strcasecmp(line, "<DefaultPrinter"))
185 {
186 /*
187 * <Printer name> or <DefaultPrinter name>
188 */
189
190 if (p == NULL && value)
191 {
192 /*
193 * Add the printer and a base file type...
194 */
195
196 cupsdLogMessage(CUPSD_LOG_DEBUG,
197 "cupsdLoadRemoteCache: Loading printer %s...", value);
198
bd7854cb 199 if ((p = cupsdFindDest(value)) != NULL)
200 {
201 if (p->type & CUPS_PRINTER_CLASS)
202 {
203 cupsdLogMessage(CUPSD_LOG_WARN,
204 "Cached remote printer \"%s\" conflicts with "
205 "existing class!",
206 value);
207 p = NULL;
208 continue;
209 }
210 }
211 else
212 p = cupsdAddPrinter(value);
213
ef416fc2 214 p->accepting = 1;
215 p->state = IPP_PRINTER_IDLE;
216 p->type |= CUPS_PRINTER_REMOTE;
217 p->browse_time = now + BrowseTimeout;
218
219 /*
220 * Set the default printer as needed...
221 */
222
223 if (!strcasecmp(line, "<DefaultPrinter"))
224 DefaultPrinter = p;
225 }
226 else
227 {
228 cupsdLogMessage(CUPSD_LOG_ERROR,
229 "Syntax error on line %d of remote.cache.", linenum);
230 return;
231 }
232 }
233 else if (!strcasecmp(line, "<Class") ||
234 !strcasecmp(line, "<DefaultClass"))
235 {
236 /*
237 * <Class name> or <DefaultClass name>
238 */
239
240 if (p == NULL && value)
241 {
242 /*
243 * Add the printer and a base file type...
244 */
245
246 cupsdLogMessage(CUPSD_LOG_DEBUG,
247 "cupsdLoadRemoteCache: Loading class %s...", value);
248
bd7854cb 249 if ((p = cupsdFindDest(value)) != NULL)
250 p->type = CUPS_PRINTER_CLASS;
251 else
252 p = cupsdAddClass(value);
253
ef416fc2 254 p->accepting = 1;
255 p->state = IPP_PRINTER_IDLE;
256 p->type |= CUPS_PRINTER_REMOTE;
257 p->browse_time = now + BrowseTimeout;
258
259 /*
260 * Set the default printer as needed...
261 */
262
263 if (!strcasecmp(line, "<DefaultClass"))
264 DefaultPrinter = p;
265 }
266 else
267 {
268 cupsdLogMessage(CUPSD_LOG_ERROR,
269 "Syntax error on line %d of remote.cache.", linenum);
270 return;
271 }
272 }
273 else if (!strcasecmp(line, "</Printer>") ||
274 !strcasecmp(line, "</Class>"))
275 {
276 if (p != NULL)
277 {
278 /*
279 * Close out the current printer...
280 */
281
282 cupsdSetPrinterAttrs(p);
283
284 p = NULL;
285 }
286 else
287 {
288 cupsdLogMessage(CUPSD_LOG_ERROR,
289 "Syntax error on line %d of remote.cache.", linenum);
290 return;
291 }
292 }
293 else if (!p)
294 {
295 cupsdLogMessage(CUPSD_LOG_ERROR,
296 "Syntax error on line %d of remote.cache.", linenum);
297 return;
298 }
299 else if (!strcasecmp(line, "Info"))
300 {
301 if (value)
302 cupsdSetString(&p->info, value);
303 }
304 else if (!strcasecmp(line, "MakeModel"))
305 {
306 if (value)
307 cupsdSetString(&p->make_model, value);
308 }
309 else if (!strcasecmp(line, "Location"))
310 {
311 if (value)
312 cupsdSetString(&p->location, value);
313 }
314 else if (!strcasecmp(line, "DeviceURI"))
315 {
316 if (value)
4400e98d 317 {
bd7854cb 318 httpSeparateURI(HTTP_URI_CODING_ALL, value, scheme, sizeof(scheme),
319 username, sizeof(username), host, sizeof(host), &port,
320 resource, sizeof(resource));
321
322 cupsdSetString(&p->hostname, host);
4400e98d 323 cupsdSetString(&p->uri, value);
ef416fc2 324 cupsdSetString(&p->device_uri, value);
4400e98d 325 }
ef416fc2 326 else
327 {
328 cupsdLogMessage(CUPSD_LOG_ERROR,
329 "Syntax error on line %d of remote.cache.", linenum);
330 return;
331 }
332 }
b423cd4c 333 else if (!strcasecmp(line, "Option") && value)
334 {
335 /*
336 * Option name value
337 */
338
339 for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
340
341 if (!*valueptr)
342 cupsdLogMessage(CUPSD_LOG_ERROR,
343 "Syntax error on line %d of remote.cache.", linenum);
344 else
345 {
346 for (; *valueptr && isspace(*valueptr & 255); *valueptr++ = '\0');
347
348 p->num_options = cupsAddOption(value, valueptr, p->num_options,
349 &(p->options));
350 }
351 }
ef416fc2 352 else if (!strcasecmp(line, "State"))
353 {
354 /*
355 * Set the initial queue state...
356 */
357
358 if (value && !strcasecmp(value, "idle"))
359 p->state = IPP_PRINTER_IDLE;
360 else if (value && !strcasecmp(value, "stopped"))
361 p->state = IPP_PRINTER_STOPPED;
362 else
363 {
364 cupsdLogMessage(CUPSD_LOG_ERROR,
365 "Syntax error on line %d of remote.cache.", linenum);
366 return;
367 }
368 }
369 else if (!strcasecmp(line, "StateMessage"))
370 {
371 /*
372 * Set the initial queue state message...
373 */
374
375 if (value)
376 strlcpy(p->state_message, value, sizeof(p->state_message));
377 }
378 else if (!strcasecmp(line, "Accepting"))
379 {
380 /*
381 * Set the initial accepting state...
382 */
383
384 if (value &&
385 (!strcasecmp(value, "yes") ||
386 !strcasecmp(value, "on") ||
387 !strcasecmp(value, "true")))
388 p->accepting = 1;
389 else if (value &&
390 (!strcasecmp(value, "no") ||
391 !strcasecmp(value, "off") ||
392 !strcasecmp(value, "false")))
393 p->accepting = 0;
394 else
395 {
396 cupsdLogMessage(CUPSD_LOG_ERROR,
397 "Syntax error on line %d of remote.cache.", linenum);
398 return;
399 }
400 }
401 else if (!strcasecmp(line, "Type"))
402 {
403 if (value)
404 p->type = atoi(value);
405 else
406 {
407 cupsdLogMessage(CUPSD_LOG_ERROR,
408 "Syntax error on line %d of remote.cache.", linenum);
409 return;
410 }
411 }
412 else if (!strcasecmp(line, "BrowseTime"))
413 {
414 if (value)
415 {
416 time_t t = atoi(value);
417
418 if (t > (now + BrowseInterval))
419 p->browse_time = t;
420 }
421 else
422 {
423 cupsdLogMessage(CUPSD_LOG_ERROR,
424 "Syntax error on line %d of remote.cache.", linenum);
425 return;
426 }
427 }
428 else if (!strcasecmp(line, "JobSheets"))
429 {
430 /*
431 * Set the initial job sheets...
432 */
433
434 if (value)
435 {
436 for (valueptr = value; *valueptr && !isspace(*valueptr & 255); valueptr ++);
437
438 if (*valueptr)
439 *valueptr++ = '\0';
440
441 cupsdSetString(&p->job_sheets[0], value);
442
443 while (isspace(*valueptr & 255))
444 valueptr ++;
445
446 if (*valueptr)
447 {
448 for (value = valueptr; *valueptr && !isspace(*valueptr & 255); valueptr ++);
449
450 if (*valueptr)
451 *valueptr++ = '\0';
452
453 cupsdSetString(&p->job_sheets[1], value);
454 }
455 }
456 else
457 {
458 cupsdLogMessage(CUPSD_LOG_ERROR,
459 "Syntax error on line %d of remote.cache.", linenum);
460 return;
461 }
462 }
463 else if (!strcasecmp(line, "AllowUser"))
464 {
465 if (value)
466 {
467 p->deny_users = 0;
468 cupsdAddPrinterUser(p, value);
469 }
470 else
471 {
472 cupsdLogMessage(CUPSD_LOG_ERROR,
473 "Syntax error on line %d of remote.cache.", linenum);
474 return;
475 }
476 }
477 else if (!strcasecmp(line, "DenyUser"))
478 {
479 if (value)
480 {
481 p->deny_users = 1;
482 cupsdAddPrinterUser(p, value);
483 }
484 else
485 {
486 cupsdLogMessage(CUPSD_LOG_ERROR,
487 "Syntax error on line %d of remote.cache.", linenum);
488 return;
489 }
490 }
491 else
492 {
493 /*
494 * Something else we don't understand...
495 */
496
497 cupsdLogMessage(CUPSD_LOG_ERROR,
498 "Unknown configuration directive %s on line %d of remote.cache.",
499 line, linenum);
500 }
501 }
502
503 cupsFileClose(fp);
504
505 /*
506 * Do auto-classing if needed...
507 */
508
e00b005a 509 process_implicit_classes();
ef416fc2 510}
511
512
513/*
e00b005a 514 * 'cupsdSaveRemoteCache()' - Save the remote printer cache.
ef416fc2 515 */
516
517void
e00b005a 518cupsdSaveRemoteCache(void)
ef416fc2 519{
e00b005a 520 int i; /* Looping var */
521 cups_file_t *fp; /* printers.conf file */
522 char temp[1024]; /* Temporary string */
523 cupsd_printer_t *printer; /* Current printer class */
524 time_t curtime; /* Current time */
525 struct tm *curdate; /* Current date */
b423cd4c 526 cups_option_t *option; /* Current option */
ef416fc2 527
ef416fc2 528
529 /*
e00b005a 530 * Create the remote.cache file...
ef416fc2 531 */
532
e00b005a 533 snprintf(temp, sizeof(temp), "%s/remote.cache", CacheDir);
ef416fc2 534
e00b005a 535 if ((fp = cupsFileOpen(temp, "w")) == NULL)
ef416fc2 536 {
537 cupsdLogMessage(CUPSD_LOG_ERROR,
e00b005a 538 "Unable to save remote.cache - %s", strerror(errno));
ef416fc2 539 return;
540 }
e00b005a 541 else
542 cupsdLogMessage(CUPSD_LOG_INFO, "Saving remote.cache...");
ef416fc2 543
544 /*
e00b005a 545 * Restrict access to the file...
ef416fc2 546 */
547
e00b005a 548 fchown(cupsFileNumber(fp), getuid(), Group);
549 fchmod(cupsFileNumber(fp), ConfigFilePerm);
ef416fc2 550
e00b005a 551 /*
552 * Write a small header to the file...
553 */
ef416fc2 554
e00b005a 555 curtime = time(NULL);
556 curdate = localtime(&curtime);
557 strftime(temp, sizeof(temp) - 1, "%Y-%m-%d %H:%M", curdate);
ef416fc2 558
e00b005a 559 cupsFilePuts(fp, "# Remote cache file for " CUPS_SVERSION "\n");
560 cupsFilePrintf(fp, "# Written by cupsd on %s\n", temp);
ef416fc2 561
562 /*
e00b005a 563 * Write each local printer known to the system...
ef416fc2 564 */
565
e00b005a 566 for (printer = (cupsd_printer_t *)cupsArrayFirst(Printers);
567 printer;
568 printer = (cupsd_printer_t *)cupsArrayNext(Printers))
ef416fc2 569 {
570 /*
e00b005a 571 * Skip local destinations...
ef416fc2 572 */
573
e00b005a 574 if (!(printer->type & CUPS_PRINTER_REMOTE))
575 continue;
ef416fc2 576
ef416fc2 577 /*
e00b005a 578 * Write printers as needed...
ef416fc2 579 */
580
e00b005a 581 if (printer == DefaultPrinter)
582 cupsFilePuts(fp, "<Default");
ef416fc2 583 else
e00b005a 584 cupsFilePutChar(fp, '<');
ef416fc2 585
e00b005a 586 if (printer->type & CUPS_PRINTER_CLASS)
587 cupsFilePrintf(fp, "Class %s>\n", printer->name);
588 else
589 cupsFilePrintf(fp, "Printer %s>\n", printer->name);
ef416fc2 590
e00b005a 591 cupsFilePrintf(fp, "Type %d\n", printer->type);
ef416fc2 592
e00b005a 593 cupsFilePrintf(fp, "BrowseTime %d\n", (int)printer->browse_time);
ef416fc2 594
e00b005a 595 if (printer->info)
596 cupsFilePrintf(fp, "Info %s\n", printer->info);
ef416fc2 597
e00b005a 598 if (printer->make_model)
599 cupsFilePrintf(fp, "MakeModel %s\n", printer->make_model);
ef416fc2 600
e00b005a 601 if (printer->location)
602 cupsFilePrintf(fp, "Location %s\n", printer->location);
ef416fc2 603
e00b005a 604 if (printer->device_uri)
605 cupsFilePrintf(fp, "DeviceURI %s\n", printer->device_uri);
ef416fc2 606
e00b005a 607 if (printer->state == IPP_PRINTER_STOPPED)
608 {
609 cupsFilePuts(fp, "State Stopped\n");
610 cupsFilePrintf(fp, "StateMessage %s\n", printer->state_message);
ef416fc2 611 }
e00b005a 612 else
613 cupsFilePuts(fp, "State Idle\n");
ef416fc2 614
e00b005a 615 if (printer->accepting)
616 cupsFilePuts(fp, "Accepting Yes\n");
617 else
618 cupsFilePuts(fp, "Accepting No\n");
ef416fc2 619
e00b005a 620 cupsFilePrintf(fp, "JobSheets %s %s\n", printer->job_sheets[0],
621 printer->job_sheets[1]);
ef416fc2 622
e00b005a 623 for (i = 0; i < printer->num_users; i ++)
624 cupsFilePrintf(fp, "%sUser %s\n", printer->deny_users ? "Deny" : "Allow",
625 printer->users[i]);
ef416fc2 626
b423cd4c 627 for (i = printer->num_options, option = printer->options;
628 i > 0;
629 i --, option ++)
630 cupsFilePrintf(fp, "Option %s %s\n", option->name, option->value);
631
e00b005a 632 if (printer->type & CUPS_PRINTER_CLASS)
633 cupsFilePuts(fp, "</Class>\n");
634 else
635 cupsFilePuts(fp, "</Printer>\n");
636 }
ef416fc2 637
e00b005a 638 cupsFileClose(fp);
639}
ef416fc2 640
ef416fc2 641
e00b005a 642/*
643 * 'cupsdSendBrowseDelete()' - Send a "browse delete" message for a printer.
644 */
ef416fc2 645
e00b005a 646void
647cupsdSendBrowseDelete(
648 cupsd_printer_t *p) /* I - Printer to delete */
649{
650 /*
4744bd90 651 * Only announce if browsing is enabled and this is a local queue...
e00b005a 652 */
ef416fc2 653
4744bd90 654 if (!Browsing || !p->shared ||
655 (p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_IMPLICIT)))
e00b005a 656 return;
ef416fc2 657
e00b005a 658 /*
659 * First mark the printer for deletion...
660 */
ef416fc2 661
e00b005a 662 p->type |= CUPS_PRINTER_DELETE;
ef416fc2 663
e00b005a 664 /*
665 * Announce the deletion...
666 */
ef416fc2 667
e00b005a 668 if (BrowseLocalProtocols & BROWSE_CUPS)
e1d6a774 669 send_cups_browse(p);
e00b005a 670#ifdef HAVE_LIBSLP
671 if (BrowseLocalProtocols & BROWSE_SLP)
672 slp_dereg_printer(p);
673#endif /* HAVE_LIBSLP */
674}
ef416fc2 675
ef416fc2 676
e00b005a 677/*
678 * 'cupsdSendBrowseList()' - Send new browsing information as necessary.
679 */
ef416fc2 680
e00b005a 681void
682cupsdSendBrowseList(void)
683{
684 int count; /* Number of dests to update */
685 cupsd_printer_t *p; /* Current printer */
686 time_t ut, /* Minimum update time */
687 to; /* Timeout time */
ef416fc2 688
e00b005a 689
690 if (!Browsing || !BrowseLocalProtocols || !Printers)
691 return;
692
693 /*
694 * Compute the update and timeout times...
695 */
696
b423cd4c 697 to = time(NULL);
698 ut = to - BrowseInterval;
e00b005a 699
700 /*
701 * Figure out how many printers need an update...
702 */
703
704 if (BrowseInterval > 0)
705 {
706 int max_count; /* Maximum number to update */
707
708
709 /*
710 * Throttle the number of printers we'll be updating this time
711 * around based on the number of queues that need updating and
712 * the maximum number of queues to update each second...
713 */
714
715 max_count = 2 * cupsArrayCount(Printers) / BrowseInterval + 1;
716
717 for (count = 0, p = (cupsd_printer_t *)cupsArrayFirst(Printers);
718 count < max_count && p != NULL;
719 p = (cupsd_printer_t *)cupsArrayNext(Printers))
720 if (!(p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_IMPLICIT)) &&
721 p->shared && p->browse_time < ut)
722 count ++;
723
724 /*
725 * Loop through all of the printers and send local updates as needed...
726 */
727
728 if (BrowseNext)
729 p = (cupsd_printer_t *)cupsArrayFind(Printers, BrowseNext);
730 else
731 p = (cupsd_printer_t *)cupsArrayFirst(Printers);
732
733 for (;
734 count > 0;
735 p = (cupsd_printer_t *)cupsArrayNext(Printers))
ef416fc2 736 {
737 /*
e00b005a 738 * Check for wraparound...
ef416fc2 739 */
740
e00b005a 741 if (!p)
742 p = (cupsd_printer_t *)cupsArrayFirst(Printers);
ef416fc2 743
e00b005a 744 if (!p)
745 break;
746 else if ((p->type & (CUPS_PRINTER_REMOTE | CUPS_PRINTER_IMPLICIT)) ||
747 !p->shared)
748 continue;
749 else if (p->browse_time < ut)
750 {
751 /*
752 * Need to send an update...
753 */
ef416fc2 754
e00b005a 755 count --;
ef416fc2 756
e00b005a 757 p->browse_time = time(NULL);
ef416fc2 758
e00b005a 759 if (BrowseLocalProtocols & BROWSE_CUPS)
e1d6a774 760 send_cups_browse(p);
ef416fc2 761
e00b005a 762#ifdef HAVE_LIBSLP
763 if (BrowseLocalProtocols & BROWSE_SLP)
e1d6a774 764 send_slp_browse(p);
e00b005a 765#endif /* HAVE_LIBSLP */
b423cd4c 766
767#ifdef HAVE_LDAP
768 if (BrowseLocalProtocols & BROWSE_LDAP)
e1d6a774 769 send_ldap_browse(p);
b423cd4c 770#endif /* HAVE_LDAP */
e00b005a 771 }
ef416fc2 772 }
e00b005a 773
774 /*
775 * Save where we left off so that all printers get updated...
776 */
777
778 BrowseNext = p;
ef416fc2 779 }
780
781 /*
e00b005a 782 * Loop through all of the printers and send local updates as needed...
ef416fc2 783 */
784
e00b005a 785 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
786 p;
787 p = (cupsd_printer_t *)cupsArrayNext(Printers))
ef416fc2 788 {
e00b005a 789 /*
790 * If this is a remote queue, see if it needs to be timed out...
791 */
ef416fc2 792
e00b005a 793 if (p->type & CUPS_PRINTER_REMOTE)
ef416fc2 794 {
b423cd4c 795 if (p->browse_expire < to)
e00b005a 796 {
797 cupsdAddEvent(CUPSD_EVENT_PRINTER_DELETED, p, NULL,
798 "%s \'%s\' deleted by directory services (timeout).",
799 (p->type & CUPS_PRINTER_CLASS) ? "Class" : "Printer",
800 p->name);
801
802 cupsdLogMessage(CUPSD_LOG_INFO,
b423cd4c 803 "Remote destination \"%s\" has timed out; "
804 "deleting it...",
e00b005a 805 p->name);
806
807 cupsArraySave(Printers);
808 cupsdDeletePrinter(p, 1);
809 cupsArrayRestore(Printers);
810 }
ef416fc2 811 }
812 }
e00b005a 813}
ef416fc2 814
ef416fc2 815
e00b005a 816/*
e1d6a774 817 * 'cupsdStartBrowsing()' - Start sending and receiving broadcast information.
e00b005a 818 */
ef416fc2 819
e00b005a 820void
e1d6a774 821cupsdStartBrowsing(void)
e00b005a 822{
e1d6a774 823 int val; /* Socket option value */
824 struct sockaddr_in addr; /* Broadcast address */
ef416fc2 825
ef416fc2 826
e1d6a774 827 BrowseNext = NULL;
ef416fc2 828
e1d6a774 829 if (!Browsing || !(BrowseLocalProtocols | BrowseRemoteProtocols))
830 return;
ef416fc2 831
e1d6a774 832 if ((BrowseLocalProtocols | BrowseRemoteProtocols) & BROWSE_CUPS)
833 {
834 if (BrowseSocket < 0)
835 {
836 /*
837 * Create the broadcast socket...
838 */
ef416fc2 839
e1d6a774 840 if ((BrowseSocket = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
841 {
842 cupsdLogMessage(CUPSD_LOG_ERROR,
843 "cupsdStartBrowsing: Unable to create broadcast "
844 "socket - %s.", strerror(errno));
845 BrowseLocalProtocols &= ~BROWSE_CUPS;
846 BrowseRemoteProtocols &= ~BROWSE_CUPS;
847 return;
848 }
ef416fc2 849
ef416fc2 850 /*
e1d6a774 851 * Bind the socket to browse port...
ef416fc2 852 */
853
e1d6a774 854 memset(&addr, 0, sizeof(addr));
855 addr.sin_addr.s_addr = htonl(INADDR_ANY);
856 addr.sin_family = AF_INET;
857 addr.sin_port = htons(BrowsePort);
858
859 if (bind(BrowseSocket, (struct sockaddr *)&addr, sizeof(addr)))
ef416fc2 860 {
e1d6a774 861 cupsdLogMessage(CUPSD_LOG_ERROR,
862 "cupsdStartBrowsing: Unable to bind broadcast "
863 "socket - %s.", strerror(errno));
ef416fc2 864
e1d6a774 865#ifdef WIN32
866 closesocket(BrowseSocket);
867#else
868 close(BrowseSocket);
869#endif /* WIN32 */
ef416fc2 870
e1d6a774 871 BrowseSocket = -1;
872 BrowseLocalProtocols &= ~BROWSE_CUPS;
873 BrowseRemoteProtocols &= ~BROWSE_CUPS;
874 return;
875 }
876 }
ef416fc2 877
e1d6a774 878 /*
879 * Set the "broadcast" flag...
880 */
ef416fc2 881
e1d6a774 882 val = 1;
883 if (setsockopt(BrowseSocket, SOL_SOCKET, SO_BROADCAST, &val, sizeof(val)))
884 {
885 cupsdLogMessage(CUPSD_LOG_ERROR,
886 "cupsdStartBrowsing: Unable to set broadcast mode - %s.",
887 strerror(errno));
ef416fc2 888
e1d6a774 889#ifdef WIN32
890 closesocket(BrowseSocket);
891#else
892 close(BrowseSocket);
893#endif /* WIN32 */
ef416fc2 894
e1d6a774 895 BrowseSocket = -1;
896 BrowseLocalProtocols &= ~BROWSE_CUPS;
897 BrowseRemoteProtocols &= ~BROWSE_CUPS;
898 return;
899 }
e00b005a 900
e1d6a774 901 /*
902 * Close the socket on exec...
903 */
e00b005a 904
e1d6a774 905 fcntl(BrowseSocket, F_SETFD, fcntl(BrowseSocket, F_GETFD) | FD_CLOEXEC);
e00b005a 906
e1d6a774 907 /*
908 * Finally, add the socket to the input selection set...
909 */
ef416fc2 910
e1d6a774 911 cupsdLogMessage(CUPSD_LOG_DEBUG2,
912 "cupsdStartBrowsing: Adding fd %d to InputSet...",
913 BrowseSocket);
ef416fc2 914
e1d6a774 915 FD_SET(BrowseSocket, InputSet);
916 }
917 else
918 BrowseSocket = -1;
ef416fc2 919
e1d6a774 920#ifdef HAVE_LIBSLP
921 if ((BrowseLocalProtocols | BrowseRemoteProtocols) & BROWSE_SLP)
922 {
923 /*
924 * Open SLP handle...
925 */
ef416fc2 926
e1d6a774 927 if (SLPOpen("en", SLP_FALSE, &BrowseSLPHandle) != SLP_OK)
928 {
929 cupsdLogMessage(CUPSD_LOG_ERROR,
930 "Unable to open an SLP handle; disabling SLP browsing!");
931 BrowseLocalProtocols &= ~BROWSE_SLP;
932 BrowseRemoteProtocols &= ~BROWSE_SLP;
933 }
e00b005a 934
e1d6a774 935 BrowseSLPRefresh = 0;
936 }
937#endif /* HAVE_LIBSLP */
938
939#ifdef HAVE_OPENLDAP
940 if ((BrowseLocalProtocols | BrowseRemoteProtocols) & BROWSE_LDAP)
941 {
942 if (!BrowseLDAPDN)
943 {
944 cupsdLogMessage(CUPSD_LOG_ERROR,
945 "Need to set BrowseLDAPDN to use LDAP browsing!");
946 BrowseLocalProtocols &= ~BROWSE_LDAP;
947 BrowseRemoteProtocols &= ~BROWSE_LDAP;
ef416fc2 948 }
949 else
950 {
e1d6a774 951 /*
952 * Open LDAP handle...
ef416fc2 953 */
954
e1d6a774 955 int rc; /* LDAP API status */
956 int version = 3; /* LDAP version */
957 struct berval bv = {0, ""}; /* SASL bind value */
ef416fc2 958
ef416fc2 959
e1d6a774 960 /*
961 * LDAP stuff currently only supports ldapi EXTERNAL SASL binds...
962 */
ef416fc2 963
e1d6a774 964 if (!BrowseLDAPServer || !strcasecmp(BrowseLDAPServer, "localhost"))
965 rc = ldap_initialize(&BrowseLDAPHandle, "ldapi:///");
966 else
967 rc = ldap_initialize(&BrowseLDAPHandle, BrowseLDAPServer);
ef416fc2 968
e1d6a774 969 if (rc != LDAP_SUCCESS)
970 {
971 cupsdLogMessage(CUPSD_LOG_ERROR,
972 "Unable to initialize LDAP; disabling LDAP browsing!");
973 BrowseLocalProtocols &= ~BROWSE_LDAP;
974 BrowseRemoteProtocols &= ~BROWSE_LDAP;
975 }
976 else if (ldap_set_option(BrowseLDAPHandle, LDAP_OPT_PROTOCOL_VERSION,
977 (const void *)&version) != LDAP_SUCCESS)
978 {
979 ldap_unbind_ext(BrowseLDAPHandle, NULL, NULL);
980 BrowseLDAPHandle = NULL;
981 cupsdLogMessage(CUPSD_LOG_ERROR,
982 "Unable to set LDAP protocol version; "
983 "disabling LDAP browsing!");
984 BrowseLocalProtocols &= ~BROWSE_LDAP;
985 BrowseRemoteProtocols &= ~BROWSE_LDAP;
986 }
987 else
988 {
989 if (!BrowseLDAPServer || !strcasecmp(BrowseLDAPServer, "localhost"))
990 rc = ldap_sasl_bind_s(BrowseLDAPHandle, NULL, "EXTERNAL", &bv, NULL,
991 NULL, NULL);
992 else
993 rc = ldap_bind_s(BrowseLDAPHandle, BrowseLDAPBindDN,
994 BrowseLDAPPassword, LDAP_AUTH_SIMPLE);
995
996 if (rc != LDAP_SUCCESS)
997 {
998 cupsdLogMessage(CUPSD_LOG_ERROR,
999 "Unable to bind to LDAP server; "
1000 "disabling LDAP browsing!");
1001 ldap_unbind_ext(BrowseLDAPHandle, NULL, NULL);
1002 BrowseLocalProtocols &= ~BROWSE_LDAP;
1003 BrowseRemoteProtocols &= ~BROWSE_LDAP;
1004 }
e00b005a 1005 }
ef416fc2 1006 }
e1d6a774 1007
1008 BrowseLDAPRefresh = 0;
1009 }
1010#endif /* HAVE_OPENLDAP */
ef416fc2 1011}
1012
1013
b423cd4c 1014/*
e1d6a774 1015 * 'cupsdStartPolling()' - Start polling servers as needed.
b423cd4c 1016 */
1017
e1d6a774 1018void
1019cupsdStartPolling(void)
b423cd4c 1020{
e1d6a774 1021 int i; /* Looping var */
1022 cupsd_dirsvc_poll_t *pollp; /* Current polling server */
1023 char polld[1024]; /* Poll daemon path */
1024 char sport[10]; /* Server port */
1025 char bport[10]; /* Browser port */
1026 char interval[10]; /* Poll interval */
1027 int statusfds[2]; /* Status pipe */
1028 char *argv[6]; /* Arguments */
1029 char *envp[100]; /* Environment */
b423cd4c 1030
b423cd4c 1031
1032 /*
e1d6a774 1033 * Don't do anything if we aren't polling...
b423cd4c 1034 */
1035
e1d6a774 1036 if (NumPolled == 0)
1037 {
1038 PollPipe = -1;
1039 PollStatusBuffer = NULL;
1040 return;
1041 }
b423cd4c 1042
e1d6a774 1043 /*
1044 * Setup string arguments for polld, port and interval options.
1045 */
b423cd4c 1046
e1d6a774 1047 snprintf(polld, sizeof(polld), "%s/daemon/cups-polld", ServerBin);
b423cd4c 1048
e1d6a774 1049 sprintf(bport, "%d", BrowsePort);
b423cd4c 1050
e1d6a774 1051 if (BrowseInterval)
1052 sprintf(interval, "%d", BrowseInterval);
1053 else
1054 strcpy(interval, "30");
b423cd4c 1055
e1d6a774 1056 argv[0] = "cups-polld";
1057 argv[2] = sport;
1058 argv[3] = interval;
1059 argv[4] = bport;
1060 argv[5] = NULL;
b423cd4c 1061
e1d6a774 1062 cupsdLoadEnv(envp, (int)(sizeof(envp) / sizeof(envp[0])));
1063
1064 /*
1065 * Create a pipe that receives the status messages from each
1066 * polling daemon...
1067 */
1068
1069 if (cupsdOpenPipe(statusfds))
b423cd4c 1070 {
e1d6a774 1071 cupsdLogMessage(CUPSD_LOG_ERROR,
1072 "Unable to create polling status pipes - %s.",
1073 strerror(errno));
1074 PollPipe = -1;
1075 PollStatusBuffer = NULL;
1076 return;
1077 }
b423cd4c 1078
e1d6a774 1079 PollPipe = statusfds[0];
1080 PollStatusBuffer = cupsdStatBufNew(PollPipe, "[Poll]");
b423cd4c 1081
e1d6a774 1082 /*
1083 * Run each polling daemon, redirecting stderr to the polling pipe...
1084 */
b423cd4c 1085
e1d6a774 1086 for (i = 0, pollp = Polled; i < NumPolled; i ++, pollp ++)
b423cd4c 1087 {
e1d6a774 1088 sprintf(sport, "%d", pollp->port);
b423cd4c 1089
e1d6a774 1090 argv[1] = pollp->hostname;
b423cd4c 1091
e1d6a774 1092 if (cupsdStartProcess(polld, argv, envp, -1, -1, statusfds[1], -1,
1093 0, &(pollp->pid)) < 0)
b423cd4c 1094 {
b423cd4c 1095 cupsdLogMessage(CUPSD_LOG_ERROR,
e1d6a774 1096 "cupsdStartPolling: Unable to fork polling daemon - %s",
1097 strerror(errno));
1098 pollp->pid = 0;
1099 break;
1100 }
1101 else
1102 cupsdLogMessage(CUPSD_LOG_DEBUG,
1103 "cupsdStartPolling: Started polling daemon for %s:%d, pid = %d",
1104 pollp->hostname, pollp->port, pollp->pid);
b423cd4c 1105 }
e1d6a774 1106
1107 close(statusfds[1]);
1108
1109 /*
1110 * Finally, add the pipe to the input selection set...
1111 */
1112
1113 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1114 "cupsdStartPolling: Adding fd %d to InputSet...", PollPipe);
1115
1116 FD_SET(PollPipe, InputSet);
b423cd4c 1117}
b423cd4c 1118
1119
ef416fc2 1120/*
e1d6a774 1121 * 'cupsdStopBrowsing()' - Stop sending and receiving broadcast information.
ef416fc2 1122 */
1123
e1d6a774 1124void
1125cupsdStopBrowsing(void)
ef416fc2 1126{
e1d6a774 1127 if (!Browsing || !(BrowseLocalProtocols | BrowseRemoteProtocols))
1128 return;
ef416fc2 1129
e1d6a774 1130 if (((BrowseLocalProtocols | BrowseRemoteProtocols) & BROWSE_CUPS) &&
1131 BrowseSocket >= 0)
1132 {
1133 /*
1134 * Close the socket and remove it from the input selection set.
1135 */
ef416fc2 1136
e1d6a774 1137#ifdef WIN32
1138 closesocket(BrowseSocket);
1139#else
1140 close(BrowseSocket);
1141#endif /* WIN32 */
ef416fc2 1142
e1d6a774 1143 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1144 "cupsdStopBrowsing: Removing fd %d from InputSet...",
1145 BrowseSocket);
ef416fc2 1146
e1d6a774 1147 FD_CLR(BrowseSocket, InputSet);
1148 BrowseSocket = -1;
1149 }
ef416fc2 1150
e1d6a774 1151#ifdef HAVE_LIBSLP
1152 if (((BrowseLocalProtocols | BrowseRemoteProtocols) & BROWSE_SLP) &&
1153 BrowseSLPHandle)
1154 {
1155 /*
1156 * Close SLP handle...
1157 */
ef416fc2 1158
e1d6a774 1159 SLPClose(BrowseSLPHandle);
1160 BrowseSLPHandle = NULL;
e00b005a 1161 }
e1d6a774 1162#endif /* HAVE_LIBSLP */
ef416fc2 1163
e1d6a774 1164#ifdef HAVE_OPENDAP
1165 if (((BrowseLocalProtocols | BrowseRemoteProtocols) & BROWSE_LDAP) &&
1166 BrowseLDAPHandle)
e00b005a 1167 {
e1d6a774 1168 ldap_unbind(BrowseLDAPHandle);
1169 BrowseLDAPHandle = NULL;
e00b005a 1170 }
e1d6a774 1171#endif /* HAVE_OPENLDAP */
1172}
ef416fc2 1173
ef416fc2 1174
e1d6a774 1175/*
1176 * 'cupsdStopPolling()' - Stop polling servers as needed.
1177 */
ef416fc2 1178
e1d6a774 1179void
1180cupsdStopPolling(void)
1181{
1182 int i; /* Looping var */
1183 cupsd_dirsvc_poll_t *pollp; /* Current polling server */
ef416fc2 1184
ef416fc2 1185
e1d6a774 1186 if (PollPipe >= 0)
e00b005a 1187 {
e1d6a774 1188 cupsdStatBufDelete(PollStatusBuffer);
1189 close(PollPipe);
ef416fc2 1190
e1d6a774 1191 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1192 "cupsdStopPolling: removing fd %d from InputSet.", PollPipe);
1193 FD_CLR(PollPipe, InputSet);
1194
1195 PollPipe = -1;
1196 PollStatusBuffer = NULL;
e00b005a 1197 }
ef416fc2 1198
e1d6a774 1199 for (i = 0, pollp = Polled; i < NumPolled; i ++, pollp ++)
1200 if (pollp->pid)
1201 cupsdEndProcess(pollp->pid, 0);
1202}
ef416fc2 1203
ef416fc2 1204
e1d6a774 1205/*
1206 * 'cupsdUpdateCUPSBrowse()' - Update the browse lists using the CUPS protocol.
1207 */
ef416fc2 1208
e1d6a774 1209void
1210cupsdUpdateCUPSBrowse(void)
1211{
1212 int i; /* Looping var */
1213 int auth; /* Authorization status */
1214 int len; /* Length of name string */
1215 int bytes; /* Number of bytes left */
1216 char packet[1541], /* Broadcast packet */
1217 *pptr; /* Pointer into packet */
1218 socklen_t srclen; /* Length of source address */
1219 http_addr_t srcaddr; /* Source address */
1220 char srcname[1024]; /* Source hostname */
1221 unsigned address[4]; /* Source address */
1222 unsigned type; /* Printer type */
1223 unsigned state; /* Printer state */
1224 char uri[HTTP_MAX_URI], /* Printer URI */
1225 host[HTTP_MAX_URI], /* Host portion of URI */
1226 resource[HTTP_MAX_URI], /* Resource portion of URI */
1227 info[IPP_MAX_NAME], /* Information string */
1228 location[IPP_MAX_NAME], /* Location string */
1229 make_model[IPP_MAX_NAME];/* Make and model string */
1230 int num_attrs; /* Number of attributes */
1231 cups_option_t *attrs; /* Attributes */
ef416fc2 1232
ef416fc2 1233
e1d6a774 1234 /*
1235 * Read a packet from the browse socket...
1236 */
ef416fc2 1237
e1d6a774 1238 srclen = sizeof(srcaddr);
1239 if ((bytes = recvfrom(BrowseSocket, packet, sizeof(packet) - 1, 0,
1240 (struct sockaddr *)&srcaddr, &srclen)) < 0)
e00b005a 1241 {
e1d6a774 1242 /*
1243 * "Connection refused" is returned under Linux if the destination port
1244 * or address is unreachable from a previous sendto(); check for the
1245 * error here and ignore it for now...
1246 */
ef416fc2 1247
e1d6a774 1248 if (errno != ECONNREFUSED && errno != EAGAIN)
1249 {
1250 cupsdLogMessage(CUPSD_LOG_ERROR, "Browse recv failed - %s.",
1251 strerror(errno));
1252 cupsdLogMessage(CUPSD_LOG_ERROR, "Browsing turned off.");
ef416fc2 1253
e1d6a774 1254 cupsdStopBrowsing();
1255 Browsing = 0;
1256 }
ef416fc2 1257
e1d6a774 1258 return;
1259 }
ef416fc2 1260
e1d6a774 1261 packet[bytes] = '\0';
ef416fc2 1262
1263 /*
e1d6a774 1264 * If we're about to sleep, ignore incoming browse packets.
ef416fc2 1265 */
1266
e1d6a774 1267 if (Sleeping)
1268 return;
ef416fc2 1269
1270 /*
e1d6a774 1271 * Figure out where it came from...
ef416fc2 1272 */
1273
e1d6a774 1274#ifdef AF_INET6
1275 if (srcaddr.addr.sa_family == AF_INET6)
1276 {
1277 address[0] = ntohl(srcaddr.ipv6.sin6_addr.s6_addr32[0]);
1278 address[1] = ntohl(srcaddr.ipv6.sin6_addr.s6_addr32[1]);
1279 address[2] = ntohl(srcaddr.ipv6.sin6_addr.s6_addr32[2]);
1280 address[3] = ntohl(srcaddr.ipv6.sin6_addr.s6_addr32[3]);
1281 }
1282 else
1283#endif /* AF_INET6 */
1284 {
1285 address[0] = 0;
1286 address[1] = 0;
1287 address[2] = 0;
1288 address[3] = ntohl(srcaddr.ipv4.sin_addr.s_addr);
1289 }
ef416fc2 1290
e1d6a774 1291 if (HostNameLookups)
1292 httpAddrLookup(&srcaddr, srcname, sizeof(srcname));
1293 else
1294 httpAddrString(&srcaddr, srcname, sizeof(srcname));
ef416fc2 1295
e1d6a774 1296 len = strlen(srcname);
ef416fc2 1297
e1d6a774 1298 /*
1299 * Do ACL stuff...
1300 */
ef416fc2 1301
e1d6a774 1302 if (BrowseACL)
e00b005a 1303 {
e1d6a774 1304 if (httpAddrLocalhost(&srcaddr) || !strcasecmp(srcname, "localhost"))
e00b005a 1305 {
1306 /*
e1d6a774 1307 * Access from localhost (127.0.0.1) is always allowed...
e00b005a 1308 */
ef416fc2 1309
e1d6a774 1310 auth = AUTH_ALLOW;
1311 }
1312 else
1313 {
e00b005a 1314 /*
e1d6a774 1315 * Do authorization checks on the domain/address...
e00b005a 1316 */
ef416fc2 1317
e1d6a774 1318 switch (BrowseACL->order_type)
e00b005a 1319 {
e1d6a774 1320 default :
1321 auth = AUTH_DENY; /* anti-compiler-warning-code */
1322 break;
ef416fc2 1323
e1d6a774 1324 case AUTH_ALLOW : /* Order Deny,Allow */
1325 auth = AUTH_ALLOW;
ef416fc2 1326
e1d6a774 1327 if (cupsdCheckAuth(address, srcname, len,
1328 BrowseACL->num_deny, BrowseACL->deny))
1329 auth = AUTH_DENY;
ef416fc2 1330
e1d6a774 1331 if (cupsdCheckAuth(address, srcname, len,
1332 BrowseACL->num_allow, BrowseACL->allow))
1333 auth = AUTH_ALLOW;
1334 break;
ef416fc2 1335
e1d6a774 1336 case AUTH_DENY : /* Order Allow,Deny */
1337 auth = AUTH_DENY;
ef416fc2 1338
e1d6a774 1339 if (cupsdCheckAuth(address, srcname, len,
1340 BrowseACL->num_allow, BrowseACL->allow))
1341 auth = AUTH_ALLOW;
ef416fc2 1342
e1d6a774 1343 if (cupsdCheckAuth(address, srcname, len,
1344 BrowseACL->num_deny, BrowseACL->deny))
1345 auth = AUTH_DENY;
1346 break;
1347 }
e00b005a 1348 }
e1d6a774 1349 }
1350 else
1351 auth = AUTH_ALLOW;
ef416fc2 1352
e1d6a774 1353 if (auth == AUTH_DENY)
1354 {
1355 cupsdLogMessage(CUPSD_LOG_DEBUG,
1356 "cupsdUpdateCUPSBrowse: Refused %d bytes from %s", bytes,
1357 srcname);
1358 return;
1359 }
ef416fc2 1360
e1d6a774 1361 cupsdLogMessage(CUPSD_LOG_DEBUG2,
1362 "cupsdUpdateCUPSBrowse: (%d bytes from %s) %s", bytes,
1363 srcname, packet);
ef416fc2 1364
e1d6a774 1365 /*
1366 * Parse packet...
1367 */
ef416fc2 1368
e1d6a774 1369 if (sscanf(packet, "%x%x%1023s", &type, &state, uri) < 3)
1370 {
1371 cupsdLogMessage(CUPSD_LOG_WARN,
1372 "cupsdUpdateCUPSBrowse: Garbled browse packet - %s", packet);
1373 return;
e00b005a 1374 }
ef416fc2 1375
e1d6a774 1376 strcpy(location, "Location Unknown");
1377 strcpy(info, "No Information Available");
1378 make_model[0] = '\0';
1379 num_attrs = 0;
1380 attrs = NULL;
1381
1382 if ((pptr = strchr(packet, '\"')) != NULL)
ef416fc2 1383 {
e1d6a774 1384 /*
1385 * Have extended information; can't use sscanf for it because not all
1386 * sscanf's allow empty strings with %[^\"]...
ef416fc2 1387 */
1388
e1d6a774 1389 for (i = 0, pptr ++;
1390 i < (sizeof(location) - 1) && *pptr && *pptr != '\"';
1391 i ++, pptr ++)
1392 location[i] = *pptr;
e00b005a 1393
e1d6a774 1394 if (i)
1395 location[i] = '\0';
b423cd4c 1396
e1d6a774 1397 if (*pptr == '\"')
1398 pptr ++;
b423cd4c 1399
e1d6a774 1400 while (*pptr && isspace(*pptr & 255))
1401 pptr ++;
b423cd4c 1402
e1d6a774 1403 if (*pptr == '\"')
1404 {
1405 for (i = 0, pptr ++;
1406 i < (sizeof(info) - 1) && *pptr && *pptr != '\"';
1407 i ++, pptr ++)
1408 info[i] = *pptr;
b423cd4c 1409
e1d6a774 1410 info[i] = '\0';
b423cd4c 1411
e1d6a774 1412 if (*pptr == '\"')
1413 pptr ++;
b423cd4c 1414
e1d6a774 1415 while (*pptr && isspace(*pptr & 255))
1416 pptr ++;
1417
1418 if (*pptr == '\"')
b423cd4c 1419 {
e1d6a774 1420 for (i = 0, pptr ++;
1421 i < (sizeof(make_model) - 1) && *pptr && *pptr != '\"';
1422 i ++, pptr ++)
1423 make_model[i] = *pptr;
b423cd4c 1424
e1d6a774 1425 if (*pptr == '\"')
1426 pptr ++;
1427
1428 make_model[i] = '\0';
1429
1430 if (*pptr)
1431 num_attrs = cupsParseOptions(pptr, num_attrs, &attrs);
b423cd4c 1432 }
1433 }
b423cd4c 1434 }
ef416fc2 1435
e1d6a774 1436 DEBUG_puts(packet);
1437 DEBUG_printf(("type=%x, state=%x, uri=\"%s\"\n"
1438 "location=\"%s\", info=\"%s\", make_model=\"%s\"\n",
1439 type, state, uri, location, info, make_model));
ef416fc2 1440
1441 /*
e1d6a774 1442 * Pull the URI apart to see if this is a local or remote printer...
ef416fc2 1443 */
1444
e1d6a774 1445 if (is_local_queue(uri, host, sizeof(host), resource, sizeof(resource)))
e00b005a 1446 {
e1d6a774 1447 cupsFreeOptions(num_attrs, attrs);
e00b005a 1448 return;
1449 }
ef416fc2 1450
1451 /*
e1d6a774 1452 * Do relaying...
ef416fc2 1453 */
1454
e1d6a774 1455 for (i = 0; i < NumRelays; i ++)
1456 if (cupsdCheckAuth(address, srcname, len, 1, &(Relays[i].from)))
1457 if (sendto(BrowseSocket, packet, bytes, 0,
1458 (struct sockaddr *)&(Relays[i].to),
1459 sizeof(http_addr_t)) <= 0)
1460 {
1461 cupsdLogMessage(CUPSD_LOG_ERROR,
1462 "cupsdUpdateCUPSBrowse: sendto failed for relay %d - %s.",
1463 i + 1, strerror(errno));
1464 cupsFreeOptions(num_attrs, attrs);
1465 return;
1466 }
ef416fc2 1467
e1d6a774 1468 /*
1469 * Process the browse data...
1470 */
ef416fc2 1471
e1d6a774 1472 process_browse_data(uri, host, resource, (cups_ptype_t)type,
1473 (ipp_pstate_t)state, location, info, make_model,
1474 num_attrs, attrs);
1475}
ef416fc2 1476
ef416fc2 1477
e1d6a774 1478#ifdef HAVE_OPENLDAP
1479/*
1480 * 'cupsdUpdateLDAPBrowse()' - Scan for new printers via LDAP...
1481 */
1482
1483void
1484cupsdUpdateLDAPBrowse(void)
1485{
1486 char uri[HTTP_MAX_URI], /* Printer URI */
1487 host[HTTP_MAX_URI], /* Hostname */
1488 resource[HTTP_MAX_URI], /* Resource path */
1489 location[1024], /* Printer location */
1490 info[1024], /* Printer information */
1491 make_model[1024], /* Printer make and model */
1492 **value; /* Holds the returned data from LDAP */
1493 int type; /* Printer type */
1494 int rc; /* LDAP status */
1495 int limit; /* Size limit */
1496 LDAPMessage *res, /* LDAP search results */
1497 *e; /* Current entry from search */
1498
ef416fc2 1499
e00b005a 1500 /*
e1d6a774 1501 * Search for printers...
e00b005a 1502 */
ef416fc2 1503
e1d6a774 1504 cupsdLogMessage(CUPSD_LOG_DEBUG2, "UpdateLDAPBrowse: %s", ServerName);
1505
1506 BrowseLDAPRefresh = time(NULL) + BrowseInterval;
1507
1508 rc = ldap_search_s(BrowseLDAPHandle, BrowseLDAPDN, LDAP_SCOPE_SUBTREE,
1509 "(objectclass=cupsPrinter)", (char **)ldap_attrs, 0, &res);
1510 if (rc != LDAP_SUCCESS)
e00b005a 1511 {
1512 cupsdLogMessage(CUPSD_LOG_ERROR,
e1d6a774 1513 "LDAP search returned error %d: %s", rc,
1514 ldap_err2string(rc));
e00b005a 1515 return;
1516 }
ef416fc2 1517
e1d6a774 1518 limit = ldap_count_entries(BrowseLDAPHandle, res);
1519 cupsdLogMessage(CUPSD_LOG_DEBUG2, "LDAP search returned %d entries", limit);
1520 if (limit < 1)
1521 return;
ef416fc2 1522
e00b005a 1523 /*
e1d6a774 1524 * Loop through the available printers...
e00b005a 1525 */
ef416fc2 1526
e1d6a774 1527 if ((e = ldap_first_entry(BrowseLDAPHandle, res)) == NULL)
e00b005a 1528 {
e1d6a774 1529 cupsdLogMessage(CUPSD_LOG_ERROR, "Unable to get LDAP printer entry!");
1530 return;
1531 }
ef416fc2 1532
e1d6a774 1533 while (e)
1534 {
1535 value = ldap_get_values(BrowseLDAPHandle, e, "printerDescription");
1536 strlcpy(info, *value, sizeof(info));
1537 ldap_value_free(value);
ef416fc2 1538
e1d6a774 1539 value = ldap_get_values(BrowseLDAPHandle, e, "printerLocation");
1540 strlcpy(location, *value, sizeof(location));
1541 ldap_value_free(value);
ef416fc2 1542
e1d6a774 1543 value = ldap_get_values(BrowseLDAPHandle, e, "printerMakeAndModel");
1544 strlcpy(make_model, *value, sizeof(make_model));
1545 ldap_value_free(value);
ef416fc2 1546
e1d6a774 1547 value = ldap_get_values(BrowseLDAPHandle, e, "printerType");
1548 type = atoi(*value);
1549 ldap_value_free(value);
ef416fc2 1550
e1d6a774 1551 value = ldap_get_values(BrowseLDAPHandle, e, "printerURI");
1552 strlcpy(uri, *value, sizeof(uri));
1553 ldap_value_free(value);
ef416fc2 1554
e1d6a774 1555 if (!is_local_queue(uri, host, sizeof(host), resource, sizeof(resource)))
1556 process_browse_data(uri, host, resource, type, IPP_PRINTER_IDLE,
1557 location, info, make_model, 0, NULL);
1558
1559 e = ldap_next_entry(BrowseLDAPHandle, e);
1560 }
ef416fc2 1561}
e1d6a774 1562#endif /* HAVE_OPENLDAP */
ef416fc2 1563
1564
ef416fc2 1565/*
e1d6a774 1566 * 'cupsdUpdatePolling()' - Read status messages from the poll daemons.
ef416fc2 1567 */
1568
e00b005a 1569void
e1d6a774 1570cupsdUpdatePolling(void)
ef416fc2 1571{
e1d6a774 1572 char *ptr, /* Pointer to end of line in buffer */
1573 message[1024]; /* Pointer to message text */
1574 int loglevel; /* Log level for message */
ef416fc2 1575
ef416fc2 1576
e1d6a774 1577 while ((ptr = cupsdStatBufUpdate(PollStatusBuffer, &loglevel,
1578 message, sizeof(message))) != NULL)
1579 if (!strchr(PollStatusBuffer->buffer, '\n'))
1580 break;
ef416fc2 1581
e1d6a774 1582 if (ptr == NULL)
ef416fc2 1583 {
e1d6a774 1584 /*
1585 * All polling processes have died; stop polling...
e00b005a 1586 */
ef416fc2 1587
e1d6a774 1588 cupsdLogMessage(CUPSD_LOG_ERROR,
1589 "cupsdUpdatePolling: all polling processes have exited!");
1590 cupsdStopPolling();
b423cd4c 1591 }
e00b005a 1592}
ef416fc2 1593
ef416fc2 1594
e1d6a774 1595#ifdef HAVE_LIBSLP
e00b005a 1596/*
e1d6a774 1597 * 'cupsdUpdateSLPBrowse()' - Get browsing information via SLP.
e00b005a 1598 */
ef416fc2 1599
e00b005a 1600void
e1d6a774 1601cupsdUpdateSLPBrowse(void)
e00b005a 1602{
e1d6a774 1603 slpsrvurl_t *s, /* Temporary list of service URLs */
1604 *next; /* Next service in list */
1605 cupsd_printer_t p; /* Printer information */
1606 const char *uri; /* Pointer to printer URI */
1607 char host[HTTP_MAX_URI], /* Host portion of URI */
1608 resource[HTTP_MAX_URI]; /* Resource portion of URI */
ef416fc2 1609
ef416fc2 1610
e1d6a774 1611 /*
1612 * Reset the refresh time...
1613 */
ef416fc2 1614
e1d6a774 1615 BrowseSLPRefresh = time(NULL) + BrowseInterval;
ef416fc2 1616
e1d6a774 1617 /*
1618 * Poll for remote printers using SLP...
1619 */
ef416fc2 1620
e1d6a774 1621 s = NULL;
ef416fc2 1622
e1d6a774 1623 SLPFindSrvs(BrowseSLPHandle, SLP_CUPS_SRVTYPE, "", "",
1624 slp_url_callback, &s);
ef416fc2 1625
e00b005a 1626 /*
e1d6a774 1627 * Loop through the list of available printers...
e00b005a 1628 */
ef416fc2 1629
e1d6a774 1630 for (; s; s = next)
e00b005a 1631 {
1632 /*
e1d6a774 1633 * Save the "next" pointer...
e00b005a 1634 */
ef416fc2 1635
e1d6a774 1636 next = s->next;
ef416fc2 1637
e1d6a774 1638 /*
1639 * Load a cupsd_printer_t structure with the SLP service attributes...
1640 */
ef416fc2 1641
e1d6a774 1642 SLPFindAttrs(BrowseSLPHandle, s->url, "", "", slp_attr_callback, &p);
ef416fc2 1643
e1d6a774 1644 /*
1645 * Process this printer entry...
1646 */
ef416fc2 1647
e1d6a774 1648 uri = s->url + SLP_CUPS_SRVLEN + 1;
ef416fc2 1649
e1d6a774 1650 if (!strncmp(uri, "http://", 7) || !strncmp(uri, "ipp://", 6))
e00b005a 1651 {
09ec0018 1652 /*
e1d6a774 1653 * Pull the URI apart to see if this is a local or remote printer...
09ec0018 1654 */
1655
e1d6a774 1656 if (!is_local_queue(uri, host, sizeof(host), resource, sizeof(resource)))
1657 process_browse_data(uri, host, resource, p.type, IPP_PRINTER_IDLE,
1658 p.location, p.info, p.make_model, 0, NULL);
ef416fc2 1659 }
ef416fc2 1660
e00b005a 1661 /*
e1d6a774 1662 * Free this listing...
e00b005a 1663 */
ef416fc2 1664
e1d6a774 1665 cupsdClearString(&p.info);
1666 cupsdClearString(&p.location);
1667 cupsdClearString(&p.make_model);
ef416fc2 1668
e1d6a774 1669 free(s);
1670 }
1671}
1672#endif /* HAVE_LIBSLP */
ef416fc2 1673
ef416fc2 1674
e1d6a774 1675/*
1676 * 'dequote()' - Remote quotes from a string.
1677 */
e00b005a 1678
e1d6a774 1679static char * /* O - Dequoted string */
1680dequote(char *d, /* I - Destination string */
1681 const char *s, /* I - Source string */
1682 int dlen) /* I - Destination length */
1683{
1684 char *dptr; /* Pointer into destination */
e00b005a 1685
e00b005a 1686
e1d6a774 1687 if (s)
1688 {
1689 for (dptr = d, dlen --; *s && dlen > 0; s ++)
1690 if (*s != '\"')
1691 {
1692 *dptr++ = *s;
1693 dlen --;
1694 }
e00b005a 1695
e1d6a774 1696 *dptr = '\0';
1697 }
1698 else
1699 *d = '\0';
e00b005a 1700
e1d6a774 1701 return (d);
1702}
e00b005a 1703
e00b005a 1704
e1d6a774 1705/*
1706 * 'is_local_queue()' - Determine whether the URI points at a local queue.
1707 */
e00b005a 1708
e1d6a774 1709static int /* O - 1 = local, 0 = remote, -1 = bad URI */
1710is_local_queue(const char *uri, /* I - Printer URI */
1711 char *host, /* O - Host string */
1712 int hostlen, /* I - Length of host buffer */
1713 char *resource, /* O - Resource string */
1714 int resourcelen) /* I - Length of resource buffer */
1715{
1716 char scheme[32], /* Scheme portion of URI */
1717 username[HTTP_MAX_URI]; /* Username portion of URI */
1718 int port; /* Port portion of URI */
1719 cupsd_netif_t *iface; /* Network interface */
e00b005a 1720
ef416fc2 1721
1722 /*
e00b005a 1723 * Pull the URI apart to see if this is a local or remote printer...
ef416fc2 1724 */
1725
e1d6a774 1726 if (httpSeparateURI(HTTP_URI_CODING_ALL, uri, scheme, sizeof(scheme),
1727 username, sizeof(username), host, hostlen, &port,
1728 resource, resourcelen) < HTTP_URI_OK)
1729 return (-1);
1730
1731 DEBUG_printf(("host=\"%s\", ServerName=\"%s\"\n", host, ServerName));
ef416fc2 1732
ef416fc2 1733 /*
e1d6a774 1734 * Check for local server addresses...
ef416fc2 1735 */
1736
e1d6a774 1737 if (!strcasecmp(host, ServerName) && port == LocalPort)
1738 return (1);
1739
1740 cupsdNetIFUpdate();
1741
1742 for (iface = (cupsd_netif_t *)cupsArrayFirst(NetIFList);
1743 iface;
1744 iface = (cupsd_netif_t *)cupsArrayNext(NetIFList))
1745 if (!strcasecmp(host, iface->hostname) && port == iface->port)
1746 return (1);
ef416fc2 1747
e00b005a 1748 /*
e1d6a774 1749 * If we get here, the printer is remote...
e00b005a 1750 */
1751
e1d6a774 1752 return (0);
ef416fc2 1753}
1754
1755
b423cd4c 1756/*
e1d6a774 1757 * 'process_browse_data()' - Process new browse data.
b423cd4c 1758 */
1759
e1d6a774 1760static void
1761process_browse_data(
1762 const char *uri, /* I - URI of printer/class */
1763 const char *host, /* I - Hostname */
1764 const char *resource, /* I - Resource path */
1765 cups_ptype_t type, /* I - Printer type */
1766 ipp_pstate_t state, /* I - Printer state */
1767 const char *location, /* I - Printer location */
1768 const char *info, /* I - Printer information */
1769 const char *make_model, /* I - Printer make and model */
1770 int num_attrs, /* I - Number of attributes */
1771 cups_option_t *attrs) /* I - Attributes */
b423cd4c 1772{
e1d6a774 1773 int i; /* Looping var */
1774 int update; /* Update printer attributes? */
1775 char finaluri[HTTP_MAX_URI], /* Final URI for printer */
1776 name[IPP_MAX_NAME], /* Name of printer */
1777 newname[IPP_MAX_NAME], /* New name of printer */
1778 *hptr, /* Pointer into hostname */
1779 *sptr; /* Pointer into ServerName */
1780 char local_make_model[IPP_MAX_NAME];
1781 /* Local make and model */
1782 cupsd_printer_t *p; /* Printer information */
1783 const char *ipp_options, /* ipp-options value */
1784 *lease_duration; /* lease-duration value */
b423cd4c 1785
1786
1787 /*
e1d6a774 1788 * Determine if the URI contains any illegal characters in it...
b423cd4c 1789 */
1790
e1d6a774 1791 if (strncmp(uri, "ipp://", 6) || !host[0] ||
1792 (strncmp(resource, "/printers/", 10) &&
1793 strncmp(resource, "/classes/", 9)))
b423cd4c 1794 {
1795 cupsdLogMessage(CUPSD_LOG_ERROR,
e1d6a774 1796 "process_browse_data: Bad printer URI in browse data: %s",
1797 uri);
b423cd4c 1798 return;
1799 }
1800
e1d6a774 1801 if (strchr(resource, '?') ||
1802 (!strncmp(resource, "/printers/", 10) && strchr(resource + 10, '/')) ||
1803 (!strncmp(resource, "/classes/", 9) && strchr(resource + 9, '/')))
1804 {
1805 cupsdLogMessage(CUPSD_LOG_ERROR,
1806 "process_browse_data: Bad resource in browse data: %s",
1807 resource);
b423cd4c 1808 return;
e1d6a774 1809 }
b423cd4c 1810
1811 /*
e1d6a774 1812 * OK, this isn't a local printer; add any remote options...
b423cd4c 1813 */
1814
e1d6a774 1815 ipp_options = cupsGetOption("ipp-options", num_attrs, attrs);
b423cd4c 1816
e1d6a774 1817 if (BrowseRemoteOptions)
b423cd4c 1818 {
e1d6a774 1819 if (BrowseRemoteOptions[0] == '?')
1820 {
1821 /*
1822 * Override server-supplied options...
1823 */
b423cd4c 1824
e1d6a774 1825 snprintf(finaluri, sizeof(finaluri), "%s%s", uri, BrowseRemoteOptions);
1826 }
1827 else if (ipp_options)
1828 {
1829 /*
1830 * Combine the server and local options...
1831 */
b423cd4c 1832
e1d6a774 1833 snprintf(finaluri, sizeof(finaluri), "%s?%s+%s", uri, ipp_options,
1834 BrowseRemoteOptions);
1835 }
1836 else
1837 {
1838 /*
1839 * Just use the local options...
1840 */
b423cd4c 1841
e1d6a774 1842 snprintf(finaluri, sizeof(finaluri), "%s?%s", uri, BrowseRemoteOptions);
1843 }
b423cd4c 1844
e1d6a774 1845 uri = finaluri;
b423cd4c 1846 }
e1d6a774 1847 else if (ipp_options)
ef416fc2 1848 {
e00b005a 1849 /*
e1d6a774 1850 * Just use the server-supplied options...
ef416fc2 1851 */
1852
e1d6a774 1853 snprintf(finaluri, sizeof(finaluri), "%s?%s", uri, ipp_options);
1854 uri = finaluri;
ef416fc2 1855 }
ef416fc2 1856
e00b005a 1857 /*
e1d6a774 1858 * See if we already have it listed in the Printers list, and add it if not...
e00b005a 1859 */
1860
e1d6a774 1861 type |= CUPS_PRINTER_REMOTE;
1862 type &= ~CUPS_PRINTER_IMPLICIT;
1863 update = 0;
1864 hptr = strchr(host, '.');
1865 sptr = strchr(ServerName, '.');
e00b005a 1866
e1d6a774 1867 if (sptr != NULL && hptr != NULL)
e00b005a 1868 {
1869 /*
e1d6a774 1870 * Strip the common domain name components...
e00b005a 1871 */
1872
e1d6a774 1873 while (hptr != NULL)
1874 {
1875 if (!strcasecmp(hptr, sptr))
1876 {
1877 *hptr = '\0';
1878 break;
1879 }
1880 else
1881 hptr = strchr(hptr + 1, '.');
1882 }
1883 }
e00b005a 1884
e1d6a774 1885 if (type & CUPS_PRINTER_CLASS)
1886 {
e00b005a 1887 /*
e1d6a774 1888 * Remote destination is a class...
e00b005a 1889 */
1890
e1d6a774 1891 if (!strncmp(resource, "/classes/", 9))
1892 snprintf(name, sizeof(name), "%s@%s", resource + 9, host);
1893 else
1894 return;
e00b005a 1895
e1d6a774 1896 if ((p = cupsdFindClass(name)) == NULL && BrowseShortNames)
e00b005a 1897 {
e1d6a774 1898 if ((p = cupsdFindClass(resource + 9)) != NULL)
1899 {
1900 if (p->hostname && strcasecmp(p->hostname, host))
1901 {
1902 /*
1903 * Nope, this isn't the same host; if the hostname isn't the local host,
1904 * add it to the other class and then find a class using the full host
1905 * name...
1906 */
e00b005a 1907
e1d6a774 1908 if (p->type & CUPS_PRINTER_REMOTE)
1909 {
1910 cupsdLogMessage(CUPSD_LOG_INFO,
1911 "Renamed remote class \"%s\" to \"%s@%s\"...",
1912 p->name, p->name, p->hostname);
1913 cupsdAddEvent(CUPSD_EVENT_PRINTER_DELETED, p, NULL,
1914 "Class \'%s\' deleted by directory services.",
1915 p->name);
e00b005a 1916
e1d6a774 1917 snprintf(newname, sizeof(newname), "%s@%s", p->name, p->hostname);
1918 cupsdRenamePrinter(p, newname);
e00b005a 1919
1920 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED, p, NULL,
1921 "Class \'%s\' added by directory services.",
1922 p->name);
1923 }
1924
1925 p = NULL;
1926 }
1927 else if (!p->hostname)
1928 {
1929 /*
1930 * Hostname not set, so this must be a cached remote printer
1931 * that was created for a pending print job...
1932 */
1933
1934 cupsdSetString(&p->hostname, host);
1935 cupsdSetString(&p->uri, uri);
1936 cupsdSetString(&p->device_uri, uri);
1937 update = 1;
1938 }
1939 }
1940 else
1941 {
1942 /*
1943 * Use the short name for this shared class.
1944 */
1945
1946 strlcpy(name, resource + 9, sizeof(name));
1947 }
1948 }
1949 else if (p && !p->hostname)
1950 {
1951 /*
1952 * Hostname not set, so this must be a cached remote printer
1953 * that was created for a pending print job...
1954 */
1955
1956 cupsdSetString(&p->hostname, host);
1957 cupsdSetString(&p->uri, uri);
1958 cupsdSetString(&p->device_uri, uri);
1959 update = 1;
1960 }
1961
1962 if (!p)
1963 {
1964 /*
1965 * Class doesn't exist; add it...
1966 */
1967
1968 p = cupsdAddClass(name);
1969
1970 cupsdLogMessage(CUPSD_LOG_INFO, "Added remote class \"%s\"...", name);
1971
1972 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED, p, NULL,
1973 "Class \'%s\' added by directory services.", name);
1974
1975 /*
1976 * Force the URI to point to the real server...
1977 */
1978
1979 p->type = type & ~CUPS_PRINTER_REJECTING;
1980 p->accepting = 1;
1981 cupsdSetString(&p->uri, uri);
1982 cupsdSetString(&p->device_uri, uri);
1983 cupsdSetString(&p->hostname, host);
1984
1985 update = 1;
1986 }
ef416fc2 1987 }
1988 else
ef416fc2 1989 {
e00b005a 1990 /*
1991 * Remote destination is a printer...
1992 */
1993
1994 if (!strncmp(resource, "/printers/", 10))
1995 snprintf(name, sizeof(name), "%s@%s", resource + 10, host);
1996 else
1997 return;
1998
1999 if ((p = cupsdFindPrinter(name)) == NULL && BrowseShortNames)
2000 {
2001 if ((p = cupsdFindPrinter(resource + 10)) != NULL)
2002 {
2003 if (p->hostname && strcasecmp(p->hostname, host))
2004 {
2005 /*
2006 * Nope, this isn't the same host; if the hostname isn't the local host,
2007 * add it to the other printer and then find a printer using the full host
2008 * name...
2009 */
ef416fc2 2010
e00b005a 2011 if (p->type & CUPS_PRINTER_REMOTE)
2012 {
2013 cupsdLogMessage(CUPSD_LOG_INFO,
2014 "Renamed remote printer \"%s\" to \"%s@%s\"...",
2015 p->name, p->name, p->hostname);
2016 cupsdAddEvent(CUPSD_EVENT_PRINTER_DELETED, p, NULL,
2017 "Printer \'%s\' deleted by directory services.",
2018 p->name);
ef416fc2 2019
b423cd4c 2020 snprintf(newname, sizeof(newname), "%s@%s", p->name, p->hostname);
2021 cupsdRenamePrinter(p, newname);
ef416fc2 2022
e00b005a 2023 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED, p, NULL,
2024 "Printer \'%s\' added by directory services.",
2025 p->name);
2026 }
ef416fc2 2027
e00b005a 2028 p = NULL;
2029 }
2030 else if (!p->hostname)
2031 {
2032 /*
2033 * Hostname not set, so this must be a cached remote printer
2034 * that was created for a pending print job...
2035 */
2036
2037 cupsdSetString(&p->hostname, host);
2038 cupsdSetString(&p->uri, uri);
2039 cupsdSetString(&p->device_uri, uri);
2040 update = 1;
2041 }
2042 }
2043 else
2044 {
2045 /*
2046 * Use the short name for this shared printer.
2047 */
2048
2049 strlcpy(name, resource + 10, sizeof(name));
2050 }
2051 }
2052 else if (p && !p->hostname)
ef416fc2 2053 {
2054 /*
e00b005a 2055 * Hostname not set, so this must be a cached remote printer
2056 * that was created for a pending print job...
ef416fc2 2057 */
2058
e00b005a 2059 cupsdSetString(&p->hostname, host);
2060 cupsdSetString(&p->uri, uri);
2061 cupsdSetString(&p->device_uri, uri);
2062 update = 1;
ef416fc2 2063 }
e00b005a 2064
2065 if (!p)
ef416fc2 2066 {
2067 /*
e00b005a 2068 * Printer doesn't exist; add it...
ef416fc2 2069 */
2070
e00b005a 2071 p = cupsdAddPrinter(name);
ef416fc2 2072
e00b005a 2073 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED, p, NULL,
2074 "Printer \'%s\' added by directory services.", name);
ef416fc2 2075
e00b005a 2076 cupsdLogMessage(CUPSD_LOG_INFO, "Added remote printer \"%s\"...", name);
ef416fc2 2077
e00b005a 2078 /*
2079 * Force the URI to point to the real server...
2080 */
ef416fc2 2081
e00b005a 2082 p->type = type & ~CUPS_PRINTER_REJECTING;
2083 p->accepting = 1;
2084 cupsdSetString(&p->hostname, host);
2085 cupsdSetString(&p->uri, uri);
2086 cupsdSetString(&p->device_uri, uri);
ef416fc2 2087
e00b005a 2088 update = 1;
ef416fc2 2089 }
2090 }
ef416fc2 2091
2092 /*
e00b005a 2093 * Update the state...
ef416fc2 2094 */
2095
e00b005a 2096 p->state = state;
2097 p->browse_time = time(NULL);
ef416fc2 2098
b423cd4c 2099 if ((lease_duration = cupsGetOption("lease-duration", num_attrs,
2100 attrs)) != NULL)
2101 {
2102 /*
2103 * Grab the lease-duration for the browse data; anything less then 1
2104 * second or more than 1 week gets the default BrowseTimeout...
2105 */
2106
2107 i = atoi(lease_duration);
2108 if (i < 1 || i > 604800)
2109 i = BrowseTimeout;
2110
2111 p->browse_expire = p->browse_time + i;
2112 }
2113 else
2114 p->browse_expire = p->browse_time + BrowseTimeout;
2115
e00b005a 2116 if (type & CUPS_PRINTER_REJECTING)
ef416fc2 2117 {
e00b005a 2118 type &= ~CUPS_PRINTER_REJECTING;
ef416fc2 2119
e00b005a 2120 if (p->accepting)
ef416fc2 2121 {
e00b005a 2122 update = 1;
2123 p->accepting = 0;
ef416fc2 2124 }
2125 }
e00b005a 2126 else if (!p->accepting)
2127 {
2128 update = 1;
2129 p->accepting = 1;
2130 }
ef416fc2 2131
e00b005a 2132 if (p->type != type)
2133 {
2134 p->type = type;
2135 update = 1;
2136 }
ef416fc2 2137
e00b005a 2138 if (location && (!p->location || strcmp(p->location, location)))
2139 {
2140 cupsdSetString(&p->location, location);
2141 update = 1;
2142 }
ef416fc2 2143
e00b005a 2144 if (info && (!p->info || strcmp(p->info, info)))
2145 {
2146 cupsdSetString(&p->info, info);
2147 update = 1;
2148 }
ef416fc2 2149
e00b005a 2150 if (!make_model || !make_model[0])
2151 {
2152 if (type & CUPS_PRINTER_CLASS)
2153 snprintf(local_make_model, sizeof(local_make_model),
2154 "Remote Class on %s", host);
2155 else
2156 snprintf(local_make_model, sizeof(local_make_model),
2157 "Remote Printer on %s", host);
2158 }
2159 else
2160 snprintf(local_make_model, sizeof(local_make_model),
2161 "%s on %s", make_model, host);
ef416fc2 2162
e00b005a 2163 if (!p->make_model || strcmp(p->make_model, local_make_model))
ef416fc2 2164 {
e00b005a 2165 cupsdSetString(&p->make_model, local_make_model);
2166 update = 1;
ef416fc2 2167 }
2168
b423cd4c 2169 if (p->num_options)
2170 {
2171 if (!update && !(type & CUPS_PRINTER_DELETE))
2172 {
2173 /*
2174 * See if we need to update the attributes...
2175 */
2176
2177 if (p->num_options != num_attrs)
2178 update = 1;
2179 else
2180 {
2181 for (i = 0; i < num_attrs; i ++)
2182 if (strcmp(attrs[i].name, p->options[i].name) ||
2183 (!attrs[i].value != !p->options[i].value) ||
2184 (attrs[i].value && strcmp(attrs[i].value, p->options[i].value)))
2185 {
2186 update = 1;
2187 break;
2188 }
2189 }
2190 }
2191
2192 /*
2193 * Free the old options...
2194 */
2195
2196 cupsFreeOptions(p->num_options, p->options);
2197 }
2198
2199 p->num_options = num_attrs;
2200 p->options = attrs;
2201
e00b005a 2202 if (type & CUPS_PRINTER_DELETE)
2203 {
2204 cupsdAddEvent(CUPSD_EVENT_PRINTER_DELETED, p, NULL,
2205 "%s \'%s\' deleted by directory services.",
2206 (type & CUPS_PRINTER_CLASS) ? "Class" : "Printer", p->name);
ef416fc2 2207
e00b005a 2208 cupsdExpireSubscriptions(p, NULL);
2209
2210 cupsdDeletePrinter(p, 1);
2211 cupsdUpdateImplicitClasses();
2212 }
2213 else if (update)
2214 {
2215 cupsdSetPrinterAttrs(p);
2216 cupsdUpdateImplicitClasses();
2217 }
ef416fc2 2218
2219 /*
b423cd4c 2220 * See if we have a default printer... If not, make the first network
2221 * default printer the default.
ef416fc2 2222 */
2223
e00b005a 2224 if (DefaultPrinter == NULL && Printers != NULL && UseNetworkDefault)
2225 {
2226 /*
2227 * Find the first network default printer and use it...
2228 */
2229
2230 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers);
2231 p;
2232 p = (cupsd_printer_t *)cupsArrayNext(Printers))
2233 if (p->type & CUPS_PRINTER_DEFAULT)
ef416fc2 2234 {
e00b005a 2235 DefaultPrinter = p;
2236 break;
ef416fc2 2237 }
e00b005a 2238 }
ef416fc2 2239
2240 /*
e00b005a 2241 * Do auto-classing if needed...
ef416fc2 2242 */
2243
e00b005a 2244 process_implicit_classes();
2245
2246 /*
2247 * Update the printcap file...
2248 */
2249
2250 cupsdWritePrintcap();
ef416fc2 2251}
2252
2253
2254/*
e00b005a 2255 * 'process_implicit_classes()' - Create/update implicit classes as needed.
ef416fc2 2256 */
2257
e00b005a 2258static void
2259process_implicit_classes(void)
ef416fc2 2260{
e00b005a 2261 int i; /* Looping var */
2262 int update; /* Update printer attributes? */
2263 char name[IPP_MAX_NAME], /* Name of printer */
2264 *hptr; /* Pointer into hostname */
2265 cupsd_printer_t *p, /* Printer information */
2266 *pclass, /* Printer class */
2267 *first; /* First printer in class */
2268 int offset, /* Offset of name */
2269 len; /* Length of name */
ef416fc2 2270
2271
e00b005a 2272 if (!ImplicitClasses || !Printers)
2273 return;
ef416fc2 2274
e00b005a 2275 /*
2276 * Loop through all available printers and create classes as needed...
2277 */
2278
2279 for (p = (cupsd_printer_t *)cupsArrayFirst(Printers), len = 0, offset = 0,
2280 update = 0, pclass = NULL, first = NULL;
2281 p != NULL;
2282 p = (cupsd_printer_t *)cupsArrayNext(Printers))
ef416fc2 2283 {
2284 /*
e00b005a 2285 * Skip implicit classes...
ef416fc2 2286 */
2287
e00b005a 2288 if (p->type & CUPS_PRINTER_IMPLICIT)
2289 {
2290 len = 0;
2291 continue;
2292 }
ef416fc2 2293
e00b005a 2294 /*
2295 * If len == 0, get the length of this printer name up to the "@"
2296 * sign (if any).
2297 */
ef416fc2 2298
e00b005a 2299 cupsArraySave(Printers);
ef416fc2 2300
e00b005a 2301 if (len > 0 &&
2302 !strncasecmp(p->name, name + offset, len) &&
2303 (p->name[len] == '\0' || p->name[len] == '@'))
2304 {
2305 /*
2306 * We have more than one printer with the same name; see if
2307 * we have a class, and if this printer is a member...
2308 */
ef416fc2 2309
e00b005a 2310 if (pclass && strcasecmp(pclass->name, name))
2311 {
2312 if (update)
2313 cupsdSetPrinterAttrs(pclass);
ef416fc2 2314
e00b005a 2315 update = 0;
2316 pclass = NULL;
2317 }
ef416fc2 2318
e00b005a 2319 if (!pclass && (pclass = cupsdFindDest(name)) == NULL)
2320 {
2321 /*
2322 * Need to add the class...
2323 */
ef416fc2 2324
e00b005a 2325 pclass = cupsdAddPrinter(name);
2326 cupsArrayAdd(ImplicitPrinters, pclass);
ef416fc2 2327
e00b005a 2328 pclass->type |= CUPS_PRINTER_IMPLICIT;
2329 pclass->accepting = 1;
2330 pclass->state = IPP_PRINTER_IDLE;
ef416fc2 2331
e00b005a 2332 cupsdSetString(&pclass->location, p->location);
2333 cupsdSetString(&pclass->info, p->info);
ef416fc2 2334
e00b005a 2335 update = 1;
ef416fc2 2336
e00b005a 2337 cupsdLogMessage(CUPSD_LOG_INFO, "Added implicit class \"%s\"...",
2338 name);
b423cd4c 2339 cupsdAddEvent(CUPSD_EVENT_PRINTER_ADDED, p, NULL,
2340 "Implicit class \'%s\' added by directory services.",
2341 name);
e00b005a 2342 }
ef416fc2 2343
e00b005a 2344 if (first != NULL)
2345 {
2346 for (i = 0; i < pclass->num_printers; i ++)
2347 if (pclass->printers[i] == first)
2348 break;
ef416fc2 2349
e00b005a 2350 if (i >= pclass->num_printers)
2351 {
2352 first->in_implicit_class = 1;
2353 cupsdAddPrinterToClass(pclass, first);
2354 }
ef416fc2 2355
e00b005a 2356 first = NULL;
2357 }
ef416fc2 2358
e00b005a 2359 for (i = 0; i < pclass->num_printers; i ++)
2360 if (pclass->printers[i] == p)
2361 break;
ef416fc2 2362
e00b005a 2363 if (i >= pclass->num_printers)
2364 {
2365 p->in_implicit_class = 1;
2366 cupsdAddPrinterToClass(pclass, p);
2367 update = 1;
2368 }
2369 }
2370 else
ef416fc2 2371 {
2372 /*
e00b005a 2373 * First time around; just get name length and mark it as first
2374 * in the list...
ef416fc2 2375 */
2376
e00b005a 2377 if ((hptr = strchr(p->name, '@')) != NULL)
2378 len = hptr - p->name;
2379 else
2380 len = strlen(p->name);
ef416fc2 2381
e00b005a 2382 strncpy(name, p->name, len);
2383 name[len] = '\0';
2384 offset = 0;
ef416fc2 2385
e00b005a 2386 if ((first = (hptr ? cupsdFindDest(name) : p)) != NULL &&
2387 !(first->type & CUPS_PRINTER_IMPLICIT))
2388 {
2389 /*
2390 * Can't use same name as a local printer; add "Any" to the
2391 * front of the name, unless we have explicitly disabled
2392 * the "ImplicitAnyClasses"...
2393 */
ef416fc2 2394
e00b005a 2395 if (ImplicitAnyClasses && len < (sizeof(name) - 4))
2396 {
2397 /*
2398 * Add "Any" to the class name...
2399 */
2400
2401 strcpy(name, "Any");
2402 strncpy(name + 3, p->name, len);
2403 name[len + 3] = '\0';
2404 offset = 3;
2405 }
2406 else
2407 {
2408 /*
2409 * Don't create an implicit class if we have a local printer
2410 * with the same name...
2411 */
2412
2413 len = 0;
2414 cupsArrayRestore(Printers);
2415 continue;
2416 }
2417 }
2418
2419 first = p;
ef416fc2 2420 }
2421
e00b005a 2422 cupsArrayRestore(Printers);
2423 }
ef416fc2 2424
e00b005a 2425 /*
2426 * Update the last printer class as needed...
2427 */
ef416fc2 2428
e00b005a 2429 if (pclass && update)
2430 cupsdSetPrinterAttrs(pclass);
ef416fc2 2431}
2432
2433
e1d6a774 2434/*
2435 * 'send_cups_browse()' - Send new browsing information using the CUPS
2436 * protocol.
2437 */
2438
2439static void
2440send_cups_browse(cupsd_printer_t *p) /* I - Printer to send */
2441{
2442 int i; /* Looping var */
2443 cups_ptype_t type; /* Printer type */
2444 cupsd_dirsvc_addr_t *b; /* Browse address */
2445 int bytes; /* Length of packet */
2446 char packet[1453], /* Browse data packet */
2447 uri[1024], /* Printer URI */
2448 location[1024], /* printer-location */
2449 info[1024], /* printer-info */
2450 make_model[1024];
2451 /* printer-make-and-model */
2452 cupsd_netif_t *iface; /* Network interface */
2453
2454
2455 /*
2456 * Figure out the printer type value...
2457 */
2458
2459 type = p->type | CUPS_PRINTER_REMOTE;
2460
2461 if (!p->accepting)
2462 type |= CUPS_PRINTER_REJECTING;
2463
2464 if (p == DefaultPrinter)
2465 type |= CUPS_PRINTER_DEFAULT;
2466
2467 /*
2468 * Remove quotes from printer-info, printer-location, and
2469 * printer-make-and-model attributes...
2470 */
2471
2472 dequote(location, p->location, sizeof(location));
2473 dequote(info, p->info, sizeof(info));
2474 dequote(make_model, p->make_model ? p->make_model : "Unknown",
2475 sizeof(make_model));
2476
2477 /*
2478 * Send a packet to each browse address...
2479 */
2480
2481 for (i = NumBrowsers, b = Browsers; i > 0; i --, b ++)
2482 if (b->iface[0])
2483 {
2484 /*
2485 * Send the browse packet to one or more interfaces...
2486 */
2487
2488 if (!strcmp(b->iface, "*"))
2489 {
2490 /*
2491 * Send to all local interfaces...
2492 */
2493
2494 cupsdNetIFUpdate();
2495
2496 for (iface = (cupsd_netif_t *)cupsArrayFirst(NetIFList);
2497 iface;
2498 iface = (cupsd_netif_t *)cupsArrayNext(NetIFList))
2499 {
2500 /*
2501 * Only send to local, IPv4 interfaces...
2502 */
2503
2504 if (!iface->is_local || !iface->port ||
2505 iface->address.addr.sa_family != AF_INET)
2506 continue;
2507
2508 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
2509 iface->hostname, iface->port,
2510 (p->type & CUPS_PRINTER_CLASS) ? "/classes/%s%s" :
2511 "/printers/%s",
2512 p->name);
2513 snprintf(packet, sizeof(packet), "%x %x %s \"%s\" \"%s\" \"%s\" %s\n",
2514 type, p->state, uri, location, info, make_model,
2515 p->browse_attrs ? p->browse_attrs : "");
2516
2517 bytes = strlen(packet);
2518
2519 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2520 "cupsdSendBrowseList: (%d bytes to \"%s\") %s", bytes,
2521 iface->name, packet);
2522
2523 iface->broadcast.ipv4.sin_port = htons(BrowsePort);
2524
2525 sendto(BrowseSocket, packet, bytes, 0,
2526 (struct sockaddr *)&(iface->broadcast),
2527 sizeof(struct sockaddr_in));
2528 }
2529 }
2530 else if ((iface = cupsdNetIFFind(b->iface)) != NULL)
2531 {
2532 /*
2533 * Send to the named interface using the IPv4 address...
2534 */
2535
2536 while (iface)
2537 if (strcmp(b->iface, iface->name))
2538 {
2539 iface = NULL;
2540 break;
2541 }
2542 else if (iface->address.addr.sa_family == AF_INET && iface->port)
2543 break;
2544 else
2545 iface = (cupsd_netif_t *)cupsArrayNext(NetIFList);
2546
2547 if (iface)
2548 {
2549 httpAssembleURIf(HTTP_URI_CODING_ALL, uri, sizeof(uri), "ipp", NULL,
2550 iface->hostname, iface->port,
2551 (p->type & CUPS_PRINTER_CLASS) ? "/classes/%s%s" :
2552 "/printers/%s",
2553 p->name);
2554 snprintf(packet, sizeof(packet), "%x %x %s \"%s\" \"%s\" \"%s\" %s\n",
2555 type, p->state, uri, location, info, make_model,
2556 p->browse_attrs ? p->browse_attrs : "");
2557
2558 bytes = strlen(packet);
2559
2560 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2561 "cupsdSendBrowseList: (%d bytes to \"%s\") %s", bytes,
2562 iface->name, packet);
2563
2564 iface->broadcast.ipv4.sin_port = htons(BrowsePort);
2565
2566 sendto(BrowseSocket, packet, bytes, 0,
2567 (struct sockaddr *)&(iface->broadcast),
2568 sizeof(struct sockaddr_in));
2569 }
2570 }
2571 }
2572 else
2573 {
2574 /*
2575 * Send the browse packet to the indicated address using
2576 * the default server name...
2577 */
2578
2579 snprintf(packet, sizeof(packet), "%x %x %s \"%s\" \"%s\" \"%s\" %s\n",
2580 type, p->state, p->uri, location, info, make_model,
2581 p->browse_attrs ? p->browse_attrs : "");
2582
2583 bytes = strlen(packet);
2584 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2585 "cupsdSendBrowseList: (%d bytes) %s", bytes, packet);
2586
2587 if (sendto(BrowseSocket, packet, bytes, 0,
2588 (struct sockaddr *)&(b->to),
2589 sizeof(struct sockaddr_in)) <= 0)
2590 {
2591 /*
2592 * Unable to send browse packet, so remove this address from the
2593 * list...
2594 */
2595
2596 cupsdLogMessage(CUPSD_LOG_ERROR,
2597 "cupsdSendBrowseList: sendto failed for browser "
2598 "%d - %s.",
2599 (int)(b - Browsers + 1), strerror(errno));
2600
2601 if (i > 1)
2602 memmove(b, b + 1, (i - 1) * sizeof(cupsd_dirsvc_addr_t));
2603
2604 b --;
2605 NumBrowsers --;
2606 }
2607 }
2608}
2609
2610
2611#ifdef HAVE_OPENLDAP
2612/*
2613 * 'send_ldap_browse()' - Send LDAP printer registrations.
2614 */
2615
2616static void
2617send_ldap_browse(cupsd_printer_t *p) /* I - Printer to register */
2618{
2619 int i; /* Looping var... */
2620 LDAPMod mods[7]; /* The 7 attributes we will be adding */
2621 LDAPMod *pmods[8]; /* Pointers to the 7 attributes + NULL */
2622 LDAPMessage *res; /* Search result token */
2623 char *cn_value[2], /* Change records */
2624 *uri[2],
2625 *info[2],
2626 *location[2],
2627 *make_model[2],
2628 *type[2],
2629 typestring[255], /* String to hold printer-type */
2630 filter[256], /* Search filter for possible UPDATEs */
2631 dn[1024]; /* DN of the printer we are adding */
2632 int rc; /* LDAP status */
2633 static const char * const objectClass_values[] =
2634 { /* The 3 objectClass's we use in */
2635 "top", /* our LDAP entries */
2636 "device",
2637 "cupsPrinter",
2638 NULL
2639 };
2640
2641 cupsdLogMessage(CUPSD_LOG_DEBUG2, "send_ldap_browse: %s\n", p->name);
2642
2643 /*
2644 * Everything in ldap is ** so we fudge around it...
2645 */
2646
2647 sprintf(typestring, "%u", p->type);
2648
2649 cn_value[0] = p->info;
2650 cn_value[1] = NULL;
2651 info[0] = p->info;
2652 info[1] = NULL;
2653 location[0] = p->location;
2654 location[1] = NULL;
2655 make_model[0] = p->make_model;
2656 make_model[1] = NULL;
2657 type[0] = typestring;
2658 type[1] = NULL;
2659 uri[0] = p->uri;
2660 uri[1] = NULL;
2661
2662 snprintf(filter, sizeof(filter),
2663 "(&(objectclass=cupsPrinter)(printerDescription~=%s))", p->info);
2664
2665 ldap_search_s(BrowseLDAPHandle, BrowseLDAPDN, LDAP_SCOPE_SUBTREE,
2666 filter, (char **)ldap_attrs, 0, &res);
2667 cupsdLogMessage(CUPSD_LOG_DEBUG2, "send_ldap_browse: Searching \"%s\"",
2668 filter);
2669
2670 mods[0].mod_type = "cn";
2671 mods[0].mod_values = cn_value;
2672 mods[1].mod_type = "printerDescription";
2673 mods[1].mod_values = info;
2674 mods[2].mod_type = "printerURI";
2675 mods[2].mod_values = uri;
2676 mods[3].mod_type = "printerLocation";
2677 mods[3].mod_values = location;
2678 mods[4].mod_type = "printerMakeAndModel";
2679 mods[4].mod_values = make_model;
2680 mods[5].mod_type = "printerType";
2681 mods[5].mod_values = type;
2682 mods[6].mod_type = "objectClass";
2683 mods[6].mod_values = (char **)objectClass_values;
2684
2685 snprintf(dn, sizeof(dn), "cn=%s,ou=printers,%s", p->info, BrowseLDAPDN);
2686 cupsdLogMessage(CUPSD_LOG_DEBUG2, "send_ldap_browse: dn=\"%s\"", dn);
2687
2688 if (ldap_count_entries(BrowseLDAPHandle, res) > 0)
2689 {
2690 /*
2691 * Printer has already been registered, modify the current
2692 * registration...
2693 */
2694
2695 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2696 "send_ldap_browse: Replacing entry...");
2697
2698 for (i = 0; i < 7; i ++)
2699 {
2700 pmods[i] = mods + i;
2701 pmods[i]->mod_op = LDAP_MOD_REPLACE;
2702 }
2703 pmods[i] = NULL;
2704
2705 if ((rc = ldap_modify_s(BrowseLDAPHandle, dn, pmods)) != LDAP_SUCCESS)
2706 cupsdLogMessage(CUPSD_LOG_ERROR,
2707 "LDAP modify for %s failed with status %d: %s",
2708 p->name, rc, ldap_err2string(rc));
2709 }
2710 else
2711 {
2712 /*
2713 * Printer has already been registered, modify the current
2714 * registration...
2715 */
2716
2717 cupsdLogMessage(CUPSD_LOG_DEBUG2,
2718 "send_ldap_browse: Adding entry...");
2719
2720 for (i = 0; i < 7; i ++)
2721 {
2722 pmods[i] = mods + i;
2723 pmods[i]->mod_op = LDAP_MOD_REPLACE;
2724 }
2725 pmods[i] = NULL;
2726
2727 if ((rc = ldap_modify_s(BrowseLDAPHandle, dn, pmods)) != LDAP_SUCCESS)
2728 cupsdLogMessage(CUPSD_LOG_ERROR,
2729 "LDAP add for %s failed with status %d: %s",
2730 p->name, rc, ldap_err2string(rc));
2731 }
2732}
2733#endif /* HAVE_OPENLDAP */
2734
2735
2736#ifdef HAVE_LIBSLP
2737/*
2738 * 'send_slp_browse()' - Register the specified printer with SLP.
2739 */
2740
2741static void
2742send_slp_browse(cupsd_printer_t *p) /* I - Printer to register */
2743{
2744 char srvurl[HTTP_MAX_URI], /* Printer service URI */
2745 attrs[8192], /* Printer attributes */
2746 finishings[1024], /* Finishings to support */
2747 make_model[IPP_MAX_NAME * 2],
2748 /* Make and model, quoted */
2749 location[IPP_MAX_NAME * 2],
2750 /* Location, quoted */
2751 info[IPP_MAX_NAME * 2], /* Info, quoted */
2752 *src, /* Pointer to original string */
2753 *dst; /* Pointer to destination string */
2754 ipp_attribute_t *authentication; /* uri-authentication-supported value */
2755 SLPError error; /* SLP error, if any */
2756
2757
2758 cupsdLogMessage(CUPSD_LOG_DEBUG, "send_slp_browse(%p = \"%s\")", p,
2759 p->name);
2760
2761 /*
2762 * Make the SLP service URL that conforms to the IANA
2763 * 'printer:' template.
2764 */
2765
2766 snprintf(srvurl, sizeof(srvurl), SLP_CUPS_SRVTYPE ":%s", p->uri);
2767
2768 cupsdLogMessage(CUPSD_LOG_DEBUG2, "Service URL = \"%s\"", srvurl);
2769
2770 /*
2771 * Figure out the finishings string...
2772 */
2773
2774 if (p->type & CUPS_PRINTER_STAPLE)
2775 strcpy(finishings, "staple");
2776 else
2777 finishings[0] = '\0';
2778
2779 if (p->type & CUPS_PRINTER_BIND)
2780 {
2781 if (finishings[0])
2782 strlcat(finishings, ",bind", sizeof(finishings));
2783 else
2784 strcpy(finishings, "bind");
2785 }
2786
2787 if (p->type & CUPS_PRINTER_PUNCH)
2788 {
2789 if (finishings[0])
2790 strlcat(finishings, ",punch", sizeof(finishings));
2791 else
2792 strcpy(finishings, "punch");
2793 }
2794
2795 if (p->type & CUPS_PRINTER_COVER)
2796 {
2797 if (finishings[0])
2798 strlcat(finishings, ",cover", sizeof(finishings));
2799 else
2800 strcpy(finishings, "cover");
2801 }
2802
2803 if (p->type & CUPS_PRINTER_SORT)
2804 {
2805 if (finishings[0])
2806 strlcat(finishings, ",sort", sizeof(finishings));
2807 else
2808 strcpy(finishings, "sort");
2809 }
2810
2811 if (!finishings[0])
2812 strcpy(finishings, "none");
2813
2814 /*
2815 * Quote any commas in the make and model, location, and info strings...
2816 */
2817
2818 for (src = p->make_model, dst = make_model;
2819 src && *src && dst < (make_model + sizeof(make_model) - 2);)
2820 {
2821 if (*src == ',' || *src == '\\' || *src == ')')
2822 *dst++ = '\\';
2823
2824 *dst++ = *src++;
2825 }
2826
2827 *dst = '\0';
2828
2829 if (!make_model[0])
2830 strcpy(make_model, "Unknown");
2831
2832 for (src = p->location, dst = location;
2833 src && *src && dst < (location + sizeof(location) - 2);)
2834 {
2835 if (*src == ',' || *src == '\\' || *src == ')')
2836 *dst++ = '\\';
2837
2838 *dst++ = *src++;
2839 }
2840
2841 *dst = '\0';
2842
2843 if (!location[0])
2844 strcpy(location, "Unknown");
2845
2846 for (src = p->info, dst = info;
2847 src && *src && dst < (info + sizeof(info) - 2);)
2848 {
2849 if (*src == ',' || *src == '\\' || *src == ')')
2850 *dst++ = '\\';
2851
2852 *dst++ = *src++;
2853 }
2854
2855 *dst = '\0';
2856
2857 if (!info[0])
2858 strcpy(info, "Unknown");
2859
2860 /*
2861 * Get the authentication value...
2862 */
2863
2864 authentication = ippFindAttribute(p->attrs, "uri-authentication-supported",
2865 IPP_TAG_KEYWORD);
2866
2867 /*
2868 * Make the SLP attribute string list that conforms to
2869 * the IANA 'printer:' template.
2870 */
2871
2872 snprintf(attrs, sizeof(attrs),
2873 "(printer-uri-supported=%s),"
2874 "(uri-authentication-supported=%s>),"
2875#ifdef HAVE_SSL
2876 "(uri-security-supported=tls>),"
2877#else
2878 "(uri-security-supported=none>),"
2879#endif /* HAVE_SSL */
2880 "(printer-name=%s),"
2881 "(printer-location=%s),"
2882 "(printer-info=%s),"
2883 "(printer-more-info=%s),"
2884 "(printer-make-and-model=%s),"
2885 "(printer-type=%d),"
2886 "(charset-supported=utf-8),"
2887 "(natural-language-configured=%s),"
2888 "(natural-language-supported=de,en,es,fr,it),"
2889 "(color-supported=%s),"
2890 "(finishings-supported=%s),"
2891 "(sides-supported=one-sided%s),"
2892 "(multiple-document-jobs-supported=true)"
2893 "(ipp-versions-supported=1.0,1.1)",
2894 p->uri, authentication->values[0].string.text, p->name, location,
2895 info, p->uri, make_model, p->type, DefaultLanguage,
2896 p->type & CUPS_PRINTER_COLOR ? "true" : "false",
2897 finishings,
2898 p->type & CUPS_PRINTER_DUPLEX ?
2899 ",two-sided-long-edge,two-sided-short-edge" : "");
2900
2901 cupsdLogMessage(CUPSD_LOG_DEBUG2, "Attributes = \"%s\"", attrs);
2902
2903 /*
2904 * Register the printer with the SLP server...
2905 */
2906
2907 error = SLPReg(BrowseSLPHandle, srvurl, BrowseTimeout,
2908 SLP_CUPS_SRVTYPE, attrs, SLP_TRUE, slp_reg_callback, 0);
2909
2910 if (error != SLP_OK)
2911 cupsdLogMessage(CUPSD_LOG_ERROR, "SLPReg of \"%s\" failed with status %d!", p->name,
2912 error);
2913}
2914
2915
ef416fc2 2916/*
2917 * 'slp_attr_callback()' - SLP attribute callback
2918 */
2919
2920static SLPBoolean /* O - SLP_TRUE for success */
2921slp_attr_callback(
2922 SLPHandle hslp, /* I - SLP handle */
2923 const char *attrlist, /* I - Attribute list */
2924 SLPError errcode, /* I - Parsing status for this attr */
2925 void *cookie) /* I - Current printer */
2926{
b423cd4c 2927 char *tmp = 0; /* Temporary string */
ef416fc2 2928 cupsd_printer_t *p = (cupsd_printer_t*)cookie;
b423cd4c 2929 /* Current printer */
ef416fc2 2930
2931
b423cd4c 2932 (void)hslp; /* anti-compiler-warning-code */
ef416fc2 2933
2934 /*
2935 * Bail if there was an error
2936 */
2937
2938 if (errcode != SLP_OK)
2939 return (SLP_TRUE);
2940
2941 /*
2942 * Parse the attrlist to obtain things needed to build CUPS browse packet
2943 */
2944
2945 memset(p, 0, sizeof(cupsd_printer_t));
2946
ef416fc2 2947 if (slp_get_attr(attrlist, "(printer-location=", &(p->location)))
2948 return (SLP_FALSE);
2949 if (slp_get_attr(attrlist, "(printer-info=", &(p->info)))
2950 return (SLP_FALSE);
2951 if (slp_get_attr(attrlist, "(printer-make-and-model=", &(p->make_model)))
2952 return (SLP_FALSE);
b423cd4c 2953 if (!slp_get_attr(attrlist, "(printer-type=", &tmp))
2954 p->type = atoi(tmp);
2955 else
2956 p->type = CUPS_PRINTER_REMOTE;
ef416fc2 2957
2958 cupsdClearString(&tmp);
2959
2960 return (SLP_TRUE);
2961}
2962
2963
2964/*
2965 * 'slp_dereg_printer()' - SLPDereg() the specified printer
2966 */
2967
2968static void
2969slp_dereg_printer(cupsd_printer_t *p) /* I - Printer */
2970{
2971 char srvurl[HTTP_MAX_URI]; /* Printer service URI */
2972
2973
2974 cupsdLogMessage(CUPSD_LOG_DEBUG, "slp_dereg_printer: printer=\"%s\"", p->name);
2975
2976 if (!(p->type & CUPS_PRINTER_REMOTE))
2977 {
2978 /*
2979 * Make the SLP service URL that conforms to the IANA
2980 * 'printer:' template.
2981 */
2982
2983 snprintf(srvurl, sizeof(srvurl), SLP_CUPS_SRVTYPE ":%s", p->uri);
2984
2985 /*
2986 * Deregister the printer...
2987 */
2988
2989 SLPDereg(BrowseSLPHandle, srvurl, slp_reg_callback, 0);
2990 }
2991}
2992
2993
2994/*
2995 * 'slp_get_attr()' - Get an attribute from an SLP registration.
2996 */
2997
2998static int /* O - 0 on success */
2999slp_get_attr(const char *attrlist, /* I - Attribute list string */
3000 const char *tag, /* I - Name of attribute */
3001 char **valbuf) /* O - Value */
3002{
3003 char *ptr1, /* Pointer into string */
3004 *ptr2; /* ... */
3005
3006
3007 cupsdClearString(valbuf);
3008
3009 if ((ptr1 = strstr(attrlist, tag)) != NULL)
3010 {
3011 ptr1 += strlen(tag);
3012
3013 if ((ptr2 = strchr(ptr1,')')) != NULL)
3014 {
3015 /*
3016 * Copy the value...
3017 */
3018
3019 *valbuf = calloc(ptr2 - ptr1 + 1, 1);
3020 strncpy(*valbuf, ptr1, ptr2 - ptr1);
3021
3022 /*
3023 * Dequote the value...
3024 */
3025
3026 for (ptr1 = *valbuf; *ptr1; ptr1 ++)
3027 if (*ptr1 == '\\' && ptr1[1])
3028 _cups_strcpy(ptr1, ptr1 + 1);
3029
3030 return (0);
3031 }
3032 }
3033
3034 return (-1);
3035}
3036
3037
3038/*
3039 * 'slp_reg_callback()' - Empty SLPRegReport.
3040 */
3041
3042static void
3043slp_reg_callback(SLPHandle hslp, /* I - SLP handle */
3044 SLPError errcode, /* I - Error code, if any */
3045 void *cookie) /* I - App data */
3046{
3047 (void)hslp;
3048 (void)errcode;
3049 (void)cookie;
3050
3051 return;
3052}
3053
3054
3055/*
3056 * 'slp_url_callback()' - SLP service url callback
3057 */
3058
3059static SLPBoolean /* O - TRUE = OK, FALSE = error */
3060slp_url_callback(
3061 SLPHandle hslp, /* I - SLP handle */
3062 const char *srvurl, /* I - URL of service */
3063 unsigned short lifetime, /* I - Life of service */
3064 SLPError errcode, /* I - Existing error code */
3065 void *cookie) /* I - Pointer to service list */
3066{
3067 slpsrvurl_t *s, /* New service entry */
3068 **head; /* Pointer to head of entry */
3069
3070
3071 /*
3072 * Let the compiler know we won't be using these vars...
3073 */
3074
3075 (void)hslp;
3076 (void)lifetime;
3077
3078 /*
3079 * Bail if there was an error
3080 */
3081
3082 if (errcode != SLP_OK)
3083 return (SLP_TRUE);
3084
3085 /*
3086 * Grab the head of the list...
3087 */
3088
3089 head = (slpsrvurl_t**)cookie;
3090
3091 /*
3092 * Allocate a *temporary* slpsrvurl_t to hold this entry.
3093 */
3094
3095 if ((s = (slpsrvurl_t *)calloc(1, sizeof(slpsrvurl_t))) == NULL)
3096 return (SLP_FALSE);
3097
3098 /*
3099 * Copy the SLP service URL...
3100 */
3101
3102 strlcpy(s->url, srvurl, sizeof(s->url));
3103
3104 /*
3105 * Link the SLP service URL into the head of the list
3106 */
3107
3108 if (*head)
3109 s->next = *head;
3110
3111 *head = s;
3112
3113 return (SLP_TRUE);
3114}
3115#endif /* HAVE_LIBSLP */
3116
3117
3118/*
80ca4592 3119 * End of "$Id: dirsvc.c 5330 2006-03-23 21:07:20Z mike $".
ef416fc2 3120 */