xref: /aosp_15_r20/external/fastrpc/src/std_SwapBytes.c (revision 418b791d679beb2078b579a3b6936cf330c41799)

/*
 * Copyright (c) 2019, The Linux Foundation. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above
 *      copyright notice, this list of conditions and the following
 *      disclaimer in the documentation and/or other materials provided
 *      with the distribution.
 *    * Neither the name of The Linux Foundation nor the names of its
 *      contributors may be used to endorse or promote products derived
 *      from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR 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.
 */
#include "AEEstd.h"
#include "AEEsmath.h"



static int xMinSize(int a, int b)
{
   if (b < a) {
      a = b;
   }
   return (a >= 0 ? a : 0);
}


static void xMoveBytes(byte *pbDest, const byte *pbSrc, int cb)
{
   if (pbDest != pbSrc) {
      (void) std_memmove(pbDest, pbSrc, cb);
   }
}


#ifdef AEE_BIGENDIAN
#  define STD_COPY       std_CopyBE
#  define STD_COPY_SWAP  std_CopyLE
#else
#  define STD_COPY       std_CopyLE
#  define STD_COPY_SWAP  std_CopyBE
#endif


// See std_CopyLE/BE for documentation.  This function implements the case
// where host ordering != target byte ordering.
//
int STD_COPY_SWAP(void *      pvDest, int nDestSize,
                  const void *pvSrc,  int nSrcSize,
                  const char *pszFields)
{
   byte* pbDest = (byte*)pvDest;
   byte* pbSrc  = (byte*)pvSrc;
   int cbCopied = xMinSize(nDestSize, nSrcSize);
   const char * pszNextField;
   int cb, nSize;

   nSize = 0;  // avoid warning when using RVCT2.2 with -O1

   pszNextField = pszFields;

   for (cb = cbCopied; cb > 0; cb -= nSize) {
      char  ch;

      ch = *pszNextField++;
      if ('\0' == ch) {
         ch = *pszFields;
         pszNextField = pszFields+1;
      }

      if (ch == 'S') {

         // S = 2 bytes

         nSize = 2;
         if (cb < nSize) {
            break;
         } else {
            byte by   = pbSrc[0];
            pbDest[0] = pbSrc[1];
            pbDest[1] = by;
         }
      } else if (ch == 'L') {

         // L = 4 bytes

         nSize = 4;
         if (cb < nSize) {
            break;
         } else {
            byte by   = pbSrc[0];
            pbDest[0] = pbSrc[3];
            pbDest[3] = by;
            by        = pbSrc[1];
            pbDest[1] = pbSrc[2];
            pbDest[2] = by;
         }
      } else if (ch == 'Q') {

         // Q = 8 bytes

         nSize = 8;
         if (cb < nSize) {
            break;
         } else {
            byte by   = pbSrc[0];
            pbDest[0] = pbSrc[7];
            pbDest[7] = by;
            by        = pbSrc[1];
            pbDest[1] = pbSrc[6];
            pbDest[6] = by;
            by        = pbSrc[2];
            pbDest[2] = pbSrc[5];
            pbDest[5] = by;
            by        = pbSrc[3];
            pbDest[3] = pbSrc[4];
            pbDest[4] = by;
         }
      } else {

         // None of the above => read decimal and copy without swap

         if (ch >= '0' && ch <= '9') {
            nSize = (int) (ch - '0');
            while ( (ch = *pszNextField) >= '0' && ch <= '9') {
               nSize = nSize*10 + (int)(ch - '0');
               ++pszNextField;
            }
            // Check bounds & ensure progress
            if (nSize > cb || nSize <= 0) {
               nSize = cb;
            }
         } else {
            // Unexpected character: copy rest of data
            nSize = cb;
         }

         xMoveBytes(pbDest, pbSrc, nSize);
      }

      pbDest += nSize;
      pbSrc += nSize;
   }

   if (cb > 0) {

      // Swap could not be completed:  0 < cb < nSize <= 8

      byte byBuf[8];

      // If entire value is available in source, use swapped version
      if (nSrcSize - (pbSrc - (byte*)pvSrc) >= nSize) {
         int i;
         for (i=0; i<cb; ++i) {
            byBuf[i] = pbSrc[nSize-1-i];
         }
         pbSrc = byBuf;
      }
      std_memmove(pbDest, pbSrc, cb);
   }

   return cbCopied;
}


// See std_CopyLE/BE for documentation.  This function implements the case
// where host ordering == target byte ordering.
//
int STD_COPY(void *pvDest, int nDestSize,
             const void *pvSrc,  int nSrcSize,
             const char *pszFields)
{
   int cb = xMinSize(nDestSize, nSrcSize);
   (void)pszFields;
   xMoveBytes(pvDest, pvSrc, cb);
   return cb;
}