SMB

/* 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.
 */
/*
*
*  SMB.C  -- SMB Server routines
*
*  14-02-94 INH  Original
*                No WriteRaw
*  17-08-94      No 'drv' numbers passed
*  12-09-94      New NetBIOS interface
*  22-09-95	 Tracks Uids & session keys. Uses "DOS LM1.2X002"
*                  protocol to keep Lan Manager happy.
*  26-03-97      SMB_GetAttribs call replaced for NT 4.0 bug workround
*  21-04-97	 SMB_SetAttribs sets time/date using Open/Close on Windows95
*
*  04-12-98      sbrodie: started adding long filename support - controlled
*                  by LONGNAMES macro.
*  08-12-98      sbrodie: Added SMB_Transact2 with full support for setup
*                  words and the like (present only for LONGNAMES build)
*                  Several new functions added to support long filename
*                  compatible versions of some calls,  These functions have
*                  the same name as the function they upgrade with an X2 suffix
*                  added.
*/

/* A word about 'drive letters':

   Each connection from us to a shared directory or printer on a server
   is given a drive letter (starting at 'A' and working up). This is
   essentially a handle to a (server_name, share_name) pair, but it
   is made a character to allow it to be passed as the first character
   in filename strings to the SMB_xxx functions.

   LanManFS itself will allow disk-type network connections to be
   given 'mount names' so RISCOS file names take the form
     LanMan::MountName.$.<filespec>

   We never see these mount names; they are handled in c.Omni. When
   a RISCOS filename is passed to Xlt_ConvertPath, it uses
   Omni_GetDrvLetter() to convert the mount name to an SMB drive letter.

   We could allow SMB to deal directly in mount names, but (i) we'd
   have to create nonconflicting names for all the anonymous mounts
   like printers and RPC connections, (ii) the Omni module has to
   deal with mount names anyway, & has a perfectly good set of list-
   management routines there already; we'd only have to duplicate
   them & write an interface (iii) legal characters & case
   sensitivity for mount names may be different to DOS filenames,
   making a composite name a pain in the bum to validate.

   SMB treats drives, printers and the IPC$ share used for remote
   procedure call as alike; a different set of operations
   is allowed on each one, but they are all connected with
   SMB_CreateShare() & SMB_DeleteShare(), and they all have a
   'drive letter'. Hence you will find references to
   drive letters in the printer and RPC code - panic not, they
   are just connection identifiers.
*/


/* Standard includes */

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

/* Our includes */

#include "stdtypes.h"
#include "buflib.h"
#include "netbios.h"
#include "smb.h"
#ifdef LONGNAMES
#include "Transact.h" /* for transaction structure building helpers */
#include "NameCache.h" /* for the directory entry cache */
#endif
#include "lmvars.h"
#include "attr.h"   /* For InvalidateDrive */
#include "xlate.h"  /* For string functions */


/* Definitions ===================================================== */

/* Timeouts * */

/* Reply timeout (12s) */

#ifdef LONGNAMES
#define REPLY_TIMEOUT 4000
#else
#define REPLY_TIMEOUT 1200
#endif

/* Timeout to put in 'Transact' params, in ms */

#define TRANSACT_TIMEOUT 5000
#ifdef LONGNAMES
#define TRANSACT2_TIMEOUT 10000
#endif

/* Our definitions */

#define MAX_SERVERS  (MAX_DRIVES + 4)
#define MAX_SHARES   (MAX_DRIVES + 4)

/* Tuning parameters */

#define FILE_BLOCK_SIZE 1024
#define RDRAW_BLOCK_SIZE 32768
#define WRRAW_BLOCK_SIZE 16384
#define PRN_BLOCK_SIZE  1024

/* This structure relies on Norcroft C packing the bytes & words
   properly!
 */
typedef struct
{
  BYTE id[4];
  BYTE command;
  BYTE errclass;
  BYTE reh;
  BYTE errlo;
  BYTE errhi;
  BYTE flg;
  WORD flg2;
  WORD rsvd[6];

  WORD tid;
  WORD pid;
  WORD uid;
  WORD mid;
  BYTE wct;  /* Word count */

} SMBHDR;

/* Size of above structure - sizeof() may round to word boundary! */
#define SMBHDR_SIZE 33

/* Maximum number of word params - 14 is used by Transact */
#ifdef LONGNAMES
/* Transact2 (LONGNAMES build only) requires 14 plus setup words
 * The NT LM 0.12 negprot response requires 17.
 */
#define MAX_WCT (17+(MAX_SETUPWORDS)+1)
#else
#define MAX_WCT 14
#endif

/* Max number of significant characters in a shared drive
   or printer name */
#define SHARENAME_LEN 16

#define DATA_BLOCK      1
#define DATA_DIALECT    2
#define DATA_PATHNAME   3
#define DATA_ASCII      4
#define DATA_VARBLK     5

#define ECLASS_DOS      1
#define ECLASS_SRV      2
#define ECLASS_HARD     3


#define SMBmkdir      0x00   /* create directory */
#define SMBrmdir      0x01   /* delete directory */
#define SMBopen       0x02   /* open file */
#define SMBcreate     0x03   /* create file */
#define SMBclose      0x04   /* close file */
#define SMBflush      0x05   /* flush file */
#define SMBunlink     0x06   /* delete file */
#define SMBmv         0x07   /* rename file */
#define SMBgetatr     0x08   /* get file attributes */
#define SMBsetatr     0x09   /* set file attributes */
#define SMBread       0x0A   /* read from file */
#define SMBwrite      0x0B   /* write to file */
#define SMBlock       0x0C   /* lock byte range */
#define SMBunlock     0x0D   /* unlock byte range */
#define SMBctemp      0x0E   /* create temporary file */
#define SMBmknew      0x0F   /* make new file */
#define SMBchkpth     0x10   /* check directory path */
#define SMBexit       0x11   /* process exit */
#define SMBlseek      0x12   /* seek */
#define SMBreadBraw   0x1A   /* Read block raw */
#define SMBwriteBraw  0x1D   /* Write block raw */
#define SMBtransact   0x25   /* RPC transaction */
#define SMBtcon       0x70   /* tree connect */
#define SMBtdis       0x71   /* tree disconnect */
#define SMBnegprot    0x72   /* negotiate protocol */
#define SMBsesssetup  0x73   /* Session setup and X */
#define SMBdskattr    0x80   /* get disk attributes */
#define SMBsearch     0x81   /* search directory */
#define SMBsplopen    0xC0   /* open print spool file */
#define SMBsplwr      0xC1   /* write to print spool file */
#define SMBsplclose   0xC2   /* close print spool file */
#define SMBsplretq    0xC3   /* return print queue */
#define SMBsends      0xD0   /* send single block message */
#define SMBsendb      0xD1   /* send broadcast message */
#define SMBfwdname    0xD2   /* forward user name */
#define SMBcancelf    0xD3   /* cancel forward */
#define SMBgetmac     0xD4   /* get machine name */
#define SMBsendstrt   0xD5   /* send start of multi-block message */
#define SMBsendend    0xD6   /* send end of multi-block message */
#define SMBsendtxt    0xD7   /* send text of multi-block message */

#ifdef LONGNAMES
/* The following are only available with LANMAN 2.0 Extended File Sharing
 * Protocol as defined in "SMB F. S. P. Extensions Version 3.0", document
 * version 1.11, June 19, 1990.
 */
#define SMBtrans2     0x32   /* transaction2 */
#define SMBtranss2    0x33   /* transaction2 (secondary request/response) */
#define SMBfindclose2 0x34   /* terminates a TRANSACT2_FIND_FIRST/NEXT */
#define SMBecho       0x2B

/* And now the sub-commands for SMBtrans2 */
#define TRANSACT2_FINDFIRST   0x01
#define TRANSACT2_FINDNEXT    0x02
#define TRANSACT2_QUERYFSINFORMATION 0x03
#define TRANSACT2_QUERYPATHINFORMATION 0x05
#endif

#define SUCCESS   0
#define ERRDOS 0x01
#define ERRSRV 0x02
#define ERRHRD 0x03
#define ERRCMD 0xFF


#define SEARCH_TOT_SIZE 43
#define SEARCH_COUNT 10

#define PROT_USERLOGON   1
#define PROT_ENCRYPT     2
#define PROT_READRAW     4
#define PROT_WRITERAW    8
#define PROT_RWMULTI     16
#define PROT_SETDATETIME 32
#define PROT_HAVE_GUID   64

#define SMB_CASELESS   8

#ifdef LONGNAMES
#define SMB_KNOWS_LONG_NAMES	(1)
#define SMB_IS_LONG_NAME	(0x40)
#define SMB_UNICODE		(0x8000)

#define T2FLAGS_LONGNAMES	(1)
#define T2FLAGS_SWAPDATETIME	(2)
#define T2FLAGS_TESTEDSWAP	(4)

#define CAP_EXTENDED_SECURITY	(0x80000000)
#endif

/* Private structures */

#define FREE         0   /* 'flags' values: */
#define ALLOCATED    1   /* True whenever this slot is allocated */
#define CONNECTED    2   /* True if share is connected, to the best of
                             our knowledge */

/* Password fields are strewn around here as mild hacker discouragement */

struct ActiveServer
{
  int      flags;
  time_t   last_xact;

  hSESSION hSession;    /* Only valid if status is IN_USE */
  char     password[NAME_LIMIT];

  int      Uid;        /* User identifier */
  int      Sesskey;    /* Session key */
  int      ProtFlags;  /* USERLOGON/ENCRYPT etc */
  int      SMB_flg;    /* Flags to pass in SMB_flg field */
#ifdef LONGNAMES
  int      SMB_flg2;   /* Flags to pass in SMB_flg2 field */
  int      t2flags;
#endif
  int      prot;       /* which protocol was nogitated */
  char     guid[16];   /* GUID returned from NT negprot commands */
  int      bloblen;
  BYTE     *blob;
  char     servname[NAME_LIMIT]; /* upper case */
  char     username[NAME_LIMIT]; /* case preserved */
};

typedef struct ActiveServer *hSERVER;

struct ActiveShare
{
  int     flags;

  char    password[NAME_LIMIT];
  hSERVER hServer;  /* Only valid if status is IN_USE */
  int     sharetype;

  int     Tid;          /* Tree ID */
  int     Uid;          /* User ID */
  int     Datasize;
  int     FH_base;    /* Base number for file handles */
  char    drvletter;  /* Letter for identifying 'drive' */
  char    sharename[SHARENAME_LEN];  /* upper case */
};


#define GetFid(FH) ((FH) & 0xFFFF)
#define MakeFH(pS,FID) ((pS)->FH_base | (FID & 0xFFFF) )

#ifdef LONGNAMES
static err_t SMB_Transact2 ( hSHARE hS, struct TransactParms *pT );
#endif

/* SMB globals ======================================================== */

static SMBHDR SMB_TxHdr;
static WORD   SMB_TxWords [MAX_WCT+1];

static SMBHDR SMB_RxHdr;
static WORD   SMB_RxWords [MAX_WCT];
static WORD   SMB_RxByteCount;
static int    SMB_RxWordCount;

static struct ActiveServer SMB_Servers[MAX_SERVERS];
static struct ActiveShare  SMB_Shares[MAX_SHARES];

BYTE   SMB_WorkBuf[SMBWORKBUF_SIZE];


/* SMB routines ======================================================== */

static int DOS_Errs[] =
{
  18, ENOMOREFILES,
  2,  EFILENOTFOUND,
  12, ENOTPRESENT,  /* Returned by OS2-Connect from SetAttrib */
  50, ENOTPRESENT,  /* Return~ed by W4WG from SetAttrib call */
  110, EFILENOTFOUND, /* Returned by OS2 servers for hidden files */
  3,  EPATHNOTFOUND,
  1,  EBADPARAM,
  5,  ENOACCESS,
  16, ESHARING,     /* Attempt to remove current dir on server */
  80, EFILEEXISTS,
  32, ESHARING,     /* Normal sharing violation */
  67, ENOSUCHSHARE, /* Returned by NT3.5 for bad share names */
  112, EDISKFULL,   /* Returned by NT3.5 when disk full */
  65, ENOACCESS,    /* Returned by W4WG on set-attribs on CDROM */
  145, EDIRNOTEMPTY, /* Attempt to remove non-empty directory */
  -1, EDOSERROR
};

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

static int SMB_Errs[] =
{
  2,  EBADPASSWD,
  4,  ENOACCESS,
  6,  ENOSUCHSHARE,
  5,  ENOACCESS,     /* Returned by W4WG when password changed */
  2239, EACCDISABLED,
  -1, ESERVERROR
};

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

static err_t Err_Translate ( int class, int code )
{
  int *p1;

  debug2(" SMB-Err class %d number %d\n", class, code );

  if ( class == 0 )
    return OK;
  else if ( class == ECLASS_DOS )
    p1 = DOS_Errs;
  else if ( class == ECLASS_SRV )
    p1 = SMB_Errs;
  else if ( class == ECLASS_HARD )
    return EHARDERROR;
  else
    return EPROTOCOLERR;

  while ( *p1 >= 0 && *p1 != code )
    p1 += 2;

  debug1(" Unknown err code %d\n", code );
  return p1[1];
}


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

static BUFCHAIN MkDataBlock ( BUFCHAIN pB, int type,
                                    BYTE *ptr, int len, bool indirect )
{
  BYTE   hdrblk[4];

  if ( len > 0 )
  {
    if ( indirect )
      pB = AddChainIndirect ( pB, ptr, len );
    else
      pB = AddChain ( pB, ptr, len );

    if ( pB == NULL ) return NULL;
  }

  hdrblk[0] = type;
  hdrblk[1] = len & 0xFF;
  hdrblk[2] = len >> 8;

  return AddChain ( pB, hdrblk, 3 );
}

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

/* This routine takes an ASCII string and encodes it into Unicode by
 * inserting extra zero bytes between each character and at the end
 * It adds the resulting string to the given BUFCHAIN.  It optimises
 * for strings up to AUSTC_SKIP chars long.
 */
#if 0
static BUFCHAIN AddUnicodeStringToChain ( BUFCHAIN pB, char *str )
{
#define AUSTC_SKIP 18
        int len = strlen(str)+1, skiplen, cp;
        char ucbuf[AUSTC_SKIP*2];

	skiplen = len % AUSTC_SKIP;
	len -= skiplen;

        do {
                for (cp = skiplen - 1; cp>=0; --cp) {
                        ucbuf[cp*2] = str[len + cp];
                        ucbuf[cp*2+1] = '\0';
                }
                pB = AddChain(pB, ucbuf, skiplen * 2);
                skiplen = AUSTC_SKIP;
                len -= skiplen;
        } while (pB && len >= 0);

        return pB;
}
#endif

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

static BUFCHAIN MkDataString ( BUFCHAIN pB, int type, char *ptr )
{
  BYTE   hdrblk[4];

  pB = AddChain ( pB, ptr, strlen(ptr)+1 );

  if ( pB == NULL ) return NULL;

  hdrblk[0] = type;

  return AddChain ( pB, hdrblk, 1 );
}


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

#ifdef DEBUG
static void DumpBuffer(void *ptr, int len)
{
        static char DumpBuf[256];
        const char *membuf = ptr;
        char *db;
        int i,j;
        db = DumpBuf;
        *db = 0;
        for (i=0; i<((len+31)&~31); ++i) {
                if (!(i & 31)) {
                        db += sprintf(db, "  ");
                        if (i) for (j = i - 32; j != i; ++j) {
                                db += sprintf(db, "%c", (membuf[j]>=32 && membuf[j] != 0x7f) ?
                                membuf[j] : '.');
                        }
                        dprintf(("BufferDump", "%s\n", DumpBuf));
                        db = DumpBuf;
                        db += sprintf(db, "%04x: ", i);
                }
                if (i>=len) {
                        db += sprintf(db, "  ");
                        if ((i & 1)) db += sprintf(db, " ");
                }
                else {
                        db += sprintf(db, "%02x", membuf[i]);
                        if ((i & 1)) db += sprintf(db, " ");
                }
        }
        if (i) for (db += sprintf(db, "  "), j = i - 32; j != i; ++j) db += sprintf(db, "%c",
            j>=len ? ' ' : (membuf[j]>=32 && membuf[j] != 0x7f) ?
            membuf[j] : '.');
	dprintf(("BufferDump", "%s\n", DumpBuf));
}
#else
#define DumpBuffer(ptr, len) ((void)0)
#endif

#ifdef DEBUG
static BUFCHAIN DumpChain(BUFCHAIN pB)
{
        static char membuf[32768];
        int len = ChainLen(pB);

        GetData ( pB, membuf, len);
        FreeChain(pB);
        pB = AddChain ( NULL, membuf, len);
        if (pB == NULL)
                return NULL;
        DumpBuffer(membuf, len);
        return pB;
}
#else
#define DumpChain(pB) (pB)
#endif

#ifdef DEBUG
typedef struct {
        const char *name;
        int size;
} DumpVarStr;
#define DVS_MK(name,type) {name, sizeof(type)}
#define DVS_END {0,0}

DumpVarStr dvs_NTnegprot[] = {
	DVS_MK("dialect", WORD),
	DVS_MK("securitymode", BYTE),
	DVS_MK("maxmpx", WORD),
	DVS_MK("maxvcs", WORD),
	DVS_MK("maxbuffersize", DWORD),
	DVS_MK("maxrawsize", DWORD),
	DVS_MK("sessionkey", DWORD),
	DVS_MK("capabilities", DWORD),
	DVS_MK("systimelo", DWORD),
	DVS_MK("systimehi", DWORD),
	DVS_MK("servertimezone", WORD),
	DVS_MK("securitybloblen", BYTE),
	DVS_END
};

DumpVarStr dvs_negprot[] = {
	DVS_MK("dialect", WORD),
	DVS_MK("securitymode", WORD),
	DVS_MK("maxbuffersize", DWORD),
	DVS_MK("maxmpx", WORD),
	DVS_MK("maxvcs", WORD),
	DVS_MK("rawmode", WORD),
	DVS_MK("sessionkey", DWORD),
	DVS_MK("systime", WORD),
	DVS_MK("sysdate", WORD),
	DVS_MK("challengelen", WORD),
	DVS_MK("reserved (MBZ)", WORD),
	DVS_END
};

static void *DumpVar(void *ptr, const char *name, unsigned long sz)
{
        static const char *sizestr[] = { "<NULL>", "UCHAR", "USHORT", "????", "ULONG" };
	BYTE *bptr = ptr;
	unsigned long value = 0;
	unsigned long s;

	for (s=0; s<sz; ++s) {
	        value |= ((unsigned long)(*bptr++) << (s<<3UL));
	}
	dprintf(("%6s %s: %#lx (%ld)\n", sizestr[sz], name, value, value));
	return bptr;

}

static void DumpStruct(void *ptr, const DumpVarStr *dvs)
{
        while (dvs->size) {
                ptr = DumpVar(ptr, dvs->name, dvs->size);
                ++dvs;
        }
}
#else
#define DumpVar(ptr, name, sz) ((void *)(((char *)ptr)+sz))
#define DumpStruct(ptr, str) ((void)0)
#endif

/* Does one SMB command (send & reply).

   hS is the connection handle to do it on (MUST BE VALIDATED!)
   cmd is the command byte value
   wct_in is the number of Tx Words to be sent
   pB_in is any Tx Bytes to be sent afterwards, or NULL
   ppB_out is the address of a variable in which to store a pointer
        to any received bytes. If this is NULL, any received bytes
        will be discarded. If it isn't, either a pointer will be
        stored here (which MUST be freed after use), or NULL will
        be stored if there is any error.

   It will leave results in SMB_RxWords, SMB_RxWordCount and
    SMB_RxByteCount.
*/

/* sbrodie (15 Jan 1999)
 *
 * This function has been split into two parts so that SMB_Transact2 can share the
 * packet response code (now in Do_SMBResponse) with that used by Do_SMB.  SMB_Transact2
 * can have multiple response packets if the data is very large.
 */
static err_t Do_SMBResponse(hSHARE hS, int cmd, BUFCHAIN *ppB_out )
{
  int wct_rx;
  err_t res;
  BUFCHAIN pB_rx;

  if (cmd == SMBchkpth) {
    /* This was just the keep-alive message */
    debug0("Not waiting for response to SMBchkpth request\n");
    return OK;
  }

  /* Get reply */
  res = NB_GetData ( hS->hServer->hSession, &pB_rx, REPLY_TIMEOUT );
  if ( res != OK )
    return res;

  /* Extract received data */
  debug2("Do_SMB (cmd=0x%x) - NB_GetData returned %d bytes\n", cmd, ChainLen(pB_rx));
#ifdef DEBUG
  if (cmd == SMBwriteBraw) pB_rx = DumpChain(pB_rx);
#endif

  SMB_RxHdr.wct = 0;
  SMB_RxByteCount = 0;
  SMB_RxWordCount = 0;

  pB_rx = GetData ( pB_rx, &SMB_RxHdr, SMBHDR_SIZE );
  wct_rx = SMB_RxHdr.wct;

  if (SMB_RxHdr.command == SMBchkpth) {
    /* Discard the 'ping' response */
    debug0("This response was actually to the previous chkpth call\n");
    FreeChain(pB_rx);
    return Do_SMBResponse(hS, cmd, ppB_out);
  }

/* sbrodie: moved this from just above "OK - all was well" comment */
  /* Process errors back from server */
  if ( SMB_RxHdr.errclass != 0 )
  {
    debug1("Do_SMB: errclass was %d\n", SMB_RxHdr.errclass);
    FreeChain(pB_rx);
    return Err_Translate ( SMB_RxHdr.errclass,
        SMB_RxHdr.errlo + (SMB_RxHdr.errhi << 8) );
  }

  if ( wct_rx > MAX_WCT )  /* Dispose of extra word results */
  {
    pB_rx = GetData ( pB_rx, SMB_RxWords, MAX_WCT*2 );
    pB_rx = GetData ( pB_rx, NULL, (wct_rx-MAX_WCT)*2 );
  }
  else if ( wct_rx > 0 )
  {
    pB_rx = GetData ( pB_rx, SMB_RxWords, wct_rx*2 );
  }

  pB_rx = GetData(pB_rx, &SMB_RxByteCount, 2); /* Get byte count */

  if ( pB_rx == NULL ) /* It's all gone horribly wrong! */
    return EDATALEN;

  /* OK - all was well */
#ifdef DEBUG
  if (cmd == SMBnegprot) debug2("Protocol negotiation returned %d words and %d bytes\n",
          wct_rx, SMB_RxByteCount);
#endif

  SMB_RxWordCount = wct_rx;

  if ( ppB_out != NULL )
    *ppB_out = pB_rx;     /* Hand over ownership */
  else
    FreeChain(pB_rx);
  return OK;
}

static err_t Do_SMB_threadsafe ( hSHARE hS, int cmd, int wct_in, BUFCHAIN pB_in,
                      BUFCHAIN *ppB_out )
{
  err_t res;
  hSESSION hSess;

  (void) time(&hS->hServer->last_xact);

  if ( ppB_out != NULL ) /* If early exit, leave NULL in result */
    *ppB_out = NULL;

  hSess = hS->hServer->hSession;

  /* Fill in parameters for this connection */

  SMB_TxHdr.tid = hS->Tid;
  SMB_TxHdr.uid = hS->hServer->Uid;
  SMB_TxHdr.flg = hS->hServer->SMB_flg;
#ifdef LONGNAMES
  SMB_TxHdr.flg2 = hS->hServer->SMB_flg2;
#endif

  /* Add byte count */

  SMB_TxWords[wct_in] = ChainLen(pB_in);

  /* Add parameter words */

  pB_in = AddChain ( pB_in, SMB_TxWords, (wct_in*2) + 2 );
  if ( pB_in == NULL )
    return EOUTOFMEM;

  /* Prepare & add header */

  SMB_TxHdr.command = cmd;
  SMB_TxHdr.wct     = wct_in;

  pB_in = AddChain ( pB_in, &SMB_TxHdr, SMBHDR_SIZE );
  if ( pB_in == NULL )
    return EOUTOFMEM;

  /* Send data */

  res = NB_ClearRxQueue ( hSess );
  if (res != OK) {
    debug0("****************** NB_ClearRxQueue says there was stuff pending!!!!!!!!\n");
  }

  res = NB_SendData ( hSess, pB_in );
  if ( res != OK )
    return res;

  return Do_SMBResponse(hS, cmd, ppB_out);
}

static err_t Do_SMB ( hSHARE hS, int cmd, int wct_in, BUFCHAIN pB_in,
                      BUFCHAIN *ppB_out )
{
  static volatile int threaded = 0;

  if (threaded) {
    return ELANMANFSINUSE;
  }
  else {
     err_t res;
     ++threaded;
     res = Do_SMB_threadsafe(hS, cmd, wct_in, pB_in, ppB_out);
     --threaded;
     return res;
  }
}


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

/* This attempts to do a ReadRaw on a given file. If there are any errors,
   or we're at end of file, it returns 0. Assume 'hS' etc. has been
   validated.
*/


static int SMB_ReadRaw ( hSHARE hS,
                     int fid, int offset, int len, BYTE *where )
{
  err_t res;
  BUFCHAIN pB;
  hSESSION hSess = hS->hServer->hSession;;

  if (len>RDRAW_BLOCK_SIZE) len=RDRAW_BLOCK_SIZE;

  SMB_TxWords[0] = fid;
  SMB_TxWords[1] = (offset & 0xFFFF);
  SMB_TxWords[2] = (offset >> 16 );
  SMB_TxWords[3] = len;
  SMB_TxWords[4] = 0; /* Minimum returned byte count */

  SMB_TxWords[5] = 0xFFFF; /* Timeout */
  SMB_TxWords[6] = 0xFFFF;

  SMB_TxWords[7] = 0; /* Reserved */
  SMB_TxWords[8] = 0; /* Following byte count */

  pB = AddChain( NULL, SMB_TxWords, 18 );
  if ( pB == NULL )
    return 0;

  SMB_TxHdr.tid = hS->Tid;
  SMB_TxHdr.uid = hS->hServer->Uid;

  SMB_TxHdr.command = SMBreadBraw;
  SMB_TxHdr.wct     = 8; /* Word count */

  pB = AddChain ( pB, &SMB_TxHdr, SMBHDR_SIZE );
  if ( pB == NULL )
    return 0;

  /* Send data */

  NB_ClearRxQueue ( hSess ); /* Ensure reply is correct */

  res = NB_SendData ( hSess, pB );
  if ( res != OK )
  {
    debug1("Send data failed, %d\n", res);
    return 0;
  }

  /* Get reply (raw data block) */

  res = NB_GetBlockData ( hSess, where, &len, REPLY_TIMEOUT );
  if ( res != OK )
    return 0;

  return len;
}

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

static err_t SMB_WriteRaw ( hSHARE hS, int fid, int offset,
                    int len, BYTE *where )
{
  err_t res;

  SMB_TxWords[0] = fid;
  SMB_TxWords[1] = len;
  SMB_TxWords[2] = 0;
  SMB_TxWords[3] = (offset & 0xFFFF);
  SMB_TxWords[4] = (offset >> 16 );
  SMB_TxWords[5] = 0xFFFF; /* Timeout */
  SMB_TxWords[6] = 0xFFFF;

  SMB_TxWords[7] = 0; /* Write mode: write-through */
  SMB_TxWords[8] = 0; /* Reserved */
  SMB_TxWords[9] = 0; /* Reserved */
  SMB_TxWords[10] = 0; /* # of data bytes immediately following */
  SMB_TxWords[11] = 0x3C; /* Offset to immediate data bytes */

  res = Do_SMB ( hS, SMBwriteBraw, 12, NULL, NULL );
  if ( res != OK )
    return res;

  /* If no error, just send the data in a large block. Any errors
     will be picked up on the next write or close operation. If
     we get to this stage, we can assume 'drv' is validated. */

  return NB_SendBlockData ( hS->hServer->hSession, where, len );

}

/* sbrodie: Abstract the dialect strings here - means debug version can
 * call this function to find out which protocol was accepted.  The
 * offsets within the array of each string are vital to SMB_Negotiate.
 */
static char *dialects[] = {
                "PC NETWORK PROGRAM 1.0",
                "DOS LM1.2X002",
                "LM1.2X002",
                "NT LM 0.12"
};
#define MAX_DIALECT ((sizeof(dialects)/sizeof(*dialects))-1)
#define DIALECT_BASIC 0
#define DIALECT_LM12X002 1
#define DIALECT_NT 3
static char *SMB_Dialect(unsigned int num)
{
        if (num <= MAX_DIALECT) return dialects[num];
        return "";
}

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

static err_t SMB_Negotiate( hSHARE hS )
{
  err_t res;
  unsigned int dcount;
  BUFCHAIN pB;

  pB = NULL;

  /* Must be entered in reverse order */
  for (dcount = MAX_DIALECT; ; --dcount) {
    pB = MkDataString( pB, DATA_DIALECT, SMB_Dialect(dcount));
    if (pB == NULL || dcount == 0) break;
  }

  if ( pB == NULL )
    return EOUTOFMEM;

  res = Do_SMB ( hS, SMBnegprot, 0, pB, &pB );
  if ( res != OK )
    return res;

  #ifdef DEBUG
  debug1("Data length on negprot is %d\n", ChainLen(pB));
  {
          static char buf[4096];
          void *ptr = SMB_RxWords;
          int len = ChainLen(pB);
          GetData(pB, buf, len);
          DumpBuffer(buf, len);
          DumpStruct(ptr, (SMB_RxWords[0] >= DIALECT_NT) ? dvs_NTnegprot : dvs_negprot);
  }
  #endif
  FreeChain(pB);

  debug1("Negotiated protocol `%s'\n", SMB_Dialect(SMB_RxWords[0]));
  hS->hServer->prot = SMB_RxWords[0];
  if ( SMB_RxWords[0] >= DIALECT_LM12X002 )
  {
    if (SMB_RxWords[0] >= DIALECT_NT) {
      /* grr - different response format */
      hS->hServer->ProtFlags = PROT_RWMULTI + PROT_SETDATETIME +
         (SMB_RxWords[9] & 0x100 ? PROT_READRAW+PROT_WRITERAW : 0 ) +
         (SMB_RxWords[1] & 1 ? PROT_USERLOGON : 0 ) +
         (SMB_RxWords[1] & 2 ? PROT_ENCRYPT : 0 );
      if (SMB_RxWords[10] & 0x80) {
        /* CAP_EXTENDED_SECURITY */
        hS->hServer->ProtFlags |= PROT_HAVE_GUID;
        GetData(pB, hS->hServer->guid, 16);
        debug0("Found a GUID block in the data section\n");
      }
      else {
        /* No bit */
        debug0("No extended security - no GUID in the data block\n");
      }
      hS->hServer->bloblen = SMB_RxWords[16] >> 8;
    }
    else {
      hS->hServer->bloblen = SMB_RxWords[11];
      hS->hServer->ProtFlags = PROT_RWMULTI + PROT_SETDATETIME +
         (SMB_RxWords[1] & 1 ? PROT_USERLOGON : 0 ) +
         (SMB_RxWords[1] & 2 ? PROT_ENCRYPT : 0 ) +
         (SMB_RxWords[5] & 1 ? PROT_READRAW : 0 ) +
         (SMB_RxWords[5] & 2 ? PROT_WRITERAW : 0 );
    }
    hS->hServer->SMB_flg = SMB_CASELESS;
#ifdef LONGNAMES
    debug0("Enabling long filenames on this share\n");
    hS->hServer->SMB_flg2 = SMB_KNOWS_LONG_NAMES; /* | SMB_IS_LONG_NAME;*/
    hS->hServer->t2flags = T2FLAGS_LONGNAMES;
#endif
    hS->hServer->Sesskey = SMB_RxWords[6] | (SMB_RxWords[7] << 16);
    if (hS->hServer->bloblen > 0) {
      free(hS->hServer->blob);
      hS->hServer->blob = malloc(hS->hServer->bloblen);
      if (hS->hServer->blob != NULL) {
        GetData(pB, hS->hServer->blob, hS->hServer->bloblen);
      }
    }
    else {
      hS->hServer->blob = 0;
    }
  }
  else
  {
    hS->hServer->ProtFlags = PROT_SETDATETIME;
    hS->hServer->SMB_flg = 0;
#ifdef LONGNAMES
    hS->hServer->t2flags = 0;
    hS->hServer->SMB_flg2 = 0;
#endif
  }
  debug1("%s-level security\n", hS->hServer->ProtFlags & PROT_USERLOGON ? "User" : "Share");
  return OK;
}

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

/* Session setup logs the user on with a given name and password */

static err_t SMB_SessSetup ( hSHARE hS, char *userid, char *passwd )
{
  BUFCHAIN pB;
  err_t res;

  SMB_TxWords[0] = 0x00FF; /* No additional command */
  SMB_TxWords[1] = 0;      /* Offset to next cmd */
  SMB_TxWords[2] = 4096;   /* Our buffer size */
  SMB_TxWords[3] = 0;      /* Max pending requests */
  SMB_TxWords[4] = 0;      /* First & only VC */
  SMB_TxWords[5] = hS->hServer->Sesskey & 0xFFFF;
  SMB_TxWords[6] = hS->hServer->Sesskey >> 16;

  if (hS->hServer->prot < DIALECT_NT) {
    pB = AddChain ( NULL, userid, strlen(userid)+1 );
    if ( pB != NULL ) pB = AddChain ( pB, passwd, strlen(passwd)+1 );
    if ( pB == NULL )
      return EOUTOFMEM;

    SMB_TxWords[7] = strlen ( passwd ) + 1;
    SMB_TxWords[8] = 0;
    SMB_TxWords[9] = 0;

    res = Do_SMB ( hS, SMBsesssetup, 10, pB, NULL );
  }
  else if (hS->hServer->ProtFlags & PROT_HAVE_GUID) {
    /* CAP_EXTENDED_SECURITY is supported by the server - setup session accordingly */
    SMB_TxWords[7] = hS->hServer->bloblen;
    SMB_TxWords[8] = SMB_TxWords[9] = 0; /* reserved */
    SMB_TxWords[10] = SMB_TxWords[11] = 0; /* client capabilities */
    pB = AddChain ( NULL, hS->hServer->blob, hS->hServer->bloblen );
    if (pB == NULL )
      return EOUTOFMEM;
    res = Do_SMB ( hS, SMBsesssetup, 12, pB, NULL );
  }
  else {
    /* Server does not support extended security */
    SMB_TxWords[7] = strlen ( passwd );
    SMB_TxWords[8] = 0;
    SMB_TxWords[9] = SMB_TxWords[10] = 0; /* Reserved */
    SMB_TxWords[11] = SMB_TxWords[12] = 0; /* client capabilities */
    pB = AddChain(pB, "CIFS", sizeof("CIFS"));
    if (pB) pB = AddChain(pB, "\0RISCOS", sizeof("\0RISCOS"));
    if (pB) pB = AddChain(pB, userid, strlen(userid) + 1);
    if (pB) pB = AddChain(pB, passwd, strlen(passwd));
    if (pB) pB = DumpChain(pB);
// FreeChain(pB); return EOUTOFMEM;
    if (pB == NULL)
      return EOUTOFMEM;
    res = Do_SMB ( hS, SMBsesssetup, 13, pB, NULL );
  }
  if ( res != OK )
    return res;

  hS->hServer->Uid = SMB_RxHdr.uid;

  return OK;
}

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

/* Keep in step with #defines in H.SMB ! */

static char *sharetype_str[4] =
{
  "A:", "LPT1:", "COMM", "IPC"
};

/* ConnectShare connects to a given share, with share name & type &
   password as given in the hSHARE structure. hS->hServer is
   assumed to be valid & connected
*/

static err_t ConnectShare ( hSHARE hS )
{
  BUFCHAIN pB;
  err_t res;

  /* Mild sanity check */

  if ( hS==NULL || hS->hServer==NULL ||
       hS->sharetype < 0 || hS->sharetype > 3 )
    return EBADPARAM;

  debug3("Connect share %c to \\\\%s\\%s\n", hS->drvletter,
            hS->hServer->servname, hS->sharename );

  pB = MkDataString( NULL, DATA_ASCII, sharetype_str[hS->sharetype] );

  if ( pB == NULL ) return EOUTOFMEM;

  /* For user-based logon schemes, there is not a password for
      tree connect */

  if ( hS->hServer->ProtFlags & PROT_USERLOGON )
    pB = MkDataString ( pB, DATA_ASCII, "" );
  else
  {
    Xlt_Unjumble ( hS->password );
    pB = MkDataString ( pB, DATA_ASCII, hS->password );
    Xlt_Jumble ( hS->password );
  }

  if ( pB == NULL ) return EOUTOFMEM;

  /* Path name is of the form \\SERVER\SHARENAME */

  sprintf( (char*)SMB_WorkBuf, "\\\\%s\\%s", hS->hServer->servname,
                                             hS->sharename );
  pB = MkDataString ( pB, DATA_ASCII, (char *)SMB_WorkBuf );

  if ( pB == NULL ) return EOUTOFMEM;

  /* Do connection */

  res = Do_SMB ( hS, SMBtcon, 0, pB, NULL );

  if ( res == OK )
  {
    hS->Tid      = SMB_RxWords[1];
    hS->Datasize = SMB_RxWords[0];
    hS->flags   |= CONNECTED;     /* Clear CONN_LOST flag */
  }

  return res;
}



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

static err_t DisconnectShare ( hSHARE hS )
{
  if ( hS==NULL )       /* Shouldn't happen, but make sure */
    return EBADPARAM;

  debug3("Disconnect share %c from \\\\%s\\%s\n", hS->drvletter,
            hS->hServer->servname, hS->sharename );

  /* Say connection has been broken; if the operation fails it's
     probably been broken already */

  hS->flags &= ~CONNECTED;

  /* Do SMB Tree disconnect operation */
  return Do_SMB ( hS, SMBtdis, 0, NULL, NULL );
}

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

/* ConnectServer attempts to connect to a given server. It is actually
   passed an hSHARE handle for internal reasons. It it assumed that
   hS->hServer has been set up to point to a valid server, and that
   the server name, user name & password are set up correctly.
*/

static err_t ConnectServer ( hSHARE hS )
{
  NETNAME nnserver;
  hSERVER hSrv;
  err_t res;

  if ( hS == NULL || (hSrv=hS->hServer, hSrv == NULL) )
    return EBADPARAM;

  debug1("Connect server %s\n", hSrv->servname);

  /* Set initial values */

  hSrv->ProtFlags = 0;
  hSrv->SMB_flg = 0;
  hSrv->Uid = 0;
  hSrv->Sesskey = 0;
  hSrv->hSession = NULL;

  /* Try to contact server */

  debug0("NB_FormatName..\n");
  res = NB_FormatName ( ntSERVER, hSrv->servname, &nnserver );
  if ( res != OK )
    return res;

  /* Try to contact server */

  debug0("NB_OpenSession..\n");
  res = NB_OpenSession( NB_MachineName, &nnserver, &(hSrv->hSession) );
  if ( res != OK )
    return res;

  /* Establish protocol */

  debug0("SMB_Negotiate..\n");
  res = SMB_Negotiate ( hS );
  if ( res != OK )
    goto abort_server;

  /* Logon user, if it's that sort of server */

  if (hSrv->ProtFlags & PROT_USERLOGON)
  {
    Xlt_Unjumble(hSrv->password);
  debug0("SMB_SessSetup..\n");
    res = SMB_SessSetup ( hS, hSrv->username, hSrv->password );
    Xlt_Jumble(hSrv->password);

    if ( res != OK ) goto abort_server;
  }

  debug0("ConnectServer succeeds\n");

  return OK;

abort_server:
  NB_CloseSession(hSrv->hSession);
  hSrv->hSession = NULL;
  return res;
}

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

static err_t DisconnectServer ( hSERVER hSrv )
{
  int i;
  hSHARE hS;

  if ( hSrv == NULL )
    return EBADPARAM;

  debug1("Disconnect server %s\n", hSrv->servname);

  /* Disconnect Server implicity closes all shares using it;
     fortunately, the server will do all this if we drop the
     link. All we have to do is mark the relevant shares as being
     disconnected.
  */

  hS = SMB_Shares;
  for ( i=0; i < MAX_SHARES; i++ )
  {
    if ( (hS->flags & ALLOCATED) &&
         (hS->hServer == hSrv )     )
      hS->flags &= ~CONNECTED;

    hS++;
  }

  /* Close NetBIOS session */
  if ( hSrv->hSession != NULL )
  {
    NB_CloseSession(hSrv->hSession);
    hSrv->hSession = NULL;
  }
  return OK;
}

/* As a general rule, the routines above don't perform
   any allocation/deallocation functions, only the network
   transactions themselves. These are dealt with in the following
   bits.
*/

/* ==========================================  */

static hSERVER AllocServer ( void )
{
  hSERVER hS;
  int i;

  for ( hS = SMB_Servers, i=0; i < MAX_SERVERS; hS++, i++ )
    if ( (hS->flags & ALLOCATED)==0 )
    {
      hS->flags = ALLOCATED;
      hS->hSession = 0;
      hS->blob = 0;
      return hS;
    }

  return NULL;
}

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

static hSHARE AllocShare ( void )
{
  hSHARE hS;
  int i;

  for ( hS = SMB_Shares, i=0; i < MAX_SHARES; hS++, i++ )
    if ( (hS->flags & ALLOCATED)== 0 )
    {
      hS->flags = ALLOCATED;
      hS->hServer = NULL;
      hS->Tid=0;
      hS->Datasize=0;
#ifdef LONGNAMES
      hS->hServer->t2flags = 0;
#endif
      return hS;
    }

  return NULL;
}

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

static bool ServerInUse ( hSERVER hServ )
{
  int i;
  hSHARE hS;

  for ( hS=SMB_Shares, i=0; i<MAX_SHARES; hS++, i++ )
  {
    if ( hS->hServer == hServ && (hS->flags & ALLOCATED)  )
      return true;
  }

  return false;
}

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

static hSERVER FindServer ( char *serv_name )
{
  hSERVER hS;
  int i;

  for ( hS = SMB_Servers, i=0; i < MAX_SERVERS; hS++, i++ )
  {
    if ( (hS->flags & ALLOCATED) &&
         stricmp ( hS->servname, serv_name ) == 0
       )
      return hS;
  }

  return NULL;
}

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

static hSHARE FindShare ( hSERVER hServ, char *share_name )
{
  hSHARE hS;
  int i;

  for ( hS = SMB_Shares, i=0; i < MAX_SHARES; hS++, i++ )
  {
    if ( hS->hServer == hServ && (hS->flags & ALLOCATED) &&
         stricmp ( hS->sharename, share_name ) == 0
       )
      return hS;
  }

  return NULL;
}


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

static void FreeServer ( hSERVER hS )
{
  if (hS->flags != FREE) {
    free(hS->blob);
    hS->blob = NULL;
  }
  hS->flags = FREE;
}

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

static void FreeShare ( hSHARE hS )
{
  hS->flags = FREE;
}

/* =======================================  */

/* Validates a share, given a filename (the first character being the
   drive letter). If the link to the server has failed, it will
   attempt to reconnect it before returning.

   Unlike most routines, it returns an hSHARE as a result and an error
   via a pointer. The hSHARE will be non-Null if & only if the result is
   OK; it is acceptable to test either.
*/

static hSHARE GetShare ( const char *filename, err_t *pRes )
{
  uint tmp;
  hSHARE hS;
  err_t res;

  /* Is drive letter in range & in use? */

  tmp = filename[0] - 'A';
  if ( tmp >= MAX_SHARES ||
        (hS=&SMB_Shares[tmp], (hS->flags & ALLOCATED)==0) )
  {
    *pRes = EBADDRV;
    return NULL;
  }

  /* Can we still talk to the server */

  if ( !NB_LinkOK ( hS->hServer->hSession ) )
  {
    DisconnectServer(hS->hServer);      /* Drop links, deallocate stuff */

    res = ConnectServer(hS);   /* Try to reconnect to server */
    if ( res != OK )
    {
      *pRes = res;
      return NULL;
    }
  }

  /* Server works, now see if we need reconnecting */

  if ( (hS->flags & CONNECTED) == 0 )
  {
    res = ConnectShare(hS);
    if ( res != OK )
    {
      *pRes = res;
      return NULL;
    }
  }

  *pRes = OK;
  return hS;
}


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

/* GetShareNoConn() is used to validate a drive letter when
    we aren't bothered if the connection is lost (e.g. for
    the GetConnInfo or DisconnectShare calls)
*/
static hSHARE GetShareNoConn ( uint letter )
{
  letter -= 'A';
  if ( (letter < MAX_SHARES) &&
       (SMB_Shares[letter].flags & ALLOCATED) )
    return &SMB_Shares[letter];

  return NULL;
}


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

/* SMB_IsLongNameFS() returns true if the path refers to a share which is using long
    filenames.  Xlate.c needs to know this in order to determine which set of file
    mappings is to be used.
 */
bool SMB_IsLongNameFS( const char * path)
{
  hSHARE hS;

  hS = GetShareNoConn(*path);
  if (hS != NULL && (hS->hServer->t2flags & T2FLAGS_LONGNAMES)) return true;
  return false;
}


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

/* When trying to get a share ID from a file handle, there's
   no point reconnecting, because the handle wouldn't be valid
   anyway.
*/

static hSHARE GetShareFromFH ( uint FH, err_t *pRes )
{
  FH = (FH >> 16);  /* Get share identifier from file handle */
  if ( FH < MAX_SHARES )
  {
    hSHARE hS=&SMB_Shares[FH];

    if ( (hS->flags & (ALLOCATED|CONNECTED))  == (ALLOCATED|CONNECTED) )
      return hS;
  }

  *pRes = EFILEHANDLE;
  return NULL;
}

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

static err_t SMB_SingleOp ( int op, char *path )
{
  BUFCHAIN pB;
  hSHARE hS;
  err_t res;

  hS = GetShare (path, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString( NULL, DATA_ASCII, path+2 );
  if ( pB == NULL )
    return EOUTOFMEM;

  return Do_SMB ( hS, op, 0, pB, NULL );
}

/* Public Connect/disconnect operations ====================== */

/* CreateShare can do about five different things, depending on
    the current state of the system. See SMB.H for full
    description of the parameters. Scenarios include
    - connection to a new share on a new server
    - if we're already connected to the given server and the
        given user name is blank or the same, connect to a new
        share on the same server.
    - if we're already connected to the given server and the
        given user name is different, reconnect to the server;
        the share name may be the same as an existing name (in
        which case we're just changing user ID) or it may be
        a new one (in which case it needs adding)
    - if all of (server name, user name, share name) are the
        same, return the drive letter corresponding to this
        connection.

    This is all a bit of a logical nightmare, especially as we
    have to back out gracefully if any bit fails, so I've written
    it out using flags which get set as each thing needs to be
    done.

*/

static bool IsBlank ( char *str )
{
  while ( isspace(*str) ) str++;  /* Skip leading spaces */

  if ( iscntrl(*str) )            /* If it's the end, it's blank */
    return true;

  return false;
}

#define ALLOC_SERVER   1
#define ALLOC_SHARE    2
#define DISCONN_SERVER 4
#define CONN_SERVER    8

err_t SMB_CreateShare (  int sharetype_in,
                         int style,
                         char *servname_in, char *sharename_in,
                         char *username_in, char *password_in,
                         char *drv_letter_out )
{
  hSHARE hShare;
  hSERVER hServ;
  char uc_sharename[SHARENAME_LEN];
  char uc_servname [NAME_LIMIT];
  char plain_password[NAME_LIMIT];
  int to_do, done;
  err_t res;

  /* Validate & format parameters */
#ifdef TRACE
  debug2("Server name %p; share name %p\n", servname_in, sharename_in);
  debug2("Server name `%s'; share name `%s'\n", servname_in, sharename_in);
#endif

  if ( servname_in == NULL || sharename_in==NULL )
    return EBADPARAM;

  strcpyn_upper ( uc_sharename, sharename_in, SHARENAME_LEN);
  strcpyn_upper ( uc_servname,  servname_in, NAME_LIMIT);

  if ( username_in == NULL ) username_in = "";
  if ( password_in == NULL ) password_in = "";

  /* Work out a list of what we have to do ------------ */

  to_do = 0;

  hServ = FindServer ( uc_servname );

  if ( hServ == NULL )  /* New server */
  {
    hShare = NULL;
    to_do |= (ALLOC_SERVER | ALLOC_SHARE | CONN_SERVER);

    /* If both names are blank, use logon names */
    if ( IsBlank(username_in) && IsBlank(password_in) )
    {
      username_in = LM_Vars.username;
      Xlt_Unjumble ( LM_Vars.password_ptr );
      strcpyn ( plain_password, LM_Vars.password_ptr, NAME_LIMIT );
      Xlt_Jumble ( LM_Vars.password_ptr );
      password_in = plain_password;
    }
  }
  else
  {
    /* Already have connection to server */
    hShare = FindShare(hServ, uc_sharename);

    if ( hShare == NULL ) /* New share on existing server */
      to_do |= (ALLOC_SHARE);

    /* Check if user name is being given. If not,
       disconnect and reconnect to force name change */

    if ( (style & CREATE_NEW_USER) && !IsBlank (username_in)  )
      to_do |= (DISCONN_SERVER | CONN_SERVER);
  }

  /* Check that's OK with the given style ----- */

  if ( (style & CREATE_NEW_SHARE) && !(to_do & ALLOC_SHARE) )
  {
    /* If the share already exists, and the 'insist it's something
       new' bit is set,  we fail the call and say  which drive letter
       it is. Otherwise, we drop through the rest of the code - the
       only thing that might happen is a disconnect/reconnect to
       change user ID */
    *drv_letter_out = hShare->drvletter;
    return ECONNEXISTS;
  }

  /* Now do each bit ----------------------- */

  done = 0;

  /* Ensure hServ is allocated */
  if ( to_do & ALLOC_SERVER )
  {
    hServ = AllocServer();
    if ( hServ == NULL )
    {
      res = ECONNLIMIT;
      goto fail;
    }
    strcpy  ( hServ->servname, uc_servname );
    done |= ALLOC_SERVER;
  }

  /* Ensure hShare is allocated & set up */
  if ( to_do & ALLOC_SHARE )
  {
    hShare = AllocShare();
    if ( hShare == NULL )
    {
      res = ECONNLIMIT;
      goto fail;
    }

    /* Assume flags don't have CONNECTED set */
    hShare->hServer = hServ;
    hShare->sharetype = sharetype_in;
    strcpy  ( hShare->sharename, uc_sharename );
    strcpyn_upper ( hShare->password, password_in, NAME_LIMIT );
    Xlt_Jumble(hShare->password);
    done |= ALLOC_SHARE;
  }

  /* Clear attribute-file cache for the drive */

  Attr_InvalidateDrive ( hShare->drvletter );

  /* Disconnect server if new user */

  if ( to_do & DISCONN_SERVER )
  {
    /* For a change of user, disconnect the server. It will mark
       all attached shares as being disconnected */
    DisconnectServer ( hServ );
    done |= DISCONN_SERVER;
  }

  /* (re)connect to server */

  if ( to_do & CONN_SERVER )
  {
    /* Set up new server details */
    strcpyn_upper ( hServ->username, username_in, NAME_LIMIT );
    strcpyn_upper ( hServ->password, password_in, NAME_LIMIT );
    Xlt_Jumble(hServ->password);

    res = ConnectServer ( hShare );
    if ( res != OK )
      goto fail;

    done |= CONN_SERVER;
  }

  /* Connect to share ------------------- */

  /* Reconnect share, & reconnect link if it's down */
  if ( GetShare ( &(hShare->drvletter), &res ) == NULL )
    goto fail;

  *drv_letter_out = hShare->drvletter;
  return OK;

  /* Back out if something goes wrong */

fail:
  if ( done & ALLOC_SHARE )   /* If it was a new share */
    FreeShare(hShare);        /*   free it */

  if ( done & ALLOC_SERVER )  /* If it was a new server... */
  {
    if ( done & CONN_SERVER )  /* Disconnect it if it was */
      DisconnectServer(hServ); /* connected */

    FreeServer(hServ);
  }

  return res;
}

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

err_t SMB_DeleteShare ( char drvlettr )
{
  hSHARE  hShare;
  hSERVER hSrv;

  hShare = GetShareNoConn(drvlettr);
  if ( hShare == NULL )
    return EBADDRV;

  hSrv = hShare->hServer;

  /* Do Tree disconnect */

  DisconnectShare(hShare);
  FreeShare(hShare);

  /* If there are no shares left on this server, drop link */

  if ( !ServerInUse(hSrv) )
  {
    DisconnectServer(hSrv);
    FreeServer(hSrv);
  }

  return OK;
}

/* Public file/directory routines ================================ */

static err_t SMB_ChkPath ( char *path )
{
  return SMB_SingleOp( SMBchkpth, path );
}

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

err_t SMB_MkDir ( char *path )
{
  return SMB_SingleOp( SMBmkdir, path );
}

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

err_t SMB_RmDir ( char *path )
{
  return SMB_SingleOp( SMBrmdir, path );
}

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

err_t SMB_Delete ( char *path )
{
  BUFCHAIN pB;
  hSHARE hS;
  err_t res;

  hS = GetShare (path, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString( NULL, DATA_ASCII, path+2 );
  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = ATTR_NORM;

  return Do_SMB ( hS, SMBunlink, 1, pB, NULL );
}


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

err_t SMB_Rename ( char *oldpath, char *newpath )
{
  BUFCHAIN pB;
  hSHARE hS;
  err_t res;

  if ( oldpath[0] != newpath[0] )  /* Different drives! */
    return EBADRENAME;

  debug2("SMB_Rename: %s %s\n", oldpath+1, newpath+1);
  if (strcmp(oldpath+1, newpath+1) == 0)
    return OK;

  hS = GetShare (oldpath, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString( NULL, DATA_ASCII, newpath+2 );
  if ( pB != NULL ) pB = MkDataString ( pB, DATA_ASCII, oldpath+2 );

  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = ATTR_NORM;

  return Do_SMB ( hS, SMBmv, 1, pB, NULL );
}

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

#ifdef LONGNAMES

/* Some Microsoft servers not sending them in the documented order */
static void swap_time_date(BYTE *p)
{
        BYTE swp;

        swp = p[0];
        p[0] = p[2];
        p[2] = swp;

        swp = p[1];
        p[1] = p[3];
        p[3] = swp;
}

static err_t SMB_GetAttribsX2 (hSHARE hS, char *filename, DOS_ATTRIBS *pAttr )
{
  err_t res;
  BYTE *resb;
  static struct TransactParms tp;

  debug1("SMB_GetAttribs: %s\n", filename);
  resb = NameCache_Locate(filename);
  if (resb != NULL) {
    Transact_init(&tp, 1 * 2);           /* need to initialise tp.data_out_buf!! */
    memcpy( tp.data_out_buf, resb, 23);
    strcpy( (char *) tp.data_out_buf + 23, (char *) resb + 23);
    return Xlt_ExpandSearchEntryX2 ( tp.data_out_buf, NULL, NULL, pAttr, NULL);
  }

  if (!(hS->hServer->t2flags & T2FLAGS_TESTEDSWAP)) {
    /* Need to test whether we have to swap the date/time fields */
    char fnbuffer[8];
    DOS_ATTRIBS aattrbuf;
    hS->hServer->t2flags |= T2FLAGS_TESTEDSWAP;
    fnbuffer[0] = *filename;
    fnbuffer[1] = ':';
    fnbuffer[2] = '\\';
    fnbuffer[3] = '\0';
    debug1("Looking up `%s' to test buffer format\n", fnbuffer);
    if (SMB_GetAttribsX2 ( hS, fnbuffer, &aattrbuf ) == OK) {
      fnbuffer[3] = '\0';
      fnbuffer[4] = '\0';
      Transact_init(&tp, 6 * 2);           /* will accept 6 WORD return params */
      Transact_addsetupword(&tp, TRANSACT2_FINDFIRST);
    if (LM_Vars.namemode & 4) {
      Transact_addword(&tp, ATTR_DIR | ATTR_SYS | ATTR_HID);     /* findfirst_Attribute */
    }
    else {
      Transact_addword(&tp, ATTR_DIR);     /* findfirst_Attribute */
    }
      Transact_addword(&tp, 1);            /* findfirst_SearchCount */
      Transact_addword(&tp, 0);            /* findfirst_flags */
      Transact_addword(&tp, 1);            /* Search level  */
      Transact_addlong(&tp, 0L);           /* reserved, MBZ */
      Transact_addstring(&tp, fnbuffer+2); /* findfirst_FileName[] */
      debug1("Looking for `%s'\n", fnbuffer+2);
      res = SMB_Transact2(hS, &tp);
      if (res == OK) {
        debug0("SMB_Transact2 worked\n");
        SMB_TxWords[0] = Transact_getword(tp.parms_out_buf);
        if (Transact_getword(tp.parms_out_buf + 2) == 1) {
          DOS_ATTRIBS sattrbuf;
          debug1("Filename was `%s'\n", tp.data_out_buf + 23);
          res = Xlt_ExpandSearchEntryX2 ( tp.data_out_buf, NULL, NULL, &sattrbuf, NULL);
          if (res == OK) {
            if (sattrbuf.utime != aattrbuf.utime) {
               debug0("Need to swap date/time!\n");
               hS->hServer->t2flags |= T2FLAGS_SWAPDATETIME;
               swap_time_date(tp.data_out_buf);
               swap_time_date(tp.data_out_buf+4);
               swap_time_date(tp.data_out_buf+8);
               Xlt_ExpandSearchEntryX2 ( tp.data_out_buf, NULL, NULL, &sattrbuf, NULL);
               if (sattrbuf.utime != aattrbuf.utime) {
                 debug0("Didnt get the right thing anyway\n");
               }
               else {
                 debug0("Tested and verified!\n");
               }
            }
            else {
               debug0("Don't need to swap date/time!\n");
            }
          }
        }
      	(void) Do_SMB(hS, SMBfindclose2, 1, NULL, NULL);
      }
      else {
        debug0("SMB_Transact2 failed\n");
      }
    }
  }

  Transact_init(&tp, 1 * 2);
  Transact_addsetupword(&tp, TRANSACT2_QUERYPATHINFORMATION);
  Transact_addword(&tp, 1);  /* information level */
  Transact_addlong(&tp, 0L); /* Reserved */
  Transact_addstring(&tp, filename+2);
  res = SMB_Transact2(hS, &tp);
  if (res != OK)
    return res;
  /*
   * OK.  Who decided that this call should return data in a different
   * format than the FindFirst/FindNext calls.  Need to reverse the times
   * and dates of the file before calling Xlt to expand them ... but only
   * if the remote server has this bug.
   */
  if (hS->hServer->t2flags & T2FLAGS_SWAPDATETIME) {
    swap_time_date(tp.data_out_buf);
    swap_time_date(tp.data_out_buf+4);
    swap_time_date(tp.data_out_buf+8);
  }
  /* end workaround */
  strcpy((char *)tp.data_out_buf+23, filename); /* Xlt_ExpandSearchEntryX2 relies on this */
  return Xlt_ExpandSearchEntryX2 ( tp.data_out_buf, NULL, NULL, pAttr, NULL);
}
#endif /* LONGNAMES */

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

#if 0
err_t SMB_GetAttribs ( char *filename, DOS_ATTRIBS *pAttr )
{
  err_t res;
  BUFCHAIN pB;
  hSHARE hS;

  hS = GetShare (filename, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString ( NULL, DATA_ASCII, filename+2 );
  if ( pB == NULL )
    return EOUTOFMEM;

  res = Do_SMB ( hS, SMBgetatr, 0, pB, NULL );

  if ( res == OK )
  {
    pAttr->attr  = SMB_RxWords[0];
    pAttr->utime = SMB_RxWords[1] + (SMB_RxWords[2] << 16);
    pAttr->length = SMB_RxWords[3] + (SMB_RxWords[4] << 16);
  }

  return res;
}
#else
/* THIS IS A BODGE!!
   The SMB_GetAtr command in NT4.0 returns rubbish the file time;
     it renders this command basically unusable. We have to get the
     same information out via a directory search command instead.
*/

err_t SMB_GetAttribs ( char *filename, DOS_ATTRIBS *pAttr )
{
  err_t res;
  BUFCHAIN pB, pBres;
  hSHARE hS;

  hS = GetShare (filename, &res);
  if ( hS == NULL )
    return res;

#ifdef LONGNAMES
  if (hS->hServer->t2flags & T2FLAGS_LONGNAMES)
    return SMB_GetAttribsX2 (hS, filename, pAttr );
#endif

  pB = MkDataBlock ( NULL, DATA_VARBLK, NULL, 0, false );
  if ( pB != NULL )
    pB = MkDataString ( pB, DATA_ASCII, filename+2 );

  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = 1; /* Count of entries to return */
  SMB_TxWords[1] = ATTR_DIR; /* Return files & directories info */

  res = Do_SMB ( hS, SMBsearch, 2, pB, &pBres );

  if ( res == ENOMOREFILES )
    return EFILENOTFOUND;

  if ( res != OK )
    return res;

  /* Extract all data  */

  FreeChain( GetData ( pBres, SMB_WorkBuf, SMB_RxByteCount ) );

  if ( SMB_RxWords[0] < 1 ) /* No files read */
    return EFILENOTFOUND;

  return Xlt_ExpandSearchEntry ( SMB_WorkBuf+3+SEARCH_ST_SIZE,
               NULL, NULL, pAttr, NULL );

}
#endif

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

static err_t SMB_SetDateTimeAttr ( char *filename, DOS_ATTRIBS *pAttr,
                                         int flags )
{
  BUFCHAIN pB;
  hSHARE hS;
  err_t res;

  hS = GetShare (filename, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString ( NULL, DATA_ASCII, "" );
  if ( pB != NULL )
    pB = MkDataString ( pB, DATA_ASCII, filename+2 );
  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = pAttr->attr;
  if ( flags & PROT_SETDATETIME )
  {
    SMB_TxWords[1] = pAttr->utime & 0xFFFF;
    SMB_TxWords[2] = pAttr->utime >> 16;
  }
  else
  {
    SMB_TxWords[1] = 0;
    SMB_TxWords[2] = 0;
  }
  SMB_TxWords[3] = 0;
  SMB_TxWords[4] = 0;
  SMB_TxWords[5] = 0;
  SMB_TxWords[6] = 0;
  SMB_TxWords[7] = 0;

  return Do_SMB ( hS, SMBsetatr, 8, pB, NULL );
}

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

err_t SMB_SetAttribs ( char *filename, DOS_ATTRIBS *pAttr )
{
  err_t res;

  /* W4WG / Windows 95 barfs if we try to set a file time with this call */
  /* but they can set other attributes, so we have to retry */

  res = SMB_SetDateTimeAttr ( filename, pAttr, PROT_SETDATETIME );
  if ( res != ENOTPRESENT )
    return res;

  /* 1997.04.21 - try really hard to set file attributes first, then
                  date & time by opening and closing the file */

  res = SMB_SetDateTimeAttr ( filename, pAttr, 0 );
  if ( res != OK )
    return res;

  if ( pAttr->utime != 0 && (pAttr->attr & ATTR_DIR) == 0 )
  {
    int FH, tmp;
    DOS_ATTRIBS da;

    res = SMB_Open ( MODE_RD, filename, &da, &FH, &tmp );
    if ( res == OK )
    {
      da.utime = pAttr->utime;
      SMB_Close( FH, &da );
    }
    /* Swallow errors, as this is a bit of a bodge! */
  }

  return OK;
}

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

#ifdef LONGNAMES
static err_t SMB_GetFreeSpaceX2 ( hSHARE hS, struct disk_size_response *pDSR  )
{
  err_t res;
  static struct TransactParms tp;
  BYTE *p;
  DWORD sectors_per_alloc, total_allocs, total_avail_allocs;
  WORD bytes_per_sector;

  Transact_init(&tp, 1 * 2);
  Transact_addsetupword(&tp, TRANSACT2_QUERYFSINFORMATION);
  Transact_addword(&tp, 1);  /* information level */
  res = SMB_Transact2(hS, &tp);
  if (res != OK)
    return res;
  p = tp.data_out_buf + 4;
  sectors_per_alloc = Transact_getlong(p), p += 4;
  total_allocs = Transact_getlong(p), p += 4;
  total_avail_allocs = Transact_getlong(p), p += 4;
  bytes_per_sector = Transact_getword(p);

  pDSR->blksize = bytes_per_sector * sectors_per_alloc;
  pDSR->freeblks =  total_avail_allocs;
  pDSR->totalblks = total_allocs;

  /*
  debug2("S/A %10d %#08x\n", sectors_per_alloc, sectors_per_alloc);
  debug2("T A %10d %#08x\n", total_allocs, total_allocs);
  debug2("TAA %10d %#08x\n", total_avail_allocs, total_avail_allocs);
  debug2("B?S %10d %#08x\n", (DWORD) bytes_per_sector, (DWORD) bytes_per_sector);
  */

  return OK;
}
#endif

err_t SMB_GetFreeSpace ( char lettr, struct disk_size_response *pDSR  )
{
  err_t res;
  hSHARE hS;

  hS = GetShare (&lettr, &res);
  if ( hS == NULL )
    return res;

#ifdef LONGNAMES
  if (hS->hServer->t2flags & T2FLAGS_LONGNAMES)
  {
    return SMB_GetFreeSpaceX2(hS, pDSR);
  }
#endif

  res = Do_SMB ( hS, SMBdskattr, 0, NULL, NULL );

  if ( res == OK )
  {
    pDSR->blksize = SMB_RxWords[1] * SMB_RxWords[2];
    pDSR->freeblks = SMB_RxWords[3];
    pDSR->totalblks = SMB_RxWords[0];
  }

  return res;
}


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

#ifdef LONGNAMES

/* Note.
 *
 * Requesting close_if_done doesn't seem to work (at least on NT 4.0 SP3)
 *
 */
enum {
        ffirst_FORCE_CLOSE = 1,
        ffirst_CLOSE_IF_DONE = 2,
        ffirst_RETURN_KEYS = 4,
        fnext_CONTINUE = 8
};

#ifdef DEBUGLIB
static int SIDS=0;
#endif

static err_t SMB_AbandonFind2( hSHARE hS, WORD dir_handle )
{
        dprintf(("SID", "Terminating search op (dir_handle = 0x%04x) (%d open)\n",
        	dir_handle, --SIDS));
        SMB_TxWords[0] = dir_handle;
        return Do_SMB(hS, SMBfindclose2, 1, NULL, NULL);
}

static err_t SMB_ReadDirEntriesX2 ( hSHARE hS, char *path, int count,
                               ENUM_DIR_FN dirfn, void *private,
                               struct Transact2_SearchContext *con )
{
  char *ptr_last_filename;
  err_t res;
  BYTE *p;
  int n_read = 0;
  int eos;
  int lastname;
  int i;
  const int first_flags = /*ffirst_CLOSE_IF_DONE |*/ ffirst_RETURN_KEYS;
  const int next_flags  = /*ffirst_CLOSE_IF_DONE |*/ ffirst_RETURN_KEYS;// | fnext_CONTINUE;
  int flags;

  if (path != NULL && con->t1.NextSearchOK == true || count < 0) {
     /* We need to abandon the current search attached to dir_handle.
      * Ignore errors.
      */
     debug3("SMB_ReadDirEntriesX2 -> path (%p) NextSearchOK (%d) count (%d)\n",
       path, con->t1.NextSearchOK, count);
     if (con->dir_handle_valid) {
       (void) SMB_AbandonFind2( hS, con->dir_handle );
       con->dir_handle_valid = false;
     }
  }

  con->t1. NextSearchOK = false;
  if (count < 0) return ENOMOREFILES;

  //count = min (count, 10);

  /* Implement directory searching via TRANSACT2/FINDFIRST/FINDNEXT */
  if (path != NULL) {
    /* Initial search - note we accept SIX return parameters - contrary to
     * Microsoft's own document - because it doesn't work if you only pass 5. Grr.
     */
    if (con->dir_handle_valid) {
      SMB_AbandonFind2( hS, con->dir_handle);
      con->dir_handle_valid = false;
    }
    con->resume_key = 0;
    flags = first_flags;
    Transact_init(&con->tp, 6 * 2);           /* will accept 6 WORD return params */
    Transact_addsetupword(&con->tp, TRANSACT2_FINDFIRST);
    if (LM_Vars.namemode & 4) {
      Transact_addword(&con->tp, ATTR_DIR | ATTR_SYS | ATTR_HID);     /* findfirst_Attribute */
    }
    else {
      Transact_addword(&con->tp, ATTR_DIR);   /* findfirst_Attribute */
    }
    Transact_addword(&con->tp, count);        /* findfirst_SearchCount */
    Transact_addword(&con->tp, first_flags);  /* findfirst_flags */
    Transact_addword(&con->tp, 1);            /* Search level  */
    Transact_addlong(&con->tp, 0L);           /* reserved, MBZ */
    Transact_addstring(&con->tp, path+2);     /* findfirst_FileName[] */
    res = SMB_Transact2(hS, &con->tp);
    if (res != OK)
      return res;
    p = con->tp.parms_out_buf;
    con->dir_handle = Transact_getword(p); p += 2;
    con->dir_handle_valid = true;
    dprintf(("SID", "SID = 0x%04hx (%d open)\n", con->dir_handle, ++SIDS));
  }
  else {
    /* continuation */
    flags = next_flags;
    Transact_init(&con->tp, 4 * 2);           /* will accept 4 WORD return params */
    Transact_addsetupword(&con->tp, TRANSACT2_FINDNEXT);
    Transact_addword(&con->tp, con->dir_handle);   /* findnext_DirHandle */
    Transact_addword(&con->tp, count);        /* findnext_SearchCount */
    Transact_addword(&con->tp, 1);            /* Search level  */
    Transact_addlong(&con->tp, con->resume_key);   /* Resume key from previous */
    Transact_addword(&con->tp, next_flags);   /* findnext_flags */
    Transact_addstring(&con->tp, con->last_filename); /* resumption filename */
    res = SMB_Transact2(hS, &con->tp);
    if (res != OK)
      return res;
    p = con->tp.parms_out_buf;
  }
  /* Remainder of response handling is common to both sub-commands */
  n_read = Transact_getword(p); p += 2;
  eos = Transact_getword(p); p += 2;
  p += 2; /* skip error offset */
  lastname = Transact_getword(p);
  if (lastname == 0) {
    ptr_last_filename = NULL;
  }
  else {
    ptr_last_filename = (char *) con->tp.data_out_buf + lastname;
  }

  if (eos) {
          debug0(">> Server said it was the end of the search operation\n");
  }

  p = con->tp.data_out_buf;
  /* At this point, p is pointing to the start of the returned data
   * buffer, n_read contains the number of files known to be in the
   * return buffer, eos is non-zero if the search is completed.
   */
  if (n_read == 0)
    return ENOMOREFILES;

  for (i=1; i <= n_read; ++i) {
    int length;
    DWORD next_resume_key;
    if (flags & ffirst_RETURN_KEYS) {
            next_resume_key = Transact_getlong(p); p += 4;
    }
    length = p[22];
    //debug2("ding - got one (length = %d) `%s'\n", length, p+23);
    //DumpBuffer(p, 2 + 2 + 2 + 2 +2 +2 + 4 + 4 +2 + 1 + length);
    res = dirfn(p, 1, private);
    if (res != OK) {
      /* Entry expander must have run out of space!  Remember where the
       * search was at, and try to rewind it a bit by using the resume
       * key and the last_filename
       */
      /* If the search said this was the end of the search though, it will
       * have already terminated the search, so NextSearchOK becomes false
       * and it will have to restart the search next time around.
       */
       //NextSearchOK = eos ? false : true;
       debug0("Bugger.  Looks like client ran out of space (or could be name xlate code)\n");
       if (eos) {
         (void) SMB_AbandonFind2( hS, con->dir_handle );
         con->dir_handle_valid = false;
       }
       else {
         int j;
         con->t1.NextSearchOK = true;
         for (j=i; j<n_read; ++j) dirfn(p, 1, private);
       }
       return EOUTOFMEM;
    }
    else {
       con->resume_key = next_resume_key;
       ptr_last_filename = (char *) p + 23;
       (void) strncpy(con->last_filename, ptr_last_filename?ptr_last_filename:"",
         sizeof(con->last_filename));
    }
    p += 23 + length + 1;
    if ( i == count )  /* By implication, if n_read >= count */
    {
      debug3("i = %3d; count = %3d; n_read = %3d\n", i, count, n_read);
      debug0("OK - there are more to come later; ");
      if (flags & ffirst_RETURN_KEYS) {
        debug1("Resume key is 0x%08x; ", con->resume_key);
      }
      debug1("Next filename is `%s'\n", con->last_filename);
      con->t1.NextSearchOK = true;
    }
  }

  if (eos) {
          debug0(">> Server said it was the end of the search operation\n");
          con->t1.NextSearchOK = false;
  }

  return con->t1.NextSearchOK ? OK : ENOMOREFILES;
}
#endif

err_t SMB_ReadDirEntries ( char *path, int count,
                               ENUM_DIR_FN dirfn, void *private, Transact_SearchContext *conp )
{
  err_t res;
  int i, n_read;
  BYTE *entry;
  BUFCHAIN pB, pBres;
  static Transact_SearchContext rde_context;
  struct Transact1_SearchContext *con;

  con = (conp == NULL) ? &rde_context.t1 : &conp->t1;
  /* Start or continue search? */

  if ( path != NULL ) /* Start search */
  {
    con->SearchDrive = GetShare(path, &res);
    if ( con->SearchDrive == NULL )
      return res;
  }
  else
  {
    if ( !con->NextSearchOK || con->SearchDrive == NULL )
      return ENOMOREFILES;
  }

#ifdef LONGNAMES
  if (con->SearchDrive->hServer->t2flags & T2FLAGS_LONGNAMES)
  {
     struct Transact2_SearchContext *const t2sc = (conp == NULL) ? &rde_context.t2 : &conp->t2;
     return SMB_ReadDirEntriesX2(con->SearchDrive, path, count, dirfn, private, t2sc);
  }
#endif

  /* Check 'count' */

  if ( count <= 0 )
    return ENOMOREFILES;

  count = min ( count, SEARCH_COUNT ); /* Don't do more than is convenient */

  if ( path != NULL ) /* Starting search */
  {
    pB = MkDataBlock ( NULL, DATA_VARBLK, NULL, 0, false );
    if ( pB != NULL )
      pB = MkDataString( pB, DATA_ASCII, path+2 );
  }
  else                /* Continue search */
  {
    pB = MkDataBlock (NULL, DATA_VARBLK, con->SearchState,
                                      SEARCH_ST_SIZE, false);
    if ( pB != NULL)
      pB = MkDataString( pB, DATA_ASCII, "" );
  }

  if ( pB == NULL )
    return EOUTOFMEM;

  /* Do search */

  SMB_TxWords[0] = count;
  SMB_TxWords[1] = ATTR_DIR /* | ATTR_SYS | ATTR_HID */;
  con->NextSearchOK = false;

  res = Do_SMB ( con->SearchDrive, SMBsearch, 2, pB, &pBres );

  if ( res != OK )
    return res;

  /* Extract all data  */

  FreeChain( GetData ( pBres, SMB_WorkBuf, SMB_RxByteCount ) );

  /* Process it */
  n_read = SMB_RxWords[0];
  entry = SMB_WorkBuf+3;

  for ( i=1; i<=n_read; i++ )
  {
    entry[42] = 0;
    dirfn ( entry+SEARCH_ST_SIZE, 0, private );
    if ( i == count )  /* By implication, if n_read >= count */
    {
      con->NextSearchOK = true;
      memcpy ( con->SearchState, entry, SEARCH_ST_SIZE );
    }
    entry += SEARCH_TOT_SIZE;
  }

  /* Return OK, or 'no more' */
  return con->NextSearchOK ? OK : ENOMOREFILES;
}

/* Public file read/write operations ============================= */


err_t SMB_Create ( char *filename, DOS_ATTRIBS *pInAttr,
                   int *pOutFH )
{
  err_t res;
  BUFCHAIN pB;
  hSHARE hS;

  hS = GetShare(filename, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString ( NULL, DATA_ASCII, filename+2 );
  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = (pInAttr->attr) & (ATTR_RO|ATTR_SYS|ATTR_HID);
  SMB_TxWords[1] = (pInAttr->utime) & 0xFFFF;
  SMB_TxWords[2] = (pInAttr->utime) >> 16;

  res = Do_SMB ( hS, SMBcreate, 3, pB, NULL );
  if ( res == OK )
    *pOutFH = MakeFH(hS, SMB_RxWords[0]);

  return res;
}

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

static int ModeXlate[4] = { MODE_RD, MODE_WR, MODE_RDWR, 0 };

err_t SMB_Open ( int mode, char *filename,
      DOS_ATTRIBS *pOutAttr, int *pOutFH, int *pOutModes )
{
  err_t res;
  BUFCHAIN pB;
  hSHARE hS;

  hS = GetShare(filename, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString ( NULL, DATA_ASCII, filename+2 );
  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = mode;  /* Exclusive access */
  SMB_TxWords[1] = ATTR_RO | ATTR_HID | ATTR_SYS; /* Attribute */

  res = Do_SMB ( hS, SMBopen, 2, pB, NULL );
  if ( res == OK )
  {
    *pOutFH = MakeFH(hS, SMB_RxWords[0]);

    if ( pOutAttr != NULL )
    {
      pOutAttr->attr    = SMB_RxWords[1];
      pOutAttr->utime   = SMB_RxWords[2] + (SMB_RxWords[3] << 16);
      pOutAttr->length  = SMB_RxWords[4] + (SMB_RxWords[5] << 16);
    }

    if ( pOutModes != NULL )
      *pOutModes = ModeXlate[SMB_RxWords[6] & 3];
  }
  return res;
}

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

err_t SMB_GetLength ( int FH, int *pOutLen )
{
  err_t res;
  hSHARE hS = GetShareFromFH(FH, &res);
  if ( hS == NULL )
    return res;

  SMB_TxWords[0] = GetFid(FH);
  SMB_TxWords[1] = 2;  /* SEEK from end */
  SMB_TxWords[2] = 0;  /* Offset 0: Relative to end */
  SMB_TxWords[3] = 0;

  res = Do_SMB ( hS, SMBlseek, 4, NULL, NULL );
  if ( res == OK )
  {
    *pOutLen = SMB_RxWords[0] + (SMB_RxWords[1] << 16);
  }

  return res;
}

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


err_t SMB_Read ( int FH, int offset, int len, BYTE *where,
    int *pOutLen )
{
  int len_left, n_read, fid;
  hSHARE hS;
  BUFCHAIN pB_res;
  err_t res = OK;

  len_left = len;
  hS = GetShareFromFH(FH, &res);
  if ( hS == NULL )
    return res;

  fid = GetFid(FH);

  /* Can a raw block read help us ? */

  if ( hS->hServer->ProtFlags & PROT_READRAW )
  {
    while ( len_left > FILE_BLOCK_SIZE )
    {
      n_read = SMB_ReadRaw ( hS, fid, offset, len_left, where );
      if ( n_read <= 0 )  /* Didn't work? Find out why */
        break;

      len_left -= n_read;
      where    += n_read;
      offset   += n_read;
    }
  }

  /* Conventional read command */

  while ( len_left > 0 )
  {
    SMB_TxWords[0] = fid;
    SMB_TxWords[1] = min(len_left,FILE_BLOCK_SIZE);
    SMB_TxWords[2] = offset & 0xFFFF;
    SMB_TxWords[3] = (offset >> 16 );
    SMB_TxWords[4] = (len_left);

    res = Do_SMB ( hS, SMBread, 5, NULL, &pB_res );
    if ( res != OK )
      break;

    n_read = SMB_RxWords[0];

    if ( n_read > 0 )
    {
      pB_res = GetData(pB_res, NULL, 3 ); /* Data header */
      pB_res = GetData(pB_res, where, n_read );

      if ( pB_res == NULL )  /* Read failed */
      {
        res = EDATALEN;
        break;
      }

      len_left -= n_read;
      where    += n_read;
      offset   += n_read;
    }

    FreeChain(pB_res);

    if ( n_read < FILE_BLOCK_SIZE )  /* Reached end of file */
      break;
  }

  if ( pOutLen != NULL ) *pOutLen = len-len_left;
  return res;
}

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

err_t SMB_Truncate ( int FH, int length )
{
  BUFCHAIN pB;
  err_t res;
  hSHARE hS;

  hS = GetShareFromFH(FH, &res);
  if ( hS == NULL )
    return res;

  /* Do a truncate with a write of length zero */
  SMB_TxWords[0] = GetFid(FH);
  SMB_TxWords[1] = 0 /* Byte count to write */;
  SMB_TxWords[2] = length & 0xFFFF;
  SMB_TxWords[3] = (length >> 16 );
  SMB_TxWords[4] = 0;

  pB = MkDataBlock ( NULL, DATA_BLOCK, NULL, 0, false );
  if ( pB == NULL )
    return EOUTOFMEM;

  return Do_SMB ( hS, SMBwrite, 5, pB, NULL );
}

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

err_t SMB_Write ( int FH, int offset, int len, BYTE *where,
    int *pOutLen )
{
  BUFCHAIN pB;
  int len_left, n_written, fid;
  hSHARE hS;

  err_t res=OK;

  hS = GetShareFromFH(FH, &res);
  if ( hS == NULL )
    return res;

  fid = GetFid(FH);
  len_left = len;

  /* Can we do it with raw writes? */

  if ( hS->hServer->ProtFlags & PROT_WRITERAW )
  {
    while ( len_left > FILE_BLOCK_SIZE )
    {
      n_written = min(len_left,WRRAW_BLOCK_SIZE);
      res = SMB_WriteRaw ( hS, fid, offset, n_written, where );
      if ( res != OK )
        goto finish;

      len_left -= n_written;
      where    += n_written;
      offset   += n_written;
    }
  }

  while ( len_left > 0 )
  {
    n_written = min(len_left,FILE_BLOCK_SIZE);
    SMB_TxWords[0] = fid;
    SMB_TxWords[1] = n_written;
    SMB_TxWords[2] = offset & 0xFFFF;
    SMB_TxWords[3] = (offset >> 16 );
    SMB_TxWords[4] = (len_left);

    pB = MkDataBlock ( NULL, DATA_BLOCK, where, n_written, true );
    if ( pB == NULL )
    {
      res = EOUTOFMEM;
      break;
    }

    res = Do_SMB ( hS, SMBwrite, 5, pB, NULL );
    if ( res != OK )
      break;

    n_written = SMB_RxWords[0];
    len_left -= n_written;
    where    += n_written;
    offset   += n_written;

    if ( n_written < FILE_BLOCK_SIZE )  /* End of data */
      break;
  }

finish:
  if ( pOutLen != NULL ) *pOutLen = len-len_left;
  return res;

}

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

err_t SMB_Flush ( int FH )
{
  err_t res;
  hSHARE hS;

  hS = GetShareFromFH(FH, &res);
  if ( hS == NULL )
    return res;

  SMB_TxWords[0] = GetFid(FH);
  return Do_SMB ( hS, SMBflush, 1, NULL, NULL );
}

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

err_t SMB_Close ( int FH, DOS_ATTRIBS *pAttr )
{
  err_t res;
  hSHARE hS;

  hS = GetShareFromFH(FH, &res);
  if ( hS == NULL )
    return res;

  SMB_TxWords[0] = GetFid(FH);
  SMB_TxWords[1] = pAttr->utime & 0xFFFF;
  SMB_TxWords[2] = pAttr->utime >> 16;

  return Do_SMB ( hS, SMBclose, 3, NULL, NULL );
}


/* Printing routines ================================== */

err_t SMB_OpenPrinter ( char drvlettr, char *idstring, int *ph_out )
{
  err_t res;
  BUFCHAIN pB;
  hSHARE hS;

  hS = GetShare(&drvlettr, &res);
  if ( hS == NULL )
    return res;

  pB = MkDataString ( NULL, DATA_ASCII, idstring );
  if ( pB == NULL )
    return EOUTOFMEM;

  SMB_TxWords[0] = 0;  /* Length of printer setup data */
  SMB_TxWords[1] = 1;  /* Graphics mode */

  res = Do_SMB ( hS, SMBsplopen, 2, pB, NULL );

  if ( res == OK )
    *ph_out = MakeFH(hS, SMB_RxWords[0]);

  return res;
}

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

err_t SMB_WritePrinter ( int PH, BYTE *data, int datalen )
{
  BUFCHAIN pB;
  hSHARE hS;
  int len;
  err_t res=OK;

  hS = GetShareFromFH(PH, &res);
  if ( hS == NULL )
    return res;

  while ( datalen > 0 )
  {
    len = ( datalen > PRN_BLOCK_SIZE ) ? PRN_BLOCK_SIZE : datalen;
    SMB_TxWords[0] = GetFid(PH);

    pB = MkDataBlock ( NULL, DATA_BLOCK, data, len, true );
    if ( pB == NULL )
    {
      res = EOUTOFMEM;
      break;
    }

    res = Do_SMB ( hS, SMBsplwr, 1, pB, NULL );
    if ( res != OK )
      break;

    datalen -= len;
    data += len;
  }

  return res;
}

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

err_t SMB_ClosePrinter ( int PH )
{
  err_t res;
  hSHARE hS;

  hS = GetShareFromFH(PH, &res);
  if ( hS == NULL )
    return res;

  SMB_TxWords[0] = GetFid(PH);
  return Do_SMB ( hS, SMBsplclose, 1, NULL, NULL );
}

/* "Transact" (Remote-procedure-call) operations =========== */

/* For the time being, we limit each transmission to one
   packet's worth (1500 bytes). This might cause Tx failures
   if we exceed it.

   Also, we don't allow any 'setup words' (cos I've never seen them
   used & don't know what they do!).

*/

err_t SMB_Transact ( char drvlettr, char *name, struct TransactParms *pT )
{
  BUFCHAIN pB, pBres;
  err_t res;
  int   a, padbytes;    /* Temp variable */
  hSHARE hS;

  hS = GetShare(&drvlettr, &res);
  if ( hS == NULL )
    return res;

  a = SMBHDR_SIZE + (14*2) + 2 + strlen(name) + 1;
      /* Size of SMB header, 14 word params, 2 byte data length,
            plus the transaction name inc. zero terminator */

  SMB_TxWords[0]  = pT->parms_in_len; /* Total length */
  SMB_TxWords[1]  = pT->data_in_len; /* Total length */
  SMB_TxWords[2]  = pT->parms_out_maxlen;
  SMB_TxWords[3]  = pT->data_out_maxlen;
  SMB_TxWords[4]  = 0; /* Setup words to return */
  SMB_TxWords[5]  = 0; /* Flags - normal */
  SMB_TxWords[6]  = TRANSACT_TIMEOUT; /* Timeout LSW */
  SMB_TxWords[7]  = 0; /* Timeout MSW */
  SMB_TxWords[8]  = 0; /* Reserved */
  SMB_TxWords[9]  = pT->parms_in_len; /* Length this buffer */
  SMB_TxWords[10] = a;  /* Offset from SMB header to parm bytes */
  SMB_TxWords[11] = pT->data_in_len; /* Length this buffer */
  SMB_TxWords[12] = a + pT->parms_in_len;  /* Offset to data bytes */
  SMB_TxWords[13] = 0; /* Setup words being sent */

  pB = NULL;

  /* Make up data chain */

  if ( pT->data_in_len != 0 )
  {
    pB = AddChain ( pB, pT->data_in, pT->data_in_len );
    if ( pB == NULL )
      return EOUTOFMEM;
  }

  if ( pT->parms_in_len != 0 )
  {
    pB = AddChain ( pB, pT->parms_in, pT->parms_in_len );
    if ( pB == NULL )
      return EOUTOFMEM;
  }

  pB = AddChain ( pB, name, strlen(name)+1 );

  res = Do_SMB ( hS, SMBtransact, 14, pB, &pBres );

  if ( res != OK )
    return res;

  /* Now extract results */

  if ( SMB_RxWordCount < 10 )
  {
    FreeChain(pBres);
    return EDATALEN;
  }

  a = SMBHDR_SIZE + (SMB_RxWordCount)*2 + 2;
  /* Size of SMBHDR plus returned rx words plus byte count
     = offset of data in pBres from start of header */

  pT->parms_out_len = min(SMB_RxWords[3], pT->parms_out_maxlen);
                          /* Parm bytes being returned */
  pT->data_out_len  = min(SMB_RxWords[6], pT->data_out_maxlen);
                          /* Data bytes being returned */

  if ( pT->parms_out_len > 0 )         /* Get parms_out */
  {
    padbytes = SMB_RxWords[4] - a;     /* RxWords[4] is offset;
                                          Get number of pad bytes */

    if ( padbytes > 0 )
      pBres = GetData(pBres, NULL, padbytes);
    pBres = GetData(pBres, pT->parms_out_buf, pT->parms_out_len);
    a += padbytes + pT->parms_out_len; /* New offset value */
  }

  if ( pT->data_out_len > 0 )        /* Get parms_out */
  {
    padbytes = SMB_RxWords[7] - a;     /* Number of pad bytes */

    if ( padbytes > 0 )
      pBres = GetData(pBres, NULL, padbytes);
    pBres = GetData(pBres, pT->data_out_buf, pT->data_out_len);
  }

  if ( pBres == NULL )  /* Oh no! Techo fear! */
    return EDATALEN;

  FreeChain(pBres);
  return OK;
}

#ifdef LONGNAMES
/* 14 is the number of words common to all Transact2 commands.  The
 * number of setup words is then added to that value.  The 14 passed
 * to Do_SMB has the number of setup words added to it as this doubles
 * as the header length limiter and the pointer to where to write the
 * total data+param size field (what the Microsoft docs call smb_bcc).
 * This is why you cannot just AddChain the setup word blocks like the
 * data and parameters are handled.
 */
static err_t SMB_Transact2 ( hSHARE hS, struct TransactParms *pT )
{
  BUFCHAIN pB, pBres;
  err_t res;
  int iter = 0; /* Response iteration number */
  int a = SMBHDR_SIZE + ((14 + pT->setup_in_len)*2) + 2;
  int pda = ((a + 3) & ~3);
      /* SMB header size, 14 params + setup words + 2 byte data length
       */
  int   padbytes;    /* Temp variable */
  int   sc;
  int   retry = 3;
  int   tot_data_rcvd = 0, tot_param_rcvd = 0;

retry_transact2:
  debug2("SMB_Transact2: processing (Tid = %#04x, sub-cmd=%#04x)...\n", hS->Tid,
    pT->setup_in[0]);

  SMB_TxWords[0]  = pT->parms_in_len; /* Total length */
  SMB_TxWords[1]  = pT->data_in_len; /* Total length */
  SMB_TxWords[2]  = pT->parms_out_maxlen;
  SMB_TxWords[3]  = pT->data_out_maxlen;
  SMB_TxWords[4]  = 0; /* Setup words to return */
  SMB_TxWords[5]  = 0; /* Flags - normal */
  SMB_TxWords[6]  = TRANSACT2_TIMEOUT; /* Timeout LSW */
  SMB_TxWords[7]  = 0; /* Timeout MSW */
  SMB_TxWords[8]  = 0; /* Reserved */
  SMB_TxWords[9]  = pT->parms_in_len; /* Length this buffer */
  SMB_TxWords[10] = pda;  /* Offset from SMB header to parm bytes */
  SMB_TxWords[11] = pT->data_in_len; /* Length this buffer */
  SMB_TxWords[12] = pda + pT->parms_in_len;  /* Offset to data bytes */
  SMB_TxWords[13] = pT->setup_in_len; /* Setup words being sent */

  debug2("%d bytes of parameters at offset %#x\n", pT->parms_in_len, pda);
  debug2("%d bytes of data at offset %#x\n", pT->data_in_len, SMB_TxWords[12]);

  for (sc = 0; sc < pT->setup_in_len; ++sc)
    SMB_TxWords[14 + sc] = pT->setup_in[sc];

  pB = NULL;

  /* Make up data chain */

  if ( pT->data_in_len != 0 )
  {
    pB = AddChain ( pB, pT->data_in, pT->data_in_len );
    if ( pB == NULL )
      return EOUTOFMEM;
  }

  if ( pT->parms_in_len != 0 )
  {
    pB = AddChain ( pB, pT->parms_in, pT->parms_in_len );
    if ( pB == NULL )
      return EOUTOFMEM;
  }

  /* Add the null string - pda-a must be 1 or 3.  "D " added because
   * that's what SAMBA does (because that's what OS/2 does) */
  pB = AddChain ( pB, "\0D ", pda - a );
  if (pB == NULL )
    return EOUTOFMEM;

  res = Do_SMB ( hS, SMBtrans2, 14 + pT->setup_in_len, pB, &pBres );

  if ( res != OK ) {
    if (SMB_RxHdr.errclass == ERRSRV && SMB_RxHdr.errlo == 1 && SMB_RxHdr.errhi == 0 && retry)
    {
       --retry;
       debug0("SMB_Transact2: retrying request\n");
       goto retry_transact2;
    }
    debug0("SMB_Transact2: Do_SMB failed\n");
    DumpBuffer(&SMB_RxHdr, SMBHDR_SIZE);
    return res;
  }

  /* Now extract results - note that there may be 1 of these.  OTOH, there may be several
   * if the data didn't fit into the negotiated buffer sizes ... */
  for (iter = 0; ; ++iter) {

    if ( SMB_RxWordCount < 10 )
    {
      FreeChain(pBres);
      return EDATALEN;
    }

    a = SMBHDR_SIZE + (SMB_RxWordCount)*2 + 2;
    /* Size of SMBHDR plus returned rx words plus byte count
       = offset of data in pBres from start of header */

    if (iter == 0) {
      /* First response will tell us how much is coming */
      pT->parms_out_len = min(SMB_RxWords[0], pT->parms_out_maxlen);
                              /* Parm bytes being returned */
      pT->data_out_len  = min(SMB_RxWords[1], pT->data_out_maxlen);
                              /* Data bytes being returned */
      pT->setup_out_len = min(SMB_RxWords[9] & 0xFF, pT->setup_out_maxlen);

      /* setup words must come in the first packet */
      if (pT->setup_out_len > 0 )          /* Get setup_out */
      {
        memcpy(pT->setup_out, &SMB_RxWords[14], 2 * pT->setup_out_len);
      }
    }

    if ( pT->parms_out_len > 0 && SMB_RxWords[3])         /* Get parms_out */
    {
      padbytes = SMB_RxWords[4] - a;     /* RxWords[4] is offset;
                                            Get number of pad bytes */

      if ( padbytes > 0 )
        pBres = GetData(pBres, NULL, padbytes);
      pBres = GetData(pBres, pT->parms_out_buf + SMB_RxWords[5], SMB_RxWords[3]);
      a += padbytes + pT->parms_out_len; /* New offset value */
      tot_param_rcvd += SMB_RxWords[3];
    }

    if ( pT->data_out_len > 0 && SMB_RxWords[6] > 0)        /* Get data_out */
    {
      padbytes = SMB_RxWords[7] - a;     /* Number of pad bytes */
      if ( padbytes > 0 )
        pBres = GetData(pBres, NULL, padbytes);
      pBres = GetData(pBres, pT->data_out_buf + SMB_RxWords[8], SMB_RxWords[6]);
      tot_data_rcvd += SMB_RxWords[6];
      if (pT->setup_in[0] == TRANSACT2_QUERYPATHINFORMATION)
        DumpBuffer(pT->data_out_buf, pT->data_out_len);
    }

    if ( pBres == NULL ) {  /* Oh no! Techo fear! */
      debug0("SMB_Transact2: pBres was NULL\n");
      return EDATALEN;
    }

    FreeChain(pBres);

    if (tot_data_rcvd < pT->data_out_len || tot_param_rcvd < pT->parms_out_len) {
      res = Do_SMBResponse(hS, SMBtrans2, &pBres);
      if (res != OK)
        return res;
      /* Extract received data */
      debug1("Transact2 (2ndary response) - returned %d bytes\n", ChainLen(pBres));
    }
    else break;
  }

  return OK;
}
#endif

/* Utility routines ============================================ */

static char *sharetype_name[4] = { "Disk", "Printer", "Comms", "IPC" };

char *SMB_GetConnInfo ( char drvletter, int infotype )
{
  hSHARE hS = GetShareNoConn(drvletter);

  if ( hS == NULL )
    return NULL;

  switch ( infotype )
  {
    case GCI_SERVER:
      return hS->hServer->servname;

    case GCI_USER:
      if ( hS->hServer->ProtFlags & PROT_USERLOGON )
        return hS->hServer->username;
      else
        return "(none)";

    case GCI_SHARE:
      return hS->sharename;

    case GCI_LOGONTYPE:
      if ( hS->hServer->ProtFlags & PROT_USERLOGON )
        return "User";
      else
        return "Share";

    case GCI_SHARETYPE:
      return sharetype_name[ hS->sharetype ];

    case GCI_SERVERINFO:
      return NB_DescribeLink( hS->hServer->hSession );
  }

  return "";
}

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

bool SMB_ConnectedTo ( char *server )
{
  return (bool)( FindServer ( server ) != NULL );
}

/* Init routines ================================================ */

bool SMB_Init( void )
{
  int i;

  for ( i=0; i<MAX_SHARES; i++ )
  {
    SMB_Servers[i].flags = FREE;
  }

  for ( i=0; i<MAX_SHARES; i++ )
  {
    SMB_Shares[i].flags = FREE;
    SMB_Shares[i].drvletter = 'A' + i;
    SMB_Shares[i].FH_base = (i << 16);
  }

  SMB_TxHdr.id[0] = 0xFF;
  SMB_TxHdr.id[1] = 'S';
  SMB_TxHdr.id[2] = 'M';
  SMB_TxHdr.id[3] = 'B';

  SMB_TxHdr.mid = 0;  /* Multiplex ID: not used */
  SMB_TxHdr.pid = 1;  /* Process ID: dummy value */
  SMB_TxHdr.tid = 0;  /* Tree ID: set later */
#ifdef LONGNAMES
  SMB_TxHdr.flg2 = SMB_KNOWS_LONG_NAMES; /*| SMB_IS_LONG_NAME;*/
#else
  SMB_TxHdr.flg2 = 0;
#endif
#ifdef LONGNAMES
  NameCache_Init();
#endif
  return true;
}


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

/* Shutdown will disconnect all logged-on drives */

err_t SMB_Shutdown ( void )
{
  int i;
  for ( i=0; i < MAX_SHARES; i++ )
    SMB_DeleteShare ( 'A'+i );

  return OK;
}

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

/* SMB_AntiIdle() is used to stop idle-outs on shares.
 * Each call, it moves onto the next share in order to
 * "ping" the server to keep it awake.
 */
void SMB_AntiIdle ( void )
{
  static uint letter = -1;
  hSHARE hS;

  ++letter;
  if (letter >= MAX_SHARES) letter = 0;
  hS = GetShareNoConn('A' + letter);
  if (hS == NULL) {
    return;
  }
  else {
    time_t t;
    (void) time(&t);
    if (t > (hS->hServer->last_xact + 60 * 10)) {
      char echodat[sizeof("A:\\")];
      (void) sprintf(echodat, "%c:\\", 'A' + letter);
      debug1("Anti idle-out measure: %s\n", echodat);
#ifdef TRACE
      if (ELANMANFSINUSE == SMB_ChkPath(echodat)) {
        debug0("Re-entrancy due to idle-out check prevented\n");
      }
#else
      (void) SMB_ChkPath(echodat);
#endif
    }
  }
}