1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License, Version 1.0 only
6 * (the "License"). You may not use this file except in compliance
7 * with the License.
8 *
9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10 * or http://www.opensolaris.org/os/licensing.
11 * See the License for the specific language governing permissions
12 * and limitations under the License.
13 *
14 * When distributing Covered Code, include this CDDL HEADER in each
15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16 * If applicable, add the following below this CDDL HEADER, with the
17 * fields enclosed by brackets "[]" replaced with your own identifying
18 * information: Portions Copyright [yyyy] [name of copyright owner]
19 *
20 * CDDL HEADER END
21 */
22 /*
23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 */
26
27 #pragma ident "%Z%%M% %I% %E% SMI"
28
29 /*
30 * Target Lists
31 * ============
32 * All UA functions use target lists to select and manage their
33 * network targets. There are two types of network targets: unicast (uc)
34 * and multicast (mc) -- multicast will also work for broadcast. This
35 * module organizes unicast targets into an efficient ordering. The
36 * targeting structure can be though of as a 2-dimensional matrix, with
37 * the following axes:
38 *
39 * unicast failovers --->
40 * targets
41 * |
42 * |
43 * \ /
44 *
45 * Callers walk down the unicast targets, unicasting to each. If any
46 * unicast target fails, callers then walk to the right, through failover
47 * targets until they either find one that works, or there are no more
48 * failover targets.
49 *
50 * The targeting heuristic orders the unicast targets so that those
51 * DAs which support the greatest number of requested scopes are called
52 * first, thus minimizing the number of unicasts which need to be done.
53 * Within groups of DAs supporting the same scope coverage, the DAs are
54 * sorted according to network proximity relative to the local host:
55 * DAs on the local host come first, then those on a same subnet, then
56 * all other (remote) DAs.
57 *
58 * A given DA is called no more than once, and failed DAs are skipped
59 * after they have been marked 'failed'.
60 *
61 * All access to a target list is done through the following functions
62 * and types:
63 * There are two opaque types:
64 * slp_target_list_t: A handle to a target list
65 * slp_target_t: A handle to an individual target. slp_get_target_sin
66 * will extract an inet address for this target.
67 *
68 * There are the following accessor functions:
69 * slp_new_target_list: creates a new target list for the given scopes,
70 * and populates with all known DAs for these scopes.
71 * slp_get_uc_scopes: returns a list of all scopes for which there are
72 * DAs (and which can thus be used for unicasts)
73 * slp_get_mc_scopes: returns a list of all scopes for which there are
74 * no DAs (and which must thus be used for multicasts).
75 * slp_next_uc_target: Returns a slp_target_t handle for the next unicast
76 * target, or NULL for none.
77 * slp_next_failover: Returns the next failover DA for a given target, or
78 * NULL for none.
79 * slp_get_target_sin: extracts a sockaddr_in for a given slp_target_t;
80 * slp_mark_target_used: callers should mark a slp_target_t used after
81 * successfully communicating with that target.
82 * slp_mark_target_failed: callers should mark a slp_target_t failed after
83 * trying and failing to communicate with a target.
84 * slp_destroy_target_list: destroys and frees a target list and all its
85 * associated resources.
86 * slp_fabricate_target: Creates a slp_target_t from a given sockaddr_in.
87 * This is useful for situations such as when a
88 * multicast routine needs to hand off to a TCP
89 * routine (due to overflow), and there is no target
90 * list available. Fabricated targets should be free'd
91 * with slp_free_target; the input sin will duplicated
92 * in the target, so the caller can free it after
93 * calling slp_fabricate_target.
94 * slp_free_target: Frees an slp_target_t created by slp_fabricate_target.
95 * This should not be used to free any other target.
96 *
97 */
98
99 #include <stdio.h>
100 #include <stdlib.h>
101 #include <string.h>
102 #include <syslog.h>
103 #include <arpa/inet.h>
104 #include <slp-internal.h>
105 #include <slp_net_utils.h>
106
107 typedef enum {
108 SLP_REMOTE_PROX = 0, /* remote to local host */
109 SLP_SUBNET_PROX = 1, /* on same subnet as local host */
110 SLP_LOCAL_PROX = 2 /* on local host */
111 } slp_net_prox;
112
113 struct da_node {
114 struct sockaddr_in sin;
115 char *scopes;
116 SLPBoolean used, failed;
117 int coverage;
118 slp_net_prox proximity;
119 struct da_node *next, *prev;
120 };
121
122 struct scope_targets {
123 struct da_node *da;
124 struct scope_targets *next;
125 };
126
127 struct target_list {
128 struct scope_targets **scopes;
129 struct scope_targets **state;
130 char *uc_scopes;
131 char *mc_scopes;
132 char *all_scopes;
133 struct da_node *DAs;
134 };
135
136 static void add2scopes_list(struct da_node *, struct target_list *);
137 static void add_da_entry(struct da_node **, struct sockaddr_in *,
138 char *, slp_net_prox, int);
139 static SLPSrvURLCallback collect_DAs;
140 static void format_query(char *, const char *);
141
slp_new_target_list(slp_handle_impl_t * hp,const char * scopes,slp_target_list_t ** handle)142 SLPError slp_new_target_list(slp_handle_impl_t *hp, const char *scopes,
143 slp_target_list_t **handle) {
144 struct target_list *tl;
145 int scope_cnt;
146 char *p;
147 struct da_node *te;
148 char *query, *reply;
149 SLPError err;
150 void *collator = NULL;
151
152 /* count the number of scopes in the list */
153 scope_cnt = 0;
154 for (p = (char *)scopes; p; p++) {
155 p = slp_utf_strchr(p, ',');
156 scope_cnt++;
157 if (!p)
158 break;
159 }
160
161 /* create a new target list */
162 if (!(tl = calloc(1, sizeof (*tl)))) {
163 slp_err(LOG_CRIT, 0, "slp_new_target_list", "out of memory");
164 return (SLP_MEMORY_ALLOC_FAILED);
165 }
166 tl->DAs = NULL;
167
168 if (!(tl->scopes = calloc(scope_cnt + 1, sizeof (*(tl->scopes))))) {
169 slp_err(LOG_CRIT, 0, "slp_new_target_list", "out of memory");
170 free(tl);
171 return (SLP_MEMORY_ALLOC_FAILED);
172 }
173 tl->uc_scopes = NULL;
174 tl->state = tl->scopes;
175 if (!(tl->all_scopes = strdup(scopes))) {
176 slp_err(LOG_CRIT, 0, "slp_new_target_list", "out of memory");
177 free(tl->scopes); free(tl);
178 return (SLP_MEMORY_ALLOC_FAILED);
179 }
180 /* As scopes are added to uc list, they are removed from the mc list */
181 if (!(tl->mc_scopes = strdup(scopes))) {
182 slp_err(LOG_CRIT, 0, "slp_new_target_list", "out of memory");
183 free(tl->scopes); free(tl->all_scopes); free(tl);
184 return (SLP_MEMORY_ALLOC_FAILED);
185 }
186
187 if (hp->force_multicast) {
188 /* all scopes remain multicast scopes; useful for SAAdverts */
189 *handle = tl;
190 return (SLP_OK);
191 }
192
193 /* DAs from active and passive discovery */
194 if (!(query = malloc(strlen(scopes) -
195 (scope_cnt - 1) + /* exclude commas */
196 strlen(SLP_SUN_VERSION_TAG) +
197 strlen("(&(=2)(|))") + 1 +
198 (scope_cnt *
199 (strlen(SLP_SUN_SCOPES_TAG) +
200 strlen("(=)")))))) { /* (scopes=) */
201 slp_err(LOG_CRIT, 0, "slp_new_target_list", "out of memory");
202 free(tl->scopes);
203 free(tl->all_scopes);
204 free(tl->mc_scopes);
205 free(tl);
206 return (SLP_MEMORY_ALLOC_FAILED);
207 }
208 format_query(query, scopes);
209
210 if ((err = slp_find_das(query, &reply)) != SLP_OK &&
211 err != SLP_NETWORK_ERROR) {
212 free(tl->scopes);
213 free(tl->all_scopes);
214 free(tl->mc_scopes);
215 free(tl);
216 free(query);
217 return (err);
218 }
219 free(query);
220
221 /* Unpack the reply */
222 if (reply) {
223 int numResults = 0; /* placeholder; not actually used */
224 /* tag call as internal */
225 hp->internal_call = SLP_TRUE;
226
227 (void) slp_unpackSrvReply(hp, reply, collect_DAs,
228 tl, &collator, &numResults);
229 free(reply);
230 /* invoke last call */
231 (void) slp_unpackSrvReply(hp, NULL, collect_DAs,
232 tl, &collator, &numResults);
233
234 /* revert internal call tag */
235 hp->internal_call = SLP_FALSE;
236 }
237
238 /*
239 * tl->DAs now points to a list of DAs sorted by the number of
240 * relevant scopes they serve. Using this ordering, populate the
241 * scope array lists.
242 */
243 for (te = tl->DAs; te; te = te->next)
244 add2scopes_list(te, tl);
245
246 *handle = tl;
247 return (SLP_OK);
248 }
249
slp_get_uc_scopes(slp_target_list_t * h)250 const char *slp_get_uc_scopes(slp_target_list_t *h) {
251 struct target_list *tl = (struct target_list *)h;
252 return (tl->uc_scopes);
253 }
254
slp_get_mc_scopes(slp_target_list_t * h)255 const char *slp_get_mc_scopes(slp_target_list_t *h) {
256 struct target_list *tl = (struct target_list *)h;
257 return (tl->mc_scopes);
258 }
259
slp_next_uc_target(slp_target_list_t * h)260 slp_target_t *slp_next_uc_target(slp_target_list_t *h) {
261 struct scope_targets *p;
262 struct target_list *tl = (struct target_list *)h;
263
264 if (!(*tl->state))
265 return (NULL);
266 /* find the next unused target */
267 for (; *tl->state; tl->state++) {
268 if (!(*tl->state)->da->used && !(*tl->state)->da->failed)
269 return (*tl->state++);
270 if ((*tl->state)->da->failed) {
271 /* get next failover */
272 if (p = slp_next_failover(*tl->state)) {
273 tl->state++;
274 return (p);
275 }
276 /* else nothing more we can do */
277 }
278 }
279 return (NULL);
280 }
281
slp_next_failover(slp_target_t * h)282 slp_target_t *slp_next_failover(slp_target_t *h) {
283 struct scope_targets *p = (struct scope_targets *)h;
284 for (p = p->next; p; p = p->next) {
285 if (p->da->used)
286 return (NULL); /* already did this scope */
287 if (!p->da->used && !p->da->failed)
288 return (p);
289 }
290 return (NULL);
291 }
292
slp_get_target_sin(slp_target_t * h)293 void *slp_get_target_sin(slp_target_t *h) {
294 struct scope_targets *p = (struct scope_targets *)h;
295 return (void *)(p ? &(p->da->sin) : NULL);
296 }
297
slp_mark_target_used(slp_target_t * h)298 void slp_mark_target_used(slp_target_t *h) {
299 struct scope_targets *p = (struct scope_targets *)h;
300 p->da->used = SLP_TRUE;
301 }
302
slp_mark_target_failed(slp_target_t * h)303 void slp_mark_target_failed(slp_target_t *h) {
304 struct scope_targets *p = (struct scope_targets *)h;
305 p->da->failed = SLP_TRUE;
306 }
307
slp_fabricate_target(void * s)308 slp_target_t *slp_fabricate_target(void *s) {
309 struct da_node *dn;
310 struct scope_targets *st;
311 struct sockaddr_in *sin = (struct sockaddr_in *)s;
312
313 if (!(st = malloc(sizeof (*st)))) {
314 slp_err(LOG_CRIT, 0, "slp_fabricate_target", "out of memory");
315 return (NULL);
316 }
317 if (!(dn = malloc(sizeof (*dn)))) {
318 free(st);
319 slp_err(LOG_CRIT, 0, "slp_fabricate_target", "out of memory");
320 return (NULL);
321 }
322 (void) memcpy(&(dn->sin), sin, sizeof (dn->sin));
323 dn->used = dn->failed = SLP_FALSE;
324 dn->coverage = 0;
325 dn->proximity = SLP_REMOTE_PROX;
326 dn->next = dn->prev = NULL;
327
328 st->da = dn;
329 st->next = NULL;
330
331 return (st);
332 }
333
slp_free_target(slp_target_t * target)334 void slp_free_target(slp_target_t *target) {
335 struct scope_targets *t = (struct scope_targets *)target;
336 if (!t)
337 return;
338 free(t->da);
339 free(t);
340 }
341
slp_destroy_target_list(slp_target_list_t * h)342 void slp_destroy_target_list(slp_target_list_t *h) {
343 struct da_node *das, *dap;
344 int i;
345 struct target_list *tl = (struct target_list *)h;
346
347 /* free da node list */
348 for (das = tl->DAs; das; das = dap) {
349 dap = das->next;
350 free(das->scopes);
351 free(das);
352 }
353
354 /* free scope target linked lists */
355 for (i = 0; tl->scopes[i]; i++) {
356 struct scope_targets *sts, *stp;
357 for (sts = tl->scopes[i]; sts; sts = stp) {
358 stp = sts->next;
359 free(sts);
360 }
361 }
362
363 /* free scope array */
364 free(tl->scopes);
365
366 /* free any char * lists in use */
367 if (tl->uc_scopes)
368 free(tl->uc_scopes);
369 if (tl->mc_scopes)
370 free(tl->mc_scopes);
371 free(tl->all_scopes);
372
373 /* free the target list struct */
374 free(tl);
375 }
376
add2scopes_list(struct da_node * te,struct target_list * tl)377 static void add2scopes_list(struct da_node *te, struct target_list *tl) {
378 struct scope_targets **scopes = tl->scopes;
379 char *p, *s;
380 int i;
381
382 /*
383 * for each scope in tl->uc_scopes:
384 * add this DA if it serves the scope.
385 */
386 i = 0;
387 for (s = tl->uc_scopes; s; s = p) {
388 p = slp_utf_strchr(s, ',');
389 if (p)
390 *p = 0;
391 if (slp_onlist(s, te->scopes)) {
392 struct scope_targets *st, *stp;
393 /* add this DA node to this scope's target list */
394 if (!(st = malloc(sizeof (*st)))) {
395 slp_err(LOG_CRIT, 0, "add2scopes_list",
396 "out of memory");
397 return;
398 }
399 st->da = te;
400 st->next = NULL;
401 /* find the end of the target list */
402 for (stp = scopes[i]; stp && stp->next; ) {
403 stp = stp->next;
404 }
405 if (stp)
406 stp->next = st;
407 else
408 scopes[i] = st;
409 }
410 if (p)
411 *p++ = ',';
412 i++;
413 }
414 }
415
add_da_entry(struct da_node ** tel,struct sockaddr_in * sin,char * scopes,slp_net_prox proximity,int c)416 static void add_da_entry(struct da_node **tel, struct sockaddr_in *sin,
417 char *scopes, slp_net_prox proximity, int c) {
418 struct da_node *te, *p;
419
420 if (!(te = malloc(sizeof (*te)))) {
421 slp_err(LOG_CRIT, 0, "add_da_entry", "out of memory");
422 return;
423 }
424 te->scopes = scopes;
425 te->coverage = c;
426 te->proximity = proximity;
427 (void) memcpy(&(te->sin), sin, sizeof (te->sin));
428 te->used = SLP_FALSE;
429 te->failed = SLP_FALSE;
430 te->prev = NULL;
431 te->next = NULL;
432
433 /* find its place in the list */
434 if (!(*tel)) {
435 *tel = te;
436 return;
437 }
438 for (p = *tel; p; p = p->next)
439 if (c >= p->coverage) {
440 /* found a coverage grouping; now sort by proximity */
441 for (; p && proximity < p->proximity; )
442 p = p->next;
443
444 if (!p) {
445 break;
446 }
447
448 /* add it here */
449 te->next = p;
450 te->prev = p->prev;
451 if (p->prev)
452 p->prev->next = te;
453 else
454 /* we're at the head */
455 (*tel) = te;
456 p->prev = te;
457 return;
458 }
459
460 /* didn't find a place in the list, so add it at the end */
461 for (p = *tel; p->next; )
462 p = p->next;
463
464 p->next = te;
465 te->prev = p;
466 }
467
468 /*ARGSUSED*/
collect_DAs(SLPHandle h,const char * u,unsigned short lifetime,SLPError errCode,void * cookie)469 static SLPBoolean collect_DAs(SLPHandle h, const char *u,
470 unsigned short lifetime,
471 SLPError errCode, void *cookie) {
472 SLPSrvURL *surl = NULL;
473 char *s, *p, *sscopes, *sscopes_end, *url;
474 int coverage, proximity;
475 struct sockaddr_in sin[1];
476 struct target_list *tl = (struct target_list *)cookie;
477
478 if (errCode != SLP_OK)
479 return (SLP_TRUE);
480
481 /* dup url so as not to corrupt da cache */
482 if (!(url = strdup(u))) {
483 slp_err(LOG_CRIT, 0, "collect_DAs", "out of memory");
484 return (SLP_FALSE);
485 }
486
487 /* parse url into a SLPSrvURL struct */
488 if (SLPParseSrvURL(url, &surl) != SLP_OK) {
489 return (SLP_TRUE); /* bad URL; skip it */
490 }
491
492 /* determine proximity */
493 if (slp_surl2sin(surl, sin) != SLP_OK) {
494 goto cleanup;
495 }
496 if (slp_on_localhost(h, sin->sin_addr)) {
497 proximity = SLP_LOCAL_PROX;
498 } else if (slp_on_subnet(h, sin->sin_addr)) {
499 proximity = SLP_SUBNET_PROX;
500 } else {
501 proximity = SLP_REMOTE_PROX;
502 }
503
504 /*
505 * sort the DAs into the entry list, ranked by the number of
506 * relevant scopes they serve (coverage).
507 */
508 coverage = 0;
509 if (!(sscopes = slp_utf_strchr(surl->s_pcSrvPart, '='))) {
510 /* URL part should be of the form 'scopes=...' */
511 goto cleanup;
512 }
513 sscopes++;
514
515 /* cut off host scope at end */
516 if (sscopes_end = slp_utf_strchr(sscopes, '=')) {
517 /* skip the =[hostname] at the end */
518 *sscopes_end = 0;
519 }
520
521 /* copy out the scopes part, since url will be freed after this call */
522 if (!(sscopes = strdup(sscopes))) {
523 slp_err(LOG_CRIT, 0, "collect_DAs", "out of memory");
524 free(surl);
525 return (SLP_FALSE);
526 }
527
528 for (s = tl->all_scopes; s; s = p) {
529 p = slp_utf_strchr(s, ',');
530 if (p)
531 *p = 0;
532 if (slp_onlist(s, sscopes)) {
533 /* add to uc list; remove from mc list */
534 slp_add2list(s, &(tl->uc_scopes), SLP_TRUE);
535 slp_list_subtract(s, &(tl->mc_scopes));
536 coverage++;
537 }
538 if (p)
539 *p++ = ',';
540 }
541 if (coverage)
542 add_da_entry(&(tl->DAs), sin, sscopes, proximity, coverage);
543
544 cleanup:
545 free(url);
546 if (surl) free(surl);
547
548 return (SLP_TRUE);
549 }
550
551 /*
552 * Takes a scopes list of the form 's1,s2,s3,...' and formats it into
553 * an LDAP search filter of the form '(|(SCOPETAG=s1)(SCOPETAG=s2)...)'.
554 * 'scopes' contains the scopes list; 'q' is a buffer allocated
555 * by the caller into which the result will be placed.
556 */
format_query(char * q,const char * scopes)557 static void format_query(char *q, const char *scopes) {
558 char *p, *s;
559 int more_than_one = slp_utf_strchr(scopes, ',') ? 1 : 0;
560
561 *q++ = '('; *q++ = '&';
562 if (more_than_one) {
563 *q++ = '('; *q++ = '|';
564 }
565
566 for (p = s = (char *)scopes; p; s = p) {
567 *q++ = '(';
568 (void) strcpy(q, SLP_SUN_SCOPES_TAG);
569 q += strlen(SLP_SUN_SCOPES_TAG);
570 *q++ = '=';
571
572 p = slp_utf_strchr(s, ',');
573 if (p) {
574 (void) memcpy(q, s, p - s);
575 q += (p - s);
576 p++;
577 } else {
578 (void) strcpy(q, s);
579 q += strlen(s);
580 }
581 *q++ = ')';
582 }
583
584 if (more_than_one) {
585 *q++ = ')';
586 }
587 *q++ = '(';
588 (void) strcpy(q, SLP_SUN_VERSION_TAG);
589 q += strlen(SLP_SUN_VERSION_TAG);
590 *q++ = '=';
591 *q++ = '2';
592 *q++ = ')';
593 *q++ = ')';
594 *q = 0;
595 }
596