netchat.c

一个tcp/ip协议栈,带有PPP、IP、TCP、UDP等协议

/*****************************************************************************
* netchat.c - Communications Dialog (Chat) Code File.
*
* Copyright (c) 1996, 1998 by Global Election Systems Inc.
*
* The authors hereby grant permission to use, copy, modify, distribute,
* and license this software and its documentation for any purpose, provided
* that existing copyright notices are retained in all copies and that this
* notice and the following disclaimer are included verbatim in any 
* distributions. No written agreement, license, or royalty fee is required
* for any of the authorized uses.
*
* THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS *AS IS* AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
* IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
* REVISION HISTORY (please don't use tabs!)
*
*(yyyy-mm-dd)
* 1998-06-16 Guy Lancaster <[e-mail]>, Global Election Systems Inc.
*
* 2001-04-05 Robert Dickenson <[e-mail]>, Cognizant Pty Ltd.
*            Updated for building.
*
******************************************************************************
*/
#include "netconf.h"
#include <string.h>
#include "net.h"
#include "netbuf.h"     // Required by devio.h.
#include "devio.h"
#include "netchat.h"

#include <stdio.h>
#include "netdebug.h"

#pragma warning (push)
#pragma warning (disable: 4018) // signed/unsigned mismatch
////////////////////////////////////////////////////////////////////////////////

/*************************/
/*** LOCAL DEFINITIONS ***/
/*************************/
#define MAXFLUSH 1000           /* Max characters to flush before sendRecv(). */
#define RECVBUFSZ 100           /* Size of the receive buffer. */
#define MAXRESPONSE 10          /* Max response strings that sendRecv() can match. */

/* Pattern matching states. */
#define PMSKIPSOURCE 5
#define PMSKIPPATTERN 4
#define PMMULTIPLYING 3
#define PMTRYNEXT 2
#define PMMATCHING 1
#define PMINITIALIZE 0
#define PMSUCCESS -1
#define PMFAIL -2


/************************/
/*** LOCAL DATA TYPES ***/
/************************/
typedef struct patternContext_s {
    int  st;                    /* The pattern matching status. */
    char *patStr;               /* The pattern string to match. */
    UINT patNdx;                /* Index to the pattern string. */
    UINT sourceNdx;             /* Index to the source string. */
    UINT matchNdx;              /* Index to the source string. */
} PatternContext;


/***********************************/
/*** LOCAL FUNCTION DECLARATIONS ***/
/***********************************/
static PatternContext *copyPattern(PatternContext *srcPat, PatternContext *destPat,
                                      int srcOffset, int matchOffset, int patOffset);
static int tryNextSource(PatternContext *respPat);
static int matchEOL(char *sourceStr, PatternContext *respPat);
static int matchCurrent(char *sourceStr, PatternContext *respPat);
static int patternMatch(char *sourceStr, PatternContext *respPat) ;

static int timedOut;

static void timeMeOut(void *p)
{
	printf("************timeMeOut\n");
	timedOut=1;
}

#define TRACECHAT 0

/***********************************/
/*** PUBLIC FUNCTION DEFINITIONS ***/
/***********************************/
/* Send a string to the modem and wait a limited time for one of a list of
 *  up to MAXRESPONSE possible responses.
 * Returns: >= 0 if successful as the index of the matching response string,
 *      -1 if timed out, or -2 if aborted by user pressing the NO button.
 */
//int sendRecv(int fd, const char *sendStr, UINT timeLimit, UINT respStrQty, ...)
int sendRecv(int fd, const char *sendStr, UINT timeLimit, const char *s_respStrQty, ...)
{
    int  i, st;
    char curChar;
    int finished = FALSE;
    char recvBuf[RECVBUFSZ];            /* The receive buffer and index. */
    UINT recvNdx;
    PatternContext respPat[MAXRESPONSE];    /* Response pattern structures. */
    PatternContext* curRespPat;
    void* arg;
    LONG timeOut = timeLimit * 100;     /* Time limit converted to milliseconds. */
//    va_list ap;
    unsigned long respStrQty=(unsigned long)s_respStrQty;

    if (respStrQty >= MAXRESPONSE) {
	respStrQty = MAXRESPONSE;
    }

    /* Set up for matching the response strings. */
    arg = &respStrQty;
    ((int*)arg)++;      /* Assume that UINT pushed as an int on target machine. */
    if (respStrQty >= MAXRESPONSE) {
        CHATTRACE((LOG_WARNING, TL_CHAT, "sendRecv: WARNING! Ignoring extra response strings"));
        respStrQty = MAXRESPONSE;
    }
#if TRACECHAT > 0
    recvNdx = 0;
#endif
    for (i = 0; i < respStrQty; i++) {
        curRespPat = &respPat[i];
        curRespPat->st = 0; /* Initialize */
        curRespPat->patStr = *((char**)arg)++;
        curRespPat->patNdx = 0;
        curRespPat->sourceNdx = 0;
        curRespPat->matchNdx = 0;
#if TRACECHAT > 0
        sprintf(&recvBuf[recvNdx], " p%d=[%Z]", i, respPat[i].patStr);
        recvNdx = strlen(recvBuf);
        if (recvNdx >= RECVBUFSZ - 32 || recvNdx >= 50) {
            CHATTRACE((LOG_INFO, TL_CHAT, "sendRecv: %s", recvBuf));
            recvNdx = 0;
        }
#endif
    }

	CHATTRACE((LOG_INFO, TL_CHAT, "sendRecv: s=[%s] t=%d q=%d",
                sendStr, timeLimit, respStrQty));

    /* Flush the input buffer up to MAXFLUSH characters. */
    st = 0;
    while ((i = read(fd, recvBuf, RECVBUFSZ - 1)) > 0) {
        st += i;
        if (st >= MAXFLUSH) {
            CHATTRACE((LOG_ERR, TL_CHAT, "sendRecv: Too much garbage from device %d", fd));
            st = -1;
            finished = TRUE;
        } else {
            recvBuf[min(i, RECVBUFSZ - 1)] = '\0';
	    CHATTRACE((LOG_DEBUG, TL_CHAT,"sendRecv: flushed[%d]", i));
        }
    }
    
    /* Send string to device if not null. */
    if (!finished && sendStr != NULL && sendStr[0] != '\0') {
		CHATTRACE((LOG_INFO, TL_CHAT, "sendRecv: sending [%s]", sendStr));
        i = strlen(sendStr);
        if (write(fd, sendStr, i) != i ) {
	    CHATTRACE((LOG_ERR, TL_CHAT, "sendRecv: Error sending [%s] to %d", sendStr, fd));
            st = -1;
            finished = TRUE;
        }
    }

#if TRACECHAT > 0
    if (recvNdx > 0) {
        CHATTRACE((LOG_INFO, TL_CHAT, "sendRecv: %s", recvBuf));
    }
#endif

    /* Wait limited time for response. */
    recvNdx = 0;
    recvBuf[0] = '\0';
    while (!finished) {
#if AVOS /** @todo introduce a callback instead of calling AVOS directly */
        /* Abort if user presses the NO button. */
        if (buttonNoStatus() == NOBUTTON) {
            CHATTRACE((LOG_ERR, TL_CHAT, "sendRecv: User abort!"));
            st = -2;
            finished = TRUE;
        /* Read next character. */
        } else 
#endif /* AVOS */
        if ((i = read(fd, &curChar, 1)) == 1) {
            /* Trap ^C as abort character. */
            if (curChar == '\003') {
                st = -2;
                finished = TRUE;
            } else if (curChar > 0) {
                recvBuf[recvNdx++] = curChar;
                recvBuf[recvNdx] = '\0';
                timeOut--;      /* Assume a character takes at least a millisecond. */
                for (i = 0; i < respStrQty && !finished; i++) {
                    if (patternMatch(recvBuf, &respPat[i]) == 0) {
                        st = i;
                        finished = TRUE;
                    }
                }
            }
        /* Abort if read failed. */
        } else if (i < -1) {
            CHATTRACE((LOG_ERR, TL_CHAT, "sendRecv: Error reading from %d", fd));
            st = -2;        /* Assume user pressed NO button to generate error. */
            finished = TRUE;
        /* Abort if timed out. */
        } else if (timeOut <= 0) {
            CHATTRACE((LOG_DETAIL, TL_CHAT, "sendRecv:abort due to timeout"));
            st = -1;            /* Time out */
            finished = TRUE;
        /* Wait for 100ms but abort if NO button pressed. */
        }
#if AVOS /** @todo introduce a callback instead of calling AVOS directly */
        else if (prompt(NOBUTTON, 100, NULL) == NOBUTTON) {
            CHATTRACE((LOG_ERR, TL_CHAT, "sendRecv: User aborted reading from %d", fd);)
            st = -2;
            finished = TRUE;
        /* Decrement the timer. */
        } 
#endif /* AVOS */
        else
            timeOut -= 100;
    }
    // Trace shows the last 20 bytes received if it'll fit.
#if TRACECHAT > 0
    i = MIN(recvNdx, 20);
    if (i == 0) i = 1;
#endif
    CHATTRACE((LOG_INFO, TL_CHAT, "sendRecv: [%*.*Z] => %d",
               i, LOGMSGLEN - 25, &recvBuf[recvNdx - i], st));
    return st;
}


/**********************************/
/*** LOCAL FUNCTION DEFINITIONS ***/
/**********************************/
/*