blob: 94b0732c12c8319a4eed9f965f08173f1006aa6e [file] [log] [blame]
Jack Jansen72781191995-08-07 14:34:15 +00001/*
2** Routines to represent binary data in ASCII and vice-versa
3**
4** This module currently supports the following encodings:
5** uuencode:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00006** each line encodes 45 bytes (except possibly the last)
7** First char encodes (binary) length, rest data
8** each char encodes 6 bits, as follows:
9** binary: 01234567 abcdefgh ijklmnop
10** ascii: 012345 67abcd efghij klmnop
11** ASCII encoding method is "excess-space": 000000 is encoded as ' ', etc.
12** short binary data is zero-extended (so the bits are always in the
13** right place), this does *not* reflect in the length.
Jack Jansen84bbc2e1995-10-04 16:38:44 +000014** base64:
15** Line breaks are insignificant, but lines are at most 76 chars
16** each char encodes 6 bits, in similar order as uucode/hqx. Encoding
17** is done via a table.
18** Short binary data is filled (in ASCII) with '='.
Jack Jansen72781191995-08-07 14:34:15 +000019** hqx:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000020** File starts with introductory text, real data starts and ends
21** with colons.
22** Data consists of three similar parts: info, datafork, resourcefork.
23** Each part is protected (at the end) with a 16-bit crc
24** The binary data is run-length encoded, and then ascii-fied:
25** binary: 01234567 abcdefgh ijklmnop
26** ascii: 012345 67abcd efghij klmnop
27** ASCII encoding is table-driven, see the code.
28** Short binary data results in the runt ascii-byte being output with
29** the bits in the right place.
Jack Jansen72781191995-08-07 14:34:15 +000030**
31** While I was reading dozens of programs that encode or decode the formats
32** here (documentation? hihi:-) I have formulated Jansen's Observation:
33**
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000034** Programs that encode binary data in ASCII are written in
35** such a style that they are as unreadable as possible. Devices used
36** include unnecessary global variables, burying important tables
37** in unrelated sourcefiles, putting functions in include files,
38** using seemingly-descriptive variable names for different purposes,
39** calls to empty subroutines and a host of others.
Jack Jansen72781191995-08-07 14:34:15 +000040**
41** I have attempted to break with this tradition, but I guess that that
42** does make the performance sub-optimal. Oh well, too bad...
43**
44** Jack Jansen, CWI, July 1995.
Tim Peters934c1a12002-07-02 22:24:50 +000045**
Martin v. Löwis16dc7f42001-09-30 20:32:11 +000046** Added support for quoted-printable encoding, based on rfc 1521 et al
Tim Peters934c1a12002-07-02 22:24:50 +000047** quoted-printable encoding specifies that non printable characters (anything
Martin v. Löwis16dc7f42001-09-30 20:32:11 +000048** below 32 and above 126) be encoded as =XX where XX is the hexadecimal value
49** of the character. It also specifies some other behavior to enable 8bit data
Tim Peters934c1a12002-07-02 22:24:50 +000050** in a mail message with little difficulty (maximum line sizes, protecting
51** some cases of whitespace, etc).
Martin v. Löwis16dc7f42001-09-30 20:32:11 +000052**
53** Brandon Long, September 2001.
Jack Jansen72781191995-08-07 14:34:15 +000054*/
55
Thomas Wouters9c544482006-03-01 21:59:44 +000056#define PY_SSIZE_T_CLEAN
Jack Jansen72781191995-08-07 14:34:15 +000057
58#include "Python.h"
Gregory P. Smith9c6b9162015-04-26 00:42:13 +000059#include "pystrhex.h"
Christian Heimes1dc54002008-03-24 02:19:29 +000060#ifdef USE_ZLIB_CRC32
61#include "zlib.h"
62#endif
Jack Jansen72781191995-08-07 14:34:15 +000063
Marcel Plch33e71e02019-05-22 13:51:26 +020064typedef struct binascii_state {
65 PyObject *Error;
66 PyObject *Incomplete;
67} binascii_state;
Jack Jansen72781191995-08-07 14:34:15 +000068
69/*
70** hqx lookup table, ascii->binary.
71*/
72
73#define RUNCHAR 0x90
74
75#define DONE 0x7F
76#define SKIP 0x7E
77#define FAIL 0x7D
78
Serhiy Storchaka2d06e842015-12-25 19:53:18 +020079static const unsigned char table_a2b_hqx[256] = {
Jack Jansen72781191995-08-07 14:34:15 +000080/* ^@ ^A ^B ^C ^D ^E ^F ^G */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000081/* 0*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000082/* \b \t \n ^K ^L \r ^N ^O */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000083/* 1*/ FAIL, FAIL, SKIP, FAIL, FAIL, SKIP, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000084/* ^P ^Q ^R ^S ^T ^U ^V ^W */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000085/* 2*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000086/* ^X ^Y ^Z ^[ ^\ ^] ^^ ^_ */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000087/* 3*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000088/* ! " # $ % & ' */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000089/* 4*/ FAIL, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
Jack Jansen72781191995-08-07 14:34:15 +000090/* ( ) * + , - . / */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000091/* 5*/ 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000092/* 0 1 2 3 4 5 6 7 */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000093/* 6*/ 0x0D, 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000094/* 8 9 : ; < = > ? */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000095/* 7*/ 0x14, 0x15, DONE, FAIL, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +000096/* @ A B C D E F G */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000097/* 8*/ 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D,
Jack Jansen72781191995-08-07 14:34:15 +000098/* H I J K L M N O */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +000099/* 9*/ 0x1E, 0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000100/* P Q R S T U V W */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000101/*10*/ 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000102/* X Y Z [ \ ] ^ _ */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000103/*11*/ 0x2C, 0x2D, 0x2E, 0x2F, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000104/* ` a b c d e f g */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000105/*12*/ 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000106/* h i j k l m n o */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000107/*13*/ 0x37, 0x38, 0x39, 0x3A, 0x3B, 0x3C, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000108/* p q r s t u v w */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000109/*14*/ 0x3D, 0x3E, 0x3F, FAIL, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000110/* x y z { | } ~ ^? */
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000111/*15*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
112/*16*/ FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
113 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
114 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
115 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
116 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
117 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
118 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
119 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
120 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
121 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
122 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
123 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
124 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
125 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
126 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
127 FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL, FAIL,
Jack Jansen72781191995-08-07 14:34:15 +0000128};
129
Serhiy Storchaka2d06e842015-12-25 19:53:18 +0200130static const unsigned char table_b2a_hqx[] =
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000131"!\"#$%&'()*+,-012345689@ABCDEFGHIJKLMNPQRSTUVXYZ[`abcdefhijklmpqr";
Jack Jansen72781191995-08-07 14:34:15 +0000132
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500133static const unsigned char table_a2b_base64[] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000134 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
135 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
136 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,62, -1,-1,-1,63,
137 52,53,54,55, 56,57,58,59, 60,61,-1,-1, -1, 0,-1,-1, /* Note PAD->0 */
138 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10, 11,12,13,14,
139 15,16,17,18, 19,20,21,22, 23,24,25,-1, -1,-1,-1,-1,
140 -1,26,27,28, 29,30,31,32, 33,34,35,36, 37,38,39,40,
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500141 41,42,43,44, 45,46,47,48, 49,50,51,-1, -1,-1,-1,-1,
142
143 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
144 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
145 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
146 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
147 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
148 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
149 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
150 -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1, -1,-1,-1,-1,
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000151};
152
153#define BASE64_PAD '='
Guido van Rossum355bc0c2001-10-30 03:00:52 +0000154
155/* Max binary chunk size; limited only by available memory */
Guido van Rossum0e225aa2007-05-22 20:24:57 +0000156#define BASE64_MAXBIN ((PY_SSIZE_T_MAX - 3) / 2)
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000157
Serhiy Storchaka2d06e842015-12-25 19:53:18 +0200158static const unsigned char table_b2a_base64[] =
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000159"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000160
161
162
Serhiy Storchaka2d06e842015-12-25 19:53:18 +0200163static const unsigned short crctab_hqx[256] = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000164 0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
165 0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
166 0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
167 0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
168 0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
169 0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
170 0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
171 0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
172 0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
173 0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
174 0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
175 0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
176 0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
177 0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
178 0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
179 0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
180 0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
181 0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
182 0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
183 0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
184 0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
185 0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
186 0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
187 0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
188 0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
189 0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
190 0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
191 0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
192 0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
193 0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
194 0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
195 0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0,
Jack Jansen72781191995-08-07 14:34:15 +0000196};
197
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200198/*[clinic input]
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200199module binascii
200[clinic start generated code]*/
Serhiy Storchaka1009bf12015-04-03 23:53:51 +0300201/*[clinic end generated code: output=da39a3ee5e6b4b0d input=de89fb46bcaf3fec]*/
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200202
203/*[python input]
204
205class ascii_buffer_converter(CConverter):
206 type = 'Py_buffer'
207 converter = 'ascii_buffer_converter'
208 impl_by_reference = True
Benjamin Petersonb62deac2014-01-26 10:41:58 -0500209 c_default = "{NULL, NULL}"
210
211 def cleanup(self):
212 name = self.name
213 return "".join(["if (", name, ".obj)\n PyBuffer_Release(&", name, ");\n"])
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200214
215[python start generated code]*/
Larry Hastings581ee362014-01-28 05:00:08 -0800216/*[python end generated code: output=da39a3ee5e6b4b0d input=3eb7b63610da92cd]*/
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200217
Antoine Pitrou08316762011-12-20 13:58:41 +0100218static int
219ascii_buffer_converter(PyObject *arg, Py_buffer *buf)
220{
221 if (arg == NULL) {
222 PyBuffer_Release(buf);
223 return 1;
224 }
225 if (PyUnicode_Check(arg)) {
226 if (PyUnicode_READY(arg) < 0)
227 return 0;
228 if (!PyUnicode_IS_ASCII(arg)) {
229 PyErr_SetString(PyExc_ValueError,
230 "string argument should contain only ASCII characters");
231 return 0;
232 }
233 assert(PyUnicode_KIND(arg) == PyUnicode_1BYTE_KIND);
234 buf->buf = (void *) PyUnicode_1BYTE_DATA(arg);
235 buf->len = PyUnicode_GET_LENGTH(arg);
236 buf->obj = NULL;
237 return 1;
238 }
239 if (PyObject_GetBuffer(arg, buf, PyBUF_SIMPLE) != 0) {
240 PyErr_Format(PyExc_TypeError,
241 "argument should be bytes, buffer or ASCII string, "
Berker Peksag3cd30c22015-02-15 00:31:00 +0200242 "not '%.100s'", Py_TYPE(arg)->tp_name);
Antoine Pitrou08316762011-12-20 13:58:41 +0100243 return 0;
244 }
245 if (!PyBuffer_IsContiguous(buf, 'C')) {
246 PyErr_Format(PyExc_TypeError,
247 "argument should be a contiguous buffer, "
Berker Peksag3cd30c22015-02-15 00:31:00 +0200248 "not '%.100s'", Py_TYPE(arg)->tp_name);
Antoine Pitrou08316762011-12-20 13:58:41 +0100249 PyBuffer_Release(buf);
250 return 0;
251 }
252 return Py_CLEANUP_SUPPORTED;
253}
254
Larry Hastingsf256c222014-01-25 21:30:37 -0800255#include "clinic/binascii.c.h"
Antoine Pitrou08316762011-12-20 13:58:41 +0100256
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200257/*[clinic input]
258binascii.a2b_uu
259
Serhiy Storchaka12785612014-01-25 11:49:49 +0200260 data: ascii_buffer
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200261 /
262
263Decode a line of uuencoded data.
264[clinic start generated code]*/
Jack Jansen72781191995-08-07 14:34:15 +0000265
266static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300267binascii_a2b_uu_impl(PyObject *module, Py_buffer *data)
268/*[clinic end generated code: output=e027f8e0b0598742 input=7cafeaf73df63d1c]*/
Jack Jansen72781191995-08-07 14:34:15 +0000269{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200270 const unsigned char *ascii_data;
271 unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000272 int leftbits = 0;
273 unsigned char this_ch;
274 unsigned int leftchar = 0;
275 PyObject *rv;
276 Py_ssize_t ascii_len, bin_len;
Marcel Plch33e71e02019-05-22 13:51:26 +0200277 binascii_state *state;
Tim Peters934c1a12002-07-02 22:24:50 +0000278
Serhiy Storchaka12785612014-01-25 11:49:49 +0200279 ascii_data = data->buf;
280 ascii_len = data->len;
Jack Jansen72781191995-08-07 14:34:15 +0000281
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000282 assert(ascii_len >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000283
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000284 /* First byte: binary data length (in bytes) */
285 bin_len = (*ascii_data++ - ' ') & 077;
286 ascii_len--;
Jack Jansen72781191995-08-07 14:34:15 +0000287
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000288 /* Allocate the buffer */
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200289 if ( (rv=PyBytes_FromStringAndSize(NULL, bin_len)) == NULL )
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000290 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000291 bin_data = (unsigned char *)PyBytes_AS_STRING(rv);
Tim Peters934c1a12002-07-02 22:24:50 +0000292
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000293 for( ; bin_len > 0 ; ascii_len--, ascii_data++ ) {
294 /* XXX is it really best to add NULs if there's no more data */
295 this_ch = (ascii_len > 0) ? *ascii_data : 0;
296 if ( this_ch == '\n' || this_ch == '\r' || ascii_len <= 0) {
297 /*
298 ** Whitespace. Assume some spaces got eaten at
299 ** end-of-line. (We check this later)
300 */
301 this_ch = 0;
302 } else {
303 /* Check the character for legality
304 ** The 64 in stead of the expected 63 is because
305 ** there are a few uuencodes out there that use
306 ** '`' as zero instead of space.
307 */
308 if ( this_ch < ' ' || this_ch > (' ' + 64)) {
Marcel Plch33e71e02019-05-22 13:51:26 +0200309 state = PyModule_GetState(module);
310 if (state == NULL) {
311 return NULL;
312 }
313 PyErr_SetString(state->Error, "Illegal char");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000314 Py_DECREF(rv);
315 return NULL;
316 }
317 this_ch = (this_ch - ' ') & 077;
318 }
319 /*
320 ** Shift it in on the low end, and see if there's
321 ** a byte ready for output.
322 */
323 leftchar = (leftchar << 6) | (this_ch);
324 leftbits += 6;
325 if ( leftbits >= 8 ) {
326 leftbits -= 8;
327 *bin_data++ = (leftchar >> leftbits) & 0xff;
328 leftchar &= ((1 << leftbits) - 1);
329 bin_len--;
330 }
331 }
332 /*
333 ** Finally, check that if there's anything left on the line
334 ** that it's whitespace only.
335 */
336 while( ascii_len-- > 0 ) {
337 this_ch = *ascii_data++;
338 /* Extra '`' may be written as padding in some cases */
339 if ( this_ch != ' ' && this_ch != ' '+64 &&
340 this_ch != '\n' && this_ch != '\r' ) {
Marcel Plch33e71e02019-05-22 13:51:26 +0200341 state = PyModule_GetState(module);
342 if (state == NULL) {
343 return NULL;
344 }
345 PyErr_SetString(state->Error, "Trailing garbage");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000346 Py_DECREF(rv);
347 return NULL;
348 }
349 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000350 return rv;
Jack Jansen72781191995-08-07 14:34:15 +0000351}
352
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200353/*[clinic input]
354binascii.b2a_uu
355
356 data: Py_buffer
357 /
Xiang Zhang13f1f422017-05-03 11:16:21 +0800358 *
359 backtick: bool(accept={int}) = False
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200360
361Uuencode line of data.
362[clinic start generated code]*/
Tim Peters934c1a12002-07-02 22:24:50 +0000363
Jack Jansen72781191995-08-07 14:34:15 +0000364static PyObject *
Xiang Zhang13f1f422017-05-03 11:16:21 +0800365binascii_b2a_uu_impl(PyObject *module, Py_buffer *data, int backtick)
366/*[clinic end generated code: output=b1b99de62d9bbeb8 input=b26bc8d32b6ed2f6]*/
Jack Jansen72781191995-08-07 14:34:15 +0000367{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200368 unsigned char *ascii_data;
369 const unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000370 int leftbits = 0;
371 unsigned char this_ch;
372 unsigned int leftchar = 0;
Marcel Plch33e71e02019-05-22 13:51:26 +0200373 binascii_state *state;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200374 Py_ssize_t bin_len, out_len;
375 _PyBytesWriter writer;
Tim Peters934c1a12002-07-02 22:24:50 +0000376
Victor Stinnereaaaf132015-10-13 10:51:47 +0200377 _PyBytesWriter_Init(&writer);
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200378 bin_data = data->buf;
379 bin_len = data->len;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000380 if ( bin_len > 45 ) {
381 /* The 45 is a limit that appears in all uuencode's */
Marcel Plch33e71e02019-05-22 13:51:26 +0200382 state = PyModule_GetState(module);
383 if (state == NULL) {
384 return NULL;
385 }
386 PyErr_SetString(state->Error, "At most 45 bytes at once");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000387 return NULL;
388 }
Jack Jansen72781191995-08-07 14:34:15 +0000389
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000390 /* We're lazy and allocate to much (fixed up later) */
Victor Stinnereaaaf132015-10-13 10:51:47 +0200391 out_len = 2 + (bin_len + 2) / 3 * 4;
392 ascii_data = _PyBytesWriter_Alloc(&writer, out_len);
393 if (ascii_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000394 return NULL;
Jack Jansen72781191995-08-07 14:34:15 +0000395
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000396 /* Store the length */
Xiang Zhang13f1f422017-05-03 11:16:21 +0800397 if (backtick && !bin_len)
398 *ascii_data++ = '`';
399 else
Segev Finer679b5662017-07-27 01:17:57 +0300400 *ascii_data++ = ' ' + (unsigned char)bin_len;
Tim Peters934c1a12002-07-02 22:24:50 +0000401
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000402 for( ; bin_len > 0 || leftbits != 0 ; bin_len--, bin_data++ ) {
403 /* Shift the data (or padding) into our buffer */
404 if ( bin_len > 0 ) /* Data */
405 leftchar = (leftchar << 8) | *bin_data;
406 else /* Padding */
407 leftchar <<= 8;
408 leftbits += 8;
Jack Jansen72781191995-08-07 14:34:15 +0000409
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000410 /* See if there are 6-bit groups ready */
411 while ( leftbits >= 6 ) {
412 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
413 leftbits -= 6;
Xiang Zhang13f1f422017-05-03 11:16:21 +0800414 if (backtick && !this_ch)
415 *ascii_data++ = '`';
416 else
417 *ascii_data++ = this_ch + ' ';
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000418 }
419 }
420 *ascii_data++ = '\n'; /* Append a courtesy newline */
Tim Peters934c1a12002-07-02 22:24:50 +0000421
Victor Stinnereaaaf132015-10-13 10:51:47 +0200422 return _PyBytesWriter_Finish(&writer, ascii_data);
Jack Jansen72781191995-08-07 14:34:15 +0000423}
424
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200425/*[clinic input]
426binascii.a2b_base64
427
Serhiy Storchaka12785612014-01-25 11:49:49 +0200428 data: ascii_buffer
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200429 /
430
431Decode a line of base64 data.
432[clinic start generated code]*/
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000433
434static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300435binascii_a2b_base64_impl(PyObject *module, Py_buffer *data)
436/*[clinic end generated code: output=0628223f19fd3f9b input=5872acf6e1cac243]*/
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000437{
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500438 assert(data->len >= 0);
Tim Peters934c1a12002-07-02 22:24:50 +0000439
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500440 const unsigned char *ascii_data = data->buf;
441 size_t ascii_len = data->len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200442
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000443 /* Allocate the buffer */
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500444 Py_ssize_t bin_len = ((ascii_len+3)/4)*3; /* Upper bound, corrected later */
445 _PyBytesWriter writer;
446 _PyBytesWriter_Init(&writer);
447 unsigned char *bin_data = _PyBytesWriter_Alloc(&writer, bin_len);
Victor Stinnereaaaf132015-10-13 10:51:47 +0200448 if (bin_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000449 return NULL;
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500450 unsigned char *bin_data_start = bin_data;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000451
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500452 int quad_pos = 0;
453 unsigned char leftchar = 0;
454 int pads = 0;
455 for (size_t i = 0; i < ascii_len; i++) {
456 unsigned char this_ch = ascii_data[i];
Guido van Rossum2db4f471999-10-19 19:05:14 +0000457
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000458 /* Check for pad sequences and ignore
459 ** the invalid ones.
460 */
461 if (this_ch == BASE64_PAD) {
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500462 if (quad_pos >= 2 && quad_pos + ++pads >= 4) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000463 /* A pad sequence means no more input.
464 ** We've already interpreted the data
465 ** from the quad at this point.
466 */
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500467 goto done;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000468 }
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500469 continue;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000470 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000471
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500472 this_ch = table_a2b_base64[this_ch];
473 if (this_ch >= 64) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000474 continue;
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500475 }
476 pads = 0;
Guido van Rossum2db4f471999-10-19 19:05:14 +0000477
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500478 switch (quad_pos) {
479 case 0:
480 quad_pos = 1;
481 leftchar = this_ch;
482 break;
483 case 1:
484 quad_pos = 2;
485 *bin_data++ = (leftchar << 2) | (this_ch >> 4);
486 leftchar = this_ch & 0x0f;
487 break;
488 case 2:
489 quad_pos = 3;
490 *bin_data++ = (leftchar << 4) | (this_ch >> 2);
491 leftchar = this_ch & 0x03;
492 break;
493 case 3:
494 quad_pos = 0;
495 *bin_data++ = (leftchar << 6) | (this_ch);
496 leftchar = 0;
497 break;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000498 }
499 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000500
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500501 if (quad_pos != 0) {
502 binascii_state *state = PyModule_GetState(module);
Marcel Plch33e71e02019-05-22 13:51:26 +0200503 if (state == NULL) {
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500504 /* error already set, from PyModule_GetState */
505 } else if (quad_pos == 1) {
Tal Einat1b85c712018-06-10 10:01:50 +0300506 /*
507 ** There is exactly one extra valid, non-padding, base64 character.
508 ** This is an invalid length, as there is no possible input that
509 ** could encoded into such a base64 string.
510 */
Marcel Plch33e71e02019-05-22 13:51:26 +0200511 PyErr_Format(state->Error,
Tal Einat1fba2ff2018-09-28 08:57:22 +0300512 "Invalid base64-encoded string: "
Serhiy Storchakad53fe5f2019-03-13 22:59:55 +0200513 "number of data characters (%zd) cannot be 1 more "
Tal Einat1fba2ff2018-09-28 08:57:22 +0300514 "than a multiple of 4",
515 (bin_data - bin_data_start) / 3 * 4 + 1);
Tal Einat1b85c712018-06-10 10:01:50 +0300516 } else {
Marcel Plch33e71e02019-05-22 13:51:26 +0200517 PyErr_SetString(state->Error, "Incorrect padding");
Tal Einat1b85c712018-06-10 10:01:50 +0300518 }
Victor Stinnereaaaf132015-10-13 10:51:47 +0200519 _PyBytesWriter_Dealloc(&writer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000520 return NULL;
521 }
Guido van Rossum2db4f471999-10-19 19:05:14 +0000522
Sergey Fedoseev1c5e68e2019-07-14 17:15:32 +0500523done:
Victor Stinnereaaaf132015-10-13 10:51:47 +0200524 return _PyBytesWriter_Finish(&writer, bin_data);
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000525}
526
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200527
528/*[clinic input]
529binascii.b2a_base64
530
531 data: Py_buffer
Xiang Zhang1374dbb2017-05-01 13:12:07 +0800532 /
Victor Stinnere84c9762015-10-11 11:01:02 +0200533 *
Serhiy Storchaka202fda52017-03-12 10:10:47 +0200534 newline: bool(accept={int}) = True
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200535
536Base64-code line of data.
537[clinic start generated code]*/
Tim Peters934c1a12002-07-02 22:24:50 +0000538
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000539static PyObject *
Serhiy Storchaka2954f832016-07-07 18:20:03 +0300540binascii_b2a_base64_impl(PyObject *module, Py_buffer *data, int newline)
Xiang Zhang1374dbb2017-05-01 13:12:07 +0800541/*[clinic end generated code: output=4ad62c8e8485d3b3 input=6083dac5777fa45d]*/
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000542{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200543 unsigned char *ascii_data;
544 const unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000545 int leftbits = 0;
546 unsigned char this_ch;
547 unsigned int leftchar = 0;
Victor Stinnere84c9762015-10-11 11:01:02 +0200548 Py_ssize_t bin_len, out_len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200549 _PyBytesWriter writer;
Marcel Plch33e71e02019-05-22 13:51:26 +0200550 binascii_state *state;
Tim Peters934c1a12002-07-02 22:24:50 +0000551
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200552 bin_data = data->buf;
553 bin_len = data->len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200554 _PyBytesWriter_Init(&writer);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000555
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000556 assert(bin_len >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000557
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000558 if ( bin_len > BASE64_MAXBIN ) {
Marcel Plch33e71e02019-05-22 13:51:26 +0200559 state = PyModule_GetState(module);
560 if (state == NULL) {
561 return NULL;
562 }
563 PyErr_SetString(state->Error, "Too much data for base64 line");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000564 return NULL;
565 }
Tim Peters934c1a12002-07-02 22:24:50 +0000566
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000567 /* We're lazy and allocate too much (fixed up later).
Victor Stinnere84c9762015-10-11 11:01:02 +0200568 "+2" leaves room for up to two pad characters.
569 Note that 'b' gets encoded as 'Yg==\n' (1 in, 5 out). */
570 out_len = bin_len*2 + 2;
571 if (newline)
572 out_len++;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200573 ascii_data = _PyBytesWriter_Alloc(&writer, out_len);
574 if (ascii_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000575 return NULL;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000576
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000577 for( ; bin_len > 0 ; bin_len--, bin_data++ ) {
578 /* Shift the data into our buffer */
579 leftchar = (leftchar << 8) | *bin_data;
580 leftbits += 8;
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000581
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000582 /* See if there are 6-bit groups ready */
583 while ( leftbits >= 6 ) {
584 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
585 leftbits -= 6;
586 *ascii_data++ = table_b2a_base64[this_ch];
587 }
588 }
589 if ( leftbits == 2 ) {
590 *ascii_data++ = table_b2a_base64[(leftchar&3) << 4];
591 *ascii_data++ = BASE64_PAD;
592 *ascii_data++ = BASE64_PAD;
593 } else if ( leftbits == 4 ) {
594 *ascii_data++ = table_b2a_base64[(leftchar&0xf) << 2];
595 *ascii_data++ = BASE64_PAD;
596 }
Victor Stinnere84c9762015-10-11 11:01:02 +0200597 if (newline)
598 *ascii_data++ = '\n'; /* Append a courtesy newline */
Tim Peters934c1a12002-07-02 22:24:50 +0000599
Victor Stinnereaaaf132015-10-13 10:51:47 +0200600 return _PyBytesWriter_Finish(&writer, ascii_data);
Jack Jansen84bbc2e1995-10-04 16:38:44 +0000601}
602
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200603/*[clinic input]
604binascii.a2b_hqx
605
Serhiy Storchaka12785612014-01-25 11:49:49 +0200606 data: ascii_buffer
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200607 /
608
609Decode .hqx coding.
610[clinic start generated code]*/
Jack Jansen72781191995-08-07 14:34:15 +0000611
612static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300613binascii_a2b_hqx_impl(PyObject *module, Py_buffer *data)
614/*[clinic end generated code: output=4d6d8c54d54ea1c1 input=0d914c680e0eed55]*/
Jack Jansen72781191995-08-07 14:34:15 +0000615{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200616 const unsigned char *ascii_data;
617 unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000618 int leftbits = 0;
619 unsigned char this_ch;
620 unsigned int leftchar = 0;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200621 PyObject *res;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000622 Py_ssize_t len;
623 int done = 0;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200624 _PyBytesWriter writer;
Marcel Plch33e71e02019-05-22 13:51:26 +0200625 binascii_state *state;
Tim Peters934c1a12002-07-02 22:24:50 +0000626
Serhiy Storchaka12785612014-01-25 11:49:49 +0200627 ascii_data = data->buf;
628 len = data->len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200629 _PyBytesWriter_Init(&writer);
Jack Jansen72781191995-08-07 14:34:15 +0000630
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000631 assert(len >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000632
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200633 if (len > PY_SSIZE_T_MAX - 2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000634 return PyErr_NoMemory();
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000635
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000636 /* Allocate a string that is too big (fixed later)
637 Add two to the initial length to prevent interning which
638 would preclude subsequent resizing. */
Victor Stinnereaaaf132015-10-13 10:51:47 +0200639 bin_data = _PyBytesWriter_Alloc(&writer, len + 2);
640 if (bin_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000641 return NULL;
Jack Jansen72781191995-08-07 14:34:15 +0000642
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000643 for( ; len > 0 ; len--, ascii_data++ ) {
644 /* Get the byte and look it up */
645 this_ch = table_a2b_hqx[*ascii_data];
646 if ( this_ch == SKIP )
647 continue;
648 if ( this_ch == FAIL ) {
Marcel Plch33e71e02019-05-22 13:51:26 +0200649 state = PyModule_GetState(module);
650 if (state == NULL) {
651 return NULL;
652 }
653 PyErr_SetString(state->Error, "Illegal char");
Victor Stinnereaaaf132015-10-13 10:51:47 +0200654 _PyBytesWriter_Dealloc(&writer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000655 return NULL;
656 }
657 if ( this_ch == DONE ) {
658 /* The terminating colon */
659 done = 1;
660 break;
661 }
Jack Jansen72781191995-08-07 14:34:15 +0000662
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000663 /* Shift it into the buffer and see if any bytes are ready */
664 leftchar = (leftchar << 6) | (this_ch);
665 leftbits += 6;
666 if ( leftbits >= 8 ) {
667 leftbits -= 8;
668 *bin_data++ = (leftchar >> leftbits) & 0xff;
669 leftchar &= ((1 << leftbits) - 1);
670 }
671 }
Tim Peters934c1a12002-07-02 22:24:50 +0000672
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000673 if ( leftbits && !done ) {
Marcel Plch33e71e02019-05-22 13:51:26 +0200674 state = PyModule_GetState(module);
675 if (state == NULL) {
676 return NULL;
677 }
678 PyErr_SetString(state->Incomplete,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000679 "String has incomplete number of bytes");
Victor Stinnereaaaf132015-10-13 10:51:47 +0200680 _PyBytesWriter_Dealloc(&writer);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000681 return NULL;
682 }
Roger E. Masse5f4ce181997-01-16 17:10:22 +0000683
Victor Stinnereaaaf132015-10-13 10:51:47 +0200684 res = _PyBytesWriter_Finish(&writer, bin_data);
685 if (res == NULL)
686 return NULL;
687 return Py_BuildValue("Ni", res, done);
Jack Jansen72781191995-08-07 14:34:15 +0000688}
689
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200690
691/*[clinic input]
692binascii.rlecode_hqx
693
694 data: Py_buffer
695 /
696
697Binhex RLE-code binary data.
698[clinic start generated code]*/
Jack Jansen72781191995-08-07 14:34:15 +0000699
700static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300701binascii_rlecode_hqx_impl(PyObject *module, Py_buffer *data)
702/*[clinic end generated code: output=393d79338f5f5629 input=e1f1712447a82b09]*/
Jack Jansen72781191995-08-07 14:34:15 +0000703{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200704 const unsigned char *in_data;
705 unsigned char *out_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000706 unsigned char ch;
707 Py_ssize_t in, inend, len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200708 _PyBytesWriter writer;
Tim Peters934c1a12002-07-02 22:24:50 +0000709
Victor Stinnereaaaf132015-10-13 10:51:47 +0200710 _PyBytesWriter_Init(&writer);
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200711 in_data = data->buf;
712 len = data->len;
Jack Jansen72781191995-08-07 14:34:15 +0000713
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000714 assert(len >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000715
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200716 if (len > PY_SSIZE_T_MAX / 2 - 2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000717 return PyErr_NoMemory();
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000718
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000719 /* Worst case: output is twice as big as input (fixed later) */
Victor Stinnereaaaf132015-10-13 10:51:47 +0200720 out_data = _PyBytesWriter_Alloc(&writer, len * 2 + 2);
721 if (out_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000722 return NULL;
Tim Peters934c1a12002-07-02 22:24:50 +0000723
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000724 for( in=0; in<len; in++) {
725 ch = in_data[in];
726 if ( ch == RUNCHAR ) {
727 /* RUNCHAR. Escape it. */
728 *out_data++ = RUNCHAR;
729 *out_data++ = 0;
730 } else {
731 /* Check how many following are the same */
732 for(inend=in+1;
733 inend<len && in_data[inend] == ch &&
734 inend < in+255;
735 inend++) ;
736 if ( inend - in > 3 ) {
737 /* More than 3 in a row. Output RLE. */
738 *out_data++ = ch;
739 *out_data++ = RUNCHAR;
Antoine Pitrou40455752010-08-15 18:51:10 +0000740 *out_data++ = (unsigned char) (inend-in);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000741 in = inend-1;
742 } else {
743 /* Less than 3. Output the byte itself */
744 *out_data++ = ch;
745 }
746 }
747 }
Victor Stinnereaaaf132015-10-13 10:51:47 +0200748
749 return _PyBytesWriter_Finish(&writer, out_data);
Jack Jansen72781191995-08-07 14:34:15 +0000750}
751
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200752
753/*[clinic input]
754binascii.b2a_hqx
755
756 data: Py_buffer
757 /
758
759Encode .hqx data.
760[clinic start generated code]*/
Tim Peters934c1a12002-07-02 22:24:50 +0000761
Jack Jansen72781191995-08-07 14:34:15 +0000762static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300763binascii_b2a_hqx_impl(PyObject *module, Py_buffer *data)
764/*[clinic end generated code: output=d0aa5a704bc9f7de input=9596ebe019fe12ba]*/
Jack Jansen72781191995-08-07 14:34:15 +0000765{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200766 unsigned char *ascii_data;
767 const unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000768 int leftbits = 0;
769 unsigned char this_ch;
770 unsigned int leftchar = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000771 Py_ssize_t len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200772 _PyBytesWriter writer;
Tim Peters934c1a12002-07-02 22:24:50 +0000773
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200774 bin_data = data->buf;
775 len = data->len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200776 _PyBytesWriter_Init(&writer);
Jack Jansen72781191995-08-07 14:34:15 +0000777
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000778 assert(len >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000779
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200780 if (len > PY_SSIZE_T_MAX / 2 - 2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000781 return PyErr_NoMemory();
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000782
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000783 /* Allocate a buffer that is at least large enough */
Victor Stinnereaaaf132015-10-13 10:51:47 +0200784 ascii_data = _PyBytesWriter_Alloc(&writer, len * 2 + 2);
785 if (ascii_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000786 return NULL;
Tim Peters934c1a12002-07-02 22:24:50 +0000787
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000788 for( ; len > 0 ; len--, bin_data++ ) {
789 /* Shift into our buffer, and output any 6bits ready */
790 leftchar = (leftchar << 8) | *bin_data;
791 leftbits += 8;
792 while ( leftbits >= 6 ) {
793 this_ch = (leftchar >> (leftbits-6)) & 0x3f;
794 leftbits -= 6;
795 *ascii_data++ = table_b2a_hqx[this_ch];
796 }
797 }
798 /* Output a possible runt byte */
799 if ( leftbits ) {
800 leftchar <<= (6-leftbits);
801 *ascii_data++ = table_b2a_hqx[leftchar & 0x3f];
802 }
Victor Stinnereaaaf132015-10-13 10:51:47 +0200803
804 return _PyBytesWriter_Finish(&writer, ascii_data);
Jack Jansen72781191995-08-07 14:34:15 +0000805}
806
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200807
808/*[clinic input]
809binascii.rledecode_hqx
810
811 data: Py_buffer
812 /
813
814Decode hexbin RLE-coded string.
815[clinic start generated code]*/
Tim Peters934c1a12002-07-02 22:24:50 +0000816
Jack Jansen72781191995-08-07 14:34:15 +0000817static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300818binascii_rledecode_hqx_impl(PyObject *module, Py_buffer *data)
819/*[clinic end generated code: output=9826619565de1c6c input=54cdd49fc014402c]*/
Jack Jansen72781191995-08-07 14:34:15 +0000820{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200821 const unsigned char *in_data;
822 unsigned char *out_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000823 unsigned char in_byte, in_repeat;
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200824 Py_ssize_t in_len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200825 _PyBytesWriter writer;
Jack Jansen72781191995-08-07 14:34:15 +0000826
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200827 in_data = data->buf;
828 in_len = data->len;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200829 _PyBytesWriter_Init(&writer);
Marcel Plch33e71e02019-05-22 13:51:26 +0200830 binascii_state *state;
Jack Jansen72781191995-08-07 14:34:15 +0000831
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000832 assert(in_len >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +0000833
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000834 /* Empty string is a special case */
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200835 if ( in_len == 0 )
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000836 return PyBytes_FromStringAndSize("", 0);
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200837 else if (in_len > PY_SSIZE_T_MAX / 2)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000838 return PyErr_NoMemory();
Jack Jansen72781191995-08-07 14:34:15 +0000839
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000840 /* Allocate a buffer of reasonable size. Resized when needed */
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200841 out_data = _PyBytesWriter_Alloc(&writer, in_len);
Victor Stinnereaaaf132015-10-13 10:51:47 +0200842 if (out_data == NULL)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000843 return NULL;
Victor Stinnereaaaf132015-10-13 10:51:47 +0200844
845 /* Use overallocation */
846 writer.overallocate = 1;
Jack Jansen72781191995-08-07 14:34:15 +0000847
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000848 /*
849 ** We need two macros here to get/put bytes and handle
850 ** end-of-buffer for input and output strings.
851 */
Victor Stinnereaaaf132015-10-13 10:51:47 +0200852#define INBYTE(b) \
853 do { \
854 if ( --in_len < 0 ) { \
Marcel Plch33e71e02019-05-22 13:51:26 +0200855 state = PyModule_GetState(module); \
856 if (state == NULL) { \
857 return NULL; \
858 } \
859 PyErr_SetString(state->Incomplete, ""); \
Victor Stinnereaaaf132015-10-13 10:51:47 +0200860 goto error; \
861 } \
862 b = *in_data++; \
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000863 } while(0)
Tim Peters934c1a12002-07-02 22:24:50 +0000864
Victor Stinnereaaaf132015-10-13 10:51:47 +0200865 /*
866 ** Handle first byte separately (since we have to get angry
867 ** in case of an orphaned RLE code).
868 */
869 INBYTE(in_byte);
Jack Jansen72781191995-08-07 14:34:15 +0000870
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000871 if (in_byte == RUNCHAR) {
872 INBYTE(in_repeat);
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200873 /* only 1 byte will be written, but 2 bytes were preallocated:
Raymond Hettinger15f44ab2016-08-30 10:47:49 -0700874 subtract 1 byte to prevent overallocation */
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200875 writer.min_size--;
876
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000877 if (in_repeat != 0) {
878 /* Note Error, not Incomplete (which is at the end
879 ** of the string only). This is a programmer error.
880 */
Marcel Plch33e71e02019-05-22 13:51:26 +0200881 state = PyModule_GetState(module);
882 if (state == NULL) {
883 return NULL;
884 }
885 PyErr_SetString(state->Error, "Orphaned RLE code at start");
Victor Stinnereaaaf132015-10-13 10:51:47 +0200886 goto error;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000887 }
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200888 *out_data++ = RUNCHAR;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000889 } else {
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200890 *out_data++ = in_byte;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000891 }
Tim Peters934c1a12002-07-02 22:24:50 +0000892
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000893 while( in_len > 0 ) {
894 INBYTE(in_byte);
Jack Jansen72781191995-08-07 14:34:15 +0000895
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000896 if (in_byte == RUNCHAR) {
897 INBYTE(in_repeat);
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200898 /* only 1 byte will be written, but 2 bytes were preallocated:
Raymond Hettinger15f44ab2016-08-30 10:47:49 -0700899 subtract 1 byte to prevent overallocation */
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200900 writer.min_size--;
901
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000902 if ( in_repeat == 0 ) {
903 /* Just an escaped RUNCHAR value */
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200904 *out_data++ = RUNCHAR;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000905 } else {
906 /* Pick up value and output a sequence of it */
907 in_byte = out_data[-1];
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200908
909 /* enlarge the buffer if needed */
910 if (in_repeat > 1) {
911 /* -1 because we already preallocated 1 byte */
912 out_data = _PyBytesWriter_Prepare(&writer, out_data,
913 in_repeat - 1);
914 if (out_data == NULL)
915 goto error;
916 }
917
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000918 while ( --in_repeat > 0 )
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200919 *out_data++ = in_byte;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000920 }
921 } else {
922 /* Normal byte */
Victor Stinnerf9c9a3f2015-10-14 15:20:07 +0200923 *out_data++ = in_byte;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000924 }
925 }
Victor Stinnereaaaf132015-10-13 10:51:47 +0200926 return _PyBytesWriter_Finish(&writer, out_data);
927
928error:
929 _PyBytesWriter_Dealloc(&writer);
930 return NULL;
Jack Jansen72781191995-08-07 14:34:15 +0000931}
932
Jack Jansen72781191995-08-07 14:34:15 +0000933
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200934/*[clinic input]
Serhiy Storchaka2ef7c472015-04-20 09:26:49 +0300935binascii.crc_hqx -> unsigned_int
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200936
937 data: Py_buffer
Serhiy Storchaka2ef7c472015-04-20 09:26:49 +0300938 crc: unsigned_int(bitwise=True)
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200939 /
940
Martin Panter3310e142016-12-24 07:36:44 +0000941Compute CRC-CCITT incrementally.
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200942[clinic start generated code]*/
943
Serhiy Storchaka2ef7c472015-04-20 09:26:49 +0300944static unsigned int
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +0300945binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc)
Martin Panter3310e142016-12-24 07:36:44 +0000946/*[clinic end generated code: output=8ec2a78590d19170 input=f18240ff8c705b79]*/
Jack Jansen72781191995-08-07 14:34:15 +0000947{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +0200948 const unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000949 Py_ssize_t len;
Tim Peters934c1a12002-07-02 22:24:50 +0000950
Serhiy Storchaka2ef7c472015-04-20 09:26:49 +0300951 crc &= 0xffff;
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200952 bin_data = data->buf;
953 len = data->len;
Jack Jansen72781191995-08-07 14:34:15 +0000954
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000955 while(len-- > 0) {
Serhiy Storchaka2ef7c472015-04-20 09:26:49 +0300956 crc = ((crc<<8)&0xff00) ^ crctab_hqx[(crc>>8)^*bin_data++];
Antoine Pitrouf95a1b32010-05-09 15:52:27 +0000957 }
Jack Jansen72781191995-08-07 14:34:15 +0000958
Serhiy Storchaka2ef7c472015-04-20 09:26:49 +0300959 return crc;
Jack Jansen72781191995-08-07 14:34:15 +0000960}
961
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +0200962#ifndef USE_ZLIB_CRC32
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000963/* Crc - 32 BIT ANSI X3.66 CRC checksum files
964 Also known as: ISO 3307
965**********************************************************************|
966* *|
967* Demonstration program to compute the 32-bit CRC used as the frame *|
968* check sequence in ADCCP (ANSI X3.66, also known as FIPS PUB 71 *|
969* and FED-STD-1003, the U.S. versions of CCITT's X.25 link-level *|
970* protocol). The 32-bit FCS was added via the Federal Register, *|
971* 1 June 1982, p.23798. I presume but don't know for certain that *|
972* this polynomial is or will be included in CCITT V.41, which *|
973* defines the 16-bit CRC (often called CRC-CCITT) polynomial. FIPS *|
974* PUB 78 says that the 32-bit FCS reduces otherwise undetected *|
975* errors by a factor of 10^-5 over 16-bit FCS. *|
976* *|
977**********************************************************************|
978
979 Copyright (C) 1986 Gary S. Brown. You may use this program, or
980 code or tables extracted from it, as desired without restriction.
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000981
Tim Peters934c1a12002-07-02 22:24:50 +0000982 First, the polynomial itself and its table of feedback terms. The
983 polynomial is
984 X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0
985 Note that we take it "backwards" and put the highest-order term in
986 the lowest-order bit. The X^32 term is "implied"; the LSB is the
987 X^31 term, etc. The X^0 term (usually shown as "+1") results in
988 the MSB being 1.
Guido van Rossum7d47c9e2000-02-16 21:11:52 +0000989
Tim Peters934c1a12002-07-02 22:24:50 +0000990 Note that the usual hardware shift register implementation, which
991 is what we're using (we're merely optimizing it by doing eight-bit
992 chunks at a time) shifts bits into the lowest-order term. In our
993 implementation, that means shifting towards the right. Why do we
994 do it this way? Because the calculated CRC must be transmitted in
995 order from highest-order term to lowest-order term. UARTs transmit
996 characters in order from LSB to MSB. By storing the CRC this way,
997 we hand it to the UART in the order low-byte to high-byte; the UART
998 sends each low-bit to hight-bit; and the result is transmission bit
999 by bit from highest- to lowest-order term without requiring any bit
1000 shuffling on our part. Reception works similarly.
1001
1002 The feedback terms table consists of 256, 32-bit entries. Notes:
1003
1004 1. The table can be generated at runtime if desired; code to do so
1005 is shown later. It might not be obvious, but the feedback
1006 terms simply represent the results of eight shift/xor opera-
1007 tions for all combinations of data and CRC register values.
1008
1009 2. The CRC accumulation logic is the same for all CRC polynomials,
1010 be they sixteen or thirty-two bits wide. You simply choose the
1011 appropriate table. Alternatively, because the table can be
1012 generated at runtime, you can start by generating the table for
1013 the polynomial in question and use exactly the same "updcrc",
1014 if your application needn't simultaneously handle two CRC
1015 polynomials. (Note, however, that XMODEM is strange.)
1016
1017 3. For 16-bit CRCs, the table entries need be only 16 bits wide;
1018 of course, 32-bit entries work OK if the high 16 bits are zero.
1019
1020 4. The values must be right-shifted by eight bits by the "updcrc"
1021 logic; the shift must be unsigned (bring in zeroes). On some
1022 hardware you could probably optimize the shift in assembler by
1023 using byte-swap instructions.
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001024********************************************************************/
1025
Serhiy Storchaka2d06e842015-12-25 19:53:18 +02001026static const unsigned int crc_32_tab[256] = {
Gregory P. Smith3c0e4d22008-03-25 07:51:12 +000010270x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U,
10280x706af48fU, 0xe963a535U, 0x9e6495a3U, 0x0edb8832U, 0x79dcb8a4U,
10290xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U,
10300x90bf1d91U, 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU,
10310x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U, 0x136c9856U,
10320x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U,
10330xfa0f3d63U, 0x8d080df5U, 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U,
10340xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU,
10350x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U,
10360x45df5c75U, 0xdcd60dcfU, 0xabd13d59U, 0x26d930acU, 0x51de003aU,
10370xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U,
10380xb8bda50fU, 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U,
10390x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU, 0x76dc4190U,
10400x01db7106U, 0x98d220bcU, 0xefd5102aU, 0x71b18589U, 0x06b6b51fU,
10410x9fbfe4a5U, 0xe8b8d433U, 0x7807c9a2U, 0x0f00f934U, 0x9609a88eU,
10420xe10e9818U, 0x7f6a0dbbU, 0x086d3d2dU, 0x91646c97U, 0xe6635c01U,
10430x6b6b51f4U, 0x1c6c6162U, 0x856530d8U, 0xf262004eU, 0x6c0695edU,
10440x1b01a57bU, 0x8208f4c1U, 0xf50fc457U, 0x65b0d9c6U, 0x12b7e950U,
10450x8bbeb8eaU, 0xfcb9887cU, 0x62dd1ddfU, 0x15da2d49U, 0x8cd37cf3U,
10460xfbd44c65U, 0x4db26158U, 0x3ab551ceU, 0xa3bc0074U, 0xd4bb30e2U,
10470x4adfa541U, 0x3dd895d7U, 0xa4d1c46dU, 0xd3d6f4fbU, 0x4369e96aU,
10480x346ed9fcU, 0xad678846U, 0xda60b8d0U, 0x44042d73U, 0x33031de5U,
10490xaa0a4c5fU, 0xdd0d7cc9U, 0x5005713cU, 0x270241aaU, 0xbe0b1010U,
10500xc90c2086U, 0x5768b525U, 0x206f85b3U, 0xb966d409U, 0xce61e49fU,
10510x5edef90eU, 0x29d9c998U, 0xb0d09822U, 0xc7d7a8b4U, 0x59b33d17U,
10520x2eb40d81U, 0xb7bd5c3bU, 0xc0ba6cadU, 0xedb88320U, 0x9abfb3b6U,
10530x03b6e20cU, 0x74b1d29aU, 0xead54739U, 0x9dd277afU, 0x04db2615U,
10540x73dc1683U, 0xe3630b12U, 0x94643b84U, 0x0d6d6a3eU, 0x7a6a5aa8U,
10550xe40ecf0bU, 0x9309ff9dU, 0x0a00ae27U, 0x7d079eb1U, 0xf00f9344U,
10560x8708a3d2U, 0x1e01f268U, 0x6906c2feU, 0xf762575dU, 0x806567cbU,
10570x196c3671U, 0x6e6b06e7U, 0xfed41b76U, 0x89d32be0U, 0x10da7a5aU,
10580x67dd4accU, 0xf9b9df6fU, 0x8ebeeff9U, 0x17b7be43U, 0x60b08ed5U,
10590xd6d6a3e8U, 0xa1d1937eU, 0x38d8c2c4U, 0x4fdff252U, 0xd1bb67f1U,
10600xa6bc5767U, 0x3fb506ddU, 0x48b2364bU, 0xd80d2bdaU, 0xaf0a1b4cU,
10610x36034af6U, 0x41047a60U, 0xdf60efc3U, 0xa867df55U, 0x316e8eefU,
10620x4669be79U, 0xcb61b38cU, 0xbc66831aU, 0x256fd2a0U, 0x5268e236U,
10630xcc0c7795U, 0xbb0b4703U, 0x220216b9U, 0x5505262fU, 0xc5ba3bbeU,
10640xb2bd0b28U, 0x2bb45a92U, 0x5cb36a04U, 0xc2d7ffa7U, 0xb5d0cf31U,
10650x2cd99e8bU, 0x5bdeae1dU, 0x9b64c2b0U, 0xec63f226U, 0x756aa39cU,
10660x026d930aU, 0x9c0906a9U, 0xeb0e363fU, 0x72076785U, 0x05005713U,
10670x95bf4a82U, 0xe2b87a14U, 0x7bb12baeU, 0x0cb61b38U, 0x92d28e9bU,
10680xe5d5be0dU, 0x7cdcefb7U, 0x0bdbdf21U, 0x86d3d2d4U, 0xf1d4e242U,
10690x68ddb3f8U, 0x1fda836eU, 0x81be16cdU, 0xf6b9265bU, 0x6fb077e1U,
10700x18b74777U, 0x88085ae6U, 0xff0f6a70U, 0x66063bcaU, 0x11010b5cU,
10710x8f659effU, 0xf862ae69U, 0x616bffd3U, 0x166ccf45U, 0xa00ae278U,
10720xd70dd2eeU, 0x4e048354U, 0x3903b3c2U, 0xa7672661U, 0xd06016f7U,
10730x4969474dU, 0x3e6e77dbU, 0xaed16a4aU, 0xd9d65adcU, 0x40df0b66U,
10740x37d83bf0U, 0xa9bcae53U, 0xdebb9ec5U, 0x47b2cf7fU, 0x30b5ffe9U,
10750xbdbdf21cU, 0xcabac28aU, 0x53b39330U, 0x24b4a3a6U, 0xbad03605U,
10760xcdd70693U, 0x54de5729U, 0x23d967bfU, 0xb3667a2eU, 0xc4614ab8U,
10770x5d681b02U, 0x2a6f2b94U, 0xb40bbe37U, 0xc30c8ea1U, 0x5a05df1bU,
10780x2d02ef8dU
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001079};
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001080#endif /* USE_ZLIB_CRC32 */
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001081
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001082/*[clinic input]
1083binascii.crc32 -> unsigned_int
1084
1085 data: Py_buffer
1086 crc: unsigned_int(bitwise=True) = 0
1087 /
1088
1089Compute CRC-32 incrementally.
1090[clinic start generated code]*/
1091
1092static unsigned int
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +03001093binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc)
1094/*[clinic end generated code: output=52cf59056a78593b input=bbe340bc99d25aa8]*/
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001095
1096#ifdef USE_ZLIB_CRC32
1097/* This was taken from zlibmodule.c PyZlib_crc32 (but is PY_SSIZE_T_CLEAN) */
1098{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001099 const Byte *buf;
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001100 Py_ssize_t len;
1101 int signed_val;
1102
1103 buf = (Byte*)data->buf;
1104 len = data->len;
1105 signed_val = crc32(crc, buf, len);
1106 return (unsigned int)signed_val & 0xffffffffU;
1107}
1108#else /* USE_ZLIB_CRC32 */
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001109{ /* By Jim Ahlstrom; All rights transferred to CNRI */
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001110 const unsigned char *bin_data;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001111 Py_ssize_t len;
1112 unsigned int result;
Tim Peters934c1a12002-07-02 22:24:50 +00001113
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001114 bin_data = data->buf;
1115 len = data->len;
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001116
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001117 crc = ~ crc;
1118 while (len-- > 0) {
1119 crc = crc_32_tab[(crc ^ *bin_data++) & 0xff] ^ (crc >> 8);
1120 /* Note: (crc >> 8) MUST zero fill on left */
1121 }
Tim Petersa98011c2002-07-02 20:20:08 +00001122
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001123 result = (crc ^ 0xFFFFFFFF);
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001124 return result & 0xffffffff;
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001125}
Christian Heimes1dc54002008-03-24 02:19:29 +00001126#endif /* USE_ZLIB_CRC32 */
Guido van Rossum7d47c9e2000-02-16 21:11:52 +00001127
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001128/*[clinic input]
1129binascii.b2a_hex
1130
1131 data: Py_buffer
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001132 sep: object = NULL
1133 An optional single character or byte to separate hex bytes.
1134 bytes_per_sep: int = 1
1135 How many bytes between separators. Positive values count from the
1136 right, negative values count from the left.
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001137
1138Hexadecimal representation of binary data.
1139
1140The return value is a bytes object. This function is also
1141available as "hexlify()".
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001142
1143Example:
1144>>> binascii.b2a_hex(b'\xb9\x01\xef')
1145b'b901ef'
1146>>> binascii.hexlify(b'\xb9\x01\xef', ':')
1147b'b9:01:ef'
1148>>> binascii.b2a_hex(b'\xb9\x01\xef', b'_', 2)
1149b'b9_01ef'
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001150[clinic start generated code]*/
Barry Warsawe977c212000-08-15 06:07:13 +00001151
1152static PyObject *
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001153binascii_b2a_hex_impl(PyObject *module, Py_buffer *data, PyObject *sep,
1154 int bytes_per_sep)
1155/*[clinic end generated code: output=a26937946a81d2c7 input=ec0ade6ba2e43543]*/
Barry Warsawe977c212000-08-15 06:07:13 +00001156{
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001157 return _Py_strhex_bytes_with_sep((const char *)data->buf, data->len,
1158 sep, bytes_per_sep);
Barry Warsawe977c212000-08-15 06:07:13 +00001159}
1160
Zachary Wareb176d402015-01-20 13:59:46 -06001161/*[clinic input]
1162binascii.hexlify = binascii.b2a_hex
1163
1164Hexadecimal representation of binary data.
1165
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001166The return value is a bytes object. This function is also
1167available as "b2a_hex()".
Zachary Wareb176d402015-01-20 13:59:46 -06001168[clinic start generated code]*/
1169
1170static PyObject *
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001171binascii_hexlify_impl(PyObject *module, Py_buffer *data, PyObject *sep,
1172 int bytes_per_sep)
1173/*[clinic end generated code: output=d12aa1b001b15199 input=bc317bd4e241f76b]*/
Zachary Wareb176d402015-01-20 13:59:46 -06001174{
Gregory P. Smith0c2f9302019-05-29 11:46:58 -07001175 return _Py_strhex_bytes_with_sep((const char *)data->buf, data->len,
1176 sep, bytes_per_sep);
Zachary Wareb176d402015-01-20 13:59:46 -06001177}
Barry Warsawe977c212000-08-15 06:07:13 +00001178
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001179/*[clinic input]
1180binascii.a2b_hex
1181
1182 hexstr: ascii_buffer
1183 /
1184
1185Binary data of hexadecimal representation.
1186
1187hexstr must contain an even number of hex digits (upper or lower case).
1188This function is also available as "unhexlify()".
1189[clinic start generated code]*/
1190
Barry Warsawe977c212000-08-15 06:07:13 +00001191static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +03001192binascii_a2b_hex_impl(PyObject *module, Py_buffer *hexstr)
1193/*[clinic end generated code: output=0cc1a139af0eeecb input=9e1e7f2f94db24fd]*/
Barry Warsawe977c212000-08-15 06:07:13 +00001194{
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001195 const char* argbuf;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001196 Py_ssize_t arglen;
1197 PyObject *retval;
1198 char* retbuf;
1199 Py_ssize_t i, j;
Marcel Plch33e71e02019-05-22 13:51:26 +02001200 binascii_state *state;
Barry Warsawe977c212000-08-15 06:07:13 +00001201
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001202 argbuf = hexstr->buf;
1203 arglen = hexstr->len;
Barry Warsawe977c212000-08-15 06:07:13 +00001204
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001205 assert(arglen >= 0);
Amaury Forgeot d'Arc9c74b142008-06-18 00:47:36 +00001206
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001207 /* XXX What should we do about strings with an odd length? Should
1208 * we add an implicit leading zero, or a trailing zero? For now,
1209 * raise an exception.
1210 */
1211 if (arglen % 2) {
Marcel Plch33e71e02019-05-22 13:51:26 +02001212 state = PyModule_GetState(module);
1213 if (state == NULL) {
1214 return NULL;
1215 }
1216 PyErr_SetString(state->Error, "Odd-length string");
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001217 return NULL;
1218 }
Barry Warsawe977c212000-08-15 06:07:13 +00001219
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001220 retval = PyBytes_FromStringAndSize(NULL, (arglen/2));
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001221 if (!retval)
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001222 return NULL;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001223 retbuf = PyBytes_AS_STRING(retval);
Barry Warsawe977c212000-08-15 06:07:13 +00001224
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001225 for (i=j=0; i < arglen; i += 2) {
Sergey Fedoseev6b5df902018-02-27 01:35:41 +05001226 unsigned int top = _PyLong_DigitValue[Py_CHARMASK(argbuf[i])];
1227 unsigned int bot = _PyLong_DigitValue[Py_CHARMASK(argbuf[i+1])];
1228 if (top >= 16 || bot >= 16) {
Marcel Plch33e71e02019-05-22 13:51:26 +02001229 state = PyModule_GetState(module);
1230 if (state == NULL) {
1231 return NULL;
1232 }
1233 PyErr_SetString(state->Error,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001234 "Non-hexadecimal digit found");
1235 goto finally;
1236 }
1237 retbuf[j++] = (top << 4) + bot;
1238 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001239 return retval;
Barry Warsawe977c212000-08-15 06:07:13 +00001240
1241 finally:
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001242 Py_DECREF(retval);
1243 return NULL;
Barry Warsawe977c212000-08-15 06:07:13 +00001244}
1245
Zachary Wareb176d402015-01-20 13:59:46 -06001246/*[clinic input]
1247binascii.unhexlify = binascii.a2b_hex
1248
1249Binary data of hexadecimal representation.
1250
1251hexstr must contain an even number of hex digits (upper or lower case).
1252[clinic start generated code]*/
1253
1254static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +03001255binascii_unhexlify_impl(PyObject *module, Py_buffer *hexstr)
1256/*[clinic end generated code: output=51a64c06c79629e3 input=dd8c012725f462da]*/
Zachary Wareb176d402015-01-20 13:59:46 -06001257{
1258 return binascii_a2b_hex_impl(module, hexstr);
1259}
1260
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001261#define MAXLINESIZE 76
1262
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001263
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001264/*[clinic input]
1265binascii.a2b_qp
1266
Serhiy Storchaka12785612014-01-25 11:49:49 +02001267 data: ascii_buffer
Serhiy Storchaka202fda52017-03-12 10:10:47 +02001268 header: bool(accept={int}) = False
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001269
1270Decode a string of qp-encoded data.
1271[clinic start generated code]*/
1272
1273static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +03001274binascii_a2b_qp_impl(PyObject *module, Py_buffer *data, int header)
Serhiy Storchaka202fda52017-03-12 10:10:47 +02001275/*[clinic end generated code: output=e99f7846cfb9bc53 input=bf6766fea76cce8f]*/
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001276{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001277 Py_ssize_t in, out;
1278 char ch;
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001279 const unsigned char *ascii_data;
1280 unsigned char *odata;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001281 Py_ssize_t datalen = 0;
1282 PyObject *rv;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001283
Serhiy Storchaka12785612014-01-25 11:49:49 +02001284 ascii_data = data->buf;
1285 datalen = data->len;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001286
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001287 /* We allocate the output same size as input, this is overkill.
1288 * The previous implementation used calloc() so we'll zero out the
1289 * memory here too, since PyMem_Malloc() does not guarantee that.
1290 */
1291 odata = (unsigned char *) PyMem_Malloc(datalen);
1292 if (odata == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001293 PyErr_NoMemory();
1294 return NULL;
1295 }
1296 memset(odata, 0, datalen);
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001297
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001298 in = out = 0;
1299 while (in < datalen) {
Serhiy Storchaka12785612014-01-25 11:49:49 +02001300 if (ascii_data[in] == '=') {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001301 in++;
1302 if (in >= datalen) break;
1303 /* Soft line breaks */
Serhiy Storchaka12785612014-01-25 11:49:49 +02001304 if ((ascii_data[in] == '\n') || (ascii_data[in] == '\r')) {
1305 if (ascii_data[in] != '\n') {
1306 while (in < datalen && ascii_data[in] != '\n') in++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001307 }
1308 if (in < datalen) in++;
1309 }
Serhiy Storchaka12785612014-01-25 11:49:49 +02001310 else if (ascii_data[in] == '=') {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001311 /* broken case from broken python qp */
1312 odata[out++] = '=';
1313 in++;
1314 }
Serhiy Storchakae6265e92016-09-14 16:34:37 +03001315 else if ((in + 1 < datalen) &&
1316 ((ascii_data[in] >= 'A' && ascii_data[in] <= 'F') ||
Serhiy Storchaka12785612014-01-25 11:49:49 +02001317 (ascii_data[in] >= 'a' && ascii_data[in] <= 'f') ||
1318 (ascii_data[in] >= '0' && ascii_data[in] <= '9')) &&
1319 ((ascii_data[in+1] >= 'A' && ascii_data[in+1] <= 'F') ||
1320 (ascii_data[in+1] >= 'a' && ascii_data[in+1] <= 'f') ||
1321 (ascii_data[in+1] >= '0' && ascii_data[in+1] <= '9'))) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001322 /* hexval */
Sergey Fedoseev6b5df902018-02-27 01:35:41 +05001323 ch = _PyLong_DigitValue[ascii_data[in]] << 4;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001324 in++;
Sergey Fedoseev6b5df902018-02-27 01:35:41 +05001325 ch |= _PyLong_DigitValue[ascii_data[in]];
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001326 in++;
1327 odata[out++] = ch;
1328 }
1329 else {
1330 odata[out++] = '=';
1331 }
1332 }
Serhiy Storchaka12785612014-01-25 11:49:49 +02001333 else if (header && ascii_data[in] == '_') {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001334 odata[out++] = ' ';
1335 in++;
1336 }
1337 else {
Serhiy Storchaka12785612014-01-25 11:49:49 +02001338 odata[out] = ascii_data[in];
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001339 in++;
1340 out++;
1341 }
1342 }
1343 if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001344 PyMem_Free(odata);
1345 return NULL;
1346 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001347 PyMem_Free(odata);
1348 return rv;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001349}
1350
Tim Peters934c1a12002-07-02 22:24:50 +00001351static int
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001352to_hex (unsigned char ch, unsigned char *s)
1353{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001354 unsigned int uvalue = ch;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001355
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001356 s[1] = "0123456789ABCDEF"[uvalue % 16];
1357 uvalue = (uvalue / 16);
1358 s[0] = "0123456789ABCDEF"[uvalue % 16];
1359 return 0;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001360}
1361
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001362/* XXX: This is ridiculously complicated to be backward compatible
1363 * (mostly) with the quopri module. It doesn't re-create the quopri
1364 * module bug where text ending in CRLF has the CR encoded */
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001365
1366/*[clinic input]
1367binascii.b2a_qp
1368
1369 data: Py_buffer
Serhiy Storchaka202fda52017-03-12 10:10:47 +02001370 quotetabs: bool(accept={int}) = False
1371 istext: bool(accept={int}) = True
1372 header: bool(accept={int}) = False
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001373
1374Encode a string using quoted-printable encoding.
1375
1376On encoding, when istext is set, newlines are not encoded, and white
1377space at end of lines is. When istext is not set, \r and \n (CR/LF)
1378are both encoded. When quotetabs is set, space and tabs are encoded.
1379[clinic start generated code]*/
1380
1381static PyObject *
Serhiy Storchaka1a2b24f2016-07-07 17:35:15 +03001382binascii_b2a_qp_impl(PyObject *module, Py_buffer *data, int quotetabs,
Larry Hastings89964c42015-04-14 18:07:59 -04001383 int istext, int header)
Serhiy Storchaka202fda52017-03-12 10:10:47 +02001384/*[clinic end generated code: output=e9884472ebb1a94c input=21fb7eea4a184ba6]*/
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001385{
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001386 Py_ssize_t in, out;
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001387 const unsigned char *databuf;
1388 unsigned char *odata;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001389 Py_ssize_t datalen = 0, odatalen = 0;
1390 PyObject *rv;
1391 unsigned int linelen = 0;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001392 unsigned char ch;
1393 int crlf = 0;
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001394 const unsigned char *p;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001395
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001396 databuf = data->buf;
1397 datalen = data->len;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001398
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001399 /* See if this string is using CRLF line ends */
1400 /* XXX: this function has the side effect of converting all of
1401 * the end of lines to be the same depending on this detection
1402 * here */
Serhiy Storchakaef1585e2015-12-25 20:01:53 +02001403 p = (const unsigned char *) memchr(databuf, '\n', datalen);
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001404 if ((p != NULL) && (p > databuf) && (*(p-1) == '\r'))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001405 crlf = 1;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001406
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001407 /* First, scan to see how many characters need to be encoded */
1408 in = 0;
1409 while (in < datalen) {
Benjamin Peterson4f976512016-08-13 18:33:33 -07001410 Py_ssize_t delta = 0;
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001411 if ((databuf[in] > 126) ||
1412 (databuf[in] == '=') ||
1413 (header && databuf[in] == '_') ||
1414 ((databuf[in] == '.') && (linelen == 0) &&
Serhiy Storchakae6265e92016-09-14 16:34:37 +03001415 (in + 1 == datalen || databuf[in+1] == '\n' ||
1416 databuf[in+1] == '\r' || databuf[in+1] == 0)) ||
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001417 (!istext && ((databuf[in] == '\r') || (databuf[in] == '\n'))) ||
1418 ((databuf[in] == '\t' || databuf[in] == ' ') && (in + 1 == datalen)) ||
1419 ((databuf[in] < 33) &&
1420 (databuf[in] != '\r') && (databuf[in] != '\n') &&
1421 (quotetabs || ((databuf[in] != '\t') && (databuf[in] != ' ')))))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001422 {
1423 if ((linelen + 3) >= MAXLINESIZE) {
1424 linelen = 0;
1425 if (crlf)
Benjamin Peterson4f976512016-08-13 18:33:33 -07001426 delta += 3;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001427 else
Benjamin Peterson4f976512016-08-13 18:33:33 -07001428 delta += 2;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001429 }
1430 linelen += 3;
Benjamin Peterson4f976512016-08-13 18:33:33 -07001431 delta += 3;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001432 in++;
1433 }
1434 else {
1435 if (istext &&
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001436 ((databuf[in] == '\n') ||
1437 ((in+1 < datalen) && (databuf[in] == '\r') &&
1438 (databuf[in+1] == '\n'))))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001439 {
1440 linelen = 0;
1441 /* Protect against whitespace on end of line */
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001442 if (in && ((databuf[in-1] == ' ') || (databuf[in-1] == '\t')))
Benjamin Peterson4f976512016-08-13 18:33:33 -07001443 delta += 2;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001444 if (crlf)
Benjamin Peterson4f976512016-08-13 18:33:33 -07001445 delta += 2;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001446 else
Benjamin Peterson4f976512016-08-13 18:33:33 -07001447 delta += 1;
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001448 if (databuf[in] == '\r')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001449 in += 2;
1450 else
1451 in++;
1452 }
1453 else {
1454 if ((in + 1 != datalen) &&
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001455 (databuf[in+1] != '\n') &&
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001456 (linelen + 1) >= MAXLINESIZE) {
1457 linelen = 0;
1458 if (crlf)
Benjamin Peterson4f976512016-08-13 18:33:33 -07001459 delta += 3;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001460 else
Benjamin Peterson4f976512016-08-13 18:33:33 -07001461 delta += 2;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001462 }
1463 linelen++;
Benjamin Peterson4f976512016-08-13 18:33:33 -07001464 delta++;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001465 in++;
1466 }
1467 }
Benjamin Peterson4f976512016-08-13 18:33:33 -07001468 if (PY_SSIZE_T_MAX - delta < odatalen) {
Benjamin Peterson4f976512016-08-13 18:33:33 -07001469 PyErr_NoMemory();
1470 return NULL;
1471 }
1472 odatalen += delta;
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001473 }
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001474
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001475 /* We allocate the output same size as input, this is overkill.
1476 * The previous implementation used calloc() so we'll zero out the
1477 * memory here too, since PyMem_Malloc() does not guarantee that.
1478 */
1479 odata = (unsigned char *) PyMem_Malloc(odatalen);
1480 if (odata == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001481 PyErr_NoMemory();
1482 return NULL;
1483 }
1484 memset(odata, 0, odatalen);
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001485
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001486 in = out = linelen = 0;
1487 while (in < datalen) {
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001488 if ((databuf[in] > 126) ||
1489 (databuf[in] == '=') ||
1490 (header && databuf[in] == '_') ||
1491 ((databuf[in] == '.') && (linelen == 0) &&
Serhiy Storchakae6265e92016-09-14 16:34:37 +03001492 (in + 1 == datalen || databuf[in+1] == '\n' ||
1493 databuf[in+1] == '\r' || databuf[in+1] == 0)) ||
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001494 (!istext && ((databuf[in] == '\r') || (databuf[in] == '\n'))) ||
1495 ((databuf[in] == '\t' || databuf[in] == ' ') && (in + 1 == datalen)) ||
1496 ((databuf[in] < 33) &&
1497 (databuf[in] != '\r') && (databuf[in] != '\n') &&
Serhiy Storchakae6265e92016-09-14 16:34:37 +03001498 (quotetabs || ((databuf[in] != '\t') && (databuf[in] != ' ')))))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001499 {
1500 if ((linelen + 3 )>= MAXLINESIZE) {
1501 odata[out++] = '=';
1502 if (crlf) odata[out++] = '\r';
1503 odata[out++] = '\n';
1504 linelen = 0;
1505 }
1506 odata[out++] = '=';
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001507 to_hex(databuf[in], &odata[out]);
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001508 out += 2;
1509 in++;
1510 linelen += 3;
1511 }
1512 else {
1513 if (istext &&
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001514 ((databuf[in] == '\n') ||
1515 ((in+1 < datalen) && (databuf[in] == '\r') &&
1516 (databuf[in+1] == '\n'))))
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001517 {
1518 linelen = 0;
1519 /* Protect against whitespace on end of line */
1520 if (out && ((odata[out-1] == ' ') || (odata[out-1] == '\t'))) {
1521 ch = odata[out-1];
1522 odata[out-1] = '=';
1523 to_hex(ch, &odata[out]);
1524 out += 2;
1525 }
Tim Peters934c1a12002-07-02 22:24:50 +00001526
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001527 if (crlf) odata[out++] = '\r';
1528 odata[out++] = '\n';
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001529 if (databuf[in] == '\r')
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001530 in += 2;
1531 else
1532 in++;
1533 }
1534 else {
1535 if ((in + 1 != datalen) &&
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001536 (databuf[in+1] != '\n') &&
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001537 (linelen + 1) >= MAXLINESIZE) {
1538 odata[out++] = '=';
1539 if (crlf) odata[out++] = '\r';
1540 odata[out++] = '\n';
1541 linelen = 0;
1542 }
1543 linelen++;
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001544 if (header && databuf[in] == ' ') {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001545 odata[out++] = '_';
1546 in++;
1547 }
1548 else {
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001549 odata[out++] = databuf[in++];
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001550 }
1551 }
1552 }
1553 }
1554 if ((rv = PyBytes_FromStringAndSize((char *)odata, out)) == NULL) {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001555 PyMem_Free(odata);
1556 return NULL;
1557 }
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001558 PyMem_Free(odata);
1559 return rv;
Martin v. Löwis16dc7f42001-09-30 20:32:11 +00001560}
Barry Warsawe977c212000-08-15 06:07:13 +00001561
Jack Jansen72781191995-08-07 14:34:15 +00001562/* List of functions defined in the module */
1563
1564static struct PyMethodDef binascii_module_methods[] = {
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001565 BINASCII_A2B_UU_METHODDEF
1566 BINASCII_B2A_UU_METHODDEF
1567 BINASCII_A2B_BASE64_METHODDEF
1568 BINASCII_B2A_BASE64_METHODDEF
1569 BINASCII_A2B_HQX_METHODDEF
1570 BINASCII_B2A_HQX_METHODDEF
1571 BINASCII_A2B_HEX_METHODDEF
1572 BINASCII_B2A_HEX_METHODDEF
Zachary Wareb176d402015-01-20 13:59:46 -06001573 BINASCII_HEXLIFY_METHODDEF
1574 BINASCII_UNHEXLIFY_METHODDEF
Serhiy Storchaka3ffd9132014-01-25 11:21:23 +02001575 BINASCII_RLECODE_HQX_METHODDEF
1576 BINASCII_RLEDECODE_HQX_METHODDEF
1577 BINASCII_CRC_HQX_METHODDEF
1578 BINASCII_CRC32_METHODDEF
1579 BINASCII_A2B_QP_METHODDEF
1580 BINASCII_B2A_QP_METHODDEF
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001581 {NULL, NULL} /* sentinel */
Jack Jansen72781191995-08-07 14:34:15 +00001582};
1583
1584
Martin v. Löwis1a214512008-06-11 05:26:20 +00001585/* Initialization function for the module (*must* be called PyInit_binascii) */
Martin v. Löwis14f8b4c2002-06-13 20:33:02 +00001586PyDoc_STRVAR(doc_binascii, "Conversion between binary data and ASCII");
Jack Jansen72781191995-08-07 14:34:15 +00001587
Marcel Plch33e71e02019-05-22 13:51:26 +02001588static int
1589binascii_exec(PyObject *m) {
1590 int result;
1591 binascii_state *state = PyModule_GetState(m);
1592 if (state == NULL) {
1593 return -1;
1594 }
1595
1596 state->Error = PyErr_NewException("binascii.Error", PyExc_ValueError, NULL);
1597 if (state->Error == NULL) {
1598 return -1;
1599 }
1600 result = PyModule_AddObject(m, "Error", state->Error);
1601 if (result == -1) {
1602 return -1;
1603 }
1604
1605 state->Incomplete = PyErr_NewException("binascii.Incomplete", NULL, NULL);
1606 if (state->Incomplete == NULL) {
1607 return -1;
1608 }
1609 result = PyModule_AddObject(m, "Incomplete", state->Incomplete);
1610 if (result == -1) {
1611 return -1;
1612 }
1613
1614 return 0;
1615}
1616
1617static PyModuleDef_Slot binascii_slots[] = {
1618 {Py_mod_exec, binascii_exec},
1619 {0, NULL}
1620};
Martin v. Löwis1a214512008-06-11 05:26:20 +00001621
1622static struct PyModuleDef binasciimodule = {
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001623 PyModuleDef_HEAD_INIT,
1624 "binascii",
1625 doc_binascii,
Marcel Plch33e71e02019-05-22 13:51:26 +02001626 sizeof(binascii_state),
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001627 binascii_module_methods,
Marcel Plch33e71e02019-05-22 13:51:26 +02001628 binascii_slots,
Antoine Pitrouf95a1b32010-05-09 15:52:27 +00001629 NULL,
1630 NULL,
1631 NULL
Martin v. Löwis1a214512008-06-11 05:26:20 +00001632};
1633
Mark Hammondfe51c6d2002-08-02 02:27:13 +00001634PyMODINIT_FUNC
Martin v. Löwis1a214512008-06-11 05:26:20 +00001635PyInit_binascii(void)
Jack Jansen72781191995-08-07 14:34:15 +00001636{
Marcel Plch33e71e02019-05-22 13:51:26 +02001637 return PyModuleDef_Init(&binasciimodule);
Jack Jansen72781191995-08-07 14:34:15 +00001638}