session.c

NETBIOS C程序源代码 用于网络通信

/*============================================================*/
/*                         Session.C                          */
/*============================================================*/

#include "netbios.h"
#include "predef.h"

/*------------------------------------------------------------*/
static  BYTE	RemoteName;
/*------------------------------------------------------------*/
/*    Receive Any Hand_Shaking Signals in the background.     */
/*------------------------------------------------------------*/
void  Receive_All_Message(void)
	{
	static BOOL Inited=FALSE;

	if(!Inited)
	    {
	    Inited=TRUE;
	    }
	else				//When Name is Changed, Cancel Old NCB 
					//and Hook Up a New One.
	    {
	    Cancel_Cmd(&Receive_Any_Ncb);
	    }
	Hook_RecvAll_Ncb();
	}
/*------------------------------------------------------------*/
/*    Dailing to another user...                              */
/*------------------------------------------------------------*/
void  Dailing(char *OtherName)
	{
	BOOL Done;
	BYTE KeyVal;
	BOOL Special;
	int  cnt;
	char Buffer[80];

	PhoneSession=0xFF;
	RemoteBusy=FALSE;
	RemoteReject=FALSE;
	RemoteOffline=FALSE;
	strcpy((char *)RemoteName,OtherName);

	sprintf(Buffer,"Now We Are Dailing To Remote User %s...",OtherName);
	Set_Status_Bar(Buffer);
	//
	//Listen For Remote Call In The Background...
	//
	Connect_Done=FALSE;
	memset(&Listen_Ncb,0,sizeof(NCB));
	Listen_Ncb.NCB_COMMAND=LISTEN;
	memcpy((char *)Listen_Ncb.NCB_CALLNAME,OtherName,16);
	memcpy((char *)Listen_Ncb.NCB_NAME,SelfName,16);
	MakeStandName((char *)Listen_Ncb.NCB_CALLNAME);
	MakeStandName((char *)Listen_Ncb.NCB_NAME);
	Listen_Ncb.NCB_RTO=10;
	Listen_Ncb.NCB_STO=10;
	Listen_Ncb.POST_FUNC=Connect_Post;
	NetBios(&listen_Ncb);

	cnt=0;
	Done=FALSE;
	while(!Done)
	    {
	    if(kbhit)
		{
		Get_Key(&Special,&KeyVal);
		if(Special && KeyVal==KEY_F3)
		    {
		    Set_Status_Bar("Dailing to Another User Canceled...");
		    Send_Cmd((char far *)OtherName,PHONE_CANCEL);
		    Cancel_Cmd(&Listen_Ncb);
		    Done=TRUE;
		    getch();
		    }
		}
	    else
		{
		Send_Cmd((char far *)OtherName,PHONE_DAILING);
		delay(1000);
		Beep();
		cnt++;
		if(cnt>=20 /* 20 Senconds */)
		    {
		    Set_Status_Bar("Dailing to Another User TimeOuted...");	
		    Send_Cmd((char far *)OtherName,PHONE_TIMEOUT);
		    Cancel_Cmd(&Listen_Ncb);
		    Done=TRUE;
		    getch();
		    }	
		}
	    if(!Done && Connect_Done)
		//
		//  When Listen Canceled or Seesion Established...
		//
		{
		Done=TRUE;
		}
	    if(!Done && (RemoteBusy||RemoteReject||RemoteOffline))
		{
		Cancel_Cmd(&Listen_Ncb);
		Done=TRUE;
		}
	    }
	}
/*------------------------------------------------------------*/
/*    Responding the Dailing Request from remote user...      */
/*------------------------------------------------------------*/
void  Responding(char *OtherName)
	{
	BOOL Done;
	BOOL Have_Called;
	BYTE KeyVal;
	BOOL Special;
	int  cnt;
	char Buffer[80];

	PhoneSession=0xFF;
	RemoteCanceled=FALSE;
	RemoteTimeOuted=FALSE;
	Connect_Done=FALSE;
	Have_Called=FALSE;

	sprintf(Buffer,"Dailed BY Remote User %s -- Connect? (Y/N)",RemoteName);
	Set_Status_Bar(Buffer);
	Beep();

	cnt=0;
	Done=FALSE;
	Have_Called=FALSE;
	while(!Done)
	    {
	    if(!Have_Called && kbhit)
		{
		Have_Called=TRUE;
		Get_Key(&Special,&KeyVal);
		if(!Special && toupper(KeyVal)=='Y')
		    {
		    sprintf(Buffer,"Responding Remote User %s...",(char *)RemoteName);
		    Set_Status_Bar(Buffer);
		    Beep();
		    //
		    //  Responding Remote Listen to Establish Session...	
		    //
		    memset(&Call_Ncb,0,sizeof(NCB));
		    Call_Ncb.NCB_COMMAND=CALL;
		    memcpy((char *)Call_Ncb.NCB_CALLNAME,RemoteName,16);
	            memcpy((char *)Call_Ncb.NCB_NAME,SelfName,16);
	            MakeStandName((char *)Call_Ncb.NCB_CALLNAME);
	            MakeStandName((char *)Call_Ncb.NCB_NAME);
	            Call_Ncb.NCB_RTO=10;
	            Call_Ncb.NCB_STO=10;
	            Call_Ncb.POST_FUNC=Connect_Post;
	            NetBios(&Call_Ncb);
		    }
		else
		    {
		    Send_Cmd((char far *)RemoteName,PHONE_REJECT);
		    Done=TRUE;
		    }
		}
	    delay(1000);
	    Beep();
	    cnt++;
	    if(!Done && Connect_Done)
		{
		Done=TRUE;
		}
	    if(!Done && (cnt>=20))
		{
		Send_Cmd((char far *)RemoteName,PHONE_OFFLINE);
		Cancel_Cmd(&Call_Ncb);
		Done=TRUE;
		}
	    if(!Done && (RemoteCanceled||RemoteTimeOuted))
		{
		Cancel_Cmd(&Call_Ncb);
		Done=TRUE;
		}
	    }
	}
/*------------------------------------------------------------*/
/*    Post Routine (Callback Function) to Process All         */
/*    Hand-Shaking Signals,                                   */
/*    and set all flags for foreground Cycle                  */
/*------------------------------------------------------------*/
void  interrupt	Process_Cmd(void)
	{
	if(Receive_Any_Ncb.NCB_CMD_CPLT!=NB_SUCCESSFULLY_EXECUTED)
	    {
	    return;
	    }
	enable();
	if(Cmd_Data_Block.Phone_Cmd==PHONE_DAILING)
	    {
	    if(!Phone_Busy)
		{
		InBeDailed=TRUE;
		_fmemcpy(RemoteName,Receive_Any_Ncb.NCB_CALLNAME,16);
		}
	    else
		{
		if(!StrEqual((char far *)RemoteName,\
			     (char far *)Receive_Any_Ncb.NCB_CALLNAME))
		    {
		    Send_Cmd((char *)RemoteName,PHONE_BUSY);
		    }
		}
	    Hook_RecvAll_Ncb();
	    return;
	    }
	if(!Phone_Busy||Receive_Any_Ncb.NCB_LENGTH!=sizeof(PHONE_DATA_BLOCK))
	    {
	    Hook_RecvAll_Ncb();
	    return;
	    }
	if(InBeDailed)
	    {
	    switch(Cmd_Data_Block.Phone_Cmd)
		{
		case PHONE_CANCEL:
		    RemoteCanceled=TRUE;
		    break;
		case PHONE_TIMEOUT:
		    RemoteTimeOuted=TRUE;
		    break;
		}
	    Hook_RecvAll_Ncb();
	    return;
	    }
	if(InDailing)
	    {
	    switch(Cmd_Data_Block.Phone_Cmd)
		{
		case PHONE_BUSY:
		    RemoteBusy=TRUE;
		    break;
		case PHONE_REJECT:
		    RemoteReject=TRUE;
		    break;
		case PHONE_OFFLINE:
		    RemoteOffline=TRUE;
		    break;
		}
	    Hook_RecvAll_Ncb();
	    return;
	    }	    
	}
/*------------------------------------------------------------*/
void  Hook_RecvAll_Ncb(void)
	{
	//
	//  Send Out Receive_Any_Message Command again...
	//
	memset(&Receive_Any_Ncb,0,sizeof(NCB));
	Receive_Any_Ncb.NCB_COMMAND=RECEIVE_DATAGRAM;
	Receive_Any_Ncb.NCB_NUM=SelfNameNum;
	Receive_Any_Ncb.NCB_BUFFER_PTR=(void far *)&Cmd_Data_Block;
	Receive_Any_Ncb.NCB_LENGTH=sizeof(PHONE_DATA_BLOCK);
	Receive_Any_Ncb.POST_FUNC=Process_Cmd;
	NetBios(&Receive_Any_Ncb);
	}
/*--------------------------------------------------------------*/
/* When Dailing and Responding is Success,                      */
/* Call this function to Receive Remote Keys in the background. */
/*--------------------------------------------------------------*/
void  Hook_RecvKey_Ncb(void)
	{
	//
	//  Send Out Receive_Key Command again...
	//
	memset(&Recv_Ncb,0,sizeof(NCB));
	Recv_Ncb.NCB_COMMAND=RECEIVE;
	Recv_Ncb.NCB_LSN=PhoneSession;
	Recv_Ncb.NCB_BUFFER_PTR=(void far *)&Key_Data_Block;
	Recv_Ncb.NCB_LENGTH=sizeof(PHONE_DATA_BLOCK);
	Recv_Ncb.POST_FUNC=Key_Received;
	NetBios(&Recv_Ncb);
	}
/*--------------------------------------------------------------*/
/* When Dailing and Responding is Success,                      */
/* Call this function to Send Keys to Remote User.              */
/*--------------------------------------------------------------*/
void  Send_Cmd(char far *Name,BYTE Cmd)
	{
	NCB  AnswerNcb;
	static volatile PHONE_DATA_BLOCK AnswerData;
	
	AnswerData.Phone_Cmd=Cmd;

	memset(&AnswerNcb,0,sizeof(NCB));
	AnswerNcb.NCB_COMMAND=SEND_DATAGRAM_WAIT;
	AnswerNcb.NCB_NUM=SelfNameNum;
	_fstrcpy((char far *)AnswerNcb.NCB_CALLNAME,Name);
	MakeStandName((char far *)AnswerNcb.NCB_CALLNAME);
	AnswerNcb.NCB_BUFFER_PTR=(void far *)&AnswerData;
	AnswerNcb.NCB_LENGTH=sizeof(PHONE_DATA_BLOCK);
	NetBios(&AnswerNcb);
	}
/*------------------------------------------------------------*/
void  interrupt	Connect_Post(void)
	{
	enable();
	if(Phone_Busy && InBeDailed)
	    {
	    if(Call_Ncb.NCB_CMD_CPLT==NB_SUCCESSFULLY_EXECUTED)
	    	{
		PhoneSession=Call_Ncb.NCB_LSN;
		}
	    }
	else
	    if(Phone_Busy && InDailing)
		{
		if(Listen_Ncb.NCB_CMD_CPLT==NB_SUCCESSFULLY_EXECUTED)
	    	    {
		    PhoneSession=Listen_Ncb.NCB_LSN;
		    }
		}
	//