string.c

enumerates Plug-n-Play RS-232 devices that are compliant with the current revision of Plug and Play

    PCHAR string)
// Measures the length of a string
{
    int i;
    if (string == NULL) {
        return 0;
    }
    for (i=0; string[i] != '\0'; i++) {
    }
    return i;
}

int
Serenum_SzCopy (
    PCHAR source,
    PCHAR dest)
// Copies a string
// Assumes the buffer is already allocated to be copied into
{
    int i;

    ASSERT (source);
    ASSERT (dest);

    for (i=0; source[i] != '\0'; i++) {
        *dest++ = source[i];
    }
    return i;
}

//
// String extraction functions:
//
int
Serenum_GetDevOtherID(
    PCHAR input,
    PCHAR output)
{

    int tail;
    CHAR c;

    tail = 0;

    c = input[tail++];

    while((tail < 17 ) && (c != '(') && (c != '(' - 0x20)) {
    *output++ = c;
    c = input[tail++];
    }

    *output = '\0';
    return(tail-1);
}


/****************************************************************************
 *
 *
 ***************************************************************************/
int
Serenum_HToI(char c) {

    if('0' <= c  &&  c <= '9')
    return(c - '0');

    if('A' <= c  &&  c <= 'F')
    return(c - 'A' + 10);

    if('a' <= c  &&  c <= 'f')
    return(c - 'a' + 10);

    return(-1);
}

void
Serenum_FixptToAscii(
    int n,
    PCHAR output)
/****************************************************************************
 *
 *
 ***************************************************************************/
{
    int tmp;

    tmp = n / 100;

    if(tmp >= 10)
        *output++ = (CHAR)('0' + (tmp / 10));

    *output++ = (CHAR)('0' + (tmp % 10));
    *output++ = '.';

    tmp = n % 100;

    *output++ = (CHAR)('0' + (tmp / 10));
    *output++ = (CHAR)('0' + (tmp % 10));

    *output = '\0';
}

/****************************************************************************
 *
 *
 ***************************************************************************/
NTSTATUS
Serenum_GetDevPnPRev(PFDO_DEVICE_DATA FdoData, PCHAR input,  PCHAR output,
                     int *start)
{
   int tail;
   int i;
   char delta;
   char c, begin_PnP, end_PnP_pos;
   int sum, chk_sum, msd, lsd;

   UNREFERENCED_PARAMETER(FdoData);

   if (output == NULL  ||  input == NULL) {
      Serenum_KdPrint(FdoData, SER_DBG_SS_ERROR,
                      ("GetDevPnPRev Failed, NULL pointer!\n"));
      return STATUS_UNSUCCESSFUL;
   }

   *output = '\0';

   tail = *start;

   if (input[tail] == 0) {
      Serenum_KdPrint(FdoData, SER_DBG_SS_ERROR,
                      ("GetDevPnPRev Failed, input buffer empty!\n"));
      return STATUS_UNSUCCESSFUL;
   }

   c = input[tail++];

   while ((tail < 256) && (c != '(') && (c != '(' - 0x20)) {
      c = input[tail++];
   }

   if (c != '('  &&  c != '(' - 0x20) {
      Serenum_KdPrint(FdoData, SER_DBG_SS_ERROR,
                      ("GetDevPnPRev Failed, no Begin PnP char!\n"));
      return STATUS_UNSUCCESSFUL;
   }

   begin_PnP = c;
   delta = '(' - begin_PnP;

   if (input[tail + 9] != ')' - delta) {

      //
      // compute checksum
      //

      sum = c;
      i = tail;
      while ( (i < 256)  &&  (c !=  ( ')' - delta)) ) {
         c = input[i++];
         sum += c;
      }

      msd = input[i-3];
      lsd = input[i-2];

      sum -= msd;
      sum -= lsd;

      msd += delta;
      lsd += delta;

      Serenum_KdPrint(FdoData, SER_DBG_SS_TRACE,
                      ("checksum from device  (chars) = %c%c\n", (char)msd,
                       (char)lsd));

      msd = Serenum_HToI((char)msd);
      if (msd < 0) {
         Serenum_KdPrint(FdoData, SER_DBG_SS_ERROR,
                         ("Bad msd checksum digit\n"));
         return STATUS_UNSUCCESSFUL;
      }

      lsd = Serenum_HToI((char)lsd);
      if (lsd < 0) {
         Serenum_KdPrint(FdoData, SER_DBG_SS_ERROR,
                         ("Bad lsd checksum digit\n"));
         return STATUS_UNSUCCESSFUL;
      }

      chk_sum = (msd << 4) + lsd;

      sum &= 0xff;

      Serenum_KdPrint(FdoData, SER_DBG_SS_TRACE,
                      ("checksum read from device = %0x\n", chk_sum));
      Serenum_KdPrint(FdoData, SER_DBG_SS_TRACE,
                      ("Computed checksum = %0x\n", sum));

      end_PnP_pos = (char)i;

      if ( c - begin_PnP  !=  ')' - '(' ) {
         Serenum_KdPrint(FdoData,  SER_DBG_SS_ERROR,
                         ("GetDevPnPRev Failed,BeginPnP didn't match "
                          "EndPnP\n"));
         Serenum_KdPrint(FdoData,  SER_DBG_SS_ERROR,
                         ("begin_PnP = %02x   end_PnP = %02x\n", begin_PnP, c));
         return STATUS_UNSUCCESSFUL;
      }

      //
      // check the checksum
      //

      if (chk_sum != sum) {
         Serenum_KdPrint(FdoData, SER_DBG_SS_ERROR,
                         ("checksum Failed! Continuing...\n"));
         //          return STATUS_UNSUCCESSFUL;     // Commented out in Memphis
      }

      i = end_PnP_pos;

      input[i-3] = ')' - delta;       // trash the checksum
      input[i-2] = '\0';              // since we are done with it
   }

   if (input[tail] > 0x3f ||
       input[tail+1] > 0x3f) {

      Serenum_KdPrint(FdoData, SER_DBG_SS_TRACE, ("Bad PnP Rev digits\n"));
      return STATUS_UNSUCCESSFUL;
   }

   i = (input[tail++] & 0x3f) << 6;
   i |= (input[tail++]) & 0x3f;

   Serenum_FixptToAscii(i, output);

   i = tail;

   //
   // get ride of Mouse'output 0x20 bias in the string
   //
   while ( (i < 256) && delta ) {
      input[i] += delta;
      c = input[i++];
      if ( c == ')' ) {
         delta = 0;    // indicate we are done
      }
   }

   *start = tail;

   return STATUS_SUCCESS;
}

/****************************************************************************
 *
 *
 ***************************************************************************/
void Serenum_GetDevName(
    PCHAR input,
    PCHAR output,
    int *start)
{

    int tail;
    char c;

    if(output == NULL  ||  input == NULL)
        return;

    tail = *start;

    // EISA ID
    *output++ = input[tail++];
    *output++ = input[tail++];
    *output++ = input[tail++];

    // Product ID

    c = input[tail++];
    if(Serenum_HToI(c) >= 0)
        *output++ = c;

    c = input[tail++];
    if(Serenum_HToI(c) >= 0)
        *output++ = c;

    c = input[tail++];
    if(Serenum_HToI(c) >= 0)
        *output++ = c;

    c = input[tail++];
    if(Serenum_HToI(c) >= 0)
        *output++ = c;

    *output = '\0';

    *start = tail;

    return;
}

/****************************************************************************
 *
 *
 ***************************************************************************/
void Serenum_GetDevSerialNo(
    PCHAR input,
    PCHAR output,
    int *start)
{

    int tail, cnt;
    char c;

    if(output == NULL  ||  input == NULL)
        return;

    *output = '\0';

    tail = *start;

    if( input[tail++] != '\\')
        return;

    c = input[tail++];

    cnt = 0;

    while(cnt < 8 && tail < 256 && ( c != '\\') && ( c != ')') ) {
        cnt++;
        if(Serenum_HToI(c) < 0)
            break;

        *output++ = c;
        c = input[tail++];
    }

    *output = '\0';

    *start = tail - 1;

    return;
}

/****************************************************************************
 *
 *
 ***************************************************************************/
void Serenum_GetDevClass(
    PCHAR input,
    PCHAR output,
    int *start)
{

    int tail;
    char c;

    if(output == NULL  ||  input == NULL)
        return;

    *output = '\0';

    tail = *start;

    if( input[tail++] != '\\')
        return;

    c = input[tail++];

    while(tail < 256 && ( c != '\\') && ( c != ')') ) {
        *output++ = c;
        c = input[tail++];
    }
    *output = '\0';

    *start = tail - 1;

    return;
}


void Serenum_GetDevCompId(
    PCHAR input,
    PCHAR output,
    int *start)
/****************************************************************************
 *
 *
 ***************************************************************************/
{

    int tail;
    char c;

    if(output == NULL  ||  input == NULL)
        return;

    *output = '\0';

    tail = *start;

    if( input[tail++] != '\\')
        return;

    c = input[tail++];

    while(tail < 256 && ( c != '\\') && ( c != ')') ) {
        *output++ = c;
        //
        // Put a * after every comma
        //
        if ('\x0C' == c || '\x2C' == c) {
            *output++ = '*';
        }
        c = input[tail++];
    }

    *output = '\0';

    *start = tail - 1;
}

void
Serenum_GetDevDesc(
    PCHAR input,
    PCHAR output,
    int *start)
/****************************************************************************
 *
 *
 ***************************************************************************/
{

    int tail;
    char c;

    if(output == NULL  ||  input == NULL)
        return;

    *output = '\0';

    tail = *start;

    if( input[tail++] != '\\')
        return;

    c = input[tail++];

    while(tail < 256 && ( c != '\\') && ( c != ')') ) {
    *output++ = c;
    c = input[tail++];
    }

    *output = '\0';

    *start = tail - 1;
}