LanMan

/* 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.
 */
/*
*
*  LanMan.C -- Lan Manager network client main module
*
*  Versions
*
*  28-02-94 INH Derived from FSinC (added c.Statics)
*
*
*/

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <locale.h>
#include <string.h>

#include "kernel.h"
#include "swis.h"

#include "stdtypes.h"
#include "lanman.h"
#include "lmvars.h"
#include "Params.h"
#include "corefn.h"

#include "buflib.h"
#include "netbios.h"
#include "SMB.h"
#include "xlate.h"
#include "version.h"
#include "omni.h"
#include "printers.h"
#include "RPC.h"
#include "stats.h"
#include "logon.h"
#include "sys/dcistructs.h"

#include "sys/types.h"
#include "netinet/in.h"
#include "arpa/inet.h"

#include "LanMan_MH.h"

static volatile int callbackflag = 0;

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

/* Added SNB 980224 */
extern char *LM_Status(void);

#define DEFAULT_ETHER_TYPE 	"_default_"

typedef void (*pfnShutdown)(void);
typedef void (*pfnTransportInit)(void);

enum {
        LMInitState_Uninitialised,
        LMInitState_PreInit,
        LMInitState_FullyInited,
        LMInitState_Boot
};

static void startcallbacks(void);
static void stopcallbacks(void);

static _kernel_oserror *LM_init_phase_2(void);

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

struct LMvars LM_Vars;

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

int  LM_pw;          /* Our module's private word */
struct NETBIOS_TRANSPORT *NB_ActiveTransport; /* Selected net transport */
static pfnTransportInit NB_InitedTransport; /* Identify active transport */
static bool LM_Declared;  /* True if we're registered as a filing system */

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

#define CMOS_FSNUMBER   5
/* Contains number of FS to be booted */
#define CMOS_FSFLAGS    16
/* Contains flags, bit 4 is set if booting is enabled */
#define FSF_BOOT        0x10

#define CMOS_FSSTAT     1 /* NAS 11/Feb/97 */
#define CMOS_FSERVER1   2 /* NAS 11/Feb/97 */
#define CMOS_FSERVER    158 /* NAS 11/Feb/97 */
#define FSERVER_LEN     (172-159+1)
/* Locations in CMOS containing file server name.
   It's assumed this is less than NAME_LIMIT. If it's not, put FSERVER_LEN
   at NAME_LIMIT-1, and it'll have to be truncated. */

#define CMOS_NB_TYPE    0x6F
#define	NBTYPE_IP_BIT	(1<<0)

/* Can select IP or NetBEUI transport with this bit in CMOS. It's 0 if
   we should use NetBEUI, 1 if IP */


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

int RdCMOS ( int addr )
{
  return (_kernel_osbyte ( 161, addr, 0 ) & 0xFF00 ) >> 8;
}

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

static void WrCMOS ( int addr, unsigned int data )
{
  _kernel_osbyte ( 162, addr, data );
}

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

static void SetFSName(char *buf_in)
{
  int i, t;

  WrCMOS(CMOS_FSSTAT, 0);
  WrCMOS(CMOS_FSERVER1, buf_in[0]);
  if (buf_in[0] == 0) return;

  for (i=1; i < FSERVER_LEN; i++)
  {
    /* NAS 11/Feb/97 */
    t = buf_in[i];
    if (t <= 0x20 || t > 0x7F) t = 0;
    WrCMOS ( CMOS_FSERVER+i-1, t);
    if (t == 0) break;
  }
}

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

static void GetFSName ( char *buf_out )
{
  int i;

  if (!_kernel_getenv("Inet$ServerName", buf_out, CMOS_FSERVER)) {
          return;
  }

  if ( RdCMOS ( CMOS_FSSTAT ) == 0 )
  {
    /* NAS 11/Feb/97 */
    *buf_out++ = RdCMOS ( CMOS_FSERVER1 );
    for ( i=1; i < FSERVER_LEN; i++ )
      *buf_out++ = RdCMOS ( CMOS_FSERVER+i-1 );
  }

  *buf_out = 0;
}

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

enum dps_reason {
  protocolstatus_STARTING,
  protocolstatus_TERMINATING
};

static void lanman_announce_lanmanfs(enum dps_reason r2, void *pw)
{
#ifndef NO_NETBEUI
  /* Send the service call announcing the presence/absence of a protocol module */
  if (NB_InitedTransport == NB_NetBEUI_Setup)
    (void) _swix(OS_ServiceCall, _INR(0,4), pw,
      Service_DCIProtocolStatus, r2, DCIVERSION, Module_Title);
#endif
}


/* Finalisation code ------------------------------------ */

static void LM_Undeclare ( void )
{
  _kernel_swi_regs r;

  if ( LM_Declared )
  {
    r.r[0] = FSControl_RemoveFilingSystem;
    r.r[1] = (int)FilingSystemName;

    _kernel_swi( XOS_Bit | OS_FSControl, &r, &r );
    LM_Declared = false;
  }
}

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

static void LM_GracefulClosedown(void)
{
  if (LM_Vars.initialised == LMInitState_FullyInited) {
    stopcallbacks();
    Omni_Shutdown();
    OmniS_ResourceShutdown();
    Prn_Shutdown();
    SMB_Shutdown();
    NB_Shutdown();
    Buf_Shutdown();
    LM_Vars.initialised = LMInitState_PreInit;
  }
}

_kernel_oserror * LM_Finalise (int fatal, int podule, void *pw)
{
  debug0("Finalise\n");
  (void) fatal;
  (void) podule;
  (void) pw;

  lanman_announce_lanmanfs(protocolstatus_TERMINATING, pw);

  LM_GracefulClosedown();
  LM_Undeclare();
  return NULL;
}


/* LM_declare ------------------------------------------ */

static _kernel_oserror *LM_Declare ( void )
{
  _kernel_oserror *err;
  int InfoBlk [ Information_Block_Size ];

  LM_Declared = false;

  InfoBlk[0] = (int)FilingSystemName             - (int)Image_RO_Base;
  InfoBlk[1] = -1; /* Self-ident - request call FSFunc_PrintStartupBanner */
  InfoBlk[2] = (int) veneer_fsentry_open         - (int)Image_RO_Base;
  InfoBlk[3] = (int) veneer_fsentry_getbytes     - (int)Image_RO_Base;
  InfoBlk[4] = (int) veneer_fsentry_putbytes     - (int)Image_RO_Base;
  InfoBlk[5] = (int) veneer_fsentry_args         - (int)Image_RO_Base;
  InfoBlk[6] = (int) veneer_fsentry_close        - (int)Image_RO_Base;
  InfoBlk[7] = (int) veneer_fsentry_file         - (int)Image_RO_Base;
  InfoBlk[8] = Information_Word;
  InfoBlk[9] = (int) veneer_fsentry_func         - (int)Image_RO_Base;
  InfoBlk[10] = (int)veneer_fsentry_gbpb         - (int)Image_RO_Base;
  InfoBlk[11] = Information2_Word;

  err = _swix(OS_FSControl, _INR(0,3), FSControl_AddFilingSystem, Image_RO_Base,
    (int)InfoBlk - (int)Image_RO_Base, LM_pw);
  if ( err == NULL )
    LM_Declared=true;

  return err;
}


/* *Command processor ------------------------------------ */

#define MAX_ARGS    20
#define MAX_CMDLEN  256

static char Cmdbuf[ MAX_CMDLEN ];

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

static int GetArgs ( const char *args, char *argv_out[], int maxargs )
{
  /* Splits "args" into a number of separate arguments. Each one is
     copied into Cmdbuf so it is held statically. Pointers to the
     start of each one are put in argv_out. Any unused spaces in
     argv_out are set to NULL for convenience. Returns the number
     of arguments actually found.  */

  int i, argc;

  for (i=0; i < maxargs; i++ ) argv_out[i] = NULL;

  i=0; /* In this loop, i counts characters in Cmdbuf */
  argc=0;

  do
  {
    while ( *args == ' ' ) /* Skip spaces */
      args++;

    if ( *args < ' ' )  /* The end */
      break;

    /* Got one */

    if ( argc >= maxargs )  /* Too many! */
      break;

    argv_out[argc++] = Cmdbuf+i;

    while ( i < MAX_CMDLEN-1 && *args > ' ' ) /* Copy it */
      Cmdbuf[i++] = *args++;

    Cmdbuf[i++] = 0;     /* Terminate it */
  }
    while ( i < MAX_CMDLEN-1 );

  return argc;
}

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

static _kernel_oserror *Cmd_LANMAN ( const char *args )
{
  /* No args! */
  _kernel_swi_regs r;
  (void) args;

  r.r[0] = FSControl_SelectFilingSystem;
  r.r[1] = (int)FilingSystemName;

  return _kernel_swi( XOS_Bit | OS_FSControl, &r, &r );
}

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

#if 0
static char *(LM_local_num)(char *buf)
{
  char *sep, *map, *space = buf;
  if (_swix(Territory_ReadSymbols, _INR(0,1)|_OUT(0), -1, 1, &sep)) return buf;
  if (_swix(Territory_ReadSymbols, _INR(0,1)|_OUT(0), -1, 2, &map)) return buf;

  while (space && *sep) {
    space = strchr(space, ' ');
    if (space) *space = *sep;
  }
  return buf;
}
#endif

static _kernel_oserror *Cmd_FREE ( const char *args )
{
  _kernel_swi_regs r;
  _kernel_oserror *e;
  int values[6];
  char *argv[1];

  if (GetArgs(args, argv, sizeof(argv)/sizeof(*argv)) == 0)
    argv[0] = getenv("FileSwitch$" FilingSystemName "$CSD");

  if (argv[0] == NULL)
    return Xlt_Error( EBADDRV );

  r.r[0] = 4; /* 64-bit free space - will not fail! */
  r.r[1] = Our_FS_Number;
  r.r[2] = (int) values;
  r.r[3] = (int) argv[0];
  e = Omni_FreeOp_SWI(&r);

  if (e == NULL) {
    if (values[3] == 0 && values[5] == 0) {
      printf("Bytes free &%08x\n", values[2] );
      if (values[4] != -1) {
        printf("Bytes used &%08x\n", values[4] );
      }
      else {
        printf("Bytes used unavailable\n");
      }
    }
    else {
      printf("Bytes free &%08x%08x\n", values[3], values[2] );
      if (values[4] != -1) {
        printf("Bytes used &%08x%08x\n", values[5], values[4] );
      }
      else {
        printf("Bytes used unavailable\n");
      }
    }
  }

#ifdef TRACE
  module_printf(NULL);
#endif

  return e;
}

/* --------------------- */
static _kernel_oserror *Cmd_LMLS ( const char *args )
{
  char *argv[1];

  if (GetArgs(args, argv, sizeof(argv)/sizeof(*argv)) == 0) {
    return Omni_DumpServers();
  }
  else {
    return Omni_DumpShares(argv[0]);
  }
}

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

static _kernel_oserror *Cmd_CONNECT ( const char *args )
{
  char *argv[5];
  err_t res;
  int   tmp;

  if ( GetArgs ( args, argv, 5 ) < 3 )
    return Xlt_Error(EBADPARAM);

  /* Convert '-' user name to NULL */

  if ( argv[3] != NULL    &&
       argv[3][0] == '-'  &&
       argv[3][1] == 0 )
    argv[3] = NULL;

  res =  Omni_MountServer ( argv[1],  /* Server */
          argv[3], /* User name or NULL */
          argv[4], /* password or NULL */
          argv[0], /* Mountname */
          argv[2], /* Drive name */
          &tmp ); /* MountID_out */

  Omni_RecheckInfo ( RI_MOUNTS );
  return Xlt_Error(res);
}

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

static _kernel_oserror *Cmd_DISCONNECT ( const char *args )
{
  char *argv[1];
  int mountID;
  err_t res;

  if ( GetArgs( args, argv, 1 ) < 1 )
    return Xlt_Error(EBADPARAM);

  mountID = Omni_GetMountID(argv[0]);
  if ( mountID == 0 ) return Xlt_Error ( EBADDRV );

  res = Omni_DismountServer(mountID);
  Omni_RecheckInfo ( RI_MOUNTS );
  return Xlt_Error (res);
}


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

static void LanMan_InitTransport(pfnTransportInit i)
{
        NB_InitedTransport = i;
        (*i)();
}

static void SetDefaultVars ( void )
{
  char *name;
  char fs_name [ FSERVER_LEN+1 ];

#ifdef DEBUG
    LM_Vars.verbose = true; /* DEBUG NAS */
#else
    LM_Vars.verbose = false;
#endif

  LM_Vars.initialised = LMInitState_Uninitialised;
  name = getenv("Inet$EtherType");
  strcpyn ( LM_Vars.drivername,
                (name==NULL) ? DEFAULT_ETHER_TYPE : name, NAME_LIMIT );

  name = getenv("Inet$HostName");
  /* Trap added to catch 'ARM_NoName', as set by STB OS */
  if ((name == NULL) || (stricmp(name,"ARM_NoName")==0))
    strcpy ( LM_Vars.machinename,   "" );
  else
  {
    strcpyn_upper ( LM_Vars.machinename, name, NAME_LIMIT );
    /* Truncate at first dot - it might be a full domain name */
    name = strchr ( LM_Vars.machinename, '.' );
    if ( name != NULL ) *name = 0;
  }

  /* Following 'get from CMOS' bits added 980127:RCE                *
   * to address user complain that it has to be typed in every time *
   */

  Lgn_Init();
  GetFSName(fs_name);
  if (fs_name[0] != '\0')
  {
    strcpy(LM_Vars.workgroup,fs_name);
  }

  LM_Vars.namemode  = NM_FIRSTCAPS;

  /* Set transport type from CMOS, unless overridden on command line */
#ifdef NO_NETBEUI
  LanMan_InitTransport(NB_NBIP_Setup);
#else
  LanMan_InitTransport(RdCMOS ( CMOS_NB_TYPE ) & NBTYPE_IP_BIT  ?
    NB_NBIP_Setup : NB_NetBEUI_Setup);
#endif
}

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

static _kernel_oserror *Cmd_LOGOFF( const char *args )
{
  (void) args;
  Lgn_Logoff();
  return NULL;
}

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

static _kernel_oserror *Cmd_LOGON( const char *args )
{
  char *argv[3];
  if ( GetArgs(args, argv, 3) < 2 )
    return Xlt_Error(EBADPARAM);

  /* argv[2] may be NULL for blank password */

  return Xlt_Error (Lgn_Logon ( argv[0], argv[1], argv[2] ) );
}


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

static _kernel_oserror *Cmd_LMINFO ( const char *args )
{
  (void) args;
  Omni_Debug();
  if (LM_Vars.verbose)
          printf("Status: %s\n", LM_Status());
  return NULL;
}

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

static _kernel_oserror *Cmd_LMNAMEMODE ( const char *args )
{
  char *argv[1];
  int tmp;

  if ( GetArgs( args, argv, 1 ) < 1 ||
       sscanf( argv[0], "%d", &tmp) != 1 ||
       tmp < 0 ||
#ifdef TRACE
       0
#else
       tmp > 2
#endif
     )
    return Xlt_Error (EBADPARAM);

  LM_Vars.namemode = tmp;
  return NULL;
}

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

static _kernel_oserror *Cmd_LMSERVER ( const char *args )
{
  char *argv[MAX_ARGS];
  int i;

  if ( GetArgs( args, argv, MAX_ARGS ) < 1 )
    return Xlt_Error ( EBADPARAM );

  if ( argv[1] == NULL ) /* Just name of server */
  {
    Omni_AddInfo ( OAI_SERVER, argv[0], NULL, NULL );
  }
  else
  {
    for ( i=1; i < MAX_ARGS && argv[i] != NULL; i++ )
      Omni_AddInfo ( OAI_DISK, argv[0], argv[i], NULL );
  }

  Omni_RecheckInfo (RI_SERVERS);
  return NULL;
}

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

static _kernel_oserror *Cmd_LMPRINTERS ( const char *args )
{
  char *argv[MAX_ARGS];
  int i;

  if ( GetArgs( args, argv, MAX_ARGS ) < 1 )
    return Xlt_Error ( EBADPARAM );

  if ( argv[1] == NULL ) /* Just name of server */
  {
    Omni_AddInfo ( OAI_SERVER, argv[0], NULL, NULL );
  }
  else
  {
    for ( i=1; i < MAX_ARGS && argv[i] != NULL; i++ )
      Omni_AddInfo ( OAI_PRINTER, argv[0], argv[i], NULL );
  }

  Omni_RecheckInfo (RI_SERVERS);
  Omni_RecheckInfo (RI_PRINTERS);
  return NULL;
}

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

static _kernel_oserror *Cmd_LMSTATS ( const char *args )
{
  (void) args;
  Stat_Show();
  return NULL;
}

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

static _kernel_oserror *Cmd_FS ( const char *args )
{
  /* This is a *Configure/Status command handler - it's therefore unusual */
  char *argv[1];

  if ( (int) args == 0 ) /* Show 'Configure' options */
  {                      /* Syntax corrected 980127 RCE */
    printf("FS           <domain-name> | <file-server>\n");
    return NULL;
  }
  else if ( (int) args == 1 ) /* Show FS status */
  {
    char buf[NAME_LIMIT];
    GetFSName(buf);
    printf("FS           %s\n", buf);
    return NULL;
  }

  if ( GetArgs( args, argv, 1 ) < 1 )
    return Xlt_Error ( EBADPARAM );

  SetFSName(argv[0]);
  return NULL;
}

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

static _kernel_oserror *Cmd_LMTRANSPORT ( const char *args )
{
  /* This is a *Configure/Status command handler */
  char *argv[1];
  char *tp1 = "IP";

#ifdef NO_NETBEUI
  if (args == arg_CONFIGURE_SYNTAX || args == arg_STATUS)
  {
    printf("LMTransport  IP\n");
    return NULL;
  }
#else
  char *tp0 = "NetBEUI";
  if ( args == arg_CONFIGURE_SYNTAX ) /* Show 'Configure' options */
  {
    printf("LMTransport  [%s | %s]\n", tp0, tp1);
    return NULL;
  }
  else if ( args == arg_STATUS ) /* Show FS status */
  {
    printf("LMTransport  %s\n",
      (RdCMOS(CMOS_NB_TYPE) & NBTYPE_IP_BIT) ? tp1:tp0);
    return NULL;
  }
#endif

  if ( GetArgs( args, argv, 1 ) < 1 )
    return Xlt_Error ( EBADPARAM );

#ifndef NO_NETBEUI
  if ( stricmp ( argv[0], tp0 ) == 0 )
    WrCMOS(CMOS_NB_TYPE, RdCMOS(CMOS_NB_TYPE) & ~NBTYPE_IP_BIT );
  else
#endif
  if ( stricmp ( argv[0], tp1 ) == 0 )
    WrCMOS(CMOS_NB_TYPE, RdCMOS(CMOS_NB_TYPE) | NBTYPE_IP_BIT );
  else
    printf("'%s' isn't a supported option\n", argv[0] );

  return NULL;
}

/* --------------------- */
static _kernel_oserror *Cmd_NBNSIP( const char *args )
{
  /* This is a *Configure/Status command handler - it's therefore unusual */
  char *argv[1];
  struct in_addr address;
  int result;

  if ( args == arg_CONFIGURE_SYNTAX ) /* Show 'Configure' options */
  {
    printf("LMNameServer xx.xx.xx.xx\n");
    return NULL;
  }
  else if ( args == arg_STATUS ) /* Show FS status */
  {
    int b0, b1, b2, b3;

    b0 = RdCMOS(NBNSIPCMOS0);
    b1 = RdCMOS(NBNSIPCMOS1);
    b2 = RdCMOS(NBNSIPCMOS2);
    b3 = RdCMOS(NBNSIPCMOS3);

    if ( ((b0 != 0) && (b0 != 127) && (b0 <= 223))  &&  ((b3 != 0) && (b3 != 255)) )
    {
      printf("LMNameServer %d.%d.%d.%d\n", b0,b1,b2,b3);
    }
    else
    {
      printf("LMNameServer <unset>\n");
    }
    return NULL;
  }
  else if (GetArgs(args,argv,1) == 1)
  {
    result = inet_aton(argv[0],&address);
    if (result)
    {
      unsigned long b0, b1, b2, b3;

      b0 = (address.s_addr & 0x000000ff);
      b1 = (address.s_addr & 0x0000ff00) >>  8;
      b2 = (address.s_addr & 0x00ff0000) >> 16;
      b3 = (address.s_addr & 0xff000000) >> 24;

      if ( ((b0 != 127) && (b0 <= 223))  &&  ((b3 != 255)) )
      {
        WrCMOS(NBNSIPCMOS0,(int) b0);
        WrCMOS(NBNSIPCMOS1,(int) b1);
        WrCMOS(NBNSIPCMOS2,(int) b2);
        WrCMOS(NBNSIPCMOS3,(int) b3);
        return NULL;
      }
    }
  }
  return Xlt_Error(EBADPARAM);
}

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

typedef _kernel_oserror * (*CommandFnPtr) ( const char *args );

#define MAX_CMDS 15
static CommandFnPtr Cmd_Dispatch[MAX_CMDS] =
{
  Cmd_LANMAN,
  Cmd_CONNECT,
  Cmd_DISCONNECT,
  Cmd_LOGON,
  Cmd_LMINFO,
  Cmd_LMNAMEMODE,
  Cmd_LOGOFF,
  Cmd_LMSERVER,
  Cmd_LMPRINTERS,
  Cmd_LMSTATS,
  Cmd_FS,
  Cmd_LMTRANSPORT,
  Cmd_NBNSIP,
  Cmd_FREE,
  Cmd_LMLS
};

#ifdef TRACE
static void chk_a_command(CommandFnPtr ptr, int num)
{
        if (Cmd_Dispatch[num] != ptr) {
           fprintf(stderr, "Command-table error (%d)\n", num);
        }
}
static void chk_commands(void)
{
  chk_a_command(Cmd_LANMAN, CMD_LanMan);
  chk_a_command(Cmd_CONNECT, CMD_LMConnect);
  chk_a_command(Cmd_DISCONNECT, CMD_LMDisconnect);
  chk_a_command(Cmd_LOGON, CMD_LMLogon);
  chk_a_command(Cmd_LMINFO, CMD_LMInfo);
  chk_a_command(Cmd_LMNAMEMODE, CMD_LMNameMode);
  chk_a_command(Cmd_LOGOFF, CMD_LMLogoff);
  chk_a_command(Cmd_LMSERVER, CMD_LMServer);
  chk_a_command(Cmd_LMPRINTERS, CMD_LMPrinters);
  chk_a_command(Cmd_LMSTATS, CMD_LMStats);
  chk_a_command(Cmd_FS, CMD_FS);
  chk_a_command(Cmd_LMTRANSPORT, CMD_LMTransport);
  chk_a_command(Cmd_NBNSIP, CMD_LMNameServer);
  chk_a_command(Cmd_FREE, CMD_Free);
  chk_a_command(Cmd_LMLS, CMD_LMls);
}
#endif

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

_kernel_oserror *LM_Command ( const char *args, int argc, int cmd_no, void *pw )
{
  (void) pw;
  (void) argc;

  if ( cmd_no < 0 || cmd_no >= MAX_CMDS )
    return Xlt_Error(ENOTPRESENT);

  return Cmd_Dispatch[cmd_no](args);
}

/* Service call handler --------------------------------- */
static void LM_check_driver_status(_kernel_swi_regs *r);
static void LM_check_internet_status(_kernel_swi_regs *r);
static void LM_check_protocol_status(_kernel_swi_regs *r);

void LM_Service ( int service_number, _kernel_swi_regs *r, void *pw )
{
  (void) pw;
  /* Any changes to list of service calls?  Must mirror in cmhg inputfile too! */

  switch(service_number)
  {
    case Service_FSRedeclare:
      LM_Declare();
      break;

    case Service_OmniAction:
      Omni_ServiceCall (r);
      break;

    case Service_ResourceFSStarting:
      OmniS_ResFSStarting(r->r[2], r->r[3]);
      break;

    case Service_DCIDriverStatus:
      LM_check_driver_status(r);
      break;

    case Service_DCIProtocolStatus:
      LM_check_protocol_status(r);
      break;

    case Service_InternetStatus:
      if (NB_InitedTransport == NB_NBIP_Setup) {
          LM_check_internet_status(r);
      }
      break;

    default:
      break;
  }
}

/* SWI handler ------------------------------------------ */

_kernel_oserror *LM_Swi( int swi_ofs, _kernel_swi_regs *r, void *pw )
{
  (void) pw;  /* Not used */
  switch ( swi_ofs )
  {
    case LanMan_OmniOp - LanMan_00:
      return OmniOp_SWI(r);

    case LanMan_LogonOp - LanMan_00:
      return Lgn_LogonOp_SWI(r);

    case LanMan_FreeOp - LanMan_00:
      return Omni_FreeOp_SWI(r);

    case LanMan_NameOp - LanMan_00:
      return Xlt_Error(RPC_NameOp(r->r[0], /* reason code */
                                  (char *)(r->r[1]), /* name in */
                                  (char *)(r->r[2])  /* buffer out */
                                   ));
    case LanMan_Transact - LanMan_00:
      return Xlt_Error(RPC_Transact((char *)(r->r[0]), /* server */
                                    (char *)(r->r[1]), /* share name */
                                    (void *)(r->r[2]) /* params */
                                     ));

    default:
      return Xlt_Error(ENOTPRESENT);
  }

  return NULL;
}

/* Initialisation code ---------------------------------- */

static char *copy_space ( char *dst, char *src, int maxlen )
{
  while ( *src > ' ' )
  {
    if ( --maxlen > 0 )
      *dst++ = *src;
    src++;
  }

  *dst = 0;
  return src;
}

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

static err_t ProcessCmdLine ( const char *_line )
{
  char cli[256];
  char *end;
  char *line;

  /* This code relies on NB_xxx_Setup() only setting variables, not
     allocating anything. Multiple NB_xxx_Setup()'s may be called if
     the user is being perverse */

  /* NAS 20/3/97 - RO doesn't pass a 0-terminated string, but a ctrl-terminated one */
  strncpy(cli, _line, 255);
  line = end = cli;
  while (*end >= ' ') end++;
  *end = '\0';

  while ((line = strchr(line, '-')) != NULL)
  {
    line++;
    switch ( toupper(*line) )
    {
      case 'D':    /* Specify driver name ************ */
         line = copy_space ( LM_Vars.drivername, line+1, NAME_LIMIT );
         break;

      case 'H':
      case '?':
         printf( "Lan Man client for RISCOS, version " VERSION_STRING
                 "\nWritten by Ian Harvey 1994-1996\nUse:\n"
                 "\t-dea0\tto use 'ea0' for network driver (etc)\n"
                 "\t-n\tto disable network browsing\n"
                 "\t-mMYNAME\tto set machine name to MYNAME\n"
                 "\t-i\tto use NetBIOS-over-IP transport\n"
#ifndef NO_NETBEUI
                 "\t-t\tto use NetBEUI transport\n"
#endif
                 "\t-v\tto show progress information on startup\n"
                 "\t-?\tto display this help\n" );
         return ENOTINSTALLED;

      case 'V':
         LM_Vars.verbose = true;
         break;

      case 'N':
         Lgn_Logoff();
         break;

      case 'M':
         line = copy_space( LM_Vars.machinename, line+1, NAME_LIMIT );
         strcpyn_upper( LM_Vars.machinename,LM_Vars.machinename,NAME_LIMIT );
         break;

      case 'I':
         LanMan_InitTransport(NB_NBIP_Setup);
         break;

#ifndef NO_NETBEUI
      case 'T':
         LanMan_InitTransport(NB_NetBEUI_Setup);
         break;
#endif

      default:
         printf("\nCommand line switch '-%c' not recognised\n", line[0] );
         printf("Use '-?' to show available options\n");
         return ECMDLINE;

    }

  }

  return OK;
}


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

void LM_Boot(void)
{
  int tries=1;
  int tmp;
  err_t res;
  char *serv_name;
  char fs_name [ FSERVER_LEN+1 ];

  if (LM_Vars.initialised < LMInitState_FullyInited) {
  if (LM_Vars.verbose) {
          printf("LanManFS: LM_Boot called, but cannot comply: %s\n", LM_Status());
  }
    LM_Vars.initialised = LMInitState_Boot;
    return;
  }

  GetFSName(fs_name);

  if ( strlen(fs_name) == 0 )
  {
    if (LM_Vars.verbose) {
      printf("Auto-boot: server name has not been set...\n");
    }
    return;
  }

  /* Ready to go... */

  for (;;) {
    serv_name = RPC_GetDomainController(fs_name);
    if ( serv_name == NULL )
      serv_name = fs_name;

    if ( LM_Vars.verbose )
      printf("  Server name '%s'\n", serv_name );

    /* Wash'n'go... */

    res =  Omni_MountServer ( serv_name,  /* Server */
            "ARMBOOT", "", /* User name & password */
            "BOOT",        /* Mountname */
            "ARMBOOT",     /* Drive name */
            &tmp );          /* MountID_out */

    if ( res != OK )
    {
      printf("  Error during boot: %s\n", Xlt_Error(res)->errmess);
      /* tmp will be zero unless the share was successfully created */
      if (tmp == 0)
      {
        char var_name[sizeof("Inet$ServerName12")];
        sprintf(var_name, "Inet$ServerName%d", ++tries);
        if (!_kernel_getenv(var_name, fs_name, FSERVER_LEN))
          continue; /* Try next server */
      }
    }
    break;
  }
}


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


/* SNB 980224.
 *
 *
 *  This function has been split into two as it is inappropriate for some
 *  parts of this code to be executed during a service call.  The initialised
 *  member of LM_Vars has been promoted to 'int' type so that it can hold any
 *  of the values in the anonymous enum at the top of this file.  This is used
 *  to control the execution of the LM_init_phase_2 function.
 *
 *
 */

_kernel_oserror *LM_Initialise(const char *cmd_tail, int pod_base, void *pw)
{
  _kernel_oserror *err;
  _kernel_swi_regs R;

  debug_initialise("LanManFS", "", "");
  debug_atexit();
  debug_set_options(0,0,0);
  debug_output_device(DEBUGIT_OUTPUT);

  LM_Vars.initialised = LMInitState_Uninitialised;

  (void)pod_base;
  if (pw != NULL)
  {
    LM_pw = (int)pw;
  }

  SetDefaultVars();

  R.r[0] = 129;
  R.r[1] = 0;
  R.r[2] = 255;
  _kernel_swi(OS_Byte, &R, &R);

  if (R.r[1] < 0xA2)
    return Xlt_Error(ERISCOSVER);

#ifdef TRACE
  chk_commands();
#endif

if (cmd_tail != NULL)
  {
    err = Xlt_Error(ProcessCmdLine(cmd_tail));
    if (err != NULL)
      return err;
  }

  err = LM_Declare();
  if (err != NULL)
      return err;

  LM_Vars.initialised = LMInitState_PreInit;
  (void) LM_init_phase_2();

#ifndef NO_NETBEUI
  /* Cheap way to set a callback ;-) Send service call announcing ourselves */
  if (NB_InitedTransport == NB_NetBEUI_Setup) {
    callevery_handler(&R, pw);
    callbackflag = 2;
  }
#endif

  return NULL;
}

static _kernel_oserror *LM_init_phase_2(void)
{
  /* Initialise various modules */

  enum { MAXEXITS = 4 };
  pfnShutdown shutdowns[MAXEXITS];
  int ctr = 0;
  int want_boot;
  int oldstate = LM_Vars.initialised;
  _kernel_oserror *err;


  want_boot = (LM_Vars.initialised == LMInitState_Boot);

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

  if (!FS_Init() || !SMB_Init()) goto initfailed;
  shutdowns[ctr++] = (pfnShutdown) SMB_Shutdown;
  if (!RPC_Init() || !Prn_Init()) goto initfailed;
  shutdowns[ctr++] = (pfnShutdown) Prn_Shutdown;
  if (!Stat_Init()) goto initfailed;

  err = Xlt_Error(Buf_Init());
  if (err != NULL) goto abort;

  shutdowns[ctr++] = (pfnShutdown) Buf_Shutdown;

  /* Try to start various modules */

  if (LM_Vars.verbose)
    printf("Starting network transport...\n");

  err = Xlt_Error( NB_Startup() );
  if (err != NULL)
  {
    debug2(    "Error - NB_Startup() returned %d (%s)\n",err->errnum,err->errmess);
    goto abort;
  }

#if 0
  if (LM_Vars.verbose)
    printf( "Starting filing system...\n");

  err = LM_Declare();
  if (err != NULL) {
          if (LM_Vars.verbose) printf("LanManFS: %s\n", err->errmess);
          NB_Shutdown();
          goto abort;
  }
#endif

  startcallbacks();

  /* We have now managed to fully initialise everything that we need - whee! */
  LM_Vars.initialised = LMInitState_FullyInited;
  ctr=0; /* Forget destructors */

  Omni_StartUp();  /* Try to contact OmniFiler */

  OmniS_ResourceInit();

  _kernel_oscli("IconSprites Resources:$.ThirdParty.OmniClient.LanMan.Sprites");

  /*LM_StartupBoot();*/
  if (want_boot) {
          if (LM_Vars.verbose) printf("Booting ...\n");
          LM_Boot();
  }

  if ( LM_Vars.verbose )
    printf("All done...\n");

  return NULL;

initfailed:
  err = Xlt_Error(EINITFAILED);
#ifdef DEBUG
  if (LM_Vars.verbose) {
          printf("LanManFS: %s (%s)\n", err->errmess, LM_Status());
  }
#endif
  while (--ctr >= 0) (shutdowns[ctr])();
  return err;

abort:
  LM_Vars.initialised = oldstate;
  while (--ctr >= 0) (shutdowns[ctr])();
#ifdef DEBUG
  if (LM_Vars.verbose) {
          printf("LanManFS: %s\n", LM_Status());
  }
#endif
  return NULL;

/* abort used to use this, but that assumes deterministic module startup,   *
 * which can't be assumed under DCI4, so now it just sits around waiting    *
 * for an appropriate set of service calls to wake it up.  RCE 980212       *

abort:
  LM_Finalise();
  return err;
 */
}

/* SNB 980224 added this function to verify the actual contents of the
 * Service_DCIDriverStatus service call
 */
static void LM_check_driver_status(_kernel_swi_regs *r)
{
        char if_name[16];
        Dib *dib = (Dib *) (r->r[0]);

        sprintf(if_name, "%-.8s%d", dib->dib_name, dib->dib_unit);

#ifdef TRACE
        printf ("Service_DCIDriverStatus called (interface %s%d is %sing)\n"
        	"  Driver supports DCI version %d.%02d\n",
        	dib->dib_name, dib->dib_unit, r->r[2] ? "dy" : "start",
		r->r[3] / 100, r->r[3] % 100
                );

        printf ("We are looking for driver `%s' - got `%s'\n", LM_Vars.drivername,
        	if_name);

#endif
        if (strcmp(LM_Vars.drivername, DEFAULT_ETHER_TYPE) == 0) {
                if (if_name[0] != 'l') {
                	(void) strncpy(LM_Vars.drivername, if_name, NAME_LIMIT);
                }
        }

#ifndef NO_NETBEUI
        if (NB_InitedTransport != NB_NetBEUI_Setup) {
                return;
        }


        if (stricmp(LM_Vars.drivername, if_name) != 0) {
                /* printf("Not interested\n"); */
                return;
        }
        else {
                debug0("Ding!  This was our interface\n");
		if (r->r[2] == 0) {
		        if (LM_Vars.initialised ==  LMInitState_FullyInited) {
                        	LM_GracefulClosedown();
		        }
	                LM_init_phase_2();
		}
		else if (r->r[2] == 1) {
		        LM_GracefulClosedown();
		}
        }
#endif
}

static void LM_check_protocol_status(_kernel_swi_regs *r)
{
  /* A protocol module came or went (could be us in NetBEUI mode!)
   * Inform our transport layer if we find it was Internet leaving.
   */
  const char *proto = (char *) r->r[4];
  if (r->r[2] == protocolstatus_TERMINATING && strcmp(proto, "Internet") == 0) {
    NB_InternetGone();
  }
}


#ifdef TRACE

static void DumpBuffer(void *ptr, int len)
{
        static char db[512];
        char *p = db;

        const char *membuf = ptr;
        int i,j;
	db[0] = '\0';
        for (i=0; i<((len+31)&~31); ++i) {
                if (!(i & 31)) {
                        p += sprintf (p, "  ");
                        if (i) for (j = i - 32; j != i; ++j) {
                                p+=sprintf(p, "%c", (membuf[j]>=32 && membuf[j] != 0x7f) ?
                                membuf[j] : '.');
                        }
                        printf("$%s\n", db);
                        p=db+sprintf(db,"%04x: ", i);
                }
                if (i>=len) {
                        p+=sprintf (p,"  ");
                        if (3==(i & 3)) p+=sprintf (p," ");
                }
                else {
                        p+=sprintf (p,"%02x", membuf[i]);
                        if (3==(i & 3)) p+=sprintf (p," ");
                }
        }
        if (i) for ( p+=sprintf (p,"  "), j = i - 32; j != i; ++j) p+=sprintf (p,"%c",
            j>=len ? ' ' : (membuf[j]>=32 && membuf[j] != 0x7f) ?
            membuf[j] : '.');
        printf("$%s\n", db);
}
#endif

/* SNB 981029 added this function to verify the contents of the Service_InternetStatus
 * service call to determine whether we were waiting for the interface to go up so
 * that we could boot
 */
static void LM_check_internet_status(_kernel_swi_regs *r)
{
        char *cp = (char *) r->r[3];

	if (r->r[0] == InternetStatus_AddressChanged) {
	  if (LM_Vars.initialised != LMInitState_PreInit &&
	      LM_Vars.initialised != LMInitState_Boot) {
            return;
	  }
	  /* An interface address was set - almost certainly ours! */
	}
#ifdef TRACE
	else if (r->r[0] == InternetStatus_DynamicBootReply) {
	  DumpBuffer((void *)r->r[4], r->r[5]);
	}
	else if (r->r[0] == InternetStatus_DynamicBootStart) {
	  DumpBuffer((void *)r->r[4], r->r[5]);
	}
#endif
        else {
          /* Were we actually waiting for the driver to appear */
    	  if (LM_Vars.initialised != LMInitState_PreInit &&
              LM_Vars.initialised != LMInitState_Boot) return;
     	  /* Was it the right reason code? */
	  if (r->r[0] != InternetStatus_InterfaceUpDown) return;
	  /* Was it the right interface? */
	  if (stricmp(LM_Vars.drivername, cp) != 0) return;
	  /* was the interface coming up? */
	  if (r->r[2] != 1) return;
        }

	if (LM_Vars.initialised == LMInitState_FullyInited) {
	        /* Should never happen nowadays ?? */
	        LM_GracefulClosedown();
	}
	LM_init_phase_2();
}


char *LM_Status(void)
{
        switch (LM_Vars.initialised) {
        case LMInitState_Uninitialised: return "Dormant";
        case LMInitState_PreInit: return "Waiting for driver";
        case LMInitState_FullyInited: return "Active";
        case LMInitState_Boot: return "Waiting to boot";
        default: return "Dead";
        }
}

#ifdef TRACE
/* Debugging routine.  If str is NULL, then the log is printed to 'f' (or stderr
 * if f was NULL).  If f is NULL, the message is added to the log but not displayed
 * on the screen.  If neither f nor str was NULL, the screen characteristcs are set
 * to useful things (text window is reset, default colours restored and text origin
 * restored to 0,0, and the message is printed to the screen and copied to tne log.
 * A monotonic coumnter is incremented for each debug message logged.  Timestamps
 * are stored in the log buffer too.
 */
#include <stdarg.h>
int module_printf(const char *str, ...)
{
	static int callcount = 0;
	static char pbuffer[65536];
	static int pbufferptr = 0;
	va_list ap;
	int inblock[2];
	FILE *f;

	f=stderr;

	if (f != NULL || str == NULL)  {
		inblock[1] = -1;
		inblock[0] = 132;
		_swix(OS_ReadVduVariables, _INR(0,1), inblock, inblock);
		_swix(OS_WriteC, _IN(0), 6);
		if (inblock[0] > 20) {
			int i;
			for (i=0; i<0; ++i) (void) _kernel_osbyte(19,0,0);
			_swix(OS_WriteN, _INR(0,1), "\x1a\x0c", 2);
		}
		_swix(OS_WriteC, _IN(0), 20);
	}

	if (!str) {
		if (pbufferptr > 0) fprintf(f?f:stderr, "%s\n", pbuffer);
		return 0;
	}

	++callcount;
	if (*str != '$' && f != NULL) {
		va_start(ap, str);
		vfprintf(f, str, ap);
		va_end(ap);
	}
	va_start(ap, str);
	_swix(OS_ReadMonotonicTime, _OUT(0), inblock);
	if (*str == '$') ++str; else
	pbufferptr += sprintf(pbuffer + pbufferptr, "(%8d) (%4d) ", inblock[0], callcount);
	pbufferptr += vsprintf(pbuffer + pbufferptr, str, ap);
	if (pbufferptr > 60000) pbufferptr = 0;
	return 0;
}
#endif


/* ========== Callback code ========== */

/* Callback management.  Some servers tend to idle-out connections.  This code stops
 * that happening.
 */

_kernel_oserror *callback_handler(_kernel_swi_regs *r, void *pw)
{
	(void) r;
	switch (callbackflag) {
	  case 2:
                /* Re-entrancy on this code is OK - announce we are starting */
                callbackflag = 0;
                lanman_announce_lanmanfs(protocolstatus_STARTING, pw);
                break;
	  case 1:
	        debug0("Anti IdleOut Callback entered\n");
	        SMB_AntiIdle();
		callbackflag = 0;
	}
	return 0;
}

static void clearcallback(void)
{
	if (callbackflag != 0) {
		(void) _swix(OS_RemoveCallBack, _INR(0,1), callback_entry, LM_pw);
		callbackflag = 0;
	}
}

_kernel_oserror *callevery_handler(_kernel_swi_regs *r, void *pw)
{
        (void) r;
	if (callbackflag == 0) {
		if (_swix(OS_AddCallBack, _INR(0,1), callback_entry, pw) == NULL) {
			callbackflag = 1;
			debug0(Module_Title ": (setcallback) just set a callback\n");
		}
	}
	return 0;
}

static void startcallbacks(void)
{
        /* Remember that as the SMB_AntiIdle routine rotates through all the shares,
         * each share will only be every pinged MAX_SHARES * 100 * 45 seconds.
         */
        (void) _swix(OS_CallEvery, _INR(0,2), 100*45, callevery_entry, LM_pw);
}

static void stopcallbacks(void)
{
        (void) _swix(OS_RemoveTickerEvent, _INR(0,1), callevery_entry, LM_pw);
        clearcallback();
}