script.c

汇编源代码大全

/*                     Look for alternate matches                     */
/*--------------------------------------------------------------------*/

   if ( alternates > 0 )
   {
      subscript = alternates;

      while ( subscript-- )
      {
         if (Match( failure[subscript], Buffer, &SearchPos[subscript]))
         {
            printmsg(0,"got \"%s\" (failure)",failure[subscript]);
            return 2;
         }
      } /* while ( subscript-- ) */

   } /* if ( alternates > 0 ) */

   return 0;

} /* StrMatch */

/*--------------------------------------------------------------------*/
/*    m a t c h                                                       */
/*                                                                    */
/*    Match a single string                                           */
/*--------------------------------------------------------------------*/

static boolean Match( char *Search,
                      char *Buffer,
                      size_t *SearchPos)
{
   int BufInd;             /* Index to input string buffer for string
                              compare */
   char *SearchInd;        /* Index to search string for string
                              compare */

   *SearchPos += 1;
   for (BufInd = *SearchPos, SearchInd = Search; *SearchInd; SearchInd++)
   {
     if (Buffer[BufInd++ & QINDMASK] != *SearchInd)
        return FALSE;
   }

   return TRUE;

} /* Match */

/*--------------------------------------------------------------------*/
/*    M a t c h I n i t                                               */
/*                                                                    */
/*    Initialize one set of parameters for MATCH                      */
/*--------------------------------------------------------------------*/

static size_t MatchInit( const char *MatchStr )
{
   size_t SearchLen = strlen(MatchStr);

   if (SearchLen > MAXMATCH)
   {
      printmsg(0,"StrMatch: String to match '%s' is too long.\n",
           MatchStr);
      panic();
   }

   return MAXMATCH - SearchLen;

} /* MatchInit */

/*--------------------------------------------------------------------*/
/*    w r i t e s t r                                                 */
/*                                                                    */
/*    Send a string to the port during login                          */
/*--------------------------------------------------------------------*/

static void writestr(register char *s)
{
   register char last = '\0';
   boolean writeCR = TRUE;
   unsigned char digit;

   while (*s)
   {
      if (last == '\\') {
         last = *s;
         switch (*s) {
         case 'd':   /* delay */
         case 'D':
            flushScriptBuffer();
            ssleep(2);
            break;
         case 'c':   /* don't output CR at end of string */
         case 'C':
            writeCR = FALSE;
            break;
         case 'r':   /* carriage return */
         case 'R':
         case 'm':
         case 'M':
            slowWrite("\r", 1);
            break;
         case 'n':   /* new line */
         case 'N':
            slowWrite("\n", 1);
            break;
         case 'p':   /* delay */
         case 'P':
            flushScriptBuffer();
            ddelay(400);
            break;
         case 'b':   /* backspace */
         case 'B':
            slowWrite("\b", 1);
            break;
         case 't':   /* tab */
         case 'T':
            slowWrite("\t", 1);
            break;
         case 's':   /* space */
         case 'S':
            slowWrite(" ", 1);
            break;
         case 'z':   /* set serial port speed */
         case 'Z':
            flushScriptBuffer();
            SIOSpeed(atoi(++s));
            while (isdigit(*(s+1)))
               s++;
            break;

         case '0':
         case '1':
         case '2':
         case '3':
         case '4':
         case '5':
         case '6':
         case '7':
            digit = 0;
            while( (*s >= '0') && (*s < '8'))
               digit = (unsigned char) (digit * 8 + *s++ - '0');
            s--;              /* Backup before non-numeric char      */
            slowWrite((char *) &digit,1);
            break;

         default: /* ordinary character */
            slowWrite(s, 1);
            last = '\0';      /* Zap any repeated backslash (\)      */
         }
      }
      else if (*s != '\\') /* backslash */
         slowWrite(s, 1);
      else
         last = *s;
      s++;

   }  /* while */

   if ( writeCR )
      slowWrite( "\r", 1 );

   flushScriptBuffer();             // Handle any queued data on net

} /* writestr */

/*--------------------------------------------------------------------*/
/*       s e n d s t r                                                */
/*                                                                    */
/*       Send line of login sequence                                  */
/*--------------------------------------------------------------------*/

void sendstr(char *str)
{
   printmsg(2, "sending \"%s\"", str);

   if (equaln(str, "BREAK", 5))
   {
      int   nulls;
      nulls = atoi(&str[5]);
      if (nulls <= 0 || nulls > 10)
         nulls = 3;
      ssendbrk(nulls);  /* send a break signal */
      return;
   }

   if (equal(str, "EOT"))
   {
      slowWrite(EOTMSG, strlen(EOTMSG));
      flushScriptBuffer();
      return;
   }

   if (equal(str, "\"\""))
      *str = '\0';

   writestr(str);

} /*sendstr*/

/*--------------------------------------------------------------------*/
/*    s l o w w r i t e                                               */
/*                                                                    */
/*    Write characters to the serial port at a configurable           */
/*    snail's pace.                                                   */
/*--------------------------------------------------------------------*/

static void slowWrite( char *s, size_t len)
{
   if ( M_charDelay )
   {
      swrite( s , len );
      ddelay(M_charDelay);
   }
   else {

      if ( (scriptBufferLen + len) > sizeof scriptBuffer )
         flushScriptBuffer();

      if ( len == 1 )
         scriptBuffer[ scriptBufferLen++ ] = *s;
      else if ( len >= sizeof scriptBuffer )
         swrite( s , len );
      else {
         memcpy( scriptBuffer + scriptBufferLen, s, len );
         scriptBufferLen += len;
      } /* else */

   } /* else */

} /* slowWrite */

/*--------------------------------------------------------------------*/
/*       f l u s h S c r i p t B u f f e r                            */
/*                                                                    */
/*       Flush queued network I/O                                     */
/*--------------------------------------------------------------------*/

static void flushScriptBuffer( void )
{
   if ( scriptBufferLen )
   {
      swrite( scriptBuffer, scriptBufferLen );
      scriptBufferLen = 0;
   }

} /* flushScriptBuffer */