GCC Code Coverage Report
Directory: ./ Exec Total Coverage
File: usr.sbin/npppd/npppd/../pptp/pptp_call.c Lines: 0 288 0.0 %
Date: 2017-11-13 Branches: 0 107 0.0 %

Line Branch Exec Source
1
/*	$OpenBSD: pptp_call.c,v 1.9 2015/12/05 16:10:31 yasuoka Exp $	*/
2
3
/*-
4
 * Copyright (c) 2009 Internet Initiative Japan Inc.
5
 * All rights reserved.
6
 *
7
 * Redistribution and use in source and binary forms, with or without
8
 * modification, are permitted provided that the following conditions
9
 * are met:
10
 * 1. Redistributions of source code must retain the above copyright
11
 *    notice, this list of conditions and the following disclaimer.
12
 * 2. Redistributions in binary form must reproduce the above copyright
13
 *    notice, this list of conditions and the following disclaimer in the
14
 *    documentation and/or other materials provided with the distribution.
15
 *
16
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
17
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
20
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
21
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
22
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
23
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
24
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
25
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26
 * SUCH DAMAGE.
27
 */
28
/* $Id: pptp_call.c,v 1.9 2015/12/05 16:10:31 yasuoka Exp $ */
29
/**@file PPTP Call */
30
/* currently it supports PAC mode only */
31
#include <sys/types.h>
32
#include <sys/socket.h>
33
#include <sys/time.h>
34
#include <netinet/in.h>
35
#include <net/if_dl.h>
36
#include <stdio.h>
37
#include <stdarg.h>
38
#include <stdlib.h>
39
#include <string.h>
40
#include <unistd.h>
41
#include <syslog.h>
42
#include <event.h>
43
44
#ifdef USE_LIBSOCKUTIL
45
#include <seil/sockfromto.h>
46
#endif
47
48
#include "bytebuf.h"
49
#include "slist.h"
50
#include "hash.h"
51
#include "debugutil.h"
52
#include "time_utils.h"
53
54
#include "pptp.h"
55
#include "pptp_local.h"
56
#include "pptp_subr.h"
57
58
#include "npppd.h"
59
60
#ifdef PPTP_CALL_DEBUG
61
#define PPTP_CALL_DBG(x)	pptp_call_log x
62
#define PPTP_CALL_ASSERT(x)	ASSERT(x)
63
#else
64
#define PPTP_CALL_DBG(x)
65
#define PPTP_CALL_ASSERT(x)
66
#endif
67
68
static void  pptp_call_log (pptp_call *, int, const char *, ...) __printflike(3,4);
69
70
71
static void  pptp_call_notify_down (pptp_call *);
72
static int   pptp_call_recv_SLI (pptp_call *, u_char *, int);
73
static int   pptp_call_recv_CCR (pptp_call *, u_char *, int);
74
static int   pptp_call_recv_OCRQ (pptp_call *, u_char *, int);
75
static void  pptp_call_send_CDN (pptp_call *, int, int, int, const char *);
76
static int   pptp_call_send_OCRP (pptp_call *, int, int, int);
77
static int   pptp_call_gre_output (pptp_call *, int, int, u_char *, int);
78
static int   pptp_call_bind_ppp (pptp_call *);
79
static void  pptp_call_log (pptp_call *, int, const char *, ...);
80
static void  pptp_call_OCRQ_string (struct pptp_ocrq *, char *, int);
81
static void  pptp_call_OCRP_string (struct pptp_ocrp *, char *, int);
82
static void   pptp_call_ppp_input (pptp_call *, unsigned char *, int, int);
83
static char * pptp_call_state_string(int);
84
85
static int   pptp_call_ppp_output (npppd_ppp *, unsigned char *, int, int);
86
static void  pptp_call_closed_by_ppp (npppd_ppp *);
87
88
/* not used
89
static int   pptp_call_send_SLI (pptp_call *);
90
 */
91
92
#define SEQ_LT(a,b)	((int)((a) - (b)) <  0)
93
#define SEQ_LE(a,b)	((int)((a) - (b)) <= 0)
94
#define SEQ_GT(a,b)	((int)((a) - (b)) >  0)
95
#define SEQ_GE(a,b)	((int)((a) - (b)) >= 0)
96
#define SEQ_SUB(a,b)	((int32_t)((a) - (b)))
97
98
/* round-up division */
99
#define RUPDIV(n,d)	(((n) + ((d) - ((n) % (d)))) / (d))
100
101
/*
102
 * instance related functions
103
 */
104
pptp_call *
105
pptp_call_create(void)
106
{
107
	pptp_call *_this;
108
109
	if ((_this = malloc(sizeof(pptp_call))) == NULL)
110
		return NULL;
111
112
	return _this;
113
}
114
115
int
116
pptp_call_init(pptp_call *_this, pptp_ctrl *ctrl)
117
{
118
	memset(_this, 0, sizeof(pptp_call));
119
	_this->ctrl = ctrl;
120
121
	_this->maxwinsz = PPTP_CALL_DEFAULT_MAXWINSZ;
122
	_this->winsz = RUPDIV(_this->maxwinsz, 2);
123
	_this->last_io = get_monosec();
124
	_this->snd_nxt = 1;
125
126
	return 0;
127
}
128
129
int
130
pptp_call_start(pptp_call *_this)
131
{
132
	if (pptp_call_bind_ppp(_this) != 0)
133
		return 1;
134
135
	return 0;
136
}
137
138
int
139
pptp_call_stop(pptp_call *_this)
140
{
141
	if (_this->state != PPTP_CALL_STATE_CLEANUP_WAIT)
142
		pptp_call_disconnect(_this, 0, 0, NULL);
143
144
	pptp_call_log(_this, LOG_NOTICE, "logtype=Terminated");
145
	pptpd_release_call(_this->ctrl->pptpd, _this);
146
147
	return 0;
148
}
149
150
void
151
pptp_call_destroy(pptp_call *_this)
152
{
153
	PPTP_CALL_ASSERT(_this != NULL);
154
	free(_this);
155
}
156
157
void
158
pptp_call_disconnect(pptp_call *_this, int result, int error, const char *
159
    statistics)
160
{
161
	if (_this->state == PPTP_CALL_STATE_CLEANUP_WAIT) {
162
		pptp_call_notify_down(_this);
163
		return;
164
	}
165
	if (result > 0)
166
		pptp_call_send_CDN(_this, result, error, 0, statistics);
167
	_this->state = PPTP_CALL_STATE_CLEANUP_WAIT;
168
	pptp_call_notify_down(_this);
169
}
170
171
/*
172
 * PPTP control packet I/O
173
 */
174
175
void
176
pptp_call_input(pptp_call *_this, int mes_type, u_char *pkt, int lpkt)
177
{
178
179
	PPTP_CALL_ASSERT(_this != NULL);
180
	PPTP_CALL_ASSERT(pkt != NULL);
181
	PPTP_CALL_ASSERT(lpkt >= 4);
182
183
	_this->last_io = get_monosec();
184
	switch (mes_type) {
185
	case PPTP_CTRL_MES_CODE_OCRQ:
186
		if (_this->state != PPTP_CALL_STATE_IDLE) {
187
			pptp_call_send_OCRP(_this,
188
			    PPTP_OCRP_RESULT_GENERIC_ERROR,
189
			    PPTP_ERROR_BAD_CALL, 0);
190
			goto bad_state;
191
		}
192
		if (pptp_call_recv_OCRQ(_this, pkt, lpkt) != 0) {
193
			pptp_call_send_OCRP(_this,
194
			    PPTP_OCRP_RESULT_GENERIC_ERROR,
195
			    PPTP_ERROR_BAD_CALL, 0);
196
			return;
197
		}
198
		if (pptpd_assign_call(_this->ctrl->pptpd, _this) != 0) {
199
			pptp_call_send_OCRP(_this, PPTP_OCRP_RESULT_BUSY,
200
			    PPTP_ERROR_NONE, 0);
201
			return;
202
		}
203
		if (pptp_call_send_OCRP(_this, PPTP_OCRP_RESULT_CONNECTED,
204
		    PPTP_ERROR_NONE, 0) != 0) {
205
			pptp_call_disconnect(_this,
206
			    PPTP_CDN_RESULT_GENRIC_ERROR,
207
			    PPTP_ERROR_PAC_ERROR, NULL);
208
			return;
209
		}
210
		if (pptp_call_start(_this) != 0) {
211
			pptp_call_disconnect(_this,
212
			    PPTP_CDN_RESULT_GENRIC_ERROR,
213
			    PPTP_ERROR_PAC_ERROR, NULL);
214
			return;
215
		}
216
		_this->state = PPTP_CALL_STATE_ESTABLISHED;
217
		break;
218
	case PPTP_CTRL_MES_CODE_SLI:
219
		if (pptp_call_recv_SLI(_this, pkt, lpkt) != 0) {
220
			return;
221
		}
222
		return;
223
	case PPTP_CTRL_MES_CODE_CCR:
224
		pptp_call_recv_CCR(_this, pkt, lpkt);
225
		if (_this->state == PPTP_CALL_STATE_ESTABLISHED) {
226
			pptp_call_disconnect(_this, PPTP_CDN_RESULT_REQUEST,
227
			    PPTP_ERROR_NONE, NULL);
228
		} else {
229
			pptp_call_disconnect(_this, 0, 0, NULL);
230
			if (_this->state != PPTP_CALL_STATE_CLEANUP_WAIT)
231
				goto bad_state;
232
		}
233
		return;
234
	default:
235
	    pptp_call_log(_this, LOG_WARNING,
236
		"Unhandled control message type=%s(%d)",
237
		    pptp_ctrl_mes_type_string(mes_type), mes_type);
238
	}
239
	return;
240
bad_state:
241
	pptp_call_log(_this, LOG_WARNING,
242
	    "Received control message %s(%d) in bad state=%s",
243
		pptp_ctrl_mes_type_string(mes_type), mes_type,
244
		pptp_call_state_string(_this->state));
245
}
246
247
/* receive Set-Link-Info */
248
/* XXX: this implementation is only supporting "Sync-Frame",
249
 * ACCM (Asynchronous Control Character Map) will be discarded */
250
static int
251
pptp_call_recv_SLI(pptp_call *_this, u_char *pkt, int lpkt)
252
{
253
	struct pptp_sli *sli;
254
255
	if (lpkt < sizeof(struct pptp_sli)) {
256
		pptp_call_log(_this, LOG_ERR, "Received bad SLI: packet too "
257
		    "short: %d < %d", lpkt, (int)sizeof(struct pptp_sli));
258
		return 1;
259
	}
260
	sli = (struct pptp_sli *)pkt;
261
	sli->send_accm = ntohl(sli->send_accm);
262
	sli->recv_accm = ntohl(sli->recv_accm);
263
	if (sli->send_accm != 0xffffffffL ||
264
	    sli->recv_accm != 0xffffffffL) {
265
		pptp_call_log(_this, LOG_WARNING,
266
		    "RecvSLI Received bad ACCM %08x:%08x: asynchronous framing "
267
		    "is not supported.\n", sli->send_accm, sli->recv_accm);
268
		return 1;
269
	}
270
	pptp_call_log(_this, LOG_INFO, "RecvSLI accm=%08x:%08x",
271
	    sli->send_accm, sli->recv_accm);
272
273
	return 0;
274
}
275
276
#if 0
277
/* Some route implementation which has "PPTP pass-through" function
278
 * will discard 1723/tcp packet between PAC and PNS, when it recognize
279
 * SLI from PAC. (for example, FLASHWAVE by Fujitsu).
280
 *
281
 * To avoid avobe situation, npppd send well-known SLI only.
282
 */
283
static int
284
pptp_call_send_SLI(pptp_call *_this)
285
{
286
	int lpkt;
287
	struct pptp_sli *sli;
288
289
	sli = bytebuffer_pointer(_this->ctrl->send_buf);
290
	lpkt = bytebuffer_remaining(_this->ctrl->send_buf);
291
	if (lpkt < sizeof(struct pptp_sli)) {
292
		pptp_call_log(_this, LOG_ERR,
293
		    "SendOCRP failed: No buffer space available");
294
		return -1;
295
	}
296
	memset(sli, 0, sizeof(struct pptp_sli));
297
298
	pptp_init_header(&sli->header, sizeof(struct pptp_sli),
299
	    PPTP_CTRL_MES_CODE_SLI);
300
301
	sli->peers_call_id = _this->id;
302
	sli->send_accm = 0xffffffff;
303
	sli->recv_accm = 0xffffffff;
304
305
	_this->last_io = get_monosec();
306
	pptp_call_log(_this, LOG_INFO, "SendSLI accm=%08x:%08x",
307
	    sli->send_accm, sli->recv_accm);
308
	sli->peers_call_id = htons(sli->peers_call_id);
309
	sli->send_accm = htonl(sli->send_accm);
310
	sli->recv_accm = htonl(sli->recv_accm);
311
	pptp_ctrl_output(_this->ctrl, NULL,  sizeof(struct pptp_sli));
312
313
	return 0;
314
}
315
#endif
316
317
/* Receive Call-Clear-Request */
318
static int
319
pptp_call_recv_CCR(pptp_call *_this, u_char *pkt, int lpkt)
320
{
321
	struct pptp_ccr *ccr;
322
323
	/* check size */
324
	PPTP_CALL_ASSERT(lpkt >= sizeof(struct pptp_ccr));
325
	if (lpkt < sizeof(struct pptp_ccr)) {
326
		/* never happen, should KASSERT() here? */
327
		return 1;
328
	}
329
	ccr = (struct pptp_ccr *)pkt;
330
331
	/* convert byte-order */
332
	ccr->call_id = ntohs(ccr->call_id);
333
	pptp_call_log(_this, LOG_INFO, "RecvCCR call_id=%u", ccr->call_id);
334
335
	return 0;
336
}
337
338
/* Send Call-Disconnect-Notify */
339
static void
340
pptp_call_send_CDN(pptp_call *_this, int result, int error, int cause,
341
    const char *statistics)
342
{
343
	int lpkt;
344
	struct pptp_cdn *cdn;
345
346
	cdn = bytebuffer_pointer(_this->ctrl->send_buf);
347
	lpkt = bytebuffer_remaining(_this->ctrl->send_buf);
348
	if (lpkt < sizeof(struct pptp_cdn)) {
349
		pptp_call_log(_this, LOG_ERR,
350
		    "SendCCR failed: No buffer space available");
351
		return;
352
	}
353
	memset(cdn, 0, sizeof(struct pptp_cdn));
354
355
	pptp_init_header(&cdn->header, sizeof(struct pptp_cdn),
356
	    PPTP_CTRL_MES_CODE_CDN);
357
358
	cdn->call_id = _this->id;
359
	cdn->result_code = result;
360
	cdn->error_code = error;
361
	cdn->cause_code = cause;
362
	if (statistics != NULL)
363
		strlcpy(cdn->statistics, statistics, sizeof(cdn->statistics));
364
365
	pptp_call_log(_this, LOG_INFO, "SendCDN "
366
	    "call_id=%u result=%s(%d) error=%s(%d) cause=%d statistics=%s",
367
	    cdn->call_id,
368
	    pptp_CDN_result_string(cdn->result_code), cdn->result_code,
369
	    pptp_general_error_string(cdn->error_code), cdn->error_code,
370
	    cdn->cause_code,
371
		(statistics == NULL)? "(none)" : (char *)cdn->statistics);
372
373
	cdn->call_id = htons(cdn->call_id);
374
	cdn->cause_code = htons(cdn->cause_code);
375
376
	_this->last_io = get_monosec();
377
	pptp_ctrl_output(_this->ctrl, NULL, sizeof(struct pptp_cdn));
378
}
379
380
/* Send Outgoing-Call-Reply */
381
static int
382
pptp_call_send_OCRP(pptp_call *_this, int result, int error, int cause)
383
{
384
	int lpkt;
385
	struct pptp_ocrp *ocrp;
386
	char logbuf[512];
387
388
	ocrp = bytebuffer_pointer(_this->ctrl->send_buf);
389
	lpkt = bytebuffer_remaining(_this->ctrl->send_buf);
390
	if (lpkt < sizeof(struct pptp_ocrp)) {
391
		pptp_call_log(_this, LOG_ERR,
392
		    "SendOCRP failed: No buffer space available");
393
		return -1;
394
	}
395
	memset(ocrp, 0, sizeof(struct pptp_ocrp));
396
397
	pptp_init_header(&ocrp->header, sizeof(struct pptp_ocrp),
398
	    PPTP_CTRL_MES_CODE_OCRP);
399
400
	ocrp->call_id = _this->id;
401
	ocrp->peers_call_id = _this->peers_call_id;
402
	ocrp->result_code = result;
403
	ocrp->error_code = error;
404
	ocrp->cause_code = cause;
405
	ocrp->connect_speed = PPTP_CALL_CONNECT_SPEED;
406
	ocrp->recv_winsz =  _this->maxwinsz;
407
	ocrp->packet_proccessing_delay = PPTP_CALL_INITIAL_PPD;
408
	ocrp->physical_channel_id = _this->id;
409
410
	pptp_call_OCRP_string(ocrp, logbuf, sizeof(logbuf));
411
	pptp_call_log(_this, LOG_INFO, "SendOCRP %s", logbuf);
412
413
	ocrp->call_id = htons(ocrp->call_id);
414
	ocrp->peers_call_id = htons(ocrp->peers_call_id);
415
	ocrp->cause_code = htons(ocrp->cause_code);
416
	ocrp->connect_speed = htons(ocrp->connect_speed);
417
	ocrp->recv_winsz = htons(ocrp->recv_winsz);
418
	ocrp->packet_proccessing_delay = htons(ocrp->packet_proccessing_delay);
419
	ocrp->physical_channel_id = htonl(ocrp->physical_channel_id);
420
421
	_this->last_io = get_monosec();
422
	pptp_ctrl_output(_this->ctrl, NULL,  sizeof(struct pptp_ocrp));
423
424
	return 0;
425
}
426
427
/* Receive Outgoing-Call-Request */
428
static int
429
pptp_call_recv_OCRQ(pptp_call *_this, u_char *pkt, int lpkt)
430
{
431
	char logbuf[512];
432
	struct pptp_ocrq *ocrq;
433
434
	/* check size */
435
	if (lpkt < sizeof(struct pptp_ocrq)) {
436
		pptp_call_log(_this, LOG_ERR, "Received bad OCRQ: packet too "
437
		    "short: %d < %d", lpkt, (int)sizeof(struct pptp_ocrq));
438
		return 1;
439
	}
440
	ocrq = (struct pptp_ocrq *)pkt;
441
442
	/* convert byte-order */
443
	ocrq->call_id = ntohs(ocrq->call_id);
444
	ocrq->call_serial_number = ntohs(ocrq->call_serial_number);
445
	ocrq->recv_winsz = ntohs(ocrq->recv_winsz);
446
	ocrq->packet_proccessing_delay =
447
	    ntohs(ocrq->packet_proccessing_delay);
448
	ocrq->phone_number_length = ntohs(ocrq->phone_number_length);
449
	ocrq->reservied1 = ntohs(ocrq->reservied1);
450
	ocrq->maximum_bps = ntohl(ocrq->maximum_bps);
451
	ocrq->minimum_bps = ntohl(ocrq->minimum_bps);
452
	ocrq->bearer_type = ntohl(ocrq->bearer_type);
453
	ocrq->framing_type = ntohl(ocrq->framing_type);
454
455
	_this->peers_call_id = ocrq->call_id;
456
	_this->peers_maxwinsz = ocrq->recv_winsz;
457
458
	pptp_call_OCRQ_string(ocrq, logbuf, sizeof(logbuf));
459
	pptp_call_log(_this, LOG_INFO, "RecvOCRQ %s", logbuf);
460
461
	return 0;
462
}
463
464
/*
465
 * GRE I/O
466
 */
467
468
/* Reciver packet via GRE */
469
void
470
pptp_call_gre_input(pptp_call *_this, uint32_t seq, uint32_t ack,
471
    int input_flags, u_char *pkt, int pktlen)
472
{
473
	int log_prio;
474
	const char *reason;
475
	int delayed = 0;
476
477
	PPTP_CALL_ASSERT(_this != NULL);
478
479
	log_prio = LOG_INFO;
480
481
#ifdef	PPTP_CALL_DEBUG
482
	if (debuglevel >= 2) {
483
		pptp_call_log(_this, LOG_DEBUG,
484
		    "Received data packet seq=%u(%u-%u) ack=%u(%u-%u)",
485
		    seq, _this->rcv_nxt,
486
		    _this->rcv_nxt + _this->peers_maxwinsz - 1,
487
		    ack, _this->snd_una, _this->snd_nxt);
488
	}
489
#endif
490
	if (_this->state != PPTP_CALL_STATE_ESTABLISHED) {
491
		pptp_call_log(_this, LOG_INFO,
492
		    "Received data packet in illegal state=%s",
493
		    pptp_call_state_string(_this->state));
494
		return;
495
	}
496
	PPTP_CALL_ASSERT(_this->state == PPTP_CALL_STATE_ESTABLISHED);
497
498
	if (input_flags & PPTP_GRE_PKT_ACK_PRESENT) {
499
		if (ack + 1 == _this->snd_una) {
500
			/* nothing to do */
501
		} else if (SEQ_LT(ack, _this->snd_una)) {
502
			delayed = 1;
503
		} else if (SEQ_GT(ack, _this->snd_nxt)) {
504
			reason = "ack for unknown sequence.";
505
			goto bad_pkt;
506
		} else {
507
			ack++;
508
			_this->snd_una = ack;
509
		}
510
	}
511
512
	if ((input_flags & PPTP_GRE_PKT_SEQ_PRESENT) == 0)
513
		return;	/* ack only packet */
514
515
	/* check sequence# */
516
	if (SEQ_LT(seq, _this->rcv_nxt)) {
517
		/* delayed delivery? */
518
		if (SEQ_LT(seq, _this->rcv_nxt - PPTP_CALL_DELAY_LIMIT)) {
519
			reason = "out of sequence";
520
			goto bad_pkt;
521
		}
522
		delayed = 1;
523
	} else if (SEQ_GE(seq, _this->rcv_nxt + _this->maxwinsz)){
524
		/* MUST Process them */
525
		/* XXX FIXME: if over 4096 packets lost, it can not
526
		 * fix MPPE state */
527
		pptp_call_log(_this, LOG_INFO,
528
		    "Received packet caused window overflow.  seq=%u(%u-%u), "
529
		    "may lost %d packets.", seq, _this->rcv_nxt,
530
		    _this->rcv_nxt + _this->maxwinsz - 1,
531
		    SEQ_SUB(seq, _this->rcv_nxt));
532
	}
533
534
	if (!delayed) {
535
		seq++;
536
		/* XXX : TODO: should it counts lost packets  ppp->ierrors
537
		 * and update ppp->ierrors counter? */
538
		_this->rcv_nxt = seq;
539
540
		if (SEQ_SUB(seq, _this->rcv_acked) > RUPDIV(_this->winsz, 2)) {
541
			/*
542
			 * Multi-packet acknowledgement.
543
			 * send ack when it reachs to half of window size
544
			 */
545
			PPTP_CALL_DBG((_this, LOG_DEBUG,
546
			    "rcv window size=%u %u %u\n",
547
			    SEQ_SUB(seq, _this->rcv_acked), seq,
548
			    _this->rcv_acked));
549
			pptp_call_gre_output(_this, 0, 1, NULL, 0);
550
		}
551
	}
552
553
	pptp_call_ppp_input(_this, pkt, pktlen, delayed);
554
555
	return;
556
bad_pkt:
557
	pptp_call_log(_this, log_prio,
558
	    "Received bad data packet: %s: seq=%u(%u-%u) ack=%u(%u-%u)",
559
	    reason, seq, _this->rcv_nxt, _this->rcv_nxt + _this->maxwinsz - 1,
560
	    ack, _this->snd_una, _this->snd_nxt);
561
}
562
563
/* output to GRE */
564
/* flags: fseq: contain SEQ field, fack: contain ACK field */
565
static int
566
pptp_call_gre_output(pptp_call *_this, int fseq, int fack, u_char *pkt,
567
    int lpkt)
568
{
569
	int sz;
570
	struct pptp_gre_header *grehdr;
571
	u_char buf[65535], *opkt;
572
	struct sockaddr_storage peer, sock;
573
#ifndef USE_LIBSOCKUTIL
574
	socklen_t peerlen;
575
#endif
576
577
	memset(buf, 0, sizeof(buf));
578
579
	opkt = buf;
580
	grehdr = (struct pptp_gre_header *)opkt;
581
	opkt += sizeof(struct pptp_gre_header);
582
583
	/* GRE header */
584
	grehdr->K = 1;
585
	grehdr->ver = PPTP_GRE_VERSION;
586
	grehdr->protocol_type = htons(PPTP_GRE_PROTOCOL_TYPE);
587
	grehdr->payload_length = htons(lpkt);
588
	grehdr->call_id = htons(_this->peers_call_id);
589
590
#ifdef	PPTP_CALL_DEBUG
591
	if (debuglevel >= 2 && (fseq || fack)) {
592
		pptp_call_log(_this, LOG_DEBUG,
593
		    "Sending data packet seq=%u ack=%u",
594
		    _this->snd_nxt, _this->rcv_nxt - 1);
595
	}
596
#endif
597
	PPTP_CALL_ASSERT(ALIGNED_POINTER(opkt, uint32_t));
598
	if (fseq) {
599
		grehdr->S = 1;
600
		*(uint32_t *)opkt = htonl(_this->snd_nxt++);
601
		opkt += 4;
602
	}
603
	if (fack) {
604
		grehdr->A = 1;
605
		_this->rcv_acked = _this->rcv_nxt;
606
		*(uint32_t *)opkt = htonl(_this->rcv_nxt - 1);
607
		opkt += 4;
608
	}
609
	if (lpkt > 0) {
610
		memcpy(opkt, pkt, lpkt);
611
		opkt += lpkt;
612
	}
613
	memcpy(&peer, &_this->ctrl->peer, sizeof(peer));
614
	memcpy(&sock, &_this->ctrl->our, sizeof(sock));
615
	switch (peer.ss_family) {
616
	case AF_INET:
617
		((struct sockaddr_in *)&peer)->sin_port = 0;
618
		((struct sockaddr_in *)&sock)->sin_port = 0;
619
#ifndef USE_LIBSOCKUTIL
620
		peerlen = sizeof(struct sockaddr_in);
621
#endif
622
		break;
623
	default:
624
		return 1;
625
	}
626
627
	if (PPTP_CTRL_CONF(_this->ctrl)->data_out_pktdump != 0) {
628
		pptp_call_log(_this, LOG_DEBUG, "PPTP Data output packet dump");
629
		show_hd(debug_get_debugfp(), buf, opkt - buf);
630
	}
631
#ifdef USE_LIBSOCKUTIL
632
	sz = sendfromto(pptp_ctrl_sock_gre(_this->ctrl), buf, opkt - buf,
633
	    0, (struct sockaddr *)&sock, (struct sockaddr *)&peer);
634
#else
635
	sz = sendto(pptp_ctrl_sock_gre(_this->ctrl), buf, opkt - buf, 0,
636
	    (struct sockaddr *)&peer, peerlen);
637
#endif
638
639
	if (sz <= 0)
640
		pptp_call_log(_this, LOG_WARNING, "sendto(%d) failed: %m",
641
		    pptp_ctrl_sock_gre(_this->ctrl));
642
643
	return (sz > 0)? 0 : 1;
644
}
645
646
/*
647
 * npppd physical layer functions
648
 */
649
650
/* notify to ppp that the PPTP physical layer is already downed */
651
static void
652
pptp_call_notify_down(pptp_call *_this)
653
{
654
	if (_this->ppp != NULL)
655
		ppp_phy_downed(_this->ppp);
656
}
657
658
659
/* input packet to ppp */
660
static void
661
pptp_call_ppp_input(pptp_call *_this, u_char *pkt, int pktlen, int delayed)
662
{
663
	int rval;
664
	npppd_ppp *ppp;
665
666
	ppp = _this->ppp;
667
	if (ppp == NULL) {
668
		pptp_call_log(_this, LOG_WARNING,
669
		    "Received ppp frame but ppp is not assigned yet");
670
		return;
671
	}
672
	rval = ppp->recv_packet(ppp, pkt, pktlen, delayed ? PPP_IO_FLAGS_DELAYED : 0);
673
	if (_this->ppp == NULL)		/* ppp is freed */
674
		return;
675
676
	if (rval != 0) {
677
		ppp->ierrors++;
678
	} else {
679
		ppp->ipackets++;
680
		ppp->ibytes += pktlen;
681
	}
682
}
683
684
/* it called when ppp outputs packet */
685
static int
686
pptp_call_ppp_output(npppd_ppp *ppp, unsigned char *bytes, int nbytes,
687
    int flags)
688
{
689
	pptp_call *_this;
690
691
	_this = ppp->phy_context;
692
	PPTP_CALL_ASSERT(_this != NULL);
693
694
	if (_this == NULL)
695
		return 0;
696
697
	if (pptp_call_gre_output(_this, 1, 1, bytes, nbytes) != 0) {
698
		ppp->oerrors++;
699
		return 1;
700
	}
701
	ppp->opackets++;
702
	ppp->obytes += nbytes;
703
704
	return 0;
705
}
706
707
/* it called when pptp call was closed at ppp */
708
static void
709
pptp_call_closed_by_ppp(npppd_ppp *ppp)
710
{
711
	pptp_call *_this;
712
713
	PPTP_CALL_ASSERT(ppp != NULL);
714
	PPTP_CALL_ASSERT(ppp->phy_context != NULL);
715
716
	_this = ppp->phy_context;
717
718
	/* do this before pptp_call_disconnect() */
719
	_this->ppp = NULL;
720
721
	if (_this->state != PPTP_CALL_STATE_CLEANUP_WAIT) {
722
		pptp_call_disconnect(_this, PPTP_CDN_RESULT_LOST_CARRIER, 0,
723
		    NULL);
724
	}
725
	pptp_call_log(_this, LOG_NOTICE, "logtype=PPPUnbind");
726
}
727
728
/* bind() for ppp */
729
static int
730
pptp_call_bind_ppp(pptp_call *_this)
731
{
732
	npppd_ppp *ppp;
733
734
	ppp = NULL;
735
	if ((ppp = ppp_create()) == NULL)
736
		goto fail;
737
738
	PPTP_CALL_ASSERT(_this->ppp == NULL);
739
740
	if (_this->ppp != NULL)
741
		return -1;
742
743
	_this->ppp = ppp;
744
745
	ppp->phy_context = _this;
746
	ppp->tunnel_type = NPPPD_TUNNEL_PPTP;
747
	ppp->tunnel_session_id = _this->id;
748
	ppp->send_packet = pptp_call_ppp_output;
749
	ppp->phy_close = pptp_call_closed_by_ppp;
750
751
	strlcpy(ppp->phy_label, PPTP_CTRL_LISTENER_TUN_NAME(_this->ctrl),
752
	    sizeof(ppp->phy_label));
753
754
	PPTP_CALL_ASSERT(sizeof(ppp->phy_info) >= _this->ctrl->peer.ss_len);
755
	memcpy(&ppp->phy_info, &_this->ctrl->peer,
756
	    MINIMUM(sizeof(ppp->phy_info), _this->ctrl->peer.ss_len));
757
758
	if (ppp_init(npppd_get_npppd(), ppp) != 0)
759
		goto fail;
760
761
	pptp_call_log(_this, LOG_NOTICE, "logtype=PPPBind ppp=%d", ppp->id);
762
	ppp_start(ppp);
763
764
	return 0;
765
fail:
766
	pptp_call_log(_this, LOG_ERR, "failed binding ppp");
767
768
	if (ppp != NULL)
769
		ppp_destroy(ppp);
770
	_this->ppp = NULL;
771
772
	return 1;
773
}
774
775
/*
776
 * utility functions
777
 */
778
779
/* logging with the label for the instance */
780
static void
781
pptp_call_log(pptp_call *_this, int prio, const char *fmt, ...)
782
{
783
	char logbuf[BUFSIZ];
784
	va_list ap;
785
786
	va_start(ap, fmt);
787
#ifdef	PPTPD_MULTIPLE
788
	snprintf(logbuf, sizeof(logbuf), "pptpd id=%u ctrl=%u call=%u %s",
789
	    _this->ctrl->pptpd->id, _this->ctrl->id, _this->id, fmt);
790
#else
791
	snprintf(logbuf, sizeof(logbuf), "pptpd ctrl=%u call=%u %s",
792
	    _this->ctrl->id, _this->id, fmt);
793
#endif
794
	vlog_printf(prio, logbuf, ap);
795
	va_end(ap);
796
}
797
798
/* convert Outgoing-Call-Request packet to strings */
799
static void
800
pptp_call_OCRQ_string(struct pptp_ocrq *ocrq, char *buf, int lbuf)
801
{
802
	snprintf(buf, lbuf,
803
	    "call_id=%u call_serial_number=%u max_bps=%u min_bps=%u bearer=%s "
804
	    "framing=%s recv_winsz=%u packet_proccessing_delay=%u "
805
	    "phone_nunmber=%s subaddress=%s",
806
	    ocrq->call_id, ocrq->call_serial_number, ocrq->maximum_bps,
807
	    ocrq->minimum_bps, pptp_bearer_string(ocrq->bearer_type),
808
	    pptp_framing_string(ocrq->framing_type), ocrq->recv_winsz,
809
	    ocrq->packet_proccessing_delay, ocrq->phone_number,
810
	    ocrq->subaddress);
811
}
812
813
/* convert Outgoing-Call-Reply packet to strings */
814
void
815
pptp_call_OCRP_string(struct pptp_ocrp *ocrp, char *buf, int lbuf)
816
{
817
	snprintf(buf, lbuf,
818
	    "call_id=%u peers_call_id=%u result=%u error=%u cause=%u "
819
	    "conn_speed=%u recv_winsz=%u packet_proccessing_delay=%u "
820
	    "physical_channel_id=%u",
821
	    ocrp->call_id, ocrp->peers_call_id, ocrp->result_code,
822
	    ocrp->error_code, ocrp->cause_code, ocrp->connect_speed,
823
	    ocrp->recv_winsz, ocrp->packet_proccessing_delay,
824
	    ocrp->physical_channel_id);
825
}
826
827
static char *
828
pptp_call_state_string(int state)
829
{
830
	switch (state) {
831
	case PPTP_CALL_STATE_IDLE:
832
		return "idle";
833
	case PPTP_CALL_STATE_WAIT_CONN:
834
		return "wait-conn";
835
	case PPTP_CALL_STATE_ESTABLISHED:
836
		return "established";
837
	case PPTP_CALL_STATE_CLEANUP_WAIT:
838
		return "cleanup-wait";
839
	}
840
	return "unknown";
841
}
842