20
20
* it under the terms of the GNU General Public License as published by
21
21
* the Free Software Foundation; either version 2 of the License, or
22
22
* (at your option) any later version.
24
24
* This program is distributed in the hope that it will be useful,
25
25
* but WITHOUT ANY WARRANTY; without even the implied warranty of
26
26
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
27
27
* GNU General Public License for more details.
29
29
* You should have received a copy of the GNU General Public License
30
30
* along with this program; if not, write to the Free Software
31
31
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
113
113
struct squid_radix_mask *squid_rn_mkfreelist;
114
114
struct squid_radix_node_head *squid_mask_rnhead;
115
115
static char *addmask_key;
116
static unsigned char normal_chars[] =
117
{0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xFF};
116
static unsigned char normal_chars[] = {0, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xFF};
118
117
static char *rn_zeros, *rn_ones;
159
158
* We define the index of a route to associated with the mask to be
160
159
* the first bit number in the mask where 0 occurs (with bit number 0
161
160
* representing the highest order bit).
163
162
* We say a mask is normal if every bit is 0, past the index of the mask.
164
163
* If a node n has a descendant (k, m) with index(m) == index(n) == rn_b,
165
164
* and m is a normal mask, then the route applies to every descendant of n.
166
165
* If the index(m) < rn_b, this implies the trailing last few bits of k
167
166
* before bit b are all 0, (and hence consequently true of every descendant
168
167
* of n), so the route applies to all descendants of the node as well.
170
169
* Similar logic shows that a non-normal mask m such that
171
170
* index(m) <= index(n) could potentially apply to many children of n.
172
171
* Thus, for each non-host route, we attach its mask to a list at an internal
173
* node as high in the tree as we can go.
172
* node as high in the tree as we can go.
175
174
* The present version of the code makes use of normal routes in short-
176
175
* circuiting an explict mask and compare operation when testing whether
181
180
struct squid_radix_node *
182
squid_rn_search(void *v_arg, struct squid_radix_node *head)
181
squid_rn_search(void *v_arg, struct squid_radix_node *head) {
184
182
register struct squid_radix_node *x;
185
183
register caddr_t v;
187
185
for (x = head, v = v_arg; x->rn_b >= 0;) {
188
if (x->rn_bmask & v[x->rn_off])
186
if (x->rn_bmask & v[x->rn_off])
196
194
struct squid_radix_node *
197
squid_rn_search_m(void *v_arg, struct squid_radix_node *head, void *m_arg)
195
squid_rn_search_m(void *v_arg, struct squid_radix_node *head, void *m_arg) {
199
196
register struct squid_radix_node *x;
200
197
register caddr_t v = v_arg, m = m_arg;
202
199
for (x = head; x->rn_b >= 0;) {
203
if ((x->rn_bmask & m[x->rn_off]) &&
204
(x->rn_bmask & v[x->rn_off]))
200
if ((x->rn_bmask & m[x->rn_off]) &&
201
(x->rn_bmask & v[x->rn_off]))
218
215
int masks_are_equal = 1;
222
219
while (n < lim) {
231
228
if (masks_are_equal && (longer < 0))
232
for (lim2 = m - longer; m < lim2;)
229
for (lim2 = m - longer; m < lim2;)
235
232
return (!masks_are_equal);
238
235
struct squid_radix_node *
239
squid_rn_lookup(void *v_arg, void *m_arg, struct squid_radix_node_head *head)
236
squid_rn_lookup(void *v_arg, void *m_arg, struct squid_radix_node_head *head) {
241
237
register struct squid_radix_node *x;
242
238
caddr_t netmask = 0;
245
if ((x = squid_rn_addmask(m_arg, 1, head->rnh_treetop->rn_off)) == 0)
241
if ((x = squid_rn_addmask(m_arg, 1, head->rnh_treetop->rn_off)) == 0)
249
245
x = squid_rn_match(v_arg, head);
250
246
if (x && netmask) {
251
while (x && x->rn_mask != netmask)
247
while (x && x->rn_mask != netmask)
262
258
int length = min(*(u_char *) cp, *(u_char *) cp2);
267
length = min(length, *(u_char *) cp3);
263
length = min(length, *(u_char *) cp3);
268
264
cplim = cp + length;
271
267
for (cp += skip; cp < cplim; cp++, cp2++, cp3++)
272
if ((*cp ^ *cp2) & *cp3)
268
if ((*cp ^ *cp2) & *cp3)
277
273
struct squid_radix_node *
278
squid_rn_match(void *v_arg, struct squid_radix_node_head *head)
274
squid_rn_match(void *v_arg, struct squid_radix_node_head *head) {
280
275
caddr_t v = v_arg;
281
276
register struct squid_radix_node *t = head->rnh_treetop, *x;
282
277
register caddr_t cp = v, cp2;
332
327
* If there is a host route in a duped-key chain, it will be first.
334
329
if ((saved_t = t)->rn_mask == 0)
336
331
for (; t; t = t->rn_dupedkey)
338
* Even if we don't match exactly as a host,
339
* we may match if the leaf we wound up at is
342
if (t->rn_flags & RNF_NORMAL) {
345
} else if (rn_satsifies_leaf(v, t, matched_off))
333
* Even if we don't match exactly as a host,
334
* we may match if the leaf we wound up at is
337
if (t->rn_flags & RNF_NORMAL) {
340
} else if (rn_satsifies_leaf(v, t, matched_off))
348
343
/* start searching up the tree */
350
register struct squid_radix_mask *m;
352
if ((m = t->rn_mklist)) {
354
* If non-contiguous masks ever become important
355
* we can restore the masking and open coding of
356
* the search and satisfaction test and put the
357
* calculation of "off" back before the "do".
360
if (m->rm_flags & RNF_NORMAL) {
364
off = min(t->rn_off, matched_off);
365
x = squid_rn_search_m(v, t, m->rm_mask);
366
while (x && x->rn_mask != m->rm_mask)
368
if (x && rn_satsifies_leaf(v, x, off))
371
} while ((m = m->rm_mklist));
345
register struct squid_radix_mask *m;
347
if ((m = t->rn_mklist)) {
349
* If non-contiguous masks ever become important
350
* we can restore the masking and open coding of
351
* the search and satisfaction test and put the
352
* calculation of "off" back before the "do".
355
if (m->rm_flags & RNF_NORMAL) {
359
off = min(t->rn_off, matched_off);
360
x = squid_rn_search_m(v, t, m->rm_mask);
361
while (x && x->rn_mask != m->rm_mask)
363
if (x && rn_satsifies_leaf(v, x, off))
366
} while ((m = m->rm_mklist));
373
368
} while (t != top);
417
410
* Find first bit at which v and t->rn_key differ
420
register caddr_t cp2 = t->rn_key + head_off;
421
register int cmp_res;
422
caddr_t cplim = v + vlen;
413
register caddr_t cp2 = t->rn_key + head_off;
414
register int cmp_res;
415
caddr_t cplim = v + vlen;
431
cmp_res = (cp[-1] ^ cp2[-1]) & 0xff;
432
for (b = (cp - v) << 3; cmp_res; b--)
424
cmp_res = (cp[-1] ^ cp2[-1]) & 0xff;
425
for (b = (cp - v) << 3; cmp_res; b--)
436
register struct squid_radix_node *p, *x = top;
440
if (cp[x->rn_off] & x->rn_bmask)
444
} while (b > (unsigned) x->rn_b); /* x->rn_b < b && x->rn_b >= 0 */
429
register struct squid_radix_node *p, *x = top;
433
if (cp[x->rn_off] & x->rn_bmask)
437
} while (b > (unsigned) x->rn_b); /* x->rn_b < b && x->rn_b >= 0 */
447
fprintf(stderr, "squid_rn_insert: Going In:\n");
440
fprintf(stderr, "squid_rn_insert: Going In:\n");
450
t = squid_rn_newpair(v_arg, b, nodes);
452
if ((cp[p->rn_off] & p->rn_bmask) == 0)
457
t->rn_p = p; /* frees x, p as temp vars below */
458
if ((cp[t->rn_off] & t->rn_bmask) == 0) {
443
t = squid_rn_newpair(v_arg, b, nodes);
445
if ((cp[p->rn_off] & p->rn_bmask) == 0)
450
t->rn_p = p; /* frees x, p as temp vars below */
451
if ((cp[t->rn_off] & t->rn_bmask) == 0) {
466
log(LOG_DEBUG, "squid_rn_insert: Coming Out:\n"), traverse(p);
459
log(LOG_DEBUG, "squid_rn_insert: Coming Out:\n"), traverse(p);
472
465
struct squid_radix_node *
473
squid_rn_addmask(void *n_arg, int search, int skip)
466
squid_rn_addmask(void *n_arg, int search, int skip) {
475
467
caddr_t netmask = (caddr_t) n_arg;
476
468
register struct squid_radix_node *x;
477
469
register caddr_t cp, cplim;
481
473
static int last_zeroed = 0;
483
475
if ((mlen = *(u_char *) netmask) > squid_max_keylen)
484
mlen = squid_max_keylen;
476
mlen = squid_max_keylen;
487
479
if (mlen <= skip)
488
return (squid_mask_rnhead->rnh_nodes);
480
return (squid_mask_rnhead->rnh_nodes);
490
memcpy(addmask_key + 1, rn_ones + 1, skip - 1);
482
memcpy(addmask_key + 1, rn_ones + 1, skip - 1);
491
483
if ((m0 = mlen) > skip)
492
memcpy(addmask_key + skip, netmask + skip, mlen - skip);
484
memcpy(addmask_key + skip, netmask + skip, mlen - skip);
494
486
* Trim trailing zeroes.
496
488
for (cp = addmask_key + mlen; (cp > addmask_key) && cp[-1] == 0;)
498
490
mlen = cp - addmask_key;
499
491
if (mlen <= skip) {
500
if (m0 >= last_zeroed)
502
return (squid_mask_rnhead->rnh_nodes);
492
if (m0 >= last_zeroed)
494
return (squid_mask_rnhead->rnh_nodes);
504
496
if (m0 < last_zeroed)
505
memset(addmask_key + m0, '\0', last_zeroed - m0);
497
memset(addmask_key + m0, '\0', last_zeroed - m0);
506
498
*addmask_key = last_zeroed = mlen;
507
499
x = squid_rn_search(addmask_key, rn_masktop);
508
500
if (memcmp(addmask_key, x->rn_key, mlen) != 0)
512
504
squid_R_Malloc(x, struct squid_radix_node *, squid_max_keylen + 2 * sizeof(*x));
513
505
if ((saved_x = x) == 0)
515
507
memset(x, '\0', squid_max_keylen + 2 * sizeof(*x));
516
508
netmask = cp = (caddr_t) (x + 2);
517
509
memcpy(cp, addmask_key, mlen);
518
510
x = squid_rn_insert(cp, squid_mask_rnhead, &maskduplicated, x);
519
511
if (maskduplicated) {
520
fprintf(stderr, "squid_rn_addmask: mask impossibly already in tree");
512
fprintf(stderr, "squid_rn_addmask: mask impossibly already in tree");
525
517
* Calculate index of mask, and check for normalcy.
547
539
register u_char *mp = m_arg, *np = n_arg, *lim;
550
return 1; /* not really, but need to check longer one first */
542
return 1; /* not really, but need to check longer one first */
552
for (lim = mp + *mp; mp < lim;)
544
for (lim = mp + *mp; mp < lim;)
558
550
static struct squid_radix_mask *
559
rn_new_radix_mask(struct squid_radix_node *tt, struct squid_radix_mask *next)
551
rn_new_radix_mask(struct squid_radix_node *tt, struct squid_radix_mask *next) {
561
552
register struct squid_radix_mask *m;
565
fprintf(stderr, "Mask for route not entered\n");
556
fprintf(stderr, "Mask for route not entered\n");
568
559
memset(m, '\0', sizeof *m);
569
560
m->rm_b = tt->rn_b;
570
561
m->rm_flags = tt->rn_flags;
571
562
if (tt->rn_flags & RNF_NORMAL)
574
m->rm_mask = tt->rn_mask;
565
m->rm_mask = tt->rn_mask;
575
566
m->rm_mklist = next;
576
567
tt->rn_mklist = m;
580
571
struct squid_radix_node *
581
squid_rn_addroute(void *v_arg, void *n_arg, struct squid_radix_node_head *head, struct squid_radix_node treenodes[2])
572
squid_rn_addroute(void *v_arg, void *n_arg, struct squid_radix_node_head *head, struct squid_radix_node treenodes[2]) {
583
573
caddr_t v = (caddr_t) v_arg, netmask = (caddr_t) n_arg;
584
574
register struct squid_radix_node *t, *x = NULL, *tt;
585
575
struct squid_radix_node *saved_tt, *top = head->rnh_treetop;
596
586
* nodes and possibly save time in calculating indices.
599
if ((x = squid_rn_addmask(netmask, 0, top->rn_off)) == 0)
589
if ((x = squid_rn_addmask(netmask, 0, top->rn_off)) == 0)
606
596
* Deal with duplicated keys: attach node to previous instance
608
598
saved_tt = tt = squid_rn_insert(v, head, &keyduplicated, treenodes);
609
599
if (keyduplicated) {
610
for (t = tt; tt; t = tt, tt = tt->rn_dupedkey) {
611
if (tt->rn_mask == netmask)
615
((b_leaf < tt->rn_b) || /* index(netmask) > node */
616
squid_rn_refines(netmask, tt->rn_mask) ||
617
rn_lexobetter(netmask, tt->rn_mask))))
621
* If the mask is not duplicated, we wouldn't
622
* find it among possible duplicate key entries
623
* anyway, so the above test doesn't hurt.
625
* We sort the masks for a duplicated key the same way as
626
* in a masklist -- most specific to least specific.
627
* This may require the unfortunate nuisance of relocating
628
* the head of the list.
630
if (tt == saved_tt) {
631
struct squid_radix_node *xx = x;
632
/* link in at head of list */
633
(tt = treenodes)->rn_dupedkey = t;
634
tt->rn_flags = t->rn_flags;
635
tt->rn_p = x = t->rn_p;
643
(tt = treenodes)->rn_dupedkey = t->rn_dupedkey;
600
for (t = tt; tt; t = tt, tt = tt->rn_dupedkey) {
601
if (tt->rn_mask == netmask)
605
((b_leaf < tt->rn_b) || /* index(netmask) > node */
606
squid_rn_refines(netmask, tt->rn_mask) ||
607
rn_lexobetter(netmask, tt->rn_mask))))
611
* If the mask is not duplicated, we wouldn't
612
* find it among possible duplicate key entries
613
* anyway, so the above test doesn't hurt.
615
* We sort the masks for a duplicated key the same way as
616
* in a masklist -- most specific to least specific.
617
* This may require the unfortunate nuisance of relocating
618
* the head of the list.
620
if (tt == saved_tt) {
621
struct squid_radix_node *xx = x;
622
/* link in at head of list */
625
tt->rn_flags = t->rn_flags;
626
tt->rn_p = x = t->rn_p;
635
tt->rn_dupedkey = t->rn_dupedkey;
648
tt->rn_info = rn_nodenum++;
649
t->rn_info = rn_nodenum++;
651
tt->rn_ybro = rn_clist;
640
tt->rn_info = rn_nodenum++;
641
t->rn_info = rn_nodenum++;
643
tt->rn_ybro = rn_clist;
654
tt->rn_key = (caddr_t) v;
656
tt->rn_flags = RNF_ACTIVE;
646
tt->rn_key = (caddr_t) v;
648
tt->rn_flags = RNF_ACTIVE;
659
651
* Put mask in tree.
662
tt->rn_mask = netmask;
664
tt->rn_flags |= x->rn_flags & RNF_NORMAL;
654
tt->rn_mask = netmask;
656
tt->rn_flags |= x->rn_flags & RNF_NORMAL;
666
658
t = saved_tt->rn_p;
667
659
if (keyduplicated)
669
661
b_leaf = -1 - t->rn_b;
670
662
if (t->rn_r == saved_tt)
674
666
/* Promote general routes from below */
675
667
if (x->rn_b < 0) {
676
for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
677
if (x->rn_mask && (x->rn_b >= b_leaf) && x->rn_mklist == 0) {
678
if ((*mp = m = rn_new_radix_mask(x, 0)))
668
for (mp = &t->rn_mklist; x; x = x->rn_dupedkey)
669
if (x->rn_mask && (x->rn_b >= b_leaf) && x->rn_mklist == 0) {
670
if ((*mp = m = rn_new_radix_mask(x, 0)))
681
673
} else if (x->rn_mklist) {
683
* Skip over masks whose index is > that of new node
685
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
686
if (m->rm_b >= b_leaf)
675
* Skip over masks whose index is > that of new node
677
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
678
if (m->rm_b >= b_leaf)
692
684
/* Add new route to highest possible ancestor's list */
693
685
if ((netmask == 0) || (b > t->rn_b))
694
return tt; /* can't lift at all */
686
return tt; /* can't lift at all */
695
687
b_leaf = tt->rn_b;
699
691
} while (b <= t->rn_b && x != top);
701
693
* Search through routes associated with node to
704
696
* double loop on deletion.
706
698
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist) {
707
if (m->rm_b < b_leaf)
709
if (m->rm_b > b_leaf)
711
if (m->rm_flags & RNF_NORMAL) {
712
mmask = m->rm_leaf->rn_mask;
713
if (tt->rn_flags & RNF_NORMAL) {
715
"Non-unique normal route, mask not entered");
720
if (mmask == netmask) {
725
if (squid_rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
699
if (m->rm_b < b_leaf)
701
if (m->rm_b > b_leaf)
703
if (m->rm_flags & RNF_NORMAL) {
704
mmask = m->rm_leaf->rn_mask;
705
if (tt->rn_flags & RNF_NORMAL) {
707
"Non-unique normal route, mask not entered");
712
if (mmask == netmask) {
717
if (squid_rn_refines(netmask, mmask) || rn_lexobetter(netmask, mmask))
728
720
*mp = rn_new_radix_mask(tt, *mp);
732
724
struct squid_radix_node *
733
squid_rn_delete(void *v_arg, void *netmask_arg, struct squid_radix_node_head *head)
725
squid_rn_delete(void *v_arg, void *netmask_arg, struct squid_radix_node_head *head) {
735
726
register struct squid_radix_node *t, *p, *x, *tt;
736
727
struct squid_radix_mask *m, *saved_m, **mp;
737
728
struct squid_radix_node *dupedkey, *saved_tt, *top;
750
memcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
741
memcmp(v + head_off, tt->rn_key + head_off, vlen - head_off))
753
744
* Delete our route from mask lists.
756
if ((x = squid_rn_addmask(netmask, 1, head_off)) == 0)
759
while (tt->rn_mask != netmask)
760
if ((tt = tt->rn_dupedkey) == 0)
747
if ((x = squid_rn_addmask(netmask, 1, head_off)) == 0)
750
while (tt->rn_mask != netmask)
751
if ((tt = tt->rn_dupedkey) == 0)
763
754
if (tt->rn_mask == 0 || (saved_m = m = tt->rn_mklist) == 0)
765
756
if (tt->rn_flags & RNF_NORMAL) {
766
if (m->rm_leaf != tt || m->rm_refs > 0) {
767
fprintf(stderr, "squid_rn_delete: inconsistent annotation\n");
768
return 0; /* dangling ref could cause disaster */
757
if (m->rm_leaf != tt || m->rm_refs > 0) {
758
fprintf(stderr, "squid_rn_delete: inconsistent annotation\n");
759
return 0; /* dangling ref could cause disaster */
771
if (m->rm_mask != tt->rn_mask) {
772
fprintf(stderr, "squid_rn_delete: inconsistent annotation\n");
775
if (--m->rm_refs >= 0)
762
if (m->rm_mask != tt->rn_mask) {
763
fprintf(stderr, "squid_rn_delete: inconsistent annotation\n");
766
if (--m->rm_refs >= 0)
778
769
b = -1 - tt->rn_b;
779
770
t = saved_tt->rn_p;
781
goto on1; /* Wasn't lifted at all */
772
goto on1; /* Wasn't lifted at all */
785
776
} while (b <= t->rn_b && x != top);
786
777
for (mp = &x->rn_mklist; (m = *mp); mp = &m->rm_mklist)
793
fprintf(stderr, "squid_rn_delete: couldn't find our annotation\n");
794
if (tt->rn_flags & RNF_NORMAL)
795
return (0); /* Dangling ref to us */
784
fprintf(stderr, "squid_rn_delete: couldn't find our annotation\n");
785
if (tt->rn_flags & RNF_NORMAL)
786
return (0); /* Dangling ref to us */
799
790
* Eliminate us from tree
801
792
if (tt->rn_flags & RNF_ROOT)
804
795
/* Get us out of the creation list */
805
796
for (t = rn_clist; t && t->rn_ybro != tt; t = t->rn_ybro) {
808
t->rn_ybro = tt->rn_ybro;
799
t->rn_ybro = tt->rn_ybro;
811
802
if ((dupedkey = saved_tt->rn_dupedkey)) {
812
if (tt == saved_tt) {
820
for (x = p = saved_tt; p && p->rn_dupedkey != tt;)
823
p->rn_dupedkey = tt->rn_dupedkey;
825
fprintf(stderr, "squid_rn_delete: couldn't find us\n");
828
if (t->rn_flags & RNF_ACTIVE) {
803
if (tt == saved_tt) {
811
for (x = p = saved_tt; p && p->rn_dupedkey != tt;)
814
p->rn_dupedkey = tt->rn_dupedkey;
816
fprintf(stderr, "squid_rn_delete: couldn't find us\n");
819
if (t->rn_flags & RNF_ACTIVE) {
847
838
if (t->rn_l == tt)
852
843
if (p->rn_r == t)
858
849
* Demote routes attached to us.
860
851
if (t->rn_mklist) {
862
for (mp = &x->rn_mklist; (m = *mp);)
866
/* If there are any key,mask pairs in a sibling
867
* duped-key chain, some subset will appear sorted
868
* in the same order attached to our mklist */
869
for (m = t->rn_mklist; m && x; x = x->rn_dupedkey)
870
if (m == x->rn_mklist) {
871
struct squid_radix_mask *mm = m->rm_mklist;
873
if (--(m->rm_refs) < 0)
853
for (mp = &x->rn_mklist; (m = *mp);)
857
/* If there are any key,mask pairs in a sibling
858
* duped-key chain, some subset will appear sorted
859
* in the same order attached to our mklist */
860
for (m = t->rn_mklist; m && x; x = x->rn_dupedkey)
861
if (m == x->rn_mklist) {
862
struct squid_radix_mask *mm = m->rm_mklist;
864
if (--(m->rm_refs) < 0)
879
fprintf(stderr, "%s %x at %x\n",
880
"squid_rn_delete: Orphaned Mask", (int) m, (int) x);
870
fprintf(stderr, "%s %x at %x\n",
871
"squid_rn_delete: Orphaned Mask", (int) m, (int) x);
887
878
* We may be holding an active internal node in the tree.
923
914
/* First time through node, go left */
924
915
while (rn->rn_b >= 0)
928
/* If at right child go back up, otherwise, go right */
929
while (rn->rn_p->rn_r == rn && (rn->rn_flags & RNF_ROOT) == 0)
931
/* Find the next *leaf* since next node might vanish, too */
932
for (rn = rn->rn_p->rn_r; rn->rn_b >= 0;)
936
while ((rn = base)) {
937
base = rn->rn_dupedkey;
938
if (!(rn->rn_flags & RNF_ROOT) && (error = (*f) (rn, w)))
942
if (rn->rn_flags & RNF_ROOT)
919
/* If at right child go back up, otherwise, go right */
920
while (rn->rn_p->rn_r == rn && (rn->rn_flags & RNF_ROOT) == 0)
922
/* Find the next *leaf* since next node might vanish, too */
923
for (rn = rn->rn_p->rn_r; rn->rn_b >= 0;)
927
while ((rn = base)) {
928
base = rn->rn_dupedkey;
929
if (!(rn->rn_flags & RNF_ROOT) && (error = (*f) (rn, w)))
933
if (rn->rn_flags & RNF_ROOT)
983
974
struct domain *dom;
985
976
for (dom = domains; dom; dom = dom->dom_next)
986
if (dom->dom_maxrtkey > squid_max_keylen)
987
squid_max_keylen = dom->dom_maxrtkey;
977
if (dom->dom_maxrtkey > squid_max_keylen)
978
squid_max_keylen = dom->dom_maxrtkey;
989
980
if (squid_max_keylen == 0) {
991
"squid_rn_init: radix functions require squid_max_keylen be set\n");
982
"squid_rn_init: radix functions require squid_max_keylen be set\n");
994
985
squid_R_Malloc(rn_zeros, char *, 3 * squid_max_keylen);
995
986
if (rn_zeros == NULL) {
996
fprintf(stderr, "squid_rn_init failed.\n");
987
fprintf(stderr, "squid_rn_init failed.\n");
999
990
memset(rn_zeros, '\0', 3 * squid_max_keylen);
1000
991
rn_ones = cp = rn_zeros + squid_max_keylen;
1001
992
addmask_key = cplim = rn_ones + squid_max_keylen;
1002
993
while (cp < cplim)
1004
995
if (squid_rn_inithead(&squid_mask_rnhead, 0) == 0) {
1005
fprintf(stderr, "rn_init2 failed.\n");
996
fprintf(stderr, "rn_init2 failed.\n");
added
removed
lib/radix.c
