/*
 * Copyright (c) 2018 Lars Thrane A/S
 * SPDX-License-Identifier: GPL-2.0
 *
 * Telnet protocol handling - server
 */
#include <stdlib.h>
#include <string.h>

#include "lib/nvt_log.h"
#include "telnet.h"
#include "telnet_param.h"


/* Telnet commands */
static const char *const tn_cmd[] = {
    "SE", "NOP", "MARK", "BRK", "IP", "AO", "AYT", "EC",
    "EL", "GA", "SB", "WILL", "WONT", "DO", "DONT", "IAC"
};

#define OPT_NACK    0           /* Reject      (DONT/WONT)      */
#define OPT_IGNORE  1           /* Ignore the command (?)       */
#define OPT_ACK     2           /* Acknowledge (DO  /WILL)      */

/* Telnet option support */
static const unsigned char tn_opt[256] = {
/* *INDENT-OFF* */
    [TNO_BINARY] = OPT_ACK,
    [TNO_SUPP_GA] = OPT_ACK,
//  [TNO_TTYP]   = OPT_NACK,
//  [TNO_NAWS]   = OPT_NACK,
//  [TNO_NEO]    = OPT_NACK,
    [TNO_CPCO]   = OPT_ACK,
//  [TNO_KERMIT] = OPT_NACK,
/* *INDENT-ON* */
};


static void _telnet_handle_req(tn_ctx_t *tcc, int cmd, int opt)
{
    char            buf[3];

    switch (tn_opt[opt])
    {
    default:
    case OPT_IGNORE:
        return;
    case OPT_ACK:
        cmd = (cmd == TNC_FB_WILL) ? TNC_FD_DO : TNC_FB_WILL;
        break;
    case OPT_NACK:
        cmd = (cmd == TNC_FB_WILL) ? TNC_FE_DONT : TNC_FC_WONT;
        break;
    }

    buf[0] = TNC_FF_IAC;
    buf[1] = cmd;
    buf[2] = opt;
    DBG("TNo: Op2 %02x %02x: %-4s %d", cmd, opt, tn_cmd[cmd & 0xf], opt);
    tcc->cli_tx(tcc->cctx, buf, 3);

    if (opt == TNO_CPCO && (cmd == TNC_FB_WILL || cmd == TNC_FD_DO))
        telnet_rfc2217_init(tcc, TNI_ON);
}

void telnet_reply_opt(tn_ctx_t *tcc, int opt, int prm,
                      const void *val, int len)
{
    unsigned char   buf[128], *pu = buf;
    const unsigned char *pv;
    int             i;

    *pu++ = TNC_FF_IAC;
    *pu++ = TNC_FA_SB;

    *pu++ = opt;
    *pu++ = prm;
    if (len > 0 && len <= 32)
    {
        pv = val;
        for (i = 0; i < len; i++)
        {
            *pu++ = *pv;
            if (*pv++ == TNC_FF_IAC)
                *pu++ = TNC_FF_IAC;
        }
    }

    *pu++ = TNC_FF_IAC;
    *pu++ = TNC_F0_SE;

    len = pu - buf;
    DBG2_BUF("opto", buf, len);
    tcc->cli_tx(tcc->cctx, buf, len);
}

static void _telnet_handle_opt(tn_ctx_t *tcc, int opt,
                               unsigned char *pu, int nd)
{
    DBG2_BUF("opti", pu, nd);

    switch (opt)
    {
    default:
        nvt_log(LOG_WARNING, "Unexpected SB: Opt = %d", opt);
        break;
    case TNO_CPCO:             /* RFC 2217 */
        tcc->mode_rfc2217 = 1;
        telnet_rfc2217_handle_opt(tcc, opt, pu, nd);
        break;
    }
}

int telnet_rx(tn_ctx_t *tcc, char *buf, int *plen)
{
    char           *s, *p;
    unsigned char  *pu;
    int             len, rem;
    int             np, nd;
    int             b1, b2;

    /* Drop telnet processing entirely if we haven't seen any telnet
     * negotiation in the beginning */
    if (tcc->bytes_rx >= 32 && !tcc->mode_telnet)
        return 0;

    len = *plen;
    tcc->bytes_rx += len;

    if (len < (int)tcc->off_rx)
        tcc->off_rx = 0;

    for (s = buf + tcc->off_rx, rem = len - tcc->off_rx; rem > 0; s = p)
    {
        DBG2_BUF("****", s, rem);
        p = memchr(s, TNC_FF_IAC, rem);
        if (!p)
            break;

        /* We have IAC (= 0xff) */
        np = rem - (p - s);     /* N. chars available incl. IAC */
        if (np < 2)
            goto tn_more;

        pu = (unsigned char *)p;
        b1 = pu[1];
        switch (b1)
        {
        default:
        case TNC_F0_SE:
        case TNC_F1_NOP:
        case TNC_F2_MARK:
        case TNC_F3_BRK:
        case TNC_F4_IP:
        case TNC_F5_AO:
        case TNC_F6_AYT:
        case TNC_F7_EC:
        case TNC_F8_EL:
        case TNC_F9_GA:
            DBG("TNi: Op1 %02x   : %s", b1, tn_cmd[b1 & 0xf]);
            nd = 2;             /* Drop 2 bytes */
            goto tn_drop;

        case TNC_FB_WILL:
        case TNC_FC_WONT:
        case TNC_FD_DO:
        case TNC_FE_DONT:
            if (np < 3)
                goto tn_more;   /* Need more */
            tcc->mode_telnet = 1;       /* Any such sequence activates TN */
            b2 = pu[2];
            DBG("TNi: Op2 %02x %02x: %-4s %d", b1, b2, tn_cmd[b1 & 0xf], b2);
            if (b1 == TNC_FB_WILL || b1 == TNC_FD_DO)
                _telnet_handle_req(tcc, b1, b2);
            nd = 3;             /* Drop 3 bytes */
            goto tn_drop;

        case TNC_FA_SB:
            for (nd = 2; nd < np - 1; nd++)
            {
                if (pu[nd] == TNC_FF_IAC && pu[nd + 1] == TNC_F0_SE)
                {
                    nd -= 2;
                    if (nd <= 0)
                        break;
                    b2 = pu[2];
                    tcc->mode_telnet = 1;       /* Any such sequence activates TN */
                    DBG("TNi: Op2 %02x %02x: %-4s %d",
                        b1, b2, tn_cmd[b1 & 0xf], b2);
                    _telnet_handle_opt(tcc, b2, pu + 3, nd - 1);
                    nd += 4;
                    goto tn_drop;
                }
            }
            if (np < 16)
                goto tn_more;   /* Not done */
            /* This does not look right */
            nvt_log_buf(LOG_WARNING, "tnrx", p, np);
            rem = 0;            /* Quit loop */
            break;

        case TNC_FF_IAC:
            p++;
            nd = 1;             /* Drop 1 bytes */
            goto tn_drop;

          tn_drop:
            if (!tcc->mode_telnet)
                goto tn_break;
            DBG2_BUF("drop", p, nd);
            rem -= nd + (p - s);
            len -= nd;
            memmove(p, p + nd, rem);
            break;

          tn_break:
            rem = 0;            /* Quit loop */
            break;

          tn_more:             /* Request more data */
            tcc->off_rx = len - np;
            *plen = len;
            return 1;
        }
    }

    tcc->off_rx = 0;
    *plen = len;

    return 0;
}

int telnet_tx(tn_ctx_t *tcc, const char *buf, int len)
{
    const char     *s, *p;
    int             rem, nd;

    for (s = buf, rem = len; rem > 0; s = p)
    {
        if (tcc->mode_telnet)
            p = memchr(s, TNC_FF_IAC, rem);
        else
            p = NULL;
        if (!p)
        {
            /* Send the rest */
            nd = rem;
            tcc->cli_tx(tcc->cctx, s, nd);
        }
        else
        {
            nd = p - s + 1;
            tcc->cli_tx(tcc->cctx, s, nd);
            tcc->cli_tx(tcc->cctx, p, 1);       /* One TNC_FF_IAC */
            p++;
        }
        rem -= nd;
    }

    return 0;
}

tn_ctx_t       *telnet_ctx_init(void *cctx, cli_tx_f *ftx, cli_ss_f *fss)
{
    tn_ctx_t       *tcc;

    tcc = calloc(1, sizeof(tn_ctx_t));
    tcc->cctx = cctx;
    tcc->cli_tx = ftx;          /* Write to client */
    tcc->cli_ss = fss;          /* Set state (line/modem) */

    telnet_rfc2217_init(tcc, TNI_INIT);

    return tcc;
}