llbase32.cpp
上传用户:king477883
上传日期:2021-03-01
资源大小:9553k
文件大小:7k
源码类别:

游戏引擎

开发平台:

C++ Builder

  1. /** 
  2.  * @file llbase32.cpp
  3.  * @brief base32 encoding that returns a std::string
  4.  * @author James Cook
  5.  *
  6.  * Based on code from bitter
  7.  * http://ghostwhitecrab.com/bitter/
  8.  *
  9.  * Some parts of this file are:
  10.  * $LicenseInfo:firstyear=2007&license=viewergpl$
  11.  * 
  12.  * Copyright (c) 2007-2010, Linden Research, Inc.
  13.  * 
  14.  * Second Life Viewer Source Code
  15.  * The source code in this file ("Source Code") is provided by Linden Lab
  16.  * to you under the terms of the GNU General Public License, version 2.0
  17.  * ("GPL"), unless you have obtained a separate licensing agreement
  18.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  19.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  20.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  21.  * 
  22.  * There are special exceptions to the terms and conditions of the GPL as
  23.  * it is applied to this Source Code. View the full text of the exception
  24.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  25.  * online at
  26.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  27.  * 
  28.  * By copying, modifying or distributing this software, you acknowledge
  29.  * that you have read and understood your obligations described above,
  30.  * and agree to abide by those obligations.
  31.  * 
  32.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  33.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  34.  * COMPLETENESS OR PERFORMANCE.
  35.  * $/LicenseInfo$
  36.  */
  37. /**
  38.  * Copyright (c) 2006 Christian Biere <christianbiere@gmx.de>
  39.  * All rights reserved.
  40.  *
  41.  * Redistribution and use in source and binary forms, with or without
  42.  * modification, are permitted provided that the following conditions
  43.  * are met:
  44.  *
  45.  * 1. Redistributions of source code must retain the above copyright
  46.  *    notice, this list of conditions and the following disclaimer.
  47.  * 2. Redistributions in binary form must reproduce the above copyright
  48.  *    notice, this list of conditions and the following disclaimer in the
  49.  *    documentation and/or other materials provided with the distribution.
  50.  * 3. Neither the name of the authors nor the names of its contributors
  51.  *    may be used to endorse or promote products derived from this software
  52.  *    without specific prior written permission.
  53.  *
  54.  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  55.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  56.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  57.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  58.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  59.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  60.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  61.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  62.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  63.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  64.  * SUCH DAMAGE.
  65.  */
  66. #include "linden_common.h"
  67. #include "llbase32.h"
  68. #include <string>
  69. // bitter - base32.c starts here
  70. /*
  71.  * See RFC 3548 for details about Base 32 encoding:
  72.  *  http://www.faqs.org/rfcs/rfc3548.html
  73.  */
  74. static const char base32_alphabet[32] = {
  75.   'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
  76.   'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  77.   'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X',
  78.   'Y', 'Z', '2', '3', '4', '5', '6', '7'
  79. };
  80. size_t
  81. base32_encode(char *dst, size_t size, const void *data, size_t len)
  82. {
  83.   size_t i = 0;
  84.   const U8 *p = (const U8*)data;
  85.   const char *end = &dst[size];
  86.   char *q = dst;
  87.   do {
  88.     size_t j, k;
  89.     U8 x[5];
  90.     char s[8];
  91.     switch (len - i) {
  92.     case 4: k = 7; break;
  93.     case 3: k = 5; break;
  94.     case 2: k = 3; break;
  95.     case 1: k = 2; break;
  96.     default:
  97.       k = 8;
  98.     }
  99.     for (j = 0; j < 5; j++)
  100.       x[j] = i < len ? p[i++] : 0;
  101. /*
  102.   +-------+-----------+--------+
  103.   | target| source    | source |
  104.   | byte  | bits      | byte   |
  105.   +-------+-----------+--------+
  106.   |     0 | 7 6 5 4 3 | 0      |
  107.   |     1 | 2 1 0 7 6 | 0-1    |
  108.   |     2 | 5 4 3 2 1 | 1      |
  109.   |     3 | 0 7 6 5 4 | 1-2    |
  110.   |     4 | 3 2 1 0 7 | 2-3    |
  111.   |     5 | 6 5 4 3 2 | 3      |
  112.   |     6 | 1 0 7 6 5 | 3-4    |
  113.   |     7 | 4 3 2 1 0 | 4      |
  114.   +-------+-----------+--------+
  115.   
  116. */
  117.     
  118.     s[0] =  (x[0] >> 3);
  119.     s[1] = ((x[0] & 0x07) << 2) | (x[1] >> 6);
  120.     s[2] =  (x[1] >> 1) & 0x1f;
  121.     s[3] = ((x[1] & 0x01) << 4) | (x[2] >> 4);
  122.     s[4] = ((x[2] & 0x0f) << 1) | (x[3] >> 7);
  123.     s[5] =  (x[3] >> 2) & 0x1f;
  124.     s[6] = ((x[3] & 0x03) << 3) | (x[4] >> 5);
  125.     s[7] =   x[4] & 0x1f;
  126.     for (j = 0; j < k && q != end; j++)
  127.       *q++ = base32_alphabet[(U8) s[j]];
  128.   } while (i < len);
  129.   return q - dst;
  130. }
  131. /* *TODO: Implement base32 encode.
  132. static inline int
  133. ascii_toupper(int c)
  134. {
  135.   return c >= 97 && c <= 122 ? c - 32 : c;
  136. }
  137. static inline int
  138. ascii_tolower(int c)
  139. {
  140.   return c >= 65 && c <= 90 ? c + 32 : c;
  141. }
  142. static char base32_map[(unsigned char) -1];
  143. size_t
  144. base32_decode(char *dst, size_t size, const void *data, size_t len)
  145. {
  146.   const char *end = &dst[size];
  147.   const unsigned char *p = data;
  148.   char *q = dst;
  149.   size_t i;
  150.   unsigned max_pad = 3;
  151.   if (0 == base32_map[0]) {
  152.     for (i = 0; i < LL_ARRAY_SIZE(base32_map); i++) {
  153.       const char *x;
  154.       
  155.       x = memchr(base32_alphabet, ascii_toupper(i), sizeof base32_alphabet);
  156.       base32_map[i] = x ? (x - base32_alphabet) : (unsigned char) -1;
  157.     }
  158.   }
  159.   
  160.   for (i = 0; i < len && max_pad > 0; i++) {
  161.     unsigned char c;
  162.     char s[8];
  163.     size_t j;
  164.     c = p[i];
  165.     if ('=' == c) {
  166.       max_pad--;
  167.       c = 0;
  168.     } else {
  169.       c = base32_map[c];
  170.       if ((unsigned char) -1 == c) {
  171.         return -1;
  172.       }
  173.     }
  174.     j = i % LL_ARRAY_SIZE(s);
  175.     s[j] = c;
  176.     if (7 == j) {
  177.       char b[5];
  178.       b[0] = ((s[0] << 3) & 0xf8) | ((s[1] >> 2) & 0x07);
  179.       b[1] = ((s[1] & 0x03) << 6) | ((s[2] & 0x1f) << 1) | ((s[3] >> 4) & 1);
  180.       b[2] = ((s[3] & 0x0f) << 4) | ((s[4] >> 1) & 0x0f);
  181.       b[3] = ((s[4] & 1) << 7) | ((s[5] & 0x1f) << 2) | ((s[6] >> 3) & 0x03);
  182.       b[4] = ((s[6] & 0x07) << 5) | (s[7] & 0x1f);
  183.       for (j = 0; j < LL_ARRAY_SIZE(b); j++) {
  184.         if (q != end)
  185.           *q = b[j];
  186.         q++;
  187.       }
  188.     }
  189.   }
  190.   return q - dst;
  191. }
  192. */
  193. // The following is
  194. // Copyright (c) 2007-$CurrentYear$, Linden Research, Inc.
  195. // static
  196. std::string LLBase32::encode(const U8* input, size_t input_size)
  197. {
  198. std::string output;
  199. if (input)
  200. {
  201. // Each 5 byte chunk of input is represented by an
  202. // 8 byte chunk of output.
  203. size_t input_chunks = (input_size + 4) / 5;
  204. size_t output_size = input_chunks * 8;
  205. output.resize(output_size);
  206. size_t encoded = base32_encode(&output[0], output_size, input, input_size);
  207. llinfos << "encoded " << encoded << " into buffer of size "
  208. << output_size << llendl;
  209. }
  210. return output;
  211. }