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 <QByteArrayView>
  34 #include <QList>
  35
  36 QList<QByteArrayView> Utils::ByteArray::splitToViews(const QByteArrayView in, const QByteArrayView sep, const Qt::SplitBehavior behavior)
  37 {
  38     if (sep.isEmpty())
  39         return {in};
  40
  41     QList<QByteArrayView> ret;
  42     ret.reserve((behavior == Qt::KeepEmptyParts)
  43                 ? (1 + (in.size() / sep.size()))
  44                 : (1 + (in.size() / (sep.size() + 1))));
  45     int head = 0;
  46     while (head < in.size())
  47     {
  48         int end = in.indexOf(sep, head);
  49         if (end < 0)
  50             end = in.size();
  51
  52         // omit empty parts
  53         const QByteArrayView part = in.mid(head, (end - head));
  54         if (!part.isEmpty() || (behavior == Qt::KeepEmptyParts))
  55             ret += part;
  56
  57         head = end + sep.size();
  58     }
  59
  60     return ret;
  61 }
  62
  63 QByteArray Utils::ByteArray::asQByteArray(const QByteArrayView view)
  64 {
  65     // `QByteArrayView::toByteArray()` will deep copy the data
  66     // So we provide our own fast path for appropriate situations/code
  67     return QByteArray::fromRawData(view.constData(), view.size());
  68 }
  69
  70 QByteArray Utils::ByteArray::toBase32(const QByteArray &in)
  71 {
  72     const char alphabet[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
  73     const char padchar = '=';
  74
  75     const qsizetype inSize = in.size();
  76
  77     auto tmp = QByteArray((inSize + 4) / 5 * 8, Qt::Uninitialized);
  78     qsizetype inIndex = 0;
  79     char *out = tmp.data();
  80     while (inIndex < inSize)
  81     {
  82         // encode 5 bytes at a time
  83         qsizetype inPadLen = 5;
  84         int64_t chunk = 0;
  85         while (inPadLen > 0)
  86         {
  87             chunk |= static_cast<int64_t>(static_cast<uchar>(in.data()[inIndex++])) << (--inPadLen * 8);
  88             if (inIndex == inSize)
  89                 break;
  90         }
  91
  92         const int outCharCounts[] = {8, 7, 5, 4, 2};
  93         for (int i = 7; i >= 0; --i)
  94         {
  95             if (i >= (8 - outCharCounts[inPadLen]))
  96             {
  97                 const int shift = (i * 5);
  98                 const int64_t mask = static_cast<int64_t>(0x1f) << shift;
  99                 const int charIndex = (chunk & mask) >> shift;
 100                 *out++ = alphabet[charIndex];
 101             }
 102             else
 103             {
 104                 *out++ = padchar;
 105             }
 106         }
 107     }
 108
 109     return tmp;
 110 }