GCOV - Varnish Cache


/*-
 * Copyright (c) 2012-2019 Varnish Software AS
 * All rights reserved.
 *
 * Author: Poul-Henning Kamp <phk@FreeBSD.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <unistd.h>

// #include "vdef.h"
//#include "vas.h"
#include "cache/cache.h"
#include "vend.h"
#include "vsa.h"
#include "vsb.h"
#include "vsha256.h"
#include "vtcp.h"
#include "vtim.h"
#include "vcc_debug_if.h"

VCL_ACL v_matchproto_(td_debug_null_acl)
xyzzy_null_acl(VRT_CTX)
{

        CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
        return (NULL);
}

VCL_ACL v_matchproto_(td_debug_acl)
xyzzy_acl(VRT_CTX, VCL_ACL acl)
{

        CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
        return (acl);
}

VCL_BOOL v_matchproto_(td_debug_match_acl)
xyzzy_match_acl(VRT_CTX, VCL_ACL acl, VCL_IP ip)
{

        CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
        assert(VSA_Sane(ip));

        return (VRT_acl_match(ctx, acl, ip));
}

/*
 * The code below is more intimate with VSA than anything is supposed to.
 */

struct acl_sweep {
        int                     family;
        const uint8_t           *ip0_p;
        const uint8_t           *ip1_p;
        struct suckaddr         *probe;
        uint8_t                 *probe_p;
        VCL_INT                 step;
        uint64_t                reset;
        uint64_t                that;
        uint64_t                count;
};

static void
reset_sweep(struct acl_sweep *asw)
{
        asw->that = asw->reset;
}

static int
setup_sweep(VRT_CTX, struct acl_sweep *asw, VCL_IP ip0, VCL_IP ip1,
    VCL_INT step)
{
        int fam0, fam1;
        const uint8_t *ptr;

        AN(asw);
        memset(asw, 0, sizeof *asw);

        AN(ip0);
        AN(ip1);
        fam0 = VSA_GetPtr(ip0, &asw->ip0_p);
        fam1 = VSA_GetPtr(ip1, &asw->ip1_p);
        if (fam0 != fam1) {
                VRT_fail(ctx, "IPs have different families (0x%x vs 0x%x)",
                    fam0, fam1);
                return (-1);
        }

        asw->family = fam0;
        if (asw->family == PF_INET) {
                if (memcmp(asw->ip0_p, asw->ip1_p, 4) > 0) {
                        VRT_fail(ctx, "Sweep: ipv4.end < ipv4.start");
                        return (-1);
                }
                asw->reset = vbe32dec(asw->ip0_p);
        } else {
                if (memcmp(asw->ip0_p, asw->ip1_p, 16) > 0) {
                        VRT_fail(ctx, "Sweep: ipv6.end < ipv6.start");
                        return (-1);
                }
                asw->reset = vbe64dec(asw->ip0_p + 8);
        }
        asw->that = asw->reset;

        /* Dont try this at home */
        asw->probe = malloc(vsa_suckaddr_len);
        AN(asw->probe);
        memcpy(asw->probe, ip0, vsa_suckaddr_len);
        (void)VSA_GetPtr(asw->probe, &ptr);
        asw->probe_p = ((uint8_t*)(asw->probe)) + (ptr - (uint8_t*)asw->probe);

        asw->step = step;

        return (0);
}

static void
cleanup_sweep(struct acl_sweep *asw)
{
        free(asw->probe);
        memset(asw, 0, sizeof *asw);
}

static int
step_sweep(struct acl_sweep *asw)
{

        AN(asw);
        asw->count++;
        asw->that += asw->step;
        if (asw->family == PF_INET) {
                vbe32enc(asw->probe_p, asw->that);
                return (memcmp(asw->probe_p, asw->ip1_p, 4));
        } else {
                vbe64enc(asw->probe_p + 8, asw->that);
                return (memcmp(asw->probe_p, asw->ip1_p, 16));
        }
}


VCL_BLOB
xyzzy_sweep_acl(VRT_CTX, VCL_ACL acl, VCL_IP ip0, VCL_IP ip1, VCL_INT step)
{
        struct acl_sweep asw[1];
        int i, j;
        struct vsb *vsb;
        char abuf[VTCP_ADDRBUFSIZE];
        char pbuf[VTCP_PORTBUFSIZE];
        unsigned char digest[VSHA256_DIGEST_LENGTH];
        struct VSHA256Context vsha[1];
        struct vrt_blob *b;
        ssize_t sz;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(acl);
        AN(ip0);
        AN(ip1);
        assert(step > 0);
        if (setup_sweep(ctx, asw, ip0, ip1, step))
                return (NULL);

        vsb = VSB_new_auto();
        AN(vsb);

        VSHA256_Init(vsha);
        for (j = 0; ; j++) {
                if ((j & 0x3f) == 0x00) {
                        VTCP_name(asw->probe, abuf, sizeof abuf,
                            pbuf, sizeof pbuf);
                        VSB_printf(vsb, "Sweep: %-15s", abuf);
                }
                i = VRT_acl_match(ctx, acl, asw->probe);
                assert(0 <= i && i <= 1);
                VSB_putc(vsb, "-X"[i]);
                if ((j & 0x3f) == 0x3f) {
                        AZ(VSB_finish(vsb));
                        VSLbs(ctx->vsl, SLT_Debug, TOSTRAND(VSB_data(vsb)));
                        sz =VSB_len(vsb);
                        assert (sz > 0);
                        VSHA256_Update(vsha, VSB_data(vsb), sz);
                        VSB_clear(vsb);
                }
                if (step_sweep(asw) > 0)
                        break;
        }
        if (VSB_len(vsb)) {
                AZ(VSB_finish(vsb));
                VSLbs(ctx->vsl, SLT_Debug, TOSTRAND(VSB_data(vsb)));
                sz =VSB_len(vsb);
                assert (sz > 0);
                VSHA256_Update(vsha, VSB_data(vsb), sz);
                VSB_clear(vsb);
        }
        VSB_destroy(&vsb);

        VSHA256_Final(digest, vsha);
        b = WS_Alloc(ctx->ws, sizeof *b + sizeof digest);
        if (b != NULL) {
                memcpy(b + 1, digest, sizeof digest);
                b->blob = b + 1;
                b->len = sizeof digest;
        }
        cleanup_sweep(asw);
        return (b);
}

VCL_DURATION
xyzzy_time_acl(VRT_CTX, VCL_ACL acl, VCL_IP ip0, VCL_IP ip1,
    VCL_INT step, VCL_INT turnus)
{
        struct acl_sweep asw[1];
        vtim_mono t0, t1;
        vtim_dur d;
        VCL_INT cnt;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(acl);
        AN(ip0);
        AN(ip1);
        assert(step > 0);
        assert(turnus > 0);

        if (setup_sweep(ctx, asw, ip0, ip1, step))
                return (-1);
        do {
                (void)VRT_acl_match(ctx, acl, asw->probe);
        } while (step_sweep(asw) <= 0);
        asw->count = 0;
        t0 = VTIM_mono();
        for (cnt = 0; cnt < turnus; cnt++) {
                reset_sweep(asw);
                do {
                        (void)VRT_acl_match(ctx, acl, asw->probe);
                } while (step_sweep(asw) <= 0);
        }
        t1 = VTIM_mono();
        cnt = asw->count;
        assert(cnt > 0);
        d = (t1 - t0) / cnt;
        VSLb(ctx->vsl, SLT_Debug,
            "Timed ACL: %.9f -> %.9f = %.9f %.9f/round, %.9f/IP %ju IPs",
            t0, t1, t1 - t0, (t1-t0) / turnus, d, (intmax_t)cnt);
        cleanup_sweep(asw);
        return (d);
}

struct xyzzy_debug_aclobj {
        unsigned                        magic;
#define VMOD_DEBUG_ACLOBJ_MAGIC 0xac10ac10
        char *                          vcl_name;
        VCL_ACL                 acl;
};

VCL_VOID v_matchproto_(td_xyzzy_debug_aclobj__init)
xyzzy_aclobj__init(VRT_CTX, struct VPFX(debug_aclobj) **op,
    const char *vcl_name, VCL_ACL acl)
{
        struct VPFX(debug_aclobj) *o;

        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        AN(op);
        AZ(*op);
        ALLOC_OBJ(o, VMOD_DEBUG_ACLOBJ_MAGIC);
        AN(o);
        REPLACE(o->vcl_name, vcl_name);
        o->acl = acl;
        *op = o;
}

VCL_VOID v_matchproto_(td_xyzzy_debug_aclobj__fini)
xyzzy_aclobj__fini(struct VPFX(debug_aclobj) **op)
{
        struct VPFX(debug_aclobj) *o;

        TAKE_OBJ_NOTNULL(o, op, VMOD_DEBUG_ACLOBJ_MAGIC);
        REPLACE(o->vcl_name, NULL);
        FREE_OBJ(o);
}

VCL_ACL v_matchproto_(td_xyzzy_debug_aclobj_get)
xyzzy_aclobj_get(VRT_CTX, struct VPFX(debug_aclobj) *o)
{
        CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
        CHECK_OBJ_NOTNULL(o, VMOD_DEBUG_ACLOBJ_MAGIC);
        return (o->acl);
}

		varnish-cache/vmod/vmod_debug_acl.c
0		/*-
1		* Copyright (c) 2012-2019 Varnish Software AS
2		* All rights reserved.
3		*
4		* Author: Poul-Henning Kamp <phk@FreeBSD.org>
5		*
6		* SPDX-License-Identifier: BSD-2-Clause
7		*
8		* Redistribution and use in source and binary forms, with or without
9		* modification, are permitted provided that the following conditions
10		* are met:
11		* 1. Redistributions of source code must retain the above copyright
12		* notice, this list of conditions and the following disclaimer.
13		* 2. Redistributions in binary form must reproduce the above copyright
14		* notice, this list of conditions and the following disclaimer in the
15		* documentation and/or other materials provided with the distribution.
16		*
17		* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18		* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19		* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20		* ARE DISCLAIMED. IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21		* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22		* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23		* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24		* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25		* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26		* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27		* SUCH DAMAGE.
28		*/
29
30		#include "config.h"
31
32		#include <stdlib.h>
33		#include <stdio.h>
34		#include <string.h>
35		#include <sys/socket.h>
36		#include <unistd.h>
37
38		// #include "vdef.h"
39		//#include "vas.h"
40		#include "cache/cache.h"
41		#include "vend.h"
42		#include "vsa.h"
43		#include "vsb.h"
44		#include "vsha256.h"
45		#include "vtcp.h"
46		#include "vtim.h"
47		#include "vcc_debug_if.h"
48
49		VCL_ACL v_matchproto_(td_debug_null_acl)
50	28	xyzzy_null_acl(VRT_CTX)
51		{
52
53	28	CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
54	28	return (NULL);
55		}
56
57		VCL_ACL v_matchproto_(td_debug_acl)
58	14	xyzzy_acl(VRT_CTX, VCL_ACL acl)
59		{
60
61	14	CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
62	14	return (acl);
63		}
64
65		VCL_BOOL v_matchproto_(td_debug_match_acl)
66	28	xyzzy_match_acl(VRT_CTX, VCL_ACL acl, VCL_IP ip)
67		{
68
69	28	CHECK_OBJ_ORNULL(ctx, VRT_CTX_MAGIC);
70	28	assert(VSA_Sane(ip));
71
72	28	return (VRT_acl_match(ctx, acl, ip));
73		}
74
75		/*
76		* The code below is more intimate with VSA than anything is supposed to.
77		*/
78
79		struct acl_sweep {
80		int family;
81		const uint8_t *ip0_p;
82		const uint8_t *ip1_p;
83		struct suckaddr *probe;
84		uint8_t *probe_p;
85		VCL_INT step;
86		uint64_t reset;
87		uint64_t that;
88		uint64_t count;
89		};
90
91		static void
92	14000	reset_sweep(struct acl_sweep *asw)
93		{
94	14000	asw->that = asw->reset;
95	14000	}
96
97		static int
98	112	setup_sweep(VRT_CTX, struct acl_sweep *asw, VCL_IP ip0, VCL_IP ip1,
99		VCL_INT step)
100		{
101		int fam0, fam1;
102		const uint8_t *ptr;
103
104	112	AN(asw);
105	112	memset(asw, 0, sizeof *asw);
106
107	112	AN(ip0);
108	112	AN(ip1);
109	112	fam0 = VSA_GetPtr(ip0, &asw->ip0_p);
110	112	fam1 = VSA_GetPtr(ip1, &asw->ip1_p);
111	112	if (fam0 != fam1) {
112	0	VRT_fail(ctx, "IPs have different families (0x%x vs 0x%x)",
113	0	fam0, fam1);
114	0	return (-1);
115		}
116
117	112	asw->family = fam0;
118	112	if (asw->family == PF_INET) {
119	42	if (memcmp(asw->ip0_p, asw->ip1_p, 4) > 0) {
120	0	VRT_fail(ctx, "Sweep: ipv4.end < ipv4.start");
121	0	return (-1);
122		}
123	42	asw->reset = vbe32dec(asw->ip0_p);
124	42	} else {
125	70	if (memcmp(asw->ip0_p, asw->ip1_p, 16) > 0) {
126	0	VRT_fail(ctx, "Sweep: ipv6.end < ipv6.start");
127	0	return (-1);
128		}
129	70	asw->reset = vbe64dec(asw->ip0_p + 8);
130		}
131	112	asw->that = asw->reset;
132
133		/* Dont try this at home */
134	112	asw->probe = malloc(vsa_suckaddr_len);
135	112	AN(asw->probe);
136	112	memcpy(asw->probe, ip0, vsa_suckaddr_len);
137	112	(void)VSA_GetPtr(asw->probe, &ptr);
138	112	asw->probe_p = ((uint8_t)(asw->probe)) + (ptr - (uint8_t)asw->probe);
139
140	112	asw->step = step;
141
142	112	return (0);
143	112	}
144
145		static void
146	112	cleanup_sweep(struct acl_sweep *asw)
147		{
148	112	free(asw->probe);
149	112	memset(asw, 0, sizeof *asw);
150	112	}
151
152		static int
153	1349460	step_sweep(struct acl_sweep *asw)
154		{
155
156	1349460	AN(asw);
157	1349460	asw->count++;
158	1349460	asw->that += asw->step;
159	1349460	if (asw->family == PF_INET) {
160	1386	vbe32enc(asw->probe_p, asw->that);
161	1386	return (memcmp(asw->probe_p, asw->ip1_p, 4));
162		} else {
163	1348074	vbe64enc(asw->probe_p + 8, asw->that);
164	1348074	return (memcmp(asw->probe_p, asw->ip1_p, 16));
165		}
166	1349460	}
167
168
169		VCL_BLOB
170	98	xyzzy_sweep_acl(VRT_CTX, VCL_ACL acl, VCL_IP ip0, VCL_IP ip1, VCL_INT step)
171		{
172		struct acl_sweep asw[1];
173		int i, j;
174		struct vsb *vsb;
175		char abuf[VTCP_ADDRBUFSIZE];
176		char pbuf[VTCP_PORTBUFSIZE];
177		unsigned char digest[VSHA256_DIGEST_LENGTH];
178		struct VSHA256Context vsha[1];
179		struct vrt_blob *b;
180		ssize_t sz;
181
182	98	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
183	98	AN(acl);
184	98	AN(ip0);
185	98	AN(ip1);
186	98	assert(step > 0);
187	98	if (setup_sweep(ctx, asw, ip0, ip1, step))
188	0	return (NULL);
189
190	98	vsb = VSB_new_auto();
191	98	AN(vsb);
192
193	98	VSHA256_Init(vsha);
194	4116	for (j = 0; ; j++) {
195	4116	if ((j & 0x3f) == 0x00) {
196	224	VTCP_name(asw->probe, abuf, sizeof abuf,
197	112	pbuf, sizeof pbuf);
198	112	VSB_printf(vsb, "Sweep: %-15s", abuf);
199	112	}
200	4116	i = VRT_acl_match(ctx, acl, asw->probe);
201	4116	assert(0 <= i && i <= 1);
202	4116	VSB_putc(vsb, "-X"[i]);
203	4116	if ((j & 0x3f) == 0x3f) {
204	14	AZ(VSB_finish(vsb));
205	14	VSLbs(ctx->vsl, SLT_Debug, TOSTRAND(VSB_data(vsb)));
206	14	sz =VSB_len(vsb);
207	14	assert (sz > 0);
208	14	VSHA256_Update(vsha, VSB_data(vsb), sz);
209	14	VSB_clear(vsb);
210	14	}
211	4116	if (step_sweep(asw) > 0)
212	98	break;
213	4018	}
214	98	if (VSB_len(vsb)) {
215	98	AZ(VSB_finish(vsb));
216	98	VSLbs(ctx->vsl, SLT_Debug, TOSTRAND(VSB_data(vsb)));
217	98	sz =VSB_len(vsb);
218	98	assert (sz > 0);
219	98	VSHA256_Update(vsha, VSB_data(vsb), sz);
220	98	VSB_clear(vsb);
221	98	}
222	98	VSB_destroy(&vsb);
223
224	98	VSHA256_Final(digest, vsha);
225	98	b = WS_Alloc(ctx->ws, sizeof *b + sizeof digest);
226	98	if (b != NULL) {
227	98	memcpy(b + 1, digest, sizeof digest);
228	98	b->blob = b + 1;
229	98	b->len = sizeof digest;
230	98	}
231	98	cleanup_sweep(asw);
232	98	return (b);
233	98	}
234
235		VCL_DURATION
236	14	xyzzy_time_acl(VRT_CTX, VCL_ACL acl, VCL_IP ip0, VCL_IP ip1,
237		VCL_INT step, VCL_INT turnus)
238		{
239		struct acl_sweep asw[1];
240		vtim_mono t0, t1;
241		vtim_dur d;
242		VCL_INT cnt;
243
244	14	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
245	14	AN(acl);
246	14	AN(ip0);
247	14	AN(ip1);
248	14	assert(step > 0);
249	14	assert(turnus > 0);
250
251	14	if (setup_sweep(ctx, asw, ip0, ip1, step))
252	0	return (-1);
253	14	do {
254	1344	(void)VRT_acl_match(ctx, acl, asw->probe);
255	1344	} while (step_sweep(asw) <= 0);
256	14	asw->count = 0;
257	14	t0 = VTIM_mono();
258	14014	for (cnt = 0; cnt < turnus; cnt++) {
259	14000	reset_sweep(asw);
260	14000	do {
261	1344000	(void)VRT_acl_match(ctx, acl, asw->probe);
262	1344000	} while (step_sweep(asw) <= 0);
263	14000	}
264	14	t1 = VTIM_mono();
265	14	cnt = asw->count;
266	14	assert(cnt > 0);
267	14	d = (t1 - t0) / cnt;
268	28	VSLb(ctx->vsl, SLT_Debug,
269		"Timed ACL: %.9f -> %.9f = %.9f %.9f/round, %.9f/IP %ju IPs",
270	14	t0, t1, t1 - t0, (t1-t0) / turnus, d, (intmax_t)cnt);
271	14	cleanup_sweep(asw);
272	14	return (d);
273	14	}
274
275		struct xyzzy_debug_aclobj {
276		unsigned magic;
277		#define VMOD_DEBUG_ACLOBJ_MAGIC 0xac10ac10
278		char * vcl_name;
279		VCL_ACL acl;
280		};
281
282		VCL_VOID v_matchproto_(td_xyzzy_debug_aclobj__init)
283	28	xyzzy_aclobj__init(VRT_CTX, struct VPFX(debug_aclobj) **op,
284		const char *vcl_name, VCL_ACL acl)
285		{
286		struct VPFX(debug_aclobj) *o;
287
288	28	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
289	28	AN(op);
290	28	AZ(*op);
291	28	ALLOC_OBJ(o, VMOD_DEBUG_ACLOBJ_MAGIC);
292	28	AN(o);
293	28	REPLACE(o->vcl_name, vcl_name);
294	28	o->acl = acl;
295	28	*op = o;
296	28	}
297
298		VCL_VOID v_matchproto_(td_xyzzy_debug_aclobj__fini)
299	0	xyzzy_aclobj__fini(struct VPFX(debug_aclobj) **op)
300		{
301		struct VPFX(debug_aclobj) *o;
302
303	0	TAKE_OBJ_NOTNULL(o, op, VMOD_DEBUG_ACLOBJ_MAGIC);
304	0	REPLACE(o->vcl_name, NULL);
305	0	FREE_OBJ(o);
306	0	}
307
308		VCL_ACL v_matchproto_(td_xyzzy_debug_aclobj_get)
309	28	xyzzy_aclobj_get(VRT_CTX, struct VPFX(debug_aclobj) *o)
310		{
311	28	CHECK_OBJ_NOTNULL(ctx, VRT_CTX_MAGIC);
312	28	CHECK_OBJ_NOTNULL(o, VMOD_DEBUG_ACLOBJ_MAGIC);
313	28	return (o->acl);
314		}