Annotation of embedaddon/libpdel/ppp/ppp_engine.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include "ppp/ppp_defs.h"
42: #include "ppp/ppp_log.h"
43: #include "ppp/ppp_node.h"
44: #include "ppp/ppp_fsm_option.h"
45: #include "ppp/ppp_auth.h"
46: #include "ppp/ppp_lcp.h"
47: #include "ppp/ppp_link.h"
48: #include "ppp/ppp_bundle.h"
49: #include "ppp/ppp_manager.h"
50: #include "ppp/ppp_engine.h"
51: #include "ppp/ppp_pptp_server.h"
52: #include "ppp/ppp_l2tp_server.h"
53:
54: #define ENGINE_MTYPE "ppp_engine"
55: #define ENGINE_HASH_LOAD 200
56:
57: struct ppp_engine {
58: struct ppp_manager *manager; /* ppp manager object */
59: struct pevent_ctx *ev_ctx; /* event context */
60: pthread_mutex_t mutex; /* mutex for context */
61: struct ppp_log *log; /* log */
62: struct ghash *bundles; /* bundles, each >= 1 link */
63: struct ghash *links; /* "floating" unbundled links */
64: void *pptp_server; /* pptp server */
65: void *l2tp_server; /* l2tp server */
66: };
67:
68: /* Macro for logging */
69: #define LOG(sev, fmt, args...) PPP_LOG(engine->log, sev, fmt , ## args)
70:
71: /*
72: * Create a new PPP engine.
73: *
74: * The "log" is destroyed when the engine is destroyed.
75: */
76: struct ppp_engine *
77: ppp_engine_create(struct ppp_manager *manager,
78: const pthread_attr_t *attr, struct ppp_log *log)
79: {
80: struct ppp_engine *engine;
81: pthread_mutexattr_t mattr;
82: int got_mutex = 0;
83: int got_mattr = 0;
84:
85: /* Create engine object */
86: if ((engine = MALLOC(ENGINE_MTYPE, sizeof(*engine))) == NULL)
87: return (NULL);
88: memset(engine, 0, sizeof(*engine));
89: engine->manager = manager;
90: engine->log = log;
91:
92: /* Create hash tables */
93: if ((engine->links = ghash_create(engine, 0, ENGINE_HASH_LOAD,
94: ENGINE_MTYPE, NULL, NULL, NULL, NULL)) == NULL)
95: goto fail;
96: if ((engine->bundles = ghash_create(engine, 0, ENGINE_HASH_LOAD,
97: ENGINE_MTYPE, NULL, NULL, NULL, NULL)) == NULL)
98: goto fail;
99:
100: /* Initialize mutex */
101: if ((errno = pthread_mutexattr_init(&mattr)) != 0)
102: goto fail;
103: got_mattr = 1;
104: if ((errno = pthread_mutexattr_settype(&mattr,
105: PTHREAD_MUTEX_RECURSIVE)) != 0)
106: goto fail;
107: if ((errno = pthread_mutex_init(&engine->mutex, &mattr)) != 0)
108: goto fail;
109: got_mutex = 1;
110: pthread_mutexattr_destroy(&mattr);
111: got_mattr = 0;
112:
113: /* Create event context */
114: if ((engine->ev_ctx = pevent_ctx_create("ppp_engine", attr)) == NULL)
115: goto fail;
116:
117: /* Done */
118: return (engine);
119:
120: fail:
121: /* Clean up after failure */
122: ghash_destroy(&engine->bundles);
123: ghash_destroy(&engine->links);
124: if (got_mutex)
125: pthread_mutex_destroy(&engine->mutex);
126: if (got_mattr)
127: pthread_mutexattr_destroy(&mattr);
128: FREE(ENGINE_MTYPE, engine);
129: return (NULL);
130: }
131:
132: /*
133: * Destroy a PPP engine.
134: *
135: * If "wait" is true, wait for all associated threads to exit.
136: */
137: void
138: ppp_engine_destroy(struct ppp_engine **enginep, int wait)
139: {
140: struct ppp_engine *const engine = *enginep;
141: struct ppp_bundle **bundles;
142: struct ppp_link **links;
143: int num;
144: int i;
145:
146: /* Sanity check */
147: if (engine == NULL)
148: return;
149: *enginep = NULL;
150:
151: /* Stop PPTP and L2TP servers (if any) */
152: ppp_pptp_server_stop(engine);
153: ppp_l2tp_server_stop(engine);
154:
155: /* Destroy floating links */
156: if ((num = ghash_dump(engine->links,
157: (void ***)&links, TYPED_MEM_TEMP)) == -1)
158: LOG(LOG_ERR, "%s: %m", "ghash_dump");
159: else {
160: for (i = 0; i < num; i++)
161: ppp_link_destroy(&links[i]);
162: FREE(TYPED_MEM_TEMP, links);
163: }
164:
165: /* Destroy bundles */
166: if ((num = ghash_dump(engine->bundles,
167: (void ***)&bundles, TYPED_MEM_TEMP)) == -1)
168: LOG(LOG_ERR, "%s: %m", "ghash_dump");
169: else {
170: for (i = 0; i < num; i++)
171: ppp_bundle_destroy(&bundles[i]);
172: FREE(TYPED_MEM_TEMP, bundles);
173: }
174:
175: /* Destroy event context; there should be no remaining events */
176: if ((num = pevent_ctx_count(engine->ev_ctx)) != 0) {
177: LOG(LOG_ERR, "%s: %d events remain at shutdown",
178: __FUNCTION__, num);
179: }
180: pevent_ctx_destroy(&engine->ev_ctx);
181:
182: /* Free engine object */
183: ghash_destroy(&engine->links);
184: ghash_destroy(&engine->bundles);
185: ppp_log_close(&engine->log);
186: FREE(ENGINE_MTYPE, engine);
187: }
188:
189: /*
190: * Get a list of all known bundles.
191: */
192: int
193: ppp_engine_get_bundles(struct ppp_engine *engine,
194: struct ppp_bundle ***listp, const char *mtype)
195: {
196: return (ghash_dump(engine->bundles, (void ***)listp, mtype));
197: }
198:
199: /*
200: * Add a newly created (and therefore "floating") link.
201: */
202: int
203: ppp_engine_add_link(struct ppp_engine *engine, struct ppp_link *link)
204: {
205: return (ghash_put(engine->links, link));
206: }
207:
208: /*
209: * Remove a "floating" link from the floating link hash table.
210: */
211: void
212: ppp_engine_del_link(struct ppp_engine *engine, struct ppp_link *link)
213: {
214: ghash_remove(engine->links, link);
215: }
216:
217: /*
218: * Add a bundle.
219: */
220: int
221: ppp_engine_add_bundle(struct ppp_engine *engine, struct ppp_bundle *bundle)
222: {
223: return (ghash_put(engine->bundles, bundle));
224: }
225:
226: /*
227: * Remove a bundle.
228: */
229: void
230: ppp_engine_del_bundle(struct ppp_engine *engine, struct ppp_bundle *bundle)
231: {
232: ghash_remove(engine->bundles, bundle);
233: }
234:
235: /*
236: * An "unbundled" link has reached the OPENED state and authenticated.
237: * Add it to an existing bundle or create a new bundle as appropriate.
238: */
239: struct ppp_bundle *
240: ppp_engine_join(struct ppp_engine *engine, struct ppp_link *link,
241: struct ppp_node **nodep, u_int16_t *link_num)
242: {
243: struct ppp_bundle *bundle = NULL;
244: struct ppp_lcp_req lcp_req;
245: struct ghash_walk walk;
246:
247: /* Sanity */
248: assert(*nodep != NULL);
249:
250: /* If link does not have multilink, can't join any bundles */
251: ppp_link_get_lcp_req(link, &lcp_req);
252: if (!lcp_req.multilink[PPP_SELF] || !lcp_req.multilink[PPP_PEER])
253: goto no_join;
254:
255: /* See if link matches any existing bundle */
256: ghash_walk_init(engine->bundles, &walk);
257: while ((bundle = ghash_walk_next(engine->bundles, &walk)) != NULL) {
258: const char *link_authname[2];
259: const char *bund_authname[2];
260: struct ppp_eid link_eid[2];
261: struct ppp_eid bund_eid[2];
262: int j;
263:
264: /* If bundle does not have multilink, can't join it */
265: if (!ppp_bundle_get_multilink(bundle))
266: continue;
267:
268: /* Get info about link and bundle */
269: for (j = 0; j < 2; j++) {
270: link_authname[j] = ppp_link_get_authname(link, j);
271: ppp_link_get_eid(link, j, &link_eid[j]);
272: bund_authname[j] = ppp_bundle_get_authname(bundle, j);
273: ppp_bundle_get_eid(bundle, j, &bund_eid[j]);
274: }
275:
276: /* Compare them */
277: for (j = 0; j < 2; j++) {
278: if (strcmp(link_authname[j], bund_authname[j]) != 0)
279: break;
280: if (link_eid[j].class != bund_eid[j].class)
281: break;
282: if (link_eid[j].length != bund_eid[j].length)
283: break;
284: if (memcmp(link_eid[j].value,
285: bund_eid[j].value, link_eid[j].length) != 0)
286: break;
287: }
288:
289: /* If equal, stop */
290: if (j == 2)
291: break;
292: }
293:
294: no_join:
295: /* If no matching bundle found, create a new one */
296: if (bundle == NULL) {
297:
298: /* Create new bundle */
299: if ((bundle = ppp_bundle_create(engine,
300: link, *nodep)) == NULL) {
301: PPP_LOG(ppp_link_get_log(link), LOG_ERR,
302: "failed to create new bundle: %m");
303: return (NULL);
304: }
305:
306: /* The bundle steals the link's node */
307: *nodep = NULL;
308: *link_num = 0;
309: } else {
310:
311: /* Join link into bundle */
312: if (ppp_bundle_join(bundle, link, *nodep, link_num) == -1) {
313: PPP_LOG(ppp_link_get_log(link), LOG_ERR,
314: "link failed to join bundle: %m");
315: return (NULL);
316: }
317:
318: /* Destroy link's node: it's no longer needed */
319: ppp_node_destroy(nodep);
320: }
321:
322: /* Link is no longer 'floating' as bundle now references it */
323: ppp_engine_del_link(engine, link);
324:
325: /* Done */
326: return (bundle);
327: }
328:
329: void
330: ppp_engine_set_pptp_server(struct ppp_engine *engine, void *s)
331: {
332: engine->pptp_server = s;
333: }
334:
335: void *
336: ppp_engine_get_pptp_server(struct ppp_engine *engine)
337: {
338: return (engine->pptp_server);
339: }
340:
341: void
342: ppp_engine_set_l2tp_server(struct ppp_engine *engine, void *s)
343: {
344: engine->l2tp_server = s;
345: }
346:
347: void *
348: ppp_engine_get_l2tp_server(struct ppp_engine *engine)
349: {
350: return (engine->l2tp_server);
351: }
352:
353: struct pevent_ctx *
354: ppp_engine_get_ev_ctx(struct ppp_engine *engine)
355: {
356: return (engine->ev_ctx);
357: }
358:
359: pthread_mutex_t *
360: ppp_engine_get_mutex(struct ppp_engine *engine)
361: {
362: return (&engine->mutex);
363: }
364:
365: struct ppp_log *
366: ppp_engine_get_log(struct ppp_engine *engine)
367: {
368: return (engine->log);
369: }
370:
371: /********************************************************************
372: MANAGER CALL-THROUGH FUNCTIONS
373: ********************************************************************/
374:
375: /*
376: * Configure a bundle.
377: */
378: void *
379: ppp_engine_bundle_config(struct ppp_engine *engine,
380: struct ppp_link *link, struct ppp_bundle_config *conf)
381: {
382: return (ppp_manager_bundle_config(engine->manager, link, conf));
383: }
384:
385: /*
386: * Plumb 'top' side of netgraph node.
387: */
388: void *
389: ppp_engine_bundle_plumb(struct ppp_engine *engine,
390: struct ppp_bundle *bundle, const char *path, const char *hook,
391: struct in_addr *ips, struct in_addr *dns, struct in_addr *nbns,
392: u_int mtu)
393: {
394: return (ppp_manager_bundle_plumb(engine->manager, bundle,
395: path, hook, ips, dns, nbns, mtu));
396: }
397:
398: /*
399: * Disconnect 'top' side of netgraph node.
400: */
401: void
402: ppp_engine_bundle_unplumb(struct ppp_engine *engine, void *arg,
403: struct ppp_bundle *bundle)
404: {
405: ppp_manager_bundle_unplumb(engine->manager, arg, bundle);
406: }
407:
408: /*
409: * Release an IP address for a peer.
410: */
411: void
412: ppp_engine_release_ip(struct ppp_engine *engine,
413: struct ppp_bundle *bundle, struct in_addr ip)
414: {
415: ppp_manager_release_ip(engine->manager, bundle, ip);
416: }
417:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_engine.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp