
{$A+,B-,D+,E-,F-,G-,I+,L+,N-,O-,R+,S+,V-,X-}
{$M 30000,0,50000}

{                      Turbo Pascal NetBios Interface
                          Written by Alon Gingold
                             Hitch Hiker's BBS
                                  Israel

   This Interface represents many hours of work, and of "why for god's sake
   does'nt it work ???" so  if you decide to use this Interface in your
   programs, please send your contributions to me.
   Anything more then 5 USD will do. Please note that if you send a cheque,
   then sending less then 10 USD will most likely cost me more then the
   cheque's value itself !

   Please post your contributions to :

   Alon Gingold
   P.O.B 450
   Raanana
   Israel 43104


   Introduction
   ------------

   This unit is an interface to a comunication way used on some LAN systems
   called NetBios. As far as I know, the only system on which NetBios is not
   built in, is NOVEL, but there is a small utility that comes with Novel
   to give it the NetBios support.

   So, why do I need to comunicate using netbios, if I can simply write to the
   remote's Disk ??  well, I asked myself the same question some time ago, and
   decided to try. I wrote a program the sent pages after a request was recived
   from a remote. the request was written to the host's ramdisk, and the reply
   was written there as well, and read by the remote. it took about 1 sec. for
   the screen to be transfered (It takes some time for the host to prepair the
   screen).
   After I rewritten the program using this NetBios interface, I could send
   about 5 screens per sec !

   I have used CBIS's Netbios text file documentation to learn about NetBios.
   I have included the COMPLETE package of CBIS's text file with no changes
   to the text. That text file is copyrighted by them , and is only added
   here to make it easier for you to find it. it is not a part of my work.

   TIPS
   ----

   1. Never use DataGrams ! they stinks ! when you receive one DataGram , you
      loose two others.

   2. When local names are added to the list, it is , sometimes, imposible
      to delete them from the list. The fact is , that adding and deleting
      names from the list takes quite a while (2 - 3 sec. on lantastic)
      If you write a program that you run, exit from ,and run it again, you
      should NOT try to delete the local name , but simply use the NetStatus
      command , and search to see if the name is allready there. If it is,
      use it, if not, add it.

   3. Local names must be unique to each computer on the lan. If you write
      a program that uses a specific name, run it on one computer, then try
      to run it on another computer, you'll get error. As sometimes it is
      imposible to delete a name from the local list, you better use unique
      names on each computer...

   4. Never call non POST netbios functions from a POST routine. a post routine
      should update a global table, and a global pointer of that table, and
      then execute the same command that brought up the post, with a post to
      itself. this is most likely a LISTEN command.

   5. NetBios's CANCEL command does'nt work that good. it is advised not to use
      it. The way to cancel POST routines is as follows :

      A. add an IF in the post routine , that if a specific boolean is true,
         don't execute the Post command again.

      B. set that boolean to true.

      C. add another name (save the original name, name nunmber) and send a
         command to match the post routine (i.e. A CALL to a listen post).
         then HangUp that session.


}



Unit NetBios;
interface
uses Dos{,service};

Const                             {Command number}
  NC_Reset            = $32;
  NC_Cancel           = $35;
  NC_AddName          = $30;
  NC_DelName          = $31;
  NC_AddGroup         = $36;
  NC_Call             = $10;
  NC_Listen           = $11;
  NC_HangUp           = $12;
  NC_ReceiveAny       = $16;
  NC_Receive          = $15;
  NC_Send             = $14;
  NC_SendDataGram     = $20;
  NC_ReceiveDataGram  = $21;
  NC_GetStatus        = $34;
  NC_GetAdapterStatus = $33;

  Listen_TimeOut :Byte = 2;       {TimeOuts on several Commands}
  Recive_TimeOut :Byte = 10;
  Send_TimeOut :Byte  = 10;
  Call_TimeOut :Byte = 10;

  Net_NoWait : Boolean = False;   {Generate a POST call. Turn this on}
  Net_Jump : Pointer = Nil;       {and set this Pointer to location to
                                  {jump to when the function ends}
                                  {don't forget to turn the boolean off}
                                  {after the call !}


Type
  NetBiosType = Record
                  Command:Byte;       {Command to execute}
                  RetCode:Byte;       {Return Code, 0 if ok}
                  LSN:Byte;           {Local Session Number}
                  Num:Byte;           {Name Number}
                  BufAdr:Pointer;     {Address of Message Buffer}
                  BufLen:Integer;     {Length of message, up to 512}
                  CallName:String[15];{Name to call, don't use as string!!!}
                  Name:String[15];    {Local Name used  "   "    "  "}
                  RTO:Byte;           {Recieve Time Out 0.5 incr}
                  STO:Byte;           {Send Time Out in 0.5 incr}
                  Post:Pointer;       {Address of User Interupt routine}
                  LANA_Num:Byte;      {Number of Adapter card}
                  CMD_Done:Byte;      {Command Completed Flag.}
                  RES:String[13]      {Internal use of NetBios}
                end;


  NetStatusType = record
                    NameNum:Byte;
                    Sessions:Byte;
                    OutStandingDataGram:Byte;
                    OutStanding:Byte;
                    S:Array[1..20] of Record
                      LSN:Byte;
                      State:Byte;
                      Name:String[15];
                      CallName:String[15];
                      OutStandingDataGram:Byte;
                      OutStanding:Byte;
                    end;
                  end;

  NetAdapterStatusType = record
                           Node:String[5];
                           Jumper:byte;
                           Power:Byte;
                           version:Word;
                           minutes:Word;
                           CrcErrors:Word;
                           AlignErrors:Word;
                           TransErrors:Word;
                           AbortErrors:Word;
                           SentPacketes:LongInt;
                           RecvPacketes:LongInt;
                           Retransmits:word;
                           OutofBuffers:Word;
                           Reserved:array[1..8] of byte;
                           NCBFree:Word;
                           ResetNCB:Word;
                           MaxResetNCB:Word;
                           Reserved2:array[1..4] of byte;
                           ActiveSessions:Word;
                           ResetSessions:Word;
                           MaxResetSessions:Word;
                           PackMaxLen:Word;
                           NamesNum:Word;
                           Names:Array[1..20] of record
                             Name:String[15];
                             Num:Byte;
                             Status:Byte;
                           end;
                         end;


var
  Net_Name:String[15];  {Name of this local machine}
  Net_NameNum:Byte;     {Name Number}
  Net_LastError:Byte;   {Last Error}
  NetB:NetBiosType;     {The NCB that is used on most commands.}
                        {Listen uses a user's NCB cause it's used}
                        {mostly for post}


procedure PutString(var Dest:String; Source:String; l:integer);
{
  Takes the source PASCAL string and puts it in the ASCIIZ (zero terminated)
  string in Dest. note that the DEST string is used from possition zero !
  l is the length of the Dest string (paded with zeros) should be equal
  to the sizeof(dest) - or to the Dest string length + 1
}

procedure GetString(Source:String; var Dest:String; l:integer);
{
  The oposite of PutString..
  Takes the ASCIIZ string from Source with the length l, and puts it into
  Pascal's Dest string
}

{               All the following routines return FALSE if an error had
                occoured. The error numer is found in the Net_LastError
                The strings are PASCAL strings. the asciiz translation
                is automaticaly done.
}


procedure Net_Do(var NetB:NetBiosType);
{
  Execute the NetBios command in NetB. this will call NetBios with or without
  POST as in Net_NoWait boolean, and return the error in Net_LastError.
}


Function Net_Reset:Boolean;
{
  Reset the NetBios. This is a NO NO ! , a reset on lantastic caused the
  computer to be disconnected from the rest of the lan !
}


Function Net_Cancel(var NetBOld:NetBiosType):boolean;
{
  Cancel the NetBios command in the NCB pointed bt NetBOld
  This does'nt allways work, and should not be used if other ways could be
  insted
}


Function Net_AddName(NameSt:String):Boolean;
{
  Add a name to the local name table. The name will be saved in Net_Name.
  The Name number is entered into Net_NameNum.
  Only the last name added is saved , and if more then one name is used, they
  must be saved by the user (Name Numbers as well)
}

Function Net_DelName:Boolean;
{
  Delete the name that is in the Net_Name.
}


Function Net_AddGroup(Name:String):Boolean;
{
  Add a GROUP name. this is used for the broadCast messages. BroadCasts are not
  implemented in this interface, but can be easily implemented from the Data
  Gram equavalents
}



Function Net_Call(CallToName:String; var SessionNum:byte):Boolean;
{
  Call a remote computer. SessionNum returnes the Session Number if the call
  was successfull
}


Function Net_Listen(var NetB:NetBiosType; var NameCalled:string; var SessionNum:byte):Boolean;
{
  Listen for Calls. NetB is a user NetBiosType. I made it use a different
  NetBios var , as I used it as a POST routine.
  NameCalled should have a name to listen to , or * for all systems, and will
  return the name of the calling computer , if * was used
  SessionNum returns the Session number , if successfull.
}

Function Net_Receive(ReceiveFrom:Byte; var MsgTxt; var MsgLen:Integer):Boolean;
{
  Recive data from an online session. SessionNumber should be in ReciveFrom,
  MsgTxt is a pointer to the buffer, and MsgLen should have the maximum msg
  length to receive. It will be changed to the actuall size of the msg recived
}

Function Net_ReceiveAny(var MsgTxt; var MsgLen:Integer; var Session:byte):Boolean;
{
  Recived from any online session. Session will return the session the msg was
  recived from
}

Function Net_Send(SendToSession:Byte; var MsgTxt; var MsgLen:Integer):Boolean;
{
  Send data to an online session. MsgLen should have the size of the message
  as pointed by MsgTxt
}

Function Net_SendDataGram(CallToName:String; var MsgTxt; var MsgLen:Integer):Boolean;
{
  Send DataGram to CallToName. max size is 512 byte
}

Function Net_ReceiveDataGram(Num:byte; var NameCalled:string; var MsgTxt; var MsgLen:Integer):Boolean;
{
  Recived DataGram to Name Number Num. NameCalled will return the name of the
  remote computer who sent the datagram, MsgTxt is a pointer to where the
  message will be written to, and MsgLen is the max length (will return the
  actuall size

}

Function Net_GetStatus(Var Status:NetStatusType):Boolean;
{
  Get NetStatus.
}

Function Net_GetAdapterStatus(Name:string;Var Status:NetAdapterStatusType):Boolean;
{
  Get Adapter Status.
}

Function Net_HangUp(SessionNum:Byte):Boolean;
{
  HangUp session number SessionNum
}

function Net_NameRestore(NameToRestore:String):boolean;  {Restore Specific name from name table}
{
  Retrive NameToRestore from the local name table. if found, Net_Name, and
  Net_NameNum will be set.
}


implementation


procedure PutString(var Dest:String; Source:String; l:integer);
var
  i:integer;
begin
  fillChar(Dest,l,#0);
  for i := 1 to length(source) do Dest[i-1] := Source[i];
end;

procedure GetString(Source:String; var Dest:String; l:integer);
var
  i:integer;
begin
  Dest := '';
  i := 0;
  while (Source[i] <> #0) and (i<=l) do begin
    Dest[i+1] := Source[i];
    inc(i);
  end;
  Dest[0] := char(i);
end;


procedure Net_Do(var NetB:NetBiosType);
var
  reg:Registers;
begin
  if Net_NoWait then begin
    NetB.Command := NetB.Command or $80;
    if Net_Jump <> nil then NetB.Post := Net_Jump;
  end;
  Reg.ES := seg(NetB);
  Reg.BX := ofs(NetB);
  Intr($5C,Reg);
  Net_LastError := NetB.RETCode;
end;


Function Net_Reset:Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_Reset;  {Reset Net Bios}
  Net_Do(NetB);
  Net_Reset := (NetB.RetCode = 0);
end;

Function Net_Cancel(var NETBOLD:NetBiosType):boolean;
var
  NetB:NetBiosType;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_Cancel;
  NetB.BufAdr := addr(NetBold);
  PutString(NetB.Name,Net_Name,16);
  Net_Do(NetB);
  Net_NameNum := NetB.Num;
  Net_Cancel := (NetB.RetCode = 0);
end;


Function Net_AddName(NameSt:String):Boolean;
begin
  Net_Name := NameSt;
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_AddName;
  PutString(NetB.Name,Net_Name,16);
  Net_Do(NetB);
  Net_NameNum := NetB.Num;
  Net_AddName := (NetB.RetCode = 0);
end;


Function Net_DelName:Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_DelName;
  PutString(NetB.Name,Net_Name,16);
  Net_Do(NetB);
  Net_DelName := (NetB.RetCode = 0);
end;


Function Net_AddGroup(Name:String):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_AddGroup;
  PutString(NetB.Name,Name,16);
  Net_Do(NetB);
  Net_AddGroup := (NetB.RetCode = 0);
end;

Function Net_Call(CallToName:String; var SessionNum:byte):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_Call;
  PutString(NetB.Name,Net_Name,16);
  PutString(NetB.CallName,CallToName,16);
  NetB.RTO := Call_TimeOut;
  NetB.STO := Call_TimeOut;
  {directwrite(Net_Name,5,20);
  directwrite(CallToName,20,20);}
  Net_Do(NetB);
  SessionNum := NetB.LSN ;
  Net_Call := (NetB.RetCode = 0);
end;

Function Net_Listen(var NetB:NetBiosType; var NameCalled:string; var SessionNum:byte):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_Listen;
  PutString(NetB.Name,Net_Name,16);
{ NameCalled := '*';}
  PutString(NetB.CallName,NameCalled,16);
  NetB.RTO := Listen_TimeOut;
  NetB.STO := Listen_TimeOut;
  {directwrite(Net_Name,5,20);
  directwrite(NameCalled,20,20);}
  Net_Do(NetB);
  GetString(NetB.CallName,NameCalled,16);
  SessionNum := NetB.LSN ;
  Net_Listen := (NetB.RetCode = 0);
end;


Function Net_ReceiveAny(var MsgTxt; var MsgLen:Integer; var Session:byte):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_ReceiveAny;
  NetB.Num := $FF;  {Recive messages from All callers}
  NetB.BufAdr := addr(MsgTxt);
  NetB.BufLen := MsgLen;
  Net_Do(NetB);
  Session := NetB.LSN;
  MsgLen := NetB.BufLen;
  Net_ReceiveAny := (NetB.RetCode = 0);
end;

Function Net_Receive(ReceiveFrom:Byte; var MsgTxt; var MsgLen:Integer):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_Receive;
  NetB.LSN := ReceiveFrom;
  NetB.BufAdr := addr(MsgTxt);
  NetB.BufLen := MsgLen;
  Net_Do(NetB);
  MsgLen := NetB.BufLen;
  Net_Receive := (NetB.RetCode = 0);
end;

Function Net_Send(SendToSession:Byte; var MsgTxt; var MsgLen:Integer):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_Send;
  NetB.LSN := SendToSession;
  NetB.BufAdr := addr(MsgTxt);
  NetB.BufLen := MsgLen;
  Net_Do(NetB);
  Net_Send := (NetB.RetCode = 0);
end;

Function Net_SendDataGram(CallToName:String; var MsgTxt; var MsgLen:Integer):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_SendDataGram;
  PutString(NetB.CallName,CallToName,16);
  NetB.Num := Net_NameNum;
  NetB.BufAdr := addr(MsgTxt);
  NetB.BufLen := MsgLen;
  Net_Do(NetB);
  Net_SendDataGram := (NetB.RetCode = 0);
end;

Function Net_ReceiveDataGram(Num:Byte; var NameCalled:string; var MsgTxt; var MsgLen:Integer):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_ReceiveDataGram;
  NetB.Num := Num;
  NetB.BufAdr := addr(MsgTxt);
  NetB.BufLen := MsgLen;
  Net_Do(NetB);
  GetString(NetB.CallName,NameCalled,16);
  MsgLen := NetB.BufLen;
  Net_ReceiveDataGram := (NetB.RetCode = 0);
end;


Function Net_GetStatus(Var Status:NetStatusType):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_GetStatus;
  NetB.BufAdr := addr(Status);
  NetB.BufLen := sizeof(Status);
  PutString(NetB.Name,Net_Name,16);
  Net_Do(NetB);
  Net_GetStatus := (NetB.RetCode = 0);
end;

Function Net_GetAdapterStatus(Name:string;Var Status:NetAdapterStatusType):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_GetAdapterStatus;
  NetB.BufAdr := addr(Status);
  NetB.BufLen := sizeof(Status);
  PutString(NetB.Name,Net_Name,16);

  PutString(NetB.CallName,Name,16);

  Net_Do(NetB);
  Net_GetAdapterStatus := (NetB.RetCode = 0);
end;

Function Net_HangUp(SessionNum:Byte):Boolean;
begin
  FillChar(NetB,sizeof(NetBiosType),#0);
  NetB.Command := NC_HangUp;
  NetB.LSN := SessionNum;
  Net_Do(NetB);
  Net_HangUp := (NetB.RetCode = 0);
end;

function NET_NameRestore(NameToRestore:String):boolean;
var
  Status:NetAdapterStatusType;
  Name:String;
  i:word;
begin
  Net_Name := '';
  if Net_GetAdapterStatus('*',Status) then begin
    for i := 1 to Status.Namesnum do begin
      GetString(Status.Names[i].Name,name,16);
      if Name = NameToRestore then begin
        Net_Name := Name;
        Net_NameNum := Status.Names[i].Num;
      end;
    end;
  end;
  NET_NameRestore := (Net_Name=NameToRestore);
end;


begin
  Net_Name := '';
end.
