Annotation of embedaddon/libpdel/ppp/ppp_pptp_ctrl.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Copyright (c) 1995-1999 Whistle Communications, Inc.
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: * Whistle Communications; provided, however, that: (i) any and
10: * all reproductions of the source or object code must include the
11: * copyright notice above and the following disclaimer of warranties;
12: * and (ii) no rights are granted, in any manner or form, to use
13: * Whistle Communications, Inc. trademarks, including the mark "WHISTLE
14: * COMMUNICATIONS" on advertising, endorsements, or otherwise except
15: * as such appears in the above copyright notice or in the software.
16: *
17: * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS",
18: * AND TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS
19: * MAKES NO REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED,
20: * REGARDING THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND
21: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
22: * PURPOSE, OR NON-INFRINGEMENT. WHISTLE COMMUNICATIONS DOES NOT
23: * WARRANT, GUARANTEE, OR MAKE ANY REPRESENTATIONS REGARDING THE USE
24: * OF, OR THE RESULTS OF THE USE OF THIS SOFTWARE IN TERMS OF ITS
25: * CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE. IN NO EVENT
26: * SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES RESULTING
27: * FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING WITHOUT
28: * LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
29: * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE
30: * GOODS OR SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED
31: * AND UNDER ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
32: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
33: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS
34: * IS ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35: *
36: * Author: <archie@freebsd.org>
37: */
38:
39: #include "ppp/ppp_defs.h"
40: #include "ppp/ppp_log.h"
41: #include "ppp/ppp_pptp_ctrl.h"
42: #include "ppp/ppp_pptp_ctrl_defs.h"
43: #include <netinet/tcp.h>
44:
45: /*
46: * DEFINITIONS
47: */
48:
49: #define RANDOMIZE_CID 1
50: #define CHECK_RESERVED_FIELDS 0
51: #define LOGNAME_MAX 32
52:
53: #ifndef FALSE
54: #define FALSE 0
55: #define TRUE 1
56: #endif
57:
58: #define PPTP_MTYPE "ppp_pptp_ctrl"
59: #define PPTP_CTRL_MTYPE "ppp_pptp_ctrl.ctrl"
60: #define PPTP_CHAN_MTYPE "ppp_pptp_ctrl.chan"
61: #define PPTP_PREP_MTYPE "ppp_pptp_ctrl.prep"
62:
63: #define PPTP_FIRMWARE_REV 0x0101
64:
65: #define PPTP_STR_INTERNAL_CALLING "Internally originated VPN call"
66:
67: /* Limits on how long we wait for replies to things */
68: #define PPTP_DFL_REPLY_TIME PPTP_IDLE_TIMEOUT
69: #define PPTP_OUTCALLREQ_REPLY_TIME 60
70: #define PPTP_INCALLREP_REPLY_TIME 60
71: #define PPTP_STOPCCR_REPLY_TIME 3
72:
73: /* Logging */
74: #define PLOG(sev, fmt, args...) \
75: ppp_log_put(pptp->log, sev, fmt , ## args)
76: #define CLOG(sev, fmt, args...) \
77: ppp_log_put(c->log, sev, fmt , ## args)
78: #define CHLOG(sev, fmt, args...) \
79: ppp_log_put(ch->log, sev, fmt , ## args)
80:
81: struct pptp_engine;
82:
83: /* This describes how/if a reply is required */
84: struct pptpreqrep {
85: u_char reply; /* required reply (or zero) */
86: u_char killCtrl; /* fatal to ctrl or just to channel */
87: u_short timeout; /* max time to wait for reply */
88: };
89: typedef struct pptpreqrep *PptpReqRep;
90:
91: /* This represents a pending reply we're waiting for */
92: struct pptppendrep {
93: const struct pptpmsginfo *request; /* original message info */
94: struct pptpctrl *ctrl; /* control channel */
95: struct pptpchan *chan; /* channel (NULL if none) */
96: struct pevent *timer; /* reply timeout timer */
97: struct pptppendrep *next; /* next in list */
98: };
99: typedef struct pptppendrep *PptpPendRep;
100:
101: /* This describes how to match a message to the corresponding channel */
102: struct pptpchanid {
103: u_char findIn; /* how to find channel (incoming) */
104: u_char findOut; /* how to find channel (outgoing) */
105: const char *inField; /* field used to find channel (in) */
106: const char *outField; /* field used to find channel (out) */
107: };
108: typedef struct pptpchanid *PptpChanId;
109:
110: #define PPTP_FIND_CHAN_MY_CID 1 /* match field vs. my cid */
111: #define PPTP_FIND_CHAN_PEER_CID 2 /* match field vs. peer cid */
112: #define PPTP_FIND_CHAN_PNS_CID 3 /* match field vs. PNS cid */
113: #define PPTP_FIND_CHAN_PAC_CID 4 /* match field vs. PAC cid */
114:
115: /* Message handler function type */
116: typedef void pptpmsghandler_t(void *, void *);
117:
118: /* Total info about a message type (except field layout) */
119: struct pptpmsginfo {
120: const char *name; /* name for this message type */
121: pptpmsghandler_t *handler; /* message handler function */
122: u_char isReply; /* this is always a reply message */
123: u_char length; /* length of message (sans header) */
124: u_short states; /* states which admit this message */
125: struct pptpchanid match; /* how to find corresponding channel */
126: struct pptpreqrep reqrep; /* what kind of reply we expect */
127: };
128: typedef const struct pptpmsginfo *PptpMsgInfo;
129:
130: /* Receive window size XXX */
131: #define PPTP_RECV_WIN 16
132:
133: /* Packet processing delay XXX */
134: #define PPTP_PPD 1
135:
136: /* Channel state */
137: struct pptpchan {
138: u_char state; /* channel state */
139: u_char id; /* channel index */
140: u_char orig:1; /* call originated from us */
141: u_char incoming:1; /* call is incoming, not outgoing */
142: u_char killing:1; /* channel is being killed */
143: u_int16_t cid; /* my call id */
144: u_int16_t serno; /* call serial number */
145: u_int16_t peerCid; /* peer call id */
146: u_int16_t peerPpd; /* peer's packet processing delay */
147: u_int16_t recvWin; /* peer's recv window size */
148: u_int32_t recvSeq; /* last seq # we rcv'd */
149: u_int32_t xmitSeq; /* last seq # we sent */
150: u_int32_t recvAck; /* last seq # peer acknowledged */
151: u_int32_t xmitAck; /* last seq # we acknowledged */
152: u_int32_t bearType; /* call bearer type */
153: u_int32_t frameType; /* call framing type */
154: u_int32_t minBps; /* minimum acceptable speed */
155: u_int32_t maxBps; /* maximum acceptable speed */
156: struct pptplinkinfo linfo; /* info about corresponding link */
157: struct pptpctrl *ctrl; /* my control channel */
158: struct ppp_log *log; /* log */
159: char callingNum[PPTP_PHONE_LEN + 1]; /* calling number */
160: char calledNum[PPTP_PHONE_LEN + 1]; /* called number */
161: char subAddress[PPTP_SUBADDR_LEN + 1];/* sub-address */
162: };
163: typedef struct pptpchan *PptpChan;
164:
165: #define PPTP_CHAN_IS_PNS(ch) (!(ch)->orig ^ !(ch)->incoming)
166:
167: /* Control channel state */
168: struct pptpctrl {
169: u_char frame[PPTP_CTRL_MAX_FRAME];
170: u_char state; /* state */
171: u_char id; /* channel index */
172: u_char orig:1; /* we originated connection */
173: u_char killing:1; /* connection is being killed */
174: u_int16_t flen; /* length of partial frame */
175: int csock; /* peer control messages */
176: struct in_addr self_addr; /* local IP address */
177: struct in_addr peer_addr; /* peer we're talking to */
178: u_int16_t self_port;
179: u_int16_t peer_port;
180: struct pptp_engine *pptp; /* engine that owns me */
181: struct pevent *connEvent; /* connection event */
182: struct pevent *ctrlEvent; /* control connection input */
183: struct pevent *killEvent; /* kill this ctrl in separate thread */
184: struct pevent *idleTimer; /* idle timer */
185: struct ppp_log *log; /* log */
186: u_int32_t echoId; /* last echo id # sent */
187: PptpPendRep reps; /* pending replies to msgs */
188: PptpChan *channels; /* array of channels */
189: int numChannels; /* length of channels array */
190: char logname[LOGNAME_MAX]; /* name for logging */
191: };
192: typedef struct pptpctrl *PptpCtrl;
193:
194: #define MAX_IOVEC 32
195:
196: /* Our physical channel ID */
197: #define PHYS_CHAN(ch) (((ch)->ctrl->id << 16) | (ch)->id)
198:
199: /*
200: * INTERNAL FUNCTIONS
201: */
202:
203: /* Methods for each control message type */
204: static void PptpStartCtrlConnRequest(PptpCtrl c,
205: struct pptpStartCtrlConnRequest *m);
206: static void PptpStartCtrlConnReply(PptpCtrl c,
207: struct pptpStartCtrlConnReply *m);
208: static void PptpStopCtrlConnRequest(PptpCtrl c,
209: struct pptpStopCtrlConnRequest *m);
210: static void PptpStopCtrlConnReply(PptpCtrl c,
211: struct pptpStopCtrlConnReply *m);
212: static void PptpEchoRequest(PptpCtrl c, struct pptpEchoRequest *m);
213: static void PptpEchoReply(PptpCtrl c, struct pptpEchoReply *m);
214: static void PptpOutCallRequest(PptpCtrl c, struct pptpOutCallRequest *m);
215: static void PptpOutCallReply(PptpChan ch, struct pptpOutCallReply *m);
216: static void PptpInCallRequest(PptpCtrl c, struct pptpInCallRequest *m);
217: static void PptpInCallReply(PptpChan ch, struct pptpInCallReply *m);
218: static void PptpInCallConn(PptpChan ch, struct pptpInCallConn *m);
219: static void PptpCallClearRequest(PptpChan ch,
220: struct pptpCallClearRequest *m);
221: static void PptpCallDiscNotify(PptpChan ch, struct pptpCallDiscNotify *m);
222: static void PptpWanErrorNotify(PptpChan ch, struct pptpWanErrorNotify *m);
223: static void PptpSetLinkInfo(PptpChan ch, struct pptpSetLinkInfo *m);
224:
225: /* Link layer callbacks */
226: static void PptpCtrlCloseChan(PptpChan ch,
227: int result, int error, int cause);
228: static void PptpCtrlKillChan(PptpChan ch, const char *errmsg);
229: static void PptpCtrlDialResult(void *cookie,
230: int result, int error, int cause, int speed);
231:
232: /* Internal event handlers */
233: static pevent_handler_t PptpCtrlListenEvent;
234: static pevent_handler_t PptpCtrlConnEvent;
235: static pevent_handler_t PptpCtrlReadCtrl;
236:
237: /* Shutdown routines */
238: static void PptpCtrlCloseCtrl(PptpCtrl c);
239: static void PptpCtrlKillCtrl(PptpCtrl c);
240:
241: /* Timer routines */
242: static void PptpCtrlResetIdleTimer(PptpCtrl c);
243: static void PptpCtrlIdleTimeout(void *arg);
244: static void PptpCtrlReplyTimeout(void *arg);
245:
246: /* Misc routines */
247: static void PptpCtrlInitCtrl(PptpCtrl c, int orig);
248: static void PptpCtrlMsg(PptpCtrl c, int type, void *msg);
249: static void PptpCtrlWriteMsg(PptpCtrl c, int type, void *msg);
250: static int PptpCtrlGetSocket(struct in_addr ip,
251: u_int16_t port, char *ebuf, size_t elen);
252:
253: static void PptpCtrlSwap(int type, void *buf);
254: static void PptpCtrlDump(int sev, PptpCtrl c, int type, void *msg);
255: static void PptpCtrlDumpBuf(int sev, PptpCtrl c,
256: const void *data, size_t len, const char *fmt, ...);
257: static int PptpCtrlFindField(int type, const char *name, u_int *offset);
258: static void PptpCtrlInitCinfo(PptpChan ch, PptpCtrlInfo ci);
259:
260: static void PptpCtrlNewCtrlState(PptpCtrl c, int new);
261: static void PptpCtrlNewChanState(PptpChan ch, int new);
262:
263: static int PptpCtrlExtendArray(const char *mtype,
264: void *arrayp, int esize, int *alenp);
265:
266: static struct pptpctrlinfo
267: PptpCtrlOrigCall(struct pptp_engine *pptp, int incmg,
268: struct pptplinkinfo linfo, struct in_addr ip,
269: u_int16_t port, const char *logname,
270: int bearType, int frameType, int minBps, int maxBps,
271: const char *callingNum, const char *calledNum,
272: const char *subAddress);
273:
274: static PptpCtrl PptpCtrlGetCtrl(struct pptp_engine *pptp,
275: int orig, struct in_addr peer_addr,
276: u_int16_t peer_port, const char *logname,
277: char *buf, int bsiz);
278: static PptpChan PptpCtrlGetChan(PptpCtrl c, int chanState, int orig,
279: int incoming, int bearType, int frameType, int minBps,
280: int maxBps, const char *callingNum,
281: const char *calledNum, const char *subAddress);
282: static PptpChan PptpCtrlFindChan(PptpCtrl c, int type,
283: void *msg, int incoming);
284: static void PptpCtrlCheckConn(PptpCtrl c);
285:
286: /*
287: * PPTP ENGINE STATE
288: */
289:
290: /* PPTP engine structure */
291: struct pptp_engine {
292: int listen_sock; /* listening socket */
293: struct in_addr listen_addr; /* listen ip address */
294: u_int16_t listen_port; /* listen port */
295: u_char nocd; /* no collision detection */
296: struct pevent_ctx *ev_ctx; /* event context */
297: pthread_mutex_t *mutex; /* mutex */
298: struct pevent *listen_event; /* incoming connection event */
299: PptpCheckNewConn_t *check_new_conn;/* callback for new connectn. */
300: PptpGetInLink_t *get_in_link; /* callback for incoming call */
301: PptpGetOutLink_t *get_out_link; /* callback for outgoing call */
302: struct ppp_log *log; /* log */
303: void *arg; /* client arg */
304: u_int16_t last_call_id; /* last used call id */
305: PptpCtrl *ctrl; /* array of control channels */
306: int nctrl; /* length of ctrl array */
307: char vendor[PPTP_VENDOR_LEN]; /* vendor name */
308: };
309:
310: /*
311: * INTERNAL VARIABLES
312: */
313:
314: /* Control message field layout */
315: static const struct pptpfield
316: gPptpMsgLayout[PPTP_MAX_CTRL_TYPE][PPTP_CTRL_MAX_FIELDS] =
317: {
318: #define _WANT_PPTP_FIELDS
319: #include "ppp/ppp_pptp_ctrl_defs.h"
320: };
321:
322: /* Control channel and call state names */
323: static const char *gPptpCtrlStates[] = {
324: #define PPTP_CTRL_ST_FREE 0
325: "FREE",
326: #define PPTP_CTRL_ST_IDLE 1
327: "IDLE",
328: #define PPTP_CTRL_ST_WAIT_CTL_REPLY 2
329: "WAIT_CTL_REPLY",
330: #define PPTP_CTRL_ST_WAIT_STOP_REPLY 3
331: "WAIT_STOP_REPLY",
332: #define PPTP_CTRL_ST_ESTABLISHED 4
333: "ESTABLISHED",
334: };
335:
336: static const char *gPptpChanStates[] = {
337: #define PPTP_CHAN_ST_FREE 0
338: "FREE",
339: #define PPTP_CHAN_ST_WAIT_IN_REPLY 1
340: "WAIT_IN_REPLY",
341: #define PPTP_CHAN_ST_WAIT_OUT_REPLY 2
342: "WAIT_OUT_REPLY",
343: #define PPTP_CHAN_ST_WAIT_CONNECT 3
344: "WAIT_CONNECT",
345: #define PPTP_CHAN_ST_WAIT_DISCONNECT 4
346: "WAIT_DISCONNECT",
347: #define PPTP_CHAN_ST_WAIT_ANSWER 5
348: "WAIT_ANSWER",
349: #define PPTP_CHAN_ST_ESTABLISHED 6
350: "ESTABLISHED",
351: #define PPTP_CHAN_ST_WAIT_CTRL 7
352: "WAIT_CTRL",
353: };
354:
355: /* Control message descriptors */
356: #define CL(s) (1 << (PPTP_CTRL_ST_ ## s))
357: #define CH(s) ((1 << (PPTP_CHAN_ST_ ## s)) | 0x8000)
358:
359: static const struct pptpmsginfo gPptpMsgInfo[PPTP_MAX_CTRL_TYPE] = {
360: { "PptpMsgHead", NULL, /* placeholder */
361: FALSE, sizeof(struct pptpMsgHead),
362: },
363: { "StartCtrlConnRequest", (pptpmsghandler_t *)PptpStartCtrlConnRequest,
364: FALSE, sizeof(struct pptpStartCtrlConnRequest),
365: CL(IDLE),
366: { 0, 0 }, /* no associated channel */
367: { PPTP_StartCtrlConnReply, TRUE, PPTP_DFL_REPLY_TIME },
368: },
369: { "StartCtrlConnReply", (pptpmsghandler_t *)PptpStartCtrlConnReply,
370: TRUE, sizeof(struct pptpStartCtrlConnReply),
371: CL(WAIT_CTL_REPLY),
372: { 0, 0 }, /* no associated channel */
373: { 0 }, /* no reply expected */
374: },
375: { "StopCtrlConnRequest", (pptpmsghandler_t *)PptpStopCtrlConnRequest,
376: FALSE, sizeof(struct pptpStopCtrlConnRequest),
377: CL(WAIT_CTL_REPLY)|CL(WAIT_STOP_REPLY)|CL(ESTABLISHED),
378: { 0, 0 }, /* no associated channel */
379: { PPTP_StopCtrlConnReply, TRUE, PPTP_STOPCCR_REPLY_TIME },
380: },
381: { "StopCtrlConnReply", (pptpmsghandler_t *)PptpStopCtrlConnReply,
382: TRUE, sizeof(struct pptpStopCtrlConnReply),
383: CL(WAIT_STOP_REPLY),
384: { 0, 0 }, /* no associated channel */
385: { 0 }, /* no reply expected */
386: },
387: { "EchoRequest", (pptpmsghandler_t *)PptpEchoRequest,
388: FALSE, sizeof(struct pptpEchoRequest),
389: CL(ESTABLISHED),
390: { 0, 0 }, /* no associated channel */
391: { PPTP_EchoReply, TRUE, PPTP_DFL_REPLY_TIME },
392: },
393: { "EchoReply", (pptpmsghandler_t *)PptpEchoReply,
394: TRUE, sizeof(struct pptpEchoReply),
395: CL(ESTABLISHED),
396: { 0, 0 }, /* no associated channel */
397: { 0 }, /* no reply expected */
398: },
399: { "OutCallRequest", (pptpmsghandler_t *)PptpOutCallRequest,
400: FALSE, sizeof(struct pptpOutCallRequest),
401: CL(ESTABLISHED),
402: { 0, PPTP_FIND_CHAN_MY_CID, NULL, "cid" },
403: { PPTP_OutCallReply, TRUE, PPTP_OUTCALLREQ_REPLY_TIME },
404: },
405: { "OutCallReply", (pptpmsghandler_t *)PptpOutCallReply,
406: TRUE, sizeof(struct pptpOutCallReply),
407: CH(WAIT_OUT_REPLY),
408: { PPTP_FIND_CHAN_MY_CID, PPTP_FIND_CHAN_MY_CID, "peerCid", "cid" },
409: { 0 }, /* no reply expected */
410: },
411: { "InCallRequest", (pptpmsghandler_t *)PptpInCallRequest,
412: FALSE, sizeof(struct pptpInCallRequest),
413: CL(ESTABLISHED),
414: { 0, PPTP_FIND_CHAN_MY_CID, NULL, "cid" },
415: { PPTP_InCallReply, FALSE, PPTP_DFL_REPLY_TIME },
416: },
417: { "InCallReply", (pptpmsghandler_t *)PptpInCallReply,
418: TRUE, sizeof(struct pptpInCallReply),
419: CH(WAIT_IN_REPLY),
420: { PPTP_FIND_CHAN_MY_CID, PPTP_FIND_CHAN_MY_CID, "peerCid", "cid" },
421: { PPTP_InCallConn, FALSE, PPTP_INCALLREP_REPLY_TIME },
422: },
423: { "InCallConn", (pptpmsghandler_t *)PptpInCallConn,
424: TRUE, sizeof(struct pptpInCallConn),
425: CH(WAIT_CONNECT),
426: { PPTP_FIND_CHAN_MY_CID, PPTP_FIND_CHAN_PEER_CID, "peerCid", "peerCid" },
427: { 0 }, /* no reply expected */
428: },
429: { "CallClearRequest", (pptpmsghandler_t *)PptpCallClearRequest,
430: FALSE, sizeof(struct pptpCallClearRequest),
431: CH(WAIT_IN_REPLY)|CH(WAIT_ANSWER)|CH(ESTABLISHED),
432: { PPTP_FIND_CHAN_PNS_CID, PPTP_FIND_CHAN_PNS_CID, "cid", "cid" },
433: { PPTP_CallDiscNotify, TRUE, PPTP_DFL_REPLY_TIME },
434: },
435: { "CallDiscNotify", (pptpmsghandler_t *)PptpCallDiscNotify,
436: FALSE, sizeof(struct pptpCallDiscNotify),
437: CH(WAIT_OUT_REPLY)|CH(WAIT_CONNECT)|CH(WAIT_DISCONNECT)|CH(ESTABLISHED),
438: { PPTP_FIND_CHAN_PAC_CID, PPTP_FIND_CHAN_PAC_CID, "cid", "cid" },
439: { 0 }, /* no reply expected */
440: },
441: { "WanErrorNotify", (pptpmsghandler_t *)PptpWanErrorNotify,
442: FALSE, sizeof(struct pptpWanErrorNotify),
443: CH(ESTABLISHED),
444: { PPTP_FIND_CHAN_PNS_CID, PPTP_FIND_CHAN_PNS_CID, "cid", "cid" },
445: { 0 }, /* no reply expected */
446: },
447: { "SetLinkInfo", (pptpmsghandler_t *)PptpSetLinkInfo,
448: FALSE, sizeof(struct pptpSetLinkInfo),
449: CH(ESTABLISHED),
450: { PPTP_FIND_CHAN_PAC_CID, PPTP_FIND_CHAN_PAC_CID, "cid", "cid" },
451: { 0 }, /* no reply expected */
452: },
453: };
454:
455: #undef CL
456: #undef CH
457:
458: /* Error code to string converters */
459: #define DECODE(a, n) ((u_int)(n) < (sizeof(a) / sizeof(*(a))) ? \
460: (a)[(u_int)(n)] : "[out of range]")
461:
462: static const char *const gPptpErrorCodes[] = {
463: "none",
464: "not connected",
465: "bad format",
466: "bad value",
467: "no resource",
468: "bad call ID",
469: "pac error",
470: };
471: #define PPTP_ERROR_CODE(n) DECODE(gPptpErrorCodes, (n))
472:
473: static const char *const gPptpSccrReslCodes[] = {
474: "zero?",
475: "OK",
476: "general error",
477: "channel exists",
478: "not authorized",
479: "bad protocol version",
480: };
481: #define PPTP_SCCR_RESL_CODE(n) DECODE(gPptpSccrReslCodes, (n))
482:
483: static const char *const gPptpSccrReasCodes[] = {
484: "zero?",
485: "none",
486: "bad protocol version",
487: "local shutdown",
488: };
489: #define PPTP_SCCR_REAS_CODE(n) DECODE(gPptpSccrReasCodes, (n))
490:
491: static const char *const gPptpEchoReslCodes[] = {
492: "zero?",
493: "OK",
494: "general error",
495: };
496: #define PPTP_ECHO_RESL_CODE(n) DECODE(gPptpEchoReslCodes, (n))
497:
498: static const char *const gPptpOcrReslCodes[] = {
499: "zero?",
500: "OK",
501: "general error",
502: "no carrier",
503: "busy",
504: "no dialtone",
505: "timed out",
506: "admin prohib",
507: };
508: #define PPTP_OCR_RESL_CODE(n) DECODE(gPptpOcrReslCodes, (n))
509:
510: static const char *const gPptpIcrReslCodes[] = {
511: "zero?",
512: "OK",
513: "general error",
514: "not accepted",
515: };
516: #define PPTP_ICR_RESL_CODE(n) DECODE(gPptpIcrReslCodes, (n))
517:
518: static const char *const gPptpCdnReslCodes[] = {
519: "zero?",
520: "lost carrier",
521: "general error",
522: "admin action",
523: "disconnect request",
524: };
525: #define PPTP_CDN_RESL_CODE(n) DECODE(gPptpCdnReslCodes, (n))
526:
527: /*************************************************************************
528: EXPORTED FUNCTIONS
529: *************************************************************************/
530:
531: /*
532: * PptpCtrlInit()
533: *
534: * Initialize PPTP state and set up callbacks. This must be called
535: * first, and any calls after the first will ignore the ip parameter.
536: * Returns 0 if successful, -1 otherwise.
537: *
538: * Parameters:
539: * arg Client opaque argument.
540: * getInLink Function to call when a peer has requested to establish
541: * an incoming call. If returned cookie is NULL, call failed.
542: * This pointer may be NULL to deny all incoming calls.
543: * getOutLink Function to call when a peer has requested to establish
544: * an outgoming call. If returned cookie is NULL, call failed.
545: * This pointer may be NULL to deny all outgoing calls.
546: * ip The IP address for my server to use (cannot be zero).
547: * port The TCP port for my server to use (zero for default).
548: * log The log to use. Note: the log is consumed.
549: */
550:
551: struct pptp_engine *
552: PptpCtrlInit(void *arg, struct pevent_ctx *ev_ctx, pthread_mutex_t *mutex,
553: PptpCheckNewConn_t *checkNewConn, PptpGetInLink_t *getInLink,
554: PptpGetOutLink_t *getOutLink, struct in_addr ip, u_int16_t port,
555: const char *vendor, struct ppp_log *log, int nocd)
556: {
557: struct pptp_engine *pptp;
558: int type;
559:
560: /* Sanity check structure lengths and valid state bits */
561: for (type = 0; type < PPTP_MAX_CTRL_TYPE; type++) {
562: PptpField field = gPptpMsgLayout[type];
563: int total;
564:
565: assert((gPptpMsgInfo[type].match.inField != NULL)
566: ^ !(gPptpMsgInfo[type].states & 0x8000));
567: for (total = 0; field->name; field++)
568: total += field->length;
569: assert(total == gPptpMsgInfo[type].length);
570: }
571:
572: /* Create new pptp object */
573: if ((pptp = MALLOC(PPTP_MTYPE, sizeof(*pptp))) == NULL)
574: return(NULL);
575: memset(pptp, 0, sizeof(*pptp));
576: pptp->ev_ctx = ev_ctx;
577: pptp->mutex = mutex;
578: pptp->log = log;
579: pptp->nocd = nocd;
580: pptp->arg = arg;
581: pptp->listen_sock = -1;
582: pptp->check_new_conn = checkNewConn;
583: pptp->get_in_link = getInLink;
584: pptp->get_out_link = getOutLink;
585: pptp->listen_addr = ip;
586: pptp->listen_port = port ? port : PPTP_PORT;
587: if (vendor != NULL)
588: strlcpy(pptp->vendor, vendor, sizeof(pptp->vendor));
589: #if RANDOMIZE_CID
590: pptp->last_call_id = time(NULL) ^ (getpid() << 5);
591: #endif
592:
593: /* Done */
594: return(pptp);
595: }
596:
597: /*
598: * PptpCtrlShutdown()
599: *
600: * Destroy a PPTP engine
601: */
602:
603: void
604: PptpCtrlShutdown(struct pptp_engine **enginep)
605: {
606: struct pptp_engine *const pptp = *enginep;
607: int i;
608:
609: if (pptp == NULL)
610: return;
611: *enginep = NULL;
612: if (pptp->listen_sock != -1)
613: (void)close(pptp->listen_sock);
614: for (i = 0; i < pptp->nctrl; i++) {
615: if (pptp->ctrl[i] == NULL)
616: continue;
617: PptpCtrlKillCtrl(pptp->ctrl[i]);
618: }
619: pevent_unregister(&pptp->listen_event);
620: ppp_log_close(&pptp->log);
621: FREE(PPTP_MTYPE, pptp->ctrl);
622: FREE(PPTP_MTYPE, pptp);
623: }
624:
625: /*
626: * PptpCtrlListen()
627: *
628: * Enable or disable incoming PPTP TCP connections.
629: * Returns 0 if successful, -1 otherwise.
630: */
631:
632: int
633: PptpCtrlListen(struct pptp_engine *pptp, int enable)
634: {
635: char ebuf[128];
636:
637: /* Enable or disable */
638: if (enable) {
639:
640: /* Already enabled? */
641: if (pptp->listen_sock != -1)
642: return(0);
643:
644: /* We must have a callback for incoming connections */
645: if (pptp->check_new_conn == NULL) {
646: errno = ENXIO;
647: return(-1);
648: }
649:
650: /* Create listening socket */
651: if ((pptp->listen_sock = PptpCtrlGetSocket(pptp->listen_addr,
652: pptp->listen_port, ebuf, sizeof(ebuf))) == -1) {
653: PLOG(LOG_ERR, "pptp: can't get listen socket: %s", ebuf);
654: return(-1);
655: }
656:
657: /* Listen for connections */
658: if (listen(pptp->listen_sock, 10) == -1) {
659: PLOG(LOG_ERR, "pptp: %s: %s", "listen", strerror(errno));
660: goto sock_fail;
661: }
662:
663: /* Wait for incoming connections */
664: if (pevent_register(pptp->ev_ctx, &pptp->listen_event, PEVENT_RECURRING,
665: pptp->mutex, PptpCtrlListenEvent, pptp, PEVENT_READ,
666: pptp->listen_sock) == -1) {
667: PLOG(LOG_ERR, "pptp: %s: %s", "pevent_register", strerror(errno));
668: sock_fail:
669: (void)close(pptp->listen_sock);
670: pptp->listen_sock = -1;
671: return(-1);
672: }
673: } else {
674:
675: /* Already disabled? */
676: if (pptp->listen_sock == -1)
677: return(0);
678:
679: /* Stop listening */
680: (void)close(pptp->listen_sock);
681: pptp->listen_sock = -1;
682: pevent_unregister(&pptp->listen_event);
683: }
684:
685: /* Done */
686: return(0);
687: }
688:
689: /*
690: * PptpCtrlInCall()
691: *
692: * Initiate an incoming call
693: */
694:
695: struct pptpctrlinfo
696: PptpCtrlInCall(struct pptp_engine *engine,
697: struct pptplinkinfo linfo, struct in_addr ip, u_int16_t port,
698: const char *logname, int bearType, int frameType, int minBps,
699: int maxBps, const char *callingNum, const char *calledNum,
700: const char *subAddress)
701: {
702: return(PptpCtrlOrigCall(engine, TRUE, linfo, ip, port, logname,
703: bearType, frameType, minBps, maxBps, callingNum, calledNum, subAddress));
704: }
705:
706: /*
707: * PptpCtrlOutCall()
708: *
709: * Initiate an outgoing call
710: */
711:
712: struct pptpctrlinfo
713: PptpCtrlOutCall(struct pptp_engine *engine,
714: struct pptplinkinfo linfo,
715: struct in_addr ip, u_int16_t port, const char *logname,
716: int bearType, int frameType, int minBps, int maxBps,
717: const char *calledNum, const char *subAddress)
718: {
719: return(PptpCtrlOrigCall(engine, FALSE, linfo, ip, port, logname,
720: bearType, frameType, minBps, maxBps, PPTP_STR_INTERNAL_CALLING,
721: calledNum, subAddress));
722: }
723:
724: /*
725: * PptpCtrlOrigCall()
726: *
727: * Request from the PPTP peer at ip:port the establishment of an
728: * incoming or outgoing call (as viewed by the peer). The "result"
729: * callback will be called when the connection has been established
730: * or failed to do so. This initiates a TCP control connection if
731: * needed; otherwise it uses the existing connection. If port is
732: * zero, then use the normal PPTP port.
733: */
734:
735: static struct pptpctrlinfo
736: PptpCtrlOrigCall(struct pptp_engine *pptp, int incoming,
737: struct pptplinkinfo linfo, struct in_addr ip, u_int16_t port,
738: const char *logname, int bearType, int frameType, int minBps,
739: int maxBps, const char *callingNum, const char *calledNum,
740: const char *subAddress)
741: {
742: PptpCtrl c;
743: PptpChan ch;
744: struct pptpctrlinfo cinfo;
745: char ebuf[100];
746:
747: /* Init */
748: port = port ? port : PPTP_PORT;
749: memset(&cinfo, 0, sizeof(cinfo));
750:
751: /* Sanity check */
752: if (linfo.result == NULL) {
753: PLOG(LOG_ERR, "pptp: can't originate call without 'result' callback");
754: errno = EINVAL;
755: return(cinfo);
756: }
757:
758: /* Find/create control block */
759: if ((c = PptpCtrlGetCtrl(pptp, TRUE, ip, port,
760: logname, ebuf, sizeof(ebuf))) == NULL) {
761: PLOG(LOG_INFO, "pptp: %s", ebuf);
762: return(cinfo);
763: }
764:
765: /* Get new channel */
766: if ((ch = PptpCtrlGetChan(c, PPTP_CHAN_ST_WAIT_CTRL, TRUE, incoming,
767: bearType, frameType, minBps, maxBps,
768: callingNum, calledNum, subAddress)) == NULL) {
769: PptpCtrlKillCtrl(c);
770: return(cinfo);
771: }
772: ch->linfo = linfo;
773:
774: /* Control channel may be ready already; start channel if so */
775: PptpCtrlCheckConn(c);
776:
777: /* Return OK */
778: PptpCtrlInitCinfo(ch, &cinfo);
779: return(cinfo);
780: }
781:
782: /*
783: * PptpCtrlGetSessionInfo()
784: *
785: * Returns information associated with a call.
786: */
787:
788: int
789: PptpCtrlGetSessionInfo(const struct pptpctrlinfo *cp,
790: struct in_addr *selfAddr, struct in_addr *peerAddr,
791: u_int16_t *selfCid, u_int16_t *peerCid,
792: u_int16_t *peerWin, u_int16_t *peerPpd)
793: {
794: PptpChan const ch = (PptpChan)cp->cookie;
795:
796: switch (ch->state) {
797: case PPTP_CHAN_ST_WAIT_IN_REPLY:
798: case PPTP_CHAN_ST_WAIT_OUT_REPLY:
799: case PPTP_CHAN_ST_WAIT_CONNECT:
800: case PPTP_CHAN_ST_WAIT_DISCONNECT:
801: case PPTP_CHAN_ST_WAIT_ANSWER:
802: case PPTP_CHAN_ST_ESTABLISHED:
803: case PPTP_CHAN_ST_WAIT_CTRL:
804: {
805: PptpCtrl const c = ch->ctrl;
806:
807: if (selfAddr != NULL)
808: *selfAddr = c->self_addr;
809: if (peerAddr != NULL)
810: *peerAddr = c->peer_addr;
811: if (selfCid != NULL)
812: *selfCid = ch->cid;
813: if (peerCid != NULL)
814: *peerCid = ch->peerCid;
815: if (peerWin != NULL)
816: *peerWin = ch->recvWin;
817: if (peerPpd != NULL)
818: *peerPpd = ch->peerPpd;
819: return(0);
820: }
821: case PPTP_CHAN_ST_FREE:
822: errno = ENXIO;
823: return(-1);
824: break;
825: default:
826: assert(0);
827: }
828: return(-1); /* NOTREACHED */
829: }
830:
831: /*************************************************************************
832: CONTROL CONNECTION SETUP
833: *************************************************************************/
834:
835: /*
836: * PptpCtrlListenEvent()
837: *
838: * Someone has connected to our TCP socket on which we were listening.
839: */
840:
841: static void
842: PptpCtrlListenEvent(void *cookie)
843: {
844: struct pptp_engine *const pptp = cookie;
845: struct sockaddr_in peer;
846: int psize = sizeof(peer);
847: char logname[LOGNAME_MAX];
848: char ebuf[100];
849: PptpCtrl c;
850: int sock;
851:
852: /* Accept connection */
853: if ((sock = accept(pptp->listen_sock,
854: (struct sockaddr *)&peer, &psize)) == -1)
855: return;
856: (void)fcntl(sock, F_SETFD, 1);
857:
858: /* See if accepting connection is ok */
859: snprintf(logname, sizeof(logname), "%s:%u",
860: inet_ntoa(peer.sin_addr), ntohs(peer.sin_port));
861: if ((*pptp->check_new_conn)(pptp->arg, peer.sin_addr,
862: ntohs(peer.sin_port), logname, sizeof(logname)) != 0) {
863: PLOG(LOG_INFO, "pptp connection from %s rejected", logname);
864: (void)close(sock);
865: return;
866: }
867:
868: /* Initialize a new control block */
869: PLOG(LOG_INFO, "pptp connection from %s", logname);
870: if ((c = PptpCtrlGetCtrl(pptp, FALSE, peer.sin_addr,
871: ntohs(peer.sin_port), logname, ebuf, sizeof(ebuf))) == NULL) {
872: PLOG(LOG_ERR, "pptp connection failed: %s", ebuf);
873: (void)close(sock);
874: return;
875: }
876: c->csock = sock;
877:
878: /* Initialize the session */
879: PptpCtrlInitCtrl(c, FALSE);
880: }
881:
882: /*
883: * PptpCtrlConnEvent()
884: *
885: * We are trying to make a TCP connection to the peer. When this
886: * either succeeds or fails, we jump to here.
887: */
888:
889: static void
890: PptpCtrlConnEvent(void *cookie)
891: {
892: PptpCtrl const c = (PptpCtrl) cookie;
893: struct sockaddr_in addr;
894: int addrLen = sizeof(addr);
895:
896: /* Unregister event */
897: assert(c->state == PPTP_CTRL_ST_IDLE);
898: pevent_unregister(&c->connEvent);
899:
900: /* Check whether the connection was successful or not */
901: if (getpeername(c->csock, (struct sockaddr *) &addr, &addrLen) < 0) {
902: CLOG(LOG_INFO, "connection to peer failed");
903: PptpCtrlKillCtrl(c);
904: return;
905: }
906:
907: /* Initialize the session */
908: CLOG(LOG_INFO, "successfully connected to peer");
909: PptpCtrlInitCtrl(c, TRUE);
910: }
911:
912: /*
913: * PptpCtrlInitCtrl()
914: *
915: * A TCP connection has just been established. Initialize the
916: * control block for this connection and initiate the session.
917: */
918:
919: static void
920: PptpCtrlInitCtrl(PptpCtrl c, int orig)
921: {
922: struct pptp_engine *const pptp = c->pptp;
923: struct sockaddr_in self, peer;
924: static const int one = 1;
925: int k, addrLen;
926:
927: /* Good time for a sanity check */
928: assert(c->state == PPTP_CTRL_ST_IDLE);
929: assert(c->connEvent == NULL);
930: assert(c->ctrlEvent == NULL);
931: assert(c->reps == NULL);
932: for (k = 0; k < c->numChannels; k++) {
933: assert(c->channels[k] == NULL
934: || c->channels[k]->state == PPTP_CHAN_ST_WAIT_CTRL);
935: }
936:
937: /* Initialize control state */
938: c->orig = orig;
939: c->echoId = 0;
940: c->flen = 0;
941:
942: /* Get local IP address */
943: addrLen = sizeof(self);
944: if (getsockname(c->csock, (struct sockaddr *) &self, &addrLen) < 0) {
945: CLOG(LOG_ERR, "%s: %s", "getsockname", strerror(errno));
946: abort:
947: PptpCtrlKillCtrl(c);
948: return;
949: }
950: c->self_addr = self.sin_addr;
951: c->self_port = ntohs(self.sin_port);
952:
953: /* Get remote IP address */
954: addrLen = sizeof(peer);
955: if (getpeername(c->csock, (struct sockaddr *) &peer, &addrLen) < 0) {
956: CLOG(LOG_ERR, "%s: %s", "getpeername", strerror(errno));
957: goto abort;
958: }
959: c->peer_addr = peer.sin_addr;
960: c->peer_port = ntohs(peer.sin_port);
961:
962: /* Turn of Nagle algorithm on the TCP socket, since we are going to
963: be writing complete control frames one at a time */
964: if (setsockopt(c->csock, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one)) < 0)
965: CLOG(LOG_ERR, "%s: %s", "setsockopt", strerror(errno));
966:
967: /* Register for events on control and data sockets */
968: if (pevent_register(pptp->ev_ctx, &c->ctrlEvent, PEVENT_RECURRING,
969: pptp->mutex, PptpCtrlReadCtrl, c, PEVENT_READ, c->csock) == -1) {
970: CLOG(LOG_ERR, "%s: %s", "pevent_register", strerror(errno));
971: goto abort;
972: }
973:
974: /* Start echo keep-alive timer */
975: PptpCtrlResetIdleTimer(c);
976:
977: /* If we originated the call, we start the conversation */
978: if (c->orig) {
979: struct pptpStartCtrlConnRequest msg;
980:
981: memset(&msg, 0, sizeof(msg));
982: msg.vers = PPTP_PROTO_VERS;
983: msg.frameCap = PPTP_FRAMECAP_SYNC;
984: msg.bearCap = PPTP_BEARCAP_ANY;
985: msg.firmware = PPTP_FIRMWARE_REV;
986: gethostname(msg.host, sizeof(msg.host));
987: strncpy(msg.vendor, pptp->vendor, sizeof(msg.vendor));
988: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_WAIT_CTL_REPLY);
989: PptpCtrlWriteMsg(c, PPTP_StartCtrlConnRequest, &msg);
990: }
991: }
992:
993: /*************************************************************************
994: CONTROL CONNECTION MESSAGE HANDLING
995: *************************************************************************/
996:
997: /*
998: * PptpCtrlReadCtrl()
999: */
1000:
1001: static void
1002: PptpCtrlReadCtrl(void *cookie)
1003: {
1004: PptpCtrl const c = (PptpCtrl) cookie;
1005: PptpMsgHead const hdr = (PptpMsgHead) c->frame;
1006: int nread;
1007:
1008: /* Figure how much to read and read it */
1009: nread = (c->flen < sizeof(*hdr) ? sizeof(*hdr) : hdr->length) - c->flen;
1010: if ((nread = read(c->csock, c->frame + c->flen, nread)) <= 0) {
1011: if (nread < 0)
1012: CLOG(LOG_ERR, "%s: %s", "read", strerror(errno));
1013: else
1014: CLOG(LOG_INFO, "control connection closed by peer");
1015: goto abort;
1016: }
1017: PptpCtrlDumpBuf(LOG_DEBUG + 1, c,
1018: c->frame + c->flen, nread, "read ctrl data");
1019: c->flen += nread;
1020:
1021: /* Do whatever with what we got */
1022: if (c->flen < sizeof(*hdr)) /* incomplete header */
1023: return;
1024: if (c->flen == sizeof(*hdr)) { /* complete header */
1025: PptpCtrlSwap(0, hdr); /* byte swap header */
1026: CLOG(LOG_DEBUG + 1, "rec'd hdr");
1027: PptpCtrlDump(LOG_DEBUG + 1, c, 0, hdr);
1028: if (hdr->msgType != PPTP_CTRL_MSG_TYPE) {
1029: CLOG(LOG_NOTICE, "rec'd invalid msg type %d", hdr->msgType);
1030: goto abort;
1031: }
1032: if (hdr->magic != PPTP_MAGIC) {
1033: CLOG(LOG_NOTICE, "rec'd invalid magic 0x%08x", hdr->type);
1034: goto abort;
1035: }
1036: if (!PPTP_VALID_CTRL_TYPE(hdr->type)) {
1037: CLOG(LOG_NOTICE, "rec'd invalid ctrl type %d", hdr->type);
1038: goto abort;
1039: }
1040: #if CHECK_RESERVED_FIELDS
1041: if (hdr->resv0 != 0) {
1042: CLOG(LOG_NOTICE, "rec'd non-zero reserved field in header");
1043: goto abort;
1044: }
1045: #endif
1046: if (hdr->length != sizeof(*hdr) + gPptpMsgInfo[hdr->type].length) {
1047: CLOG(LOG_NOTICE, "rec'd invalid length %u for type %s",
1048: hdr->length, gPptpMsgInfo[hdr->type].name);
1049: abort:
1050: PptpCtrlKillCtrl(c);
1051: return;
1052: }
1053: return;
1054: }
1055: if (c->flen == hdr->length) { /* complete message */
1056: void *const msg = ((u_char *) hdr) + sizeof(*hdr);
1057:
1058: PptpCtrlSwap(hdr->type, msg); /* byte swap message */
1059: CLOG(LOG_DEBUG, "recv %s", gPptpMsgInfo[hdr->type].name);
1060: PptpCtrlDump(LOG_DEBUG, c, hdr->type, msg);
1061: c->flen = 0;
1062: PptpCtrlResetIdleTimer(c);
1063: PptpCtrlMsg(c, hdr->type, msg);
1064: }
1065: }
1066:
1067: /*
1068: * PptpCtrlMsg()
1069: *
1070: * We read a complete control message. Sanity check it and handle it.
1071: */
1072:
1073: static void
1074: PptpCtrlMsg(PptpCtrl c, int type, void *msg)
1075: {
1076: PptpMsgInfo const mi = &gPptpMsgInfo[type];
1077: PptpChan ch = NULL;
1078: PptpPendRep *pp;
1079:
1080: #if CHECK_RESERVED_FIELDS
1081: {
1082: PptpField field = gPptpMsgLayout[type];
1083: u_int off;
1084: static u_char zeros[4];
1085:
1086: /* Make sure all reserved fields are zero */
1087: for (off = 0; field->name; off += field->length, field++) {
1088: if (!strncmp(field->name, PPTP_RESV_PREF, strlen(PPTP_RESV_PREF))
1089: && memcmp((u_char *) msg + off, zeros, field->length)) {
1090: CLOG(LOG_INFO, "rec'd non-zero reserved field %s in %s",
1091: field->name, mi->name);
1092: PptpCtrlKillCtrl(c);
1093: return;
1094: }
1095: }
1096: }
1097: #endif
1098:
1099: /* Find channel this message corresponds to (if any) */
1100: if (mi->match.inField && !(ch = PptpCtrlFindChan(c, type, msg, TRUE)))
1101: return;
1102:
1103: /* See if this message qualifies as the reply to a previously sent message */
1104: for (pp = &c->reps; *pp; pp = &(*pp)->next) {
1105: if ((*pp)->request->reqrep.reply == type && (*pp)->chan == ch)
1106: break;
1107: }
1108:
1109: /* If not, and this message is *always* a reply, ignore it */
1110: if (*pp == NULL && mi->isReply) {
1111: CLOG(LOG_NOTICE, "rec'd spurious %s", mi->name);
1112: return;
1113: }
1114:
1115: /* If so, cancel the matching pending reply */
1116: if (*pp) {
1117: PptpPendRep const prep = *pp;
1118:
1119: pevent_unregister(&prep->timer);
1120: *pp = prep->next;
1121: FREE(PPTP_PREP_MTYPE, prep);
1122: }
1123:
1124: /* Check for invalid message and call or control state combinations */
1125: if (!ch && ((1 << c->state) & mi->states) == 0) {
1126: CLOG(LOG_NOTICE, "rec'd %s in %s state %s (not valid)",
1127: gPptpMsgInfo[type].name, "control channel", gPptpCtrlStates[c->state]);
1128: PptpCtrlKillCtrl(c);
1129: return;
1130: }
1131: if (ch && ((1 << ch->state) & mi->states) == 0) {
1132: CHLOG(LOG_NOTICE, "rec'd %s in %s state %s (not valid)",
1133: gPptpMsgInfo[type].name, "channel", gPptpChanStates[ch->state]);
1134: PptpCtrlKillCtrl(c);
1135: return;
1136: }
1137:
1138: /* Things look OK; process message */
1139: (*mi->handler)(ch ? (void *) ch : (void *) c, msg);
1140: }
1141:
1142: /*
1143: * PptpCtrlWriteMsg()
1144: *
1145: * Write out a control message. If we should expect a reply,
1146: * register a matching pending reply for it.
1147: */
1148:
1149: static void
1150: PptpCtrlWriteMsg(PptpCtrl c, int type, void *msg)
1151: {
1152: struct pptp_engine *const pptp = c->pptp;
1153: PptpMsgInfo const mi = &gPptpMsgInfo[type];
1154: u_char buf[PPTP_CTRL_MAX_FRAME];
1155: PptpMsgHead const hdr = (PptpMsgHead) buf;
1156: u_char *const payload = (u_char *) (hdr + 1);
1157: const int totlen = sizeof(*hdr) + gPptpMsgInfo[type].length;
1158: int nwrote;
1159:
1160: /* Build message */
1161: assert(PPTP_VALID_CTRL_TYPE(type));
1162: memset(hdr, 0, sizeof(*hdr));
1163: hdr->length = totlen;
1164: hdr->msgType = PPTP_CTRL_MSG_TYPE;
1165: hdr->magic = PPTP_MAGIC;
1166: hdr->type = type;
1167: memcpy(payload, msg, gPptpMsgInfo[type].length);
1168: CLOG(LOG_DEBUG, "send %s msg", gPptpMsgInfo[hdr->type].name);
1169: PptpCtrlDump(LOG_DEBUG, c, 0, hdr);
1170: PptpCtrlDump(LOG_DEBUG, c, type, msg);
1171:
1172: /* Byte swap it */
1173: PptpCtrlSwap(0, hdr);
1174: PptpCtrlSwap(type, payload);
1175:
1176: /* Send it; if TCP buffer is full, we abort the connection */
1177: if ((nwrote = write(c->csock, buf, totlen)) != totlen) {
1178: if (nwrote < 0)
1179: CLOG(LOG_ERR, "%s: %s", "write", strerror(errno));
1180: else
1181: CLOG(LOG_ERR, "only wrote %d/%d", nwrote, totlen);
1182: goto kill;
1183: }
1184: PptpCtrlDumpBuf(LOG_DEBUG + 1, c, buf, totlen, "wrote ctrl data");
1185:
1186: /* If we expect a reply to this message, start expecting it now */
1187: if (PPTP_VALID_CTRL_TYPE(mi->reqrep.reply)) {
1188: PptpPendRep prep;
1189:
1190: if ((prep = MALLOC(PPTP_PREP_MTYPE, sizeof(*prep))) == NULL) {
1191: CLOG(LOG_ERR, "%s: %s", "malloc", strerror(errno));
1192: goto kill;
1193: }
1194: memset(prep, 0, sizeof(*prep));
1195: prep->ctrl = c;
1196: prep->chan = PptpCtrlFindChan(c, type, msg, FALSE);
1197: prep->request = mi;
1198: if (pevent_register(pptp->ev_ctx, &prep->timer, 0,
1199: pptp->mutex, PptpCtrlReplyTimeout, prep, PEVENT_TIME,
1200: mi->reqrep.timeout * 1000) == -1) {
1201: CLOG(LOG_ERR, "%s: %s", "pevent_register", strerror(errno));
1202: FREE(PPTP_PREP_MTYPE, prep);
1203: goto kill;
1204: }
1205: prep->next = c->reps;
1206: c->reps = prep;
1207: }
1208:
1209: /* Done */
1210: return;
1211:
1212: kill:
1213: /* There was an error, kill connection (later) */
1214: pevent_unregister(&c->killEvent);
1215: if (pevent_register(pptp->ev_ctx, &c->killEvent, 0, pptp->mutex,
1216: (pevent_handler_t *)PptpCtrlKillCtrl, c, PEVENT_TIME, 0) == -1)
1217: CLOG(LOG_ERR, "pevent_register: %m");
1218: }
1219:
1220: /*************************************************************************
1221: CONTROL AND CHANNEL ALLOCATION FUNCTIONS
1222: *************************************************************************/
1223:
1224: /*
1225: * PptpCtrlGetCtrl()
1226: *
1227: * Get existing or create new control bock for given peer and return it.
1228: * Returns NULL if there was some problem, and puts an error message
1229: * into the buffer.
1230: *
1231: * If "orig" is TRUE, and we currently have no TCP connection to the peer,
1232: * then initiate one. Otherwise, make sure we don't already have one,
1233: * because that would mean we'd have two connections to the same peer.
1234: */
1235:
1236: static PptpCtrl
1237: PptpCtrlGetCtrl(struct pptp_engine *pptp, int orig, struct in_addr peer_addr,
1238: u_int16_t peer_port, const char *logname, char *buf, int bsiz)
1239: {
1240: PptpCtrl c;
1241: struct sockaddr_in peer;
1242: static const struct in_addr any = { 0 };
1243: int flags;
1244: int k;
1245:
1246: /* See if we're already have a control block matching this address and port */
1247: for (k = 0; k < pptp->nctrl; k++) {
1248: PptpCtrl const c = pptp->ctrl[k];
1249:
1250: if (c != NULL
1251: && c->peer_addr.s_addr == peer_addr.s_addr
1252: && c->peer_port == peer_port) {
1253: if (orig)
1254: return(c);
1255: snprintf(buf, bsiz, "connection to %s already exists", logname);
1256: return(NULL);
1257: }
1258: }
1259:
1260: /* Find/create a free one */
1261: for (k = 0; k < pptp->nctrl && pptp->ctrl[k] != NULL; k++);
1262: if (k == pptp->nctrl) {
1263: if (PptpCtrlExtendArray(PPTP_MTYPE, &pptp->ctrl,
1264: sizeof(*pptp->ctrl), &pptp->nctrl) == -1) {
1265: snprintf(buf, bsiz, "%s: %s", "malloc", strerror(errno));
1266: return(NULL);
1267: }
1268: }
1269: if ((c = MALLOC(PPTP_CTRL_MTYPE, sizeof(*c))) == NULL) {
1270: snprintf(buf, bsiz, "%s: %s", "malloc", strerror(errno));
1271: return(NULL);
1272: }
1273: memset(c, 0, sizeof(*c));
1274: pptp->ctrl[k] = c;
1275:
1276: /* Initialize it */
1277: c->id = k;
1278: c->pptp = pptp;
1279: c->orig = orig;
1280: c->csock = -1;
1281: c->peer_addr = peer_addr;
1282: c->peer_port = peer_port;
1283: strlcpy(c->logname, logname, sizeof(c->logname));
1284: if ((c->log = ppp_log_prefix(pptp->log, "%s: ", c->logname)) == NULL) {
1285: snprintf(buf, bsiz, "%s: %s", "ppp_log_prefix", strerror(errno));
1286: pptp->ctrl[k] = NULL;
1287: FREE(PPTP_CTRL_MTYPE, c);
1288: return(NULL);
1289: }
1290:
1291: /* Go to the idle state */
1292: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_IDLE);
1293:
1294: /* If not doing the connecting, return here */
1295: if (!c->orig)
1296: return(c);
1297:
1298: /* Get socket */
1299: if ((c->csock = PptpCtrlGetSocket(any, 0, buf, bsiz)) < 0) {
1300: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_FREE);
1301: return(NULL);
1302: }
1303:
1304: /* Put socket in non-blocking mode */
1305: if (fcntl(c->csock, F_GETFL, &flags) == -1
1306: || fcntl(c->csock, F_SETFL, flags | O_NONBLOCK) == -1) {
1307: snprintf(buf, bsiz, "pptp: connect to %s failed: %s: %s",
1308: logname, "fcntl", strerror(errno));
1309: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_FREE);
1310: return(NULL);
1311: }
1312:
1313: /* Initiate connection to peer */
1314: memset(&peer, 0, sizeof(peer));
1315: peer.sin_family = AF_INET;
1316: peer.sin_addr = c->peer_addr;
1317: peer.sin_port = htons(c->peer_port);
1318: if (connect(c->csock, (struct sockaddr *) &peer, sizeof(peer)) < 0
1319: && errno != EINPROGRESS) {
1320: (void) close(c->csock);
1321: c->csock = -1;
1322: snprintf(buf, bsiz, "pptp: connect to %s failed: %s",
1323: logname, strerror(errno));
1324: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_FREE);
1325: return(NULL);
1326: }
1327:
1328: /* Put socket back in blocking mode */
1329: if (fcntl(c->csock, F_SETFL, flags) == -1) {
1330: (void) close(c->csock);
1331: c->csock = -1;
1332: snprintf(buf, bsiz, "pptp: connect to %s failed: %s: %s",
1333: logname, "fcntl", strerror(errno));
1334: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_FREE);
1335: return(NULL);
1336: }
1337:
1338: /* Wait for it to go through */
1339: if (pevent_register(pptp->ev_ctx, &c->connEvent, PEVENT_RECURRING,
1340: pptp->mutex, PptpCtrlConnEvent, c, PEVENT_READ, c->csock) == -1) {
1341: CLOG(LOG_ERR, "%s: %s", "pevent_register", strerror(errno));
1342: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_FREE);
1343: return(NULL);
1344: }
1345:
1346: /* Done */
1347: CLOG(LOG_INFO, "intiating connection to peer");
1348: return(c);
1349: }
1350:
1351: /*
1352: * PptpCtrlGetChan()
1353: *
1354: * Find a free data channel and attach it to the control channel.
1355: */
1356:
1357: static PptpChan
1358: PptpCtrlGetChan(PptpCtrl c, int chanState, int orig, int incoming,
1359: int bearType, int frameType, int minBps, int maxBps,
1360: const char *callingNum, const char *calledNum, const char *subAddress)
1361: {
1362: struct pptp_engine *const pptp = c->pptp;
1363: PptpChan ch;
1364: int k;
1365:
1366: /* Get a free data channel */
1367: for (k = 0; k < c->numChannels && c->channels[k] != NULL; k++);
1368: if (k == c->numChannels) {
1369: if (PptpCtrlExtendArray(PPTP_CTRL_MTYPE, &c->channels,
1370: sizeof(*c->channels), &c->numChannels) == -1) {
1371: CLOG(LOG_ERR, "%s: %s", "malloc", strerror(errno));
1372: return(NULL);
1373: }
1374: }
1375: if ((ch = MALLOC(PPTP_CHAN_MTYPE, sizeof(*ch))) == NULL) {
1376: CLOG(LOG_ERR, "%s: %s", "malloc", strerror(errno));
1377: return(NULL);
1378: }
1379: memset(ch, 0, sizeof(*ch));
1380: c->channels[k] = ch;
1381: ch->id = k;
1382: ch->cid = ++pptp->last_call_id;
1383: ch->ctrl = c;
1384: ch->orig = orig;
1385: ch->incoming = incoming;
1386: ch->minBps = minBps;
1387: ch->maxBps = maxBps;
1388: ch->bearType = bearType;
1389: ch->frameType = frameType;
1390: snprintf(ch->calledNum, sizeof(ch->calledNum), "%s", calledNum);
1391: snprintf(ch->callingNum, sizeof(ch->callingNum), "%s", callingNum);
1392: snprintf(ch->subAddress, sizeof(ch->subAddress), "%s", subAddress);
1393:
1394: /* Get log for this channel */
1395: if ((ch->log = ppp_log_prefix(pptp->log,
1396: "%s[%d]: ", c->logname, ch->id)) == NULL) {
1397: CLOG(LOG_ERR, "%s: %s", "ppp_log_prefix", strerror(errno));
1398: pptp->last_call_id--;
1399: c->channels[k] = NULL;
1400: FREE(PPTP_CHAN_MTYPE, ch);
1401: return(NULL);
1402: }
1403:
1404: /* Go to starting state */
1405: PptpCtrlNewChanState(ch, chanState);
1406: return(ch);
1407: }
1408:
1409: /*
1410: * PptpCtrlDialResult()
1411: *
1412: * Link layer calls this to let us know whether an outgoing call
1413: * has been successfully completed or has failed.
1414: */
1415:
1416: static void
1417: PptpCtrlDialResult(void *cookie, int result, int error, int cause, int speed)
1418: {
1419: PptpChan const ch = (PptpChan) cookie;
1420: PptpCtrl const c = ch->ctrl;
1421: struct pptpOutCallReply rep;
1422:
1423: memset(&rep, 0, sizeof(rep));
1424: rep.cid = ch->cid;
1425: rep.peerCid = ch->peerCid;
1426: rep.result = result;
1427: if (rep.result == PPTP_OCR_RESL_ERR)
1428: rep.err = error;
1429: rep.cause = cause;
1430: rep.speed = speed;
1431: rep.ppd = PPTP_PPD; /* XXX should get this value from link layer */
1432: rep.recvWin = PPTP_RECV_WIN; /* XXX */
1433: rep.channel = PHYS_CHAN(ch);
1434: PptpCtrlWriteMsg(c, PPTP_OutCallReply, &rep);
1435: if (rep.result == PPTP_OCR_RESL_OK)
1436: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_ESTABLISHED);
1437: else
1438: PptpCtrlKillChan(ch, "local outgoing call failed");
1439: }
1440:
1441: /*************************************************************************
1442: SHUTDOWN FUNCTIONS
1443: *************************************************************************/
1444:
1445: /*
1446: * PptpCtrlCloseCtrl()
1447: */
1448:
1449: static void
1450: PptpCtrlCloseCtrl(PptpCtrl c)
1451: {
1452: CLOG(LOG_INFO, "closing PPTP control connection");
1453: switch (c->state) {
1454: case PPTP_CTRL_ST_IDLE:
1455: case PPTP_CTRL_ST_WAIT_STOP_REPLY:
1456: case PPTP_CTRL_ST_WAIT_CTL_REPLY:
1457: PptpCtrlKillCtrl(c);
1458: return;
1459: case PPTP_CTRL_ST_ESTABLISHED:
1460: {
1461: struct pptpStopCtrlConnRequest req;
1462:
1463: memset(&req, 0, sizeof(req));
1464: req.reason = PPTP_SCCR_REAS_LOCAL;
1465: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_WAIT_STOP_REPLY);
1466: PptpCtrlWriteMsg(c, PPTP_StopCtrlConnRequest, &req);
1467: return;
1468: }
1469: break;
1470: default:
1471: assert(0);
1472: }
1473: }
1474:
1475: /*
1476: * PptpCtrlKillCtrl()
1477: */
1478:
1479: static void
1480: PptpCtrlKillCtrl(PptpCtrl c)
1481: {
1482: PptpPendRep prep, next;
1483: int k;
1484:
1485: /* Cancel kill event */
1486: pevent_unregister(&c->killEvent);
1487:
1488: /* Don't recurse */
1489: assert(c);
1490: if (c->killing || c->state == PPTP_CTRL_ST_FREE)
1491: return;
1492: c->killing = 1;
1493:
1494: /* Do ungraceful shutdown */
1495: CLOG(LOG_DEBUG, "killing control connection");
1496: for (k = 0; k < c->numChannels; k++) {
1497: PptpChan const ch = c->channels[k];
1498:
1499: if (ch != NULL)
1500: PptpCtrlKillChan(ch, "control channel shutdown");
1501: }
1502: if (c->csock >= 0) {
1503: close(c->csock);
1504: c->csock = -1;
1505: }
1506: pevent_unregister(&c->connEvent);
1507: pevent_unregister(&c->ctrlEvent);
1508: pevent_unregister(&c->idleTimer);
1509: for (prep = c->reps; prep; prep = next) {
1510: next = prep->next;
1511: pevent_unregister(&prep->timer);
1512: FREE(PPTP_PREP_MTYPE, prep);
1513: }
1514: c->reps = NULL;
1515: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_FREE);
1516: }
1517:
1518: /*
1519: * PptpCtrlCloseChan()
1520: *
1521: * Gracefully clear a call.
1522: */
1523:
1524: static void
1525: PptpCtrlCloseChan(PptpChan ch, int result, int error, int cause)
1526: {
1527: PptpCtrl const c = ch->ctrl;
1528:
1529: /* Don't recurse */
1530: if (ch->killing)
1531: return;
1532:
1533: /* Check call state */
1534: switch (ch->state) {
1535: case PPTP_CHAN_ST_ESTABLISHED:
1536: if (PPTP_CHAN_IS_PNS(ch))
1537: goto pnsClear;
1538: else
1539: goto pacClear;
1540: break;
1541: case PPTP_CHAN_ST_WAIT_ANSWER:
1542: {
1543: struct pptpOutCallReply reply;
1544:
1545: memset(&reply, 0, sizeof(reply));
1546: reply.peerCid = ch->peerCid;
1547: reply.result = PPTP_OCR_RESL_ADMIN;
1548: PptpCtrlWriteMsg(c, PPTP_OutCallReply, &reply);
1549: PptpCtrlKillChan(ch, "link layer shutdown"); /* XXX errmsg */
1550: return;
1551: }
1552: break;
1553: case PPTP_CHAN_ST_WAIT_IN_REPLY: /* we are the PAC */
1554: pacClear:
1555: {
1556: struct pptpCallDiscNotify disc;
1557:
1558: CHLOG(LOG_INFO, "clearing call");
1559: memset(&disc, 0, sizeof(disc));
1560: disc.cid = ch->cid;
1561: disc.result = result;
1562: if (disc.result == PPTP_CDN_RESL_ERR)
1563: disc.err = error;
1564: disc.cause = cause;
1565: /* XXX stats? */
1566: PptpCtrlWriteMsg(c, PPTP_CallDiscNotify, &disc);
1567: PptpCtrlKillChan(ch, "link layer shutdown"); /* XXX errmsg */
1568: }
1569: break;
1570: case PPTP_CHAN_ST_WAIT_OUT_REPLY: /* we are the PNS */
1571: case PPTP_CHAN_ST_WAIT_CONNECT: /* we are the PNS */
1572: pnsClear:
1573: {
1574: struct pptpCallClearRequest req;
1575:
1576: CHLOG(LOG_INFO, "clearing call");
1577: memset(&req, 0, sizeof(req));
1578: req.cid = ch->cid;
1579: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_WAIT_DISCONNECT);
1580: PptpCtrlWriteMsg(c, PPTP_CallClearRequest, &req);
1581: }
1582: break;
1583: case PPTP_CHAN_ST_WAIT_DISCONNECT: /* call was already cleared */
1584: return;
1585: case PPTP_CHAN_ST_WAIT_CTRL:
1586: PptpCtrlKillChan(ch, "link layer shutdown");
1587: return;
1588: default:
1589: assert(0);
1590: }
1591: }
1592:
1593: /*
1594: * PptpCtrlKillChan()
1595: */
1596:
1597: static void
1598: PptpCtrlKillChan(PptpChan ch, const char *errmsg)
1599: {
1600: PptpCtrl const c = ch->ctrl;
1601: PptpPendRep *pp;
1602: int k;
1603:
1604: /* Don't recurse */
1605: assert(ch);
1606: if (ch->killing) /* should never happen anyway */
1607: return;
1608: ch->killing = 1;
1609:
1610: /* If link layer needs notification, tell it */
1611: CHLOG(LOG_DEBUG, "killing channel");
1612: switch (ch->state) {
1613: case PPTP_CHAN_ST_WAIT_IN_REPLY:
1614: case PPTP_CHAN_ST_WAIT_OUT_REPLY:
1615: case PPTP_CHAN_ST_WAIT_CONNECT:
1616: case PPTP_CHAN_ST_ESTABLISHED:
1617: case PPTP_CHAN_ST_WAIT_CTRL:
1618: (*ch->linfo.result)(ch->linfo.cookie, errmsg);
1619: break;
1620: case PPTP_CHAN_ST_WAIT_DISCONNECT:
1621: break;
1622: case PPTP_CHAN_ST_WAIT_ANSWER:
1623: (*ch->linfo.cancel)(ch->linfo.cookie);
1624: break;
1625: default:
1626: assert(0);
1627: }
1628:
1629: /* Nuke any pending replies pertaining to this channel */
1630: for (pp = &c->reps; *pp; ) {
1631: PptpPendRep const prep = *pp;
1632:
1633: if (prep->chan == ch) {
1634: pevent_unregister(&prep->timer);
1635: *pp = prep->next;
1636: FREE(PPTP_PREP_MTYPE, prep);
1637: } else
1638: pp = &prep->next;
1639: }
1640:
1641: /* Free channel */
1642: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_FREE);
1643:
1644: /* When the last channel is closed, close the control channel too,
1645: unless we're already in the process of killing it. */
1646: for (k = 0; k < c->numChannels; k++) {
1647: PptpChan const ch2 = c->channels[k];
1648:
1649: if (ch2 != NULL && ch2->ctrl == c)
1650: break;
1651: }
1652: if (k == c->numChannels
1653: && c->state == PPTP_CTRL_ST_ESTABLISHED
1654: && !c->killing)
1655: PptpCtrlCloseCtrl(c);
1656: }
1657:
1658: /*************************************************************************
1659: TIMER RELATED FUNCTIONS
1660: *************************************************************************/
1661:
1662: /*
1663: * PptpCtrlReplyTimeout()
1664: */
1665:
1666: static void
1667: PptpCtrlReplyTimeout(void *arg)
1668: {
1669: PptpPendRep const prep = (PptpPendRep) arg;
1670: PptpPendRep *pp;
1671: PptpChan const ch = prep->chan;
1672: PptpCtrl const c = prep->ctrl;
1673:
1674: /* Cancel timer event */
1675: pevent_unregister(&prep->timer);
1676:
1677: /* Log it */
1678: if (ch) {
1679: CHLOG(LOG_NOTICE, "no reply to %s after %d sec",
1680: prep->request->name, prep->request->reqrep.timeout);
1681: } else if (prep->request - gPptpMsgInfo != PPTP_StopCtrlConnRequest) {
1682: CLOG(LOG_NOTICE, "no reply to %s after %d sec",
1683: prep->request->name, prep->request->reqrep.timeout);
1684: }
1685:
1686: /* Unlink pending reply */
1687: for (pp = &c->reps; *pp != prep; pp = &(*pp)->next);
1688: assert(*pp);
1689: *pp = prep->next;
1690:
1691: /* Either close this channel or kill entire control connection */
1692: if (prep->request->reqrep.killCtrl)
1693: PptpCtrlKillCtrl(c);
1694: else
1695: PptpCtrlCloseChan(ch, PPTP_CDN_RESL_ERR, PPTP_ERROR_PAC_ERROR, 0);
1696:
1697: /* Done */
1698: FREE(PPTP_PREP_MTYPE, prep);
1699: }
1700:
1701: /*
1702: * PptpCtrlIdleTimeout()
1703: *
1704: * We've heard PPTP_IDLE_TIMEOUT seconds of silence from the peer.
1705: * Send an echo request to make sure it's alive.
1706: */
1707:
1708: static void
1709: PptpCtrlIdleTimeout(void *arg)
1710: {
1711: PptpCtrl const c = (PptpCtrl) arg;
1712: struct pptpEchoRequest msg;
1713: int k;
1714:
1715: /* Cancel timer event */
1716: pevent_unregister(&c->idleTimer);
1717:
1718: /* If no channels are left on this control connection, shut it down */
1719: for (k = 0; k < c->numChannels && c->channels[k] == NULL; k++);
1720: if (k == c->numChannels) {
1721: PptpCtrlCloseCtrl(c);
1722: return;
1723: }
1724:
1725: /* Send echo request */
1726: memset(&msg, 0, sizeof(msg));
1727: msg.id = ++c->echoId;
1728: PptpCtrlWriteMsg(c, PPTP_EchoRequest, &msg);
1729: }
1730:
1731: /*
1732: * PptpCtrlResetIdleTimer()
1733: *
1734: * Reset the idle timer back up to PPTP_IDLE_TIMEOUT seconds.
1735: */
1736:
1737: static void
1738: PptpCtrlResetIdleTimer(PptpCtrl c)
1739: {
1740: struct pptp_engine *const pptp = c->pptp;
1741:
1742: pevent_unregister(&c->idleTimer);
1743: if (pevent_register(pptp->ev_ctx, &c->idleTimer, 0, pptp->mutex,
1744: PptpCtrlIdleTimeout, c, PEVENT_TIME, PPTP_IDLE_TIMEOUT * 1000) == -1)
1745: CLOG(LOG_ERR, "%s: %s", "pevent_register", strerror(errno));
1746: }
1747:
1748:
1749: /*************************************************************************
1750: CHANNEL MAINTENANCE FUNCTIONS
1751: *************************************************************************/
1752:
1753: /*
1754: * PptpCtrlCheckConn()
1755: *
1756: * Check whether we have any pending connection requests, and whether
1757: * we can send them yet, or what.
1758: */
1759:
1760: static void
1761: PptpCtrlCheckConn(PptpCtrl c)
1762: {
1763: int k;
1764:
1765: switch (c->state) {
1766: case PPTP_CTRL_ST_IDLE:
1767: case PPTP_CTRL_ST_WAIT_CTL_REPLY:
1768: case PPTP_CTRL_ST_WAIT_STOP_REPLY:
1769: break;
1770: case PPTP_CTRL_ST_ESTABLISHED:
1771: for (k = 0; k < c->numChannels; k++) {
1772: PptpChan const ch = c->channels[k];
1773:
1774: if (ch == NULL || ch->state != PPTP_CHAN_ST_WAIT_CTRL)
1775: continue;
1776: if (ch->incoming) {
1777: struct pptpInCallRequest req;
1778:
1779: memset(&req, 0, sizeof(req));
1780: req.cid = ch->cid;
1781: req.serno = req.cid;
1782: req.bearType = PPTP_BEARCAP_DIGITAL;
1783: req.channel = PHYS_CHAN(ch);
1784: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_WAIT_IN_REPLY);
1785: PptpCtrlWriteMsg(c, PPTP_InCallRequest, &req);
1786: } else {
1787: struct pptpOutCallRequest req;
1788:
1789: memset(&req, 0, sizeof(req));
1790: req.cid = ch->cid;
1791: req.serno = req.cid;
1792: req.minBps = ch->minBps;
1793: req.maxBps = ch->maxBps;
1794: req.bearType = ch->bearType;
1795: req.frameType = ch->frameType;
1796: req.recvWin = PPTP_RECV_WIN; /* XXX */
1797: req.ppd = PPTP_PPD; /* XXX */
1798: req.numLen = strlen(ch->calledNum);
1799: strncpy(req.phone, ch->calledNum, sizeof(req.phone));
1800: strncpy(req.subaddr, ch->subAddress, sizeof(req.subaddr));
1801: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_WAIT_OUT_REPLY);
1802: PptpCtrlWriteMsg(c, PPTP_OutCallRequest, &req);
1803: }
1804: return;
1805: }
1806: break;
1807: default:
1808: assert(0);
1809: }
1810: }
1811:
1812: /*
1813: * PptpCtrlFindChan()
1814: *
1815: * Find the channel identified by this message. Returns NULL if
1816: * the message is not channel specific, or the channel was not found.
1817: */
1818:
1819: static PptpChan
1820: PptpCtrlFindChan(PptpCtrl c, int type, void *msg, int incoming)
1821: {
1822: PptpMsgInfo const mi = &gPptpMsgInfo[type];
1823: const char *fname = incoming ? mi->match.inField : mi->match.outField;
1824: const int how = incoming ? mi->match.findIn : mi->match.findOut;
1825: u_int16_t cid;
1826: int k, off;
1827:
1828: /* Get the identifying CID field */
1829: if (!fname)
1830: return(NULL);
1831: (void) PptpCtrlFindField(type, fname, &off); /* we know len == 2 */
1832: cid = *((u_int16_t *) ((u_char *) msg + off));
1833:
1834: /* Match the CID against our list of active channels */
1835: for (k = 0; k < c->numChannels; k++) {
1836: PptpChan const ch = c->channels[k];
1837: u_int16_t tryCid = 0;
1838:
1839: if (ch == NULL)
1840: continue;
1841: switch (how) {
1842: case PPTP_FIND_CHAN_MY_CID:
1843: tryCid = ch->cid;
1844: break;
1845: case PPTP_FIND_CHAN_PEER_CID:
1846: tryCid = ch->peerCid;
1847: break;
1848: case PPTP_FIND_CHAN_PNS_CID:
1849: tryCid = PPTP_CHAN_IS_PNS(ch) ? ch->cid : ch->peerCid;
1850: break;
1851: case PPTP_FIND_CHAN_PAC_CID:
1852: tryCid = !PPTP_CHAN_IS_PNS(ch) ? ch->cid : ch->peerCid;
1853: break;
1854: default:
1855: assert(0);
1856: }
1857: if (cid == tryCid)
1858: return(ch);
1859: }
1860:
1861: /* Not found */
1862: CLOG(LOG_INFO, "CID 0x%04x in %s not found", cid, mi->name);
1863: return(NULL);
1864: }
1865:
1866: /*************************************************************************
1867: MISC FUNCTIONS
1868: *************************************************************************/
1869:
1870: /*
1871: * PptpCtrlNewCtrlState()
1872: */
1873:
1874: static void
1875: PptpCtrlNewCtrlState(PptpCtrl c, int new)
1876: {
1877: struct pptp_engine *const pptp = c->pptp;
1878:
1879: assert(c->state != new);
1880: CLOG(LOG_DEBUG, "ctrl state %s --> %s",
1881: gPptpCtrlStates[c->state], gPptpCtrlStates[new]);
1882: if (new == PPTP_CTRL_ST_FREE) {
1883: pptp->ctrl[c->id] = NULL;
1884: ppp_log_close(&c->log);
1885: FREE(PPTP_CTRL_MTYPE, c->channels);
1886: memset(c, 0, sizeof(*c));
1887: FREE(PPTP_CTRL_MTYPE, c);
1888: return;
1889: }
1890: c->state = new;
1891: }
1892:
1893: /*
1894: * PptpCtrlNewChanState()
1895: */
1896:
1897: static void
1898: PptpCtrlNewChanState(PptpChan ch, int new)
1899: {
1900: PptpCtrl const c = ch->ctrl;
1901:
1902: assert(ch->state != new);
1903: CHLOG(LOG_DEBUG, "chan state %s --> %s",
1904: gPptpChanStates[ch->state], gPptpChanStates[new]);
1905: switch (new) {
1906: case PPTP_CHAN_ST_FREE:
1907: c->channels[ch->id] = NULL;
1908: ppp_log_close(&ch->log);
1909: memset(ch, 0, sizeof(*ch));
1910: FREE(PPTP_CHAN_MTYPE, ch);
1911: return;
1912: case PPTP_CHAN_ST_WAIT_IN_REPLY:
1913: case PPTP_CHAN_ST_WAIT_OUT_REPLY:
1914: case PPTP_CHAN_ST_WAIT_CONNECT:
1915: case PPTP_CHAN_ST_WAIT_DISCONNECT:
1916: case PPTP_CHAN_ST_WAIT_ANSWER:
1917: case PPTP_CHAN_ST_ESTABLISHED:
1918: case PPTP_CHAN_ST_WAIT_CTRL:
1919: break;
1920: }
1921: ch->state = new;
1922: }
1923:
1924: /*
1925: * PptpCtrlSwap()
1926: *
1927: * Byteswap message between host order <--> network order. Note:
1928: * this relies on the fact that ntohs == htons and ntohl == htonl.
1929: */
1930:
1931: static void
1932: PptpCtrlSwap(int type, void *buf)
1933: {
1934: PptpField field = gPptpMsgLayout[type];
1935: int off;
1936:
1937: for (off = 0; field->name; off += field->length, field++) {
1938: switch (field->length) {
1939: case 4:
1940: {
1941: u_int32_t *const valp = (u_int32_t *) ((u_char *) buf + off);
1942:
1943: *valp = ntohl(*valp);
1944: }
1945: break;
1946: case 2:
1947: {
1948: u_int16_t *const valp = (u_int16_t *) ((u_char *) buf + off);
1949:
1950: *valp = ntohs(*valp);
1951: }
1952: break;
1953: }
1954: }
1955: }
1956:
1957: /*
1958: * PptpCtrlDump()
1959: *
1960: * Debugging display of a control message.
1961: */
1962:
1963: #define DUMP_DING 65
1964: #define DUMP_MAX_DEC 100
1965: #define DUMP_MAX_BUF 200
1966:
1967: static void
1968: PptpCtrlDump(int sev, PptpCtrl c, int type, void *msg)
1969: {
1970: struct pptp_engine *const pptp = c->pptp;
1971: PptpField field = gPptpMsgLayout[type];
1972: char line[DUMP_MAX_BUF];
1973: int off;
1974:
1975: for (*line = off = 0; field->name; off += field->length, field++) {
1976: u_char *data = (u_char *) msg + off;
1977: char buf[DUMP_MAX_BUF];
1978: const char *fmt;
1979:
1980: if (!strncmp(field->name, PPTP_RESV_PREF, strlen(PPTP_RESV_PREF)))
1981: continue;
1982: snprintf(buf, sizeof(buf), " %s=", field->name);
1983: switch (field->length) {
1984: case 4:
1985: fmt = (*((u_int16_t *) data) <= DUMP_MAX_DEC) ? "%d" : "0x%x";
1986: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1987: fmt, *((u_int32_t *) data));
1988: break;
1989: case 2:
1990: fmt = (*((u_int16_t *) data) <= DUMP_MAX_DEC) ? "%d" : "0x%x";
1991: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1992: fmt, *((u_int16_t *) data));
1993: break;
1994: case 1:
1995: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1996: "%d", *((u_int8_t *) data));
1997: break;
1998: default:
1999: snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2000: "\"%s\"", (char *) data);
2001: break;
2002: }
2003: if (*line && strlen(line) + strlen(buf) > DUMP_DING) {
2004: PLOG(sev, " %s", line);
2005: *line = 0;
2006: }
2007: snprintf(line + strlen(line), sizeof(line) - strlen(line), "%s", buf);
2008: }
2009: if (*line)
2010: PLOG(sev, " %s", line);
2011: }
2012:
2013: /*
2014: * PptpCtrlDumpBuf()
2015: *
2016: * Debugging display of a some bytes with a prefix line.
2017: */
2018:
2019: static void
2020: PptpCtrlDumpBuf(int sev, PptpCtrl c,
2021: const void *data, size_t len, const char *fmt, ...)
2022: {
2023: struct pptp_engine *const pptp = c->pptp;
2024: va_list args;
2025:
2026: va_start(args, fmt);
2027: ppp_log_vput(pptp->log, sev, fmt, args);
2028: va_end(args);
2029: ppp_log_dump(pptp->log, sev, data, len);
2030: }
2031:
2032: /*
2033: * PptpCtrlFindField()
2034: *
2035: * Locate a field in a structure, returning length and offset (*offset).
2036: * Die if field was not found.
2037: */
2038:
2039: static int
2040: PptpCtrlFindField(int type, const char *name, u_int *offp)
2041: {
2042: PptpField field = gPptpMsgLayout[type];
2043: u_int off;
2044:
2045: for (off = 0; field->name; off += field->length, field++) {
2046: if (!strcmp(field->name, name)) {
2047: *offp = off;
2048: return(field->length);
2049: }
2050: }
2051: assert(0);
2052: return(0);
2053: }
2054:
2055: /*
2056: * PptpCtrlInitCinfo()
2057: */
2058:
2059: static void
2060: PptpCtrlInitCinfo(PptpChan ch, PptpCtrlInfo ci)
2061: {
2062: PptpCtrl const c = ch->ctrl;
2063:
2064: memset(ci, 0, sizeof(*ci));
2065: ci->cookie = ch;
2066: ci->peer_addr = c->peer_addr;
2067: ci->peer_port = c->peer_port;
2068: ci->close = (void (*)(void *, int, int, int))PptpCtrlCloseChan;
2069: ci->answer = PptpCtrlDialResult;
2070: }
2071:
2072: /*
2073: * PptpCtrlExtendArray()
2074: *
2075: * Extend an array
2076: */
2077:
2078: static int
2079: PptpCtrlExtendArray(const char *mtype, void *array, int esize, int *alenp)
2080: {
2081: void **const arrayp = (void **)array;
2082: void *newa;
2083:
2084: if ((newa = REALLOC(mtype, *arrayp, (*alenp + 1) * esize)) == NULL)
2085: return(-1);
2086: *arrayp = newa;
2087: memset((u_char *)*arrayp + (*alenp * esize), 0, esize);
2088: (*alenp)++;
2089: return(0);
2090: }
2091:
2092: /*
2093: * PptpCtrlGetSocket()
2094: *
2095: * Get and (if port != 0) bind a TCP socket.
2096: */
2097:
2098: static int
2099: PptpCtrlGetSocket(struct in_addr ip, u_int16_t port, char *ebuf, size_t elen)
2100: {
2101: static const int one = 1;
2102: struct sockaddr_in addr;
2103: int sock;
2104: int addr_size = sizeof(addr);
2105:
2106: /* Get socket */
2107: if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
2108: snprintf(ebuf, elen, "socket: %s", strerror(errno));
2109: return(-1);
2110: }
2111: (void)fcntl(sock, F_SETFD, 1);
2112:
2113: /* Set reusable address and port */
2114: if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one))) {
2115: snprintf(ebuf, elen, "setsockopt: %s", strerror(errno));
2116: (void)close(sock);
2117: return(-1);
2118: }
2119: if (setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &one, sizeof(one))) {
2120: snprintf(ebuf, elen, "setsockopt: %s", strerror(errno));
2121: (void)close(sock);
2122: return(-1);
2123: }
2124:
2125: /* Bind socket */
2126: if (port != 0) {
2127: memset(&addr, 0, sizeof(addr));
2128: addr.sin_family = AF_INET;
2129: addr.sin_addr = ip;
2130: addr.sin_port = htons(port);
2131: if (bind(sock, (struct sockaddr *) &addr, addr_size) == -1) {
2132: snprintf(ebuf, elen, "bind: %s", strerror(errno));
2133: (void)close(sock);
2134: return(-1);
2135: }
2136: }
2137:
2138: /* Done */
2139: return(sock);
2140: }
2141:
2142: /*************************************************************************
2143: CONTROL MESSAGE FUNCTIONS
2144: *************************************************************************/
2145:
2146: /*
2147: * PptpStartCtrlConnRequest()
2148: */
2149:
2150: static void
2151: PptpStartCtrlConnRequest(PptpCtrl c, struct pptpStartCtrlConnRequest *req)
2152: {
2153: struct pptp_engine *const pptp = c->pptp;
2154: struct pptpStartCtrlConnReply reply;
2155: int k;
2156:
2157: /* Check for a collision */
2158: if (!pptp->nocd) {
2159: for (k = 0; k < pptp->nctrl; k++) {
2160: PptpCtrl const c2 = pptp->ctrl[k];
2161: int iwin;
2162:
2163: if (c2 == NULL
2164: || c2 == c
2165: || c2->peer_addr.s_addr != c->peer_addr.s_addr)
2166: continue;
2167: iwin = (u_int32_t) ntohl(c->self_addr.s_addr)
2168: > (u_int32_t) ntohl(c->peer_addr.s_addr);
2169: CLOG(LOG_INFO, "collision with peer! %s", iwin ? "i win" : "peer wins");
2170: if (iwin)
2171: goto abort; /* Kill this peer-initiated connection */
2172: else
2173: PptpCtrlKillCtrl(c2); /* Kill the connection that I initiated */
2174: }
2175: }
2176:
2177: /* Initialize reply */
2178: memset(&reply, 0, sizeof(reply));
2179: reply.vers = PPTP_PROTO_VERS;
2180: reply.frameCap = PPTP_FRAMECAP_SYNC;
2181: reply.bearCap = PPTP_BEARCAP_ANY;
2182: reply.firmware = PPTP_FIRMWARE_REV;
2183: reply.result = PPTP_SCCR_RESL_OK;
2184: gethostname(reply.host, sizeof(reply.host));
2185: strncpy(reply.vendor, pptp->vendor, sizeof(reply.vendor));
2186:
2187: /* Check protocol version */
2188: if (req->vers != PPTP_PROTO_VERS) {
2189: CLOG(LOG_ERR, "incompatible PPTP protocol version 0x%04x", req->vers);
2190: reply.result = PPTP_SCCR_RESL_VERS;
2191: PptpCtrlWriteMsg(c, PPTP_StartCtrlConnReply, &reply);
2192: abort:
2193: PptpCtrlKillCtrl(c);
2194: return;
2195: }
2196:
2197: /* OK */
2198: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_ESTABLISHED);
2199: PptpCtrlWriteMsg(c, PPTP_StartCtrlConnReply, &reply);
2200: }
2201:
2202: /*
2203: * PptpStartCtrlConnReply()
2204: */
2205:
2206: static void
2207: PptpStartCtrlConnReply(PptpCtrl c, struct pptpStartCtrlConnReply *rep)
2208: {
2209:
2210: /* Is peer happy? */
2211: if (rep->result != PPTP_SCCR_RESL_OK) {
2212: CLOG(LOG_NOTICE, "my %s failed, result=%s err=%s",
2213: gPptpMsgInfo[PPTP_StartCtrlConnRequest].name,
2214: PPTP_SCCR_RESL_CODE(rep->result), PPTP_ERROR_CODE(rep->err));
2215: PptpCtrlKillCtrl(c);
2216: return;
2217: }
2218:
2219: /* Check peer's protocol version */
2220: if (rep->vers != PPTP_PROTO_VERS) {
2221: struct pptpStopCtrlConnRequest req;
2222:
2223: CLOG(LOG_ERR, "incompatible PPTP protocol version 0x%04x", rep->vers);
2224: memset(&req, 0, sizeof(req));
2225: req.reason = PPTP_SCCR_REAS_PROTO;
2226: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_WAIT_STOP_REPLY);
2227: PptpCtrlWriteMsg(c, PPTP_StopCtrlConnRequest, &req);
2228: return;
2229: }
2230:
2231: /* OK */
2232: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_ESTABLISHED);
2233: PptpCtrlCheckConn(c);
2234: }
2235:
2236: /*
2237: * PptpStopCtrlConnRequest()
2238: */
2239:
2240: static void
2241: PptpStopCtrlConnRequest(PptpCtrl c, struct pptpStopCtrlConnRequest *req)
2242: {
2243: struct pptpStopCtrlConnReply rep;
2244:
2245: CLOG(LOG_INFO, "rec'd %s: reason=%s",
2246: gPptpMsgInfo[PPTP_StopCtrlConnRequest].name,
2247: PPTP_SCCR_REAS_CODE(req->reason));
2248: memset(&rep, 0, sizeof(rep));
2249: rep.result = PPTP_SCCR_RESL_OK;
2250: PptpCtrlNewCtrlState(c, PPTP_CTRL_ST_IDLE);
2251: PptpCtrlWriteMsg(c, PPTP_StopCtrlConnReply, &rep);
2252: PptpCtrlKillCtrl(c);
2253: }
2254:
2255: /*
2256: * PptpStopCtrlConnReply()
2257: */
2258:
2259: static void
2260: PptpStopCtrlConnReply(PptpCtrl c, struct pptpStopCtrlConnReply *rep)
2261: {
2262: PptpCtrlKillCtrl(c);
2263: }
2264:
2265: /*
2266: * PptpEchoRequest()
2267: */
2268:
2269: static void
2270: PptpEchoRequest(PptpCtrl c, struct pptpEchoRequest *req)
2271: {
2272: struct pptpEchoReply reply;
2273:
2274: memset(&reply, 0, sizeof(reply));
2275: reply.id = req->id;
2276: reply.result = PPTP_ECHO_RESL_OK;
2277: PptpCtrlWriteMsg(c, PPTP_EchoReply, &reply);
2278: }
2279:
2280: /*
2281: * PptpEchoReply()
2282: */
2283:
2284: static void
2285: PptpEchoReply(PptpCtrl c, struct pptpEchoReply *rep)
2286: {
2287: if (rep->result != PPTP_ECHO_RESL_OK) {
2288: CLOG(LOG_NOTICE, "echo reply failed: res=%s err=%s",
2289: PPTP_ECHO_RESL_CODE(rep->result), PPTP_ERROR_CODE(rep->err));
2290: PptpCtrlKillCtrl(c);
2291: } else if (rep->id != c->echoId) {
2292: CLOG(LOG_NOTICE, "bogus echo reply: %u != %u", rep->id, c->echoId);
2293: PptpCtrlKillCtrl(c);
2294: }
2295: }
2296:
2297: /*
2298: * PptpOutCallRequest()
2299: */
2300:
2301: static void
2302: PptpOutCallRequest(PptpCtrl c, struct pptpOutCallRequest *req)
2303: {
2304: struct pptp_engine *const pptp = c->pptp;
2305: struct pptpOutCallReply reply;
2306: struct pptpctrlinfo cinfo;
2307: struct pptplinkinfo linfo;
2308: PptpChan ch = NULL;
2309: char calledNum[PPTP_PHONE_LEN + 1];
2310: char subAddress[PPTP_SUBADDR_LEN + 1];
2311:
2312: /* Does link allow this? */
2313: if (pptp->get_out_link == NULL)
2314: goto denied;
2315:
2316: /* Copy out fields */
2317: strncpy(calledNum, req->phone, sizeof(calledNum) - 1);
2318: calledNum[sizeof(calledNum) - 1] = 0;
2319: strncpy(subAddress, req->subaddr, sizeof(subAddress) - 1);
2320: subAddress[sizeof(subAddress) - 1] = 0;
2321:
2322: /* Get a data channel */
2323: if ((ch = PptpCtrlGetChan(c, PPTP_CHAN_ST_WAIT_ANSWER, FALSE, FALSE,
2324: req->bearType, req->frameType, req->minBps, req->maxBps,
2325: PPTP_STR_INTERNAL_CALLING, calledNum, subAddress)) == NULL) {
2326: CLOG(LOG_ERR, "can't get channel for %s call", "outgoing");
2327: goto chFail;
2328: }
2329:
2330: /* Fill in details */
2331: ch->serno = req->serno;
2332: ch->peerCid = req->cid;
2333: ch->peerPpd = req->ppd;
2334: ch->recvWin = req->recvWin;
2335:
2336: /* Ask link layer about making the outgoing call */
2337: PptpCtrlInitCinfo(ch, &cinfo);
2338: linfo = (*pptp->get_out_link)(pptp->arg,
2339: cinfo, c->peer_addr, c->peer_port, req->bearType,
2340: req->frameType, req->minBps, req->maxBps, calledNum, subAddress);
2341: if (linfo.cookie == NULL || linfo.cancel == NULL || linfo.result == NULL)
2342: goto denied;
2343:
2344: /* Link layer says it's OK; wait for link layer to report back later */
2345: ch->linfo = linfo;
2346: return;
2347:
2348: /* Failed */
2349: denied:
2350: CLOG(LOG_NOTICE, "peer's %s call request was denied", "outgoing");
2351: if (ch)
2352: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_FREE);
2353: chFail:
2354: memset(&reply, 0, sizeof(reply));
2355: reply.peerCid = req->cid;
2356: reply.result = PPTP_OCR_RESL_ADMIN;
2357: PptpCtrlWriteMsg(c, PPTP_OutCallReply, &reply);
2358: }
2359:
2360: /*
2361: * PptpOutCallReply()
2362: */
2363:
2364: static void
2365: PptpOutCallReply(PptpChan ch, struct pptpOutCallReply *reply)
2366: {
2367: /* Did call go through? */
2368: if (reply->result != PPTP_OCR_RESL_OK) {
2369: char errmsg[100];
2370:
2371: snprintf(errmsg, sizeof(errmsg),
2372: "outgoing call failed: res=%s err=%s",
2373: PPTP_OCR_RESL_CODE(reply->result), PPTP_ERROR_CODE(reply->err));
2374: CHLOG(LOG_NOTICE, "%s", errmsg);
2375: (*ch->linfo.result)(ch->linfo.cookie, errmsg);
2376: PptpCtrlKillChan(ch, "remote outgoing call failed");
2377: return;
2378: }
2379:
2380: /* Call succeeded */
2381: ch->peerPpd = reply->ppd;
2382: ch->recvWin = reply->recvWin;
2383: ch->peerCid = reply->cid;
2384: CHLOG(LOG_INFO, "outgoing call connected at %d bps", reply->speed);
2385: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_ESTABLISHED);
2386: (*ch->linfo.result)(ch->linfo.cookie, NULL);
2387: }
2388:
2389: /*
2390: * PptpInCallRequest()
2391: */
2392:
2393: static void
2394: PptpInCallRequest(PptpCtrl c, struct pptpInCallRequest *req)
2395: {
2396: struct pptp_engine *const pptp = c->pptp;
2397: struct pptpInCallReply reply;
2398: struct pptpctrlinfo cinfo;
2399: struct pptplinkinfo linfo;
2400: PptpChan ch;
2401: char callingNum[PPTP_PHONE_LEN + 1];
2402: char calledNum[PPTP_PHONE_LEN + 1];
2403: char subAddress[PPTP_SUBADDR_LEN + 1];
2404:
2405: /* Copy out fields */
2406: if (req->dialedLen > PPTP_PHONE_LEN)
2407: req->dialedLen = PPTP_PHONE_LEN;
2408: if (req->dialingLen > PPTP_PHONE_LEN)
2409: req->dialingLen = PPTP_PHONE_LEN;
2410: strncpy(callingNum, req->dialing, sizeof(callingNum) - 1);
2411: callingNum[req->dialingLen] = 0;
2412: strncpy(calledNum, req->dialed, sizeof(calledNum) - 1);
2413: calledNum[req->dialedLen] = 0;
2414: strncpy(subAddress, req->subaddr, sizeof(subAddress) - 1);
2415: subAddress[sizeof(subAddress) - 1] = 0;
2416:
2417: CLOG(LOG_INFO, "peer incoming call to \"%s\" from \"%s\"",
2418: calledNum, callingNum);
2419:
2420: /* Initialize reply */
2421: memset(&reply, 0, sizeof(reply));
2422: reply.peerCid = req->cid;
2423: reply.recvWin = PPTP_RECV_WIN; /* XXX */
2424: reply.ppd = PPTP_PPD; /* XXX */
2425:
2426: /* Get a data channel */
2427: if ((ch = PptpCtrlGetChan(c, PPTP_CHAN_ST_WAIT_CONNECT, FALSE, TRUE,
2428: req->bearType, 0, 0, INT_MAX,
2429: callingNum, calledNum, subAddress)) == NULL) {
2430: CLOG(LOG_ERR, "can't get channel for %s call", "incoming");
2431: reply.result = PPTP_ICR_RESL_ERR;
2432: reply.err = PPTP_ERROR_NO_RESOURCE;
2433: goto done;
2434: }
2435: reply.cid = ch->cid;
2436:
2437: /* Fill in details */
2438: ch->serno = req->serno;
2439: ch->peerCid = req->cid;
2440: ch->bearType = req->bearType;
2441:
2442: /* Ask link layer about accepting the incoming call */
2443: PptpCtrlInitCinfo(ch, &cinfo);
2444: linfo.cookie = NULL;
2445: if (pptp->get_in_link != NULL)
2446: linfo = (*pptp->get_in_link)(pptp->arg, cinfo, c->peer_addr, c->peer_port,
2447: req->bearType, callingNum, calledNum, subAddress);
2448: if (linfo.cookie == NULL) {
2449: CLOG(LOG_NOTICE, "peer's %s call request was denied", "incoming");
2450: reply.result = PPTP_ICR_RESL_NAK;
2451: goto done;
2452: }
2453:
2454: /* Link layer says it's OK */
2455: CHLOG(LOG_INFO, "accepting incoming call to \"%s\" from \"%s\"",
2456: calledNum, callingNum);
2457: reply.result = PPTP_ICR_RESL_OK;
2458: ch->linfo = linfo;
2459: strncpy(ch->callingNum, req->dialing, sizeof(ch->callingNum));
2460: strncpy(ch->calledNum, req->dialed, sizeof(ch->calledNum));
2461: strncpy(ch->subAddress, req->subaddr, sizeof(ch->subAddress));
2462:
2463: /* Return result */
2464: done:
2465: PptpCtrlWriteMsg(c, PPTP_InCallReply, &reply);
2466: if (reply.result != PPTP_ICR_RESL_OK)
2467: PptpCtrlKillChan(ch, "peer incoming call failed");
2468: }
2469:
2470: /*
2471: * PptpInCallReply()
2472: */
2473:
2474: static void
2475: PptpInCallReply(PptpChan ch, struct pptpInCallReply *reply)
2476: {
2477: PptpCtrl const c = ch->ctrl;
2478: struct pptpInCallConn con;
2479:
2480: /* Did call go through? */
2481: if (reply->result != PPTP_ICR_RESL_OK) {
2482: char errmsg[100];
2483:
2484: snprintf(errmsg, sizeof(errmsg),
2485: "peer denied incoming call: res=%s err=%s",
2486: PPTP_ICR_RESL_CODE(reply->result), PPTP_ERROR_CODE(reply->err));
2487: CHLOG(LOG_NOTICE, "%s", errmsg);
2488: (*ch->linfo.result)(ch->linfo.cookie, errmsg);
2489: PptpCtrlKillChan(ch, "peer denied incoming call");
2490: return;
2491: }
2492:
2493: /* Call succeeded */
2494: CHLOG(LOG_INFO, "incoming call accepted by peer");
2495: ch->peerCid = reply->cid;
2496: ch->peerPpd = reply->ppd;
2497: ch->recvWin = reply->recvWin;
2498: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_ESTABLISHED);
2499: (*ch->linfo.result)(ch->linfo.cookie, NULL);
2500:
2501: /* Send back connected message */
2502: memset(&con, 0, sizeof(con));
2503: con.peerCid = reply->cid;
2504: con.speed = 64000; /* XXX */
2505: con.recvWin = PPTP_RECV_WIN; /* XXX */
2506: con.ppd = PPTP_PPD; /* XXX */
2507: con.frameType = PPTP_FRAMECAP_SYNC;
2508: PptpCtrlWriteMsg(c, PPTP_InCallConn, &con);
2509: }
2510:
2511: /*
2512: * PptpInCallConn()
2513: */
2514:
2515: static void
2516: PptpInCallConn(PptpChan ch, struct pptpInCallConn *con)
2517: {
2518: CHLOG(LOG_INFO, "peer incoming call connected at %d bps", con->speed);
2519: ch->peerPpd = con->ppd;
2520: ch->recvWin = con->recvWin;
2521: ch->frameType = con->frameType;
2522: (*ch->linfo.result)(ch->linfo.cookie, NULL);
2523: PptpCtrlNewChanState(ch, PPTP_CHAN_ST_ESTABLISHED);
2524: }
2525:
2526: /*
2527: * PptpCallClearRequest()
2528: */
2529:
2530: static void
2531: PptpCallClearRequest(PptpChan ch, struct pptpCallClearRequest *req)
2532: {
2533: struct pptpCallDiscNotify notify;
2534: PptpCtrl const c = ch->ctrl;
2535:
2536: if (PPTP_CHAN_IS_PNS(ch)) {
2537: CHLOG(LOG_NOTICE, "rec'd %s, but we are PNS for this call",
2538: gPptpMsgInfo[PPTP_CallClearRequest].name);
2539: PptpCtrlKillCtrl(c);
2540: return;
2541: }
2542: CHLOG(LOG_INFO, "call cleared by peer");
2543: memset(¬ify, 0, sizeof(notify));
2544: notify.cid = ch->cid; /* we are the PAC, use our CID */
2545: notify.result = PPTP_CDN_RESL_REQ;
2546: /* XXX stats? */
2547: PptpCtrlWriteMsg(c, PPTP_CallDiscNotify, ¬ify);
2548: PptpCtrlKillChan(ch, "cleared by peer");
2549: }
2550:
2551: /*
2552: * PptpCallDiscNotify()
2553: */
2554:
2555: static void
2556: PptpCallDiscNotify(PptpChan ch, struct pptpCallDiscNotify *notify)
2557: {
2558: CHLOG(LOG_INFO, "peer call disconnected res=%s err=%s",
2559: PPTP_CDN_RESL_CODE(notify->result), PPTP_ERROR_CODE(notify->err));
2560: PptpCtrlKillChan(ch, "disconnected by peer");
2561: }
2562:
2563: /*
2564: * PptpWanErrorNotify()
2565: */
2566:
2567: static void
2568: PptpWanErrorNotify(PptpChan ch, struct pptpWanErrorNotify *notif)
2569: {
2570: CHLOG(LOG_DEBUG, "ignoring %s", gPptpMsgInfo[PPTP_WanErrorNotify].name);
2571: }
2572:
2573: /*
2574: * PptpSetLinkInfo()
2575: */
2576:
2577: static void
2578: PptpSetLinkInfo(PptpChan ch, struct pptpSetLinkInfo *info)
2579: {
2580: if (ch->linfo.setLinkInfo)
2581: (*ch->linfo.setLinkInfo)(ch->linfo.cookie, info->sendAccm, info->recvAccm);
2582: else {
2583: CHLOG(LOG_DEBUG, "ignoring %s", gPptpMsgInfo[PPTP_SetLinkInfo].name);
2584: }
2585: }
2586:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_pptp_ctrl.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