netchat.c

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

 *  Copy the source pattern into the destination pattern and add the source, match and
 *  pattern offsets to the corresponding indexes.
 *  Return the destination pattern.
 */
static PatternContext *copyPattern(PatternContext *srcPat, PatternContext *destPat,
                                      int srcOffset, int matchOffset, int patOffset)
{
    destPat->st = srcPat->st;
    destPat->patStr = srcPat->patStr;
    destPat->patNdx = srcPat->patNdx + patOffset;
    destPat->sourceNdx = srcPat->sourceNdx + srcOffset;
    destPat->matchNdx = srcPat->matchNdx + matchOffset;
    return destPat;
}

/*
 *  The pattern has failed from the current source start position so check that
 *  the pattern allows us to try again later in the source.
 */
static int tryNextSource(PatternContext *respPat)
{
    respPat->st = PMMATCHING;
    
    /* If the pattern string begins with a caret, the pattern must match from the start of
        the source string. */
    if (respPat->patStr[0] == '^') {
        /* If we haven't tried without the caret, skip the caret and try again. */
        if (respPat->patNdx == 0 && respPat->sourceNdx == 0) {
            respPat->patNdx = 1;
            respPat->matchNdx = 0;
        /* We've tried once so now we fail. */
        } else {
            respPat->st = PMFAIL;
        }
    /* The match failed from the current start position so advance to the next start
        position and try again. */
    } else {
        respPat->patNdx = 0;
        respPat->sourceNdx++;
        respPat->matchNdx = respPat->sourceNdx;
    }
    return respPat->st;
}

/*
 *  Attempt to match the end-of-line '$' character.
 */
static int matchEOL(char *sourceStr, PatternContext *respPat)
{
    char curSource = sourceStr[respPat->matchNdx];
        
    /* Note: We don't want to advance the source if we're at the end of the string
     *  because we will want to check from the same position the next time a character
     *  is appended.  We ignore a single carriage return character until we're on the
     *  next source character and then determine if it is combined with a line feed
     *  character. */
    if (curSource == '\r') {
        if (respPat->matchNdx > 0 && sourceStr[respPat->matchNdx - 1] == '\r') {
            /* We've matched on a carriage return character and the previous character
             *  is another carriage return character so this end-of-line pattern
             *  matches the previous one.  Keep the default status. */
            ;
        } else if (respPat->patStr[respPat->patNdx + 1] == '\0' &&
                 sourceStr[respPat->matchNdx + 1] == '\0') {
            /* SPECIAL CASE: This is the end of the source and pattern strings so we've
             *  got a match. */
            respPat->st = PMSUCCESS;
        } else {
            /* Otherwise ignore this. */
            respPat->st = PMSKIPSOURCE;
        }
    } else if (curSource == '\n') {
        /* We've matched a line feed character which satisfies the end-of-line pattern.
         *  Keep the default status. */
    } else if (respPat->matchNdx > 0 && sourceStr[respPat->matchNdx - 1] == '\r') {
        /* The previous character is a carriage return that we skipped above so it
         *  matches this end-of-line pattern. */
        /* Note: This also correctly breaks out of a multiplier. */
        respPat->st = PMSKIPPATTERN;
    } else {
        /* We failed to match the end-of-line from the current position so try the next. */
        respPat->st = PMTRYNEXT;
    }

    return respPat->st;
}


/*
 *  Attempt to match the current pattern position with the current source position.
 *  Return the new pattern status.
 */
static int matchCurrent(char *sourceStr, PatternContext *respPat)
{
    int i;
    char curPattern, curSource;
    PatternContext tmpPat;      /* For recursive matching. */

    /* Load the current characters to match. */
    curSource = sourceStr[respPat->matchNdx];
    if (respPat->patNdx > 0 && 
        (respPat->patStr[respPat->patNdx] == '*' || respPat->patStr[respPat->patNdx] == '+')) {
        /* We're matching a multiplier that isn't the first character of a 
         *  pattern so load the previous pattern character and set status for
         *  a multiplier.  Ideally we would just keep the previous pattern in case it wasn't
         *  a single character pattern but we have no way of carrying that between calls. */
        curPattern = respPat->patStr[respPat->patNdx - 1];
        respPat->st = PMMULTIPLYING;
    } else {
        /* Load the new pattern and assume that we're going to match. */
        curPattern = respPat->patStr[respPat->patNdx];
        respPat->st = PMMATCHING;
    }
    
    if (curPattern == '\0') {
        /* We've matched the entire pattern so return success. */
        respPat->st = PMSUCCESS;
    } else if (curSource == '\0') {
        /* We've reached the end of the source buffer without matching the pattern
         *  so return failure. */
        respPat->st = PMFAIL;
    } else if (curPattern == '\\') {
        if (curSource == respPat->patStr[respPat->patNdx + 1]) {
            /* We've matched an escaped special character so skip the escape and 
             *  take the default status. */
            respPat->patNdx++;
        }
        else {
            /* The escaped character failed to match. */
            respPat->st = PMTRYNEXT;
        }
    } else if (respPat->st == PMMULTIPLYING &&
             ((i = matchCurrent(sourceStr, copyPattern(respPat, &tmpPat, 0, 0, 1))) == PMMATCHING ||
              i == PMSUCCESS)) {
        /* We're multiplying this pattern character and the next pattern matches this source
         *  so break out of the multiplier. */
        respPat->st = PMSKIPPATTERN;
    } else if (curPattern == '$') {
        /* We're matching the end-of-line pattern. */
        respPat->st = matchEOL(sourceStr, respPat);
    } else if (curSource == curPattern) {
        /* We have a literal match so keep the default status. */
    } else if (respPat->patStr[respPat->patNdx + 1] == '*') {
        /* We have failed to match a non-wild pattern. The next pattern character is the
         *  '*' multiplier so check for a zero length match. */
        if (curPattern != '.' || 
            ((i = matchCurrent(sourceStr, copyPattern(respPat, &tmpPat, 0, 0, 2))) == PMMATCHING ||
             i == PMSUCCESS)) {
            /* Either the current pattern is the wild character '.' and the next pattern
             *  character matches this source which breaks the multiplier or the current
             *  pattern doesn't match the current source so skip the multiplier. */
            respPat->patNdx++;
            respPat->st = PMSKIPPATTERN;
        } else {
            /* The current pattern is the wild character with a multiplier and the current
             *  source doesn't match so we match on the wild character. */
        }
            
    } else if (curPattern == '.') {
        /* The wild character always matches so keep the default status. */
    } else {
        /* We've failed to find a match so try the next source position. */
        respPat->st = PMTRYNEXT;
    }
    
	CHATTRACE((LOG_DEBUG, TL_CHAT, "matchCurrent: s=[%s] @%d,%d=%p p=[%s] @%d=%p st=%d",
            &sourceStr[respPat->sourceNdx], respPat->sourceNdx, respPat->matchNdx, curSource,
            respPat->patStr, respPat->patNdx, curPattern, respPat->st));

    return respPat->st;
}


/*
 *  Attempt to match the pattern in the source string.  The pattern contains
 *  a pattern string composed of a subset of the UNIX regular expression
 *  characters.  Specifically it handles the '.' wild character and, to some
 *  degree, the '*' and '+' multipliers.  It also handles the '^' start-of-line
 *  character to mean the start of the source string and the '$' end-of-line
 *  character to mean a carriage return or line feed character or a carriage
 *  return-line feed combination.  The '\' escape character can be used before
 *  each of these special characters or itself to require that character to be
 *  matched literally.
 *
 *  This function is designed to be called for several different patterns
 *  each time a new character is added to the source string until one of the
 *  patterns match.  Thus the PatternContext structure maintains state information
 *  so that minimal previous work is repeated on each invocation.  Also, the
 *  interpretation of some of the pattern situations is modified so that a
 *  match is made early.  In particular, normally a regular expression is to
 *  match the largest input string possible from the source.  However, in our
 *  case we want the earliest match so that using the '.*x' sequence will exit
 *  on the next 'x' found in the string and no other possible matches will
 *  be attempted if the pattern fails later.  Thus the '.*' pattern must be
 *  used with caution.
 *
 *  Be especially aware that the first pattern character after the '.*' pattern
 *  will break the '.*' match.  Thus finding "t.*ing" in "this is icing" will
 *  fail because the 'i' matched the 'i' in "this".
 *
 *  Currently the patterns '**', '^*' (at the begining of a pattern), and
 *  '$*' will not work as expected since sometimes the special characters
 *  are interpretted and sometimes not.
 *
 *  Note: We cannot currently multiply escaped characters.
 *
 *  Returns: 0 on success, otherwise non-zero.
 */
static int patternMatch(char *sourceStr, PatternContext *respPat) 
{
    /* Attempt to match the rest of the pattern. */
    do {
        switch(matchCurrent(sourceStr, respPat)) {
        
        case PMMULTIPLYING:
            /* The pattern has a multiplier so just advance the source. */
            respPat->matchNdx++;
            respPat->st = PMMATCHING;
            break;
        case PMMATCHING:
            /* The pattern matched so advance the source and the pattern. */
            respPat->matchNdx++;
            respPat->patNdx++;
            respPat->st = PMMATCHING;
            break;
        case PMSKIPSOURCE:
            /* The current pattern has not completed so the source is being absorbed. */
            respPat->matchNdx++;
            respPat->st = PMMATCHING;
            break;
        case PMSKIPPATTERN:
            /* The current source starts a new pattern so skip the current pattern. */
            respPat->patNdx++;
            respPat->st = PMMATCHING;
            break;
        case PMTRYNEXT:
            /* We've failed from the current position in the source. */
            respPat->st = tryNextSource(respPat);
            break;
        default:
            /* Do nothing - we should be exitting. */
            break;
        }
    } while (respPat->st > 0);
    CHATTRACE((LOG_DEBUG, TL_CHAT, "patternMatch: st=%d => %d", 
            respPat->st, (respPat->st == PMSUCCESS ? 0 : -1)));
    return (respPat->st == PMSUCCESS ? 0 : -1);
}

#pragma warning (pop)
////////////////////////////////////////////////////////////////////////////////