/*      $OpenBSD: pptp_call.c,v 1.12 2021/03/29 03:54:40 yasuoka Exp $  */

/*-
 * Copyright (c) 2009 Internet Initiative Japan Inc.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
/* $Id: pptp_call.c,v 1.12 2021/03/29 03:54:40 yasuoka Exp $ */
/**@file PPTP Call */
/* currently it supports PAC mode only */
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <netinet/in.h>
#include <net/if_dl.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <syslog.h>
#include <event.h>

#ifdef USE_LIBSOCKUTIL
#include <seil/sockfromto.h>
#endif

#include "bytebuf.h"
#include "slist.h"
#include "hash.h"
#include "debugutil.h"
#include "time_utils.h"

#include "pptp.h"
#include "pptp_local.h"
#include "pptp_subr.h"

#include "npppd.h"

#ifdef PPTP_CALL_DEBUG
#define PPTP_CALL_DBG(x)        pptp_call_log x
#define PPTP_CALL_ASSERT(x)     ASSERT(x)
#else
#define PPTP_CALL_DBG(x)
#define PPTP_CALL_ASSERT(x)
#endif

static void  pptp_call_log (pptp_call *, int, const char *, ...) __printflike(3,4);


static void  pptp_call_notify_down (pptp_call *);
static int   pptp_call_recv_SLI (pptp_call *, u_char *, int);
static int   pptp_call_recv_CCR (pptp_call *, u_char *, int);
static int   pptp_call_recv_OCRQ (pptp_call *, u_char *, int);
static void  pptp_call_send_CDN (pptp_call *, int, int, int, const char *);
static int   pptp_call_send_OCRP (pptp_call *, int, int, int);
static int   pptp_call_gre_output (pptp_call *, int, int, u_char *, int);
static int   pptp_call_bind_ppp (pptp_call *);
static void  pptp_call_log (pptp_call *, int, const char *, ...);
static void  pptp_call_OCRQ_string (struct pptp_ocrq *, char *, int);
static void  pptp_call_OCRP_string (struct pptp_ocrp *, char *, int);
static void   pptp_call_ppp_input (pptp_call *, unsigned char *, int, int);
static char * pptp_call_state_string(int);

static int   pptp_call_ppp_output (npppd_ppp *, unsigned char *, int, int);
static void  pptp_call_closed_by_ppp (npppd_ppp *);

/* not used
static int   pptp_call_send_SLI (pptp_call *);
 */

#define SEQ_LT(a,b)     ((int)((a) - (b)) <  0)
#define SEQ_LE(a,b)     ((int)((a) - (b)) <= 0)
#define SEQ_GT(a,b)     ((int)((a) - (b)) >  0)
#define SEQ_GE(a,b)     ((int)((a) - (b)) >= 0)
#define SEQ_SUB(a,b)    ((int32_t)((a) - (b)))

/* round-up division */
#define RUPDIV(n,d)     (((n) + ((d) - ((n) % (d)))) / (d))

/*
 * instance related functions
 */
pptp_call *
pptp_call_create(void)
{
        pptp_call *_this;

        if ((_this = malloc(sizeof(pptp_call))) == NULL)
                return NULL;

        return _this;
}

int
pptp_call_init(pptp_call *_this, pptp_ctrl *ctrl)
{
        memset(_this, 0, sizeof(pptp_call));
        _this->ctrl = ctrl;

        _this->maxwinsz = PPTP_CALL_DEFAULT_MAXWINSZ;
        _this->winsz = RUPDIV(_this->maxwinsz, 2);
        _this->last_io = get_monosec();
        _this->snd_nxt = 1;

        return 0;
}

int
pptp_call_start(pptp_call *_this)
{
        if (pptp_call_bind_ppp(_this) != 0)
                return 1;

        return 0;
}

int
pptp_call_stop(pptp_call *_this)
{
        if (_this->state != PPTP_CALL_STATE_CLEANUP_WAIT)
                pptp_call_disconnect(_this, 0, 0, NULL);

        pptp_call_log(_this, LOG_NOTICE, "logtype=Terminated");
        pptpd_release_call(_this->ctrl->pptpd, _this);

        return 0;
}

void
pptp_call_destroy(pptp_call *_this)
{
        PPTP_CALL_ASSERT(_this != NULL);
        free(_this);
}

void
pptp_call_disconnect(pptp_call *_this, int result, int error, const char *
    statistics)
{
        if (_this->state == PPTP_CALL_STATE_CLEANUP_WAIT) {
                pptp_call_notify_down(_this);
                return;
        }
        if (result > 0)
                pptp_call_send_CDN(_this, result, error, 0, statistics);
        _this->state = PPTP_CALL_STATE_CLEANUP_WAIT;
        pptp_call_notify_down(_this);
}

/*
 * PPTP control packet I/O
 */

void
pptp_call_input(pptp_call *_this, int mes_type, u_char *pkt, int lpkt)
{

        PPTP_CALL_ASSERT(_this != NULL);
        PPTP_CALL_ASSERT(pkt != NULL);
        PPTP_CALL_ASSERT(lpkt >= 4);

        _this->last_io = get_monosec();
        switch (mes_type) {
        case PPTP_CTRL_MES_CODE_OCRQ:
                if (_this->state != PPTP_CALL_STATE_IDLE) {
                        pptp_call_send_OCRP(_this,
                            PPTP_OCRP_RESULT_GENERIC_ERROR,
                            PPTP_ERROR_BAD_CALL, 0);
                        goto bad_state;
                }
                if (pptp_call_recv_OCRQ(_this, pkt, lpkt) != 0) {
                        pptp_call_send_OCRP(_this,
                            PPTP_OCRP_RESULT_GENERIC_ERROR,
                            PPTP_ERROR_BAD_CALL, 0);
                        return;
                }
                if (pptpd_assign_call(_this->ctrl->pptpd, _this) != 0) {
                        pptp_call_send_OCRP(_this, PPTP_OCRP_RESULT_BUSY,
                            PPTP_ERROR_NONE, 0);
                        return;
                }
                if (pptp_call_send_OCRP(_this, PPTP_OCRP_RESULT_CONNECTED,
                    PPTP_ERROR_NONE, 0) != 0) {
                        pptp_call_disconnect(_this,
                            PPTP_CDN_RESULT_GENRIC_ERROR,
                            PPTP_ERROR_PAC_ERROR, NULL);
                        return;
                }
                if (pptp_call_start(_this) != 0) {
                        pptp_call_disconnect(_this,
                            PPTP_CDN_RESULT_GENRIC_ERROR,
                            PPTP_ERROR_PAC_ERROR, NULL);
                        return;
                }
                _this->state = PPTP_CALL_STATE_ESTABLISHED;
                break;
        case PPTP_CTRL_MES_CODE_SLI:
                if (pptp_call_recv_SLI(_this, pkt, lpkt) != 0) {
                        return;
                }
                return;
        case PPTP_CTRL_MES_CODE_CCR:
                pptp_call_recv_CCR(_this, pkt, lpkt);
                if (_this->state == PPTP_CALL_STATE_ESTABLISHED) {
                        pptp_call_disconnect(_this, PPTP_CDN_RESULT_REQUEST,
                            PPTP_ERROR_NONE, NULL);
                } else {
                        pptp_call_disconnect(_this, 0, 0, NULL);
                        if (_this->state != PPTP_CALL_STATE_CLEANUP_WAIT)
                                goto bad_state;
                }
                return;
        default:
            pptp_call_log(_this, LOG_WARNING,
                "Unhandled control message type=%s(%d)",
                    pptp_ctrl_mes_type_string(mes_type), mes_type);
        }
        return;
bad_state:
        pptp_call_log(_this, LOG_WARNING,
            "Received control message %s(%d) in bad state=%s",
                pptp_ctrl_mes_type_string(mes_type), mes_type,
                pptp_call_state_string(_this->state));
}

/* receive Set-Link-Info */
/* XXX: this implementation is only supporting "Sync-Frame",
 * ACCM (Asynchronous Control Character Map) will be discarded */
static int
pptp_call_recv_SLI(pptp_call *_this, u_char *pkt, int lpkt)
{
        struct pptp_sli *sli;

        if (lpkt < sizeof(struct pptp_sli)) {
                pptp_call_log(_this, LOG_ERR, "Received bad SLI: packet too "
                    "short: %d < %d", lpkt, (int)sizeof(struct pptp_sli));
                return 1;
        }
        sli = (struct pptp_sli *)pkt;
        sli->send_accm = ntohl(sli->send_accm);
        sli->recv_accm = ntohl(sli->recv_accm);
        if (sli->send_accm != 0xffffffffL ||
            sli->recv_accm != 0xffffffffL) {
                pptp_call_log(_this, LOG_WARNING,
                    "RecvSLI Received bad ACCM %08x:%08x: asynchronous framing "
                    "is not supported.\n", sli->send_accm, sli->recv_accm);
                return 1;
        }
        pptp_call_log(_this, LOG_INFO, "RecvSLI accm=%08x:%08x",
            sli->send_accm, sli->recv_accm);

        return 0;
}

#if 0
/* Some route implementation which has "PPTP pass-through" function
 * will discard 1723/tcp packet between PAC and PNS, when it recognize
 * SLI from PAC. (for example, FLASHWAVE by Fujitsu).
 *
 * To avoid avobe situation, npppd send well-known SLI only.
 */
static int
pptp_call_send_SLI(pptp_call *_this)
{
        int lpkt;
        struct pptp_sli *sli;

        sli = bytebuffer_pointer(_this->ctrl->send_buf);
        lpkt = bytebuffer_remaining(_this->ctrl->send_buf);
        if (lpkt < sizeof(struct pptp_sli)) {
                pptp_call_log(_this, LOG_ERR,
                    "SendOCRP failed: No buffer space available");
                return -1;
        }
        memset(sli, 0, sizeof(struct pptp_sli));

        pptp_init_header(&sli->header, sizeof(struct pptp_sli),
            PPTP_CTRL_MES_CODE_SLI);

        sli->peers_call_id = _this->id;
        sli->send_accm = 0xffffffff;
        sli->recv_accm = 0xffffffff;

        _this->last_io = get_monosec();
        pptp_call_log(_this, LOG_INFO, "SendSLI accm=%08x:%08x",
            sli->send_accm, sli->recv_accm);
        sli->peers_call_id = htons(sli->peers_call_id);
        sli->send_accm = htonl(sli->send_accm);
        sli->recv_accm = htonl(sli->recv_accm);
        pptp_ctrl_output(_this->ctrl, NULL,  sizeof(struct pptp_sli));

        return 0;
}
#endif

/* Receive Call-Clear-Request */
static int
pptp_call_recv_CCR(pptp_call *_this, u_char *pkt, int lpkt)
{
        struct pptp_ccr *ccr;

        /* check size */
        PPTP_CALL_ASSERT(lpkt >= sizeof(struct pptp_ccr));
        if (lpkt < sizeof(struct pptp_ccr)) {
                /* never happen, should KASSERT() here? */
                return 1;
        }
        ccr = (struct pptp_ccr *)pkt;

        /* convert byte-order */
        ccr->call_id = ntohs(ccr->call_id);
        pptp_call_log(_this, LOG_INFO, "RecvCCR call_id=%u", ccr->call_id);

        return 0;
}

/* Send Call-Disconnect-Notify */
static void
pptp_call_send_CDN(pptp_call *_this, int result, int error, int cause,
    const char *statistics)
{
        int lpkt;
        struct pptp_cdn *cdn;

        cdn = bytebuffer_pointer(_this->ctrl->send_buf);
        lpkt = bytebuffer_remaining(_this->ctrl->send_buf);
        if (lpkt < sizeof(struct pptp_cdn)) {
                pptp_call_log(_this, LOG_ERR,
                    "SendCCR failed: No buffer space available");
                return;
        }
        memset(cdn, 0, sizeof(struct pptp_cdn));

        pptp_init_header(&cdn->header, sizeof(struct pptp_cdn),
            PPTP_CTRL_MES_CODE_CDN);

        cdn->call_id = _this->id;
        cdn->result_code = result;
        cdn->error_code = error;
        cdn->cause_code = cause;
        if (statistics != NULL)
                strlcpy(cdn->statistics, statistics, sizeof(cdn->statistics));

        pptp_call_log(_this, LOG_INFO, "SendCDN "
            "call_id=%u result=%s(%d) error=%s(%d) cause=%d statistics=%s",
            cdn->call_id,
            pptp_CDN_result_string(cdn->result_code), cdn->result_code,
            pptp_general_error_string(cdn->error_code), cdn->error_code,
            cdn->cause_code,
                (statistics == NULL)? "(none)" : (char *)cdn->statistics);

        cdn->call_id = htons(cdn->call_id);
        cdn->cause_code = htons(cdn->cause_code);

        _this->last_io = get_monosec();
        pptp_ctrl_output(_this->ctrl, NULL, sizeof(struct pptp_cdn));
}

/* Send Outgoing-Call-Reply */
static int
pptp_call_send_OCRP(pptp_call *_this, int result, int error, int cause)
{
        int lpkt;
        struct pptp_ocrp *ocrp;
        char logbuf[512];

        ocrp = bytebuffer_pointer(_this->ctrl->send_buf);
        lpkt = bytebuffer_remaining(_this->ctrl->send_buf);
        if (lpkt < sizeof(struct pptp_ocrp)) {
                pptp_call_log(_this, LOG_ERR,
                    "SendOCRP failed: No buffer space available");
                return -1;
        }
        memset(ocrp, 0, sizeof(struct pptp_ocrp));

        pptp_init_header(&ocrp->header, sizeof(struct pptp_ocrp),
            PPTP_CTRL_MES_CODE_OCRP);

        ocrp->call_id = _this->id;
        ocrp->peers_call_id = _this->peers_call_id;
        ocrp->result_code = result;
        ocrp->error_code = error;
        ocrp->cause_code = cause;
        ocrp->connect_speed = PPTP_CALL_CONNECT_SPEED;
        ocrp->recv_winsz =  _this->maxwinsz;
        ocrp->packet_proccessing_delay = PPTP_CALL_INITIAL_PPD;
        ocrp->physical_channel_id = _this->id;

        pptp_call_OCRP_string(ocrp, logbuf, sizeof(logbuf));
        pptp_call_log(_this, LOG_INFO, "SendOCRP %s", logbuf);

        ocrp->call_id = htons(ocrp->call_id);
        ocrp->peers_call_id = htons(ocrp->peers_call_id);
        ocrp->cause_code = htons(ocrp->cause_code);
        ocrp->connect_speed = htons(ocrp->connect_speed);
        ocrp->recv_winsz = htons(ocrp->recv_winsz);
        ocrp->packet_proccessing_delay = htons(ocrp->packet_proccessing_delay);
        ocrp->physical_channel_id = htonl(ocrp->physical_channel_id);

        _this->last_io = get_monosec();
        pptp_ctrl_output(_this->ctrl, NULL,  sizeof(struct pptp_ocrp));

        return 0;
}

/* Receive Outgoing-Call-Request */
static int
pptp_call_recv_OCRQ(pptp_call *_this, u_char *pkt, int lpkt)
{
        char logbuf[512];
        struct pptp_ocrq *ocrq;

        /* check size */
        if (lpkt < sizeof(struct pptp_ocrq)) {
                pptp_call_log(_this, LOG_ERR, "Received bad OCRQ: packet too "
                    "short: %d < %d", lpkt, (int)sizeof(struct pptp_ocrq));
                return 1;
        }
        ocrq = (struct pptp_ocrq *)pkt;

        /* convert byte-order */
        ocrq->call_id = ntohs(ocrq->call_id);
        ocrq->call_serial_number = ntohs(ocrq->call_serial_number);
        ocrq->recv_winsz = ntohs(ocrq->recv_winsz);
        ocrq->packet_proccessing_delay =
            ntohs(ocrq->packet_proccessing_delay);
        ocrq->phone_number_length = ntohs(ocrq->phone_number_length);
        ocrq->reservied1 = ntohs(ocrq->reservied1);
        ocrq->maximum_bps = ntohl(ocrq->maximum_bps);
        ocrq->minimum_bps = ntohl(ocrq->minimum_bps);
        ocrq->bearer_type = ntohl(ocrq->bearer_type);
        ocrq->framing_type = ntohl(ocrq->framing_type);

        _this->peers_call_id = ocrq->call_id;
        _this->peers_maxwinsz = ocrq->recv_winsz;

        pptp_call_OCRQ_string(ocrq, logbuf, sizeof(logbuf));
        pptp_call_log(_this, LOG_INFO, "RecvOCRQ %s", logbuf);

        return 0;
}

/*
 * GRE I/O
 */

/* Reciver packet via GRE */
void
pptp_call_gre_input(pptp_call *_this, uint32_t seq, uint32_t ack,
    int input_flags, u_char *pkt, int pktlen)
{
        int log_prio;
        const char *reason;
        int delayed = 0;

        PPTP_CALL_ASSERT(_this != NULL);

        log_prio = LOG_INFO;

#ifdef  PPTP_CALL_DEBUG
        if (debuglevel >= 2) {
                pptp_call_log(_this, LOG_DEBUG,
                    "Received data packet seq=%u(%u-%u) ack=%u(%u-%u)",
                    seq, _this->rcv_nxt,
                    _this->rcv_nxt + _this->peers_maxwinsz - 1,
                    ack, _this->snd_una, _this->snd_nxt);
        }
#endif
        if (_this->state != PPTP_CALL_STATE_ESTABLISHED) {
                pptp_call_log(_this, LOG_INFO,
                    "Received data packet in illegal state=%s",
                    pptp_call_state_string(_this->state));
                return;
        }
        PPTP_CALL_ASSERT(_this->state == PPTP_CALL_STATE_ESTABLISHED);

        if (input_flags & PPTP_GRE_PKT_ACK_PRESENT) {
                if (ack + 1 == _this->snd_una) {
                        /* nothing to do */
                } else if (SEQ_LT(ack, _this->snd_una)) {
                        delayed = 1;
                } else if (SEQ_GT(ack, _this->snd_nxt)) {
                        reason = "ack for unknown sequence.";
                        goto bad_pkt;
                } else {
                        ack++;
                        _this->snd_una = ack;
                }
        }

        if ((input_flags & PPTP_GRE_PKT_SEQ_PRESENT) == 0)
                return; /* ack only packet */

        /* check sequence# */
        if (SEQ_LT(seq, _this->rcv_nxt)) {
                /* delayed delivery? */
                if (SEQ_LT(seq, _this->rcv_nxt - PPTP_CALL_DELAY_LIMIT)) {
                        reason = "out of sequence";
                        goto bad_pkt;
                }
                delayed = 1;
        } else if (SEQ_GE(seq, _this->rcv_nxt + _this->maxwinsz)){
                /* MUST Process them */
                /* XXX FIXME: if over 4096 packets lost, it can not
                 * fix MPPE state */
                pptp_call_log(_this, LOG_INFO,
                    "Received packet caused window overflow.  seq=%u(%u-%u), "
                    "may lost %d packets.", seq, _this->rcv_nxt,
                    _this->rcv_nxt + _this->maxwinsz - 1,
                    SEQ_SUB(seq, _this->rcv_nxt));
        }

        if (!delayed) {
                seq++;
                /* XXX : TODO: should it counts lost packets  ppp->ierrors
                 * and update ppp->ierrors counter? */
                _this->rcv_nxt = seq;

                if (SEQ_SUB(seq, _this->rcv_acked) > RUPDIV(_this->winsz, 2)) {
                        /*
                         * Multi-packet acknowledgement.
                         * send ack when it reaches to half of window size
                         */
                        PPTP_CALL_DBG((_this, LOG_DEBUG,
                            "rcv window size=%u %u %u\n",
                            SEQ_SUB(seq, _this->rcv_acked), seq,
                            _this->rcv_acked));
                        pptp_call_gre_output(_this, 0, 1, NULL, 0);
                }
        }

        pptp_call_ppp_input(_this, pkt, pktlen, delayed);

        return;
bad_pkt:
        pptp_call_log(_this, log_prio,
            "Received bad data packet: %s: seq=%u(%u-%u) ack=%u(%u-%u)",
            reason, seq, _this->rcv_nxt, _this->rcv_nxt + _this->maxwinsz - 1,
            ack, _this->snd_una, _this->snd_nxt);
}

/* output to GRE */
/* flags: fseq: contain SEQ field, fack: contain ACK field */
static int
pptp_call_gre_output(pptp_call *_this, int fseq, int fack, u_char *pkt,
    int lpkt)
{
        int sz;
        struct pptp_gre_header *grehdr;
        u_char buf[65535], *opkt;
        struct sockaddr_storage peer, sock;
#ifndef USE_LIBSOCKUTIL
        socklen_t peerlen;
#endif

        memset(buf, 0, sizeof(buf));

        opkt = buf;
        grehdr = (struct pptp_gre_header *)opkt;
        opkt += sizeof(struct pptp_gre_header);

        /* GRE header */
        grehdr->K = 1;
        grehdr->ver = PPTP_GRE_VERSION;
        grehdr->protocol_type = htons(PPTP_GRE_PROTOCOL_TYPE);
        grehdr->payload_length = htons(lpkt);
        grehdr->call_id = htons(_this->peers_call_id);

#ifdef  PPTP_CALL_DEBUG
        if (debuglevel >= 2 && (fseq || fack)) {
                pptp_call_log(_this, LOG_DEBUG,
                    "Sending data packet seq=%u ack=%u",
                    _this->snd_nxt, _this->rcv_nxt - 1);
        }
#endif
        PPTP_CALL_ASSERT(ALIGNED_POINTER(opkt, uint32_t));
        if (fseq) {
                grehdr->S = 1;
                *(uint32_t *)opkt = htonl(_this->snd_nxt++);
                opkt += 4;
        }
        if (fack) {
                grehdr->A = 1;
                _this->rcv_acked = _this->rcv_nxt;
                *(uint32_t *)opkt = htonl(_this->rcv_nxt - 1);
                opkt += 4;
        }
        if (lpkt > 0) {
                memcpy(opkt, pkt, lpkt);
                opkt += lpkt;
        }
        memcpy(&peer, &_this->ctrl->peer, sizeof(peer));
        memcpy(&sock, &_this->ctrl->our, sizeof(sock));
        switch (peer.ss_family) {
        case AF_INET:
                ((struct sockaddr_in *)&peer)->sin_port = 0;
                ((struct sockaddr_in *)&sock)->sin_port = 0;
#ifndef USE_LIBSOCKUTIL
                peerlen = sizeof(struct sockaddr_in);
#endif
                break;
        default:
                return 1;
        }

        if (PPTP_CTRL_CONF(_this->ctrl)->data_out_pktdump != 0) {
                pptp_call_log(_this, LOG_DEBUG, "PPTP Data output packet dump");
                show_hd(debug_get_debugfp(), buf, opkt - buf);
        }
#ifdef USE_LIBSOCKUTIL
        sz = sendfromto(pptp_ctrl_sock_gre(_this->ctrl), buf, opkt - buf,
            0, (struct sockaddr *)&sock, (struct sockaddr *)&peer);
#else
        sz = sendto(pptp_ctrl_sock_gre(_this->ctrl), buf, opkt - buf, 0,
            (struct sockaddr *)&peer, peerlen);
#endif

        if (sz <= 0)
                pptp_call_log(_this, LOG_WARNING, "sendto(%d) failed: %m",
                    pptp_ctrl_sock_gre(_this->ctrl));

        return (sz > 0)? 0 : 1;
}

/*
 * npppd physical layer functions
 */

/* notify to ppp that the PPTP physical layer is already downed */
static void
pptp_call_notify_down(pptp_call *_this)
{
        if (_this->ppp != NULL)
                ppp_phy_downed(_this->ppp);
}


/* input packet to ppp */
static void
pptp_call_ppp_input(pptp_call *_this, u_char *pkt, int pktlen, int delayed)
{
        int rval;
        npppd_ppp *ppp;

        ppp = _this->ppp;
        if (ppp == NULL) {
                pptp_call_log(_this, LOG_WARNING,
                    "Received ppp frame but ppp is not assigned yet");
                return;
        }
        rval = ppp->recv_packet(ppp, pkt, pktlen, delayed ? PPP_IO_FLAGS_DELAYED : 0);
        if (_this->ppp == NULL)         /* ppp is freed */
                return;

        if (rval != 0) {
                ppp->ierrors++;
        } else {
                ppp->ipackets++;
                ppp->ibytes += pktlen;
        }
}

/* it called when ppp outputs packet */
static int
pptp_call_ppp_output(npppd_ppp *ppp, unsigned char *bytes, int nbytes,
    int flags)
{
        pptp_call *_this;

        _this = ppp->phy_context;
        PPTP_CALL_ASSERT(_this != NULL);

        if (_this == NULL)
                return 0;

        if (pptp_call_gre_output(_this, 1, 1, bytes, nbytes) != 0) {
                ppp->oerrors++;
                return 1;
        }
        ppp->opackets++;
        ppp->obytes += nbytes;

        return 0;
}

/* it called when pptp call was closed at ppp */
static void
pptp_call_closed_by_ppp(npppd_ppp *ppp)
{
        pptp_call *_this;

        PPTP_CALL_ASSERT(ppp != NULL);
        PPTP_CALL_ASSERT(ppp->phy_context != NULL);

        _this = ppp->phy_context;

        /* do this before pptp_call_disconnect() */
        _this->ppp = NULL;

        if (_this->state != PPTP_CALL_STATE_CLEANUP_WAIT) {
                pptp_call_disconnect(_this, PPTP_CDN_RESULT_LOST_CARRIER, 0,
                    NULL);
        }
        pptp_call_log(_this, LOG_NOTICE, "logtype=PPPUnbind");
}

/* bind() for ppp */
static int
pptp_call_bind_ppp(pptp_call *_this)
{
        npppd_ppp *ppp;

        ppp = NULL;
        if ((ppp = ppp_create()) == NULL)
                goto fail;

        PPTP_CALL_ASSERT(_this->ppp == NULL);

        if (_this->ppp != NULL)
                return -1;

        _this->ppp = ppp;

        ppp->phy_context = _this;
        ppp->tunnel_type = NPPPD_TUNNEL_PPTP;
        ppp->tunnel_session_id = _this->id;
        ppp->send_packet = pptp_call_ppp_output;
        ppp->phy_close = pptp_call_closed_by_ppp;

        strlcpy(ppp->phy_label, PPTP_CTRL_LISTENER_TUN_NAME(_this->ctrl),
            sizeof(ppp->phy_label));

        PPTP_CALL_ASSERT(sizeof(ppp->phy_info) >= _this->ctrl->peer.ss_len);
        memcpy(&ppp->phy_info, &_this->ctrl->peer,
            MINIMUM(sizeof(ppp->phy_info), _this->ctrl->peer.ss_len));

        if (ppp_init(npppd_get_npppd(), ppp) != 0)
                goto fail;

        pptp_call_log(_this, LOG_NOTICE, "logtype=PPPBind ppp=%d", ppp->id);
        ppp_start(ppp);

        return 0;
fail:
        pptp_call_log(_this, LOG_ERR, "failed binding ppp");

        if (ppp != NULL)
                ppp_destroy(ppp);
        _this->ppp = NULL;

        return 1;
}

/*
 * utility functions
 */

/* logging with the label for the instance */
static void
pptp_call_log(pptp_call *_this, int prio, const char *fmt, ...)
{
        char logbuf[BUFSIZ];
        va_list ap;

        va_start(ap, fmt);
#ifdef  PPTPD_MULTIPLE
        snprintf(logbuf, sizeof(logbuf), "pptpd id=%u ctrl=%u call=%u %s",
            _this->ctrl->pptpd->id, _this->ctrl->id, _this->id, fmt);
#else
        snprintf(logbuf, sizeof(logbuf), "pptpd ctrl=%u call=%u %s",
            _this->ctrl->id, _this->id, fmt);
#endif
        vlog_printf(prio, logbuf, ap);
        va_end(ap);
}

/* convert Outgoing-Call-Request packet to strings */
static void
pptp_call_OCRQ_string(struct pptp_ocrq *ocrq, char *buf, int lbuf)
{
        snprintf(buf, lbuf,
            "call_id=%u call_serial_number=%u max_bps=%u min_bps=%u bearer=%s "
            "framing=%s recv_winsz=%u packet_proccessing_delay=%u "
            "phone_number=%.*s subaddress=%.*s",
            ocrq->call_id, ocrq->call_serial_number, ocrq->maximum_bps,
            ocrq->minimum_bps, pptp_bearer_string(ocrq->bearer_type),
            pptp_framing_string(ocrq->framing_type), ocrq->recv_winsz,
            ocrq->packet_proccessing_delay,
            (u_int)sizeof(ocrq->phone_number), ocrq->phone_number,
            (u_int)sizeof(ocrq->subaddress), ocrq->subaddress);
}

/* convert Outgoing-Call-Reply packet to strings */
void
pptp_call_OCRP_string(struct pptp_ocrp *ocrp, char *buf, int lbuf)
{
        snprintf(buf, lbuf,
            "call_id=%u peers_call_id=%u result=%u error=%u cause=%u "
            "conn_speed=%u recv_winsz=%u packet_proccessing_delay=%u "
            "physical_channel_id=%u",
            ocrp->call_id, ocrp->peers_call_id, ocrp->result_code,
            ocrp->error_code, ocrp->cause_code, ocrp->connect_speed,
            ocrp->recv_winsz, ocrp->packet_proccessing_delay,
            ocrp->physical_channel_id);
}

static char *
pptp_call_state_string(int state)
{
        switch (state) {
        case PPTP_CALL_STATE_IDLE:
                return "idle";
        case PPTP_CALL_STATE_WAIT_CONN:
                return "wait-conn";
        case PPTP_CALL_STATE_ESTABLISHED:
                return "established";
        case PPTP_CALL_STATE_CLEANUP_WAIT:
                return "cleanup-wait";
        }
        return "unknown";
}