/*
 * SpanDSP - a series of DSP components for telephony
 *
 * v42.c
 *
 * Written by Steve Underwood <steveu@coppice.org>
 *
 * Copyright (C) 2004 Steve Underwood
 *
 * All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 2.1,
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * $Id: v42.c,v 1.51 2009/11/04 15:52:06 steveu Exp $
 */

/* THIS IS A WORK IN PROGRESS. IT IS NOT FINISHED. */

/*! \file */

#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif

#include <stdio.h>
#include <stdlib.h>
#include <inttypes.h>
#include <string.h>
#include <errno.h>

#include "spandsp/telephony.h"
#include "spandsp/logging.h"
#include "spandsp/async.h"
#include "spandsp/hdlc.h"
#include "spandsp/schedule.h"
#include "spandsp/queue.h"
#include "spandsp/v42.h"

#include "spandsp/private/logging.h"
#include "spandsp/private/schedule.h"
#include "spandsp/private/hdlc.h"
#include "spandsp/private/v42.h"

#if !defined(FALSE)
#define FALSE   0
#endif
#if !defined(TRUE)
#define TRUE    (!FALSE)
#endif

#define LAPM_FRAMETYPE_MASK         0x03

#define LAPM_FRAMETYPE_I            0x00
#define LAPM_FRAMETYPE_I_ALT        0x02
#define LAPM_FRAMETYPE_S            0x01
#define LAPM_FRAMETYPE_U            0x03

/* Timer values */

#define T_WAIT_MIN                  2000
#define T_WAIT_MAX                  10000
/* Detection phase timer */
#define T_400                       750000
/* Acknowledgement timer - 1 second between SABME's */
#define T_401                       1000000
/* Replay delay timer (optional) */
#define T_402                       1000000
/* Inactivity timer (optional). No default - use 10 seconds with no packets */
#define T_403                       10000000
/* Max retries */
#define N_400                       3
/* Max octets in an information field */
#define N_401                       128

#define LAPM_DLCI_DTE_TO_DTE        0
#define LAPM_DLCI_LAYER2_MANAGEMENT 63

static void t401_expired(span_sched_state_t *s, void *user_data);
static void t403_expired(span_sched_state_t *s, void *user_data);

SPAN_DECLARE(void) lapm_reset(lapm_state_t *s);
SPAN_DECLARE(void) lapm_restart(lapm_state_t *s);

static void lapm_link_down(lapm_state_t *s);

static __inline__ void lapm_init_header(uint8_t *frame, int command)
{
    /* Data link connection identifier (0) */
    /* Command/response (0 if answerer, 1 if originator) */
    /* Extended address (1) */
    frame[0] = (LAPM_DLCI_DTE_TO_DTE << 2) | ((command)  ?  0x02  :  0x00) | 0x01;
}
/*- End of function --------------------------------------------------------*/

static int lapm_tx_frame(lapm_state_t *s, uint8_t *frame, int len)
{
    if ((s->debug & LAPM_DEBUG_LAPM_DUMP))
        lapm_dump(s, frame, len, s->debug & LAPM_DEBUG_LAPM_RAW, TRUE);
    /*endif*/
    hdlc_tx_frame(&s->hdlc_tx, frame, len);
    return 0;
}
/*- End of function --------------------------------------------------------*/

static void t400_expired(span_sched_state_t *ss, void *user_data)
{
    v42_state_t *s;
    
    /* Give up trying to detect a V.42 capable peer. */
    s = (v42_state_t *) user_data;
    s->t400_timer = -1;
    s->lapm.state = LAPM_UNSUPPORTED;
    if (s->lapm.status_callback)
        s->lapm.status_callback(s->lapm.status_callback_user_data, s->lapm.state);
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

static void lapm_send_ua(lapm_state_t *s, int pfbit)
{
    uint8_t frame[3];

    lapm_init_header(frame, !s->we_are_originator);
    frame[1] = (uint8_t) (0x63 | (pfbit << 4));
    frame[2] = 0;
    span_log(&s->logging, SPAN_LOG_FLOW, "Sending unnumbered acknowledgement\n");
    lapm_tx_frame(s, frame, 3);
}
/*- End of function --------------------------------------------------------*/

static void lapm_send_sabme(span_sched_state_t *ss, void *user_data)
{
    lapm_state_t *s;
    uint8_t frame[3];

    s = (lapm_state_t *) user_data;
    if (s->t401_timer >= 0)
    {
fprintf(stderr, "Deleting T401 q [%p] %d\n", (void *) s, s->t401_timer);
        span_schedule_del(&s->sched, s->t401_timer);
        s->t401_timer = -1;
    }
    /*endif*/
    if (++s->retransmissions > N_400)
    {
        /* 8.3.2.2 Too many retries */
        s->state = LAPM_RELEASE;
        if (s->status_callback)
            s->status_callback(s->status_callback_user_data, s->state);
        /*endif*/
        return;
    }
    /*endif*/
fprintf(stderr, "Setting T401 a1 [%p]\n", (void *) s);
    s->t401_timer = span_schedule_event(&s->sched, T_401, lapm_send_sabme, s);
    lapm_init_header(frame, s->we_are_originator);
    frame[1] = 0x7F;
    frame[2] = 0;
    span_log(&s->logging, SPAN_LOG_FLOW, "Sending SABME (set asynchronous balanced mode extended)\n");
    lapm_tx_frame(s, frame, 3);
}
/*- End of function --------------------------------------------------------*/

static int lapm_ack_packet(lapm_state_t *s, int num)
{
    lapm_frame_queue_t *f;
    lapm_frame_queue_t *prev;

    for (prev = NULL, f = s->txqueue;  f;  prev = f, f = f->next)
    {
        if ((f->frame[1] >> 1) == num)
        {
            /* Cancel each packet, as necessary */
            if (prev)
                prev->next = f->next;
            else
                s->txqueue = f->next;
            /*endif*/
            span_log(&s->logging,
                     SPAN_LOG_FLOW,
                     "-- ACKing packet %d. New txqueue is %d (-1 means empty)\n",
                     (f->frame[1] >> 1),
                     (s->txqueue)  ?  (s->txqueue->frame[1] >> 1)  :  -1);
            s->last_frame_peer_acknowledged = num;
            free(f);
            /* Reset retransmission count if we actually acked something */
            s->retransmissions = 0;
            return 1;
        }
        /*endif*/
    }
    /*endfor*/
    return 0;
}
/*- End of function --------------------------------------------------------*/

static void lapm_ack_rx(lapm_state_t *s, int ack)
{
    int i;
    int cnt;

    /* This might not be acking anything new */
    if (s->last_frame_peer_acknowledged == ack)
        return;
    /*endif*/
    /* It should be acking something that is actually outstanding */
    if ((s->last_frame_peer_acknowledged < s->next_tx_frame  &&  (ack < s->last_frame_peer_acknowledged  ||  ack > s->next_tx_frame))
        ||
        (s->last_frame_peer_acknowledged > s->next_tx_frame  &&  (ack > s->last_frame_peer_acknowledged  ||  ack < s->next_tx_frame)))
    {
        /* ACK was outside our window --- ignore */
        span_log(&s->logging, SPAN_LOG_FLOW, "ACK received outside window, ignoring\n");
        return;
    }
    /*endif*/
    
    /* Cancel each packet, as necessary */
    span_log(&s->logging,
             SPAN_LOG_FLOW,
             "-- ACKing all packets from %d to (but not including) %d\n",
             s->last_frame_peer_acknowledged,
             ack);
    for (cnt = 0, i = s->last_frame_peer_acknowledged;  i != ack;  i = (i + 1) & 0x7F) 
        cnt += lapm_ack_packet(s, i);
    /*endfor*/
    s->last_frame_peer_acknowledged = ack;
    if (s->txqueue == NULL)
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "-- Since there was nothing left, stopping timer T_401\n");
        /* Something was ACK'd.  Stop timer T_401. */
fprintf(stderr, "T401 a2 is %d [%p]\n", s->t401_timer, (void *) s);
        if (s->t401_timer >= 0)
        {
fprintf(stderr, "Deleting T401 a3 [%p] %d\n", (void *) s, s->t401_timer);
            span_schedule_del(&s->sched, s->t401_timer);
            s->t401_timer = -1;
        }
        /*endif*/
    }
    /*endif*/
    if (s->t403_timer >= 0)
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "-- Stopping timer T_403, since we got an ACK\n");
        if (s->t403_timer >= 0)
        {
fprintf(stderr, "Deleting T403 b %d\n", s->t403_timer);
            span_schedule_del(&s->sched, s->t403_timer);
            s->t403_timer = -1;
        }
        /*endif*/
    }
    /*endif*/
    if (s->txqueue)
    {
        /* Something left to transmit. Start timer T_401 again if it is stopped */
        span_log(&s->logging,
                 SPAN_LOG_FLOW,
                 "-- Something left to transmit (%d). Restarting timer T_401\n",
                 s->txqueue->frame[1] >> 1);
        if (s->t401_timer < 0)
        {
fprintf(stderr, "Setting T401 b [%p]\n", (void *) s);
            s->t401_timer = span_schedule_event(&s->sched, T_401, t401_expired, s);
        }
        /*endif*/
    }
    else
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "-- Nothing left, starting timer T_403\n");
        /* Nothing to transmit. Start timer T_403. */
fprintf(stderr, "Setting T403 c\n");
        s->t403_timer = span_schedule_event(&s->sched, T_403, t403_expired, s);
    }
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

static void lapm_reject(lapm_state_t *s)
{
    uint8_t frame[4];

    lapm_init_header(frame, !s->we_are_originator);
    frame[1] = (uint8_t) (0x00 | 0x08 | LAPM_FRAMETYPE_S);
    /* Where to start retransmission */
    frame[2] = (uint8_t) ((s->next_expected_frame << 1) | 0x01);
    span_log(&s->logging, SPAN_LOG_FLOW, "Sending REJ (reject (%d)\n", s->next_expected_frame);
    lapm_tx_frame(s, frame, 4);
}
/*- End of function --------------------------------------------------------*/

static void lapm_rr(lapm_state_t *s, int pfbit)
{
    uint8_t frame[4];

    lapm_init_header(frame, !s->we_are_originator);
    frame[1] = (uint8_t) (0x00 | 0x00 | LAPM_FRAMETYPE_S);
    frame[2] = (uint8_t) ((s->next_expected_frame << 1) | pfbit);
    /* Note that we have already ACKed this */
    s->last_frame_we_acknowledged = s->next_expected_frame;
    span_log(&s->logging, SPAN_LOG_FLOW, "Sending RR (receiver ready) (%d)\n", s->next_expected_frame);
    lapm_tx_frame(s, frame, 4);
}
/*- End of function --------------------------------------------------------*/

static void t401_expired(span_sched_state_t *ss, void *user_data)
{
    lapm_state_t *s;
    
    s = (lapm_state_t *) user_data;
fprintf(stderr, "Expiring T401 a4 [%p]\n", (void *) s);
    s->t401_timer = -1;
    if (s->txqueue)
    {
        /* Retransmit first packet in the queue, setting the poll bit */
        span_log(&s->logging, SPAN_LOG_FLOW, "-- Timer T_401 expired, What to do...\n");
        /* Update N(R), and set the poll bit */
        s->txqueue->frame[2] = (uint8_t)((s->next_expected_frame << 1) | 0x01);
        s->last_frame_we_acknowledged = s->next_expected_frame;
        s->solicit_f_bit = TRUE;
        if (++s->retransmissions <= N_400)
        {
            /* Reschedule timer T401 */
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Retransmitting %d bytes\n", s->txqueue->len);
            lapm_tx_frame(s, s->txqueue->frame, s->txqueue->len);
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Scheduling retransmission (%d)\n", s->retransmissions);
fprintf(stderr, "Setting T401 d [%p]\n", (void *) s);
            s->t401_timer = span_schedule_event(&s->sched, T_401, t401_expired, s);
        }
        else
        {
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Timeout occured\n");
            s->state = LAPM_RELEASE;
            if (s->status_callback)
                s->status_callback(s->status_callback_user_data, s->state);
            lapm_link_down(s);
            lapm_restart(s);
        }
        /*endif*/
    }
    else
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "Timer T_401 expired. Nothing to send...\n");
    }
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(const char *) lapm_status_to_str(int status)
{
    switch (status)
    {
    case LAPM_DETECT:
        return "LAPM_DETECT";
    case LAPM_ESTABLISH:
        return "LAPM_ESTABLISH";
    case LAPM_DATA:
        return "LAPM_DATA";
    case LAPM_RELEASE:
        return "LAPM_RELEASE";
    case LAPM_SIGNAL:
        return "LAPM_SIGNAL";
    case LAPM_SETPARM:
        return "LAPM_SETPARM";
    case LAPM_TEST:
        return "LAPM_TEST";
    case LAPM_UNSUPPORTED:
        return "LAPM_UNSUPPORTED";
    }
    /*endswitch*/
    return "???";
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) lapm_tx(lapm_state_t *s, const void *buf, int len)
{
    return queue_write(s->tx_queue, buf, len);
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) lapm_release(lapm_state_t *s)
{
    s->state = LAPM_RELEASE;
    return 0;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) lapm_loopback(lapm_state_t *s, int enable)
{
    s->state = LAPM_TEST;
    return 0;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) lapm_break(lapm_state_t *s, int enable)
{
    s->state = LAPM_SIGNAL;
    return 0;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) lapm_tx_iframe(lapm_state_t *s, const void *buf, int len, int cr)
{
    lapm_frame_queue_t *f;

    if ((f = malloc(sizeof(*f) + len + 4)) == NULL)
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "Out of memory\n");
        return -1;
    }
    /*endif*/

    lapm_init_header(f->frame, (s->peer_is_originator)  ?  cr  :  !cr);
    f->next = NULL;
    f->len = len + 4;
    f->frame[1] = (uint8_t) (s->next_tx_frame << 1);
    f->frame[2] = (uint8_t) (s->next_expected_frame << 1);
    memcpy(f->frame + 3, buf, len);
    s->next_tx_frame = (s->next_tx_frame + 1) & 0x7F;
    s->last_frame_we_acknowledged = s->next_expected_frame;
    /* Clear poll bit */
    f->frame[2] &= ~0x01;
    if (s->tx_last)
        s->tx_last->next = f;
    else
        s->txqueue = f;
    /*endif*/
    s->tx_last = f;
    /* Immediately transmit unless we're in a recovery state */
    if (s->retransmissions == 0)
        lapm_tx_frame(s, f->frame, f->len);
    /*endif*/
    if (s->t403_timer >= 0)
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "Stopping T_403 timer\n");
fprintf(stderr, "Deleting T403 c %d\n", s->t403_timer);
        span_schedule_del(&s->sched, s->t403_timer);
        s->t403_timer = -1;
    }
    /*endif*/
    if (s->t401_timer < 0)
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "Starting timer T_401\n");
        s->t401_timer = span_schedule_event(&s->sched, T_401, t401_expired, s);
fprintf(stderr, "Setting T401 e %d [%p]\n", s->t401_timer, (void *) s);
    }
    else
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "Timer T_401 already running (%d)\n", s->t401_timer);
    }
    /*endif*/
    return 0;
}
/*- End of function --------------------------------------------------------*/

static void t403_expired(span_sched_state_t *ss, void *user_data)
{
    lapm_state_t *s;

    s = (lapm_state_t *) user_data;
    span_log(&s->logging, SPAN_LOG_FLOW, "Timer T_403 expired. Sending RR and scheduling T_403 again\n");
    s->t403_timer = -1;
    s->retransmissions = 0;
    /* Solicit an F-bit in the other end's RR */
    s->solicit_f_bit = TRUE;
    lapm_rr(s, 1);
    /* Restart ourselves */
fprintf(stderr, "Setting T403 f\n");
    s->t401_timer = span_schedule_event(&s->sched, T_401, t401_expired, s);
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(void) lapm_dump(lapm_state_t *s, const uint8_t *frame, int len, int showraw, int txrx)
{
    const char *type;
    char direction_tag[2];
    
    direction_tag[0] = txrx  ?  '>'  :  '<';
    direction_tag[1] = '\0';
    if (showraw)
        span_log_buf(&s->logging, SPAN_LOG_FLOW, direction_tag, frame, len);
    /*endif*/

    switch ((frame[1] & LAPM_FRAMETYPE_MASK))
    {
    case LAPM_FRAMETYPE_I:
    case LAPM_FRAMETYPE_I_ALT:
        span_log(&s->logging, SPAN_LOG_FLOW, "%c Information frame:\n", direction_tag[0]);
        break;
    case LAPM_FRAMETYPE_S:
        span_log(&s->logging, SPAN_LOG_FLOW, "%c Supervisory frame:\n", direction_tag[0]);
        break;
    case LAPM_FRAMETYPE_U:
        span_log(&s->logging, SPAN_LOG_FLOW, "%c Unnumbered frame:\n", direction_tag[0]);
        break;
    }
    /*endswitch*/
    
    span_log(&s->logging,
             SPAN_LOG_FLOW,
             "%c DLCI: %2d  C/R: %d  EA: %d\n",
             direction_tag[0],
             (frame[0] >> 2),
             (frame[0] & 0x02)  ?  1  :  0,
             (frame[0] & 0x01),
             direction_tag[0]);
    switch ((frame[1] & LAPM_FRAMETYPE_MASK))
    {
    case LAPM_FRAMETYPE_I:
    case LAPM_FRAMETYPE_I_ALT:
        /* Information frame */
        span_log(&s->logging,
                 SPAN_LOG_FLOW, 
                 "%c N(S): %03d\n",
                 direction_tag[0],
                 (frame[1] >> 1));
        span_log(&s->logging,
                 SPAN_LOG_FLOW, 
                 "%c N(R): %03d   P: %d\n",
                 direction_tag[0],
                 (frame[2] >> 1),
                 (frame[2] & 0x01));
        span_log(&s->logging,
                 SPAN_LOG_FLOW, 
                 "%c %d bytes of data\n",
                 direction_tag[0],
                 len - 4);
        break;
    case LAPM_FRAMETYPE_S:
        /* Supervisory frame */
        switch (frame[1] & 0x0C)
        {
        case 0x00:
            type = "RR (receive ready)";
            break;
        case 0x04:
            type = "RNR (receive not ready)";
            break;
        case 0x08:
            type = "REJ (reject)";
            break;
        case 0x0C:
            type = "SREJ (selective reject)";
            break;
        default:
            type = "???";
            break;
        }
        /*endswitch*/
        span_log(&s->logging,
                 SPAN_LOG_FLOW,
                 "%c S: %03d [ %s ]\n",
                 direction_tag[0],
                 frame[1],
                 type);
        span_log(&s->logging,
                 SPAN_LOG_FLOW,
                 "%c N(R): %03d P/F: %d\n",
                 direction_tag[0],
                 frame[2] >> 1,
                 frame[2] & 0x01);
        span_log(&s->logging,
                 SPAN_LOG_FLOW,
                 "%c %d bytes of data\n",
                 direction_tag[0],
                 len - 4);
        break;
    case LAPM_FRAMETYPE_U:
        /* Unnumbered frame */
        switch (frame[1] & 0xEC)
        {
        case 0x00:
            type = "UI (unnumbered information)";
            break;
        case 0x0C:
            type = "DM (disconnect mode)";
            break;
        case 0x40:
            type = "DISC (disconnect)";
            break;
        case 0x60:
            type = "UA (unnumbered acknowledgement)";
            break;
        case 0x6C:
            type = "SABME (set asynchronous balanced mode extended)";
            break;
        case 0x84:
            type = "FRMR (frame reject)";
            break;
        case 0xAC:
            type = "XID (exchange identification)";
            break;
        case 0xE0:
            type = "TEST (test)";
            break;
        default:
            type = "???";
            break;
        }
        /*endswitch*/
        span_log(&s->logging,
                 SPAN_LOG_FLOW,
                 "%c   M: %03d [ %s ] P/F: %d\n",
                 direction_tag[0],
                 frame[1],
                 type,
                 (frame[1] >> 4) & 1);
        span_log(&s->logging,
                 SPAN_LOG_FLOW,
                 "%c %d bytes of data\n",
                 direction_tag[0],
                 len - 3);
        break;
    }
    /*endswitch*/
}
/*- End of function --------------------------------------------------------*/

static void lapm_link_up(lapm_state_t *s)
{
    uint8_t buf[1024];
    int len;

    lapm_reset(s);
    /* Go into connection established state */
    s->state = LAPM_DATA;
    if (s->status_callback)
        s->status_callback(s->status_callback_user_data, s->state);
    /*endif*/
    if (!queue_empty(s->tx_queue))
    {
        if ((len = queue_read(s->tx_queue, buf, s->n401)) > 0)
            lapm_tx_iframe(s, buf, len, TRUE);
        /*endif*/
    }
    /*endif*/
    if (s->t401_timer >= 0)
    {
fprintf(stderr, "Deleting T401 x [%p] %d\n", (void *) s, s->t401_timer);
        span_schedule_del(&s->sched, s->t401_timer);
        s->t401_timer = -1;
    }
    /*endif*/
    /* Start the T403 timer */
fprintf(stderr, "Setting T403 g\n");
    s->t403_timer = span_schedule_event(&s->sched, T_403, t403_expired, s);
}
/*- End of function --------------------------------------------------------*/

static void lapm_link_down(lapm_state_t *s)
{
    lapm_reset(s);

    if (s->status_callback)
        s->status_callback(s->status_callback_user_data, s->state);
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(void) lapm_reset(lapm_state_t *s)
{
    lapm_frame_queue_t *f;
    lapm_frame_queue_t *p;

    /* Having received a SABME, we need to reset our entire state */
    s->next_tx_frame = 0;
    s->last_frame_peer_acknowledged = 0;
    s->next_expected_frame = 0;
    s->last_frame_we_acknowledged = 0;
    s->window_size_k = 15;
    s->n401 = 128;
    if (s->t401_timer >= 0)
    {
fprintf(stderr, "Deleting T401 d [%p] %d\n", (void *) s, s->t401_timer);
        span_schedule_del(&s->sched, s->t401_timer);
        s->t401_timer = -1;
    }
    /*endif*/
    if (s->t403_timer >= 0)
    {
fprintf(stderr, "Deleting T403 e %d\n", s->t403_timer);
        span_schedule_del(&s->sched, s->t403_timer);
        s->t403_timer = -1;
    }
    /*endif*/
    s->busy = FALSE;
    s->solicit_f_bit = FALSE;
    s->state = LAPM_RELEASE;
    s->retransmissions = 0;
    /* Discard anything waiting to go out */
    for (f = s->txqueue;  f;  )
    {
        p = f;
        f = f->next;
        free(p);
    }
    /*endfor*/
    s->txqueue = NULL;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE_NONSTD(void) lapm_receive(void *user_data, const uint8_t *frame, int len, int ok)
{
    lapm_state_t *s;
    lapm_frame_queue_t *f;
    int sendnow;
    int octet;
    int s_field;
    int m_field;

fprintf(stderr, "LAPM receive %d %d\n", ok, len);
    if (!ok  ||  len == 0)
        return;
    /*endif*/
    s = (lapm_state_t *) user_data;
    if (len < 0)
    {
        /* Special conditions */
        span_log(&s->logging, SPAN_LOG_DEBUG, "V.42 rx status is %s (%d)\n", signal_status_to_str(len), len);
        return;
    }
    /*endif*/

    if ((s->debug & LAPM_DEBUG_LAPM_DUMP))
        lapm_dump(s, frame, len, s->debug & LAPM_DEBUG_LAPM_RAW, FALSE);
    /*endif*/
    octet = 0;
    /* We do not expect extended addresses */
    if ((frame[octet] & 0x01) == 0)
        return;
    /*endif*/
    /* Check for DLCIs we do not recognise */
    if ((frame[octet] >> 2) != LAPM_DLCI_DTE_TO_DTE)
        return;
    /*endif*/
    octet++;
    switch (frame[octet] & LAPM_FRAMETYPE_MASK)
    {
    case LAPM_FRAMETYPE_I:
    case LAPM_FRAMETYPE_I_ALT:
        if (s->state != LAPM_DATA)
        {
            span_log(&s->logging, SPAN_LOG_FLOW, "!! Got an I-frame while link state is %d\n", s->state);
            break;
        }
        /*endif*/
        /* Information frame */
        if (len < 4)
        {
            span_log(&s->logging, SPAN_LOG_FLOW, "!! Received short I-frame (expected 4, got %d)\n", len);
            break;
        }
        /*endif*/
        /* Make sure this is a valid packet */
        if ((frame[1] >> 1) == s->next_expected_frame)
        {
            /* Increment next expected I-frame */
            s->next_expected_frame = (s->next_expected_frame + 1) & 0x7F;
            /* Handle their ACK */
            lapm_ack_rx(s, frame[2] >> 1);
            if ((frame[2] & 0x01))
            {
                /* If the Poll/Final bit is set, send the RR immediately */
                lapm_rr(s, 1);
            }
            /*endif*/
            s->iframe_receive(s->iframe_receive_user_data, frame + 3, len - 4);
            /* Send an RR if one wasn't sent already */
            if (s->last_frame_we_acknowledged != s->next_expected_frame) 
                lapm_rr(s, 0);
            /*endif*/
        }
        else
        {
            if (((s->next_expected_frame - (frame[1] >> 1)) & 127) < s->window_size_k)
            {
                /* It's within our window -- send back an RR */
                lapm_rr(s, 0);
            }
            else
            {
                lapm_reject(s);
            }
            /*endif*/
        }
        /*endif*/
        break;
    case LAPM_FRAMETYPE_S:
        if (s->state != LAPM_DATA)
        {
            span_log(&s->logging, SPAN_LOG_FLOW, "!! Got S-frame while link down\n");
            break;
        }
        /*endif*/
        if (len < 4)
        {
            span_log(&s->logging, SPAN_LOG_FLOW, "!! Received short S-frame (expected 4, got %d)\n", len);
            break;
        }
        /*endif*/
        s_field = frame[octet] & 0xEC;
        switch (s_field)
        {
        case 0x00:
            /* RR (receive ready) */
            s->busy = FALSE;
            /* Acknowledge frames as necessary */
            lapm_ack_rx(s, frame[2] >> 1);
            if ((frame[2] & 0x01))
            {
                /* If P/F is one, respond with an RR with the P/F bit set */
                if (s->solicit_f_bit)
                {
                    span_log(&s->logging, SPAN_LOG_FLOW, "-- Got RR response to our frame\n");
                }
                else
                {
                    span_log(&s->logging, SPAN_LOG_FLOW, "-- Unsolicited RR with P/F bit, responding\n");
                    lapm_rr(s, 1);
                }
                /*endif*/
                s->solicit_f_bit = FALSE;
            }
            /*endif*/
            break;
        case 0x04:
            /* RNR (receive not ready) */
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Got receiver not ready\n");
            s->busy = TRUE;
            break;   
        case 0x08:
            /* REJ (reject) */
            /* Just retransmit */
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Got reject requesting packet %d...  Retransmitting.\n", frame[2] >> 1);
            if ((frame[2] & 0x01))
            {
                /* If it has the poll bit set, send an appropriate supervisory response */
                lapm_rr(s, 1);
            }
            /*endif*/
            sendnow = FALSE;
            /* Resend the appropriate I-frame */
            for (f = s->txqueue;  f;  f = f->next)
            {
                if (sendnow  ||  (f->frame[1] >> 1) == (frame[2] >> 1))
                {
                    /* Matches the request, or follows in our window */
                    sendnow = TRUE;
                    span_log(&s->logging,
                             SPAN_LOG_FLOW,
                             "!! Got reject for frame %d, retransmitting frame %d now, updating n_r!\n",
                             frame[2] >> 1,
                             f->frame[1] >> 1);
                    f->frame[2] = (uint8_t) (s->next_expected_frame << 1);
                    lapm_tx_frame(s, f->frame, f->len);
                }
                /*endif*/
            }
            /*endfor*/
            if (!sendnow)
            {
                if (s->txqueue)
                {
                    /* This should never happen */
                    if ((frame[2] & 0x01) == 0  ||  (frame[2] >> 1))
                    {
                        span_log(&s->logging,
                                 SPAN_LOG_FLOW,
                                 "!! Got reject for frame %d, but we only have others!\n",
                                 frame[2] >> 1);
                    }
                    /*endif*/
                }
                else
                {
                    /* Hrm, we have nothing to send, but have been REJ'd.  Reset last_frame_peer_acknowledged, next_tx_frame, etc */
                    span_log(&s->logging, SPAN_LOG_FLOW, "!! Got reject for frame %d, but we have nothing -- resetting!\n", frame[2] >> 1);
                    s->last_frame_peer_acknowledged =
                    s->next_tx_frame = frame[2] >> 1;
                    /* Reset t401 timer if it was somehow going */
                    if (s->t401_timer >= 0)
                    {
fprintf(stderr, "Deleting T401 f [%p] %d\n", (void *) s, s->t401_timer);
                        span_schedule_del(&s->sched, s->t401_timer);
                        s->t401_timer = -1;
                    }
                    /*endif*/
                    /* Reset and restart t403 timer */
                    if (s->t403_timer >= 0)
                    {
fprintf(stderr, "Deleting T403 g %d\n", s->t403_timer);
                        span_schedule_del(&s->sched, s->t403_timer);
                        s->t403_timer = -1;
                    }
                    /*endif*/
fprintf(stderr, "Setting T403 h\n");
                    s->t403_timer = span_schedule_event(&s->sched, T_403, t403_expired, s);
                }
                /*endif*/
            }
            /*endif*/
            break;
        case 0x0C:
            /* SREJ (selective reject) */
            break;
        default:
            span_log(&s->logging,
                     SPAN_LOG_FLOW,
                     "!! XXX Unknown Supervisory frame sd=0x%02x,pf=%02xnr=%02x vs=%02x, va=%02x XXX\n",
                     s_field,
                     frame[2] & 0x01,
                     frame[2] >> 1,
                     s->next_tx_frame,
                     s->last_frame_peer_acknowledged);
            break;
        }
        /*endswitch*/
        break;
    case LAPM_FRAMETYPE_U:
        if (len < 3)
        {
            span_log(&s->logging, SPAN_LOG_FLOW, "!! Received too short unnumbered frame\n");
            break;
        }
        /*endif*/
        m_field = frame[octet] & 0xEC;
        switch (m_field)
        {
        case 0x00:
            /* UI (unnumbered information) */
            switch (frame[++octet] & 0x7F)
            {
            case 0x40:
                /* BRK */
                span_log(&s->logging, SPAN_LOG_FLOW, "BRK - option %d, length %d\n", (frame[octet] >> 5), frame[octet + 1]);
                octet += 2;
                break;
            case 0x60:
                /* BRKACK */
                span_log(&s->logging, SPAN_LOG_FLOW, "BRKACK\n");
                break;
            default:
                /* Unknown */
                span_log(&s->logging, SPAN_LOG_FLOW, "Unknown UI type\n");
                break;
            }
            /*endswitch*/
            break;
        case 0x0C:
            /* DM (disconnect mode) */
            if ((frame[octet] & 0x10))
            {
                span_log(&s->logging, SPAN_LOG_FLOW, "-- Got Unconnected Mode from peer.\n");
                /* Disconnected mode, try again */
                lapm_link_down(s);
                lapm_restart(s);
            }
            else
            {
                span_log(&s->logging, SPAN_LOG_FLOW, "-- DM (disconnect mode) requesting SABME, starting.\n");
                /* Requesting that we start */
                lapm_restart(s);
            }
            /*endif*/
            break;
        case 0x40:
            /* DISC (disconnect) */
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Got DISC (disconnect) from peer.\n");
            /* Acknowledge */
            lapm_send_ua(s, (frame[octet] & 0x10));
            lapm_link_down(s);
            break;
        case 0x60:
            /* UA (unnumbered acknowledgement) */
            if (s->state == LAPM_ESTABLISH)
            {
                span_log(&s->logging, SPAN_LOG_FLOW, "-- Got UA (unnumbered acknowledgement) from %s peer. Link up.\n", (frame[0] & 0x02)  ?  "xxx"  :  "yyy");
                lapm_link_up(s);
            }
            else
            {
                span_log(&s->logging, SPAN_LOG_FLOW, "!! Got a UA (unnumbered acknowledgement) in state %d\n", s->state);
            }
            /*endif*/
            break;
        case 0x6C:
            /* SABME (set asynchronous balanced mode extended) */
            span_log(&s->logging, SPAN_LOG_FLOW, "-- Got SABME (set asynchronous balanced mode extended) from %s peer.\n", (frame[0] & 0x02)  ?  "yyy"  :  "xxx");
            if ((frame[0] & 0x02))
            {
                s->peer_is_originator = TRUE;
                if (s->we_are_originator)
                {
                    /* We can't both be originators */
                    span_log(&s->logging, SPAN_LOG_FLOW, "We think we are the originator, but they think so too.");
                    break;
                }
                /*endif*/
            }
            else
            {
                s->peer_is_originator = FALSE;
                if (!s->we_are_originator)
                {
                    /* We can't both be answerers */
                    span_log(&s->logging, SPAN_LOG_FLOW, "We think we are the answerer, but they think so too.\n");
                    break;
                }
                /*endif*/
            }
            /*endif*/
            /* Send unnumbered acknowledgement */
            lapm_send_ua(s, (frame[octet] & 0x10));
            lapm_link_up(s);
            break;
        case 0x84:
            /* FRMR (frame reject) */
            span_log(&s->logging, SPAN_LOG_FLOW, "!! FRMR (frame reject).\n");
            break;
        case 0xAC:
            /* XID (exchange identification) */
            span_log(&s->logging, SPAN_LOG_FLOW, "!! XID (exchange identification) frames not supported\n");
            break;
        case 0xE0:
            /* TEST (test) */
            span_log(&s->logging, SPAN_LOG_FLOW, "!! TEST (test) frames not supported\n");
            break;
        default:
            span_log(&s->logging, SPAN_LOG_FLOW, "!! Don't know what to do with M=%X u-frames\n", m_field);
            break;
        }
        /*endswitch*/
        break;
    }
    /*endswitch*/
}
/*- End of function --------------------------------------------------------*/

static void lapm_hdlc_underflow(void *user_data)
{
    lapm_state_t *s;
    uint8_t buf[1024];
    int len;

    s = (lapm_state_t *) user_data;
    span_log(&s->logging, SPAN_LOG_FLOW, "HDLC underflow\n");
    if (s->state == LAPM_DATA)
    {
        if (!queue_empty(s->tx_queue))
        {
            if ((len = queue_read(s->tx_queue, buf, s->n401)) > 0)
                lapm_tx_iframe(s, buf, len, TRUE);
            /*endif*/
        }
        /*endif*/
    }
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(void) lapm_restart(lapm_state_t *s)
{
#if 0
    if (s->state != LAPM_RELEASE)
    {
        span_log(&s->logging, SPAN_LOG_FLOW, "!! lapm_restart: Not in 'Link Connection Released' state\n");
        return;
    }
    /*endif*/
#endif
    span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
    span_log_set_protocol(&s->logging, "LAP.M");
    hdlc_tx_init(&s->hdlc_tx, FALSE, 1, TRUE, lapm_hdlc_underflow, s);
    hdlc_rx_init(&s->hdlc_rx, FALSE, FALSE, 1, lapm_receive, s);
    /* TODO: This is a bodge! */
    s->t401_timer = -1;
    s->t402_timer = -1;
    s->t403_timer = -1;
    lapm_reset(s);
    /* TODO: Maybe we should implement T_WAIT? */
    lapm_send_sabme(NULL, s);
}
/*- End of function --------------------------------------------------------*/

#if 0
static void lapm_init(lapm_state_t *s)
{
    lapm_restart(s);
}
/*- End of function --------------------------------------------------------*/
#endif

static void negotiation_rx_bit(v42_state_t *s, int new_bit)
{
    /* DC1 with even parity, 8-16 ones, DC1 with odd parity, 8-16 ones */
    //uint8_t odp = "0100010001 11111111 0100010011 11111111";
    /* V.42 OK E , 8-16 ones, C, 8-16 ones */
    //uint8_t adp_v42 = "0101000101  11111111  0110000101  11111111";
    /* V.42 disabled E, 8-16 ones, NULL, 8-16 ones */
    //uint8_t adp_nov42 = "0101000101  11111111  0000000001  11111111";

    /* There may be no negotiation, so we need to process this data through the
       HDLC receiver as well */
    if (new_bit < 0)
    {
        /* Special conditions */
        span_log(&s->logging, SPAN_LOG_DEBUG, "V.42 rx status is %s (%d)\n", signal_status_to_str(new_bit), new_bit);
        return;
    }
    /*endif*/
    new_bit &= 1;
    s->rxstream = (s->rxstream << 1) | new_bit;
    switch (s->rx_negotiation_step)
    {
    case 0:
        /* Look for some ones */
        if (new_bit)
            break;
        /*endif*/
        s->rx_negotiation_step = 1;
        s->rxbits = 0;
        s->rxstream = ~1;
        s->rxoks = 0;
        break;
    case 1:
        /* Look for the first character */
        if (++s->rxbits < 9)
            break;
        /*endif*/
        s->rxstream &= 0x3FF;
        if (s->calling_party  &&  s->rxstream == 0x145)
        {
            s->rx_negotiation_step++;
        }
        else if (!s->calling_party  &&  s->rxstream == 0x111)
        {
            s->rx_negotiation_step++;
        }
        else
        {
            s->rx_negotiation_step = 0;
        }
        /*endif*/
        s->rxbits = 0;
        s->rxstream = ~0;
        break;
    case 2:
        /* Look for 8 to 16 ones */
        s->rxbits++;
        if (new_bit)
            break;
        /*endif*/
        if (s->rxbits >= 8  &&  s->rxbits <= 16)
            s->rx_negotiation_step++;
        else
            s->rx_negotiation_step = 0;
        /*endif*/
        s->rxbits = 0;
        s->rxstream = ~1;
        break;
    case 3:
        /* Look for the second character */
        if (++s->rxbits < 9)
            break;
        /*endif*/
        s->rxstream &= 0x3FF;
        if (s->calling_party  &&  s->rxstream == 0x185)
        {
            s->rx_negotiation_step++;
        }
        else if (s->calling_party  &&  s->rxstream == 0x001)
        {
            s->rx_negotiation_step++;
        }
        else if (!s->calling_party  &&  s->rxstream == 0x113)
        {
            s->rx_negotiation_step++;
        }
        else
        {
            s->rx_negotiation_step = 0;
        }
        /*endif*/
        s->rxbits = 0;
        s->rxstream = ~0;
        break;
    case 4:
        /* Look for 8 to 16 ones */
        s->rxbits++;
        if (new_bit)
            break;
        /*endif*/
        if (s->rxbits >= 8  &&  s->rxbits <= 16)
        {
            if (++s->rxoks >= 2)
            {
                /* HIT */
                s->rx_negotiation_step++;
                if (s->calling_party)
                {
                    if (s->t400_timer >= 0)
                    {
fprintf(stderr, "Deleting T400 h %d\n", s->t400_timer);
                        span_schedule_del(&s->lapm.sched, s->t400_timer);
                        s->t400_timer = -1;
                    }
                    /*endif*/
                    s->lapm.state = LAPM_ESTABLISH;
                    if (s->lapm.status_callback)
                        s->lapm.status_callback(s->lapm.status_callback_user_data, s->lapm.state);
                    /*endif*/
                }
                else
                {
                    s->odp_seen = TRUE;
                }
                /*endif*/
                break;
            }
            /*endif*/
            s->rx_negotiation_step = 1;
            s->rxbits = 0;
            s->rxstream = ~1;
        }
        else
        {
            s->rx_negotiation_step = 0;
            s->rxbits = 0;
            s->rxstream = ~0;
        }
        /*endif*/
        break;
    case 5:
        /* Parked */
        break;
    }
    /*endswitch*/
}
/*- End of function --------------------------------------------------------*/

static int v42_support_negotiation_tx_bit(v42_state_t *s)
{
    int bit;

    if (s->calling_party)
    {
        if (s->txbits <= 0)
        {
            s->txstream = 0x3FE22;
            s->txbits = 36;
        }
        else if (s->txbits == 18)
        {
            s->txstream = 0x3FF22;
        }
        /*endif*/
        bit = s->txstream & 1;
        s->txstream >>= 1;
        s->txbits--;
    }
    else
    {
        if (s->odp_seen  &&  s->txadps < 10)
        {
            if (s->txbits <= 0)
            {
                if (++s->txadps >= 10)
                {
                    if (s->t400_timer >= 0)
                    {
fprintf(stderr, "Deleting T400 i %d\n", s->t400_timer);
                        span_schedule_del(&s->lapm.sched, s->t400_timer);
                        s->t400_timer = -1;
                    }
                    /*endif*/
                    s->lapm.state = LAPM_ESTABLISH;
                    if (s->lapm.status_callback)
                        s->lapm.status_callback(s->lapm.status_callback_user_data, s->lapm.state);
                    /*endif*/
                    s->txstream = 1;
                }
                else
                {
                    s->txstream = 0x3FE8A;
                    s->txbits = 36;
                }
                /*endif*/
            }
            else if (s->txbits == 18)
            {
                s->txstream = 0x3FE86;
            }
            /*endif*/
            bit = s->txstream & 1;
            s->txstream >>= 1;
            s->txbits--;
        }
        else
        {
            bit = 1;
        }
        /*endif*/
    }
    /*endif*/
    return bit;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(void) v42_rx_bit(void *user_data, int bit)
{
    v42_state_t *s;

    s = (v42_state_t *) user_data;
    if (s->lapm.state == LAPM_DETECT)
        negotiation_rx_bit(s, bit);
    else
        hdlc_rx_put_bit(&s->lapm.hdlc_rx, bit);
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) v42_tx_bit(void *user_data)
{
    v42_state_t *s;
    int bit;

    s = (v42_state_t *) user_data;
    if (s->lapm.state == LAPM_DETECT)
        bit = v42_support_negotiation_tx_bit(s);
    else
        bit = hdlc_tx_get_bit(&s->lapm.hdlc_tx);
    /*endif*/
    return bit;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(void) v42_set_status_callback(v42_state_t *s, v42_status_func_t callback, void *user_data)
{
    s->lapm.status_callback = callback;
    s->lapm.status_callback_user_data = user_data;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(void) v42_restart(v42_state_t *s)
{
    span_schedule_init(&s->lapm.sched);

    s->lapm.we_are_originator = s->calling_party;
    lapm_restart(&s->lapm);
    if (s->detect)
    {
        s->txstream = ~0;
        s->txbits = 0;
        s->rxstream = ~0;
        s->rxbits = 0;
        s->rxoks = 0;
        s->txadps = 0;
        s->rx_negotiation_step = 0;
        s->odp_seen = FALSE;
fprintf(stderr, "Setting T400 i\n");
        s->t400_timer = span_schedule_event(&s->lapm.sched, T_400, t400_expired, s);
        s->lapm.state = LAPM_DETECT;
    }
    else
    {
        s->lapm.state = LAPM_ESTABLISH;
    }
    /*endif*/
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(v42_state_t *) v42_init(v42_state_t *s, int calling_party, int detect, v42_frame_handler_t frame_handler, void *user_data)
{
    int alloced;
    
    if (frame_handler == NULL)
        return NULL;
    /*endif*/
    alloced = FALSE;
    if (s == NULL)
    {
        if ((s = (v42_state_t *) malloc(sizeof(*s))) == NULL)
            return NULL;
        alloced = TRUE;
    }
    memset(s, 0, sizeof(*s));
    s->calling_party = calling_party;
    s->detect = detect;
    s->lapm.iframe_receive = frame_handler;
    s->lapm.iframe_receive_user_data = user_data;
    s->lapm.debug |= (LAPM_DEBUG_LAPM_RAW | LAPM_DEBUG_LAPM_DUMP | LAPM_DEBUG_LAPM_STATE);
    s->lapm.t401_timer =
    s->lapm.t402_timer =
    s->lapm.t403_timer = -1;

    if ((s->lapm.tx_queue = queue_init(NULL, 16384, 0)) == NULL)
    {
        if (alloced)
            free(s);
        return NULL;
    }
    /*endif*/
    span_log_init(&s->logging, SPAN_LOG_NONE, NULL);
    span_log_set_protocol(&s->logging, "V.42");
    v42_restart(s);
    return s;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) v42_release(v42_state_t *s)
{
    return 0;
}
/*- End of function --------------------------------------------------------*/

SPAN_DECLARE(int) v42_free(v42_state_t *s)
{
    free(s);
    return 0;
}
/*- End of function --------------------------------------------------------*/
/*- End of file ------------------------------------------------------------*/