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 (c) 2001 by Sun Microsystems, Inc.
24 * All rights reserved.
25 */
26
27 #ifndef _DHCP_SVC_PRIVATE_H
28 #define _DHCP_SVC_PRIVATE_H
29
30 #pragma ident "%Z%%M% %I% %E% SMI"
31
32 /*
33 * Contains SMI-private interfaces to DHCP data service. DO NOT SHIP!
34 */
35
36 #ifdef __cplusplus
37 extern "C" {
38 #endif
39
40 #include <sys/types.h>
41 #include <stddef.h>
42 #include <dhcp_svc_confopt.h>
43 #include <dhcp_svc_public.h>
44
45 #define DSVC_PRIVATE_VERSION 1 /* Version of private layer API */
46 #define DSVC_MODULE_DIR "/usr/lib/inet/dhcp/svc"
47 #define DSVC_PUBLIC_PREFIX "ds"
48
49 /*
50 * Public (service provider) layer definitions at boundary with private layer.
51 */
52 typedef int (*dsvc_splfuncp_t)();
53
54 typedef struct {
55 dsvc_splfuncp_t status;
56 dsvc_splfuncp_t version;
57 dsvc_splfuncp_t mklocation;
58 dsvc_splfuncp_t list_dt;
59 dsvc_splfuncp_t open_dt;
60 dsvc_splfuncp_t close_dt;
61 dsvc_splfuncp_t remove_dt;
62 dsvc_splfuncp_t lookup_dt;
63 dsvc_splfuncp_t add_dt;
64 dsvc_splfuncp_t modify_dt;
65 dsvc_splfuncp_t delete_dt;
66 dsvc_splfuncp_t list_dn;
67 dsvc_splfuncp_t open_dn;
68 dsvc_splfuncp_t close_dn;
69 dsvc_splfuncp_t remove_dn;
70 dsvc_splfuncp_t lookup_dn;
71 dsvc_splfuncp_t add_dn;
72 dsvc_splfuncp_t modify_dn;
73 dsvc_splfuncp_t delete_dn;
74 } dsvc_splapi_t;
75
76 #define DSVC_NSPLFUNCS (sizeof (dsvc_splapi_t) / sizeof (dsvc_splfuncp_t))
77 #define DSVC_CUR_CONVER (-1) /* magic "get the current version" token */
78
79 typedef struct {
80 char *d_resource; /* datastore name; e.g. "SUNWfiles" */
81 char *d_location; /* location of datastore containers */
82 char *d_config; /* datastore-specific config data */
83 int d_conver; /* container version */
84 } dsvc_datastore_t;
85
86 /*
87 * Container types.
88 */
89 typedef enum {
90 DSVC_DHCPTAB,
91 DSVC_DHCPNETWORK
92 } dsvc_contype_t;
93
94 /*
95 * Container ID: so far just the network and netmask for DSVC_DHCPNETWORK
96 * containers, but may include more information in the future.
97 */
98 typedef struct {
99 struct in_addr c_net; /* network number */
100 struct in_addr c_mask; /* netmask */
101 } dsvc_conid_t;
102
103 struct dsvc_synch_ops; /* forward declaration */
104
105 /*
106 * Per-handle synchronization information, used when modules require
107 * private-layer synchronization.
108 */
109 typedef struct {
110 dsvc_datastore_t *s_datastore; /* datastore backpointer */
111 char s_loctoken[MAXPATHLEN];
112 char *s_conname; /* container name */
113 boolean_t s_nonblock; /* container opened NONBLOCK */
114 struct dsvc_synch_ops *s_ops; /* pointer to ops vector */
115 void *s_data; /* synch-layer private data */
116 } dsvc_synch_t;
117
118 /*
119 * Synchronization operations; each synchronization strategy must implement
120 * these operations. Right now, we only have one synchronization strategy,
121 * but this may change someday.
122 */
123 typedef struct dsvc_synch_ops {
124 int (*synch_init)(dsvc_synch_t *, unsigned int);
125 void (*synch_fini)(dsvc_synch_t *);
126 int (*synch_rdlock)(dsvc_synch_t *, void **);
127 int (*synch_wrlock)(dsvc_synch_t *, void **);
128 int (*synch_unlock)(dsvc_synch_t *, void *);
129 } dsvc_synch_ops_t;
130
131 #define DSVC_SYNCH_INIT(sp, flags) ((sp)->s_ops->synch_init((sp), (flags)))
132 #define DSVC_SYNCH_FINI(sp) ((sp)->s_ops->synch_fini((sp)))
133 #define DSVC_SYNCH_RDLOCK(sp, cp) ((sp)->s_ops->synch_rdlock((sp), (cp)))
134 #define DSVC_SYNCH_WRLOCK(sp, cp) ((sp)->s_ops->synch_wrlock((sp), (cp)))
135 #define DSVC_SYNCH_UNLOCK(sp, c) ((sp)->s_ops->synch_unlock((sp), (c)))
136
137 /*
138 * We divide the dsvc_synchtype_t up into two parts: a strategy part and a
139 * flags part. Right now, the only flag tells private layer to request
140 * cross-host synchronization. This is here instead of <dhcp_svc_public.h>
141 * since it's not a public interface and there's nowhere better to put it.
142 */
143 #define DSVC_SYNCH_FLAGMASK 0xffff0000
144 #define DSVC_SYNCH_STRATMASK 0x0000ffff
145 #define DSVC_SYNCH_CROSSHOST 0x00010000
146
147 /*
148 * Private layer handle, one per open instance of a container.
149 * Allocated by open_dd(), destroyed by close_dd().
150 */
151 typedef struct dsvc_handle {
152 dsvc_datastore_t d_desc; /* datastore descriptor */
153 void *d_instance; /* dlopen() instance */
154 dsvc_contype_t d_type; /* container type */
155 dsvc_conid_t d_conid; /* container id */
156 void *d_hand; /* public module handle */
157 dsvc_synch_t *d_synch; /* synchronization state */
158 dsvc_splapi_t d_api; /* service provider layer API */
159 } *dsvc_handle_t;
160
161 /*
162 * Quick-n-dirty check for an invalid dsvc_handle_t.
163 */
164 #define DSVC_HANDLE_INVAL(h) ((h) == NULL || (h)->d_instance == NULL || \
165 (h)->d_hand == NULL)
166
167 extern int enumerate_dd(char ***, int *);
168 extern int list_dd(dsvc_datastore_t *, dsvc_contype_t, char ***, uint_t *);
169 extern int status_dd(dsvc_datastore_t *);
170 extern int mklocation_dd(dsvc_datastore_t *);
171 extern int add_dd_entry(dsvc_handle_t, void *);
172 extern int modify_dd_entry(dsvc_handle_t, const void *, void *);
173 extern int delete_dd_entry(dsvc_handle_t, void *);
174 extern int close_dd(dsvc_handle_t *);
175 extern int remove_dd(dsvc_datastore_t *, dsvc_contype_t, const char *);
176 extern int open_dd(dsvc_handle_t *, dsvc_datastore_t *, dsvc_contype_t,
177 const char *, uint_t);
178 extern int lookup_dd(dsvc_handle_t, boolean_t, uint_t, int, const void *,
179 void **, uint_t *);
180 extern void free_dd(dsvc_handle_t, void *);
181 extern void free_dd_list(dsvc_handle_t, void *);
182 extern int confopt_to_datastore(dhcp_confopt_t *, dsvc_datastore_t *);
183 extern int module_synchtype(dsvc_datastore_t *, dsvc_synchtype_t *);
184
185 /*
186 * Under DEBUG, the DHCP_CONFOPT_ROOT environment variable can be set to
187 * the path of a directory for the DHCP server to use an alternate root
188 * for its configuration information and datastores.
189 */
190 #ifdef DEBUG
191 #define DHCP_CONFOPT_ROOT ((getenv("DHCP_CONFOPT_ROOT") != NULL) ? \
192 getenv("DHCP_CONFOPT_ROOT") : "")
193 #else
194 #define DHCP_CONFOPT_ROOT ""
195 #endif
196
197 #ifdef __cplusplus
198 }
199 #endif
200
201 #endif /* !_DHCP_SVC_PRIVATE_H */