Line data    Source code

       1              : /*
       2              :  *
       3              :  *    Copyright (c) 2020 Project CHIP Authors
       4              :  *    Copyright (c) 2013-2017 Nest Labs, Inc.
       5              :  *
       6              :  *    Licensed under the Apache License, Version 2.0 (the "License");
       7              :  *    you may not use this file except in compliance with the License.
       8              :  *    You may obtain a copy of the License at
       9              :  *
      10              :  *        http://www.apache.org/licenses/LICENSE-2.0
      11              :  *
      12              :  *    Unless required by applicable law or agreed to in writing, software
      13              :  *    distributed under the License is distributed on an "AS IS" BASIS,
      14              :  *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      15              :  *    See the License for the specific language governing permissions and
      16              :  *    limitations under the License.
      17              :  */
      18              : 
      19              : /**
      20              :  *    @file
      21              :  *      This file implements an object for Verhoeff's check-digit
      22              :  *      algorithm for base-10 strings.
      23              :  *
      24              :  */
      25              : 
      26              : #include "Verhoeff.h"
      27              : 
      28              : #include <stdint.h>
      29              : #include <string.h>
      30              : 
      31              : #ifndef VERHOEFF10_NO_MULTIPLY_TABLE
      32              : 
      33              : const uint8_t Verhoeff10::sMultiplyTable[] = {
      34              :     0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 0, 6, 7, 8, 9, 5, 2, 3, 4, 0, 1, 7, 8, 9, 5, 6, 3, 4, 0, 1,
      35              :     2, 8, 9, 5, 6, 7, 4, 0, 1, 2, 3, 9, 5, 6, 7, 8, 5, 9, 8, 7, 6, 0, 4, 3, 2, 1, 6, 5, 9, 8, 7, 1, 0, 4,
      36              :     3, 2, 7, 6, 5, 9, 8, 2, 1, 0, 4, 3, 8, 7, 6, 5, 9, 3, 2, 1, 0, 4, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0,
      37              : };
      38              : 
      39              : #endif
      40              : 
      41              : const uint8_t Verhoeff10::sPermTable[] = { 1, 5, 7, 6, 2, 8, 3, 0, 9, 4 };
      42              : 
      43           38 : char Verhoeff10::ComputeCheckChar(const char * str)
      44              : {
      45           38 :     return ComputeCheckChar(str, strlen(str));
      46              : }
      47              : 
      48           64 : char Verhoeff10::ComputeCheckChar(const char * str, size_t strLen)
      49              : {
      50           64 :     int c = 0;
      51              : 
      52          972 :     for (size_t i = 1; i <= strLen; i++)
      53              :     {
      54          910 :         char ch = str[strLen - i];
      55              : 
      56          910 :         int val = CharToVal(ch);
      57          910 :         if (val < 0)
      58            2 :             return 0; // invalid character
      59              : 
      60          908 :         int p = Verhoeff::Permute(val, sPermTable, Base, i);
      61              : 
      62              : #ifdef VERHOEFF10_NO_MULTIPLY_TABLE
      63              :         c = Verhoeff::DihedralMultiply(c, p, PolygonSize);
      64              : #else
      65          908 :         c = sMultiplyTable[c * Base + p];
      66              : #endif
      67              :     }
      68              : 
      69           62 :     c = Verhoeff::DihedralInvert(c, PolygonSize);
      70              : 
      71           62 :     return ValToChar(c);
      72              : }
      73              : 
      74           26 : bool Verhoeff10::ValidateCheckChar(char checkChar, const char * str)
      75              : {
      76           26 :     return ValidateCheckChar(checkChar, str, strlen(str));
      77              : }
      78              : 
      79           26 : bool Verhoeff10::ValidateCheckChar(char checkChar, const char * str, size_t strLen)
      80              : {
      81           26 :     return (ComputeCheckChar(str, strLen) == checkChar);
      82              : }
      83              : 
      84            0 : bool Verhoeff10::ValidateCheckChar(const char * str)
      85              : {
      86            0 :     return ValidateCheckChar(str, strlen(str));
      87              : }
      88              : 
      89            0 : bool Verhoeff10::ValidateCheckChar(const char * str, size_t strLen)
      90              : {
      91            0 :     if (strLen == 0)
      92            0 :         return false;
      93            0 :     return ValidateCheckChar(str[strLen - 1], str, strLen - 1);
      94              : }
      95              : 
      96          922 : int Verhoeff10::CharToVal(char ch)
      97              : {
      98          922 :     if (ch >= '0' && ch <= '9')
      99          920 :         return ch - '0';
     100            2 :     return -1;
     101              : }
     102              : 
     103           62 : char Verhoeff10::ValToChar(int val)
     104              : {
     105           62 :     if (val >= 0 && val <= Base)
     106           62 :         return static_cast<char>('0' + val);
     107            0 :     return 0;
     108              : }