src/base/utils/bytearray.cpp

   1 /*
   2  * Bittorrent Client using Qt and libtorrent.
   3  * Copyright (C) 2023  Vladimir Golovnev <glassez@yandex.ru>
   4  * Copyright (C) 2018  Mike Tzou (Chocobo1)
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  * In addition, as a special exception, the copyright holders give permission to
  21  * link this program with the OpenSSL project's "OpenSSL" library (or with
  22  * modified versions of it that use the same license as the "OpenSSL" library),
  23  * and distribute the linked executables. You must obey the GNU General Public
  24  * License in all respects for all of the code used other than "OpenSSL".  If you
  25  * modify file(s), you may extend this exception to your version of the file(s),
  26  * but you are not obligated to do so. If you do not wish to do so, delete this
  27  * exception statement from your version.
  28  */
  29
  30 #include "bytearray.h"
  31
  32 #include <QByteArray>
  33 #include <QVector>
  34
  35 QVector<QByteArray> Utils::ByteArray::splitToViews(const QByteArray &in, const QByteArray &sep, const Qt::SplitBehavior behavior)
  36 {
  37     if (sep.isEmpty())
  38         return {in};
  39
  40     QVector<QByteArray> ret;
  41     ret.reserve((behavior == Qt::KeepEmptyParts)
  42                 ? (1 + (in.size() / sep.size()))
  43                 : (1 + (in.size() / (sep.size() + 1))));
  44     int head = 0;
  45     while (head < in.size())
  46     {
  47         int end = in.indexOf(sep, head);
  48         if (end < 0)
  49             end = in.size();
  50
  51         // omit empty parts
  52         const QByteArray part = QByteArray::fromRawData((in.constData() + head), (end - head));
  53         if (!part.isEmpty() || (behavior == Qt::KeepEmptyParts))
  54             ret += part;
  55
  56         head = end + sep.size();
  57     }
  58
  59     return ret;
  60 }
  61
  62 const QByteArray Utils::ByteArray::midView(const QByteArray &in, const int pos, const int len)
  63 {
  64     if ((pos < 0) || (pos >= in.size()) || (len == 0))
  65         return {};
  66
  67     const int validLen = ((len < 0) || (pos + len) >= in.size())
  68             ? in.size() - pos
  69             : len;
  70     return QByteArray::fromRawData(in.constData() + pos, validLen);
  71 }
  72
  73 QByteArray Utils::ByteArray::toBase32(const QByteArray &in)
  74 {
  75     const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
  76     const char padchar = '=';
  77
  78     const qsizetype inSize = in.size();
  79
  80     auto tmp = QByteArray((inSize + 4) / 5 * 8, Qt::Uninitialized);
  81     qsizetype inIndex = 0;
  82     char *out = tmp.data();
  83     while (inIndex < inSize)
  84     {
  85         // encode 5 bytes at a time
  86         qsizetype inPadLen = 5;
  87         int64_t chunk = 0;
  88         while (inPadLen > 0)
  89         {
  90             chunk |= static_cast<int64_t>(static_cast<uchar>(in.data()[inIndex++])) << (--inPadLen * 8);
  91             if (inIndex == inSize)
  92                 break;
  93         }
  94
  95         const int outCharCounts[] = {8, 7, 5, 4, 2};
  96         for (int i = 7; i >= 0; --i)
  97         {
  98             if (i >= (8 - outCharCounts[inPadLen]))
  99             {
 100                 const int shift = (i * 5);
 101                 const int64_t mask = static_cast<int64_t>(0x1f) << shift;
 102                 const int charIndex = (chunk & mask) >> shift;
 103                 *out++ = alphabet[charIndex];
 104             }
 105             else
 106             {
 107                 *out++ = padchar;
 108             }
 109         }
 110     }
 111
 112     return tmp;
 113 }