Annotation of embedaddon/libpdel/ppp/ppp_pptp_server.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_engine.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_channel.h"
49: #include "ppp/ppp_pptp_server.h"
50: #include "ppp/ppp_pptp_ctrl.h"
51: #include "ppp/ppp_pptp_ctrl_defs.h"
52:
53: #include <net/ethernet.h>
54: #include <netgraph/ng_pptpgre.h>
55: #include <netinet/in_systm.h>
56: #include <netinet/ip.h>
57:
58: #define PPTP_MTYPE "ppp_pptp"
59: #define PPTP_OUTPUT_MTYPE "ppp_pptp.output"
60: #define PPTP_DEVICE_MTYPE "ppp_pptp.device"
61: #define PPTP_PEER_MTYPE "ppp_pptp.peer"
62:
63: #if 0 /* win2k seems to require at least 1500 */
64: #define PPTP_MRU \
65: (ETHER_MAX_LEN /* standard ethernet frame */ \
66: - ETHER_CRC_LEN /* ethernet crc */ \
67: - ETHER_HDR_LEN /* ethernet header */ \
68: - sizeof(struct ip) /* ip header */ \
69: - 16 /* gre header */ \
70: - 2) /* ppp address & control fields */
71: #else
72: #define PPTP_MRU LCP_DEFAULT_MRU
73: #endif
74:
75: #define PPTP_MRRU LCP_DEFAULT_MRRU
76:
77: #define PPTPGRE_ALWAYS_ACK 1
78:
79: /* PPTP server info */
80: struct pptp_server {
81: struct ppp_pptp_server_info info; /* client info */
82: struct ppp_log *log; /* log */
83: struct ppp_engine *engine;/* associated ppp engine */
84: struct pptp_engine *pptp; /* pptp control engine */
85: struct pevent_ctx *ev_ctx;/* event context */
86: pthread_mutex_t *mutex; /* mutex */
87: struct in_addr ip; /* my ip address */
88: u_int16_t port; /* my port */
89: u_char shutdown;/* server is shutdown */
90: u_int npeers; /* number of extant devices */
91: };
92:
93: /* Remote peer info */
94: struct ppp_pptp_peer {
95: struct pptp_server *s; /* back pointer to server */
96: struct ppp_channel *chan; /* back pointer to channel */
97: struct pptpctrlinfo cinfo; /* pptp control channel info */
98: struct nodeinfo ninfo; /* ng_pptpgre(4) node info */
99: struct pevent *answer; /* pptp answer event */
100: char path[32]; /* pptpgre node path */
101: char logname[32]; /* peer logname */
102: void *carg; /* client callback arg */
103: struct in_addr ip; /* peer remote ip address */
104: u_int16_t port; /* peer remote port */
105: u_char closed; /* closed by client side */
106: };
107:
108: /* PPTP control callbacks */
109: static PptpCheckNewConn_t ppp_pptp_server_check_new_conn;
110: static PptpGetInLink_t ppp_pptp_server_get_in_link;
111: static PptpGetOutLink_t ppp_pptp_server_get_out_link;
112:
113: /* Device methods */
114: static ppp_channel_open_t ppp_pptp_server_device_open;
115: static ppp_channel_close_t ppp_pptp_server_device_close;
116: static ppp_channel_destroy_t ppp_pptp_server_device_destroy;
117: static ppp_channel_free_output_t ppp_pptp_server_device_free_output;
118: static ppp_channel_set_link_info_t ppp_pptp_server_device_set_link_info;
119: static ppp_channel_get_origination_t ppp_pptp_server_device_get_origination;
120: static ppp_channel_get_node_t ppp_pptp_server_device_get_node;
121: static ppp_channel_get_hook_t ppp_pptp_server_device_get_hook;
122: static ppp_channel_is_async_t ppp_pptp_server_device_is_async;
123: static ppp_channel_get_mtu_t ppp_pptp_server_device_get_mtu;
124: static ppp_channel_get_acfcomp_t ppp_pptp_server_device_get_acfcomp;
125: static ppp_channel_get_pfcomp_t ppp_pptp_server_device_get_pfcomp;
126:
127: static struct ppp_channel_meth ppp_pptp_server_device_meth = {
128: ppp_pptp_server_device_open,
129: ppp_pptp_server_device_close,
130: ppp_pptp_server_device_destroy,
131: ppp_pptp_server_device_free_output,
132: ppp_pptp_server_device_set_link_info,
133: ppp_pptp_server_device_get_origination,
134: ppp_pptp_server_device_get_node,
135: ppp_pptp_server_device_get_hook,
136: ppp_pptp_server_device_is_async,
137: ppp_pptp_server_device_get_mtu,
138: ppp_pptp_server_device_get_acfcomp,
139: ppp_pptp_server_device_get_pfcomp,
140: };
141:
142: /* Other internal functions */
143: static struct ppp_pptp_peer *ppp_pptp_server_new_peer(struct pptp_server *s,
144: struct in_addr ip, u_int16_t port,
145: const struct pptpctrlinfo *cinfo);
146: static void ppp_pptp_server_device_output(struct ppp_pptp_peer *peer,
147: enum ppp_channeloutput type, ...);
148:
149: static void ppp_pptp_server_cancel(void *cookie);
150: static void ppp_pptp_server_result(void *cookie, const char *errmsg);
151:
152: static pevent_handler_t ppp_pptp_server_answer;
153:
154: /* Macro for logging */
155: #define LOG(sev, fmt, args...) PPP_LOG(s->log, sev, fmt , ## args)
156:
157: /***********************************************************************
158: PUBLIC FUNCTIONS
159: ***********************************************************************/
160:
161: /*
162: * Start the PPTP server associated with a ppp engine.
163: */
164: int
165: ppp_pptp_server_start(struct ppp_engine *engine,
166: const struct ppp_pptp_server_info *info,
167: struct in_addr ip, u_int16_t port, u_int max_conn)
168: {
169: struct ppp_log *const elog = ppp_engine_get_log(engine);
170: struct pptp_server *s;
171:
172: /* Sanity */
173: if (engine == NULL || info->arg == NULL) {
174: errno = EINVAL;
175: return (-1);
176: }
177:
178: /* See if server already exists */
179: if ((s = ppp_engine_get_pptp_server(engine)) != NULL) {
180: errno = EALREADY;
181: return (-1);
182: }
183:
184: /* Create new server */
185: if ((s = MALLOC(PPTP_MTYPE, sizeof(*s))) == NULL)
186: return (-1);
187: memset(s, 0, sizeof(*s));
188: s->engine = engine;
189: s->ev_ctx = ppp_engine_get_ev_ctx(engine);
190: s->mutex = ppp_engine_get_mutex(engine);
191: s->log = ppp_log_dup(elog);
192: s->info = *info;
193: s->ip = ip;
194: s->port = port;
195:
196: /* Start PPTP */
197: if ((s->pptp = PptpCtrlInit(s, s->ev_ctx, s->mutex,
198: ppp_pptp_server_check_new_conn, ppp_pptp_server_get_in_link,
199: ppp_pptp_server_get_out_link, ip, port, info->vendor,
200: ppp_log_dup(elog), 1)) == NULL) {
201: ppp_log_put(elog, LOG_ERR, "failed to initialize pptp");
202: FREE(PPTP_MTYPE, s);
203: return (-1);
204: }
205:
206: /* Enable incoming connections */
207: if (PptpCtrlListen(s->pptp, 1) == -1) {
208: ppp_log_put(elog, LOG_ERR, "failed start pptp server");
209: PptpCtrlShutdown(&s->pptp);
210: FREE(PPTP_MTYPE, s);
211: return (-1);
212: }
213:
214: /* Done */
215: ppp_engine_set_pptp_server(engine, s);
216: return (0);
217: }
218:
219: /*
220: * Stop the PPTP server associated with a ppp engine.
221: *
222: * We can't completely destroy it, because there may be PPTP devices
223: * in use by ppp_link's that still exist. The ppp_link's are responsible
224: * for destroying their devices, not us.
225: */
226: void
227: ppp_pptp_server_stop(struct ppp_engine *engine)
228: {
229: struct pptp_server *s;
230:
231: if ((s = ppp_engine_get_pptp_server(engine)) == NULL)
232: return;
233: ppp_engine_set_pptp_server(s->engine, NULL);
234: PptpCtrlShutdown(&s->pptp);
235: if (s->npeers == 0) {
236: ppp_log_close(&s->log);
237: FREE(PPTP_MTYPE, s);
238: return;
239: }
240:
241: /* Wait for all devices to be destroyed */
242: s->shutdown = 1;
243: }
244:
245: /*
246: * Close a PPTP connection.
247: */
248: void
249: ppp_pptp_server_close(struct ppp_engine *engine, struct ppp_pptp_peer **peerp)
250: {
251: struct ppp_pptp_peer *const peer = *peerp;
252:
253: if (peer == NULL)
254: return;
255: *peerp = NULL;
256: peer->carg = NULL; /* don't call client 'destroy' method */
257: ppp_pptp_server_device_close(peer->chan);
258: }
259:
260: /*
261: * Get the client handle for the PPTP channel associated with a device.
262: */
263: void *
264: ppp_pptp_server_get_client_info(struct ppp_channel *chan)
265: {
266: struct ppp_pptp_peer *const peer = chan->priv;
267:
268: if (chan->meth != &ppp_pptp_server_device_meth) {
269: errno = EINVAL;
270: return (NULL);
271: }
272: if (peer->carg == NULL)
273: errno = ENXIO;
274: return (peer->carg);
275: }
276:
277: /***********************************************************************
278: PPTP CONTROL CALLBACKS
279: ***********************************************************************/
280:
281: static int
282: ppp_pptp_server_check_new_conn(void *arg, struct in_addr ip,
283: u_int16_t port, char *logname, size_t max)
284: {
285: struct pptp_server *const s = arg;
286:
287: if (s->info.getlogname != NULL)
288: (*s->info.getlogname)(s->info.arg, ip, port, logname, max);
289: return (0);
290: }
291:
292: static struct pptplinkinfo
293: ppp_pptp_server_get_in_link(void *arg, struct pptpctrlinfo cinfo,
294: struct in_addr ip, u_int16_t port, int bearType,
295: const char *callingNum, const char *calledNum, const char *subAddress)
296: {
297: struct pptp_server *const s = arg;
298: struct pptplinkinfo info;
299: struct ppp_pptp_peer *peer;
300:
301: /* Create new peer */
302: memset(&info, 0, sizeof(info));
303: if ((peer = ppp_pptp_server_new_peer(s, ip, port, &cinfo)) == NULL)
304: return (info);
305:
306: /* Fill in response */
307: info.cookie = peer;
308: info.cancel = ppp_pptp_server_cancel;
309: info.result = ppp_pptp_server_result;
310:
311: /* Output 'up' message */
312: ppp_pptp_server_device_output(peer, PPP_CHANNEL_OUTPUT_UP);
313:
314: /* Done */
315: return (info);
316: }
317:
318: static struct pptplinkinfo
319: ppp_pptp_server_get_out_link(void *arg, struct pptpctrlinfo cinfo,
320: struct in_addr ip, u_int16_t port, int bearType, int frameType,
321: int minBps, int maxBps, const char *calledNum, const char *subAddress)
322: {
323: struct pptp_server *const s = arg;
324: struct pptplinkinfo info;
325: struct ppp_pptp_peer *peer;
326:
327: /* Create new peer */
328: memset(&info, 0, sizeof(info));
329: if ((peer = ppp_pptp_server_new_peer(s, ip, port, &cinfo)) == NULL)
330: return (info);
331:
332: /* Set up to 'answer' the outgoing call (but not reentrantly) */
333: pevent_unregister(&peer->answer);
334: if (pevent_register(s->ev_ctx, &peer->answer, 0, s->mutex,
335: ppp_pptp_server_answer, peer, PEVENT_TIME, 0) == -1) {
336: LOG(LOG_ERR, "pevent_register: %m");
337: return (info);
338: }
339:
340: /* Fill in response */
341: info.cookie = peer;
342: info.cancel = ppp_pptp_server_cancel;
343: info.result = ppp_pptp_server_result;
344:
345: /* Done */
346: return (info);
347: }
348:
349: static void
350: ppp_pptp_server_result(void *cookie, const char *errmsg)
351: {
352: struct ppp_pptp_peer *const peer = cookie;
353: struct pptp_server *const s = peer->s;
354:
355: LOG(LOG_INFO, "call from %s terminated: %s", peer->logname, errmsg);
356: peer->cinfo.cookie = NULL; /* don't call cinfo close() method */
357: ppp_pptp_server_device_close(peer->chan);
358: }
359:
360: static void
361: ppp_pptp_server_cancel(void *cookie)
362: {
363: struct ppp_pptp_peer *const peer = cookie;
364:
365: (void)peer;
366: assert(0);
367: }
368:
369: /***********************************************************************
370: INTERNAL FUNCTIONS
371: ***********************************************************************/
372:
373: /*
374: * Create a new PPTP peer object corresponding to a PPTP channel
375: * and start up a new PPP link/bundle.
376: */
377: static struct ppp_pptp_peer *
378: ppp_pptp_server_new_peer(struct pptp_server *s, struct in_addr ip,
379: u_int16_t port, const struct pptpctrlinfo *cinfo)
380: {
381: union {
382: u_char repbuf[sizeof(struct ng_mesg) + sizeof(struct nodeinfo)];
383: struct ng_mesg reply;
384: } repbuf;
385: struct ng_mesg *reply = &repbuf.reply;
386: struct ppp_link_config link_config;
387: struct ng_pptpgre_conf greconf;
388: struct ppp_pptp_peer *peer = NULL;
389: struct ppp_auth_config auth;
390: struct ppp_log *log = NULL;
391: struct in_addr pptp_ip[2];
392: struct ngm_mkpeer mkpeer;
393: struct ngm_rmhook rmhook;
394: int csock = -1;
395: int esave;
396:
397: /* Create peer info structure */
398: if ((peer = MALLOC(PPTP_PEER_MTYPE, sizeof(*peer))) == NULL) {
399: LOG(LOG_ERR, "can't allocate new device: %m");
400: goto fail;
401: }
402: memset(peer, 0, sizeof(*peer));
403: peer->s = s;
404: peer->cinfo = *cinfo;
405: peer->ip = ip;
406: peer->port = port;
407:
408: /* Create ng_pptpgre(4) node */
409: if (NgMkSockNode(NULL, &csock, NULL) == -1) {
410: LOG(LOG_ERR, "can't create socket node: %m");
411: goto fail;
412: }
413: memset(&mkpeer, 0, sizeof(mkpeer));
414: strlcpy(mkpeer.type, NG_PPTPGRE_NODE_TYPE, sizeof(mkpeer.type));
415: strlcpy(mkpeer.ourhook, NG_PPTPGRE_HOOK_UPPER, sizeof(mkpeer.ourhook));
416: strlcpy(mkpeer.peerhook,
417: NG_PPTPGRE_HOOK_UPPER, sizeof(mkpeer.peerhook));
418: if (NgSendMsg(csock, ".",
419: NGM_GENERIC_COOKIE, NGM_MKPEER, &mkpeer, sizeof(mkpeer)) == -1) {
420: LOG(LOG_ERR, "can't create pptpgre node: %m");
421: goto fail;
422: }
423: snprintf(peer->path, sizeof(peer->path), "%s", NG_PPTPGRE_HOOK_UPPER);
424:
425: /* Get node info including 'id' and create absolute path for node */
426: if (NgSendMsg(csock, NG_PPTPGRE_HOOK_UPPER,
427: NGM_GENERIC_COOKIE, NGM_NODEINFO, NULL, 0) == -1) {
428: LOG(LOG_ERR, "can't get node info: %m");
429: goto fail;
430: }
431: memset(&repbuf, 0, sizeof(repbuf));
432: if (NgRecvMsg(csock, reply, sizeof(repbuf), NULL) == -1) {
433: LOG(LOG_ERR, "can't read node info: %m");
434: goto fail;
435: }
436: memcpy(&peer->ninfo, reply->data, sizeof(peer->ninfo));
437: snprintf(peer->path, sizeof(peer->path),
438: "[%lx]:", (long)peer->ninfo.id);
439:
440: /* Check with client library */
441: strlcpy(peer->logname, inet_ntoa(ip), sizeof(peer->logname));
442: memset(&auth, 0, sizeof(auth));
443: if ((peer->carg = (*s->info.admit)(s->info.arg, peer, ip, port,
444: &auth, peer->logname, sizeof(peer->logname))) == NULL)
445: goto fail;
446:
447: /* Get PPTP session info */
448: memset(&greconf, 0, sizeof(greconf));
449: if (PptpCtrlGetSessionInfo(cinfo, &pptp_ip[PPP_SELF],
450: &pptp_ip[PPP_PEER], &greconf.cid, &greconf.peerCid,
451: &greconf.recvWin, &greconf.peerPpd) == -1) {
452: LOG(LOG_ERR, "can't get pptp session info: %m");
453: goto fail;
454: }
455:
456: /* Configure pptpgre node */
457: greconf.enabled = 1;
458: greconf.enableDelayedAck = 1;
459: #if PPTPGRE_ALWAYS_ACK
460: greconf.enableAlwaysAck = 1;
461: #endif
462: if (NgSendMsg(csock, peer->path, NGM_PPTPGRE_COOKIE,
463: NGM_PPTPGRE_SET_CONFIG, &greconf, sizeof(greconf)) == -1) {
464: LOG(LOG_ERR, "can't configure pptpgre node: %m");
465: goto fail;
466: }
467:
468: /* Plumb the 'lower' side of the ng_pptpgre(4) node */
469: if ((*s->info.plumb)(s->info.arg,
470: peer->carg, peer->path, NG_PPTPGRE_HOOK_LOWER, pptp_ip) == -1) {
471: LOG(LOG_ERR, "error plumbing node: %m");
472: goto fail;
473: }
474:
475: /* Disconnect from the node so the link can connect to it */
476: memset(&rmhook, 0, sizeof(rmhook));
477: strlcpy(rmhook.ourhook, NG_PPTPGRE_HOOK_UPPER, sizeof(rmhook.ourhook));
478: if (NgSendMsg(csock, ".", NGM_GENERIC_COOKIE,
479: NGM_RMHOOK, &rmhook, sizeof(rmhook)) == -1) {
480: LOG(LOG_ERR, "can't unhook from node: %m");
481: goto fail;
482: }
483:
484: /* Create a new PPP device for this pptp connection */
485: if ((peer->chan = MALLOC(PPTP_DEVICE_MTYPE,
486: sizeof(*peer->chan))) == NULL) {
487: LOG(LOG_ERR, "can't allocate new channel: %m");
488: goto fail;
489: }
490: memset(peer->chan, 0, sizeof(*peer->chan));
491: peer->chan->meth = &ppp_pptp_server_device_meth;
492: peer->chan->priv = peer;
493:
494: /* Create device output message port */
495: if ((peer->chan->outport
496: = mesg_port_create("ppp_pptp_server")) == NULL) {
497: LOG(LOG_ERR, "can't create mesg_port: %m");
498: goto fail;
499: }
500:
501: /* Create log for the new link by prefixing the engine's log */
502: if ((log = ppp_engine_get_log(s->engine)) != NULL
503: && (log = ppp_log_prefix(log, "%s: ", peer->logname)) == NULL) {
504: LOG(LOG_ERR, "can't create link log: %m");
505: goto fail;
506: }
507:
508: /* Configure new link */
509: memset(&link_config, 0, sizeof(link_config));
510: link_config.auth = auth;
511: link_config.max_self_mru = PPTP_MRU;
512: link_config.max_self_mrru = PPTP_MRRU;
513: link_config.multilink = 1;
514: link_config.eid.class = PPP_EID_CLASS_IP;
515: link_config.eid.length = sizeof(s->ip);
516: memcpy(link_config.eid.value, &s->ip, sizeof(s->ip));
517:
518: /* Add new link to the PPP engine */
519: if (ppp_link_create(s->engine, peer->chan, &link_config, log) == -1) {
520: LOG(LOG_ERR, "can't create link: %m");
521: goto fail;
522: }
523: log = NULL;
524:
525: /* Done */
526: (void)close(csock);
527: s->npeers++;
528: return (peer);
529:
530: fail:
531: /* Clean up after failure */
532: esave = errno;
533: ppp_log_close(&log);
534: if (peer != NULL) {
535: if (peer->carg != NULL)
536: (*s->info.destroy)(s->info.arg, peer->carg, peer->path);
537: if (peer->chan != NULL) {
538: if (peer->chan->outport != NULL)
539: mesg_port_destroy(&peer->chan->outport);
540: FREE(PPTP_DEVICE_MTYPE, peer->chan);
541: }
542: if (csock != -1) {
543: (void)NgSendMsg(csock, peer->path,
544: NGM_GENERIC_COOKIE, NGM_SHUTDOWN, NULL, 0);
545: }
546: FREE(PPTP_PEER_MTYPE, peer);
547: }
548: if (csock != -1)
549: (void)close(csock);
550: errno = esave;
551: return (NULL);
552: }
553:
554: /*
555: * "Answer" peer's outgoing call.
556: */
557: static void
558: ppp_pptp_server_answer(void *arg)
559: {
560: struct ppp_pptp_peer *const peer = arg;
561:
562: pevent_unregister(&peer->answer);
563: (*peer->cinfo.answer)(peer->cinfo.cookie, PPTP_OCR_RESL_OK,
564: 0, 0, 10000000 /* XXX */);
565: ppp_pptp_server_device_output(peer, PPP_CHANNEL_OUTPUT_UP);
566: }
567:
568: /*
569: * Output indication from the device.
570: */
571: static void
572: ppp_pptp_server_device_output(struct ppp_pptp_peer *peer,
573: enum ppp_channeloutput type, ...)
574: {
575: struct pptp_server *const s = peer->s;
576: struct ppp_channel_output *output;
577:
578: /* Get output object */
579: if ((output = MALLOC(PPTP_OUTPUT_MTYPE, sizeof(*output))) == NULL) {
580: LOG(LOG_ERR, "can't create pptp output: %m");
581: return;
582: }
583: memset(output, 0, sizeof(*output));
584: output->type = type;
585:
586: /* Get extra args */
587: switch (output->type) {
588: case PPP_CHANNEL_OUTPUT_DOWN_FATAL:
589: case PPP_CHANNEL_OUTPUT_DOWN_NONFATAL:
590: {
591: const char *msg;
592: va_list args;
593:
594: /* Get string message */
595: va_start(args, type);
596: msg = va_arg(args, const char *);
597: va_end(args);
598: if ((output->info = STRDUP(PPTP_OUTPUT_MTYPE, msg)) == NULL) {
599: LOG(LOG_ERR, "can't create pptp output: %m");
600: FREE(PPTP_OUTPUT_MTYPE, output);
601: return;
602: }
603: break;
604: }
605: case PPP_CHANNEL_OUTPUT_UP:
606: break;
607: }
608:
609: /* Send message */
610: if (mesg_port_put(peer->chan->outport, output) == -1) {
611: LOG(LOG_ERR, "can't send pptp output: %m");
612: ppp_pptp_server_device_free_output(peer->chan, output);
613: return;
614: }
615: }
616:
617: /***********************************************************************
618: PPTP DEVICE METHODS
619: ***********************************************************************/
620:
621: static void
622: ppp_pptp_server_device_open(struct ppp_channel *chan)
623: {
624: return;
625: }
626:
627: static void
628: ppp_pptp_server_device_close(struct ppp_channel *chan)
629: {
630: struct ppp_pptp_peer *const peer = chan->priv;
631: struct pptp_server *const s = peer->s;
632: struct ng_pptpgre_conf greconf;
633: int csock;
634:
635: /* Logging */
636: if (!peer->closed) {
637: LOG(LOG_INFO, "closing PPTP connection with %s", peer->logname);
638: peer->closed = 1;
639: }
640:
641: /* Disable the pptpgre device */
642: if (NgMkSockNode(NULL, &csock, NULL) == -1)
643: LOG(LOG_ERR, "can't create socket node: %m");
644: else {
645: memset(&greconf, 0, sizeof(greconf));
646: (void)NgSendMsg(csock, peer->path, NGM_PPTPGRE_COOKIE,
647: NGM_PPTPGRE_SET_CONFIG, &greconf, sizeof(greconf));
648: (void)close(csock);
649: }
650:
651: /* Output 'down' message from the device */
652: ppp_pptp_server_device_output(peer,
653: PPP_CHANNEL_OUTPUT_DOWN_FATAL, "administratively closed");
654: }
655:
656: static void
657: ppp_pptp_server_device_destroy(struct ppp_channel **chanp)
658: {
659: struct ppp_channel *const chan = *chanp;
660: struct ppp_channel_output *output;
661: struct ppp_pptp_peer *peer;
662: struct pptp_server *s;
663: int csock;
664:
665: /* Sanity */
666: if (chan == NULL)
667: return;
668: *chanp = NULL;
669: peer = chan->priv;
670: s = peer->s;
671:
672: /* Close client code's side of the device */
673: if (peer->carg != NULL) {
674: (*s->info.destroy)(s->info.arg, peer->carg, peer->path);
675: peer->carg = NULL;
676: }
677:
678: /* Close the PPTP channel */
679: pevent_unregister(&peer->answer);
680: if (peer->cinfo.cookie != NULL) {
681: (*peer->cinfo.close)(peer->cinfo.cookie,
682: PPTP_CDN_RESL_ADMIN, 0, 0);
683: peer->cinfo.cookie = NULL;
684: }
685:
686: /* Destroy the ng_pptpgre(4) node */
687: if (NgMkSockNode(NULL, &csock, NULL) == -1)
688: LOG(LOG_ERR, "can't create socket node: %m");
689: else {
690: (void)NgSendMsg(csock, peer->path,
691: NGM_GENERIC_COOKIE, NGM_SHUTDOWN, NULL, 0);
692: (void)close(csock);
693: }
694:
695: /* Destroy the 'peer' object */
696: FREE(PPTP_PEER_MTYPE, peer);
697:
698: /* Destroy the device object */
699: while ((output = mesg_port_get(chan->outport, 0)) != NULL)
700: ppp_pptp_server_device_free_output(chan, output);
701: mesg_port_destroy(&chan->outport);
702: FREE(PPTP_DEVICE_MTYPE, chan);
703: s->npeers--;
704:
705: /* Check if shutting down PPTP server */
706: if (s->npeers == 0 && s->shutdown) {
707: ppp_log_close(&s->log);
708: FREE(PPTP_MTYPE, s);
709: }
710: }
711:
712: static void
713: ppp_pptp_server_device_free_output(struct ppp_channel *chan,
714: struct ppp_channel_output *output)
715: {
716: FREE(PPTP_OUTPUT_MTYPE, output->info);
717: FREE(PPTP_OUTPUT_MTYPE, output);
718: }
719:
720: static void
721: ppp_pptp_server_device_set_link_info(struct ppp_channel *chan, u_int32_t accm)
722: {
723: /* XXX implement me? */
724: }
725:
726: static int
727: ppp_pptp_server_device_get_origination(struct ppp_channel *chan)
728: {
729: return (PPP_PEER); /* we don't initiate any calls ourself */
730: }
731:
732: static const char *
733: ppp_pptp_server_device_get_node(struct ppp_channel *chan)
734: {
735: struct ppp_pptp_peer *const peer = chan->priv;
736:
737: return (peer->path);
738: }
739:
740: static const char *
741: ppp_pptp_server_device_get_hook(struct ppp_channel *chan)
742: {
743: return (NG_PPTPGRE_HOOK_UPPER);
744: }
745:
746: static int
747: ppp_pptp_server_device_is_async(struct ppp_channel *chan)
748: {
749: return (0);
750: }
751:
752: static u_int
753: ppp_pptp_server_device_get_mtu(struct ppp_channel *chan)
754: {
755: return (PPTP_MRU);
756: }
757:
758: static int
759: ppp_pptp_server_device_get_acfcomp(struct ppp_channel *chan)
760: {
761: return (1);
762: }
763:
764: static int
765: ppp_pptp_server_device_get_pfcomp(struct ppp_channel *chan)
766: {
767: return (1);
768: }
769:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_pptp_server.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