plptools/link_8cc_source.html

/*

 * This file is part of plptools.

 *

 *  Copyright (C) 1999 Philip Proudman <philip.proudman@btinternet.com>

 *  Copyright (C) 1999-2002 Fritz Elfert <felfert@to.com>

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  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 General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License along

 *  along with this program; if not, see <https://www.gnu.org/licenses/>.

 *

 */

#include "config.h"


#include <iostream>


#include <stdint.h>

#include <stdlib.h>

#include <unistd.h>

#include <stdio.h>

#include <sys/time.h>


#include "bufferstore.h"

#include "bufferarray.h"


#include "link.h"

#include "ncp_log.h"

#include "ncp.h"

#include "packet.h"


extern "C" {

    static void *expire_check(void *arg)

    {

        Link *l = (Link *)arg;

        pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);

        while (1) {

            usleep(l->retransTimeout() * 500);

            l->retransmit();

        }

    }

};


using namespace std;


ENUM_DEFINITION_BEGIN(Link::link_type, Link::LINK_TYPE_UNKNOWN)

    stringRep.add(Link::LINK_TYPE_UNKNOWN, N_("Unknown"));

    stringRep.add(Link::LINK_TYPE_SIBO,    N_("SIBO"));

    stringRep.add(Link::LINK_TYPE_EPOC,    N_("EPOC"));

ENUM_DEFINITION_END(Link::link_type)


Link::Link(const char *fname, int baud, NCP *_ncp, unsigned short _verbose, const int cancellationFd)

    : p(0)

{

    theNCP = _ncp;

    verbose = _verbose;

    txSequence = 1;

    rxSequence = -1;

    failed = false;

    seqMask = 7;

    maxOutstanding = 1;

    linkType = LINK_TYPE_UNKNOWN;

    for (int i = 0; i < 256; i++)

        xoff[i] = false;

    // generate magic number for sendReqCon()

    srandom(time(NULL));

    conMagic = random();


    p = new packet(fname, baud, this, _verbose, cancellationFd);


    pthread_mutex_init(&queueMutex, NULL);

    pthread_create(&checkthread, NULL, expire_check, this);


    // submit a link request

    sendReqReq();

}


Link::~Link()

{

    flush();

    pthread_cancel(checkthread);

    pthread_join(checkthread, NULL);

    pthread_mutex_destroy(&queueMutex);

    delete p;

}


unsigned long Link::

retransTimeout()

{

    return ((unsigned long)getSpeed() * 1000 / 13200) + 200;

}


void Link::

reset() {

    txSequence = 1;

    rxSequence = -1;

    failed = false;

    seqMask = 7;

    maxOutstanding = 1;

    linkType = LINK_TYPE_UNKNOWN;

    purgeAllQueues();

    for (int i = 0; i < 256; i++)

        xoff[i] = false;

    p->reset();

    // submit a link request

    sendReqReq();

}


unsigned short Link::

getVerbose()

{

    return verbose;

}


void Link::

setVerbose(unsigned short _verbose)

{

    verbose = _verbose;

    p->setVerbose(verbose);

}


void Link::

send(const bufferStore & buff)

{

    if (buff.getLen() > 300) {

        failed = true;

    } else

        transmit(buff);

}


void Link::

purgeAllQueues()

{

    pthread_mutex_lock(&queueMutex);

    ackWaitQueue.clear();

    holdQueue.clear();

    pthread_mutex_unlock(&queueMutex);

}


void Link::

purgeQueue(int channel)

{

    pthread_mutex_lock(&queueMutex);

    vector<ackWaitQueueElement>::iterator i;

    for (i = ackWaitQueue.begin(); i != ackWaitQueue.end(); i++)

        if (i->data.getByte(0) == channel) {

            ackWaitQueue.erase(i);

            i--;

        }

    vector<bufferStore>::iterator j;

    for (j = holdQueue.begin(); j != holdQueue.end(); j++)

        if (j->getByte(0) == channel) {

            holdQueue.erase(j);

            j--;

        }

    pthread_mutex_unlock(&queueMutex);

}


void Link::

sendAck(int seq)

{

    if (hasFailed())

        return;

    bufferStore tmp;

    if (verbose & LNK_DEBUG_LOG)

        lout << "Link: >> ack seq=" << seq << endl;

    if (seq > 7) {

        int hseq = seq >> 3;

        int lseq = (seq & 7) | 8;

        seq = (hseq << 8) + lseq;

        tmp.prependWord(seq);

    } else

        tmp.prependByte(seq);

    p->send(tmp);

}


void Link::

sendReqCon()

{

    if (hasFailed())

        return;

    bufferStore tmp;

    if (verbose & LNK_DEBUG_LOG)

        lout << "Link: >> con seq=4" << endl;

    tmp.addByte(0x24);

    tmp.addDWord(conMagic);

    ackWaitQueueElement e;

    e.seq = 0; // expected ACK is 0, _NOT_ 4!

    gettimeofday(&e.stamp, NULL);

    e.data = tmp;

    e.txcount = 4;

    pthread_mutex_lock(&queueMutex);

    ackWaitQueue.push_back(e);

    pthread_mutex_unlock(&queueMutex);

    p->send(tmp);

}


void Link::

sendReqReq()

{

    if (hasFailed())

        return;

    bufferStore tmp;

    if (verbose & LNK_DEBUG_LOG)

        lout << "Link: >> con seq=1" << endl;

    tmp.addByte(0x21);

    ackWaitQueueElement e;

    e.seq = 0; // expected response is Ack with seq=0 or ReqCon

    gettimeofday(&e.stamp, NULL);

    e.data = tmp;

    e.txcount = 4;

    pthread_mutex_lock(&queueMutex);

    ackWaitQueue.push_back(e);

    pthread_mutex_unlock(&queueMutex);

    p->send(tmp);

}


void Link::

sendReq()

{

    if (hasFailed())

        return;

    bufferStore tmp;

    if (verbose & LNK_DEBUG_LOG)

        lout << "Link: >> con seq=1" << endl;

    tmp.addByte(0x20);

    // No Ack expected for this, so no new entry in ackWaitQueue

    p->send(tmp);

}


void Link::

receive(bufferStore buff)

{

    if (!p)

        return;


    vector<ackWaitQueueElement>::iterator i;

    bool ackFound;

    bool conFound;

    int type = buff.getByte(0);

    int seq = type & 0x0f;


    type &= 0xf0;

    // Support for incoming extended sequence numbers

    if (seq & 8) {

        int tseq = buff.getByte(1);

        buff.discardFirstBytes(2);

        seq = (tseq << 3) + (seq & 0x07);

    } else

        buff.discardFirstBytes(1);


    switch (type) {

        case 0x30:

            // Normal data

            if (verbose & LNK_DEBUG_LOG) {

                lout << "Link: << dat seq=" << seq ;

                if (verbose & LNK_DEBUG_DUMP)

                    lout << " " << buff << endl;

                else

                    lout << " len=" << buff.getLen() << endl;

            }


            if (((rxSequence + 1) & seqMask) == seq) {

                rxSequence++;

                rxSequence &= seqMask;


                    sendAck(rxSequence);

                // Must check for XOFF/XON ncp frames HERE!

                if ((buff.getLen() == 3) && (buff.getByte(0) == 0)) {

                    switch (buff.getByte(2)) {

                        case 1:

                            // XOFF

                            xoff[buff.getByte(1)] = true;

                            if (verbose & LNK_DEBUG_LOG)

                                lout << "Link: got XOFF for channel "

                                     << buff.getByte(1) << endl;

                            break;

                        case 2:

                            // XON

                            xoff[buff.getByte(1)] = false;

                            if (verbose & LNK_DEBUG_LOG)

                                lout << "Link: got XON for channel "

                                     << buff.getByte(1) << endl;

                            // Transmit packets on hold queue

                            transmitHoldQueue(buff.getByte(1));

                            break;

                        default:

                            theNCP->receive(buff);

                    }

                } else

                    theNCP->receive(buff);


            } else {

                    sendAck(rxSequence);

                if (verbose & LNK_DEBUG_LOG)

                    lout << "Link: DUP\n";

            }

            break;


        case 0x00:

            // Incoming ack

            // Find corresponding packet in ackWaitQueue

            ackFound = false;

            struct timeval refstamp;

            pthread_mutex_lock(&queueMutex);

            for (i = ackWaitQueue.begin(); i != ackWaitQueue.end(); i++)

                if (i->seq == seq) {

                    ackFound = true;

                    refstamp = i->stamp;

                    ackWaitQueue.erase(i);

                    if (verbose & LNK_DEBUG_LOG) {

                        lout << "Link: << ack seq=" << seq ;

                        if (verbose & LNK_DEBUG_DUMP)

                            lout << " " << buff;

                        lout << endl;

                    }

                    break;

                }

            pthread_mutex_unlock(&queueMutex);

            if (ackFound) {

                if ((linkType == LINK_TYPE_UNKNOWN) && (seq == 0)) {

                    // If the remote device runs SIBO protocol, this ACK

                    // should be 0 (the Ack on our ReqReq request, which is

                    // treated as a normal Req by the SIBO machine.

                    failed = false;

                    linkType = LINK_TYPE_SIBO;

                    seqMask = 7;

                    maxOutstanding = 1;

                    rxSequence = 0;

                    txSequence = 1;

                    purgeAllQueues();

                    p->setEpoc(false);

                    if (verbose & LNK_DEBUG_LOG)

                        lout << "Link: 1-linkType set to " << linkType << endl;

                }

                // Older packets implicitely ack'ed

                multiAck(refstamp);

                // Transmit waiting packets

                transmitWaitQueue();

            } else {

                // If packet with seq+1 is in ackWaitQueue, resend it immediately

                // (Receiving an ack for a packet not on our wait queue is a

                // hint by the Psion about which was the last packet it

                // received successfully.)

                pthread_mutex_lock(&queueMutex);

                struct timeval now;

                gettimeofday(&now, NULL);

                bool nextFound = false;

                for (i = ackWaitQueue.begin(); i != ackWaitQueue.end(); i++)

                    if (i->seq == seq+1) {

                        nextFound = true;

                        if (i->txcount-- == 0) {

                            // timeout, remove packet

                            if (verbose & LNK_DEBUG_LOG)

                                lout << "Link: >> TRANSMIT timeout seq=" <<

                                    i->seq << endl;

                            ackWaitQueue.erase(i);

                            i--;

                        } else {

                            // retransmit it

                            i->stamp = now;

                            if (verbose & LNK_DEBUG_LOG)

                                lout << "Link: >> RETRANSMIT seq=" << i->seq

                                     << endl;

                            p->send(i->data);

                        }

                        break;

                    }

                pthread_mutex_unlock(&queueMutex);

                if ((verbose & LNK_DEBUG_LOG) && (!nextFound)) {

                    lout << "Link: << UNMATCHED ack seq=" << seq;

                    if (verbose & LNK_DEBUG_DUMP)

                        lout << " " << buff;

                    lout << endl;

                }

            }

            break;


        case 0x20:

            // New link

            conFound = false;

            if (seq > 3) {

                // May be a link confirm packet (EPOC)

                pthread_mutex_lock(&queueMutex);

                for (i = ackWaitQueue.begin(); i != ackWaitQueue.end(); i++)

                    if ((i->seq == 0) && (i->data.getByte(0) == 0x21)) {

                        ackWaitQueue.erase(i);

                        linkType = LINK_TYPE_EPOC;

                        if (verbose & LNK_DEBUG_LOG)

                            lout << "Link: 2-linkType set to " << linkType << endl;

                        conFound = true;

                        failed = false;

                        // EPOC can handle extended sequence numbers

                        seqMask = 0x7ff;

                        // EPOC can handle up to 8 unacknowledged packets

                        maxOutstanding = 8;

                        p->setEpoc(true);

                        if (verbose & LNK_DEBUG_LOG) {

                            lout << "Link: << con seq=" << seq ;

                            if (verbose & LNK_DEBUG_DUMP)

                                lout << " " << buff;

                            lout << endl;

                        }

                        break;

                    }

                pthread_mutex_unlock(&queueMutex);

            }

            if (conFound) {

                rxSequence = 0;

                txSequence = 1;

                sendAck(rxSequence);

            } else {

                if (verbose & LNK_DEBUG_LOG) {

                    lout << "Link: << req seq=" << seq;

                    if (verbose & LNK_DEBUG_DUMP)

                        lout << " " << buff;

                    lout << endl;

                }

                rxSequence = txSequence = 0;

                if (seq > 0) {

                    linkType = LINK_TYPE_EPOC;

                    if (verbose & LNK_DEBUG_LOG)

                        lout << "Link: 3-linkType set to " << linkType << endl;

                    // EPOC can handle extended sequence numbers

                    seqMask = 0x7ff;

                    // EPOC can handle up to 8 unacknowledged packets

                    maxOutstanding = 8;

                    p->setEpoc(true);

                    failed = false;

                    sendReqCon();

                } else {

                    // SIBO

                    linkType = LINK_TYPE_SIBO;

                    failed = false;

                    seqMask = 7;

                    maxOutstanding = 1;

                    if (verbose & LNK_DEBUG_LOG)

                        lout << "Link: 4-linkType set to " << linkType << endl;

                    rxSequence = 0;

                    txSequence = 1; // Our ReqReq was seq 0

                    purgeAllQueues();

                    p->setEpoc(false);

                    sendAck(rxSequence);

                }

            }

            break;


        case 0x10:

            // Disconnect

            if (verbose & LNK_DEBUG_LOG)

                lout << "Link: << DISC" << endl;

            failed = true;

            break;


        default:

            lerr << "Link: FATAL: Unknown packet type " << type << endl;

    }

}


void Link::

transmitHoldQueue(int channel)

{

    vector<bufferStore> tmpQueue;

    vector<bufferStore>::iterator i;


    // First, move desired packets to a temporary queue

    pthread_mutex_lock(&queueMutex);

    for (i = holdQueue.begin(); i != holdQueue.end(); i++)

        if (i->getByte(0) == channel) {

            tmpQueue.push_back(*i);

            holdQueue.erase(i);

            i--;

        }

    pthread_mutex_unlock(&queueMutex);


    // ... then transmit the moved packets

    for (i = tmpQueue.begin(); i != tmpQueue.end(); i++)

        transmit(*i);

}


void Link::

transmitWaitQueue()

{

    vector<bufferStore> tmpQueue;

    vector<bufferStore>::iterator i;


    // First, move desired packets to a temporary queue

    for (i = waitQueue.begin(); i != waitQueue.end(); i++)

        tmpQueue.push_back(*i);

    waitQueue.clear();

    // transmit the moved packets. If the backlock gets

    // full, they are put into waitQueue again.

    for (i = tmpQueue.begin(); i != tmpQueue.end(); i++)

        transmit(*i);

}


void Link::

transmit(bufferStore buf)

{

    if (hasFailed())

        return;


    int remoteChan = buf.getByte(0);

    if (xoff[remoteChan]) {

        pthread_mutex_lock(&queueMutex);

        holdQueue.push_back(buf);

        pthread_mutex_unlock(&queueMutex);

    } else {


        // If backlock is full, put on waitQueue

        int ql;

        pthread_mutex_lock(&queueMutex);

        ql = ackWaitQueue.size();

        pthread_mutex_unlock(&queueMutex);

        if (ql >= maxOutstanding) {

            waitQueue.push_back(buf);

            return;

        }


        ackWaitQueueElement e;

        e.seq = txSequence++;

        txSequence &= seqMask;

        gettimeofday(&e.stamp, NULL);

        // An empty buffer is considered a new link request

        if (buf.empty()) {

            // Request for new link

            e.txcount = 4;

            if (verbose & LNK_DEBUG_LOG)

                lout << "Link: >> req seq=" << e.seq << endl;

            buf.prependByte(0x20 + e.seq);

        } else {

            e.txcount = 8;

            if (verbose & LNK_DEBUG_LOG) {

                lout << "Link: >> dat seq=" << e.seq;

                if (verbose & LNK_DEBUG_DUMP)

                    lout << " " << buf;

                lout << endl;

            }

            if (e.seq > 7) {

                int hseq = e.seq >> 3;

                int lseq = 0x30 + ((e.seq & 7) | 8);

                int seq = (hseq << 8) + lseq;

                buf.prependWord(seq);

            } else

                buf.prependByte(0x30 + e.seq);

        }

        e.data = buf;

        pthread_mutex_lock(&queueMutex);

        ackWaitQueue.push_back(e);

        pthread_mutex_unlock(&queueMutex);

        p->send(buf);

    }

}


static void

timesub(struct timeval *tv, unsigned long millisecs)

{

    uint64_t micros = tv->tv_sec;

    uint64_t sub = millisecs;


    micros <<= 32;

    micros += tv->tv_usec;

    micros -= (sub * 1000);

    tv->tv_usec = micros & 0xffffffff;

    tv->tv_sec  = (micros >>= 32) & 0xffffffff;

}


static bool

olderthan(struct timeval t1, struct timeval t2)

{

    uint64_t m1 = t1.tv_sec;

    uint64_t m2 = t2.tv_sec;

    m1 <<= 32;

    m2 <<= 32;

    m1 += t1.tv_usec;

    m2 += t2.tv_usec;

    return (m1 < m2);

}


void Link::

multiAck(struct timeval refstamp)

{

    vector<ackWaitQueueElement>::iterator i;

    pthread_mutex_lock(&queueMutex);

    for (i = ackWaitQueue.begin(); i != ackWaitQueue.end(); i++)

        if (olderthan(i->stamp, refstamp)) {

            ackWaitQueue.erase(i);

            i--;

        }

    pthread_mutex_unlock(&queueMutex);

}


void Link::

retransmit()

{


    if (hasFailed()) {

        purgeAllQueues();

        return;

    }


    pthread_mutex_lock(&queueMutex);

    vector<ackWaitQueueElement>::iterator i;

    struct timeval now;

    gettimeofday(&now, NULL);

    struct timeval expired = now;

    timesub(&expired, retransTimeout());

    for (i = ackWaitQueue.begin(); i != ackWaitQueue.end(); i++)

        if (olderthan(i->stamp, expired)) {

            if (i->txcount-- == 0) {

                // timeout, remove packet

                if (verbose & LNK_DEBUG_LOG)

                    lout << "Link: >> TRANSMIT timeout seq=" << i->seq << endl;

                ackWaitQueue.erase(i);

                failed = true;

                i--;

            } else {

                // retransmit it

                i->stamp = now;

                if (verbose & LNK_DEBUG_LOG)

                    lout << "Link: >> RETRANSMIT seq=" << i->seq << endl;

                p->send(i->data);

            }

        }

    pthread_mutex_unlock(&queueMutex);

}


void Link::

flush() {

    while (stuffToSend())

        sleep(1);

}


bool Link::

stuffToSend()

{

    return ((!failed) && (!ackWaitQueue.empty()));

}


bool Link::

hasFailed()

{

    bool lfailed = p->linkFailed();

    if (failed || lfailed) {

        if (verbose & LNK_DEBUG_LOG)

            lout << "Link: hasFailed: " << failed << ", " << lfailed << endl;

    }

    failed |= lfailed;

    return failed;

}


Enum<Link::link_type> Link::

getLinkType()

{

    return linkType;

}


int Link::

getSpeed()

{

    return p->getSpeed();

}

ENUM_DEFINITION_END
#define ENUM_DEFINITION_END(EnumName)
Definition: Enum.h:304

ENUM_DEFINITION_BEGIN
#define ENUM_DEFINITION_BEGIN(EnumName, initWith)
Helper macro to construct an enumeration wrapper Enum<E> for a specific enum type.
Definition: Enum.h:299

bufferarray.h

bufferstore.h

Enum
Wrapper class featuring range-checking and string representation of enumerated values.
Definition: Enum.h:136

Link
Definition: link.h:63

Link::reset
void reset()
Reset connection and attempt to reconnect to the peer.
Definition: link.cc:101

Link::waitQueue
std::vector< bufferStore > waitQueue
Definition: link.h:196

Link::getVerbose
unsigned short getVerbose()
Get current verbosity of Link.
Definition: link.cc:117

Link::transmit
void transmit(bufferStore buf)
Definition: link.cc:505

Link::ackWaitQueue
std::vector< ackWaitQueueElement > ackWaitQueue
Definition: link.h:194

Link::flush
void flush()
Wait, until all outstanding packets are acknowledged or timed out.
Definition: link.cc:636

Link::p
packet * p
Definition: link.h:184

Link::conMagic
unsigned long conMagic
Definition: link.h:189

Link::send
void send(const bufferStore &buff)
Send a PLP packet to the Peer.
Definition: link.cc:130

Link::linkType
Enum< link_type > linkType
Definition: link.h:192

Link::txSequence
int txSequence
Definition: link.h:185

Link::queueMutex
pthread_mutex_t queueMutex
Definition: link.h:181

Link::theNCP
NCP * theNCP
Definition: link.h:183

Link::~Link
~Link()
Disconnects from device and destroys instance.
Definition: link.cc:85

Link::getLinkType
Enum< link_type > getLinkType()
Get the current link type.
Definition: link.cc:660

Link::xoff
bool xoff[256]
Definition: link.h:197

Link::purgeQueue
void purgeQueue(int channel)
Purge all outstanding packets for a specified remote channel.
Definition: link.cc:148

Link::seqMask
int seqMask
Definition: link.h:187

Link::getSpeed
int getSpeed()
Get current speed of the serial device.
Definition: link.cc:666

Link::sendReqReq
void sendReqReq()
Definition: link.cc:206

Link::retransmit
void retransmit()
Definition: link.cc:601

Link::receive
void receive(bufferStore buf)
Effectively a delegate method that accepts data from our packet instance.
Definition: link.cc:239

Link::transmitHoldQueue
void transmitHoldQueue(int channel)
Definition: link.cc:468

Link::multiAck
void multiAck(struct timeval)
Definition: link.cc:588

Link::verbose
unsigned short verbose
Definition: link.h:190

Link::maxOutstanding
int maxOutstanding
Definition: link.h:188

Link::hasFailed
bool hasFailed()
Query connection failure.
Definition: link.cc:648

Link::link_type
link_type
Definition: link.h:66

Link::LINK_TYPE_UNKNOWN
@ LINK_TYPE_UNKNOWN
Definition: link.h:67

Link::LINK_TYPE_SIBO
@ LINK_TYPE_SIBO
Definition: link.h:68

Link::LINK_TYPE_EPOC
@ LINK_TYPE_EPOC
Definition: link.h:69

Link::sendReqCon
void sendReqCon()
Definition: link.cc:185

Link::holdQueue
std::vector< bufferStore > holdQueue
Definition: link.h:195

Link::transmitWaitQueue
void transmitWaitQueue()
Definition: link.cc:489

Link::sendAck
void sendAck(int seq)
Definition: link.cc:167

Link::rxSequence
int rxSequence
Definition: link.h:186

Link::failed
bool failed
Definition: link.h:191

Link::retransTimeout
unsigned long retransTimeout()
Definition: link.cc:95

Link::setVerbose
void setVerbose(unsigned short _verbose)
Set verbosity of Link and underlying packet instance.
Definition: link.cc:123

Link::stuffToSend
bool stuffToSend()
Query outstanding packets.
Definition: link.cc:642

Link::purgeAllQueues
void purgeAllQueues()
Definition: link.cc:139

Link::sendReq
void sendReq()
Definition: link.cc:226

Link::checkthread
pthread_t checkthread
Definition: link.h:180

NCP
Definition: ncp.h:54

NCP::receive
void receive(bufferStore s)
Definition: ncp.cc:118

bufferStore
A generic container for an array of bytes.
Definition: bufferstore.h:37

bufferStore::discardFirstBytes
void discardFirstBytes(int len=0)
Removes bytes from the start of the buffer.
Definition: bufferstore.cc:143

bufferStore::addByte
void addByte(unsigned char c)
Appends a byte to the content of this instance.
Definition: bufferstore.cc:159

bufferStore::prependByte
void prependByte(unsigned char c)
Prepends a byte to the content of this instance.
Definition: bufferstore.cc:212

bufferStore::prependWord
void prependWord(int w)
Prepends a word to the content of this instance.
Definition: bufferstore.cc:218

bufferStore::empty
bool empty() const
Tests if the bufferStore is empty.
Definition: bufferstore.h:258

bufferStore::addDWord
void addDWord(long dw)
Appends a dword to the content of this instance.
Definition: bufferstore.cc:199

bufferStore::getLen
unsigned long getLen() const
Retrieves the length of a bufferStore.
Definition: bufferstore.cc:94

bufferStore::getByte
unsigned char getByte(long pos=0) const
Retrieves the byte at index pos.
Definition: bufferstore.cc:98

channel
Definition: channel.h:32

packet
Definition: packet.h:38

packet::getSpeed
int getSpeed()
Definition: packet.cc:293

packet::send
void send(bufferStore &b)
Send a buffer out to serial line.
Definition: packet.cc:299

packet::setEpoc
void setEpoc(bool)
Definition: packet.cc:287

packet::linkFailed
bool linkFailed()
Definition: packet.cc:486

packet::reset
void reset()
Definition: packet.cc:225

packet::setVerbose
void setVerbose(short int)
Definition: packet.cc:281

add
stringRep add(Link::LINK_TYPE_UNKNOWN, N_("Unknown"))

olderthan
static bool olderthan(struct timeval t1, struct timeval t2)
Definition: link.cc:576

timesub
static void timesub(struct timeval *tv, unsigned long millisecs)
Definition: link.cc:563

expire_check
static void * expire_check(void *arg)
Definition: link.cc:40

link.h

std
Definition: doctest.h:522

ncp.h

ncp_log.h

lerr
std::ostream lerr

LNK_DEBUG_LOG
#define LNK_DEBUG_LOG
Definition: ncp_log.h:31

lout
std::ostream lout

LNK_DEBUG_DUMP
#define LNK_DEBUG_DUMP
Definition: ncp_log.h:32

packet.h

N_
#define N_(String)
Definition: plpintl.h:36

verbose
int verbose
Definition: plpprintd.cc:58

ackWaitQueueElement
Describes a transmitted packet which has not yet been acknowledged by the peer.
Definition: link.h:40

ackWaitQueueElement::stamp
struct timeval stamp
Time of last transmit.
Definition: link.h:52

ackWaitQueueElement::seq
int seq
Original sequence number.
Definition: link.h:44

ackWaitQueueElement::data
bufferStore data
Packet content.
Definition: link.h:56

ackWaitQueueElement::txcount
int txcount
Number of remaining transmit retries.
Definition: link.h:48