[Back to NETWORK SWAG index] [Back to Main SWAG index] [Original]
{$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.
[Back to NETWORK SWAG index] [Back to Main SWAG index] [Original]