guus
/
reman3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
reman3/Rayman_X/cpa/tempgrp/NET/l0serial.c

3646 lines
118 KiB
C
Raw Blame History

/*
* universal multiplayer library level 0 implementation file
* transport layer: serial PC-windows 95
*
*
* remark: there is no little endian/big endian swap management within the low level communication thread
* as netlib currently exists only for pc, this is not a problem
*
*/
#include "warnings.h"
/*#define NETLIB_LEVEL0COM_TRACE_FULL*/
/*
* we need this one to fill the interface structure
* with pointers to the correct functions
*/
#include "PrivL0serial.h"
#include "PrivNetDef.h"
#include "L0GlDef.h"
#include "NetMemCo.h"
#include "NetEnd.h"
#include <NET\Netdebug.h>
#include <windows.h>
#ifdef NET_USE_DEBUG
#include <stdio.h>
#endif
#define LINK_WINDOW 4
#define LINK_TIMEOUT(link_rate) ((unsigned long)(10+1000*(LINK_WINDOW)*sizeof(tdstPacket)*8*1.25/link_rate))
#define LINK_LINKNUMBER (1+C_usSerialBufferSize/LINKSIZE)
/* Defines the max number of port :*/
#define C_uw_Net_L0PCWin95Serial_PortNumber ((unsigned short)5)
/* array of descriptors to access a physical channel. */
/* not static, because also used by the modem module */
tdstL0PCWin95SerialChannel gs_a_stL0PCWin95SerialChannels[C_uw_Net_L0PCWin95Serial_PortNumber];
long lSerialChannelsOnceInitialized=0;
/* Initialisation state flag */
static char gs_bL0PCWin95SerialInitState;
/* the baud rate at which the com ports are opened */
static unsigned long gs_ulL0PCWin95SerialBaudRate;
/*******************************************************************/
#if defined(NET_USE_DEBUG)
void vDisplayComQueue(LPCOMSTAT pComStat)
{
vDebugFormat(Net_C_Debug_Serial, "cbInQue :%d", pComStat->cbInQue);
vDebugFormat(Net_C_Debug_Serial, "cbOutQue :%d", pComStat->cbOutQue);
}
#endif /* NET_USE_DEBUG */
/*******************************************************************/
#if defined(NET_USE_DEBUG)
void vDisplayComStat(unsigned short uwFileNum, LPCOMSTAT pComStat)
{
vDebugFormat(uwFileNum, "fCtsHold :%d", pComStat->fCtsHold);
vDebugFormat(uwFileNum, "fDsrHold :%d", pComStat->fDsrHold);
vDebugFormat(uwFileNum, "fRlsdHold :%d", pComStat->fRlsdHold);
vDebugFormat(uwFileNum, "fXoffHold :%d", pComStat->fXoffHold);
vDebugFormat(uwFileNum, "fXoffSent :%d", pComStat->fXoffSent);
vDebugFormat(uwFileNum, "fEof :%d", pComStat->fEof);
vDebugFormat(uwFileNum, "fTxim :%d", pComStat->fTxim);
vDebugFormat(uwFileNum, "cbInQue :%d", pComStat->cbInQue);
vDebugFormat(uwFileNum, "cbOutQue :%d", pComStat->cbOutQue);
}
#endif /* NET_USE_DEBUG */
/*******************************************************************/
#if defined(NET_USE_DEBUG)
void vDisplayErrorState(unsigned short uwFileNum, unsigned long ulCommError)
{
char acString[150];
if(ulCommError) {
vDebugFormat(uwFileNum ,"erreur:0x%.8x", ulCommError);
if(ulCommError & CE_BREAK) sprintf(acString, "CE_BREAK ");
if(ulCommError & CE_DNS) sprintf(acString, "CE_DNS ");
if(ulCommError & CE_FRAME) sprintf(acString, "CE_FRAME ");
if(ulCommError & CE_IOE) sprintf(acString, "CE_IOE ");
if(ulCommError & CE_MODE) sprintf(acString, "CE_MODE ");
if(ulCommError & CE_OOP) sprintf(acString, "CE_OOP ");
if(ulCommError & CE_OVERRUN) sprintf(acString, "CE_OVERRUN ");
if(ulCommError & CE_PTO) sprintf(acString, "CE_PTO ");
if(ulCommError & CE_RXOVER) sprintf(acString, "CE_RXOVER ");
if(ulCommError & CE_RXPARITY) sprintf(acString, "CE_RXPARITY ");
if(ulCommError & CE_TXFULL) sprintf(acString, "CE_TXFULL ");
vDebugFormat(uwFileNum, "%s", acString);
}
}
#endif /* NET_USE_DEBUG */
/*******************************************************************/
/*
* threaded low level send/receive system
*/
/************************************************************************/
/* functions that manage the sending, receiving and eventual reemitting */
/* of numbered blocks of data, per channel. */
/************************************************************************/
/* static functions */
static void vBuildPacket(tdstL0PCWin95SerialChannel *, int, tdstPacket *, unsigned char);
static int iSendPacket(tdstL0PCWin95SerialChannel *, tdstPacket *);
static void vCompleteSendPacket(tdstL0PCWin95SerialChannel *);
int iCheckTimeOut(tdstL0PCWin95SerialChannel *);
static int iChooseSendSlot(tdstWindow *);
static unsigned short usComputeChecksum(tdstPacket *);
static unsigned char ucGetAckNumber(tdstWindow *);
static int iChooseRecvSlot(tdstWindow *, unsigned char);
static int iGetAckSendSlot(tdstWindow *, unsigned char);
static int iGetPacket(tdstL0PCWin95SerialChannel *, tdstPacket *);
static int iGetFreeSlot(tdstWindow *);
static void vNumberSlot(tdstL0PCWin95SerialChannel *, int);
static void vDoRecv(tdstL0PCWin95SerialChannel *);
static void vDoSend(tdstL0PCWin95SerialChannel *);
static int iUnloadSendBuffer(tdstL0PCWin95SerialChannel *);
static int iLoadRecvBuffer(tdstL0PCWin95SerialChannel *, tdstPacket *);
/************************************************************************/
/* functions for manipulating the output 'ring' buffer */
/************************************************************************/
#ifdef NET_USE_DEBUG
char acCouple[40];
#endif /* NET_USE_DEBUG */
#define BufferSpace(pstRing) (RINGBUFFERSIZE-1)
#define FreeSpace(pstRing) ( (RINGBUFFERSIZE - 1 - (pstRing)->ulHighMark + (pstRing)->ulLowMark) \
% RINGBUFFERSIZE )
#define BusySpace(pstRing) ( (RINGBUFFERSIZE + (pstRing)->ulHighMark - (pstRing)->ulLowMark) \
% RINGBUFFERSIZE )
/**********************************************************************/
void vInitRingBuffer(tdstRingBuffer *pstRing)
{
pstRing->ulLowMark=pstRing->ulHighMark=pstRing->ulSize=pstRing->ulBottom=0L;
pstRing->pcBigMsg=(char *)C_pNull;
}
/**********************************************************************/
/* copy a new block into the ring */
int iPushBlockRingBuffer(tdstRingBuffer *pstRing, char *pcBlock, unsigned long ulSize)
{
long lLowChunk, lHighChunk;
/* no test on the validity of the parameters are performed in this function */
/* the function is supposed to always be called with valid parameters */
/* put a block into the ring */
#ifdef NET_USE_DEBUG
sprintf(acCouple, "(%lu,%lu)>>\n", pstRing->ulLowMark, pstRing->ulHighMark);
vDebugSDump(Net_C_Debug_SBuffin, acCouple, pcBlock, ulSize);
#endif /* NET_USE_DEBUG */
lLowChunk=ulSize-(RINGBUFFERSIZE-pstRing->ulHighMark);
if(lLowChunk<0)
lLowChunk=0;
lHighChunk=ulSize-lLowChunk;
memcpy(&pstRing->acBuffer[pstRing->ulHighMark], pcBlock, lHighChunk);
if(lLowChunk>0)
memcpy( pstRing->acBuffer, &pcBlock[lHighChunk], lLowChunk);
pstRing->ulHighMark= (pstRing->ulHighMark + ulSize) % RINGBUFFERSIZE;
#ifdef NET_USE_DEBUG
sprintf(acCouple, "(%ld,%ld)", lLowChunk, lHighChunk);
vDebugFormat(Net_C_Debug_SBuffin, "%s", acCouple);
#endif /* NET_USE_DEBUG */
return eRingOk;
}
/**********************************************************************/
/* try to put a new message into the ring buffer */
/* making a distinction between 'small' messages */
/* and 'big' messages (who are bigger than the buffer size, and have */
/* to be cut in many chunks that fit into the buffer */
int iPushMessageRingBuffer(tdstRingBuffer *pstRing, char *pcBlock, unsigned long ulSize)
{
if(pstRing->pcBigMsg)
return eRingFull;
/* is the new message a big one ? */
if(ulSize>BufferSpace(pstRing)) { /* the message is a big one */
/* store the message */
pstRing->pcBigMsg=pcBlock;
pstRing->ulSize=ulSize;
/* prepare to put a chunk of it into the ring */
pstRing->ulBottom=ulSize=FreeSpace(pstRing);
/* if there is room in the ring, put a chunk of message into it */
if(FreeSpace(pstRing)>0)
iPushBlockRingBuffer(pstRing, pcBlock, ulSize);
return eRingBigOk; /* i.e. the caller shouldn't deallocate the message */
} else /* the message is a small one */
/* if there isn't enough room to store this block in the buffer, return */
if(FreeSpace(pstRing)<ulSize)
return eRingFull;
return iPushBlockRingBuffer(pstRing, pcBlock, ulSize);
}
/**********************************************************************/
/* get a block of data from the ring buffer */
/* if a big message is being sent, put a new chunk of it into the */
/* ring f needed */
int iPopBlockRingBuffer(tdstRingBuffer *pstRing, char *pcBlock, unsigned long ulSize)
{
long lLowChunk, lHighChunk;
long lFreeSpace, lLeftToCopy, lToCopy;
/* is there enough content in the buffer to fill the block ? */
if(BusySpace(pstRing)<ulSize) {
/* there are fewer bytes in the ring than requested */
/* if a big message is currently being transmitted, fill the ring with a chunk of it */
if(pstRing->pcBigMsg) {
lFreeSpace=FreeSpace(pstRing);
lLeftToCopy=pstRing->ulSize-pstRing->ulBottom;
if(lLeftToCopy<lFreeSpace)
lToCopy=lLeftToCopy;
else
lToCopy=lFreeSpace;
iPushBlockRingBuffer(pstRing, &pstRing->pcBigMsg[pstRing->ulBottom], lToCopy);
pstRing->ulBottom+=lToCopy;
/* if the big message has entirely been copied, then we can free the block */
if(pstRing->ulBottom==pstRing->ulSize) {
vFree(pstRing->pcBigMsg);
pstRing->pcBigMsg=(char *)C_pNull;
pstRing->ulBottom=pstRing->ulSize=0;
}
}
/* then again, how much data can we actually send ? */
if(BusySpace(pstRing)<ulSize)
ulSize=BusySpace(pstRing);
/* if the buffer is empty, there is nothing to do */
if(ulSize==0)
return -1;
}
/* transfer a block from the ring */
#ifdef NET_USE_DEBUG
sprintf(acCouple, "(%lu,%lu)<<\n", pstRing->ulLowMark, pstRing->ulHighMark);
vDebugFormat(Net_C_Debug_SBuffout, "%s", acCouple);
#endif /* NET_USE_DEBUG */
lLowChunk=ulSize-(RINGBUFFERSIZE-pstRing->ulLowMark);
if(lLowChunk<0)
lLowChunk=0;
lHighChunk=ulSize-lLowChunk;
memcpy(pcBlock, &pstRing->acBuffer[pstRing->ulLowMark], lHighChunk);
if(lLowChunk>0)
memcpy(&pcBlock[lHighChunk], pstRing->acBuffer, lLowChunk);
pstRing->ulLowMark= (pstRing->ulLowMark + ulSize) % RINGBUFFERSIZE;
#ifdef NET_USE_DEBUG
vDebugSDump(Net_C_Debug_SBuffout, "", pcBlock, ulSize);
#endif /* NET_USE_DEBUG */
/* return the number of bytes effectively written to caller's block */
return ulSize;
}
/************************************************************************/
/* functions for manipulating the input 'link' buffer, and reassemble */
/* blocks in sequence */
/************************************************************************/
/*************************************************************************/
/* tell if a sequence number is lower than another due to overflow */
int iBeforeSequence(unsigned char seq1, unsigned char seq2)
{
unsigned char diff;
diff=seq2-seq1;
/* return true iff the distance from seq1 to seq2 is lower than ???
and greater than zero*/
return diff!=0 && diff<128;
}
/*************************************************************************/
int iNextSequence(unsigned char seq1, unsigned char seq2)
{
return (seq1+1==INVALID_SLOT)?seq2==0:seq2==seq1+1;
}
/*************************************************************************/
unsigned char ucIncSequence(unsigned char seq1)
{
return (seq1+1==INVALID_SLOT)?0:seq1+1;
}
/*************************************************************************/
unsigned char ucDiffSequence(unsigned char seq2, unsigned char seq1)
{
/* the result is correct when seq1 is BEFORE seq2 */
if(seq2>=seq1)
return seq2-seq1; /* seq1 and seq2 are of the same side of the INVALID_SLOT */
else
return seq2-seq1-1; /* because 0xff is the INVALID_SLOT */
}
/*************************************************************************/
void vInitLinkBuffer(tdstLinkBuffer *pstLinkBuffer, int iNLinks)
{
int i;
pstLinkBuffer->pstLink=(tdstLink *)pMalloc(iNLinks*sizeof(tdstLink));
if(pstLinkBuffer->pstLink==(tdstLink *)C_pNull) {
pstLinkBuffer->iNLinks=0;
return;
}
pstLinkBuffer->iNLinks=iNLinks;
for(i=0; i<pstLinkBuffer->iNLinks; i++) {
pstLinkBuffer->pstLink[i].ucSeqN=INVALID_SLOT; /* unused sequence number */
pstLinkBuffer->pstLink[i].iNextIndex=-1;
}
pstLinkBuffer->iHead=-1;
pstLinkBuffer->ucAwaitedSeqN=0;
pstLinkBuffer->iNFreeLinks=iNLinks;
}
/*************************************************************************/
void vDeleteLinkBuffer(tdstLinkBuffer *pstLinkBuffer)
{
if(pstLinkBuffer->pstLink!=(tdstLink *)C_pNull) {
vFree((tdpPointer)pstLinkBuffer->pstLink);
pstLinkBuffer->iNLinks=0;
}
}
/*************************************************************************/
int iGetLink(tdstLinkBuffer *pstLinkBuffer)
{
int i;
if(pstLinkBuffer->iNFreeLinks==0) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "GetLink():no free links !");
#endif /* NET_USE_DEBUG */
return -1;
}
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "GetLink():%d free", pstLinkBuffer->iNFreeLinks);
#endif /* NET_USE_DEBUG */
for(i=0; i<pstLinkBuffer->iNLinks; i++)
if(pstLinkBuffer->pstLink[i].ucSeqN==INVALID_SLOT) {
pstLinkBuffer->iNFreeLinks--;
return i;
}
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "GetLink():shouldn't get there !");
#endif /* NET_USE_DEBUG */
return -1;
}
/*************************************************************************/
void vFreeLink(tdstLinkBuffer *pstLinkBuffer, int iSlot)
{
#ifdef NET_USE_DEBUG
if(pstLinkBuffer->pstLink[iSlot].ucSeqN==INVALID_SLOT) {
vDebugFormat(Net_C_Debug_SLinks, "FreeLink(invalid slot): shouldn't happen !");
return;
}
if(pstLinkBuffer->iNFreeLinks==pstLinkBuffer->iNLinks) {
vDebugFormat(Net_C_Debug_SLinks, "FreeLink(): all links free, shouldn't happen !");
return;
}
#endif /* NET_USE_DEBUG */
pstLinkBuffer->pstLink[iSlot].ucSeqN=INVALID_SLOT;
pstLinkBuffer->iNFreeLinks++;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "FreeLink():%d free", pstLinkBuffer->iNFreeLinks);
#endif /* NET_USE_DEBUG */
}
/*************************************************************************/
void vMakeLink(tdstLinkBuffer *pstLinkBuffer, int iLinkIndex, unsigned char ucSeqN, unsigned char ucSize, char *pcData, int iNextIndex)
{
pstLinkBuffer->pstLink[iLinkIndex].ucSeqN=ucSeqN;
pstLinkBuffer->pstLink[iLinkIndex].ucSize=ucSize;
memcpy(pstLinkBuffer->pstLink[iLinkIndex].acData, pcData, ucSize);
pstLinkBuffer->pstLink[iLinkIndex].iNextIndex=iNextIndex;
}
/*************************************************************************/
int iPushBlockLinkBuffer(tdstLinkBuffer *pstLinkBuffer, unsigned char ucSeqN, unsigned char ucSize, char *pcData)
/* insert a new block in the list according to its sequence number */
/* and maintain the first sequence length */
{
int iPrevious, iCurrent, iNew;
unsigned char ucHole; /* number of missing links between the head packet and the new packet */
/* if the block sequence number is smaller than the awaited one, then this is a block */
/* that has been reemitted by the remote side because we acknowledged it too late */
/* just ignore it */
if(iBeforeSequence(ucSeqN, pstLinkBuffer->ucAwaitedSeqN))
return eLinkOk;
if(pstLinkBuffer->iHead==-1) { /* no list exists */
/* paranoid: test whether there are enough links to complete the sequence */
if(((unsigned char)ucSeqN-pstLinkBuffer->ucAwaitedSeqN)>pstLinkBuffer->iNFreeLinks) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "refusing packet %d to leave room (1)", ucSeqN);
#endif /* NET_USE_DEBUG */
return eLinkFull;
}
iNew=iGetLink(pstLinkBuffer);
if(iNew==-1)
return eLinkFull; /* shouldn't happen */
vMakeLink(pstLinkBuffer, iNew, ucSeqN, ucSize, pcData, -1);
pstLinkBuffer->iHead=iNew;
pstLinkBuffer->iFirstSequence=1;
pstLinkBuffer->ulFirstSequenceLength=ucSize;
return eLinkOk;
} else {
/* run through the list until we find a link whose sequence number */
/* is >= than the new sequence number */
ucHole=0;
iPrevious=-1;
iCurrent=pstLinkBuffer->iHead;
while(iCurrent!=-1 && iBeforeSequence(pstLinkBuffer->pstLink[iCurrent].ucSeqN, ucSeqN)) {
if(iPrevious!=-1 && !iNextSequence(pstLinkBuffer->pstLink[iPrevious].ucSeqN, pstLinkBuffer->pstLink[iCurrent].ucSeqN))
ucHole+=ucDiffSequence(pstLinkBuffer->pstLink[iCurrent].ucSeqN, pstLinkBuffer->pstLink[iPrevious].ucSeqN)-1;
iPrevious=iCurrent;
iCurrent=pstLinkBuffer->pstLink[iCurrent].iNextIndex;
}
if(iPrevious!=-1) {
ucHole+=ucDiffSequence(ucSeqN, pstLinkBuffer->pstLink[iPrevious].ucSeqN)-1;
/* if this packet is after the head packet and if we need all the remaining free links */
/* to complete the sequence before this new packet then refuse this new packet */
if(ucHole + ucDiffSequence(pstLinkBuffer->pstLink[pstLinkBuffer->iHead].ucSeqN , pstLinkBuffer->ucAwaitedSeqN)
>= pstLinkBuffer->iNFreeLinks) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "refusing packet %d to leave room, hole=%d", ucSeqN, ucHole);
#endif /* NET_USE_DEBUG */
return eLinkFull;
}
}
if(iCurrent==-1) {
/* the new sequence number is greater than all others */
/* insert the new block at the tail of the list */
iNew=iGetLink(pstLinkBuffer);
if(iNew==-1)
return eLinkFull; /* shouldn't happen */
vMakeLink(pstLinkBuffer, iNew, ucSeqN, ucSize, pcData, -1);
pstLinkBuffer->pstLink[iPrevious].iNextIndex=iNew;
if(ucHole==0/* && iNextSequence(pstLinkBuffer->pstLink[iPrevious].ucSeqN, ucSeqN)*/) {
pstLinkBuffer->iFirstSequence++;
pstLinkBuffer->ulFirstSequenceLength+=ucSize;
}
return eLinkOk;
}
if(pstLinkBuffer->pstLink[iCurrent].ucSeqN==ucSeqN) {
/* we already have a block with the same sequence number */
return eLinkOk;
}
/* the list contains sequence numbers that are greater than the new one */
if(iPrevious==-1) {
/* all sequence numbers are greater than the new one */
/* insert the new block at the head of the list */
iNew=iGetLink(pstLinkBuffer);
if(iNew==-1)
return eLinkFull; /* shouldn't happen */
vMakeLink(pstLinkBuffer, iNew, ucSeqN, ucSize, pcData, iCurrent);
pstLinkBuffer->iHead=iNew;
if(iNextSequence(ucSeqN, pstLinkBuffer->pstLink[iCurrent].ucSeqN)) {
pstLinkBuffer->iFirstSequence++;
pstLinkBuffer->ulFirstSequenceLength+=ucSize;
} else {
pstLinkBuffer->iFirstSequence=1;
pstLinkBuffer->ulFirstSequenceLength=ucSize;
}
return eLinkOk;
}
/* insert the new block in the middle of the list */
iNew=iGetLink(pstLinkBuffer);
if(iNew==-1)
return eLinkFull; /* shouldn't happen */
vMakeLink(pstLinkBuffer, iNew, ucSeqN, ucSize, pcData, iCurrent);
pstLinkBuffer->pstLink[iPrevious].iNextIndex=iNew;
iCurrent=iNew;
if(ucHole==0)
while( iCurrent!=-1
&& iNextSequence(pstLinkBuffer->pstLink[iPrevious].ucSeqN,
pstLinkBuffer->pstLink[iCurrent].ucSeqN)) {
pstLinkBuffer->iFirstSequence++;
pstLinkBuffer->ulFirstSequenceLength+=pstLinkBuffer->pstLink[iCurrent].ucSize;
iPrevious=iCurrent;
iCurrent=pstLinkBuffer->pstLink[iCurrent].iNextIndex;
}
return eLinkOk;
}
}
/*************************************************************************/
int iPopDataLinkBuffer(tdstLinkBuffer *pstLinkBuffer, char *pcData, unsigned long ulSize)
{
int iCurrent, iPrevious;
unsigned long ulBytesCopied, ulLeftToCopy;
char cEnd;
iCurrent=pstLinkBuffer->iHead;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "Head:%d, SeqN:%d/%d, FirstSeq:%d Size:%lu ",
iCurrent, pstLinkBuffer->ucAwaitedSeqN, pstLinkBuffer->pstLink[iCurrent].ucSeqN,
pstLinkBuffer->iFirstSequence,
ulSize);
#endif /* NET_USE_DEBUG */
if( iCurrent==-1
|| pstLinkBuffer->pstLink[iCurrent].ucSeqN!=pstLinkBuffer->ucAwaitedSeqN
|| (unsigned long)(LINKSIZE*pstLinkBuffer->iFirstSequence)<ulSize
|| pstLinkBuffer->ulFirstSequenceLength<ulSize)
return eLinkEmpty;
/* now we know that there is enough data: copy it into the caller's buffer */
ulBytesCopied=0;
cEnd=0;
while (pstLinkBuffer->pstLink[iCurrent].ucSize<(ulLeftToCopy=ulSize-ulBytesCopied)) {
/* the whole slot gets copied */
memcpy(&pcData[ulBytesCopied], pstLinkBuffer->pstLink[iCurrent].acData, pstLinkBuffer->pstLink[iCurrent].ucSize);
ulBytesCopied+=pstLinkBuffer->pstLink[iCurrent].ucSize;
pstLinkBuffer->iFirstSequence--;
pstLinkBuffer->ulFirstSequenceLength-=pstLinkBuffer->pstLink[iCurrent].ucSize;
vFreeLink(pstLinkBuffer, iCurrent);
iCurrent=pstLinkBuffer->pstLink[iCurrent].iNextIndex;
#ifdef NET_USE_DEBUG
if(iCurrent==-1)
vDebugFormat(Net_C_Debug_SLinks, "iCurrent==-1 ???");
#endif /* NET_USE_DEBUG */
}
/* this is the last slot to copy */
memcpy(&pcData[ulBytesCopied], pstLinkBuffer->pstLink[iCurrent].acData, ulLeftToCopy);
pstLinkBuffer->pstLink[iCurrent].ucSize-=(unsigned char)ulLeftToCopy;
pstLinkBuffer->ulFirstSequenceLength-=ulLeftToCopy;
if(pstLinkBuffer->pstLink[iCurrent].ucSize==0) /* nothing left in slot */ {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "exact match");
#endif /* NET_USE_DEBUG */
pstLinkBuffer->iFirstSequence--;
pstLinkBuffer->ucAwaitedSeqN=ucIncSequence(pstLinkBuffer->pstLink[iCurrent].ucSeqN);
vFreeLink(pstLinkBuffer, iCurrent);
iCurrent=pstLinkBuffer->pstLink[iCurrent].iNextIndex;
} else { /* move the remaining bytes to the beginning of the slot */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SLinks, "no match");
#endif /* NET_USE_DEBUG */
memmove(pstLinkBuffer->pstLink[iCurrent].acData, pstLinkBuffer->pstLink[iCurrent].acData+ulLeftToCopy, pstLinkBuffer->pstLink[iCurrent].ucSize);
pstLinkBuffer->ucAwaitedSeqN=pstLinkBuffer->pstLink[iCurrent].ucSeqN;
}
pstLinkBuffer->iHead=iCurrent;
/* if we ate the whole first sequence, compute the length of the new one */
if(pstLinkBuffer->iFirstSequence==0) {
cEnd=iCurrent==-1;
#ifdef NET_USE_DEBUG
if(!cEnd)
vDebugFormat(Net_C_Debug_SLinks, "first sequence exists");
#endif /* NET_USE_DEBUG */
while(!cEnd) {
pstLinkBuffer->iFirstSequence++;
pstLinkBuffer->ulFirstSequenceLength+=pstLinkBuffer->pstLink[iCurrent].ucSize;
iPrevious=iCurrent;
iCurrent=pstLinkBuffer->pstLink[iCurrent].iNextIndex;
cEnd=iCurrent==-1 ||
!iNextSequence( pstLinkBuffer->pstLink[iPrevious].ucSeqN,
pstLinkBuffer->pstLink[iCurrent].ucSeqN);
}
}
return eLinkOk;
}
/************************************************************************/
unsigned long ulLengthLinkBuffer(tdstLinkBuffer *pstLinkBuffer)
{
if(pstLinkBuffer->iHead==-1 ||
pstLinkBuffer->pstLink[pstLinkBuffer->iHead].ucSeqN!=pstLinkBuffer->ucAwaitedSeqN)
return 0L;
return pstLinkBuffer->ulFirstSequenceLength;
}
/************************************************************************/
/* global variables for the threaded control system */
static HANDLE gs_hL0PCWin95SerialThread;
static DWORD gs_dwL0PCWin95SerialThreadID;
static HANDLE gs_hL0PCWin95SerialIOToMain; /* used to synchronize thread termination */
static HANDLE gs_hL0PCWin95SerialMainToIO;
static int gs_iNEvents;
HANDLE gs_ahWaitHandles[1+2*C_uw_Net_L0PCWin95Serial_PortNumber];
tduwNetChannel gs_auwChannels[1+2*C_uw_Net_L0PCWin95Serial_PortNumber];
unsigned char gs_aucIsReadEvent[1+2*C_uw_Net_L0PCWin95Serial_PortNumber];
void vWorker(DWORD *);
void vLaunchThread(void);
void vDeleteThread(void);
void vGetThreadControl(void);
void vGiveThreadControl(void);
void vInitThreadController(void);
void vAddThreadClient(tduwNetChannel uwChannel);
void vRemoveThreadClient(tduwNetChannel uwChannel);
/************************************************************************/
void vLaunchThread(void)
{
long lErrorCode;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "Block size:%d bytes",
BLOCKSIZE);
#endif /* NET_USE_DEBUG */
gs_hL0PCWin95SerialThread=CreateThread(
NULL, /* no security attributes */
0, /* use default stack size */
(LPTHREAD_START_ROUTINE) vWorker, /* thread function */
NULL, /* argument to thread function */
CREATE_SUSPENDED,
&gs_dwL0PCWin95SerialThreadID);
if(gs_hL0PCWin95SerialThread==NULL) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "CreateThread(): erreur %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
exit(1);
}
if(SetThreadPriority(gs_hL0PCWin95SerialThread,
/*THREAD_PRIORITY_ABOVE_NORMAL*/
/*THREAD_PRIORITY_HIGHEST*/
THREAD_PRIORITY_TIME_CRITICAL)==FALSE) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "SetThreadPriority(): erreur %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
exit(1);
}
gs_hL0PCWin95SerialMainToIO=CreateEvent(NULL, FALSE, FALSE, NULL); /* auto reset event, initially set to non signaled */
if(gs_hL0PCWin95SerialMainToIO==INVALID_HANDLE_VALUE) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "MainToIO=CreateEvent(): erreur %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
}
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "MainToIO=CreateEvent()-> %ld", gs_hL0PCWin95SerialMainToIO);
#endif /* NET_USE_DEBUG */
gs_ahWaitHandles[0]=gs_hL0PCWin95SerialMainToIO;
gs_iNEvents=1;
gs_hL0PCWin95SerialIOToMain=CreateEvent(NULL, FALSE, FALSE, NULL); /* auto reset event, initially set to non signaled */
if(ResumeThread(gs_hL0PCWin95SerialThread)==-1) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "ResumeThread(): erreur %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
}
}
/*********************************************************/
void vDeleteThread()
{
TerminateThread(gs_hL0PCWin95SerialThread, 0);
CloseHandle(gs_hL0PCWin95SerialMainToIO);
CloseHandle(gs_hL0PCWin95SerialIOToMain);
gs_hL0PCWin95SerialThread = INVALID_HANDLE_VALUE;
gs_dwL0PCWin95SerialThreadID = 0;
}
/*********************************************************/
void vGetThreadControl()
{
SetEvent(gs_hL0PCWin95SerialMainToIO);
WaitForSingleObject(gs_hL0PCWin95SerialIOToMain, INFINITE);
}
/*********************************************************/
void vGiveThreadControl()
{
SetEvent(gs_hL0PCWin95SerialMainToIO);
}
/********************************************************************************/
/* this is the IO thread main function */
/* it blocks on an array of the events to monitor */
/* and performs the appropriate work when an event gets signaled */
/********************************************************************************/
void vWorker(DWORD *dwParam)
{
DWORD dwSignaledHandle;
int iChannel, iActivatedChannel;
long lErrorCode;
#ifdef NET_USE_DEBUG
unsigned long ulBlockTime;
int iEvent;
#endif /* NET_USE_DEBUG */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "WaitForMultipleObjects:");
for(iEvent=0; iEvent<gs_iNEvents; iEvent++)
vDebugFormat(Net_C_Debug_SThread, "%x ", gs_ahWaitHandles[iEvent]);
vDebugFormat(Net_C_Debug_SThread, "\n");
#endif /* NET_USE_DEBUG */
for(;;) {
/* block until an I/O operation is completed */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "blocking ");
ulBlockTime=GetTickCount();
#endif /* NET_USE_DEBUG */
dwSignaledHandle=WaitForMultipleObjects(gs_iNEvents, gs_ahWaitHandles, FALSE, 100);
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "debloque: %d ", dwSignaledHandle);
if(GetTickCount()-ulBlockTime>50)
vDebugFormat(Net_C_Debug_SThread, "long delay ?");
for(iEvent=0; iEvent<gs_iNEvents; iEvent++) {
switch(WaitForSingleObject(gs_ahWaitHandles[iEvent], 0)) {
case WAIT_ABANDONED:
vDebugFormat(Net_C_Debug_SThread, "%d ??????", iEvent);
break;
case WAIT_OBJECT_0:
vDebugFormat(Net_C_Debug_SThread, "%d ", iEvent);
break;
case WAIT_TIMEOUT:
break;
}
}
vDebugFormat(Net_C_Debug_SThread, "\n");
#endif /* NET_USE_DEBUG */
switch(dwSignaledHandle) {
case WAIT_FAILED:
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
lErrorCode=GetLastError();
vDebugFormat(Net_C_Debug_SThread, "WAIT_FAILED : erreur %ld", lErrorCode);
#endif
ExitThread(1);
break;
case WAIT_TIMEOUT:
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "WAIT_TIMEOUT: checking for timeouts");
#endif
for(iChannel=0; iChannel<C_uw_Net_L0PCWin95Serial_PortNumber; iChannel++)
if(iCheckTimeOut(&gs_a_stL0PCWin95SerialChannels[iChannel])) {
SetEvent(gs_a_stL0PCWin95SerialChannels[iChannel].stOverlappedWrite.hEvent);
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "%d timed out", iChannel);
#endif
}
break;
case WAIT_OBJECT_0:
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "WAIT_OBJECT_0: basculement");
#endif /* NET_USE_DEBUG */
/* give control to the main thread and wait for reactivation */
SetEvent(gs_hL0PCWin95SerialIOToMain);
WaitForSingleObject(gs_hL0PCWin95SerialMainToIO, INFINITE);
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "new event array:");
for(iEvent=0; iEvent<gs_iNEvents; iEvent++)
vDebugFormat(Net_C_Debug_SThread, "%x ", gs_ahWaitHandles[iEvent]);
vDebugFormat(Net_C_Debug_SThread, "\n");
#endif /* NET_USE_DEBUG */
break;
default:
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "dwSignaledHandle: %d ", dwSignaledHandle);
#endif
iActivatedChannel=gs_auwChannels[dwSignaledHandle-WAIT_OBJECT_0];
if(gs_aucIsReadEvent[dwSignaledHandle-WAIT_OBJECT_0])
vDoRecv(&gs_a_stL0PCWin95SerialChannels[iActivatedChannel]);
else
vDoSend(&gs_a_stL0PCWin95SerialChannels[iActivatedChannel]);
/* check for time outs on the other channels */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "timeout check ");
#endif
for(iChannel=0; iChannel<C_uw_Net_L0PCWin95Serial_PortNumber; iChannel++)
if(iChannel!=iActivatedChannel && iCheckTimeOut(&gs_a_stL0PCWin95SerialChannels[iChannel])) {
SetEvent(gs_a_stL0PCWin95SerialChannels[iChannel].stOverlappedWrite.hEvent);
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "%d timed out", iChannel);
#endif
}
}
}
}
/*********************************************************/
void vInitThreadController()
{
gs_hL0PCWin95SerialThread = INVALID_HANDLE_VALUE;
gs_dwL0PCWin95SerialThreadID = 0;
gs_hL0PCWin95SerialIOToMain = gs_hL0PCWin95SerialMainToIO = INVALID_HANDLE_VALUE;
gs_iNEvents=0;
}
/*********************************************************/
void vAddThreadClient(tduwNetChannel uwChannel)
{
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"AddThreadClient(%d) ", uwChannel);
#endif
/* if the channel is invalid, return */
if(uwChannel>=C_uw_Net_L0PCWin95Serial_PortNumber)
return;
/* if no thread is active, we have to create one first */
if(gs_hL0PCWin95SerialThread == INVALID_HANDLE_VALUE)
vLaunchThread();
vGetThreadControl();
/* add the channel's read and write events to the controller */
gs_ahWaitHandles[gs_iNEvents]=gs_a_stL0PCWin95SerialChannels[uwChannel].stOverlappedRead.hEvent;
gs_auwChannels[gs_iNEvents]=uwChannel;
gs_aucIsReadEvent[gs_iNEvents++]=1;
gs_ahWaitHandles[gs_iNEvents]=gs_a_stL0PCWin95SerialChannels[uwChannel].stOverlappedWrite.hEvent;
gs_auwChannels[gs_iNEvents]=uwChannel;
gs_aucIsReadEvent[gs_iNEvents++]=0;
vGiveThreadControl();
}
/*********************************************************/
void vRemoveThreadClient(tduwNetChannel uwChannel)
{
int iEvent;
int iFound;
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"RemoveThreadClient(%d) ", uwChannel);
#endif
/* if the channel is invalid return */
if(uwChannel>=C_uw_Net_L0PCWin95Serial_PortNumber)
return;
/* if no thread is active, there is nothing to do */
if(gs_hL0PCWin95SerialThread == INVALID_HANDLE_VALUE)
return;
vGetThreadControl();
/* remove the channel's read and write events from the controller */
iFound=0;
for(iEvent=1; iEvent<gs_iNEvents; iEvent+=2)
if(iFound) {
gs_ahWaitHandles[iEvent-2]=gs_ahWaitHandles[iEvent];
gs_auwChannels[iEvent-2]=gs_auwChannels[iEvent];
gs_aucIsReadEvent[iEvent-2]=gs_aucIsReadEvent[iEvent];
gs_ahWaitHandles[iEvent-1]=gs_ahWaitHandles[iEvent+1];
gs_auwChannels[iEvent-1]=gs_auwChannels[iEvent+1];
gs_aucIsReadEvent[iEvent-1]=gs_aucIsReadEvent[iEvent+1];
} else if(gs_auwChannels[iEvent]==uwChannel)
iFound=1;
if(iFound)
gs_iNEvents-=2;
if(gs_iNEvents==1) /* if no client remains, delete the thread */
vDeleteThread();
else
vGiveThreadControl(); /* if at least one client remains, let the thread work */
}
/*********************************************************/
void vBuildPacket(tdstL0PCWin95SerialChannel *pstChannel, int iSlot, tdstPacket *pstPacket, unsigned char ucAckNumber)
{
tdstSlot *pstSlot;
pstSlot=&pstChannel->stSendWindow.pstSlot[iSlot];
memcpy(pstPacket->acData, pstSlot->acData, BLOCKSIZE);
pstPacket->ucStartMark=STARTMARK;
pstPacket->ucSeqn=pstSlot->ucSeqn;
pstPacket->ucAckn=ucAckNumber;
pstPacket->ucSize=pstSlot->ucSize;
pstPacket->usChecksum=usComputeChecksum(pstPacket);
}
/*********************************************************/
int iSendPacket(tdstL0PCWin95SerialChannel *pstChannel, tdstPacket *pstPacket)
{
unsigned long ulWrittenBytes;
long lErrorCode;
EnterCriticalSection(&pstChannel->stChannelAccess);
if(pstChannel->ubf1IsSlotInUse) {
if(WriteFile(pstChannel->hCom, pstPacket, sizeof(tdstPacket), &ulWrittenBytes, &pstChannel->stOverlappedWrite)==FALSE) {
lErrorCode=GetLastError();
if(lErrorCode!=ERROR_IO_PENDING) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "WriteFile(): error %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
exit(1);
}
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "sending (%d, %d)",pstPacket->ucSeqn, pstPacket->ucAckn);
#endif /* NET_USE_DEBUG */
pstChannel->ubf1WriteInProgress=1; /* the operation is executing asynchronously */
} else {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "sending (%d, %d) (finished)",pstPacket->ucSeqn, pstPacket->ucAckn);
#endif /* NET_USE_DEBUG */
pstChannel->ubf1WriteInProgress=0; /* the operation finished synchronously */
SetEvent(pstChannel->stOverlappedWrite.hEvent);
}
} else {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "channel not in use ???");
#endif /* NET_USE_DEBUG */
/* shouldn't happen ... */
ResetEvent(pstChannel->stOverlappedWrite.hEvent);
}
LeaveCriticalSection(&pstChannel->stChannelAccess);
return 1;
}
/*********************************************************/
void vCompleteSendPacket(tdstL0PCWin95SerialChannel *pstChannel)
{
unsigned long ulWrittenBytes;
unsigned long ulLineError;
long lErrorCode;
COMSTAT stComStat;
EnterCriticalSection(&pstChannel->stChannelAccess);
if(pstChannel->ubf1IsSlotInUse) {
if(GetOverlappedResult(pstChannel->hCom, &pstChannel->stOverlappedWrite, &ulWrittenBytes, FALSE)==FALSE) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "GetOverlappedResult(write): error %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
/*
exit(1);
on Windows NT on a biprocessor system, the control happens to come here
if I comment out the call to exit(), the system works anyway ...
*/
}
pstChannel->ubf1WriteInProgress=0;
#ifdef NET_USE_DEBUG
if(ulWrittenBytes!=sizeof(tdstPacket)) {
vDebugFormat(Net_C_Debug_SBlocks, "written bytes (%lu) != sizeof(tdstPacket) ???", ulWrittenBytes);
}
#endif /* NET_USE_DEBUG */
if(ClearCommError(pstChannel->hCom, &ulLineError, &stComStat)==FALSE) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "ClearCommError(): error %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
}
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "CompleteSendPacket(): OutQueue=%d", stComStat.cbOutQue);
/* report the error state */
if(ulLineError) {
vDisplayErrorState(Net_C_Debug_SBlocks, ulLineError);
}
if( stComStat.fCtsHold || stComStat.fDsrHold || stComStat.fRlsdHold
|| stComStat.fXoffHold || stComStat.fXoffSent || stComStat.fEof || stComStat.fTxim) {
vDisplayComStat(Net_C_Debug_SBlocks, &stComStat);
}
#endif /* NET_USE_DEBUG */
}
LeaveCriticalSection(&pstChannel->stChannelAccess);
}
/*********************************************************/
void vInitWindow(tdstWindow *pstWindow, int iSize, unsigned long ulTimeout)
{
int iSlot;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "InitWindow(): size: %d, timeout: %lu", iSize, ulTimeout);
#endif /* NET_USE_DEBUG */
pstWindow->iSize=iSize;
pstWindow->ulTimeout=ulTimeout;
pstWindow->pstSlot=(tdstSlot *)pMalloc(iSize*sizeof(tdstSlot));
memset(pstWindow->pstSlot, 0, iSize*sizeof(tdstSlot));
for(iSlot=0; iSlot<iSize; iSlot++) {
pstWindow->pstSlot[iSlot].ucState=FREE;
}
}
/*********************************************************/
void vDeleteWindow(tdstWindow *pstWindow)
{
if(pstWindow->pstSlot!=(tdstSlot *)C_pNull) {
vFree((tdpPointer)pstWindow->pstSlot);
pstWindow->pstSlot=(tdstSlot *)C_pNull;
pstWindow->iSize=0;
pstWindow->ulTimeout=0;
}
}
/*********************************************************/
int iGetFreeSlot(tdstWindow *pstWindow)
{
int i, iElectedSlot;
unsigned long ulOldestDate;
tdstSlot *astSendSlot;
astSendSlot=pstWindow->pstSlot;
ulOldestDate=0xffffffff;
iElectedSlot=INVALID_SLOT;
/* find a free slot */
for(i=0; i<pstWindow->iSize; i++)
if(astSendSlot[i].ucState==FREE) {
iElectedSlot=i;
break;
}
/* or, find the oldest acknowledged slot */
if(iElectedSlot==INVALID_SLOT)
for(i=0; i<pstWindow->iSize; i++)
if(astSendSlot[i].ucState==ACK && astSendSlot[i].ulDate<ulOldestDate) {
ulOldestDate=astSendSlot[i].ulDate;
iElectedSlot=i;
}
return iElectedSlot;
}
/*********************************************************/
void vNumberSlot(tdstL0PCWin95SerialChannel *pstChannel, int iSlot)
{
pstChannel->stSendWindow.pstSlot[iSlot].ucSeqn=pstChannel->ucSeqn;
pstChannel->ucSeqn= (pstChannel->ucSeqn+1) % 0xff; /* 0xff is reserved for 'no acknowledgement' */
}
/*********************************************************/
int iChooseSendSlot(tdstWindow *pstWindow)
{
int i, iElectedSlot;
unsigned long ulDate, ulOldestDate;
unsigned char ucLowestSeqn;
tdstSlot *astSendSlot;
astSendSlot=pstWindow->pstSlot;
ulDate=GetTickCount();
ulOldestDate=0xffffffff;
iElectedSlot=INVALID_SLOT;
/* find the slots that have timed out: they have to be sent again */
for(i=0; i<pstWindow->iSize; i++)
if(astSendSlot[i].ucState==TIMED_OUT || astSendSlot[i].ucState==SENT && astSendSlot[i].ulDate+pstWindow->ulTimeout<ulDate) {
astSendSlot[i].ucState=TIMED_OUT;
if(astSendSlot[i].ulDate<ulOldestDate) {
ulOldestDate=astSendSlot[i].ulDate;
iElectedSlot=i;
}
}
if(iElectedSlot!=INVALID_SLOT) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "<%d : time out>@%lu", astSendSlot[iElectedSlot].ucSeqn, ulDate);
#endif /* NET_USE_DEBUG */
return iElectedSlot;
}
/* find the slot to send with the lowest sequence number */
ucLowestSeqn=0xff;
iElectedSlot=INVALID_SLOT;
for(i=0; i<pstWindow->iSize; i++)
if(astSendSlot[i].ucState==TO_SEND && astSendSlot[i].ucSeqn<ucLowestSeqn) {
ucLowestSeqn=astSendSlot[i].ucSeqn;
iElectedSlot=i;
}
if(iElectedSlot==INVALID_SLOT) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "<no slot to send>");
#endif /* NET_USE_DEBUG */
}
return iElectedSlot;
}
/*********************************************************/
int iCheckTimeOut(tdstL0PCWin95SerialChannel *pstChannel)
{
unsigned long ulDate;
int i;
int iTimedOut;
EnterCriticalSection(&pstChannel->stChannelAccess);
iTimedOut=0;
if( pstChannel->ubf1IsSlotInUse && pstChannel->ubf1IsSlotConnected /* if the channel is invalid, return immediately */
&& !pstChannel->ubf1WriteInProgress /* if the channel is currently sending a message, return immediately */
) {
/* check whether a slot has timed out */
ulDate=GetTickCount();
for(i=0; i<pstChannel->stSendWindow.iSize; i++)
if(pstChannel->stSendWindow.pstSlot[i].ucState==SENT && pstChannel->stSendWindow.pstSlot[i].ulDate+pstChannel->stSendWindow.ulTimeout<ulDate) {
iTimedOut=1; /* this slot has timed out */
break;
}
}
LeaveCriticalSection(&pstChannel->stChannelAccess);
return iTimedOut;
}
/*********************************************************/
int iSlotsNotAck(tdstWindow *pstSendWindow)
{
int i, iCount;
/* compute the number of data send slots still requiring to be sent and/or acknowledged */
iCount=0;
for(i=0; i<pstSendWindow->iSize; i++)
if( pstSendWindow->pstSlot[i].ucSeqn!=INVALID_SLOT &&
( pstSendWindow->pstSlot[i].ucState==TO_SEND ||
pstSendWindow->pstSlot[i].ucState==SENT ||
pstSendWindow->pstSlot[i].ucState==TIMED_OUT ) )
iCount++;
return iCount;
}
/*********************************************************/
unsigned short usComputeChecksum(tdstPacket *pstPacket)
{
int i;
unsigned short usChecksum;
usChecksum=pstPacket->ucSeqn+pstPacket->ucAckn+pstPacket->ucSize;
for(i=0; i<BLOCKSIZE; i++)
usChecksum+=pstPacket->acData[i];
return usChecksum;
}
/*********************************************************/
unsigned char ucGetAckNumber(tdstWindow *pstWindow)
{
tdstSlot *astRecvSlot;
#define SECOND_METHOD
#ifdef FIRST_METHOD
int i, iOldestSlot;
unsigned long ulOldestDate;
astRecvSlot=pstWindow->pstSlot;
ulOldestDate=0xffffffff;
iOldestSlot=INVALID_SLOT;
/* first method: get the oldest received slot */
for(i=0; i<pstWindow->iSize; i++)
if(astRecvSlot[i].ucState==RECVD && astRecvSlot[i].ulDate<ulOldestDate) {
ulOldestDate=astRecvSlot[i].ulDate;
iOldestSlot=i;
}
if(iOldestSlot==INVALID_SLOT)
return INVALID_SLOT; /* 'no acknowledgement' */
else { /* mark the block as acknowledged and return its sequence number */
astRecvSlot[iOldestSlot].ucState=ACK;
return astRecvSlot[iOldestSlot].ucSeqn;
}
#endif /* FIRST_METHOD */
#ifdef SECOND_METHOD
/* second method: get the slot with lowest sequence number */
int i, iLowestSlot;
unsigned char ucLowestn;
astRecvSlot=pstWindow->pstSlot;
iLowestSlot=INVALID_SLOT;
for(i=0; i<pstWindow->iSize; i++)
if(astRecvSlot[i].ucState==RECVD) {
ucLowestn=astRecvSlot[i].ucSeqn;
iLowestSlot=i;
break;
}
for(i++; i<pstWindow->iSize; i++)
if(astRecvSlot[i].ucState==RECVD && iBeforeSequence(astRecvSlot[i].ucSeqn, ucLowestn)) {
ucLowestn=astRecvSlot[i].ucSeqn;
iLowestSlot=i;
}
if(iLowestSlot==INVALID_SLOT)
return INVALID_SLOT; /* 'no acknowledgement' */
else { /* mark the block as acknowledged and return its sequence number */
astRecvSlot[iLowestSlot].ucState=ACK;
return ucLowestn;
}
#endif /* SECOND_METHOD */
}
/*********************************************************/
int iChooseRecvSlot(tdstWindow *pstWindow, unsigned char ucSeqn)
{
int i, iOldestSlot;
unsigned long ulOldestDate;
tdstSlot *astRecvSlot;
char cNoFreeSlot;
#ifdef NET_USE_DEBUG
int n;
#endif /* NET_USE_DEBUG */
astRecvSlot=pstWindow->pstSlot;
#ifdef NET_USE_DEBUG
/* how many receive slots are waiting for acknowledgement ? */
for(i=0, n=0; i<pstWindow->iSize; i++)
if( astRecvSlot[i].ucState==RECVD )
n++;
vDebugFormat(Net_C_Debug_SBlocks, "%d received slots not yet ack", n);
#endif /* NET_USE_DEBUG */
cNoFreeSlot=1;
ulOldestDate=0xffffffff;
iOldestSlot=INVALID_SLOT;
/* find a slot with the same sequence number */
/* or take the oldest free slot */
for(i=0; i<pstWindow->iSize; i++)
if( astRecvSlot[i].ucState==RECVD && astRecvSlot[i].ucSeqn==ucSeqn )
return i;
for(i=0; i<pstWindow->iSize; i++)
if((astRecvSlot[i].ucState==ACK || astRecvSlot[i].ucState==FREE) && astRecvSlot[i].ulDate<ulOldestDate) {
cNoFreeSlot=0;
ulOldestDate=astRecvSlot[i].ulDate;
iOldestSlot=i;
}
#ifdef NET_USE_DEBUG
if(cNoFreeSlot)
vDebugFormat(Net_C_Debug_SBlocks, "NoFreeSlot ! ");
#endif /* NET_USE_DEBUG */
return iOldestSlot;
}
/*********************************************************/
int iGetAckSendSlot(tdstWindow *pstWindow, unsigned char ucAckn)
{
int i;
tdstSlot *astSendSlot;
#ifdef NET_USE_DEBUG
int n;
#endif /* NET_USE_DEBUG */
astSendSlot=pstWindow->pstSlot;
#ifdef NET_USE_DEBUG
/* how many slots are waiting for acknowledgement ?*/
for(i=0, n=0; i<pstWindow->iSize; i++)
if( astSendSlot[i].ucState==SENT || astSendSlot[i].ucState==TIMED_OUT )
n++;
vDebugFormat(Net_C_Debug_SBlocks, "%d unacknowledged send slots", n);
#endif /* NET_USE_DEBUG */
/* find the send slot whose sequence number is acknowledged */
for(i=0; i<pstWindow->iSize; i++)
if( ( astSendSlot[i].ucState==SENT || astSendSlot[i].ucState==TIMED_OUT)
&& astSendSlot[i].ucSeqn==ucAckn)
return i;
return INVALID_SLOT;
}
/*********************************************************/
/* bitmasks to build GetPacket() function return value */
#define GET_PACKET__NO_PACKET (0)
#define GET_PACKET__PACKET_OK (1<<1)
#define GET_PACKET__MORE_AVAILABLE (1<<2)
int iGetPacket(tdstL0PCWin95SerialChannel *pstChannel, tdstPacket *pstReturnPacket)
{
long lErrorCode;
unsigned long ulLineError;
unsigned long ulReadBytes;
unsigned long ulLostBytes;
unsigned long ulBytesToRead;
char cEnoughChar;
char cChecksumCorrect;
COMSTAT stComStat;
tdstPacket *pstPacket;
int iRetVal; /* return value */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "entree GetPacket(%d)", pstChannel-gs_a_stL0PCWin95SerialChannels);
#endif /* NET_USE_DEBUG */
iRetVal=GET_PACKET__NO_PACKET; /* a priori, we have no new packet */
/* clear the error state */
EnterCriticalSection(&pstChannel->stChannelAccess);
if(pstChannel->ubf1IsSlotInUse) {
if(ClearCommError(pstChannel->hCom, &ulLineError, &stComStat)==FALSE) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "ClearCommError(): error %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "ClearCommError(): error %ld, hCom=%x", lErrorCode, pstChannel->hCom);
#endif /* NET_USE_DEBUG */
}
#ifdef NET_USE_DEBUG
/* report the error state */
if(ulLineError) {
vDisplayErrorState(Net_C_Debug_SBlocks, ulLineError);
}
if( stComStat.fCtsHold || stComStat.fDsrHold || stComStat.fRlsdHold
|| stComStat.fXoffHold || stComStat.fXoffSent || stComStat.fEof || stComStat.fTxim) {
vDisplayComStat(Net_C_Debug_SBlocks, &stComStat);
}
if( stComStat.cbInQue>0 ) {
vDebugFormat(Net_C_Debug_SBlocks, "octets residuels: %ld", stComStat.cbInQue);
}
#endif /* NET_USE_DEBUG */
if(ulLineError) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "line error:%ld", ulLineError);
#endif /* NET_USE_DEBUG */
}
/* eventually complete the asynchronous read operation */
if(pstChannel->ubf1ReadInProgress) {
ulReadBytes=0;
if(GetOverlappedResult(pstChannel->hCom, &pstChannel->stOverlappedRead, &ulReadBytes, FALSE)==FALSE) {
lErrorCode=GetLastError();
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "GetOverlappedResult(read): error %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
}
pstChannel->ulReadPos+=ulReadBytes;
pstChannel->ubf1ReadInProgress=0;
} else
ResetEvent(pstChannel->stOverlappedRead.hEvent);
/* try to find a packet */
ulLostBytes=0;
do {
cEnoughChar= pstChannel->ulReadPos-ulLostBytes >= sizeof(tdstPacket);
if(cEnoughChar) {
pstPacket=(tdstPacket *)(pstChannel->acReadBuffer+ulLostBytes);
cChecksumCorrect= pstPacket->ucStartMark == STARTMARK
&& pstPacket->usChecksum == usComputeChecksum(pstPacket);
if(!cChecksumCorrect)
ulLostBytes++;
}
} while(cEnoughChar && !cChecksumCorrect);
if(ulLostBytes>0) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "%lu bytes lost !", ulLostBytes);
#endif /* NET_USE_DEBUG */
pstChannel->ulReadPos-=ulLostBytes;
MoveMemory(pstChannel->acReadBuffer, pstChannel->acReadBuffer+ulLostBytes,
pstChannel->ulReadPos);
}
if(cEnoughChar) { /* we have a correct packet */
CopyMemory(pstReturnPacket, pstChannel->acReadBuffer, sizeof(tdstPacket));
pstChannel->ulReadPos-=sizeof(tdstPacket);
MoveMemory(pstChannel->acReadBuffer, pstChannel->acReadBuffer+sizeof(tdstPacket),
pstChannel->ulReadPos);
iRetVal|=GET_PACKET__PACKET_OK; /* inform the caller that we have a packet */
}
/* resume reading */
/* we know we can read at least sizeof(tdstPacket) bytes in the buffer */
/* because the buffer is of size 2*sizeof(tdstPacket) */
/* and at this point we have at most sizeof(tdstPacket)-1 bytes in the buffer */
/* first method */
/* if the input buffer contains no bytes, try to read one byte */
/* if the input buffer already contains bytes, read min(number of bytes, sizeof(tdstPacket) ) */
/* this is necessary to be sure that the asynchronous read operation always completes as soon */
/* as bytes are available for read */
/*
if( stComStat.cbInQue > 0 )
if( stComStat.cbInQue < sizeof(tdstPacket) )
ulBytesToRead=stComStat.cbInQue;
else ulBytesToRead=sizeof(tdstPacket);
else ulBytesToRead=1;
*/
/* second method */
/* read the number of bytes necessary to complete a packet */
/* ulBytesToRead=sizeof(tdstPacket)-pstChannel->ulReadPos;
*/
/* third method: use finite timeouts for the read operations */
/* fourth method: if an error occured , use the first method, if not, use the second method */
if(!cEnoughChar) {
if( stComStat.cbInQue > 0 )
if( stComStat.cbInQue < sizeof(tdstPacket) )
ulBytesToRead=stComStat.cbInQue;
else ulBytesToRead=sizeof(tdstPacket);
else ulBytesToRead=1;
} else {
ulBytesToRead=sizeof(tdstPacket)-pstChannel->ulReadPos;
}
/* if the next read operation is to return immediately, indicate it in the return code */
if(ulBytesToRead <= stComStat.cbInQue)
iRetVal|=GET_PACKET__MORE_AVAILABLE;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "ReadFile(%lu->%lu): ", ulBytesToRead, pstChannel->ulReadPos);
#endif /* NET_USE_DEBUG */
if(ReadFile(pstChannel->hCom, pstChannel->acReadBuffer+pstChannel->ulReadPos, /*sizeof(tdstPacket)*/ulBytesToRead, &ulReadBytes, &pstChannel->stOverlappedRead)==FALSE) {
lErrorCode=GetLastError();
if(lErrorCode!=ERROR_IO_PENDING) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "ReadFile(): error %ld", lErrorCode);
#endif /* NET_USE_DEBUG */
} else
pstChannel->ubf1ReadInProgress=1; /* the operation is asynchronous */
} else {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "ReadFile(): finished !!!");
#endif /* NET_USE_DEBUG */
/* the operation finished synchronously */
pstChannel->ulReadPos+=ulReadBytes;
pstChannel->ubf1ReadInProgress=0;
SetEvent(pstChannel->stOverlappedRead.hEvent);
}
} else {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "channel not in use ???");
#endif /* NET_USE_DEBUG */
/* shouldn't happen ... */
ResetEvent(pstChannel->stOverlappedRead.hEvent);
}
#ifdef NET_USE_DEBUG
if(iRetVal&GET_PACKET__PACKET_OK)
vDebugFormat(Net_C_Debug_SBlocks, "got a packet (%d, %d) !", pstReturnPacket->ucSeqn,
pstReturnPacket->ucAckn);
#endif /* NET_USE_DEBUG */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "sortie GetPacket()");
#endif /* NET_USE_DEBUG */
LeaveCriticalSection(&pstChannel->stChannelAccess);
return iRetVal;
}
/*********************************************************/
void vDoSend(tdstL0PCWin95SerialChannel *pstChannel)
{
int iSlot;
tdstSlot *pstSlot;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "entree DoSend(%d)", pstChannel-gs_a_stL0PCWin95SerialChannels);
#endif /* NET_USE_DEBUG */
EnterCriticalSection(&pstChannel->stChannelAccess);
/* eventually complete the former send operation */
if(pstChannel->ubf1WriteInProgress)
vCompleteSendPacket(pstChannel);
else ResetEvent(pstChannel->stOverlappedWrite.hEvent);
/* get some data to send */
iUnloadSendBuffer(pstChannel);
iSlot=iChooseSendSlot(&pstChannel->stSendWindow);
if(iSlot!=INVALID_SLOT) { /* send a real packet */
pstSlot=&pstChannel->stSendWindow.pstSlot[iSlot];
vBuildPacket(pstChannel, iSlot, &pstChannel->stPacket, ucGetAckNumber(&pstChannel->stRecvWindow));
iSendPacket(pstChannel, &pstChannel->stPacket);
pstSlot->ucState=SENT;
pstSlot->ulDate=GetTickCount();
} else if((pstChannel->stPacket.ucAckn=ucGetAckNumber(&pstChannel->stRecvWindow))!=INVALID_SLOT) {
/* there is no slot to send, however we have to send the acknowledgement */
/* of a received packet: so we build a dummy packet */
memset(pstChannel->stPacket.acData, 0, BLOCKSIZE);/* so as to avoid checksum computation */
pstChannel->stPacket.ucStartMark=STARTMARK;
pstChannel->stPacket.ucSeqn=INVALID_SLOT;
pstChannel->stPacket.usChecksum=pstChannel->stPacket.ucSeqn+pstChannel->stPacket.ucAckn;
pstChannel->stPacket.ucSize=0;
iSendPacket(pstChannel, &pstChannel->stPacket);
}
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "sortie DoSend()");
#endif /* NET_USE_DEBUG */
LeaveCriticalSection(&pstChannel->stChannelAccess);
}
/*********************************************************/
void vDoRecv(tdstL0PCWin95SerialChannel *pstChannel)
{
int iSlot;
int iPacketFlag;
int iLoopNumber;
tdstPacket stPacket;
tdstSlot *pstSlot;
#define DORECV_LOOP_LIMIT 4
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "entree DoRecv(%d)", pstChannel-gs_a_stL0PCWin95SerialChannels);
#endif /* NET_USE_DEBUG */
EnterCriticalSection(&pstChannel->stChannelAccess);
/* read packets while packets are available, without looping forever */
iLoopNumber=0;
do {
/* try to read a packet from the line */
if((iPacketFlag=iGetPacket(pstChannel, &stPacket)) & GET_PACKET__PACKET_OK) {
/* if this is not a dummy packet, store the packet in the receive buffer */
/* and prepare to acknowledge it */
if(stPacket.ucSeqn!=INVALID_SLOT) {
/* choose a slot to store the received packet into */
iSlot=iChooseRecvSlot(&pstChannel->stRecvWindow, stPacket.ucSeqn);
if(iSlot!=INVALID_SLOT) {
if(iLoadRecvBuffer(pstChannel, &stPacket)) {
pstSlot=&pstChannel->stRecvWindow.pstSlot[iSlot];
pstSlot->ucSeqn=stPacket.ucSeqn;
pstSlot->ucState=RECVD; /* so as to be acknowledged */
pstSlot->ulDate=GetTickCount();
memcpy(pstSlot->acData, stPacket.acData, BLOCKSIZE); /* not necessary in fact */
} else {
/* the packet is lost because there is no room to store it in the link buffer */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "packet %d refused by linkbuffer", stPacket.ucSeqn);
#endif /* NET_USE_DEBUG */
}
} else { /* the packet is lost because there is no slot to store its sequence number (which must be known when the acknowledgement is sent) */
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "no slot to keep packet %d", stPacket.ucSeqn);
#endif /* NET_USE_DEBUG */
}
}
/* acknowledge the send slot indicated in the packet */
iSlot=iGetAckSendSlot(&pstChannel->stSendWindow, stPacket.ucAckn);
if(iSlot!=INVALID_SLOT) {
pstChannel->stSendWindow.pstSlot[iSlot].ucState=ACK;
/* if all send slots have been acknowledged, signal the event */
if(iSlotsNotAck(&pstChannel->stSendWindow)==0)
SetEvent(pstChannel->hSlotsEmpty);
}
/* if the channel is not sending, wake it up */
if(!pstChannel->ubf1WriteInProgress) {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "DoRecv(): set write event");
#endif /* NET_USE_DEBUG */
SetEvent(pstChannel->stOverlappedWrite.hEvent);
} else {
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SBlocks, "DoRecv(): already sending: don't set write event ");
#endif /* NET_USE_DEBUG */
}
}
} while(iPacketFlag & GET_PACKET__MORE_AVAILABLE && iLoopNumber++<DORECV_LOOP_LIMIT);
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "sortie DoRecv()");
#endif /* NET_USE_DEBUG */
LeaveCriticalSection(&pstChannel->stChannelAccess);
}
/*********************************************************/
unsigned long ulMaxSendSize(int iChannel)
{
unsigned long ReturnValue;
tdstL0PCWin95SerialChannel *pstChannel;
pstChannel=&gs_a_stL0PCWin95SerialChannels[iChannel];
EnterCriticalSection(&pstChannel->stSendBufferAccess);
ReturnValue=FreeSpace(&pstChannel->stSendBuffer);
LeaveCriticalSection(&pstChannel->stSendBufferAccess);
return ReturnValue;
}
/*********************************************************/
int iSendMsg(int iChannel, char *pcMsg, unsigned long ulSize)
{
int iReturnValue;
tdstL0PCWin95SerialChannel *pstChannel;
/* try to store the message into the send buffer */
pstChannel=&gs_a_stL0PCWin95SerialChannels[iChannel];
EnterCriticalSection(&pstChannel->stSendBufferAccess);
iReturnValue=iPushMessageRingBuffer(&pstChannel->stSendBuffer, pcMsg, ulSize);
/* if the channel is inactive, wake it up */
if(!pstChannel->ubf1WriteInProgress)
SetEvent(pstChannel->stOverlappedWrite.hEvent);
LeaveCriticalSection(&pstChannel->stSendBufferAccess);
return iReturnValue;
}
/*********************************************************/
int iUnloadSendBuffer(tdstL0PCWin95SerialChannel *pstChannel)
{
int iSlot;
tdstSlot *pstSlot;
int iBlockSize;
/* if a send slot is available and there is data in the send buffer */
/* copy that data into the send slot */
/* get a send slot with a new sequence number */
iSlot=iGetFreeSlot(&pstChannel->stSendWindow);
if(iSlot!=INVALID_SLOT) {
pstSlot=&pstChannel->stSendWindow.pstSlot[iSlot];
/* get a block from the send buffer */
EnterCriticalSection(&pstChannel->stSendBufferAccess);
iBlockSize=iPopBlockRingBuffer(&pstChannel->stSendBuffer, pstSlot->acData, BLOCKSIZE);
if(iBlockSize>=0) {
pstSlot->ucState=TO_SEND;
pstSlot->ucSize=iBlockSize;
vNumberSlot(pstChannel, iSlot);
} else {
/* if there is no data left in the buffer, signal it */
SetEvent(pstChannel->hBufferEmpty);
}
LeaveCriticalSection(&pstChannel->stSendBufferAccess);
}
return iSlot!=INVALID_SLOT && pstSlot->ucState==TO_SEND;
}
/*********************************************************/
int iLoadRecvBuffer(tdstL0PCWin95SerialChannel *pstChannel, tdstPacket *pstPacket)
{
int iReturnValue;
EnterCriticalSection(&pstChannel->stRecvBufferAccess);
iReturnValue=iPushBlockLinkBuffer(&pstChannel->stRecvBuffer, pstPacket->ucSeqn, pstPacket->ucSize, pstPacket->acData)==eLinkOk;
LeaveCriticalSection(&pstChannel->stRecvBufferAccess);
return iReturnValue;
}
/*********************************************************/
int iRecvMsg(int iChannel, char *pcMsg, unsigned long ulSize)
{
int iReturnValue;
tdstL0PCWin95SerialChannel *pstChannel;
/* try to read the message from the receive buffer */
pstChannel=&gs_a_stL0PCWin95SerialChannels[iChannel];
EnterCriticalSection(&pstChannel->stRecvBufferAccess);
iReturnValue=iPopDataLinkBuffer(&pstChannel->stRecvBuffer, pcMsg, ulSize)==eLinkOk;
LeaveCriticalSection(&pstChannel->stRecvBufferAccess);
return iReturnValue;
}
/*********************************************************/
int iMaxRecvMsg(int iChannel, char *pcMsg, unsigned long *pulSize)
{
int iReturnValue;
unsigned long ulMaxRead;
/* try to read the message from the receive buffer */
tdstL0PCWin95SerialChannel *pstChannel;
pstChannel=&gs_a_stL0PCWin95SerialChannels[iChannel];
EnterCriticalSection(&pstChannel->stRecvBufferAccess);
ulMaxRead=ulLengthLinkBuffer(&pstChannel->stRecvBuffer);
if(ulMaxRead>0) {
if(*pulSize>ulMaxRead)
*pulSize=ulMaxRead;
iReturnValue=iPopDataLinkBuffer(&pstChannel->stRecvBuffer, pcMsg, *pulSize)==eLinkOk;
if(!iReturnValue) /* if a problem appeared, no data was read */
*pulSize=0L;
} else {
*pulSize=0L;
iReturnValue=~0;
}
LeaveCriticalSection(&pstChannel->stRecvBufferAccess);
return iReturnValue;
}
/*****************************************************************************
*
* Description: uwL0PCWin95SerialStartChannelScan
*
* returns the identification number of the first channel for the protocol
*
*****************************************************************************
*
* Input: none
*
* Output: identification of the channel
*
*****************************************************************************
* Creation Date: April 15, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
*
****************************************************************************/
tduwNetChannel uwL0PCWin95SerialStartChannelScan(void)
{
tduwNetChannel uwCurrentChannel;
/* scan the array of channel definitions */
for (uwCurrentChannel = 0; uwCurrentChannel < C_uw_Net_L0PCWin95Serial_PortNumber; uwCurrentChannel ++)
/* if the slot is used, and can transmit data to another individual player */
if
(
gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotInUse
&& !gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotForModem
)
/* return its index value */
return uwCurrentChannel;
/* else no slot is in use */
return C_uwNetInvalidChannel ;
}
/*****************************************************************************
*
* Description: uwL0PCWin95SerialNextChannel
*
* returns the identification number of the channel following the last
*
*****************************************************************************
*
* Input: uwLastScannedChannel, index returned by the previous call
*
* Output: identification of the channel following the specified one
*
*****************************************************************************
* Creation Date: April 15, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
*
****************************************************************************/
tduwNetChannel uwL0PCWin95SerialNextChannel(tduwNetChannel uwLastScannedChannel)
{
tduwNetChannel uwCurrentChannel;
/*
* scan the array of channel definitions, starting with the channel following
* the last channel returned
*/
for
(
uwCurrentChannel = (tduwNetChannel)(uwLastScannedChannel + 1);
uwCurrentChannel < C_uw_Net_L0PCWin95Serial_PortNumber;
uwCurrentChannel ++
)
/* if the slot is used, and can transmit data to another individual player */
if
(
gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotInUse
&& !gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotForModem
)
/* return its index value */
return uwCurrentChannel;
/* else no slot is in use */
return C_uwNetInvalidChannel;
}
/*****************************************************************************
*
* Description: uwL0PCWin95SerialStartBroadcastChannelScan
*
* returns the identification number of the first broadcast channel
* for the protocol
*
*****************************************************************************
*
* Input: none
*
* Output: identification of the channel
*
*****************************************************************************
* Creation Date: April 15, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
*
****************************************************************************/
tduwNetChannel uwL0PCWin95SerialStartBroadcastChannelScan(void)
{
tduwNetChannel uwCurrentChannel;
/* scan the array of channel definitions */
for (uwCurrentChannel = 0; uwCurrentChannel < C_uw_Net_L0PCWin95Serial_PortNumber; uwCurrentChannel ++)
/* if the slot is used, and the channel can send broadcast data */
if
(
gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotInUse
&& !gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotForModem
&& gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsBroadcast
)
/* return its index value */
return uwCurrentChannel;
/* else no slot is in use */
return C_uwNetInvalidChannel;
}
/*****************************************************************************
*
* Description: uwL0PCWin95SerialNextBroadcastChannel
*
* returns the identification number of the broadcast channel following
* the specified one
*
*****************************************************************************
*
* Input: uwLastScannedChannel, index returned by the previous call
*
* Output: identification of the channel following the specified one
*
*****************************************************************************
* Creation Date: April 15, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
*
****************************************************************************/
tduwNetChannel uwL0PCWin95SerialNextBroadcastChannel(tduwNetChannel uwLastScannedChannel)
{
tduwNetChannel uwCurrentChannel;
/*
* scan the array of channel definitions, starting with the channel following
* the last channel returned
*/
for
(
uwCurrentChannel = (tduwNetChannel)(uwLastScannedChannel + 1);
uwCurrentChannel < C_uw_Net_L0PCWin95Serial_PortNumber;
uwCurrentChannel ++
)
/* if the slot is used, and can transmit broadcast data */
if
(
gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotInUse
&& !gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsSlotForModem
&& gs_a_stL0PCWin95SerialChannels[uwCurrentChannel].ubf1IsBroadcast
)
/* return its index value */
return uwCurrentChannel;
/* else no slot is in use */
return C_uwNetInvalidChannel;
}
/*****************************************************************************
*
* Description: eL0PCWin95SerialReadData
*
* buffer the data in the incoming buffer. if a full message is present,
* allocate a block to copy the message into it and put its address in the
* given pointer.
*
*****************************************************************************
*
* Input: p_uwChannel, pointer on a field to store the identification of
* a new channel in case of access to a newly created broacast channel
* (irrelevant for the serial layer)
* ppData, address of the pointer to retrieve a full message if
* necessary.
*
* Output: an error condition.
*
*****************************************************************************
* Creation Date: April 15, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
* 05/11/96 Christophe Roguet
* corrected a bug in the swap code
* 04/02/97 Christophe Roguet
* removed the start mark stuff, no longer needed thanks to the work of the thread
****************************************************************************/
NetLib_tdeErrorStatus eL0PCWin95SerialReadData(tduwNetChannel *p_uwChannel, tdpPointer *ppData)
{
tdstL0PCWin95SerialChannel *p_stChannel;
unsigned long ulTotalSizeOfMessage;
unsigned long ulBytesCurrentlyRead;
NetLib_tdeErrorStatus eErrorReturned;
tdstNetMessage *p_stNewMsg;
/* by default, there is no full message in the buffer */
*ppData = C_pNull;
/* if the specified channel is valid */
if (*p_uwChannel >= C_uw_Net_L0PCWin95Serial_PortNumber)
/* the channel does not exist in our database -> error!! */
return NetLib_E_es_InvalidChannel;
p_stChannel = &gs_a_stL0PCWin95SerialChannels[*p_uwChannel];
/* if the slot is properly initialized */
if (!p_stChannel->ubf1IsSlotInUse)
/* the slot is not initialized for use -> error!! */
return NetLib_E_es_ChannelUninitialized;
ulBytesCurrentlyRead=C_uwMaxAsyncLength-p_stChannel->ulBytesInReadBuffer;
iMaxRecvMsg(*p_uwChannel, p_stChannel->pCurrentReceivingBuffer+p_stChannel->ulBytesInReadBuffer, &ulBytesCurrentlyRead);
#ifdef NETLIB_LEVEL0COM_TRACE_FULL
vDebugFormat(Net_C_Debug_Serial,"Bytes Received (%u) :", ulBytesCurrentlyRead);
vDebugSDump(Net_C_Debug_Serial, "", p_stChannel->pCurrentReceivingBuffer+p_stChannel->ulBytesInReadBuffer,
ulBytesCurrentlyRead);
#endif /* NETLIB_LEVEL0COM_TRACE_FULL */
p_stChannel->ulBytesInReadBuffer +=ulBytesCurrentlyRead;
if(!p_stChannel->ulBytesInReadBuffer)
{
/* Nothing comes...*/
/* (nothing to do, with the threaded version) */
return NetLib_E_es_NoFullMessage;
}
/* if a message is being received but is not complete yet */
if (p_stChannel->pCurrentReceivedMessage)
{
unsigned long ulBytesToCopy;
/* if there are enough bytes to complete the message */
if (p_stChannel->ulBytesToCompleteIncomingMessage <= p_stChannel->ulBytesInReadBuffer)
{
/* copy only the bytes needed to complete the message */
ulBytesToCopy = p_stChannel->ulBytesToCompleteIncomingMessage;
/* we can give the message to the user */
*ppData = p_stChannel->pCurrentReceivedMessage;
}
else
/* else simply copy everything we got */
ulBytesToCopy = p_stChannel->ulBytesInReadBuffer;
/* copy in the message the bytes in the instant buffer that belong to it */
g_pfn_vNetMemcpy(
p_stChannel->pCurrentMessageIncomingPoint,
p_stChannel->pCurrentReceivingBuffer,
ulBytesToCopy
);
/* there are that many bytes less in the incoming buffer */
p_stChannel->ulBytesInReadBuffer -= ulBytesToCopy;
/* If p_stChannel->ulBytesInReadBuffer > 0, it means that a new message is
following the current one */
if(p_stChannel->ulBytesInReadBuffer > 0)
{/* So move them to the beginning of the incoming buffer */
memmove( /* and not memcpy */
p_stChannel->pCurrentReceivingBuffer,
p_stChannel->pCurrentReceivingBuffer + ulBytesToCopy,
p_stChannel->ulBytesInReadBuffer
);
}
/* if we have completed the message */
if (*ppData)
{
/*
* unreference the message block (its address is passed to the caller
* in the *ppData argument)
*/
p_stChannel->pCurrentReceivedMessage
= p_stChannel->pCurrentMessageIncomingPoint = C_pNull;
p_stChannel->ulBytesToCompleteIncomingMessage = 0;
/* resume reading (i.e. nothing to do, with the threaded version) */
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Msg Received @%lu: %d (%d)",
GetTickCount(), (int)(((tdstNetMessage*)(*ppData))->eMessageType),
(int)(((tdstNetMessage*)(*ppData))->uwMessageSizeInBytes));
#endif
return NetLib_E_es_NoError;/*eL0PCWin95SerialHandleMsg(ppData,*p_uwChannel);*/
}
else
/* we did not complete the message */
{
/* there are that many bytes less to complete the message */
p_stChannel->ulBytesToCompleteIncomingMessage -= ulBytesToCopy;
p_stChannel->pCurrentMessageIncomingPoint += ulBytesToCopy;
eErrorReturned = NetLib_E_es_NoFullMessage;
}
/* resume reading (i.e. nothing to do, with the threaded version) */
/* no error, the message address is in *ppData */
return eErrorReturned;
}
else
/* no new message is being separately stored yet */
{
/* try to read a correct message header */
/* if at least the size in bytes of one message header is in the buffer */
if (p_stChannel->ulBytesInReadBuffer<sizeof(tdstNetMessage)) {
/* not enough bytes to make a buffer : Resume reading (i.e. nothing to do, with the threaded version)*/
return NetLib_E_es_NoFullMessage;
}
p_stNewMsg = (tdstNetMessage *)(p_stChannel->pCurrentReceivingBuffer);
if (p_stNewMsg->uxHeadBigEndian!=NetLib_ucGetLittleBigEndian())
NetLib_eSwapLittleBigEndianMsgHeader(p_stNewMsg);
if( (M_uwCheckSumSlot(p_stNewMsg) != M_uwProcessCheckSum(p_stNewMsg)) ||
(p_stNewMsg->eMessageType > E_Net_mt_LastSysMsg) ||
(p_stNewMsg->eMessageType <= E_Net_mt_InvalidMessage) ) {
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial ,"msg incorrect");
#ifdef NETLIB_LEVEL0COM_TRACE_FULL
vDebugSDump(Net_C_Debug_Serial ,"msg recu:", p_stNewMsg, sizeof(tdstNetMessage));
#endif /* NETLIB_LEVEL0COM_TRACE_FULL */
#endif /* NET_USE_DEBUG */
}
/* we have found a correct header */
p_stChannel->ulBytesToCompleteIncomingMessage = ulTotalSizeOfMessage
= sizeof(tdstNetMessage)
+ p_stNewMsg->uwMessageSizeInBytes;
/* allocate a buffer to store the full message */
p_stChannel->pCurrentReceivedMessage = pMalloc(ulTotalSizeOfMessage);
if(!p_stChannel->pCurrentReceivedMessage)
p_stChannel->pCurrentReceivedMessage = C_pNull;
/* if the message is already completely received */
if (ulTotalSizeOfMessage <= p_stChannel->ulBytesInReadBuffer)
/* tell its address */
*ppData = p_stChannel->pCurrentReceivedMessage;
else
/* prepare to copy what we have received for now in the buffer */
ulTotalSizeOfMessage = p_stChannel->ulBytesInReadBuffer;
/* copy in the message the bytes in the instant buffer that belong to it */
if(p_stChannel->pCurrentReceivedMessage)
g_pfn_vNetMemcpy(
p_stChannel->pCurrentReceivedMessage,
p_stChannel->pCurrentReceivingBuffer,
ulTotalSizeOfMessage
);
/* there are that many bytes less to complete this message */
p_stChannel->ulBytesToCompleteIncomingMessage -= ulTotalSizeOfMessage;
/* compute the remaining number of unprocessed bytes in the buffer */
p_stChannel->ulBytesInReadBuffer -= ulTotalSizeOfMessage;
/* move the remaining bytes to the beginning of the buffer */
if (p_stChannel->ulBytesInReadBuffer)
memmove( /* and not memcpy */
p_stChannel->pCurrentReceivingBuffer,
p_stChannel->pCurrentReceivingBuffer + ulTotalSizeOfMessage,
p_stChannel->ulBytesInReadBuffer
);
/* if the message is complete */
if (*ppData)
{
/* mark the message copy as propagated to the upper level */
p_stChannel->pCurrentMessageIncomingPoint
= p_stChannel->pCurrentReceivedMessage = C_pNull;
/* resume reading (i.e. nothing to do, with the threaded version)*/
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Msg Received @%lu: %d (%d)",
GetTickCount(), (int)(((tdstNetMessage*)(*ppData))->eMessageType),
(int)(((tdstNetMessage*)(*ppData))->uwMessageSizeInBytes));
#endif
return NetLib_E_es_NoError;/*eL0PCWin95SerialHandleMsg(ppData,*p_uwChannel);*/
}
else
{
/* further incoming bytes for the current message will be stored there */
p_stChannel->pCurrentMessageIncomingPoint
= p_stChannel->pCurrentReceivedMessage + ulTotalSizeOfMessage;
eErrorReturned = NetLib_E_es_NoFullMessage;
}
/* resume reading (i.e. nothing to do, with the threaded version) */
/* no error, the message address is in *ppData */
return eErrorReturned;
}
}
/*****************************************************************************
*
* Description: eL0PCWin95SerialSendData
*
* buffer the data in the outgoing buffer.
*
*****************************************************************************
*
* Input: uwChannel, channel to send the message into.
* pData, pointer on the block to send
*
* Output: an error condition.
*
*****************************************************************************
* Creation Date: July 20, 1996 Author: Christophe Roguet
*****************************************************************************
*
* Modification log:
*
* Date: Author:
* 31/11/96 Christophe Roguet
* added a limit on the quantity of data being sent asynchronously, so as not to bufferize too much
* 04/02/97 Christophe Roguet
* removed the start mark stuff, no longer needed thanks to the work of the thread
****************************************************************************/
NetLib_tdeErrorStatus eL0PCWin95SerialSendData(tduwNetChannel uwChannel, tdpPointer pData)
{
tdstL0PCWin95SerialChannel *p_stChannel;
unsigned long ulDataSize;
int iErrorCode;
/* if the specified channel is valid */
if (uwChannel >= C_uw_Net_L0PCWin95Serial_PortNumber)
/* the channel does not exist in our database -> error!! */
return NetLib_E_es_InvalidChannel;
p_stChannel = &gs_a_stL0PCWin95SerialChannels[uwChannel];
/* if the slot is properly initialized */
if (!p_stChannel->ubf1IsSlotInUse)
/* the slot is not initialized for use -> error!! */
return NetLib_E_es_ChannelUninitialized;
/* if there is a new message to send, try to fulfill the request */
if(pData) {
ulDataSize=sizeof(tdstNetMessage) + ((tdstNetMessage *)pData)->uwMessageSizeInBytes;
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial, "SendData: DataSize:%ld, MaxSendSize:%ld ",
ulDataSize, ulMaxSendSize(uwChannel));
#endif
if((iErrorCode=iSendMsg(uwChannel, pData, ulDataSize))==eRingFull)
return NetLib_E_es_BufferIsFull; /* the system lack resources to execute the request */
/* the message is being sent */
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial, "Msg Sent @%lu: %d (%d)",
GetTickCount(),
(int)(((tdstNetMessage*)(pData))->eMessageType),
(int)(((tdstNetMessage*)(pData))->uwMessageSizeInBytes));
vDebugFormat(Net_C_Debug_Serial, "send buffer: %d b", BusySpace(&p_stChannel->stSendBuffer));
#ifdef NETLIB_LEVEL0COM_TRACE_FULL
vDebugSDump(Net_C_Debug_Serial, "", pData, ulDataSize);
#endif /* NETLIB_LEVEL0COM_TRACE_FULL */
#endif /* NET_USE_DEBUG */
/* free the message block */
if(iErrorCode!=eRingBigOk)
vFree(pData);
}
p_stChannel->eChannelStatus = E_ts_OK;
return NetLib_E_es_NoError;
}
/*****************************************************************************
*
* Description: eL0PCWin95SerialQueryChannelStatus
*
* returns the current status of the channel
*
*****************************************************************************
*
* Input: uwChannel, channel to query
*
* Output: an error condition.
*
*****************************************************************************
* Creation Date: April 16, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
*
****************************************************************************/
NetLib_tdeErrorStatus eL0PCWin95SerialQueryChannelStatus(tduwNetChannel uwChannel)
{
tdstL0PCWin95SerialChannel *p_stChannel;
/* if the specified channel is valid */
if (uwChannel >= C_uw_Net_L0PCWin95Serial_PortNumber)
/* the channel does not exist in our database -> error!! */
return NetLib_E_es_InvalidChannel;
p_stChannel = &gs_a_stL0PCWin95SerialChannels[uwChannel];
/* if the slot is properly initialized */
if (!p_stChannel->ubf1IsSlotInUse)
/* the slot is not initialized for use -> error!! */
return NetLib_E_es_ChannelUninitialized;
if(p_stChannel->eBaudStatus==E_Net_L0SerialBaud_Set)
return NetLib_E_es_EmissionInProgress;
/* return the internal error status */
switch(p_stChannel->eChannelStatus)
{
case E_ts_OK:
return NetLib_E_es_NoError;
case E_ts_EmissionInProgress :
/* Check if it is still busy or not :*/
if(eL0PCWin95SerialSendData(uwChannel,C_pNull)==NetLib_E_es_NoError)
{
p_stChannel->eChannelStatus = E_ts_OK;
return NetLib_E_es_NoError;
}
else
return NetLib_E_es_EmissionInProgress;
default :
return NetLib_E_es_UnknownError;
}
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : void eL0PCWin95SerialNetEngine(void)
The level 0 NetEngine function
////////////////////////////////////////////////////////////////////////////////
Input :
None
////////////////////////////////////////////////////////////////////////////////
Output :
NetLib_E_es_NoError
An tdeErrorStatus if an error occured
////////////////////////////////////////////////////////////////////////////////
Creation date : April 23, 96
Author : Albert Pais
Modification log:
Date: Author: Christophe Roguet
rewritten for the thread system
////////////////////////////////////////////////////////////////////////////////
*/
void vL0PCWin95SerialNetEngine(void)
{
/* threaded version : nothing to do */
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialAddPort
Initialise a serial port
////////////////////////////////////////////////////////////////////////////////
Input :
szPortName : "COMx" for the serial port x
ulBaudRate : the baude rate
////////////////////////////////////////////////////////////////////////////////
Output :
NetLib_E_es_NoError
An tdeErrorStatus if an error occured
////////////////////////////////////////////////////////////////////////////////
Creation date : May 3, 96
Author : Albert Pais
Comment : part of code from previous function vLevel0SetupWin95PCSerialInterface
////////////////////////////////////////////////////////////////////////////////
A 0 value for the baud rate makes the port invalid. That is to say, if you don't
want to use the port COM 1 for example, call this function with the argument
"COM1" for szPortName and 0 for ulBaudRate
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus _NET_CALLING_CONV_ eL0PCWin95SerialAddPort(char *szPortName)
{
tduwNetChannel uwChannelToInit;
tdstL0PCWin95SerialChannel *pstChannel;
/* handle to the device file */
HANDLE hCom;
/* For communication properties*/
COMMPROP stComProp;
COMMTIMEOUTS stCommTimeouts;
long lErrorCode;
int iNotOk; /* flag: has anything gone wrong before ?*/
NetLib_tdeErrorStatus eErrorCode; /* return value */
uwChannelToInit = (tduwNetChannel)(szPortName[3] - '1');
pstChannel=&gs_a_stL0PCWin95SerialChannels[uwChannelToInit];
/* any failure will cause the channel to be marked as unavailable */
pstChannel->ubf1IsSlotInUse = 0;
if(gs_a_stL0PCWin95SerialChannels[uwChannelToInit].hCom == INVALID_HANDLE_VALUE)
{
/* open the serial channel */
hCom = CreateFile(
szPortName,
GENERIC_READ |GENERIC_WRITE,
0, /* exclusive access */
NULL, /* no security attrs */
OPEN_EXISTING,
/*FILE_ATTRIBUTE_NORMAL*/FILE_FLAG_OVERLAPPED,
NULL
);
pstChannel->hCom = hCom;
}
else
hCom = pstChannel->hCom;
/* The file could not be opened (may be the com is already opened by some one else */
if (hCom == INVALID_HANDLE_VALUE)
return NetLib_E_es_SerialFileCreationFailure;
if(!SetupComm (hCom,4*sizeof(tdstPacket),2*sizeof(tdstPacket)))
{
lErrorCode = GetLastError();
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"SetupComm Error: %lu",lErrorCode);
#endif
}
stCommTimeouts.ReadIntervalTimeout=0;
stCommTimeouts.ReadTotalTimeoutConstant=50;
stCommTimeouts.ReadTotalTimeoutMultiplier=0;
stCommTimeouts.WriteTotalTimeoutConstant=MAXDWORD;
stCommTimeouts.WriteTotalTimeoutMultiplier=0;
if(!SetCommTimeouts(hCom,&stCommTimeouts))
{
lErrorCode = GetLastError();
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Setcommtimeout() Error: %lu",lErrorCode);
#endif
}
/* this is a channel usable to send broadcast and private messages */
pstChannel->ubf1IsBroadcast = 1;
/* this a channel for the serial port layer */
pstChannel->ubf1IsSlotForModem = 0;
/* Getting the max baud rate :*/
if(GetCommProperties(hCom,&stComProp))
{
if(stComProp.dwMaxBaud&&BAUD_USER)
{
/* search the max baud rate available :*/
if(stComProp.dwSettableBaud&BAUD_110)
pstChannel->ulMaxBaudRate = CBR_110;
if(stComProp.dwSettableBaud&BAUD_134_5)
pstChannel->ulMaxBaudRate = CBR_110;
if(stComProp.dwSettableBaud&BAUD_150)
pstChannel->ulMaxBaudRate = CBR_110;
if(stComProp.dwSettableBaud&BAUD_300)
pstChannel->ulMaxBaudRate = CBR_300;
if(stComProp.dwSettableBaud&BAUD_600)
pstChannel->ulMaxBaudRate = CBR_600;
if(stComProp.dwSettableBaud&BAUD_1200)
pstChannel->ulMaxBaudRate = CBR_1200;
if(stComProp.dwSettableBaud&BAUD_1800)
pstChannel->ulMaxBaudRate = CBR_1200;
if(stComProp.dwSettableBaud&BAUD_2400)
pstChannel->ulMaxBaudRate = CBR_2400;
if(stComProp.dwSettableBaud&BAUD_4800)
pstChannel->ulMaxBaudRate = CBR_4800;
if(stComProp.dwSettableBaud&BAUD_7200)
pstChannel->ulMaxBaudRate = CBR_4800;
if(stComProp.dwSettableBaud&BAUD_9600)
pstChannel->ulMaxBaudRate = CBR_9600;
if(stComProp.dwSettableBaud&BAUD_14400)
pstChannel->ulMaxBaudRate = CBR_14400;
if(stComProp.dwSettableBaud&BAUD_19200)
pstChannel->ulMaxBaudRate = CBR_19200;
if(stComProp.dwSettableBaud&BAUD_38400)
pstChannel->ulMaxBaudRate = CBR_38400;
if(stComProp.dwSettableBaud&BAUD_56K)
pstChannel->ulMaxBaudRate = CBR_56000;
if(stComProp.dwSettableBaud&BAUD_128K)
pstChannel->ulMaxBaudRate = CBR_128000;
if(stComProp.dwSettableBaud&BAUD_115200)
pstChannel->ulMaxBaudRate = CBR_115200;
if(stComProp.dwSettableBaud&BAUD_57600)
pstChannel->ulMaxBaudRate = CBR_57600;
}
else
{
switch(stComProp.dwMaxBaud)
{
case BAUD_110:
pstChannel->ulMaxBaudRate = CBR_110;
break;
case BAUD_134_5:
pstChannel->ulMaxBaudRate = CBR_110;
break;
case BAUD_150:
pstChannel->ulMaxBaudRate = CBR_110;
break;
case BAUD_300:
pstChannel->ulMaxBaudRate = CBR_300;
break;
case BAUD_600:
pstChannel->ulMaxBaudRate = CBR_600;
break;
case BAUD_1200:
pstChannel->ulMaxBaudRate = CBR_1200;
break;
case BAUD_1800:
pstChannel->ulMaxBaudRate = CBR_1200;
break;
case BAUD_2400:
pstChannel->ulMaxBaudRate = CBR_2400;
break;
case BAUD_4800:
pstChannel->ulMaxBaudRate = CBR_4800;
break;
case BAUD_7200:
pstChannel->ulMaxBaudRate = CBR_4800;
break;
case BAUD_9600:
pstChannel->ulMaxBaudRate = CBR_9600;
break;
case BAUD_14400:
pstChannel->ulMaxBaudRate = CBR_14400;
break;
case BAUD_19200:
pstChannel->ulMaxBaudRate = CBR_19200;
break;
case BAUD_38400:
pstChannel->ulMaxBaudRate = CBR_38400;
break;
case BAUD_56K:
pstChannel->ulMaxBaudRate = CBR_56000;
break;
case BAUD_57600:
pstChannel->ulMaxBaudRate = CBR_57600;
break;
case BAUD_115200:
pstChannel->ulMaxBaudRate = CBR_115200;
break;
case BAUD_128K:
pstChannel->ulMaxBaudRate = CBR_128000;
break;
default :
pstChannel->ulMaxBaudRate = CBR_9600;
break;
}
}
}
else
{
CloseHandle(pstChannel->hCom);
pstChannel->hCom = INVALID_HANDLE_VALUE;
return NetLib_E_es_SerialInitFailure;
}
/* set baud rate for the device */
if(eL0PCWin95SerialResetChannel(uwChannelToInit)!=NetLib_E_es_NoError)
{
/* close the handle */
CloseHandle(pstChannel->hCom);
pstChannel->hCom = INVALID_HANDLE_VALUE;
/* go to next device in case of failure */
return NetLib_E_es_SerialInitFailure;
}
/* purge transmission channel from any extraneous lingering data */
if (!PurgeComm(hCom, PURGE_RXCLEAR | PURGE_TXCLEAR))
{
/* close the handle */
CloseHandle(pstChannel->hCom);
pstChannel->hCom = INVALID_HANDLE_VALUE;
return NetLib_E_es_SerialInitFailure;
}
iNotOk=0;
/* initialize the low level emission/reception buffers */
vInitWindow(&pstChannel->stSendWindow, LINK_WINDOW, LINK_TIMEOUT(gs_ulL0PCWin95SerialBaudRate));
vInitWindow(&pstChannel->stRecvWindow, LINK_WINDOW, 0);
pstChannel->ucSeqn=0;
pstChannel->ulReadPos=0;
vInitRingBuffer(&pstChannel->stSendBuffer);
vInitLinkBuffer(&pstChannel->stRecvBuffer, LINK_LINKNUMBER);
pstChannel->hBufferEmpty=CreateEvent(NULL, FALSE, TRUE, NULL);
pstChannel->hSlotsEmpty=CreateEvent(NULL, FALSE, TRUE, NULL);
InitializeCriticalSection(&pstChannel->stSendBufferAccess);
InitializeCriticalSection(&pstChannel->stRecvBufferAccess);
/* if we arrived here, the channel is ready for use */
pstChannel->ubf1IsSlotInUse = 1;
/* no operation in progress yet */
pstChannel->ubf1ReadInProgress
= pstChannel->ubf1WriteInProgress = 0;
/* no byte received or sent in any I/O operation yet */
pstChannel->ulBytesInReadBuffer = 0;
/* allocate buffer for reception */
pstChannel->pCurrentReceivingBuffer = pMalloc(C_uwMaxAsyncLength);
if(pstChannel->pCurrentReceivingBuffer!=C_pNull)
{
pstChannel->pCurrentReceivedMessage=C_pNull;
pstChannel->pCurrentMessageIncomingPoint=C_pNull;
pstChannel->ulBytesToCompleteIncomingMessage=0L;
/* register with the thread controller */
vAddThreadClient(uwChannelToInit);
/* start the ball rolling: signal the read event */
if(SetEvent(pstChannel->stOverlappedRead.hEvent)==TRUE) {
/* the channel is working properly */
pstChannel->eChannelStatus = E_ts_OK;
/* the channel is 'connected' */
pstChannel->ubf1IsSlotConnected = 1;
gs_bL0PCWin95SerialInitState = gs_bL0PCWin95SerialInitState|(char)0x04;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_SThread, "sortie correcte AddPort(%d)", pstChannel-gs_a_stL0PCWin95SerialChannels);
#endif /* NET_USE_DEBUG */
eErrorCode=NetLib_E_es_NoError;
} else {
iNotOk=1;
eErrorCode=NetLib_E_es_SerialInitFailure;
}
if(iNotOk) {
vRemoveThreadClient(uwChannelToInit);
}
} else {
iNotOk=1;
eErrorCode=NetLib_E_es_NotEnoughMemory;
}
if(iNotOk) {
/* close the handle */
CloseHandle(pstChannel->hCom);
pstChannel->hCom = INVALID_HANDLE_VALUE;
DeleteCriticalSection(&pstChannel->stSendBufferAccess);
DeleteCriticalSection(&pstChannel->stRecvBufferAccess);
CloseHandle(pstChannel->hBufferEmpty);
CloseHandle(pstChannel->hSlotsEmpty);
vDeleteLinkBuffer(&pstChannel->stRecvBuffer);
vDeleteWindow(&pstChannel->stRecvWindow);
vDeleteWindow(&pstChannel->stSendWindow);
pstChannel->eChannelStatus = E_ts_ChannelUnitialized; /* ? */
}
return eErrorCode;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : vL0PCWin95SerialCloseChannel
serial-Level 0 closing function
////////////////////////////////////////////////////////////////////////////////
Input :
the channel to close
////////////////////////////////////////////////////////////////////////////////
Output :
none
////////////////////////////////////////////////////////////////////////////////
Creation date : June 17,96
Author : Albert Pais
Modification log:
.....
Date: March 21, 97 Author: Christophe Roguet
thread synchronization: deregister from thread controller before releasing resources -> works better
////////////////////////////////////////////////////////////////////////////////
*/
void vL0PCWin95SerialCloseChannel(tduwNetChannel uwChannel)
{
tdstL0PCWin95SerialChannel *p_stChannel;
#ifdef NET_USE_DEBUG
vDebugFormat(Net_C_Debug_Serial, "CloseChannel(%d) ", uwChannel);
#endif /* NET_USE_DEBUG */
/* if the specified channel is valid */
if (uwChannel < C_uw_Net_L0PCWin95Serial_PortNumber)
{
p_stChannel = &gs_a_stL0PCWin95SerialChannels[uwChannel];
/* if the slot is properly initialized */
if(p_stChannel->ubf1IsSlotInUse && p_stChannel->hCom!=INVALID_HANDLE_VALUE)
{
long lErrorCode;
/* Purge the comms and close the handles :*/
eL0PCWin95SerialFlushChannel(uwChannel);
if(p_stChannel->ubf1IsSlotConnected) {
/* de-register from thread system */
vRemoveThreadClient(uwChannel);
p_stChannel->ubf1IsSlotConnected=0;
/* release the critical sections for buffer access */
DeleteCriticalSection(&p_stChannel->stSendBufferAccess);
DeleteCriticalSection(&p_stChannel->stRecvBufferAccess);
}
if(CloseHandle(p_stChannel->hCom)==FALSE)
lErrorCode=GetLastError();
/* reset the overlapped operations events */
if(ResetEvent(p_stChannel->stOverlappedRead.hEvent)==FALSE)
lErrorCode=GetLastError();
if(ResetEvent(p_stChannel->stOverlappedWrite.hEvent)==FALSE)
lErrorCode=GetLastError();
p_stChannel->hCom = INVALID_HANDLE_VALUE;
p_stChannel->ubf1IsSlotInUse = 0;
if(p_stChannel->pCurrentReceivingBuffer)
{
vFree((tdpPointer)p_stChannel->pCurrentReceivingBuffer);
p_stChannel->pCurrentReceivingBuffer = C_pNull;
}
/* free the send and receive slot window */
vDeleteWindow(&p_stChannel->stSendWindow);
vDeleteWindow(&p_stChannel->stRecvWindow);
vDeleteLinkBuffer(&p_stChannel->stRecvBuffer);
CloseHandle(p_stChannel->hBufferEmpty);
CloseHandle(p_stChannel->hSlotsEmpty);
}
}
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : vL0PCWin95SerialCloseProtocol(void)
serial-Level 0 closing function
////////////////////////////////////////////////////////////////////////////////
Input :
none
////////////////////////////////////////////////////////////////////////////////
Output :
none
////////////////////////////////////////////////////////////////////////////////
Creation date : May 6,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
void vL0PCWin95SerialCloseProtocol(void)
{
unsigned short c_uwCount;
/* close all channels */
for(c_uwCount = 0;c_uwCount <C_uw_Net_L0PCWin95Serial_PortNumber;c_uwCount++)
{
if(!gs_a_stL0PCWin95SerialChannels[c_uwCount].ubf1IsSlotForModem)
vL0PCWin95SerialCloseChannel(c_uwCount);
}
/* release the critical sections used to synchronize channel access, */
/* as well as the communication overlapped operation structures */
for(c_uwCount = 0;c_uwCount <C_uw_Net_L0PCWin95Serial_PortNumber;c_uwCount++)
{
if(!gs_a_stL0PCWin95SerialChannels[c_uwCount].ubf1IsSlotForModem) {
DeleteCriticalSection(&gs_a_stL0PCWin95SerialChannels[c_uwCount].stChannelAccess);
CloseHandle(gs_a_stL0PCWin95SerialChannels[c_uwCount].stOverlappedRead.hEvent);
CloseHandle(gs_a_stL0PCWin95SerialChannels[c_uwCount].stOverlappedWrite.hEvent);
gs_a_stL0PCWin95SerialChannels[c_uwCount].stOverlappedRead.hEvent=INVALID_HANDLE_VALUE;
gs_a_stL0PCWin95SerialChannels[c_uwCount].stOverlappedWrite.hEvent=INVALID_HANDLE_VALUE;
}
}
vLevel1RemoveProtocol(E_Net_pr_Windows95SerialProtocol);
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"\n\nBye-bye\n\n");
#endif
}
/*****************************************************************************
*
* Description: vL0PCWin95SerialOpenProtocol
*
* initialize the specified interface structure with the correct function
* pointers to enable a protocol-independant data transmission process.
*
*****************************************************************************
*
* Input: p_stProtocolInterface, pointer to the interface structure
*
* Output: none
*
*****************************************************************************
* Creation Date: April 15, 1996 Author: Benoit GERMAIN
*****************************************************************************
*
* Modification log:
*
* Date: Author:
*
****************************************************************************/
void _NET_CALLING_CONV_ vL0PCWin95SerialOpenProtocol(unsigned long ulRate)
{
tduwNetChannel uwChannelToInit;
tdstL0PCWin95SerialChannel *pstChannel;
tdstNetProtocolInterface *p_stProtocolInterface;
#ifdef NET_USE_DEBUG
/*
vDebugOpen(Net_C_Debug_Serial);
vDebugOpen(Net_C_Debug_SLinks);
vDebugOpen(Net_C_Debug_SBlocks);
vDebugOpen(Net_C_Debug_SThread);
*/
vDebugClear(Net_C_Debug_Serial);
vDebugClear(Net_C_Debug_SLinks);
vDebugClear(Net_C_Debug_SBlocks);
vDebugClear(Net_C_Debug_SThread);
vDebugFormat(Net_C_Debug_Serial,"Netlib - Level 0 - Com WIN95 : Log file \n\n");
#endif
gs_bL0PCWin95SerialInitState = 0x00;
gs_ulL0PCWin95SerialBaudRate=ulRate;
p_stProtocolInterface=pstLevel1AddProtocol();
/* logical identification of the protocol */
p_stProtocolInterface->eProtocol = E_Net_pr_Windows95SerialProtocol;
/* setup the function pointers */
p_stProtocolInterface->fn_uwStartChannelScan = uwL0PCWin95SerialStartChannelScan;
p_stProtocolInterface->fn_uwStartBroadcastChannelScan= uwL0PCWin95SerialStartBroadcastChannelScan;
p_stProtocolInterface->fn_uwNextChannel= uwL0PCWin95SerialNextChannel;
p_stProtocolInterface->fn_uwNextBroadcastChannel= uwL0PCWin95SerialNextBroadcastChannel;
p_stProtocolInterface->fn_eReadData= eL0PCWin95SerialReadData;
p_stProtocolInterface->fn_eSendData= eL0PCWin95SerialSendData;
p_stProtocolInterface->fn_eQueryChannelStatus= eL0PCWin95SerialQueryChannelStatus;
p_stProtocolInterface->fn_vLevel0NetEngine = vL0PCWin95SerialNetEngine;
p_stProtocolInterface->fn_vCloseChannel = (tdfn_vCloseChannel)C_pNull;
p_stProtocolInterface->fn_vLevel0CloseProtocol = vL0PCWin95SerialCloseProtocol;
p_stProtocolInterface->eIsInternet = 0;
/* process all potentially available channels */
for (uwChannelToInit = 0; uwChannelToInit < C_uw_Net_L0PCWin95Serial_PortNumber; uwChannelToInit ++)
{
pstChannel=&gs_a_stL0PCWin95SerialChannels[uwChannelToInit];
pstChannel->hCom = INVALID_HANDLE_VALUE;
pstChannel->ubf1IsSlotInUse = 0;
pstChannel->eBaudStatus = E_Net_L0SerialBaud_Invalid;
/* we need to initialize the overlap structure events */
/* because they are used for synchronisation even if */
/* the corresponding channel is not open (well, this isn't true any more ... could be changed then) */
memset(&pstChannel->stOverlappedRead, 0, sizeof(pstChannel->stOverlappedRead));
memset(&pstChannel->stOverlappedWrite, 0, sizeof(pstChannel->stOverlappedWrite));
pstChannel->stOverlappedRead.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
pstChannel->stOverlappedWrite.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
/* initialize the mutual exclusion object for channel access */
InitializeCriticalSection(&pstChannel->stChannelAccess);
}
vInitThreadController();
lSerialChannelsOnceInitialized=1;
gs_bL0PCWin95SerialInitState = gs_bL0PCWin95SerialInitState |(char)0x01;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : vL0PCWin95SerialClosePort
Close a serial port
////////////////////////////////////////////////////////////////////////////////
Input :
szPortName : "COMx" for the com port x
////////////////////////////////////////////////////////////////////////////////
Output :
None
////////////////////////////////////////////////////////////////////////////////
Creation date : June 17,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
void _NET_CALLING_CONV_ vL0PCWin95SerialClosePort(char *szPortName)
{
tduwNetChannel uwChannel;
uwChannel = (tduwNetChannel)(szPortName[3] - '1');
if(uwChannel < C_uw_Net_L0PCWin95Serial_PortNumber)
vL0PCWin95SerialCloseChannel(uwChannel);
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialIsPortAModem
returns true if a com port is linked to a modem
////////////////////////////////////////////////////////////////////////////////
Input :
hPort : handle to the com port to test
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : 20/02/97
Author : Christophe Roguet
Modification log:
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus _NET_CALLING_CONV_ eL0PCWin95SerialIsPortAModem(HANDLE hCom)
{
DCB stDcb;
COMMTIMEOUTS stCommTimeouts;
OVERLAPPED stOverlap;
char acReadBuffer[10];
unsigned long ulWrittenBytes, ulReadBytes;
NetLib_tdeErrorStatus eReturnValue;
if(hCom!=INVALID_HANDLE_VALUE) /* the COM port is free to use */
{
/* configure the port */
memset(&stDcb, 0, sizeof(DCB));
GetCommState(hCom, &stDcb);
stDcb.BaudRate = CBR_19200;
/* those are the universal settings for nowadays modems. */
stDcb.fBinary = TRUE; /* not text */
stDcb.ByteSize = 8; /* 8 bit chars */
stDcb.fParity = FALSE; /* no parity checking */
stDcb.Parity = NOPARITY; /* no parity checking (redundant ?) */
stDcb.StopBits = ONESTOPBIT;
stDcb.fErrorChar = FALSE; /* do not replace bad chars */
stDcb.fAbortOnError = FALSE;
/* flow control */
stDcb.fOutxCtsFlow = TRUE; /* hardware flow control */
stDcb.fOutxDsrFlow = FALSE; /* hardware flow control */
stDcb.fDtrControl = DTR_CONTROL_ENABLE; /* hardware flow control */
stDcb.fDsrSensitivity = FALSE; /* hardware flow control */
stDcb.fRtsControl = RTS_CONTROL_HANDSHAKE; /* hardware flow control */
stDcb.fOutX = FALSE;
stDcb.fInX = FALSE;
stDcb.fNull = FALSE;
SetCommState(hCom, &stDcb);
stCommTimeouts.ReadIntervalTimeout=0;
stCommTimeouts.ReadTotalTimeoutConstant=100;
stCommTimeouts.ReadTotalTimeoutMultiplier=0;
stCommTimeouts.WriteTotalTimeoutConstant=100;
stCommTimeouts.WriteTotalTimeoutMultiplier=0;
SetCommTimeouts(hCom, &stCommTimeouts);
stOverlap.hEvent=CreateEvent(NULL, TRUE, FALSE, NULL);
/* send ATI and read the response */
WriteFile(hCom, "ATI0\n", 4, &ulWrittenBytes, &stOverlap);
GetOverlappedResult(hCom, &stOverlap, &ulWrittenBytes, TRUE);
ReadFile(hCom, acReadBuffer, sizeof(acReadBuffer), &ulReadBytes, &stOverlap);
GetOverlappedResult(hCom, &stOverlap, &ulReadBytes, TRUE);
if(ulReadBytes>0 && !strncmp(acReadBuffer, "ATI0", 3))
eReturnValue=NetLib_E_es_True;
else eReturnValue = NetLib_E_es_False;
CloseHandle(stOverlap.hEvent);
}
return eReturnValue;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialIsPortAvailable
returns if a port is avaible or not
////////////////////////////////////////////////////////////////////////////////
Input :
szPortName : "COMx" for the com port x
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : May 6,96
Author : Albert Pais
Modification log:
Date: Author: Christophe Roguet
adapted to thread system
Date: 20/02/97 Author: Christophe Roguet
attempt to detect the presence of a modem on the port
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus _NET_CALLING_CONV_ eL0PCWin95SerialIsPortAvailable(char *szPortName)
{
tduwNetChannel uwChannel;
HANDLE hCom;
NetLib_tdeErrorStatus eReturnValue;
uwChannel = (tduwNetChannel)(szPortName[3] - '1');
if(uwChannel >= C_uw_Net_L0PCWin95Serial_PortNumber)
return NetLib_E_es_InvalidChannel;
eReturnValue=NetLib_E_es_False;
/* try to open the corresponding COM port */
hCom = CreateFile(
szPortName,
GENERIC_READ |GENERIC_WRITE,
0, /* exclusive access */
NULL, /* no security attrs */
OPEN_EXISTING,
FILE_FLAG_OVERLAPPED,
NULL
);
if(hCom!=INVALID_HANDLE_VALUE) { /* the COM port is free to use */
/* if(eL0PCWin95SerialIsPortAModem(hCom)==NetLib_E_es_False)*/
eReturnValue=NetLib_E_es_True;
CloseHandle(hCom);
}
return eReturnValue;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialIsProtocolSet
Returns wether the protocol has been set or not
////////////////////////////////////////////////////////////////////////////////
Input :
None
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : June 18,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus _NET_CALLING_CONV_ eL0PCWin95SerialIsProtocolSet(void)
{
if(!(gs_bL0PCWin95SerialInitState&0x01))
return NetLib_E_es_ProtocolNotInitialized;
if(!(gs_bL0PCWin95SerialInitState&0x04))
return NetLib_E_es_NoPortSelected;
return NetLib_E_es_True;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialIsProtocolAvailable
Returns wether the protocol can be used or not
////////////////////////////////////////////////////////////////////////////////
Input :
None
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : June 26,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus _NET_CALLING_CONV_ eL0PCWin95SerialIsProtocolAvailable(void)
{
NetLib_tdeErrorStatus eErrorReturned;
unsigned short uwCount;
char *szPortName = "COMx";
uwCount = 0;
eErrorReturned = NetLib_E_es_False;
while
(
(uwCount <C_uw_Net_L0PCWin95Serial_PortNumber)&&
(eErrorReturned != NetLib_E_es_True)
)
{
szPortName[3] = (char)('1'+uwCount);
eErrorReturned = eL0PCWin95SerialIsPortAvailable(szPortName);
uwCount++;
}
return eErrorReturned;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialIsPortOpened
Returns wether the port is opened or not
////////////////////////////////////////////////////////////////////////////////
Input :
A port
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : June 27,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus _NET_CALLING_CONV_ eL0PCWin95SerialIsPortOpened(char*szPortName)
{
tduwNetChannel uwChannel;
uwChannel = (tduwNetChannel)(szPortName[3] - '1');
if(uwChannel >= C_uw_Net_L0PCWin95Serial_PortNumber)
return NetLib_E_es_InvalidPortNumber;
if(gs_a_stL0PCWin95SerialChannels[uwChannel].hCom == INVALID_HANDLE_VALUE)
return NetLib_E_es_False;
if(!gs_a_stL0PCWin95SerialChannels[uwChannel].ubf1IsSlotInUse)
return NetLib_E_es_False;
return NetLib_E_es_True;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialPurgeChannel
Purge the channel specified in parameter
////////////////////////////////////////////////////////////////////////////////
Input :
A channel
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : July 1st,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus eL0PCWin95SerialPurgeChannel(tduwNetChannel uwChannel)
{
tdstL0PCWin95SerialChannel *p_stChannel;
if(uwChannel>=C_uw_Net_L0PCWin95Serial_PortNumber)
/* the channel does not exist in our database -> error!! */
return NetLib_E_es_InvalidChannel;
p_stChannel = &gs_a_stL0PCWin95SerialChannels[uwChannel];
/* stop emission and reception, and clear buffers */
/* NOT WRITTEN YET */
return NetLib_E_es_NoError;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialResetChannel
Reset the baud rate of the channel to the default value
////////////////////////////////////////////////////////////////////////////////
Input :
A channel
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : July 2nd,96
Author : Albert Pais
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus eL0PCWin95SerialResetChannel(tduwNetChannel uwChannel)
{
tdstL0PCWin95SerialChannel *p_stChannel;
if(uwChannel>=C_uw_Net_L0PCWin95Serial_PortNumber)
/* the channel does not exist in our database -> error!! */
return NetLib_E_es_InvalidChannel;
p_stChannel = &gs_a_stL0PCWin95SerialChannels[uwChannel];
memset(&p_stChannel->stChannelStatus, 0, sizeof(DCB));
/*p_stChannel->stChannelStatus->dwSize=sizeof(DCB);*/
/* Reset the default baud rate value :*/
if
(GetCommState
(
p_stChannel->hCom,
&(p_stChannel->stChannelStatus)
)
)
{
p_stChannel->stChannelStatus.BaudRate = gs_ulL0PCWin95SerialBaudRate;
/* those are the universal settings for nowadays modems. use it for the serial link */
p_stChannel->stChannelStatus.fBinary = TRUE; /* not text */
p_stChannel->stChannelStatus.ByteSize = 8; /* 8 bit chars */
p_stChannel->stChannelStatus.fParity = FALSE; /* no parity checking */
p_stChannel->stChannelStatus.Parity = NOPARITY; /* no parity checking (redundant ?) */
p_stChannel->stChannelStatus.StopBits = ONESTOPBIT;
p_stChannel->stChannelStatus.fErrorChar = FALSE; /* do not replace bad chars */
p_stChannel->stChannelStatus.fAbortOnError = TRUE;
/* flow control. the link cable has to be a null modem cable */
p_stChannel->stChannelStatus.fOutxCtsFlow = TRUE; /* hardware flow control */
p_stChannel->stChannelStatus.fOutxDsrFlow = FALSE; /* hardware flow control */
p_stChannel->stChannelStatus.fDtrControl = DTR_CONTROL_ENABLE; /* hardware flow control */
p_stChannel->stChannelStatus.fDsrSensitivity = FALSE; /* hardware flow control */
p_stChannel->stChannelStatus.fRtsControl = RTS_CONTROL_HANDSHAKE; /* hardware flow control */
p_stChannel->stChannelStatus.fOutX = FALSE;
p_stChannel->stChannelStatus.fInX = FALSE;
p_stChannel->stChannelStatus.fNull = FALSE;
if
(SetCommState
(
p_stChannel->hCom,
&(p_stChannel->stChannelStatus)
)
)
{
/* that's ok the baud rates should be the same:*/
p_stChannel->eBaudStatus = E_Net_L0SerialBaud_Default;
return NetLib_E_es_NoError;
}
}
p_stChannel->eBaudStatus = E_Net_L0SerialBaud_Invalid;
return NetLib_E_es_UnknownError;
}
/*
////////////////////////////////////////////////////////////////////////////////
Description : eL0PCWin95SerialFlushChannel
flush the sending buffers of the channel specified in parameter
////////////////////////////////////////////////////////////////////////////////
Input :
A channel
////////////////////////////////////////////////////////////////////////////////
Output :
an tdeErrorStatus
////////////////////////////////////////////////////////////////////////////////
Creation date : July 3rd,96
Author : Albert Pais
Modification log:
....
Date: Author:
12/02/97 Christophe Roguet
rewritten for the thread system
////////////////////////////////////////////////////////////////////////////////
*/
NetLib_tdeErrorStatus eL0PCWin95SerialFlushChannel(tduwNetChannel uwChannel)
{
tdstL0PCWin95SerialChannel *p_stChannel;
unsigned long ulLeftToSendBeforeWait, ulLeftToSend;
long lWaitResult;
#ifdef NET_USE_DEBUG
long lErrorCode;
#endif /* NET_USE_DEBUG */
if(uwChannel>=C_uw_Net_L0PCWin95Serial_PortNumber)
/* the channel does not exist in our database -> error!! */
return NetLib_E_es_InvalidChannel;
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Entering Flush ");
#endif
p_stChannel = &gs_a_stL0PCWin95SerialChannels[uwChannel];
EnterCriticalSection(&p_stChannel->stChannelAccess);
if(p_stChannel->ubf1IsSlotInUse) {
if(p_stChannel->ubf1IsSlotConnected) {
/* if the send buffer is not empty, wait for its content to be sent */
if((ulLeftToSend=BusySpace(&p_stChannel->stSendBuffer))>0) {
ResetEvent(p_stChannel->hBufferEmpty);
do {
ulLeftToSendBeforeWait=ulLeftToSend;
LeaveCriticalSection(&p_stChannel->stChannelAccess);
lWaitResult=WaitForSingleObject(p_stChannel->hBufferEmpty, 100);
if(lWaitResult==WAIT_FAILED) {
#if defined(NET_USE_DEBUG)
lErrorCode=GetLastError();
vDebugFormat(Net_C_Debug_Serial,"WaitForSingleObject(): %lu", lErrorCode);
#endif
}
EnterCriticalSection(&p_stChannel->stChannelAccess);
ulLeftToSend=BusySpace(&p_stChannel->stSendBuffer);
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Wait for buffer: %d left before, %d left after, ret val:%lu",
ulLeftToSendBeforeWait, ulLeftToSend, lWaitResult);
#endif
/* repeat while there is data in the send buffer and we see that the send system is not blocked */
} while(lWaitResult!=WAIT_OBJECT_0 && ulLeftToSend<ulLeftToSendBeforeWait);
}
/* the high level buffer is empty : now wait for all send slots to be transmitted ... and acknowledged */
if((ulLeftToSend=iSlotsNotAck(&p_stChannel->stSendWindow))>0) {
ResetEvent(p_stChannel->hSlotsEmpty);
do {
ulLeftToSendBeforeWait=ulLeftToSend;
LeaveCriticalSection(&p_stChannel->stChannelAccess);
lWaitResult=WaitForSingleObject(p_stChannel->hSlotsEmpty, 100);
EnterCriticalSection(&p_stChannel->stChannelAccess);
if(lWaitResult==WAIT_FAILED) {
#if defined(NET_USE_DEBUG)
lErrorCode=GetLastError();
vDebugFormat(Net_C_Debug_Serial,"WaitForSingleObject(): %lu", lErrorCode);
#endif
}
ulLeftToSend=iSlotsNotAck(&p_stChannel->stSendWindow);
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Wait for slots: %d left before, %d left after, ret val:%lu",
ulLeftToSendBeforeWait, ulLeftToSend, lWaitResult);
#endif
/* repeat while there are slots left to send and we see that the send system is not blocked */
} while(lWaitResult!=WAIT_OBJECT_0 && ulLeftToSend<ulLeftToSendBeforeWait);
}
}
}
LeaveCriticalSection(&p_stChannel->stChannelAccess);
#if defined(NET_USE_DEBUG)
vDebugFormat(Net_C_Debug_Serial,"Leaving Flush ");
#endif
return NetLib_E_es_NoError;
}
Reference in New Issue View Git Blame Copy Permalink