2021-10-13 13:22:35 +00:00
|
|
|
/* Format bytes as hexadecimal */
|
2015-04-26 00:41:00 +00:00
|
|
|
|
|
|
|
#include "Python.h"
|
2021-10-13 17:25:53 +00:00
|
|
|
#include "pycore_strhex.h" // _Py_strhex_with_sep()
|
2023-07-04 08:59:09 +00:00
|
|
|
#include "pycore_unicodeobject.h" // _PyUnicode_CheckConsistency()
|
2018-09-12 19:06:42 +00:00
|
|
|
|
2015-04-26 00:41:00 +00:00
|
|
|
static PyObject *_Py_strhex_impl(const char* argbuf, const Py_ssize_t arglen,
|
2022-04-21 20:07:19 +00:00
|
|
|
PyObject* sep, int bytes_per_sep_group,
|
2019-05-29 18:46:58 +00:00
|
|
|
const int return_bytes)
|
2015-04-26 00:41:00 +00:00
|
|
|
{
|
2020-04-15 12:05:24 +00:00
|
|
|
assert(arglen >= 0);
|
2019-05-29 18:46:58 +00:00
|
|
|
|
2020-04-15 12:05:24 +00:00
|
|
|
Py_UCS1 sep_char = 0;
|
2019-05-29 18:46:58 +00:00
|
|
|
if (sep) {
|
2019-06-01 20:02:08 +00:00
|
|
|
Py_ssize_t seplen = PyObject_Length((PyObject*)sep);
|
2019-05-29 18:46:58 +00:00
|
|
|
if (seplen < 0) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (seplen != 1) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "sep must be length 1.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (PyUnicode_Check(sep)) {
|
|
|
|
if (PyUnicode_KIND(sep) != PyUnicode_1BYTE_KIND) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "sep must be ASCII.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
sep_char = PyUnicode_READ_CHAR(sep, 0);
|
2020-04-15 12:05:24 +00:00
|
|
|
}
|
|
|
|
else if (PyBytes_Check(sep)) {
|
2019-05-29 18:46:58 +00:00
|
|
|
sep_char = PyBytes_AS_STRING(sep)[0];
|
2020-04-15 12:05:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2019-05-29 18:46:58 +00:00
|
|
|
PyErr_SetString(PyExc_TypeError, "sep must be str or bytes.");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
if (sep_char > 127 && !return_bytes) {
|
|
|
|
PyErr_SetString(PyExc_ValueError, "sep must be ASCII.");
|
|
|
|
return NULL;
|
|
|
|
}
|
2020-04-15 12:05:24 +00:00
|
|
|
}
|
|
|
|
else {
|
2019-05-29 18:46:58 +00:00
|
|
|
bytes_per_sep_group = 0;
|
|
|
|
}
|
2015-04-26 00:41:00 +00:00
|
|
|
|
2023-09-02 21:15:54 +00:00
|
|
|
unsigned int abs_bytes_per_sep = Py_ABS(bytes_per_sep_group);
|
2020-04-15 12:05:24 +00:00
|
|
|
Py_ssize_t resultlen = 0;
|
2019-05-29 18:46:58 +00:00
|
|
|
if (bytes_per_sep_group && arglen > 0) {
|
|
|
|
/* How many sep characters we'll be inserting. */
|
|
|
|
resultlen = (arglen - 1) / abs_bytes_per_sep;
|
|
|
|
}
|
|
|
|
/* Bounds checking for our Py_ssize_t indices. */
|
|
|
|
if (arglen >= PY_SSIZE_T_MAX / 2 - resultlen) {
|
2015-04-26 00:41:00 +00:00
|
|
|
return PyErr_NoMemory();
|
2019-05-29 18:46:58 +00:00
|
|
|
}
|
|
|
|
resultlen += arglen * 2;
|
|
|
|
|
2019-08-27 16:55:13 +00:00
|
|
|
if ((size_t)abs_bytes_per_sep >= (size_t)arglen) {
|
2019-05-29 18:46:58 +00:00
|
|
|
bytes_per_sep_group = 0;
|
|
|
|
abs_bytes_per_sep = 0;
|
|
|
|
}
|
2015-04-26 00:41:00 +00:00
|
|
|
|
2020-04-15 12:05:24 +00:00
|
|
|
PyObject *retval;
|
|
|
|
Py_UCS1 *retbuf;
|
2015-04-26 00:41:00 +00:00
|
|
|
if (return_bytes) {
|
|
|
|
/* If _PyBytes_FromSize() were public we could avoid malloc+copy. */
|
2020-04-15 12:05:24 +00:00
|
|
|
retval = PyBytes_FromStringAndSize(NULL, resultlen);
|
|
|
|
if (!retval) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
retbuf = (Py_UCS1 *)PyBytes_AS_STRING(retval);
|
|
|
|
}
|
|
|
|
else {
|
2019-05-29 18:46:58 +00:00
|
|
|
retval = PyUnicode_New(resultlen, 127);
|
2020-04-15 12:05:24 +00:00
|
|
|
if (!retval) {
|
2017-11-28 15:56:10 +00:00
|
|
|
return NULL;
|
2020-04-15 12:05:24 +00:00
|
|
|
}
|
2017-11-28 15:56:10 +00:00
|
|
|
retbuf = PyUnicode_1BYTE_DATA(retval);
|
2015-04-26 00:41:00 +00:00
|
|
|
}
|
|
|
|
|
2019-05-29 18:46:58 +00:00
|
|
|
/* Hexlify */
|
2020-04-15 12:05:24 +00:00
|
|
|
Py_ssize_t i, j;
|
2020-04-21 00:17:52 +00:00
|
|
|
unsigned char c;
|
|
|
|
|
|
|
|
if (bytes_per_sep_group == 0) {
|
|
|
|
for (i = j = 0; i < arglen; ++i) {
|
|
|
|
assert((j + 1) < resultlen);
|
|
|
|
c = argbuf[i];
|
|
|
|
retbuf[j++] = Py_hexdigits[c >> 4];
|
|
|
|
retbuf[j++] = Py_hexdigits[c & 0x0f];
|
|
|
|
}
|
|
|
|
assert(j == resultlen);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* The number of complete chunk+sep periods */
|
|
|
|
Py_ssize_t chunks = (arglen - 1) / abs_bytes_per_sep;
|
|
|
|
Py_ssize_t chunk;
|
|
|
|
unsigned int k;
|
|
|
|
|
|
|
|
if (bytes_per_sep_group < 0) {
|
|
|
|
i = j = 0;
|
|
|
|
for (chunk = 0; chunk < chunks; chunk++) {
|
|
|
|
for (k = 0; k < abs_bytes_per_sep; k++) {
|
|
|
|
c = argbuf[i++];
|
|
|
|
retbuf[j++] = Py_hexdigits[c >> 4];
|
|
|
|
retbuf[j++] = Py_hexdigits[c & 0x0f];
|
|
|
|
}
|
2019-05-29 18:46:58 +00:00
|
|
|
retbuf[j++] = sep_char;
|
|
|
|
}
|
2020-04-21 00:17:52 +00:00
|
|
|
while (i < arglen) {
|
|
|
|
c = argbuf[i++];
|
|
|
|
retbuf[j++] = Py_hexdigits[c >> 4];
|
|
|
|
retbuf[j++] = Py_hexdigits[c & 0x0f];
|
|
|
|
}
|
|
|
|
assert(j == resultlen);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
i = arglen - 1;
|
|
|
|
j = resultlen - 1;
|
|
|
|
for (chunk = 0; chunk < chunks; chunk++) {
|
|
|
|
for (k = 0; k < abs_bytes_per_sep; k++) {
|
|
|
|
c = argbuf[i--];
|
|
|
|
retbuf[j--] = Py_hexdigits[c & 0x0f];
|
|
|
|
retbuf[j--] = Py_hexdigits[c >> 4];
|
|
|
|
}
|
|
|
|
retbuf[j--] = sep_char;
|
|
|
|
}
|
|
|
|
while (i >= 0) {
|
|
|
|
c = argbuf[i--];
|
|
|
|
retbuf[j--] = Py_hexdigits[c & 0x0f];
|
|
|
|
retbuf[j--] = Py_hexdigits[c >> 4];
|
|
|
|
}
|
|
|
|
assert(j == -1);
|
2019-05-29 18:46:58 +00:00
|
|
|
}
|
2015-04-26 00:41:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef Py_DEBUG
|
2020-04-15 12:05:24 +00:00
|
|
|
if (!return_bytes) {
|
2015-04-26 00:41:00 +00:00
|
|
|
assert(_PyUnicode_CheckConsistency(retval, 1));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2018-09-12 19:06:42 +00:00
|
|
|
PyObject * _Py_strhex(const char* argbuf, const Py_ssize_t arglen)
|
2015-04-26 00:41:00 +00:00
|
|
|
{
|
2019-05-29 18:46:58 +00:00
|
|
|
return _Py_strhex_impl(argbuf, arglen, NULL, 0, 0);
|
2015-04-26 00:41:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Same as above but returns a bytes() instead of str() to avoid the
|
|
|
|
* need to decode the str() when bytes are needed. */
|
2022-04-21 20:07:19 +00:00
|
|
|
PyObject* _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen)
|
2015-04-26 00:41:00 +00:00
|
|
|
{
|
2019-05-29 18:46:58 +00:00
|
|
|
return _Py_strhex_impl(argbuf, arglen, NULL, 0, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* These variants include support for a separator between every N bytes: */
|
|
|
|
|
2022-04-21 20:07:19 +00:00
|
|
|
PyObject* _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen,
|
|
|
|
PyObject* sep, const int bytes_per_group)
|
2019-05-29 18:46:58 +00:00
|
|
|
{
|
|
|
|
return _Py_strhex_impl(argbuf, arglen, sep, bytes_per_group, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Same as above but returns a bytes() instead of str() to avoid the
|
|
|
|
* need to decode the str() when bytes are needed. */
|
2022-04-21 20:07:19 +00:00
|
|
|
PyObject* _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t arglen,
|
|
|
|
PyObject* sep, const int bytes_per_group)
|
2019-05-29 18:46:58 +00:00
|
|
|
{
|
|
|
|
return _Py_strhex_impl(argbuf, arglen, sep, bytes_per_group, 1);
|
2015-04-26 00:41:00 +00:00
|
|
|
}
|