NetBIOS

/* Copyright 1998 Acorn Computers Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
*
*  NETBIOS.C  -- NetBIOS name-service functions
*
*  14-02-94 INH  Original
*                AcksNeeded altered
*
*
*/

/* Standard includes */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "kernel.h"

/* Our includes */

#include "stdtypes.h"
#include "buflib.h"
#include "stats.h"
#include "llc.h"
#include "netbios.h"
#include "lmvars.h"

#define EXPORT static

/* Timeouts ************ */

#define ADD_NAME_TIME     50
#define ADD_NAME_TRIES     3
#define FIND_NAME_TIME    50
#define FIND_NAME_TRIES    5
#define OPEN_SESS_TIME  1000
#define ACK_SEND_TIME     50   /* Timeout before sending ACK */
#define ACK_WAIT_TIME   1000   /* Time to wait for ACK before failing */


/* Frame types ***************** */

#define ADD_GROUP_NAME_QUERY 0x00
#define ADD_NAME_QUERY       0x01
#define NAME_IN_CONFLICT     0x02
#define STATUS_QUERY         0x03
#define DATAGRAM             0x08
#define DATAGRAM_BROADCAST   0x09
#define NAME_QUERY           0x0A
#define ADD_NAME_RESPONSE    0x0D
#define NAME_RECOGNISED      0x0E
#define STATUS_RESPONSE      0x0F
#define DATA_ACK             0x14
#define DATA_FIRST_MIDDLE    0x15
#define DATA_ONLY_LAST       0x16
#define SESSION_CONFIRM      0x17
#define SESSION_END          0x18
#define SESSION_INITIALISE   0x19
#define NO_RECEIVE           0x1A
#define RECEIVE_OUTSTANDING  0x1B
#define RECEIVE_CONTINUE     0x1C
#define SESSION_ALIVE        0x1F

#define NETBIOS_SAP 0xF0

/* Private structures / definitions ************ */

/* ---------------- */

struct status_resp  /* Structure used to process STATUS_RESPOMSE */
{
  int    nt_search;           /* Name-type to respond to */
  struct FindName_res *pRes;  /* Pointer to result buf */
  int    spaces_left;         /* Space left in result buf */
};


/* Entries in name table: datagram-type packets come from and and
   directed at these names */

/* Status values */

#define NS_FREE      0
#define NS_AWAIT_ADD 1
#define NS_NAME_OK   2
#define NS_ADD_FAIL  4
#define NS_RECEIVING 8   /* Able to receive datagrams */

struct _NBsession; /* ... is coming up soon */

typedef struct
{
  int       Status;
  NETNAME   Name;

  struct _NBsession  *pS_call;   /* For when we're calling & awaiting
                                   reply from far end */
  struct _NBsession  *pS_listen; /* For when we're waiting for a call
             	    		   from someone else */

  struct status_resp *pStatResp;  /* Status-response state */

  BUFQUEUE  DatagramQ;            /* Queue for incoming datagrams */
}
  NAME_ENTRY;

/* Entry in session table: there is one session for each connection
   between us and another end */

#define SS_FREE         0
#define SS_CALLING      1  /* Calling far end */
#define SS_CALL_WAIT    2  /* Done NAME_RESPONSE, await LLC connect */
#define SS_LISTENING    4  /* Waiting for call from far end */
#define SS_LISTEN_RDY   8  /* Done NAME_QUERY, ready for LLC connect */
#define SS_CONNECTED    16 /* Connected */


typedef struct _NBsession
{
  /* General session state */
  int         Status;

  NAME_ENTRY *LclName;       /* Local name at this end */
  int         LclLSN;

  NETADDR     RmtAddr;       /* Address of far end */
  NETNAME     RmtName;       /* Name at far end */
  int         RmtLSN;

  HCONN       hconn;          /* LLC connection handle */

  /* Connection/sequencing status */
  int         xmitsize;       /* Max transmit size in one pkt */
  BUFCHAIN    PartialRcv;     /* Used for assembling larger pkts */
  BUFQUEUE    RcvQ;           /* Complete receive messages */
  int         next_resp;      /* Next 'response' value to use */
  int         next_xmit;      /* Next 'xmit' value to send */
  bool        ack_pending;    /* True if we need to send data ack */
  struct Timer AckTimer;      /* Timer for sending DATA_ACK */
  bool        ack_required;   /* True if we should wait for DATA_ACK
                                   before sending any more data */
} NBSESSION;


/* ------------------------------------ */

/* Note: These structures are sailing reasonably close to the
   wind by assuming that the compiler will pack the BYTEs and
   WORDs properly. All groups of bytes, 16-bit words and
   network names do start on longword boundaries, so it isn't
   technically incorrect.
*/
typedef struct
{
  WORD len;
  WORD delim;

  BYTE cmd;
  BYTE opt1;
  BYTE opt2lo;
  BYTE opt2hi;

  WORD resp;
  WORD xmit;

  BYTE dst_sn;       /* Remote session number */
  BYTE src_sn;       /* Local session  number */
}
  NB_SHORTHDR;

typedef struct
{
  WORD len;
  WORD delim;

  BYTE cmd;
  BYTE opt1;
  BYTE opt2lo;
  BYTE opt2hi;

  WORD resp;
  WORD xmit;

  NETNAME dst_name;       /* Remote session number */
  NETNAME src_name;       /* Local session  number */
}
  NB_LONGHDR;

/* Globals =========================================== */

static NETADDR Multi_Addr = { 0x03, 0x00, 0x00, 0x00, 0x00, 0x01 };

#define MAX_NAMES 16
static NAME_ENTRY NB_NameTable[MAX_NAMES];

#define MAX_SESSIONS 16
static NBSESSION NB_SessionTbl[MAX_SESSIONS];

static NB_SHORTHDR SHdr;
static NB_LONGHDR  LHdr;
static int NB_MaxSize;

/* Support functions ======================================== */

#ifdef DEBUG
static void debug_name ( NETNAME *nn )
{
  char lclbuf[17];
  memcpy (lclbuf, nn, 16);
  lclbuf[16] = 0;
  debug1("<%s>", lclbuf);
}
#else
#define debug_name(a)
#endif

/* ----------------- */

static NBSESSION *LSNtoSession (int LSN)
{
  if ( LSN <= 0 || LSN > MAX_SESSIONS ) return NULL;

  return &NB_SessionTbl [LSN-1];
}

/* ----------------- */

static NAME_ENTRY *ValidatehName( hNAME hName )
{
  NAME_ENTRY *pN = (NAME_ENTRY *)hName;
  if ( pN != NULL && pN->Status == NS_NAME_OK )
    return pN;

  return NULL;
}
/* ----------------- */

static NBSESSION *ValidatehSession( hSESSION hSess )
{
  NBSESSION *pN = (NBSESSION *)hSess;
  if ( pN != NULL && pN->Status == SS_CONNECTED )
    return pN;

  return NULL;
}

/* Exported procedures ------------------------------------ */

EXPORT bool _NB_LinkOK ( hSESSION hS )
{
  NBSESSION *pN = (NBSESSION *)hS;
  return (bool) ( pN != NULL && pN->Status == SS_CONNECTED &&
             LLC_LinkOK (pN->hconn) );
}

/* -------------------- */

EXPORT bool _NB_MatchName ( NETNAME *nn1, NETNAME *nn2 )
{
  return (bool) ( nn1->c4[0] == nn2->c4[0] &&
           nn1->c4[1] == nn2->c4[1] &&
           nn1->c4[2] == nn2->c4[2] &&
           nn1->c4[3] == nn2->c4[3] );
}

/* -------------------- */

static NAME_ENTRY *FindName ( NETNAME *nn, int flags )
{
  int i;

  if ( flags == NS_FREE )
  {
    for ( i=0; i < MAX_NAMES; i++ )
      if ( NB_NameTable[i].Status == NS_FREE )
        return &NB_NameTable[i];
  }
  else
  {
    for ( i=0; i < MAX_NAMES; i++ )
      if ( (NB_NameTable[i].Status & flags) != 0    &&
           _NB_MatchName ( nn, &NB_NameTable[i].Name ) )
        return &NB_NameTable[i];
  }

  return NULL;
}

/* --------------------- */

EXPORT err_t _NB_FormatName ( nametype_t nt, char *name, NETNAME *res )
{
  int i;

  for ( i=0; i<15; i++)
  {
    if ( name[i] <= 0x20 ) break;
    res->b[i] = toupper(name[i]);
  }

  while (i<15)
    res->b[i++] = 0x20;

  res->b[15] = nt;
  return OK;
}

/* --------------------- */

EXPORT nametype_t _NB_DecodeName ( NETNAME *pnn, char *buf )
{
  BYTE *p = pnn->b;

  while ( *p > 0x20 )
    *buf++ = *p++;

  *buf = 0;

  return (nametype_t) (pnn->b[15]);
}

/* ----------------------- */

static void SendDatagram (int Cmd, NETADDR *pnaDest,
        NETNAME *pnnDest, NETNAME *pnnSource, int Opt1, int Opt2,
        int Resp )
{
  BUFCHAIN pB;

  debug1("SendDatagram called: command %x\n",Cmd);

  LHdr.len   = 0x002C;
  LHdr.delim = 0xEFFF;
  LHdr.cmd   = Cmd;
  LHdr.opt1  = Opt1;
  LHdr.opt2lo= Opt2 & 0xFF;
  LHdr.opt2hi= Opt2 >> 8;
  LHdr.resp  = Resp;
  LHdr.xmit  = 0;
  if ( pnnSource != NULL )
    LHdr.src_name  = *pnnSource;
  if ( pnnDest != NULL )
    LHdr.dst_name  = *pnnDest;

  pB = AddChain ( NULL, &LHdr, 0x2C );
  if ( pB != NULL )
    UI_SendData ( pnaDest, NETBIOS_SAP, pB );
}

/* ----------------------- */

static void ProcessStatusResp ( struct status_resp *pSR,
   int nnames, BUFCHAIN pData )
{
  BYTE buf[18];

  /* Strip off header */
  pData = GetData ( pData, NULL, 0x3C );

  while ( pSR->spaces_left > 0 &&
          nnames -- > 0 )
  {
    pData = GetData ( pData, buf, 0x12 );
    if ( pData == NULL ) break;

    if ( pSR->nt_search == ANY_NAME_TYPE ||
         pSR->nt_search == buf[15] )
    {
      memcpy ( &(pSR->pRes->name), buf, 16 );
      pSR->pRes->type = (nametype_t) buf[15];
      pSR->pRes->flags = buf[17];
      pSR->spaces_left--;
      pSR->pRes++;
    }
  }

  FreeChain(pData);
}

/* NetBIOS name management functions ============================== */

static void NB_ReceiveDatagram ( NETADDR *src, BUFCHAIN Data, void *pw )
{
  NAME_ENTRY *pDN;
  static NB_LONGHDR  RLHdr;

  (void) pw;

  /* Read in header & check format */

  Data = GetData ( Data, &RLHdr, 0x2C );
  if ( Data == NULL )
    return;

  if ( RLHdr.len != 0x2C || RLHdr.delim != 0xEFFF )
    goto DumpIt;

  /* Deal with command */

  switch ( RLHdr.cmd )
  {
    case DATAGRAM:
    case DATAGRAM_BROADCAST:
      pDN = FindName ( &RLHdr.dst_name, NS_NAME_OK );
      if ( pDN != NULL && (pDN->Status & NS_RECEIVING) )
      {
        /* This facility is currently unused by the rest of
           LanManFS. In fact just sticking 'Data' in a queue
           is a pretty poor way of doing it, because we don't
           carry the name of the sender of the data along with
           us. */
        QueueAdd( &(pDN->DatagramQ), Data );
        return;  /* Don't need to free chain! */
      }

      break;

    case NAME_QUERY:  /* Trying to call us */
      pDN = FindName ( &RLHdr.dst_name, NS_NAME_OK );
      if ( pDN != NULL && pDN->pS_listen != NULL )
      {
        NBSESSION *pS = pDN->pS_listen;

        if ( pS->Status & SS_LISTENING )
        {
          pS->RmtAddr = *src;
          pS->RmtName = RLHdr.src_name;
          pS->RmtLSN  = RLHdr.opt2lo;

          SendDatagram ( NAME_RECOGNISED, src, &RLHdr.src_name,
                 &(pDN->Name), 0, pS->LclLSN, RLHdr.xmit );

          pS->Status = SS_LISTEN_RDY;
        } /* We don't do any more of this at present; need to
             add code to LLC to accept incoming calls */
      }
      break;

    case NAME_RECOGNISED:  /* Response to a name query */
      pDN = FindName ( &RLHdr.dst_name, NS_NAME_OK );
      if ( pDN != NULL && pDN->pS_call != NULL )
      {
        NBSESSION *pS = pDN->pS_call;

        if ( !_NB_MatchName ( &RLHdr.src_name, &pS->RmtName ) )
          break;  /* Crank call? */

        if ( pS->Status & SS_CALLING )
        {
          pS->RmtAddr= *src;
          pS->RmtLSN = RLHdr.opt2lo;  /* Copy session number */
          pS->Status = SS_CALL_WAIT;
        }
      }
      break;

    case ADD_GROUP_NAME_QUERY:  /* Does any other machine have this name? */
    case ADD_NAME_QUERY:
      pDN = FindName (&RLHdr.src_name, NS_NAME_OK | NS_AWAIT_ADD);
      if ( pDN != NULL )
        SendDatagram( ADD_NAME_RESPONSE, src, &RLHdr.src_name,
             &RLHdr.src_name, 0, 0, RLHdr.xmit ) ;
      break;

    case NAME_IN_CONFLICT:    /* Reply to ADD_NAME_QUERY: we can't use */
    case ADD_NAME_RESPONSE:   /* this name */
      pDN = FindName (&RLHdr.dst_name, NS_AWAIT_ADD);
      if ( pDN != NULL )
        pDN->Status = NS_ADD_FAIL;
      break;

    case STATUS_RESPONSE:
      pDN = FindName ( &RLHdr.dst_name, NS_NAME_OK );
      if ( pDN != NULL && pDN->pStatResp != NULL )
      {
        ProcessStatusResp ( pDN->pStatResp, RLHdr.opt1, Data );
        return;
      }
      break;

    case STATUS_QUERY:
      debug0("Status query");
      break;

    default:
      break;
  }

DumpIt:
  FreeChain ( Data );

}

/* ---------------------- */

static bool CheckNameUnique ( NAME_ENTRY *pN )
{
  int Timer;

  pN->Status = NS_AWAIT_ADD;
  SendDatagram ( ADD_NAME_QUERY, &Multi_Addr, NULL, &pN->Name, 0, 0, 0 );

  Timer = LLC_TickerTime;

  /* Wait 1 second for reply */

  do
  {
    LLC_BackgroundProcess();
    if ( pN->Status == NS_ADD_FAIL )
    {
      pN->Status = NS_FREE;
      return false;
    }
  }
  while ((LLC_TickerTime-Timer) < ADD_NAME_TIME);

  return true;
}

/* NB_AddLocalName() --------------------------------------------

   Adds a local name, and checks with the network that it is unique.
*/

EXPORT err_t _NB_AddLocalName ( nametype_t nt, char *name, hNAME *phName )
{
  NAME_ENTRY *pN;
  NETNAME  myname;
  int i;

  _NB_FormatName (  nt, name, &myname ); /* Convert to 16-byte format */

  pN = FindName ( &myname, NS_NAME_OK );
  if ( pN != NULL )
    return ENAMEEXISTS;

  pN = FindName ( NULL, NS_FREE );
  if ( pN == NULL )
    return ENOHANDLES;

  pN->Name = myname;

  for (i=0; i<3; i++)
  {
    if ( !CheckNameUnique(pN) )
    {
      debug0("  Name already exists\n");
      return ENAMEEXISTS;
    }
  }

  pN->Status  = NS_NAME_OK;
  pN->pS_call    = NULL;
  pN->pS_listen  = NULL;
  pN->pStatResp  = NULL;
  pN->DatagramQ.Head = NULL;
  pN->DatagramQ.Last = NULL;
  *phName = (hNAME) pN;

  return OK;
}

/* NB_RemoveLocalName() --------------------------------------------

   Removes a local name from the table.
   Any connections to this name get vaped!
*/
EXPORT err_t _NB_CloseSession ( hSESSION hSession ); /* Forward reference */

EXPORT err_t _NB_RemoveLocalName ( hNAME hName )
{
  int i;
  NBSESSION *pS;
  NAME_ENTRY *pN = ValidatehName(hName);

  if ( pN == NULL )
    return EBADPARAM;

  for ( i=1; i<=MAX_SESSIONS; i++ )
  {
    pS = LSNtoSession(i);
    if ( (pS->Status == SS_CONNECTED)  &&
         (pS->LclName == pN)
       )
    {
      _NB_CloseSession(pS);
    }
  }

  QueueFlush(&(pN->DatagramQ));

  pN->Status = NS_FREE;
  return OK;
}


/* NB_FindNames () ----------------------------------------- */

EXPORT int _NB_FindNames (   NETNAME *pnnFind,
                     nametype_t ntFind,
                     struct FindName_res *pResults,
                     int results_max,
                     int timeout )
{
  struct status_resp SR;
  int    Timer;
  NAME_ENTRY *pN = ValidatehName ( NB_MachineName );

  if ( pN == NULL )
    return 0;

  SR.nt_search   = ntFind;
  SR.pRes        = pResults;
  SR.spaces_left = results_max;

  pN->pStatResp = &SR;
  SendDatagram ( STATUS_QUERY, &Multi_Addr, pnnFind, &pN->Name,
     0x1, 0x15C, 0 );

  Timer = LLC_TickerTime;

  do
  {
    LLC_BackgroundProcess();
  }
    while ( (SR.spaces_left > 0)  &&
            ((LLC_TickerTime - Timer) < timeout ) );

  pN->pStatResp = NULL;
  return results_max - SR.spaces_left;
}

/* Connection-oriented functions =================================== */

static void ClearUp ( NBSESSION *pS )
{
  QueueFlush ( &pS->RcvQ );
  TimerClear ( &pS->AckTimer );
  if ( pS->PartialRcv != NULL )
    FreeChain(pS->PartialRcv);
  pS->PartialRcv = NULL;
}

/* ----------------- */

static void SendAlive ( NBSESSION *pS )
{
  BUFCHAIN pB;

  SHdr.len   = 0x0E;
  SHdr.delim = 0xEFFF;
  SHdr.cmd   = SESSION_ALIVE;
  SHdr.opt1  = 0;
  SHdr.opt2lo= 0;
  SHdr.opt2hi= 0;
  SHdr.resp  = 0;
  SHdr.xmit  = 0;
  SHdr.dst_sn = pS->RmtLSN;
  SHdr.src_sn  = pS->LclLSN;

  pB = AddChain ( NULL, &SHdr, 0x0E );

  if ( pB != NULL )
    LLC_SendData ( pS->hconn, pB );
}

/* ----------------------- */

static bool EnsureAcks ( NBSESSION *pS )
{
  BUFCHAIN pB;

  if ( !pS->ack_pending )
    return true;

  /* Send ACK to far end */

  SHdr.len   = 0x0E;
  SHdr.delim = 0xEFFF;
  SHdr.cmd   = DATA_ACK;
  SHdr.opt1  = 0;
  SHdr.opt2lo= 0;
  SHdr.opt2hi= 0;
  SHdr.resp  = pS->next_resp;
  SHdr.xmit  = 0;
  SHdr.dst_sn = pS->RmtLSN;
  SHdr.src_sn = pS->LclLSN;

  pB = AddChain ( NULL, &SHdr, 0x0E );

  if ( pB != NULL &&
       LLC_SendData( pS->hconn, pB ) == OK )
  {
    pS->ack_pending = false;
    pS->next_resp = 0;
    return true;
  }

  debug0 (" Couldn't send ack! ");
  return false;
}

/* --------------------- */

/* This is called when a data ack timer expires */

static void AckTimerCallback ( void *data )
{
  NBSESSION *pS = (NBSESSION *)data;

  /* This will retry indefinitely if EnsureAcks fails */

  if ( pS->Status == SS_CONNECTED )
  {
    if ( !EnsureAcks(pS) )
      TimerStart ( &pS->AckTimer, ACK_SEND_TIME );
  }
}

/* --------------------- */

/* This waits for an ACK from the other end, if it is needed */

static bool WaitForAck ( NBSESSION *pS )
{
  int t = LLC_TickerTime;

  while ( pS->ack_required )
  {
    LLC_BackgroundProcess();

    if ( LLC_TickerTime - t > ACK_WAIT_TIME )
      return false;
  }

  return true;
}

/* ----------------------------------------- */

/* LinkRxFn processes incoming data on a link. */

static void NB_LinkRxFn ( HCONN hc, BUFCHAIN Data, void *private )
{
  static NB_SHORTHDR RSHdr;
  NBSESSION *pS;
  (void) hc;
  (void) private;

  Data = GetData ( Data, &RSHdr, 0x0E );
  if ( Data == NULL )  /* Barf! */
    return;

  if ( RSHdr.delim != 0xEFFF )
    goto DumpIt;

  pS = LSNtoSession(RSHdr.dst_sn);
  if ( pS == NULL ||
       (pS->Status & (SS_CONNECTED | SS_CALL_WAIT)) == 0 )
    goto DumpIt;

  debug1(" Rx-NB-%X", RSHdr.cmd );

  switch ( RSHdr.cmd )
  {
    case SESSION_CONFIRM:
      pS->RmtLSN = RSHdr.src_sn; /* Should be already! */
      pS->xmitsize = RSHdr.opt2lo + (RSHdr.opt2hi << 8);
      if ( pS->xmitsize == 0 || pS->xmitsize > NB_MaxSize )
        pS->xmitsize = NB_MaxSize;

      pS->Status = SS_CONNECTED;
      break;

    case DATA_FIRST_MIDDLE:
      pS->PartialRcv = ConcatChain ( pS->PartialRcv, Data );
      return; /* Don't deallocate */

    case DATA_ONLY_LAST:
      pS->next_resp = RSHdr.xmit;
      pS->ack_pending = true;
      pS->ack_required = false;
      TimerStart ( &pS->AckTimer, ACK_SEND_TIME );
      QueueAdd ( &pS->RcvQ, ConcatChain( pS->PartialRcv, Data ) );
      pS->PartialRcv = NULL;

      return; /* Don't deallocate buffers */

    case SESSION_ALIVE:
      SendAlive(pS);
      break;

    case DATA_ACK:
      pS->ack_required = false;
      break;

    default:
      break;
  }

DumpIt:
  FreeChain ( Data );
}
/* -------------------------------- */

/* FindRemoteName does a network name query for a given name;
   this will find its network address, and also exchange
   Local Session Numbers prior to making a connection.
*/

static err_t FindRemoteName ( NBSESSION *pS )
{
  int i, Timer;

  pS->Status = SS_CALLING;

  for ( i=0; i< FIND_NAME_TRIES; i++ )
  {
    Timer = LLC_TickerTime;
    SendDatagram ( NAME_QUERY, &Multi_Addr, &(pS->RmtName),
                     &(pS->LclName->Name), 0, pS->LclLSN, 0 );

    do
    {
      LLC_BackgroundProcess();
      /* Wait for return datagram to fill in address & RmtLSN */
      if ( pS->Status == SS_CALL_WAIT )
        return OK;
    }
      while ( (LLC_TickerTime - Timer) < FIND_NAME_TIME );
  }

  /* Failed to find name */
  return ECANTFINDNAME;
}

/* ------------------------------------ */

EXPORT err_t _NB_OpenSession ( hNAME hThisEnd, NETNAME *pnnFarEnd,
                             hSESSION *phSession )
{
  err_t   res;
  HCONN   hc;
  int     i, timer;

  BUFCHAIN pB;
  NBSESSION *pS;
  NAME_ENTRY *pnLcl = ValidatehName(hThisEnd);

  if ( pnLcl == NULL || pnnFarEnd == NULL )
    return EBADPARAM;

  /* (ii) Find a suitable session number */

  for ( i=1; i <= MAX_SESSIONS; i++ )
  {
    pS = LSNtoSession(i);
    if ( pS->Status == SS_FREE )
      goto GotSession;
  }
  return ENOHANDLES;

GotSession:
  /* (iii) Do a network find-name query */

  NB_MaxSize = LLC_GetMTU() - 14;

  debug0("Call: "); debug_name(&(pnLcl->Name));
  debug0("--> "); debug_name(pnnFarEnd);

  pS->RmtName = *pnnFarEnd;
  pS->LclName = pnLcl;
  pnLcl->pS_call = pS;

  res = FindRemoteName ( pS );
  pnLcl->pS_call = NULL;

  if ( res != OK )
    goto abort_find;

  /* (iv) Try to open an LLC connection */

  res = LLC_OpenLink ( &pS->RmtAddr, NETBIOS_SAP, NB_LinkRxFn,
              NULL, &hc );

  if ( res != OK )
    goto abort_find;

  /* Initialise fields */

  pS->hconn = hc;
  pS->next_xmit = 1;
  pS->next_resp = 0;
  pS->ack_pending = false;
  pS->ack_required = false;
  ClearUp ( pS );  /* Clear queues, etc, just in case */

  /* Send SESSION_INIT to other end */

  SHdr.len   = 0x0E;
  SHdr.delim = 0xEFFF;
  SHdr.cmd   = SESSION_INITIALISE;
  SHdr.opt1  = 0x8F;         /* Various flags - ?? */
  SHdr.opt2lo= NB_MaxSize & 0xFF;
  SHdr.opt2hi= NB_MaxSize >> 8;
  SHdr.resp  = 0;
  SHdr.xmit  = 0;
  SHdr.dst_sn = pS->RmtLSN;
  SHdr.src_sn  = pS->LclLSN;

  pB = AddChain ( NULL, &SHdr, 0x0E );
  if ( pB == NULL )
  {
    res = EOUTOFMEM;
    goto abort_conn;
  }

  res = LLC_SendData ( hc, pB );
  if ( res != OK )
    goto abort_conn;

  /* Wait for SESSION_CONFIRM */

  timer = LLC_TickerTime;

  while ( pS->Status != SS_CONNECTED )
  {
    LLC_BackgroundProcess();
    if ( !LLC_LinkOK(hc) )
    {
      res = ELINKFAILED;
      goto abort_conn;
    }

    if ( (LLC_TickerTime-timer) > OPEN_SESS_TIME )
    {
      res = ETIMEOUT;
      goto abort_conn;
    }
  }

  /* We win! */
  *phSession = (hSESSION) pS;
  return OK;

abort_conn:
   LLC_CloseLink(hc);
abort_find:
   pS->Status = SS_FREE;
   return res;
}

/* ----------------------- */

EXPORT err_t _NB_SendData ( hSESSION hSession, BUFCHAIN pB )
{
  NBSESSION *pS = ValidatehSession(hSession);
  err_t res;

  if ( pS == NULL )
  {
    FreeChain(pB);
    return ENOCONN;
  }

  if ( !WaitForAck(pS) )
  {
    FreeChain(pB);
    return ETIMEOUT;
  }

  /* Send DATA_ONLY_LAST data to far end */

  SHdr.len   = 0x0E;
  SHdr.delim = 0xEFFF;
  SHdr.cmd   = DATA_ONLY_LAST;
  SHdr.opt1  = pS->ack_pending ? 0x0C : 0x04;
  SHdr.opt2lo= 0;
  SHdr.opt2hi= 0;
  SHdr.resp  = pS->next_resp;
  SHdr.xmit  = pS->next_xmit;
  SHdr.dst_sn = pS->RmtLSN;
  SHdr.src_sn = pS->LclLSN;

  pB = AddChain ( pB, &SHdr, 0x0E );

  if ( pB == NULL )
    return EOUTOFMEM;

  /* Send packet */

  res = LLC_SendData( pS->hconn, pB );
  if ( res == OK )
  {
    pS->ack_pending = false;
    pS->next_resp = 0;
    pS->next_xmit++;
    pS->ack_required = true;
  }
  return res;
}

/* ----------------------- */

EXPORT err_t _NB_SendBlockData ( hSESSION hSession, BYTE *data, int datalen )
{
  BUFCHAIN pB;
  err_t res;
  int n;
  NBSESSION *pS = ValidatehSession(hSession);

  if ( pS == NULL )
    return ENOCONN;

  if ( !WaitForAck(pS) )
    return ETIMEOUT;

  while ( datalen > 0 )
  {
    if ( datalen > pS->xmitsize )
    {
      n = pS->xmitsize;
      SHdr.cmd   = DATA_FIRST_MIDDLE;
    }
    else
    {
      n = datalen;
      SHdr.cmd   = DATA_ONLY_LAST;
    }

    SHdr.len   = 0x0E;
    SHdr.delim = 0xEFFF;
    SHdr.opt1  = pS->ack_pending ? 0x0C : 0x04;
    SHdr.opt2lo= 0;
    SHdr.opt2hi= 0;
    SHdr.resp  = pS->next_resp;
    SHdr.xmit  = pS->next_xmit;
    SHdr.dst_sn = pS->RmtLSN;
    SHdr.src_sn = pS->LclLSN;

    pB = AddChainIndirect ( NULL, data, n );
    if ( pB != NULL ) pB = AddChain ( pB, &SHdr, 0x0E );
    if ( pB == NULL )
      return EOUTOFMEM;

    /* Send packet */

    pS->ack_pending = false;
    pS->next_resp = 0;

    if ( (res=LLC_SendData( pS->hconn, pB )), res != OK )
      return res;

    datalen -= n;
    data += n;

  }

  pS->next_xmit++;
  pS->ack_required = true;

  return OK;
}

/* ----------------------- */

EXPORT err_t _NB_ClearRxQueue ( hSESSION hSession )
{
  NBSESSION *pS = ValidatehSession(hSession);

  if ( pS == NULL )
    return ENOCONN;

  QueueFlush ( &pS->RcvQ );
  FreeChain(pS->PartialRcv);
  pS->PartialRcv = NULL;
  return OK;
}


/* ----------------------- */

EXPORT err_t _NB_GetData ( hSESSION hSession, BUFCHAIN *pOutData, int timeout )
{
  int timer;
  BUFCHAIN pB;
  NBSESSION *pS = ValidatehSession(hSession);

  if ( pS == NULL )
    return ENOCONN;


  timer = LLC_TickerTime;
  do
  {
    pB = QueueGet(&pS->RcvQ);

    if ( pB != NULL )
    {
      *pOutData = pB;
      return OK;
    }

    LLC_BackgroundProcess();

    if ( !LLC_LinkOK(pS->hconn) )
      return ELINKFAILED;
  }
    while ( (LLC_TickerTime - timer) < timeout );

  return ETIMEOUT;
}

/* ----------------------- */

/* This is used chiefly by SMB_ReadRaw. The len_in_out parameter passes
   an advisory maximum block length in, and receives the received
   data count out. It is only set if OK is returned, and is unchanged
   otherwise!
   This routine was added because other transports (e.g. TCP/IP) may
   optimise a large data read differently. Indeed, keen people may want
   to try to optimise this further.
*/

EXPORT err_t _NB_GetBlockData ( hSESSION hSession, BYTE *where, int *len_in_out,
                             int timeout )
{
  int timer;
  BUFCHAIN pB;
  NBSESSION *pS = ValidatehSession(hSession);

  if ( pS == NULL )
    return ENOCONN;

  timer = LLC_TickerTime;
  do
  {
    pB = QueueGet(&pS->RcvQ);

    if ( pB != NULL )
    {
      *len_in_out = GetAllData(pB, where);
      FreeChain(pB);
      return OK;
    }

    LLC_BackgroundProcess();

    if ( !LLC_LinkOK(pS->hconn) )
      return ELINKFAILED;
  }
    while ( (LLC_TickerTime - timer) < timeout );

  return ETIMEOUT;
}

/* -------------------------------- */

EXPORT err_t _NB_CloseSession ( hSESSION hSession )
{
  BUFCHAIN pB;
  NBSESSION *pS = ValidatehSession(hSession);

  if ( pS == NULL )
    return ENOCONN;

  EnsureAcks ( pS );

  /* Send SESSION_END to far end */

  SHdr.len   = 0x0E;
  SHdr.delim = 0xEFFF;
  SHdr.cmd   = SESSION_END;
  SHdr.opt1  = 0;
  SHdr.opt2lo= 0;
  SHdr.opt2hi= 0;
  SHdr.resp  = 0;
  SHdr.xmit  = 0;
  SHdr.dst_sn = pS->RmtLSN;
  SHdr.src_sn = pS->LclLSN;

  pB = AddChain ( NULL, &SHdr, 0x0E );

  /* Send command */

  if ( pB != NULL )
    LLC_SendData ( pS->hconn, pB );

  /* Finish up on link */

  LLC_CloseLink(pS->hconn);

  /* Clean up */

  ClearUp ( pS );
  pS->Status = SS_FREE;
  return OK;

}

/* ----------------------- */

EXPORT char *_NB_DescribeLink ( hSESSION hS )
{
  static char namebuf[40];
  NBSESSION *pS = ValidatehSession(hS);

  if ( pS == NULL )
    return NULL;

  sprintf( namebuf, "%02X:%02X:%02X:%02X:%02X:%02X",
       pS->RmtAddr.b[0], pS->RmtAddr.b[1],
       pS->RmtAddr.b[2], pS->RmtAddr.b[3],
       pS->RmtAddr.b[4], pS->RmtAddr.b[5] );

  return namebuf;
}

/* ----------------------- */

EXPORT err_t _NB_Startup(void)
{
  int i;
  err_t res;
  NBSESSION *pS;
  NAME_ENTRY *pN;

  if ( LM_Vars.verbose )
    printf("  Initialising NetBEUI transport\n");

  /* First, clear out all our session & name tables */

  for ( i=1; i <= MAX_SESSIONS; i++ )
  {
    pS = LSNtoSession(i);
    pS->Status  = SS_FREE;
    pS->LclLSN  = i;
    pS->RcvQ.Head  = NULL;
    pS->RcvQ.Last  = NULL;
    pS->PartialRcv = NULL;
    TimerInit ( &pS->AckTimer, AckTimerCallback, pS );
  }

  for ( i=0; i < MAX_NAMES; i++ )
  {
    pN = &NB_NameTable[i];
    pN->Status = NS_FREE;
  }

  Stat_ClassMask |= SCLASS_NETBEUI;

  /* Initialise LLC layer */

  if ( !LLC_Init() )
    return EINITFAILED;

  /* Now find network driver */

  if ( LM_Vars.verbose )
    printf("  Looking for driver '%s'\n", LM_Vars.drivername);

  res = LLC_AttachDriver(LM_Vars.drivername);
  if ( res != OK )
    return res;

  /* Now set our machine name */

  UI_SetReceiver( NETBIOS_SAP, NB_ReceiveDatagram, NULL);

  if ( LM_Vars.machinename[0] == 0 )
  {
    BYTE *p = LLC_MachineAddress.b;
    sprintf( LM_Vars.machinename, "ARM%02X%02X%02X%02X%02X%02X",
       p[0], p[1], p[2], p[3], p[4], p[5] );
  }

  if ( LM_Vars.verbose )
    printf("  Setting machine name to '%s'\n", LM_Vars.machinename );

  return _NB_AddLocalName( ntMACHINE, LM_Vars.machinename, &NB_MachineName );
}

/* ----------------------- */

EXPORT void _NB_Shutdown(void)
{
  int i;

  /* Clear up all active sessions */

  for ( i=1; i <= MAX_SESSIONS; i++ )
    ClearUp(LSNtoSession(i));

  for ( i=0; i < MAX_NAMES; i++ )
    if ( NB_NameTable[i].Status != NS_FREE )
    {
      QueueFlush(&(NB_NameTable[i].DatagramQ));
      NB_NameTable[i].Status = NS_FREE;
    }

  LLC_Shutdown(); /* Detach driver & turn off timers, etc */
}

/* Setup routine ------------------------------- */

static struct NETBIOS_TRANSPORT NetBEUI_Transport;

void NB_NetBEUI_Setup ( void )
{
  struct NETBIOS_TRANSPORT *p;
  NB_ActiveTransport = p = &NetBEUI_Transport;

  p->pfnStartup	 = _NB_Startup;
  p->pfnShutdown = _NB_Shutdown;
  p->pfnFormatName = _NB_FormatName;
  p->pfnDecodeName = _NB_DecodeName;
  p->pfnMatchName = _NB_MatchName;
  p->pfnAddLocalName = _NB_AddLocalName;
  p->pfnRemoveLocalName = _NB_RemoveLocalName;
  p->pfnOpenSession = _NB_OpenSession;
  p->pfnSendData = _NB_SendData;
  p->pfnSendBlockData = _NB_SendBlockData;
  p->pfnClearRxQueue = _NB_ClearRxQueue;
  p->pfnGetData = _NB_GetData;
  p->pfnGetBlockData = _NB_GetBlockData;
  p->pfnLinkOK = _NB_LinkOK;
  p->pfnCloseSession = _NB_CloseSession;
  p->pfnFindNames = _NB_FindNames;
  p->pfnDescribeLink = _NB_DescribeLink;
}